Apa yang dilakukan oleh kompiler just-in-time (JIT)?

Apa yang dilakukan oleh kompiler JIT sebagai lawan dari kompiler non-JIT? Bisakah seseorang memberikan deskripsi yang ringkas dan mudah dimengerti?

Kompiler JIT berjalan setelah program dimulai dan mengkompilasi kode (biasanya bytecode atau semacam instruksi VM) dengan cepat (atau disebut tepat waktu) seperti yang disebut) menjadi bentuk yang biasanya lebih cepat, biasanya host asli CPU set instruksi. JIT memiliki akses ke informasi runtime dinamis sedangkan kompiler standar tidak dan dapat membuat optimasi yang lebih baik seperti fungsi inlining yang sering digunakan.

Ini berbeda dengan kompiler tradisional yang mengkompilasi semua kode ke bahasa mesin sebelum program dijalankan pertama kali.

Untuk parafrase, kompiler konvensional membangun seluruh program sebagai file EXE SEBELUM pertama kali Anda menjalankannya. Untuk program gaya yang lebih baru, perakitan dibuat dengan pseudocode (p-code). Hanya SETELAH Anda menjalankan program pada OS (mis., Dengan mengklik dua kali ikonnya) akan kompiler (JIT) menendang dan menghasilkan kode mesin (m-code) yang prosesor Intel atau apa pun akan mengerti.

Pada awalnya, kompiler bertanggung jawab untuk mengubah bahasa tingkat tinggi (didefinisikan sebagai tingkat yang lebih tinggi dari assembler) menjadi kode objek (instruksi mesin), yang kemudian akan dihubungkan (oleh linker) menjadi yang dapat dieksekusi.

Pada satu titik dalam evolusi bahasa, kompiler akan mengkompilasi bahasa tingkat tinggi ke dalam pseudo-code, yang kemudian akan ditafsirkan (oleh penerjemah) untuk menjalankan program Anda. Ini menghilangkan kode objek dan executable, dan memungkinkan bahasa-bahasa ini menjadi portabel untuk beberapa sistem operasi dan platform perangkat keras. Pascal (yang dikompilasi ke P-Code) adalah salah satu yang pertama; Java dan C # adalah contoh yang lebih baru. Akhirnya istilah P-Code diganti dengan bytecode, karena sebagian besar operasi pseudo adalah byte panjang.

Kompiler Just-In-Time (JIT) adalah fitur interpreter run-time, yang alih-alih menafsirkan bytecode setiap kali metode dipanggil, akan mengkompilasi bytecode ke dalam instruksi kode mesin dari mesin yang sedang berjalan, dan kemudian memohon ini kode objek sebagai gantinya. Idealnya, efisiensi menjalankan kode objek akan mengatasi ketidakefisienan mengkompilasi ulang program setiap kali dijalankan.

JIT-Tepat pada waktunya kata itu sendiri mengatakan kapan dibutuhkan (sesuai permintaan)

Skenario khas:

Kode sumber sepenuhnya dikonversi menjadi kode mesin

Skenario JIT:

