Pengurusan Memori dalam Imej Asli GraalVM

Pengurusan memori ialah komponen penting dalam pembangunan perisian komputer, ditugaskan dengan peruntukan yang berkesan, penggunaan dan pelepasan memori dalam aplikasi. Kepentingannya terletak pada meningkatkan prestasi perisian dan memastikan kestabilan sistem.

Kutipan Sampah

Pengumpulan sampah (GC) adalah penting dalam bahasa pengaturcaraan kontemporari seperti Java dan Go. Ia secara autonomi mengesan dan mengitar semula memori yang tidak digunakan, dengan itu mengurangkan keperluan untuk pembangun mengurus memori secara manual. Konsep GC pada asalnya muncul dalam bahasa pengaturcaraan LISP pada akhir 1950-an, menandakan pengenalan pengurusan memori automatik.

Kelebihan utama pengurusan memori automatik termasuk:

• Pencegahan kebocoran memori dan penggunaan memori yang cekap.
• Proses pembangunan yang dipermudahkan dan kestabilan program yang dipertingkatkan.

Memahami sifat "sampah" dalam ingatan dan mengenal pasti ruang yang boleh dituntut adalah penting. Dalam bab yang akan datang, kita akan mulakan dengan meneroka prinsip asas kutipan sampah.

Algoritma Pengiraan Rujukan [George E. Collins 1966]

Algoritma Pengiraan Rujukan memberikan medan dalam pengepala objek untuk menjejaki kiraan rujukannya. Kiraan ini meningkat dengan setiap rujukan baharu dan berkurangan apabila rujukan dialih keluar. Apabila kiraan mencecah sifar, objek itu layak untuk kutipan sampah.

Pertimbangkan kod berikut:

Mula-mula buat String dengan demo nilai yang dirujuk oleh d (Rajah 1).

String d = new String("demo");

Rajah 1 – Selepas Rentetan dibuat

Kemudian, tetapkan d kepada null. Kiraan rujukan demo ialah sifar. Dalam algoritma Pengiraan Rujukan, memori untuk demo akan dituntut semula (Rajah 2).

d =null; // Reference count of 'demo' becomes zero, prompting garbage collection.

Rajah 2 – Apabila rujukan dibatalkan

Algoritma Pengiraan Rujukan beroperasi semasa pelaksanaan program, mengelakkan acara Stop-The-World, yang menghentikan program sementara untuk pengumpulan sampah. Walau bagaimanapun, kelemahan utamanya ialah ketidakupayaan untuk mengendalikan rujukan bulat (Rajah 3).

Contohnya:

public class CircularReferenceDemo {

  public CircularReferenceDemo reference;
  private String name;

  public CircularReferenceDemo(String name) {
    this.name = name;
  }

  public void setReference(CircularReferenceDemo ref) {
    this.reference = ref;
  }

  public static void main(String[] args) {
    CircularReferenceDemo objA = new CircularReferenceDemo("Ref_A");
    CircularReferenceDemo objB = new CircularReferenceDemo("Ref_B");

    objA.setReference(objB);
    objB.setReference(objA);

    objA = null;
    objB = null;
  }
}

Di sini, walaupun rujukan luaran membatalkan, rujukan bersama antara objA dan objB menghalang kutipan sampah mereka.

Rajah 3 – Rujukan Pekeliling

Kita dapat lihat bahawa kedua-dua objek tidak boleh diakses lagi. Walau bagaimanapun, mereka dirujuk oleh satu sama lain, dan dengan itu kiraan rujukan mereka tidak akan menjadi sifar. Akibatnya, pemungut GC tidak akan dimaklumkan untuk mengutip sampah dengan menggunakan algoritma Pengiraan Rujukan.

