Pengantar Teknik Kompilasi "Janino"

The Janino

Janino merupakan open source
(BSD-berlisensi) tertanam Java compiler. Ini bukanlah sebuah compiler bahwa 
pengembang akan digunakan untuk membangun aplikasi. Sebaliknya, itu
dirancang untuk digunakan dalam aplikasi Java untuk mengkompilasi kode Java
on the fly.

Setiap pengembang Java yang telah menggunakan JSP akan akrab (jika hanya
secara tidak langsung) dengan teknik dinamis Java kompilasi sumber
kode (yang tertanam di dalam halaman web dalam kasus JSP) ke
kelas "on demand." Mereka juga mungkin cukup beruntung untuk menjadi
akrab dengan komplikasi yang dapat timbul dari itu. Alasan
bahwa teknik ini telah terbukti canggung di masa lalu adalah bahwa setiap kode
yang perlu untuk menggunakan teknik ini membutuhkan JDK untuk diinstal
(bukan hanya JRE). Hal ini dapat memperkenalkan masalah perizinan karena
JDK tidak (belum) didistribusikan secara gratis. Selain itu, platform-spesifik konfigurasi 
yang diperlukan untuk menemukan sebuah JDK yang tepat dan 
mengidentifikasi file kelas aplikasi. Implementasi portabel 
juga memerlukan kompilasi yang terjadi dalam proses sistem yang terpisah,
sebuah detail yang dapat menyebabkan masalah kinerja sendiri.

Membandingkan Kinerja Janino

membandingkan kinerja dari dua implementasi menggunakan 

tiga ekspresi dari berbagai kompleksitas, dan hasilnya memetakan
bawah pada Gambar 1. Jawa dipanggil tanpa bendera. Perintah 
baris yang digunakan untuk meluncurkan tes diberikan di bawah ini. Untuk menjalankan kinerja
tes diri Anda secara alami akan perlu menyesuaikan classpath
tepat.

java - cp janino . jar ,. janinotest . eval . JaninoTestEval

Seperti yang diharapkan, manfaat kompilasi menjadi lebih
jelas dengan meningkatnya kompleksitas. Evaluasi moderat ekspresi menunjukkan peningkatan kecepatan 7x. Angka-angka ini tidak disediakan sebagai patokan (juga tidak membuktikan bahwa kenaikan kecepatan akan terwujud), tetapi mereka berguna indikasi tingkat perbaikan yang pengembang dapat mengharapkan dalam beberapa skenario .

• 0 ( sepele )
• 100 * x + 20/2 ( sederhana )
• (X + y) / (x - y) * 100 / (x * y) ( moderat )

Gambar 1. Bagan menunjukkan superioritas eksekusi dikompilasi

Adalah penting bahwa siapa saja yang ingin mengadopsi Janino untuk mereka
sendiri proyek melakukan evaluasi mereka sendiri, optimasi pada
aplikasi didirikan jarang menghasilkan kemenangan sederhana. Dalam
evaluasi saya melakukan sebelumnya, saya mengevaluasi kinerja
Janino untuk mempercepat penggantian token seperti $ { tanda - name } dalam string Java. Gambar 2 di bawah ini menunjukkan bagan hasil. Saya membandingkan berikut implementasi:

naif-peta

Implementasi yang sederhana namun efisien menggunakan reguler Jawa
parsing ekspresi untuk menggantikan token dengan string dari peta.

cepat-peta

Implementasi dioptimalkan naif-peta yang pra-menyimpan
dekomposisi dari string tokenized.

janino-peta

Sebuah implementasi yang pra-mengkompilasi kode untuk menghasilkan
string dari nilai peta.

cepat-objek

Implementasi dioptimalkan yang menggunakan refleksi untuk menarik tanda
nilai langsung dari POJO (Plain Old Java Object).

janino-object

Sebuah implementasi yang pra-mengkompilasi kode untuk menghasilkan
string dari nilai peta.

tertanam-object

Untuk patokan waktu terbaik mungkin, implementasi ini menarik
nilai langsung dari kelas Jawa tertentu.

Gambar 2. Bagan menunjukkan inferioritas disusun
eksekusi