Kode sumber akan dikonversi menjadi bahasa assembly seperti struktur [untuk ex IL (bahasa perantara) untuk C #, ByteCode untuk java].

Kode menengah dikonversi menjadi bahasa mesin hanya ketika aplikasi membutuhkan kode yang diperlukan hanya dikonversi ke kode mesin.

JIT vs Non-JIT perbandingan:

• Dalam JIT tidak semua kode diubah menjadi kode mesin terlebih dahulu bagian dari kode yang diperlukan akan dikonversi menjadi kode mesin kemudian jika metode atau fungsi yang disebut tidak ada dalam mesin maka itu akan diubah menjadi kode mesin ... itu mengurangi beban pada CPU.

• Karena kode mesin akan dihasilkan pada waktu berjalan .... kompiler JIT akan menghasilkan kode mesin yang dioptimalkan untuk menjalankan arsitektur CPU mesin.

Contoh JIT:

1. Di Java, JIT ada di JVM (Java Virtual Machine)
2. Dalam C # itu dalam CLR (Common Language Runtime)
3. Di Android ada di DVM (Dalvik Virtual Machine), atau ART (Android RunTime) di versi yang lebih baru.

Seperti yang lain telah disebutkan

JIT adalah singkatan dari Just-in-Time yang berarti bahwa kode dikompilasi ketika dibutuhkan, bukan sebelum runtime.

Hanya untuk menambahkan satu poin ke diskusi di atas, JVM mempertahankan hitungan berapa kali suatu fungsi dieksekusi. Jika jumlah ini melebihi batas yang telah ditentukan, JIT mengkompilasi kode ke dalam bahasa mesin yang dapat langsung dieksekusi oleh prosesor (tidak seperti kasus normal di mana javac mengkompilasi kode menjadi bytecode dan kemudian java - penerjemah menginterpretasikan bytecode ini baris demi baris mengubahnya menjadi kode mesin dan jalankan).

Juga lain kali fungsi ini dihitung kode terkompilasi yang sama dieksekusi lagi tidak seperti interpretasi normal di mana kode ditafsirkan lagi baris demi baris. Ini membuat eksekusi lebih cepat.

Kompiler JIT hanya mengkompilasi kode byte ke kode asli yang setara pada eksekusi pertama. Setelah setiap eksekusi berturut-turut, JVM hanya menggunakan kode asli yang sudah dikompilasi untuk mengoptimalkan kinerja.

Tanpa kompiler JIT, juru bahasa JVM menerjemahkan kode byte baris demi baris untuk membuatnya tampak seolah-olah aplikasi asli sedang dijalankan.

Sumber

JIT adalah singkatan dari Just-in-Time yang berarti bahwa kode dikompilasi ketika dibutuhkan, bukan sebelum runtime.

Ini bermanfaat karena kompiler dapat menghasilkan kode yang dioptimalkan untuk mesin khusus Anda. Kompiler statis, seperti kompiler C rata-rata, akan mengkompilasi semua kode ke kode yang dapat dieksekusi pada mesin pengembang. Karenanya kompiler akan melakukan optimisasi berdasarkan beberapa asumsi. Ini dapat mengkompilasi lebih lambat dan melakukan lebih banyak optimasi karena tidak memperlambat eksekusi program untuk pengguna.

Setelah kode byte (yang netral arsitektur) telah dihasilkan oleh kompiler Java, eksekusi akan ditangani oleh JVM (di Jawa). Kode byte akan dimuat ke JVM oleh loader dan kemudian setiap instruksi byte ditafsirkan.

Ketika kita perlu memanggil metode beberapa kali, kita perlu menafsirkan kode yang sama berkali-kali dan ini mungkin membutuhkan waktu lebih lama daripada yang dibutuhkan. Jadi kami memiliki kompiler JIT (tepat waktu). Ketika byte telah dimuat ke JVM (run time-nya), seluruh kode akan dikompilasi daripada ditafsirkan, sehingga menghemat waktu.

Kompiler JIT hanya berfungsi saat run time, jadi kami tidak memiliki output biner.

Just In Time Compiler (JIT):
Ini mengkompilasi bytecode java menjadi instruksi mesin dari CPU tertentu.

Misalnya, jika kita memiliki pernyataan loop dalam kode java kita:

while(i<10){
    // ...
    a=a+i;
    // ...
 }

Kode loop di atas berjalan 10 kali jika nilai i adalah 0.

Tidak perlu mengkompilasi bytecode sebanyak 10 kali lagi dan lagi karena instruksi yang sama akan dieksekusi untuk 10 kali. Dalam hal ini, perlu untuk mengkompilasi kode itu hanya sekali dan nilainya dapat diubah untuk jumlah yang diperlukan kali. Jadi, Just In Time (JIT) Compiler melacak pernyataan dan metode tersebut (seperti yang disebutkan di atas sebelumnya) dan mengkompilasi potongan kode byte tersebut ke dalam kode mesin untuk kinerja yang lebih baik.

Contoh serupa lainnya, adalah pencarian pola menggunakan "Ekspresi Reguler" dalam daftar string / kalimat.

JIT Compiler tidak mengkompilasi semua kode ke kode mesin. Ini mengkompilasi kode yang memiliki pola yang sama saat dijalankan.

Lihat dokumentasi Oracle ini pada Understand JIT untuk membaca lebih lanjut.

Anda memiliki kode yang dikompilasi ke beberapa IL (bahasa perantara). Ketika Anda menjalankan program Anda, komputer tidak memahami kode ini. Itu hanya mengerti kode asli. Jadi kompiler JIT mengkompilasi IL Anda ke dalam kode asli dengan cepat. Ini dilakukan pada level metode.

Saya tahu ini adalah utas lama, tetapi optimasi runtime adalah bagian penting lain dari kompilasi JIT yang sepertinya tidak dibahas di sini. Pada dasarnya, kompiler JIT dapat memonitor program saat dijalankan untuk menentukan cara untuk meningkatkan eksekusi. Kemudian, ia dapat membuat perubahan tersebut dengan cepat - saat runtime. Google JIT optimisasi (javaworld memiliki artikel yang cukup bagus tentangnya. )

Just in time compiler (JIT) adalah perangkat lunak yang menerima input yang tidak dapat dieksekusi dan mengembalikan kode mesin yang sesuai untuk dieksekusi. Sebagai contoh:

Intermediate representation    JIT    Native machine code for the current CPU architecture

     Java bytecode            --->        machine code
     Javascript (run with V8) --->        machine code

Konsekuensi dari ini adalah bahwa untuk arsitektur CPU tertentu kompiler JIT yang sesuai harus diinstal.

Perbedaan kompiler, interpreter, dan JIT

Meskipun ada pengecualian secara umum ketika kita ingin mengubah kode sumber menjadi kode mesin kita dapat menggunakan:

1. Penyusun : Mengambil kode sumber dan mengembalikan yang dapat dieksekusi
2. Penerjemah : Menjalankan instruksi program dengan instruksi. Dibutuhkan segmen yang dapat dieksekusi dari kode sumber dan mengubah segmen itu menjadi instruksi mesin. Proses ini diulangi sampai semua kode sumber ditransformasikan menjadi instruksi mesin dan dieksekusi.
3. JIT : Banyak implementasi JIT yang berbeda dimungkinkan, namun JIT biasanya merupakan kombinasi dari kompiler dan interpreter. JIT pertama-tama mengubah data perantara (mis. Java bytecode) yang diterimanya ke dalam bahasa mesin melalui interpretasi. JIT sering dapat merasakan ketika bagian tertentu dari kode dieksekusi sering dan akan mengkompilasi bagian ini untuk eksekusi lebih cepat.

Jit singkatan dari just in time compiler jit adalah program yang mengubah kode byte java menjadi instruksi yang dapat dikirim langsung ke prosesor.

Menggunakan java just in time compiler (benar-benar kompiler kedua) pada platform sistem tertentu memenuhi bytecode ke dalam kode sistem tertentu, setelah kode telah dikompilasi ulang oleh jit complier, biasanya akan berjalan lebih cepat di komputer.

Compiler just-in-time dilengkapi dengan mesin virtual dan digunakan secara opsional. Ini mengkompilasi bytecode ke dalam kode yang dapat dieksekusi platform-spesifik yang segera dieksekusi.

kompilasi just-in-time (JIT), (juga terjemahan dinamis atau kompilasi run-time), adalah cara mengeksekusi kode komputer yang melibatkan kompilasi selama eksekusi suatu program - pada saat run time - daripada sebelum dieksekusi .

Kompilasi TI adalah kombinasi dari dua pendekatan tradisional untuk terjemahan ke kode mesin - kompilasi di depan waktu (AOT) , dan interpretasi - dan menggabungkan beberapa keuntungan dan kelemahan dari keduanya. Kompilasi JIT menggabungkan kecepatan kode yang dikompilasi dengan fleksibilitas interpretasi .

Mari kita pertimbangkan JIT yang digunakan dalam JVM,

Sebagai contoh, kompiler JS HotSpot JVM menghasilkan optimasi dinamis. Dengan kata lain, mereka membuat keputusan optimisasi saat aplikasi Java sedang berjalan dan menghasilkan instruksi mesin asli berkinerja tinggi yang ditargetkan untuk arsitektur sistem yang mendasarinya.

Ketika suatu metode dipilih untuk kompilasi, JVM memasukkan bytecode-nya ke kompiler Just-In-Time (JIT). JIT perlu memahami semantik dan sintaks dari bytecode sebelum dapat mengkompilasi metode dengan benar. Untuk membantu kompiler JIT menganalisis metode ini, bytecode-nya terlebih dahulu dirumuskan kembali dalam representasi internal yang disebut pohon jejak, yang menyerupai kode mesin lebih dekat daripada bytecode. Analisis dan optimisasi kemudian dilakukan pada pohon metode. Pada akhirnya, pohon-pohon tersebut diterjemahkan ke dalam kode asli.

Pohon jejak adalah struktur data yang digunakan dalam kompilasi runtime dari kode pemrograman. Trace tree digunakan dalam jenis 'just in time compiler' yang melacak kode yang dieksekusi selama hotspot dan mengkompilasinya. Lihat ini .

Merujuk:

• http://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html
• https://en.wikipedia.org/wiki/Just-in-time_compilation

Kompiler non-JIT mengambil kode sumber dan mengubahnya menjadi kode byte khusus mesin pada waktu kompilasi. Sebuah kompiler JIT mengambil kode byte mesin agnostik yang dihasilkan pada waktu kompilasi dan mengubahnya menjadi kode byte spesifik mesin pada saat run time. Kompiler JIT yang digunakan Java adalah apa yang memungkinkan biner tunggal berjalan pada banyak platform tanpa modifikasi.

20% dari kode byte digunakan 80% dari waktu. Kompiler JIT mendapatkan statistik ini dan mengoptimalkan 20% dari kode byte ini untuk berjalan lebih cepat dengan menambahkan metode inline, penghapusan kunci yang tidak digunakan dll dan juga membuat bytecode khusus untuk mesin itu. Saya mengutip dari artikel ini, saya merasa itu berguna. http://java.dzone.com/articles/just-time-compiler-jit-hotspot

JIT merujuk ke mesin eksekusi di beberapa implementasi JVM, yang lebih cepat tetapi membutuhkan lebih banyak memori, adalah kompiler just-in-time. Dalam skema ini, bytecode metode dikompilasi ke kode mesin asli saat metode pertama kali dipanggil. Kode mesin asli untuk metode ini kemudian di-cache, sehingga dapat digunakan kembali saat berikutnya metode yang sama dipanggil.

JVM benar-benar melakukan langkah kompilasi selama runtime karena alasan kinerja. Ini berarti bahwa Java tidak memiliki pemisahan kompilasi-eksekusi bersih. Pertama melakukan kompilasi statis dari kode sumber Java ke bytecode. Kemudian bytecode ini diteruskan ke JVM untuk dieksekusi. Tetapi mengeksekusi bytecode lambat sehingga JVM mengukur seberapa sering bytecode dijalankan dan ketika mendeteksi "hotspot" dari kode yang berjalan sangat sering ia melakukan kompilasi dinamis dari bytecode ke machinecode dari kode "hotspot" (hotspot profiler). Jadi secara efektif saat ini program Java dijalankan oleh eksekusi kode mesin.

Kompiler Just In Time juga dikenal sebagai kompiler JIT digunakan untuk peningkatan kinerja di Jawa. Ini diaktifkan secara default. Ini adalah kompilasi yang dilakukan pada waktu eksekusi lebih awal. Java telah mempopulerkan penggunaan kompiler JIT dengan memasukkannya ke dalam JVM.