Algoritma ini secara praktikal dilaksanakan dalam C++ melalui penggunaan std::shared_ptr. Direka bentuk untuk mengurus kitaran hayat objek yang diperuntukkan secara dinamik, std::shared_ptr mengautomasikan kenaikan dan pengurangan kiraan rujukan apabila penunjuk kepada objek dibuat atau dimusnahkan. Penunjuk pintar ini adalah sebahagian daripada Perpustakaan Standard C++, menyediakan keupayaan pengurusan memori yang mantap yang mengurangkan risiko yang berkaitan dengan pengendalian memori manual dengan ketara. Apabila std::shared_ptr disalin, kiraan rujukan dalaman objek terurus meningkat, mencerminkan rujukan baharu. Sebaliknya, apabila std::shared_ptr dimusnahkan, di luar skop atau ditugaskan semula ke objek lain, kiraan rujukan berkurangan. Memori yang diperuntukkan dituntut semula secara automatik dan objek dimusnahkan apabila kiraan rujukannya mencapai sifar,
berkesan mencegah kebocoran memori dengan memastikan tiada objek kekal diperuntukkan tanpa keperluan.

Algoritma Analisis Kebolehcapaian [1978]

Algoritma Analisis Kebolehcapaian bermula pada punca GC, merentasi graf objek. Objek yang tidak dapat dicapai dari akar ini dianggap tidak dapat dipulihkan dan disasarkan untuk pengumpulan.

Seperti yang ditunjukkan dalam imej di bawah, objek dalam bulatan biru harus disimpan hidup dan objek dalam bulatan kelabu boleh dikitar semula (Rajah 4).

Rajah 4 – Kebocoran memori

Kaedah ini berkesan menyelesaikan isu rujukan pekeliling yang wujud dalam Algoritma Pengiraan Rujukan. Objek yang tidak boleh dicapai dari akar GC dikategorikan untuk koleksi.

Biasanya, objek Java yang dianggap sebagai akar GC termasuk:

• Pembolehubah setempat dalam skop kaedah semasa.
• Jalur Java aktif.
• Medan statik daripada kelas.
• Rujukan JNI daripada kod asli.

Gambaran Keseluruhan Imej Asli GraalVM

GraalVM menawarkan pengkompil awal masa (AOT), yang menterjemahkan aplikasi Java ke dalam binari boleh laku kendiri yang dikenali sebagai Imej Asli GraalVM. Dibangunkan oleh Oracle Labs, binari ini
merangkum kelas aplikasi dan perpustakaan serta komponen masa jalan seperti GC, membenarkan operasi tanpa Java Runtime Environment (JRE).

Proses ini melibatkan analisis statik untuk menentukan komponen yang boleh dicapai, permulaan melalui blok yang dilaksanakan dan memuktamadkan dengan mencipta petikan keadaan aplikasi untuk terjemahan kod mesin berikutnya.

Asas-asas Substrat VM

VM Substrat berdiri sebagai sebahagian daripada suite GraalVM, didalangi oleh Oracle Labs. Ia adalah JVM yang dipertingkatkan yang bukan sahaja menyokong kompilasi lebih awal (AOT) tetapi juga memudahkan pelaksanaan bahasa di luar Java, seperti JavaScript, Python, Ruby, dan juga bahasa ibunda seperti C dan C++. Pada terasnya, Substrat VM berfungsi sebagai rangka kerja canggih yang membolehkan GraalVM menyusun aplikasi Java ke dalam binari asli kendiri. Perduaan ini tidak bergantung pada Mesin Maya Maya (JVM) konvensional untuk pelaksanaannya, yang menyelaraskan penggunaan dan
proses operasi.

Salah satu ciri utama Substrat VM ialah pemungut sampah khusus, yang diperhalusi untuk aplikasi yang memerlukan kependaman rendah dan jejak memori yang minimum. Pengumpul sampah ini mahir dalam mengendalikan reka letak memori yang unik dan model operasi yang berbeza dengan imej asli, yang jauh berbeza daripada aplikasi Java tradisional yang dijalankan pada JVM standard. Ketiadaan pengkompil Just-In-Time (JIT) dalam imej asli Substrat VM ialah pilihan strategik yang membantu dalam meminimumkan saiz keseluruhan boleh laku. Ini kerana ia menghapuskan keperluan untuk memasukkan pengkompil JIT dan metadata yang berkaitan, yang mempunyai saiz dan kerumitan yang besar.

