JIT: esensi, kompilasi Just-In-Time dan cara kerjanya
JIT (Just-In-Time) — teknologi kompilasi dinamis yang mengubah kode byte atau representasi antara program menjadi instruksi mesin secara langsung saat eksekusi. Di Android, kompilator JIT pertama kali muncul di versi 2.2 Froyo dalam mesin virtual Dalvik dan mempercepat eksekusi aplikasi 2–5 kali. Menurut data Google, 2024, JIT modern di ART menggabungkan interpretasi dengan kompilasi terprofil dari metode hot.
Poin Utama
- JIT — kompilasi Just-In-Time: mengubah kode menjadi mesin langsung saat program berjalan.
- Di Dalvik JIT mengkompilasi metode hot setelah melewati ambang panggilan (~200 kali).
- JIT memperpendek waktu instalasi dan memakan lebih sedikit ruang daripada kompilasi AOT penuh.
- Kekurangan utama — penundaan pemanasan: detik-detik pertama aplikasi berjalan lebih lambat.
- Di ART modern JIT digunakan dalam mode hibrida dengan optimasi AOT latar belakang.
Apa itu kompilasi JIT?
Just-In-Time (JIT) — metode kompilasi di mana kode sumber atau kode byte diubah menjadi instruksi mesin tidak sebelumnya (seperti di AOT), tetapi pada saat panggilan pertama bagian program yang bersangkutan. Istilah “Just-In-Time” berarti kompilasi terjadi “tepat pada waktunya” — langsung sebelum eksekusi.
Konsep JIT sudah ada sejak tahun 1960-an, tetapi penyebaran luas terjadi dengan munculnya Java Virtual Machine pada tahun 1995. JIT memungkinkan penggabungan portabilitas kode byte (tulis sekali — jalankan di mana saja) dengan performa mendekati kode asli. Di Java HotSpot VM, kompilator JIT menganalisis kode yang dieksekusi dan hanya mengkompilasi bagian yang paling kritis, menghemat waktu dan memori.
Prinsip kerja
Kompilator JIT menerima kode byte pada input, menginterpretasikannya dan secara paralel mengumpulkan statistik. Ketika suatu bagian kode (metode, loop) dipanggil cukup sering, JIT memutuskan untuk melakukan kompilasi. Kode mesin yang dikompilasi disimpan dalam cache — pada panggilan berulang digunakan versi yang sudah siap. Ini memberikan percepatan tanpa perlu mengkompilasi seluruh program.
java
// Contoh: metode akan menjadi hot setelah panggilan berulang
public class HotMethod {
private int compute(int n) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += i * i;
}
return sum;
}
}
// Panggilan 500 kali dalam loop — JIT akan mengkompilasi compute
for (int t = 0; t < 500; t++) {
hot.compute(1000);
}JIT di Android: Dalvik dan ART
Di Android, kompilasi JIT telah melalui tiga fase evolusi. Fase pertama — Dalvik tanpa JIT (Android 1.0–2.1): interpretasi murni kode byte DEX. Fase kedua — Dalvik dengan JIT (Android 2.2–4.4): munculnya kompilator JIT yang mempercepat aplikasi 2–5 kali. Fase ketiga — ART dengan JIT hibrida (Android 7.0+): kembalinya JIT dalam kualitas baru.
JIT di Dalvik diimplementasikan sebagai kompilator trace-based. Ia tidak menganalisis metode individual, tetapi rantai instruksi (traces) yang sering dieksekusi secara berurutan. Ini memungkinkan kompilasi jalur eksekusi lengkap, termasuk beberapa metode. Pendekatan ini efisien untuk prosesor mobile dengan cache instruksi kecil, karena trace yang dikompilasi muat di cache L1.
JIT di ART modern
Mulai dari Android 7.0 Nougat, ART menggunakan method-based JIT — mengkompilasi metode individual berdasarkan profil eksekusi. JIT ini bekerja jauh lebih cepat daripada Dalvik JIT: waktu kompilasi tipikal satu metode adalah 0.5–1 ms dibandingkan 3–5 ms di Dalvik. Kode yang dikompilasi disimpan di area memori terpisah (JIT code cache), bukan di heap aplikasi, yang mengurangi fragmentasi.
| Parameter | Dalvik JIT | ART JIT |
|---|---|---|
| Tipe | Trace-based | Method-based |
| Kecepatan kompilasi | 3–5 ms/metode | 0.5–1 ms/metode |
| Ambang kompilasi | ~200 panggilan | Dinamis |
| Cache kode | Di heap aplikasi | JIT code cache |
| Profilasi | Internal | File .prof eksternal |
Deteksi metode hot dan ambang kompilasi
Mekanisme sentral JIT — deteksi metode hot. Setiap panggilan metode meningkatkan penghitung internal. Ketika penghitung melewati ambang, metode ditandai sebagai “panas” dan dikirim untuk kompilasi. Di Dalvik ambang ditetapkan secara kaku (~200 panggilan). Di ART penghitung disesuaikan secara dinamis tergantung pada sumber daya perangkat yang tersedia.
Proses kompilasi mencakup beberapa fase. Pertama — analisis kode byte: JIT mempelajari aliran instruksi dan membangun grafik aliran data (data-flow graph). Kedua — optimasi: inlining metode kecil, penghapusan kode mati, folding konstanta. Ketiga — generasi kode: transformasi grafik yang dioptimalkan menjadi instruksi mesin untuk arsitektur CPU tertentu (ARM, ARM64, x86).
java
// Demonstrasi inlining — JIT akan mengganti body metode
public int inlineExample() {
return square(5);
}
private int square(int x) {
return x * x;
} // JIT akan mengganti panggilan dengan return 5 * 5;OSR — On-Stack Replacement
Teknik khusus JIT — On-Stack Replacement (OSR). Jika metode berisi loop panjang yang tidak berakhir selama ratusan iterasi, JIT dapat mengkompilasi loop “saat terbang” dan mengganti versi yang diinterpretasi dengan yang dikompilasi langsung selama eksekusi. OSR sangat efektif untuk tugas komputasi: rendering, pemrosesan gambar, kriptografi.
JIT vs AOT: analisis perbandingan
JIT dan AOT — dua pendekatan kompilasi dengan kompromi yang berlawanan. JIT mengorbankan kecepatan peluncuran pertama demi kekompakan distribusi dan kemampuan beradaptasi. AOT mengorbankan waktu instalasi dan ruang disk demi performa maksimal dari detik pertama. Tidak ada pendekatan yang mutlak lebih baik — pilihan tergantung pada skenario.
Keunggulan utama JIT adalah optimasi adaptif. JIT dapat menggunakan informasi profil yang tidak tersedia untuk AOT: tipe objek yang tepat, frekuensi panggilan aktual, percabangan sebenarnya. Ini memungkinkan penerapan optimasi agresif yang tidak mungkin dilakukan dalam kompilasi statis. Misalnya, JIT dapat melakukan virtualisasi panggilan metode (devirtualize), jika dalam praktik hanya muncul satu tipe penerima.
| Kriteria | JIT | AOT |
|---|---|---|
| Waktu instalasi | Seketika | Tergantung ukuran |
| Peluncuran pertama | Lebih lambat (pemanasan) | Cepat |
| Ruang disk | Minimal | +15–30% |
| Kemampuan beradaptasi | Tinggi | Rendah |
| Konsumsi CPU | Puncak saat kompilasi | Stabil |
Kapan memilih JIT
Kompilasi JIT lebih disukai ketika kecepatan penyebaran dan penghematan ruang disk penting. Dalam konteks pengembangan mobile, JIT ideal untuk aplikasi yang sering diperbarui (pengujian A/B, hotfix). JIT juga nyaman pada tahap pengembangan, ketika kode dibangun ulang puluhan kali sehari — setiap detik yang dihemat pada kompilasi mempercepat siklus umpan balik.
Kelebihan kompilasi JIT
JIT memberikan pengembang sejumlah kelebihan praktis. Pertama — ukuran APK kecil. Dalam pendekatan JIT, hanya kode byte (DEX) yang dikemas dalam APK, yang memakan ruang 20–30% lebih sedikit daripada kode asli yang dikompilasi. Bagi pengguna dengan memori internal terbatas, ini adalah keuntungan signifikan.
Kelebihan kedua — adaptasi ke perangkat. JIT mengkompilasi kode dengan mempertimbangkan arsitektur CPU aktual, jumlah RAM, dan beban saat ini. Misalnya, pada perangkat dengan RAM 2 GB, JIT dapat mengkompilasi kurang agresif untuk menghemat memori, dan pada flagship dengan 12 GB — menerapkan semua optimasi yang mungkin. Kompilasi AOT, sebaliknya, menetapkan keputusan pada saat instalasi.
Independensi platform
Kode byte tetap independen dari platform, yang menyederhanakan distribusi aplikasi. Satu APK berfungsi di perangkat ARM, ARM64, dan x86, dan JIT memastikan pembuatan kode asli untuk setiap arsitektur. Untuk pendekatan AOT, perlu menyertakan beberapa varian kode asli dalam APK (peningkatan ukuran), atau mengkompilasi versi terpisah untuk setiap arsitektur.
Kekurangan dan keterbatasan JIT
Kekurangan utama JIT adalah penundaan pemanasan (warm-up delay). Pengguna melihat perlambatan di detik-detik pertama aplikasi, sementara JIT mengkompilasi metode hot. Dalam game, ini muncul sebagai “gagap” (stuttering) di level awal. Dalam aplikasi dengan animasi — tersendat pada transisi pertama antar layar.
Kekurangan kedua adalah konsumsi energi. Proses kompilasi membebani CPU secara intensif, meningkatkan konsumsi energi sebesar 10–20% selama periode pemanasan. Pada perangkat bertenaga baterai, ini mengurangi waktu kerja otonom. Terutama terlihat dalam skenario dengan restart aplikasi yang sering (multitasking dengan memori terbatas, ketika sistem membongkar dan memuat ulang proses).
Fragmentasi cache
Masalah lain adalah fragmentasi cache JIT. Kode yang dikompilasi disimpan di area memori yang berkesinambungan. Saat memuat kelas baru dan kompilasi metode tambahan, cache menjadi terfragmentasi, yang meningkatkan overhead manajemen memori. Di Dalvik masalah ini diselesaikan dengan pembersihan cache berkala; di ART cache JIT dialokasikan terpisah dari heap dan menggunakan strategi defragmentasi sendiri.
Mode hibrida: terbaik dari dua dunia
Pendekatan modern di ART — kompilasi hibrida, menggabungkan kekuatan JIT dan AOT. Saat instalasi aplikasi, kompilasi tidak dilakukan — hanya verifikasi kode byte (verify). Ini memastikan instalasi cepat dan penggunaan ruang minimal. Peluncuran pertama bekerja dalam mode interpretasi dengan kompilasi JIT metode hot — pengguna mendapatkan performa yang dapat diterima tanpa menunggu lama.
Secara paralel, profilator latar belakang bekerja, mengumpulkan data tentang penggunaan aktual. Setelah 2–3 peluncuran penuh aplikasi, profil mencapai kelengkapan yang cukup, dan sistem meluncurkan dex2oat untuk mengkompilasi metode hot menjadi kode asli. Operasi ini dilakukan di latar belakang ketika perangkat tidak dibebani (pengisian daya, layar mati). Setelah AOT latar belakang selesai, aplikasi mendapatkan performa yang sebanding dengan kompilasi AOT penuh.
bash
# Memulai paksa kompilasi latar belakang
adb shell cmd package compile -m speed-profile -f com.example.app
# Melihat status kompilasi
adb shell cmd package dump-profiles com.example.appHasil pendekatan hibrida
Menurut data Google I/O 2017, kompilasi hibrida mengurangi waktu instalasi aplikasi sebesar 30–50% dibandingkan dengan AOT murni. Ruang yang ditempati pada partisi sistem berkurang 20–30%. Performa setelah kompilasi latar belakang sesuai dengan tingkat AOT penuh. Satu-satunya skenario di mana hibrida kalah dari AOT adalah peluncuran pertama segera setelah instalasi: aplikasi bekerja dalam mode JIT dan bisa 10–15% lebih lambat.
Pertanyaan yang Sering Diajukan
Apa itu kompilasi JIT dengan kata sederhana?
JIT — cara mempercepat program di mana kode diterjemahkan ke bahasa mesin tidak sebelumnya, tetapi secara bertahap selama bekerja. Bagian yang paling sering digunakan dikompilasi dan di-cache, sedangkan bagian yang jarang tetap dalam bentuk aslinya.
Apa perbedaan JIT dengan AOT?
JIT mengkompilasi kode saat eksekusi, yang menghemat ruang dan mempercepat instalasi. AOT mengkompilasi semua kode sebelumnya — aplikasi berjalan lebih cepat, tetapi membutuhkan lebih banyak ruang disk dan waktu untuk instalasi.
Mengapa JIT dihapus dari Android?
JIT tidak dihapus, tetapi berevolusi. Di Android 5.0, Dalvik dengan JIT digantikan oleh ART dengan AOT murni. Di Android 7.0, JIT kembali ke ART sebagai bagian dari sistem hibrida, di mana ia bekerja bersama dengan kompilasi AOT latar belakang untuk performa optimal.
Bagaimana JIT mempengaruhi konsumsi energi?
JIT meningkatkan konsumsi energi sebesar 10–20% selama periode pemanasan karena beban CPU. Setelah kompilasi metode hot selesai, konsumsi energi kembali ke tingkat normal. Mode hibrida ART meminimalkan puncak-puncak ini berkat kompilasi latar belakang.
Apakah pengguna melihat pemanasan JIT?
Ya, dalam skenario dengan komputasi intensif. Pengguna mungkin melihat perlambatan di detik-detik pertama aplikasi atau di awal game. Di versi Android modern (8.0+), mode hibrida meminimalkan efek ini berkat kompilasi terprofil.
Ringkasan
- JIT (Just-In-Time) — kompilasi dinamis yang mengubah kode byte menjadi instruksi mesin saat eksekusi.
- Di Android JIT mengalami evolusi: trace-based di Dalvik → AOT penuh → hibrida JIT+AOT di ART modern.
- Metode hot dideteksi melalui penghitung panggilan dan dikompilasi saat melewati ambang (~200 panggilan).
- OSR (On-Stack Replacement) memungkinkan kompilasi loop panjang saat terbang tanpa mengganggu eksekusi.
- Kelebihan utama JIT: ukuran APK kecil, instalasi cepat dan adaptasi ke perangkat.
- Kekurangan utama: penundaan pemanasan, konsumsi energi puncak dan fragmentasi cache.
- Mode hibrida ART (Android 7.0+) mengurangi waktu instalasi sebesar 30–50% sambil mempertahankan performa tinggi.
Kami akan mengembangkan aplikasi seluler turnkey
IT Sectr membuat aplikasi iOS dan Android untuk startup dan bisnis sejak 2017. Kami akan memberi saran dan mengusulkan solusi terbaik.
Baca juga