JIT: esensya, Just-In-Time na kompilasyon at kung paano ito gumagana
JIT (Just-In-Time) — teknolohiya ng dynamic na kompilasyon na nagko-convert ng bytecode o intermediate na representasyon ng programa sa machine instructions nang direkta habang isinasagawa. Sa Android, ang JIT compiler ay unang lumitaw sa bersyon 2.2 Froyo bilang bahagi ng Dalvik virtual machine at pinabilis ang pag-execute ng mga application ng 2–5 beses. Ayon sa datos ng Google, 2024, ang modernong JIT sa ART ay pinagsasama ang interpretasyon sa na-profile na kompilasyon ng mga hot na pamamaraan.
Mga Pangunahing Punto
- JIT — Just-In-Time na kompilasyon: pag-convert ng code sa machine code nang direkta habang tumatakbo ang programa.
- Sa Dalvik, JIT ay nag-compile ng mga hot na pamamaraan matapos lumampas sa threshold ng tawag (~200 beses).
- JIT nagpapababa ng oras ng pag-install at kumukuha ng mas kaunting espasyo kaysa sa buong AOT compilation.
- Pangunahing disbentahe — pagkaantala ng pag-init: unang mga segundo mas mabagal ang takbo ng app.
- Sa modernong ART, JIT ay ginagamit sa hybrid mode na may background na AOT optimization.
Ano ang JIT compilation?
Just-In-Time (JIT) — paraan ng kompilasyon kung saan ang source code o bytecode ay kino-convert sa machine instructions hindi nang maaga (tulad ng sa AOT), kundi sa sandali ng unang tawag ng kaukulang bahagi ng programa. Ang terminong “Just-In-Time” ay nangangahulugang ang kompilasyon ay nagaganap “eksakto sa oras” — direkta bago ang pag-execute.
Ang konsepto ng JIT ay umiral mula pa noong 1960s, ngunit naging malawak ang paggamit nito sa pagdating ng Java Virtual Machine noong 1995. Pinapayagan ng JIT na pagsamahin ang portability ng bytecode (sumulat nang isang beses — patakbuhin kahit saan) na may performance na malapit sa native code. Sa Java HotSpot VM, sinusuri ng JIT compiler ang na-e-execute na code at nagko-compile lamang ng mga pinaka kritikal na bahagi, nakakatipid ng oras at memorya.
Prinsipyo ng paggawa
Ang JIT compiler ay tumatanggap ng bytecode sa input, ini-interpret ito at kahanay na nangongolekta ng mga istatistika. Kapag ang isang bahagi ng code (pamamaraan, loop) ay tinatawag nang sapat na dalas, nagpapasya ang JIT na i-compile ito. Ang naka-compile na machine code ay iniimbak sa cache — sa mga paulit-ulit na tawag ay ginagamit na ang handa nang bersyon. Tinitiyak nito ang pagbilis nang hindi kinakailangang i-compile ang buong programa.
java
// Halimbawa: ang pamamaraan ay magiging hot matapos ang maraming tawag
public class HotMethod {
private int compute(int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += i * i;
}
return sum;
}
}
// Tawag ng 500 beses sa loop — JIT ay mag-compile ng compute
for (int t = 0; t < 500; t++) {
hot.compute(1000);
}JIT sa Android: Dalvik at ART
Sa Android, ang JIT compilation ay dumaan sa tatlong yugto ng ebolusyon. Unang yugto — Dalvik na walang JIT (Android 1.0–2.1): purong interpretasyon ng DEX bytecode. Ikalawang yugto — Dalvik na may JIT (Android 2.2–4.4): paglitaw ng JIT compiler na nagpabilis ng mga application ng 2–5 beses. Ikatlong yugto — ART na may hybrid JIT (Android 7.0+): pagbabalik ng JIT sa bagong kalidad.
Ang JIT sa Dalvik ay ipinatupad bilang isang trace-based compiler. Hindi ito nagsuri ng mga indibidwal na pamamaraan, kundi ng mga kadena ng mga instruction (traces) na madalas na isinasagawa nang sunud-sunod. Pinapayagan nito ang kompilasyon ng buong landas ng pag-execute, kasama ang maraming pamamaraan. Ang ganitong approach ay epektibo para sa mga mobile processor na may maliit na instruction cache, dahil ang naka-compile na trace ay kasya sa L1 cache.
JIT sa modernong ART
Simula sa Android 7.0 Nougat, ang ART ay gumagamit ng method-based JIT — nagko-compile ng mga indibidwal na pamamaraan batay sa mga profile ng pag-execute. Ang JIT na ito ay gumagana nang mas mabilis kaysa Dalvik JIT: tipikal na oras ng kompilasyon ng isang pamamaraan ay 0.5–1 ms kumpara sa 3–5 ms sa Dalvik. Ang naka-compile na code ay iniimbak sa isang hiwalay na lugar ng memorya (JIT code cache), hindi sa heap ng application, na nagbabawas ng fragmentation.
| Parameter | Dalvik JIT | ART JIT |
|---|---|---|
| Uri | Trace-based | Method-based |
| Bilis ng kompilasyon | 3–5 ms/pamamaraan | 0.5–1 ms/pamamaraan |
| Threshold ng kompilasyon | ~200 tawag | Dinamiko |
| Cache ng code | Sa heap ng application | JIT code cache |
| Profilasyon | Panloob | Panlabas na .prof file |
Pagtuklas ng mga hot na pamamaraan at mga threshold ng kompilasyon
Ang sentral na mekanismo ng JIT — pagtuklas ng mga hot na pamamaraan. Bawat tawag sa pamamaraan ay nagpapataas ng panloob na counter. Kapag nalampasan ng counter ang threshold, ang pamamaraan ay minamarkahan bilang “mainit” at ipinadala para sa kompilasyon. Sa Dalvik ang threshold ay mahigpit na itinakda (~200 tawag). Sa ART ang mga counter ay inaayos nang dinamiko depende sa magagamit na mga mapagkukunan ng device.
Ang proseso ng kompilasyon ay may kasamang ilang yugto. Una — pagsusuri ng bytecode: pinag-aaralan ng JIT ang daloy ng instruction at bumubuo ng data-flow graph. Ikalawa — optimisasyon: inlining ng maliliit na pamamaraan, pag-alis ng patay na code, pag-fold ng mga constant. Ikatlo — pagbuo ng code: pag-convert ng na-optimize na graph sa machine instructions para sa partikular na arkitektura ng CPU (ARM, ARM64, x86).
java
// Demonstrasyon ng inlining — JIT ay papalitan ang body ng pamamaraan
public int inlineExample() {
return square(5);
}
private int square(int x) {
return x * x;
} // JIT ay papalitan ang tawag ng return 5 * 5;OSR — On-Stack Replacement
Isang espesyal na teknik ng JIT — On-Stack Replacement (OSR). Kung ang isang pamamaraan ay naglalaman ng mahabang loop na hindi natatapos sa daan-daang iteration, maaaring i-compile ng JIT ang loop “sa himpapawid” at palitan ang na-interpret na bersyon ng naka-compile na bersyon nang direkta habang isinasagawa. Ang OSR ay lalong epektibo para sa mga computational na gawain: rendering, pagproseso ng imahe, cryptography.
JIT vs AOT: paghahambing na pagsusuri
JIT at AOT — dalawang approach sa kompilasyon na may magkasalungat na kompromiso. JIT ay isinasakripisyo ang bilis ng unang pagtakbo para sa pagiging compact ng distribusyon at kakayahang umangkop. AOT ay isinasakripisyo ang oras ng pag-install at espasyo sa disk para sa maximum na performance mula sa unang segundo. Wala sa mga approach ang ganap na mas mahusay — ang pagpili ay depende sa senaryo.
Ang pangunahing bentahe ng JIT ay adaptive optimization. Maaaring gamitin ng JIT ang profile na impormasyon na hindi magagamit ng AOT: eksaktong uri ng mga bagay, aktwal na dalas ng tawag, aktwal na pagsasanga. Pinapayagan nito ang paglalapat ng mga agresibong optimisasyon na imposible sa static na kompilasyon. Halimbawa, maaaring i-virtualize ng JIT ang mga tawag sa pamamaraan (devirtualize), kung sa praktika ay isang uri lamang ng tagatanggap ang lumilitaw.
| Kriterya | JIT | AOT |
|---|---|---|
| Oras ng pag-install | Agad | Depende sa laki |
| Unang pagtakbo | Mas mabagal (pag-init) | Mabilis |
| Espasyo sa disk | Minimal | +15–30% |
| Kakayahang umangkop | Mataas | Mababa |
| Pagkonsumo ng CPU | Mga taluktok sa kompilasyon | Matatag |
Kailan pumili ng JIT
JIT compilation ay mas gusto kapag mahalaga ang bilis ng deployment at pagtitipid ng espasyo sa disk. Sa konteksto ng mobile development, ang JIT ay perpekto para sa mga application na madalas na ina-update (A/B testing, hotfix). Ang JIT ay maginhawa din sa yugto ng pag-develop, kapag ang code ay itinatayong muli ng sampu-sampung beses sa isang araw — bawat segundong natitipid sa kompilasyon ay nagpapabilis ng cycle ng feedback.
Mga kalamangan ng JIT compilation
JIT ay nagbibigay sa mga developer ng isang serye ng mga praktikal na kalamangan. Una — maliit na sukat ng APK. Sa approach ng JIT, sa APK ay naka-pack lamang ang bytecode (DEX), na kumukuha ng 20–30% mas kaunting espasyo kaysa sa naka-compile na native code. Para sa mga user na may limitadong internal memory, ito ay isang makabuluhang bentahe.
Ikalawang bentahe — pag-angkop sa device. Nagko-compile ang JIT ng code na isinasaalang-alang ang aktwal na arkitektura ng CPU, dami ng RAM at kasalukuyang karga. Halimbawa, sa isang device na may 2 GB RAM, maaaring mag-compile ang JIT nang hindi gaanong agresibo upang makatipid ng memorya, at sa isang flagship na may 12 GB — ilapat ang lahat ng posibleng optimisasyon. Ang AOT compilation, sa kabaligtaran, ay nag-aayos ng desisyon sa sandali ng pag-install.
Independensiya sa platform
Bytecode ay nananatiling independiyente sa platform, na nagpapasimple sa pamamahagi ng mga application. Isang APK ang gumagana sa ARM, ARM64 at x86 device, at tinitiyak ng JIT ang pagbuo ng native code para sa bawat arkitektura. Para sa approach ng AOT, kakailanganing isama ang maraming variant ng native code sa APK (pagtaas ng laki), o mag-compile ng hiwalay na bersyon para sa bawat arkitektura.
Mga disbentahe at limitasyon ng JIT
Ang pangunahing disbentahe ng JIT ay pagkaantala ng pag-init (warm-up delay). Nakikita ng user ang mga pagbagal sa mga unang segundo ng application, habang nagko-compile ang JIT ng mga hot na pamamaraan. Sa mga laro, ito ay lumilitaw bilang “pag-utal” (stuttering) sa mga unang level. Sa mga application na may animasyon — panginginig sa mga unang transisyon sa pagitan ng mga screen.
Ikalawang disbentahe ay pagkonsumo ng enerhiya. Ang proseso ng kompilasyon ay intensibong naglo-load ng CPU, na nagpapataas ng pagkonsumo ng enerhiya ng 10–20% sa panahon ng pag-init. Sa mga device na pinapagana ng baterya, ito ay nagpapababa ng oras ng autonomous na trabaho. Lalo na kapansin-pansin sa mga senaryo na may madalas na restart ng mga application (multitasking na may limitadong memorya, kapag ang sistema ay nag-aalis at nagre-reload ng mga proseso).
Fragmentation ng cache
Isa pang problema ay fragmentation ng JIT cache. Ang naka-compile na code ay iniimbak sa isang tuloy-tuloy na lugar ng memorya. Sa pag-load ng mga bagong klase at kompilasyon ng mga karagdagang pamamaraan, ang cache ay nag-fragment, na nagpapataas ng overhead ng pamamahala ng memorya. Sa Dalvik ang problemang ito ay nalutas sa pamamagitan ng pana-panahong paglilinis ng cache; sa ART ang JIT cache ay inilalaan nang hiwalay mula sa heap at gumagamit ng sariling diskarte sa defragmentation.
Hybrid mode: pinakamahusay sa dalawang mundo
Ang modernong approach sa ART — hybrid compilation, na pinagsasama ang mga lakas ng JIT at AOT. Sa pag-install ng application, ang kompilasyon ay hindi ginagawa — tanging pag-verify ng bytecode (verify). Tinitiyak nito ang mabilis na pag-install at minimal na espasyong ginagamit. Ang mga unang pagtakbo ay gumagana sa interpretasyon mode na may JIT compilation ng mga hot na pamamaraan — ang user ay nakakakuha ng katanggap-tanggap na performance nang mahabang paghihintay.
Kahanay, gumagana ang background profiler, nangongolekta ng datos tungkol sa aktwal na paggamit. Pagkatapos ng 2–3 buong pagtakbo ng application, ang profile ay umaabot sa sapat na pagkakumpleto, at inilulunsad ng sistema ang dex2oat para i-compile ang mga hot na pamamaraan sa native code. Ang operasyong ito ay ginagawa sa background kapag ang device ay hindi na-load (nagcha-charge, naka-off ang screen). Pagkatapos ng background AOT, ang application ay nakakakuha ng performance na maihahambing sa buong AOT compilation.
bash
# Sapilitang pagsisimula ng background compilation
adb shell cmd package compile -m speed-profile -f com.example.app
# Pagtingin ng status ng kompilasyon
adb shell cmd package dump-profiles com.example.appMga resulta ng hybrid approach
Ayon sa datos ng Google I/O 2017, ang hybrid compilation ay nagbawas ng oras ng pag-install ng mga application ng 30–50% kumpara sa purong AOT. Ang espasyong ginagamit sa system partition ay nabawasan ng 20–30%. Ang performance pagkatapos ng background compilation ay tumutugma sa antas ng buong AOT. Ang tanging senaryo kung saan ang hybrid ay natalo sa AOT ay ang unang pagtakbo pagkatapos ng pag-install: ang application ay gumagana sa JIT mode at maaaring 10–15% mas mabagal.
Mga Madalas Itanong
Ano ang JIT compilation sa simpleng salita?
JIT — paraan ng pagpapabilis ng programa kung saan ang code ay isinasalin sa machine language hindi nang maaga, kundi nang paunti-unti habang tumatakbo. Ang mga pinakamadalas na bahagi ay ini-compile at ni-cache, ang mga bihirang bahagi ay nananatili sa orihinal na anyo.
Paano naiiba ang JIT sa AOT?
JIT ay nagko-compile ng code habang isinasagawa, na nakakatipid ng espasyo at nagpapabilis ng pag-install. AOT ay nagko-compile ng lahat ng code nang maaga — ang application ay mas mabilis na tumakbo, ngunit nangangailangan ng mas maraming espasyo sa disk at oras para sa pag-install.
Bakit tinanggal ang JIT mula sa Android?
Ang JIT ay hindi tinanggal, ito ay nag-evolve. Sa Android 5.0, ang Dalvik na may JIT ay pinalitan ng ART na may purong AOT. Sa Android 7.0, ang JIT ay bumalik sa ART bilang bahagi ng hybrid system, kung saan ito ay gumagana kasama ng background AOT compilation para sa optimal na performance.
Paano naaapektuhan ng JIT ang pagkonsumo ng enerhiya?
JIT ay nagpapataas ng pagkonsumo ng enerhiya ng 10–20% sa panahon ng pag-init dahil sa load ng CPU. Matapos ang kompilasyon ng mga hot na pamamaraan, ang pagkonsumo ng enerhiya ay bumalik sa normal na antas. Ang hybrid mode ng ART ay nagmi-minimize ng mga taluktok na ito dahil sa background compilation.
Nakikita ba ng user ang pag-init ng JIT?
Oo, sa mga senaryo na may intensibong pagkalkula. Maaaring mapansin ng user ang pagbagal sa mga unang segundo ng application o sa simula ng laro. Sa mga modernong bersyon ng Android (8.0+), ang hybrid mode ay nagmi-minimize ng epektong ito dahil sa na-profile na kompilasyon.
Buod
- JIT (Just-In-Time) — dynamic na kompilasyon na nagko-convert ng bytecode sa machine instructions habang isinasagawa.
- Sa Android, ang JIT ay dumaan sa ebolusyon: trace-based sa Dalvik → buong AOT → hybrid JIT+AOT sa modernong ART.
- Mga hot na pamamaraan ay natutukoy sa pamamagitan ng mga counter ng tawag at ini-compile kapag lumampas sa threshold (~200 tawag).
- Ang OSR (On-Stack Replacement) ay nagpapahintulot sa kompilasyon ng mahabang loop sa himpapawid nang hindi naaabala ang pag-execute.
- Pangunahing kalamangan ng JIT: maliit na sukat ng APK, mabilis na pag-install at pag-angkop sa device.
- Pangunahing disbentahe: pagkaantala ng pag-init, taluktok na pagkonsumo ng enerhiya at fragmentation ng cache.
- Hybrid mode ng ART (Android 7.0+) ay nagbabawas ng oras ng pag-install ng 30–50% habang pinapanatili ang mataas na performance.
Gagawa kami ng mobile application na turnkey
Gumagawa ang IT Sectr ng mga iOS at Android application para sa mga startup at negosyo mula noong 2017. Magpapayo kami sa iyo at magmumungkahi ng pinakamahusay na solusyon.
Basahin din