Tambahan pula, sementara GraalVM dibangunkan menggunakan Java, ini memperkenalkan kekangan tertentu, terutamanya dari segi akses memori asli. Sekatan sedemikian adalah disebabkan terutamanya oleh kebimbangan keselamatan dan keperluan untuk mengekalkan keserasian merentas pelbagai platform. Walau bagaimanapun, mengakses memori asli adalah penting untuk operasi pengumpulan sampah yang optimum. Untuk menangani perkara ini, Substrat VM menggunakan set antara muka khusus yang memudahkan interaksi yang selamat dan cekap dengan memori asli. Antara muka ini adalah sebahagian daripada seni bina GraalVM yang lebih luas dan membolehkan Substrat VM mengurus memori dengan berkesan dalam cara yang serupa dengan bahasa peringkat rendah seperti C, sambil mengekalkan keselamatan dan kebolehurusan Java.

Dalam praktiknya, keupayaan ini menjadikan Substrate VM alat yang sangat serba boleh yang meningkatkan fungsi dan kecekapan aplikasi yang disusun dengan GraalVM. Dengan membenarkan pembangun
memanfaatkan rangkaian bahasa pengaturcaraan yang lebih luas dan menyusunnya menjadi binari asli yang cekap, Substrat VM menolak sempadan perkara yang boleh dicapai dengan persekitaran pembangunan Java tradisional. Ini menjadikannya aset yang tidak ternilai untuk projek pembangunan perisian moden yang menuntut prestasi tinggi, penggunaan sumber yang berkurangan dan sokongan bahasa yang serba boleh.

Elemen Substrat VM yang perlu diberi perhatian termasuk:

• Akses memori yang dipermudahkan melalui antara muka seperti Penunjuk Antara Muka Penunjuk untuk operasi memori mentah dan Antara Muka WordBase WordBase untuk mengendalikan nilai bersaiz perkataan.

• Pembahagian timbunan kepada segmen pra-dimulakan yang mengandungi objek tidak berubah dan segmen masa jalan untuk peruntukan objek dinamik (Rajah 5).

Rajah 5 – Pengurusan Memori dalam Imej Asli

Pada masa jalanan, apa yang dipanggil timbunan imej dalam Substrat VM mengandungi objek yang dibuat semasa proses membina imej. Bahagian timbunan ini dipramulakan dengan data daripada bahagian data binari boleh laku dan mudah diakses semasa aplikasi dimulakan. Objek yang berada dalam timbunan imej dianggap abadi; oleh itu, rujukan dalam objek ini dianggap sebagai penunjuk akar oleh
pemungut sampah. Walau bagaimanapun, GC hanya mengimbas bahagian timbunan imej untuk penunjuk akar, khususnya yang tidak ditandakan sebagai baca sahaja.

Semasa proses binaan, objek yang ditetapkan sebagai baca sahaja diletakkan dalam bahagian baca sahaja tertentu timbunan imej. Memandangkan objek ini tidak akan sekali-kali memegang rujukan kepada objek yang diperuntukkan pada masa jalan, ia tidak mengandungi penunjuk akar, membenarkan GC memintasnya semasa imbasan. Begitu juga, objek yang hanya terdiri daripada data primitif atau tatasusunan jenis primitif juga tidak mempunyai petunjuk akar. Atribut ini menyelaraskan lagi proses pengumpulan sampah, kerana objek ini boleh diabaikan daripada imbasan GC.

