Hey cool. >> Hey what's going on man?
>> So I found this stack overflow post, that says if I change the syntax of my
for loop, and use a pre-increment over post-incrementor,
I'll get like a hundred x performance on my for loops.
Pretty awesome yeah?
>> Mm, that's not a thing, Chris.
What do you mean?
That seems really useful all I need to do is plus plus i versus i plus plus,
I mean, then I get a boost for every loop I write.
>> Chris you should probably stop now, I mean we are recording, it's,
it's not a thing.
>> Jeez. That's kind of harsh if you know better,
why don't you show me then?
>> Let me check this out.
Okay, so here's the deal, you need to remember that Java running on Android
is effectively executing in a virtual machine environment,
which means there's lots and lots of layers of complexity going on here,
from the precompiler to the compiler to the optimizer to the code itself,
actually running on the device.
What you're identifying here is something that we call
compute performance.
>> So, like, the performance of my computer?
>> No, more like how the algorithms or the computing processes are performing.
Which has everything to do with how the compiler is generating the code and
how the virtual machine itself is actually executing it on the hardware.
See, what this post has identified was a very, very specific instance
where the compiler could make a pre-fetching optimization on gigantic
four loops where a collection class has more than 20,000 elements in it.
Effectively by changing the syntax there for
your incrementer it was able to hint to the compiler that this particular type
of optimization could actually be made.
>> Totally.
You know, I was hoping, I could use it in general, though.
>> Well, see, it's not that easy when you actually want to get
huge wins in computer performance scenarios, it actually means
understanding what each piece of code is actually doing on the hardware.
Which usually means, having to go and
make small little changes throughout your entire code base,
just to get the performance wins that you're actually looking for.
>> Jeez, that sounds like a lot of work, I'm already exhausted.
>> Chris, my friend it's the whole reason I'm bald.
- مرحبًا كولت. - مرحبًا، ما الذي يحدث؟
- وجدت هذا المنشور المكدس، والذي يقول إنني إن غيرت
صيغة الحلقة التكرارية for loop واستخدمت الزيادة القبلية فوق الزيادة البعدية،
فسوف أحصل على مئات من معامل أداء X في حلقات for loop التكرارية.
إنه لشيء رائع بحق، أليس كذلك؟
- هذا ليس أمرًا مهمًا، كريس.
ماذا تعني؟
إنها تبدو مفيدة وكل ما أحتاج لفعله هو بلس بلس آي مقابل آي بلس بلس،
أعني أنني سأحصل على تعزيز لكل حلقة أكتبها.
- كريس! يجب أن تتوقف الآن، أعني أننا نقوم بالتسجيل،
هذا ليس بالأمر المهم.
- يا إلهي! إنه لأمر قاسٍ، إن كنت تعرف طريقة أفضل
لمَ لا تعلمني؟
- تحقق من ذلك.
- حسنًا، إليك الأمر، تحتاج إلى أن تتذكر أن جافا التي تعمل على الأندرويد
تنفذ بشكل فعال في بيئة آلة افتراضية،
وهذا يعني أن هناك العديد والعديد من طبقات التعقيد التي تجري هنا،
بدءًا من قبل المترجم ثم المترجم ثم المحسن ثم الكود نفسه،
وجميعها تعمل على الجهاز بالفعل.
والشيء الذي تقوم بتعريفه هنا هو شيء نطلق عليه اسم
أداء الحوسبة.
- إذن، هل يشبه أداء حاسوبي؟
- لا، يشبه أكثر كيفية أداء الخوارزميات أو عمليات الحوسبة
وهي المسؤولة عن المترجم، وكيفية تكوينه للكود
وكيفية تنفيذ الآلة الافتراضية نفسها له على المكونات المادية للجهاز.
انظر، هذا المنشور حدد مثالًا محددًا جدًا
حيث يقوم المترجم بعمل تحسين الإحضار المسبق
على حلقات for loops هائلة حيث تحتوي المجموعة أكثر من 20 ألف عنصر بداخلها.
وبتغيير الصيغة على نحو فعال للزيادة لديك،
فستكون قادرة على التلميح إلى المترجم بأن هذا النوع الخاص
من التحسين يمكن صنعه بالفعل.
- حسنًا.
أتعرف، كنت آمل استخدامه مع ذلك بشكل عام.
- حسنًا، انظر، ليس من السهل أن تحصل بالفعل
على مكاسب كبيرة في مخططات أداء الحاسوب،
إنها تعني فهم ما يعنيه كل كود وما يقوم به في مكونات الجهاز المادية.
والتي تعني غالبًا،
عمل تغييرات ضئيلة وطفيفة عبر قاعدة الكود الخاص بك بأكملها،
لتحصل فقط على مكاسب الأداء التي ترغب فيها بالفعل.
- يا إلهي! يبدو كأنه كثير من العمل، أنا منهك بالفعل.
- كريس يا صديقي، ألا تعلم أن هذا هو سبب إصابتي بالصلع.
- Hola. - ¿Qué ocurre?
Aquí en "desbordamiento de pila" dice que si cambio la sintaxis
del bucle for y uso un pre-incremento sobre un post-incremento
la velocidad de desempeño es 100 veces mayor en los bucles for.
Fantástico, ¿cierto?
Eso no es importante, Chris.
¿Qué quieres decir?
Parece realmente útil.
Todo lo que tengo que hacer es ++i versus i++
y así tendré un aumento por cada bucle que escriba.
Chris quizás debas detenerte ahora.
Estamos grabando,...
No es importante.
Cielos. Eso fue un poco hostil.
Si tú sabes más,
¿por qué no me muestras?
Déjame ver eso.
Bien. Esto es así.
Debes recordar que Java al funcionar en Android
se ejecutaba eficazmente en un entorno de máquina virtual,
lo que involucraba muchas capas de complejidad:
del precompilador al compilador,
al optimizador y al mismo código
funcionando en el dispositivo.
Lo que identificas aquí es algo que llamamos
desempeño de cómputo.
Entonces... ¿es como el desempeño de mi computadora?
No, es más como se desempeñan los algoritmos
o los procesos de cálculo,
que tiene todo que ver con cómo el compilador genera el código
y cómo la máquina virtual lo ejecuta en el hardware.
Mira, lo que esta publicación identificó
es una instancia muy específica
dónde el compilador podía hacer una optimización prefetching
en cuatro bucles con una clase de colección
de más de 20.000 elementos.
Efectivamente, al cambiar la sintaxis
de tu incrementador, pudo darle un indicio al compilador
de que este tipo particular
de optimización podía realizarse.
Entiendo.
Sabes, esperaba poder usarlo en general.
Bueno, no es tan fácil.
Cuando quieres obtener grandes beneficios
en escenarios de desempeño de prestaciones
eso significa comprender lo que cada parte del código
hace en el hardware.
Eso generalmente implica
tener que hacer pequeños cambios en toda la base de códigos
y así obtener los beneficios de desempeño que buscas.
Cielos. Parece que es mucho trabajo.
Ya estoy exhausto.
Chris, esa es la única razón por la que soy pelado.
Eh, Colt. >> Salut, qu'est-ce qu'il y a ?
>> J'ai ce message sur Stack Overflow, qui dit que si je change la syntaxe de ma
boucle for, avec une pré-incrémentation au lieu d'une post-incrémentation,
genre mes boucles for seront cent fois plus performantes.
Impressionnant, non ?
>> Euh, c'est pas nouveau, Chris.
Comment ça ?
Ça m'a l'air vraiment utile, je n'ai qu'à taper « ++i » au lieu de « i++ ».
et de là, j'obtiens un bonus pour chaque boucle écrite.
>> Chris, tu devrais arrêter, là, on enregistre, t'vois, c'est…
c'est pas intéressant.
>> Pff… C'est un peu rude. Si tu en sais plus,
tu peux m'expliquer ?
>> Regarde-moi ça.
Ah ok. Alors voilà. Tu dois te souvenir que quand JAVA tourne sous Android,
il s'exécute en réalité sur un environnement de machine virtuelle
donc il y a une tonne de couches de complexité qui s'ajoutent ici,
entre pré-compilateur, compilateur, optimisateur, le code lui-même,
qui tournent réellement sur l'appareil.
Ce que tu mentionnes ici est un cas qu'on appelle la
performance de calcul.
>> Euh, genre comme la performance de mon ordinateur ?
>> Non, c'est plus la façon dont les algos et calculs sont gérés.
C'est totalement lié à la façon dont le compilateur génère le code et
comment la machine virtuelle en elle-même tourne sur la machine réelle.
T'vois, ce que l'auteur du message a repéré, c'est un cas très particulier
où le compilateur peut lancer une optimisation de prélecture sur
« d'énormes boucles for dont les classes comportent plus de 20 000 éléments. »
En effet, en changeant la syntaxe ici pour l'incrémenteur
de for, on peut signaler au compilateur que ce type-ci
d'optimisation est faisable, ici.
>> Ah, je vois.
Tu sais, j'espérais pouvoir l'utiliser en général.
>> Ben tu sais, ce n'est pas si simple. Quand on veut réellement
y gagner à mort en matière de performance de calcul, ça implique
en fait de savoir comment s'exécute chaque code vis-à-vis du matériel.
Et ça veut généralement dire y aller à fond
et faire tout un tas de petits changements sur le code de base,
rien que pour en tirer les gains visés en performance.
>> Pfiou, ça m'a l'air d'un sacré travail, je suis déjà crevé.
>> Mon cher Chris, je ne suis pas chauve pour rien.
- Hai, Colt! - Hai, ada apa?
Kulihat artikel stackoverflow menyatakan dengan mengubah sintaksis for loop,
lalu memakai prainkremen, bukan pascainkremen,
aku akan mendapat kinerja ratusan kali lipat untuk for loop milikku.
- Keren, kan? - Itu tidak benar, Chris.
Apa maksudmu?
Sepertinya sangat berguna, aku cuma perlu plus plus i vs i plus plus.
Lalu, aku mendapat peningkatan untuk setiap loop yang kutulis.
Chris, kamu sebaiknya berhenti sekarang, kita sedang rekaman. Itu tidak benar.
Wah, jangan begitu.
Kalau kamu lebih mengerti, coba jelaskan kepadaku.
- Lihat ini. - Baiklah.
Jadi begini, kamu harus ingat bahwa Java yang berjalan di Android
secara efektif dilakukan di lingkungan mesin virtual,
yang artinya ada banyak sekali hal rumit yang terjadi,
dari prakompilator ke kompilator lalu pengoptimasi ke kode itu sendiri,
dan semua dijalankan di perangkat.
Hal yang kamu identifikasi di sini disebut kinerja komputasi.
Jadi, seperti kinerja komputerku?
Bukan, lebih tepatnya bagaimana algoritme atau proses komputasi berlangsung.
Ini mencakup semua cara kompilator menghasilkan kode
dan cara mesin virtual itu sendiri menjalankannya di perangkat keras.
Artikel ini mengidentifikasi contoh yang sangat spesifik,
di mana kompilator dapat membuat pengoptimalan prapengambilan
pada for loop raksasa dengan lebih dari 20.000 elemen di dalam kelas koleksi.
Secara efektif mengganti sintaksis inkrementor yang bisa beri tahu kompilator
bahwa pengoptimalan jenis tertentu ini dapat dilakukan.
Benar sekali. Tadinya aku harap ini bisa diaplikasikan secara umum.
Sebenarnya tidak semudah itu.
Untuk mendapatkan skenario kinerja komputer yang hebat,
kita harus tahu benar apa yang dilakukan setiap kode pada perangkat keras.
Ini biasanya diketahui dengan mencoba
dan membuat perubahan kecil di seluruh pangkalan kode,
sekadar demi mendapatkan kinerja yang diinginkan.
Itu terdengar seperti banyak pekerjaan, aku sudah pusing sebelumnya.
Temanku, Chris, karena itulah aku botak.
やあ >> 調子はどうだい
>> Stack Overflow Post を 見つけたよ
Loop の Syntax を変えて
実装前のものを使ったら 100 倍のパフォーマンスだと
かなりすごくない？
>> うーん そうではないよクリス
どういうこと？
役立つように思えるけど 必要なのは ++ i 対 i ++
全ループが調子良くなるよ
>> ここで止めておいた 方がいい--今録音中だよ
そうじゃなくて
>> えっ それは手厳しいな
じゃあなぜ見せない？
>> ちょっと調べさせて
いいかい--覚えておくんだ Android で作動中の Java は
事実上の機械環境で 効果的に実行している
すなわちここには何重もの 複雑な層があるんた
プリコンパイラから コンパイラや最適化ツール
そしてコード自体へ動く
ここで君が特定するのは いわゆる
PC のパフォーマンス
>> つまり僕の PC の パフォーマンスのことか
>> というよりアルゴリズム または算出プロセスの作動だ
コンパイラのコード育成や
ハードウェアでの実行に 関連する全を含む
つまりこの Post は 非常に限定的なんだ
コレクションクラスの要素を ２万以上持つ巨大な
４ Loop でコンパイラが 先取り最適化を行ったんだ
Incrementer の Syntax を 変えると効果的に
コンパイラに最適化のタイプを
示唆することができた
>> まさしく
でもね--それが使えればと 願っているけど
>> なるほど そんなに簡単じゃない
パフォーマンスシナリオで 大成功を収めたいなら
ハードウェア上で作動中の 全コードを理解すること
要はコードベース全体を通し
少しずつ変化をつけるんだ
君が求めるパフォーマンスの 成功を得るためだけにね
>> それはかなり骨が折れる 仕事の様でもう疲れ果てた
>> クリス だから僕はハゲてるんだよ
어이 콜트 >>안녕 무슨 일이야?
>>Stack Overflow에서 글을 봤는데
for 루프 문법을 바꿔서
post-incrementor 말고 pre-incrementor를 사용하면
내 for 루프 성능이 100배 더 빨라진대
굉장하지 않아?
그런 건 없어 크리스
무슨 말이야?
엄청 유용할 것 같은데?
i++ 대신 ++i 만 하면 매번 루프를 사용하는 곳마다 성능이 향상되는 거야
크리스 이제 그만하는 게 좋을 것 같아 우리 지금 녹화 중이야
그런 건 없어
너무 단호한거 아니야?
네가 그렇게 잘났으면 이거 한번 설명해봐
자 여기 봐봐
아 이게 무슨 얘기인지 알겠다
안드로이드에서의 자바는 가상 머신 환경을 실행하는 거야
즉 여러 개의 복잡한 단계가 존재한다는 뜻이지
전처리 컴파일러, 컴파일러, 최적화기,
그리고 실제 기기에서 돌아가는 코드까지 말이야
이 글에서 얘기하는 건
계산 성능이라고 부르는 거야
그럼 내 컴퓨터 성능 같은 거 말하는 거야?
아니 그렇다기보단 알고리즘과 계산 프로세스들의 성능이야
컴파일러의 코드 생성 성능과
가상 머신이 기기의 하드웨어로 코드를 실행하는 성능 말이지
이 게시글은 아주 구체적인 경우에 대해 얘기하는 건데
컴파일러가 프리패치 최적화를 통해
2만 개 이상의 개체가 있는 집합 클래스에 for 루프를 사용할 때
incrementer의 문법을 바꿔서
컴파일러에게 최적화가 가능하다는 걸
귀띔 해주는 거야
그렇구나
나는 일반적인 상황에도 활용할 수 있었으면 했지
그렇게 간단한 일이 아니야
계산 성능을 크게 향상시키려면
코드 한 줄 한 줄이 하드웨어를 어떻게 제어하는지 이해를 해야 해
성능 향상은 단숨에 이뤄지지 않아
코드 전체를 훑어보며 조금씩 수정해야 해
원하는 성능 목표에 닿을 때까지 말이야
아이고 작업량이 엄청 많겠다 듣기만 해도 피곤해
크리스 이젠 내가 왜 대머리인지 알겠니
Oi, Colt. - Oi tudo bem, cara?
- Encontrei este post sobre stack overflow, se eu mudar a sintaxe de meu
ciclo for, e usar um pré-incremento sobre um pós-incrementador,
eu terei tipo centenas de vezes o desempenho em meus ciclos for.
Muito legal, não?
- Mm, isso não é assim, Chris.
O que você quer dizer?
Isso parece muito útil, tudo que preciso fazer é plus plus i versus i plus plus,
quer dizer, assim eu ganho vantagem em cada ciclo que eu escrevo.
- Chris, você devia parar agora, quer dizer, nós estamos gravando e isso,
não é assim.
- Jesus. Que chato, se você sabe mais,
por que não me mostra, então?
- Me deixa verificar isto.
Ok, aqui está o negócio, você precisa se lembrar que Java rodando em Android
está efetivamente sendo executado em um ambiente de máquina virtual,
o que significa que há muitas e muitas layers de complexidade acontecendo,
desde o pré-compilador ao compilador ao otimizador, ao código em si,
de fato rodando no dispositivo.
O que você está identificando aqui é algo que nós chamamos de
desempenho de computação.
- Então, tipo, o desempenho do meu computador?
- Não, é mais sobre como o algoritmo ou os processos de computação estão rodando.
O que tem tudo que ver com a forma como o compilador está gerando o código e
como a máquina virtual em si está na verdade executando ele no hardware.
Veja, o que este post identificou foi uma situação muito, muito específica
onde o compilador poderia fazer uma otimização de pre-fetching em
ciclos for gigantes, onde uma coleção de class tem mais de 20.000 elementos nela
Efetivamente, mudando a sintaxe aí para
seu incrementador, ele foi capaz de dizer ao compilador que este tipo particular
de otimização poderia, na verdade, ser feito.
- Completamente.
Sabe, mas eu tinha esperança que eu o pudesse usar em geral.
- Bem, sabe, não é assim tão fácil quando você quer ter
grandes ganhos em cenários de desempenho de computação, isso realmente
implica compreender o que cada parte de código está de fato fazendo no hardware.
O que normalmente significa ter de
fazer pequenas alterações por todo seu código base,
apenas para ter os ganhos de desempenho que você está procurando.
- Eita, isso soa como um monte de trabalho, eu já estou exausto.
- Chris, meu amigo, é por isso mesmo que eu estou careca.
- Привет, Коул! - Привет! Как успехи?
Я нашел один пост на сайте Stack Overflow, в котором говорится, что изменив ситаксис
цикла for, а именно поставив преинкремент на место постинкремента,
производительность циклов for увеличится на порядок.
Круто, правда?
Так это не работает, Крис.
Что ты имеешь в виду?
Это же очень полезная штука: нужно просто заменить i++ на ++i,
и тогда все циклы будут выполняться быстрее.
Крис, остановись лучше. Мы же записываем все на камеру.
Так это не работает.
Да что ж такое. Ты очень резко отвечаешь.
Если ты в этом разбираешься, объясни мне.
Вот. Смотри.
Слушай, важно помнить, что Java-код, работающий в Android,
по сути исполняется на виртуальной машине.
Это подразумевает сложную многоуровневую работу:
от предкомпилятора и компилятора до оптимизатора и самого кода,
исполняемого на устройстве.
То, о чем идет речь здесь, мы называем
вычислительной мощностью.
То есть это производительность компьютера?
Нет, это скорость выполнения алгоритмов или вычислений.
Она тесно связано с тем, как компилятор генерирует код
и как виртуальная машина передает его аппаратной части компьютера.
В этом посте была рассмотрена очень специфичная ситуация.
Компилятор может оптимизировать предвыборку кода с огромными циклами for,
когда классы-коллекции содержат более 20 000 элементов.
И поменяв синтаксис в инкременторе,
можно указать компилятору на возможность
вот этой конкретной оптимизации.
Понятно.
А я думал, так можно делать везде.
Это не так-то просто. Когда ты хочешь добиться
серьезного прироста вычислительной мощности,
необходимо понять, какие указания дает «железу» каждый участок кода.
Обычно это означает, что нужно
внести небольшие изменения по всему коду,
чтобы добиться желаемой производительности.
По-моему, это очень много работы. Я уже чувствую себя уставшим.
Крис, дружище, именно поэтому я лысый.
- Hey harika. - Nasıl gidiyor?
Stack overflow'da bir gönderi gördüm, eğer döngü oluşturucumun söz dizimini
değiştirirsem ve sonra arttırmanın üzerine önce arttırma kullanırsam,
döngü oluşturucumun performansı yüz kat artacaktır.
Harika değil mi?
Sanmıyorum, Chris.
Ne demek istiyorsun?
Bu kullanışlı görünüyor, tek yapmam gereken artı artı i karşı, i artı artı,
yani her yazdığım döngü için bir arttırma elde ederim demek istiyorum.
Chris artık bence sus, yani kayıttayız,
bu işe yaramaz.
Bu biraz acımasız oldu, madem daha iyi biliyorsun,
niye bana da göstermiyorsun?
Bir bakayım.
Pekâlâ, Android üzerinde kullanılan Java'nın, sanal makine ortamında
uyguladığını hatırlamalısın, yani ön derleyiciden derleyiciye,
oradan iyileştiriciye, oradan da cihazda yürütülen koda uzanan,
katman katman bir dizi karmaşık sürecin gerçekleştiğini
unutmamalısın.
Burada tanımladığın şey, hesaplama performansı
dediğimiz şey.
Yani benim bilgisayarımın performansı gibi mi?
Hayır, daha çok algoritmaların ya da hesaplama süreçlerinin performansı gibi.
Bu, derleyicinin kodu yaratması ve
sanal makinenin bu kodu donanım üzerinde yürütmesiyle alakalıdır.
Bak, bu gönderinin tanımladığı şey çok ama çok spesifik bir örnek.
Derleme sınıfının 20.000'den fazla ögeye sahip olduğu yerde, derleyici
devasa döngü yaratıcı üzerinde bir ön getirme optimizasyonu yapabilirdi.
Etkin olarak arttırıcının söz dizilimini değiştirerek,
derleyiciye, bu özgün türdeki optimizasyonun
yapılabileceği ipucunu verdi.
Aynen.
Bilirsin, yine de genel anlamda kullanabilmeyi umuyordum.
Pekâlâ, bu o kadar kolay değil. Bilgisayar performans senaryolarında
gerçekten büyük kazanımlar elde etmek isteyince, esas itibariyle bunun anlamı
kodun her bir parçasının donanım üzerinde aslında ne yaptığını anlamak demektir.
Bu, genellikle tüm kodun gözden geçirilerek
küçük değişiklikler yapılması demektir,
istediğin performans kazanımlarını elde etmek için bunu yaparsın.
Bu çok fazla çalışma demek, şimdiden yoruldum.
Chris, dostum, benim kel olmamın tek nedeni bu.
- Này cậu. - Sao cậu?
Tớ thấy bài này trên stackoverflow nói nếu thay đổi cú pháp vòng lặp
rồi sử dụng phép tăng trước thay vì phép tăng sau,
tớ sẽ đạt được hiệu suất gấp 100 lần cho vòng lặp.
Rất tuyệt đúng không?
Không phải vậy đâu, Chris.
Ý cậu là gì?
Cái này có vẻ tiện lợi, tớ chỉ cần ++i với i++,
là có thể tăng hiệu năng mọi vòng lặp tớ viết.
Chris có lẽ cậu đừng nói nữa, ý là chúng ta đang ghi hình,
Không đúng vậy đâu.
Nói gì kỳ vậy, nếu cậu hiểu rõ hơn tớ,
sao không chỉ tớ nhỉ?
Để tớ xem nào.
Được rồi, vấn đề là, cậu cần nhớ Java chạy trên Android
chạy tốt trong môi trường máy ảo,
nghĩa là có rất rất nhiều mảng phức tạp ở đây
mảng tiền dịch, trình dịch bộ tối ưu hóa rồi đến chính bộ mã,
thực tế đều chạy trên thiết bị này.
Những gì cậu thấy ở đây
là hiệu năng điện toán.
Giống hiệu quả máy tính tớ đang sử dụng à?
Không, đó là cách thực thi thuật toán hay các quá trình xử lý của máy tính.
Cái này liên quan với cách thức trình dịch tạo ra bộ mã
và cách máy ảo thực thi bộ mã trên phần cứng.
Thấy không, bài này chẳng qua chỉ ra một trường hợp rất, rất cụ thể
trình dịch có thể tối ưu nạp trước trong bốn vòng lặp khổng lồ,
ở đó một lớp sưu tập có hơn 20.000 yếu tố.
Chỉ cần đổi cú pháp số gia có thể
trỏ gợi ý về trình dịch
mà loại tối ưu này thực thi được.
Hiểu rồi.
Cậu biết đấy, tớ đang hy vọng, dùng cái này trong trường hợp tổng quát
Đâu có dễ mà có được tình huống
đạt hiệu suất điện toán nhân bội, muốn được vậy
phải hiểu chức năng từng đoạn mã trên phần cứng.
Nghĩa là, phải cho nó chạy thử
rồi mới sửa từng chút một toàn bộ cơ sở mã hóa của cậu,
chỉ để đạt hiệu suất nhân bội mong muốn.
Ôi, mới nghe sao thấy nhiều quá, chưa gì tôi đã thấy mệt rồi.
Chris, bạn tôi ơi, chính vì thế mà tôi hói đấy.
很好 >> 怎么样 伙计？
我发现这个堆栈溢出消息， 提示我如果更改 *for* 循环语句，
使用前增量运算符，而不是增量运算符，
*for*循环语句的性能会提高约百倍。
不错吧。
>> 这不是问题 Chris。
你的意思是什么。
这看起来很有用， 我只需要写成++i而不是i++
我的意思是，我编写的所有循环语句 速度都得到提升。
>> Chris 也许你应该停下来。 我是说，我们在录音。
这不是问题。
>> 我的天 这很难做到。 如果你知道得更清楚，
你能向我展示一下吗？
>> 让我来看看。
你应该记得到 在Android上运行的Java代码
是在虚拟机环境中高效率地执行
这意味着 有很多复杂的层
从预编译到编译到代码优化
在设备上运行
在这里，你所看到的
我们称之为计算性能。
>> 与我的计算机性能一样吗？
>> 不一样 这更像是算法和计算过程的性能。
这与编译器生成代码的方式
和虚拟机本身在硬件上运行的方式有很大的关系。
看，这条消息是一个非常具体的例子。
它说，编译器可以对庞大的四个循环进行预取优化。
在这些循环中， 一个集合类内部有20,000多个元素。
通过更改增量运算符语法，
可以提示编译器，
可以进行这种类型的优化。
>> 确实如此。 你要知道，我希望通常情况下可以利用它。
我希望我可以使用它。
>> 你会发现，当你想要大幅， 提升计算性能时，
并不总是很容易做到。
这意味着，你需要理解每段代码是如何在硬件上执行的。
通常情况下，这意味着，
必须对整个代码进行很多的细微修改
才能获得你所期望的性能提升。
>> 我的天，听起来好像有很多事要做。 我已经精疲力尽了。
>> Chris，我的朋友， 正因为如此我已早早谢顶。
嘿 好棒喔. >> 嘿 怎麼啦
>> 我找到了一篇Stack Overflow的文章 它說如果我改變我的迴圈的語法
並用一個前增量代替後增量
我的迴圈的效能可以增強百倍
很棒吧
>> 嗯 克里斯 沒有這麼一回事
什麼意思
這看起來很有效阿 我只要做 + + i 對上 i + +
然後 我寫的每一個迴圈都可以得到提升
>> 阿 克里斯 我覺得你不該再說下去了 我們正在錄影呢 沒有
沒有這麼一回事
>> 哎呀 你講的真不客氣 如果你更了解的話
你怎麼不弄給我看看
>> 讓我看看.
OK 事情是這樣的 你要知道 Java在安卓系統裡
是在一個虛擬的機器環境中高效地運作
也就是說 在這裡有著 一層又一層複雜的事情
從預編譯器到編譯器 到優化器再到
在設備中運作的編碼本身
你在這裡找到的 被我們稱之為
運算效能
>> 所以 類似我的電腦的效能嗎
>> 不是 是更貼近於 演算法或運算過程的執行
這一切都跟編譯器如何製造編碼以及
虛擬機器本身如何在硬體上執行它有關
你看 這篇帖子所指出的是 一個非常非常特定的例子
在這裡 編譯器可以在一個集合類有超過 20,000個元素的巨大的迴圈中
先行預取優化
在你的增量那裡有效的改變語法
它可以暗示編譯器這種優化方式
是可行的
>> 了解了
喔 我本來以為 我能在一般情況下使用它
>> 嗯 這沒這麼簡單 當你想要在電腦效能的情況中取得
巨大的勝利 這也代表著了解
每個編碼在硬體中所扮演的角色
在通常情況下也就是必須
在你的整個編碼庫中逐步的微調
來真正獲得你想要的效能提升
>> 天哪 那聽起來就很多事 光聽都累了
>> 克里斯 我的朋友 這就是為什麼我頭髮都沒了