pemanggilan metode reflektif Jawa ternyata begitu cepat (dalam hal ini) bahwa kode JDK-dikompilasi melebihi itu Janino. Implementasi peta dioptimalkan juga lebih cepat dari versi terkompilasi. Hasil ini muncul dari optimasi yang dibuat oleh Sun Java compiler, tetapi tidak oleh Janino. Secara khusus, strategi untuk menerapkan operator Rangkaian string berbeda antara para penyusun. Kabar baiknya adalah bahwa dalam menanggapi evaluasi ini, penanganan string Janino sejak itu dioptimalkan dan kinerjanya sekarang sangat kompetitif dengan yang javac .

Setiap orang yang tertarik dalam menjalankan tes ini kinerja untuk
diri mereka sendiri dapat melakukannya dengan men-download sumber (lihat Sumber ), mengkompilasinya, dan dijalankan dengan
baris perintah di bawah ini (lagi dengan modifikasi sesuai dengan
kelas jalan).

java - cp janino . jar ,. janinotest . sub . JaninoSubTest

Pelajaran untuk menarik dari hasil ini adalah bahwa teknik
kode mengoptimalkan melalui kompilasi dinamis yang berharga, tetapi harus
diterapkan hanya dalam kasus di mana keuntungan kinerja dapat dibuktikan.
Seperti biasa, tidak ada peluru perak.

Beberapa Ide Penutupan

Ada banyak situasi yang meminjamkan diri untuk ini
pendekatan. Daftar ini mungkin memberikan beberapa ide.

• Penggunaan Java Proxy kelas dapat digantikan oleh dinamis
  kelas dikompilasi yang menghindari refleksi semua, sehingga memberikan
  peningkatan kinerja yang signifikan.
• Permintaan pada aplikasi yang meliputi fungsi user-defined
  (yang biasanya akan perlu diurai dan kemudian dievaluasi sebagai
  bahasa domain-spesifik) dapat dikompilasi dan kemudian dievaluasi sebagai
  kode Java jauh lebih cepat.
• Catatan data di mana bidang yang tetap, tetapi tidak diketahui pada
  waktu kompilasi, biasanya diimplementasikan menggunakan HashMap s. Menggunakan Janino, bidang yang dikenal dapat digunakan untuk membangun sebuah bidang swasta yang spesifik untuk setiap nilai record. Dengan beberapa pekerjaan tambahan, ladang masih bisa terkena melalui Peta antarmuka. Jika jumlah jenis catatan rendah sebagai proporsi dari jumlah record, penghematan memori bisa sangat signifikan.

Bagaimana cara kerja janino :

Janino meningkatkan pada situasi ini dalam tiga cara yang berbeda:

• Alih-alih melewati pekerjaan ke javac (atau setara Java
  compiler), Janino adalah library Java yang berjalan di JVM sama seperti
  aplikasi Anda. Tidak ada konfigurasi tambahan atau instalasi JDK yang
  diperlukan.
• Daripada membutuhkan akses ke file kelas aplikasi Anda
  dan. file jar, Janino memperoleh kelas langsung dari JVM. Ini
  berarti bahwa tidak ada masalah mengenai hak akses file atau
  membangun konfigurasi path.
• Janino menyediakan mudah menggunakan primitif untuk menyusun
  ekspresi, script, dan kelas. Pengembang menggunakan perpustakaan 
  tidak perlu menyibukkan diri dengan salah satu dari teknis 
  memuat kode yang dihasilkan secara dinamis: hal itu dilakukan untuk mereka. Pada 
  tingkat yang paling sederhana, mereka dapat lulus dalam string yang berisi kode Java dan 
  mendapatkan kembali objek.

Implikasi yang lebih luas dari ketersediaan Janino adalah bahwa
kompilasi source code dalam aplikasi Java, yang dulunya
sulit, berantakan, dan platform-spesifik, sekarang tak satu pun dari
hal. Hal ini memungkinkan penargetan hotspot kinerja 
melalui teknik dinamis mengkompilasi kode.

contoh langsung dari cara menggunakan Janino:

               
                
"  + name 
                    +  "= vars.getVariable (" "+ nama 
                    + ""); " ); 
            nama
 . add ( nama ); 
        } 

        String sumber =  "paket janinotest.eval, \ n" 
         + "JaninoEvaluator public class mengimplementasikan Evaluator { \ n " 
         + "\ tpublic ganda
 mengevaluasi (vars Variabel) {\ n"  +  "\ t \ t" 
         + varCode +  "\ n" 
 +  \ "t \ treturn