Sebaliknya, timbunan Java ditetapkan untuk memegang objek biasa yang dicipta secara dinamik semasa masa jalan. Bahagian timbunan ini tertakluk kepada kutipan sampah biasa untuk menuntut semula ruang yang diduduki oleh objek yang tidak lagi digunakan. Ia distrukturkan sebagai timbunan generasi dengan mekanisme untuk penuaan, memudahkan pengurusan ingatan yang cekap dari semasa ke semasa.

Pembahagian antara timbunan imej yang telah dimulakan dan abadi dan timbunan Java yang diurus secara dinamik membolehkan VM Substrat mengoptimumkan penggunaan memori dan kecekapan pengumpulan sampah, memenuhi kedua-dua aspek statik dan dinamik keperluan memori aplikasi.

Timbunan Ketulan

Dalam model timbunan Substrat VM, memori disusun secara sistematik ke dalam struktur yang dikenali sebagai ketulan timbunan. Bongkahan ini, biasanya bersaiz 1024KB secara lalai, membentuk segmen berterusan memori maya yang diperuntukkan semata-mata kepada storan objek. Struktur organisasi bongkahan ini ialah senarai terpaut di mana bongkah ekor mewakili segmen terbaharu ditambah. Model sedemikian
memudahkan peruntukan memori dan pengurusan objek yang cekap.

Ketulan timbunan ini dikategorikan lagi kepada dua jenis: sejajar dan tidak sejajar. Ketulan timbunan yang dijajarkan mampu memegang berbilang objek secara berterusan. Penjajaran ini membolehkan pemetaan yang lebih mudah bagi
objek kepada ketulan timbunan induk masing-masing, menjadikan pengurusan memori lebih intuitif dan cekap. Dalam senario di mana promosi objek diperlukan-biasanya, semasa pengumpulan sampah dan
pengoptimuman memori- objek dialihkan daripada peletakan asalnya dalam ketulan timbunan induk kepada ketulan timbunan sasaran yang terletak dalam "angkasa lama ke angkasa" yang ditetapkan. Penghijrahan ini merupakan sebahagian daripada strategi pengurusan timbunan generasi yang membantu dalam mengoptimumkan proses pengumpulan sampah dengan mengasingkan objek muda daripada objek lama, dengan itu mengurangkan overhed semasa kitaran GC.

Pengumpul Sampah dalam Imej Asli

GraalVM Native Image menyokong pelbagai GC yang disesuaikan dengan keperluan yang berbeza:

• GC Bersiri: Pengumpul jejak rendah lalai sesuai untuk aplikasi satu benang.

• Pengumpul Sampah G1: Direka untuk aplikasi berbilang benang dengan saiz timbunan yang besar, meningkatkan fleksibiliti dalam pengurusan penjanaan.

• Epsilon GC: Pengumpul minimalis yang mengendalikan peruntukan tetapi kekurangan penambakan, paling baik digunakan untuk aplikasi jangka pendek di mana penggunaan timbunan penuh boleh diramalkan.

Kesimpulan

Kesimpulannya, Substrat VM secara berkesan mengoptimumkan pengurusan memori dalam GraalVM dengan menggabungkan teknik lanjutan seperti pengumpulan sampah khusus dan pengurusan timbunan berstruktur. Ciri-ciri ini, termasuk ketulan timbunan dan segmen memori yang berasingan untuk timbunan imej dan Java, menyelaraskan pengumpulan sampah dan meningkatkan prestasi aplikasi. Memandangkan Substrat VM menyokong pelbagai bahasa pengaturcaraan dan menyusunnya menjadi binari asli yang cekap, ia mempamerkan cara rangka kerja JVM moden boleh melangkaui sempadan tradisional untuk meningkatkan kecekapan dan keteguhan pelaksanaan dalam persekitaran aplikasi yang pelbagai. Pendekatan ini menetapkan standard yang tinggi untuk perkembangan masa depan dalam teknologi mesin maya dan penggunaan aplikasi.

Atas ialah kandungan terperinci Pengurusan Memori dalam Imej Asli GraalVM. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!