Algoritma Penghitungan Referensi: Menerapkan Pengumpulan Sampah Siklik

Penghitungan referensi adalah teknik manajemen memori di mana setiap objek dalam memori mempertahankan jumlah referensi yang menunjuk ke dalamnya. Ketika jumlah referensi suatu objek turun ke nol, itu berarti tidak ada objek lain yang mereferensikannya, dan objek tersebut dapat dibebaskan dengan aman. Pendekatan ini menawarkan beberapa keuntungan, tetapi juga menghadapi tantangan, terutama dengan struktur data siklik. Artikel ini memberikan tinjauan komprehensif tentang penghitungan referensi, kelebihan, batasan, dan strategi untuk menerapkan pengumpulan sampah siklik.

Apa itu Penghitungan Referensi?

Penghitungan referensi adalah bentuk manajemen memori otomatis. Alih-alih mengandalkan pengumpul sampah untuk memindai memori secara berkala untuk objek yang tidak digunakan, penghitungan referensi bertujuan untuk mereklamasi memori segera setelah tidak dapat dijangkau. Setiap objek dalam memori memiliki jumlah referensi terkait, yang mewakili jumlah referensi (penunjuk, tautan, dll.) ke objek tersebut. Operasi dasarnya adalah:

• Meningkatkan Jumlah Referensi: Ketika referensi baru ke suatu objek dibuat, jumlah referensi objek ditingkatkan.
• Mengurangi Jumlah Referensi: Ketika referensi ke suatu objek dihapus atau keluar dari cakupan, jumlah referensi objek dikurangi.
• Dealokasi: Ketika jumlah referensi objek mencapai nol, itu berarti objek tersebut tidak lagi direferensikan oleh bagian lain dari program. Pada titik ini, objek dapat dibebaskan, dan memorinya dapat direklamasi.

Contoh: Pertimbangkan skenario sederhana di Python (meskipun Python terutama menggunakan pengumpul sampah pelacakan, ia juga menggunakan penghitungan referensi untuk pembersihan segera):

obj1 = MyObject()
obj2 = obj1  # Tingkatkan jumlah referensi obj1
del obj1  # Kurangi jumlah referensi MyObject; objek masih dapat diakses melalui obj2
del obj2  # Kurangi jumlah referensi MyObject; jika ini adalah referensi terakhir, objek tersebut dibebaskan

Keuntungan Penghitungan Referensi

Penghitungan referensi menawarkan beberapa keuntungan menarik dibandingkan teknik manajemen memori lainnya, seperti pengumpulan sampah pelacakan:

• Reklamasi Langsung: Memori direklamasi segera setelah suatu objek menjadi tidak dapat dijangkau, mengurangi penggunaan memori dan menghindari jeda panjang yang terkait dengan pengumpul sampah tradisional. Perilaku deterministik ini sangat berguna dalam sistem waktu-nyata atau aplikasi dengan persyaratan kinerja yang ketat.
• Kesederhanaan: Algoritma penghitungan referensi dasar relatif mudah diterapkan, sehingga cocok untuk sistem tertanam atau lingkungan dengan sumber daya terbatas.
• Lokalisasi Referensi: Dealokasi suatu objek seringkali mengarah pada dealokasi objek lain yang direferensikannya, meningkatkan kinerja cache dan mengurangi fragmentasi memori.

Keterbatasan Penghitungan Referensi

Terlepas dari keuntungannya, penghitungan referensi menderita beberapa keterbatasan yang dapat memengaruhi kepraktisannya dalam skenario tertentu:

• Overhead: Meningkatkan dan mengurangi jumlah referensi dapat memperkenalkan overhead yang signifikan, terutama dalam sistem dengan pembuatan dan penghapusan objek yang sering. Overhead ini dapat memengaruhi kinerja aplikasi.
• Referensi Melingkar: Keterbatasan paling signifikan dari penghitungan referensi dasar adalah ketidakmampuannya untuk menangani referensi melingkar. Jika dua atau lebih objek saling mereferensikan, jumlah referensi mereka tidak akan pernah mencapai nol, bahkan jika mereka tidak lagi dapat diakses dari sisa program, yang mengarah pada kebocoran memori.
• Kompleksitas: Menerapkan penghitungan referensi dengan benar, terutama di lingkungan multithread, memerlukan sinkronisasi yang cermat untuk menghindari kondisi balapan dan memastikan jumlah referensi yang akurat. Ini dapat menambah kompleksitas pada implementasi.

Masalah Referensi Melingkar

Masalah referensi melingkar adalah kelemahan dari penghitungan referensi naif. Pertimbangkan dua objek, A dan B, di mana A mereferensikan B dan B mereferensikan A. Bahkan jika tidak ada objek lain yang mereferensikan A atau B, jumlah referensi mereka setidaknya akan menjadi satu, mencegahnya untuk dibebaskan. Ini menciptakan kebocoran memori, karena memori yang ditempati oleh A dan B tetap dialokasikan tetapi tidak dapat dijangkau.

Contoh: Dalam Python:

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

node1 = Node(1)
node2 = Node(2)

node1.next = node2
node2.next = node1  # Referensi melingkar dibuat

del node1
del node2  # Kebocoran memori: node tidak lagi dapat diakses, tetapi jumlah referensi mereka masih 1

Bahasa seperti C++ menggunakan pointer pintar (misalnya, `std::shared_ptr`) juga dapat menunjukkan perilaku ini jika tidak dikelola dengan hati-hati. Siklus `shared_ptr` akan mencegah dealokasi.

Strategi Pengumpulan Sampah Siklik

Untuk mengatasi masalah referensi melingkar, beberapa teknik pengumpulan sampah siklik dapat digunakan bersama dengan penghitungan referensi. Teknik-teknik ini bertujuan untuk mengidentifikasi dan memutus siklus objek yang tidak dapat dijangkau, memungkinkan mereka untuk dibebaskan.

1. Algoritma Mark and Sweep

Algoritma Mark and Sweep adalah teknik pengumpulan sampah yang banyak digunakan yang dapat diadaptasi untuk menangani referensi siklik dalam sistem penghitungan referensi. Ini melibatkan dua fase:

• Fase Mark: Dimulai dari serangkaian objek akar (objek yang dapat diakses langsung dari program), algoritma melintasi grafik objek, menandai semua objek yang dapat dijangkau.
• Fase Sweep: Setelah fase penandaan, algoritma memindai seluruh ruang memori, mengidentifikasi objek yang tidak ditandai. Objek yang tidak ditandai ini dianggap tidak dapat dijangkau dan dibebaskan.

Dalam konteks penghitungan referensi, algoritma Mark and Sweep dapat digunakan untuk mengidentifikasi siklus objek yang tidak dapat dijangkau. Algoritma sementara mengatur jumlah referensi semua objek menjadi nol dan kemudian melakukan fase penandaan. Jika jumlah referensi suatu objek tetap nol setelah fase penandaan, itu berarti objek tersebut tidak dapat dijangkau dari objek akar mana pun dan merupakan bagian dari siklus yang tidak dapat dijangkau.

Pertimbangan Implementasi:

• Algoritma Mark and Sweep dapat dipicu secara berkala atau ketika penggunaan memori mencapai ambang batas tertentu.
• Penting untuk menangani referensi melingkar dengan hati-hati selama fase penandaan untuk menghindari perulangan tak terbatas.
• Algoritma dapat memperkenalkan jeda dalam eksekusi aplikasi, terutama selama fase sweep.

2. Algoritma Deteksi Siklus

Beberapa algoritma khusus dirancang khusus untuk mendeteksi siklus dalam grafik objek. Algoritma ini dapat digunakan untuk mengidentifikasi siklus objek yang tidak dapat dijangkau dalam sistem penghitungan referensi.

a) Algoritma Komponen yang Terhubung Kuat Tarjan

Algoritma Tarjan adalah algoritma penelusuran grafik yang mengidentifikasi komponen yang terhubung kuat (SCC) dalam grafik terarah. SCC adalah subgraf di mana setiap simpul dapat dijangkau dari setiap simpul lainnya. Dalam konteks pengumpulan sampah, SCC dapat mewakili siklus objek.

Cara kerjanya:

• Algoritma melakukan pencarian pertama-dalam (DFS) grafik objek.
• Selama DFS, setiap objek diberi indeks unik dan nilai lowlink.
• Nilai lowlink mewakili indeks terkecil dari objek apa pun yang dapat dijangkau dari objek saat ini.
• Ketika DFS menemukan objek yang sudah ada di tumpukan, ia memperbarui nilai lowlink dari objek saat ini.
• Ketika DFS selesai memproses SCC, ia mengeluarkan semua objek di SCC dari tumpukan dan mengidentifikasi mereka sebagai bagian dari siklus.

b) Algoritma Komponen Kuat Berbasis Jalur

Algoritma Komponen Kuat Berbasis Jalur (PBSCA) adalah algoritma lain untuk mengidentifikasi SCC dalam grafik terarah. Secara umum lebih efisien daripada algoritma Tarjan dalam praktiknya, terutama untuk grafik jarang.

Cara kerjanya:

• Algoritma mempertahankan tumpukan objek yang dikunjungi selama DFS.
• Untuk setiap objek, ia menyimpan jalur yang mengarah dari objek akar ke objek saat ini.
• Ketika algoritma menemukan objek yang sudah ada di tumpukan, ia membandingkan jalur ke objek saat ini dengan jalur ke objek di tumpukan.
• Jika jalur ke objek saat ini adalah awalan dari jalur ke objek di tumpukan, itu berarti objek saat ini adalah bagian dari siklus.

3. Penghitungan Referensi yang Ditunda

Penghitungan referensi yang ditunda bertujuan untuk mengurangi overhead peningkatan dan pengurangan jumlah referensi dengan menunda operasi ini hingga waktu kemudian. Ini dapat dicapai dengan menyimpan perubahan jumlah referensi dan menerapkannya secara berkelompok.

Teknik:

• Buffer Lokal-Thread: Setiap thread mempertahankan buffer lokal untuk menyimpan perubahan jumlah referensi. Perubahan ini diterapkan pada jumlah referensi global secara berkala atau ketika buffer menjadi penuh.
• Penghalang Tulis: Penghalang tulis digunakan untuk mencegat penulisan ke bidang objek. Ketika operasi tulis membuat referensi baru, penghalang tulis mencegat penulisan dan menunda peningkatan jumlah referensi.

Meskipun penghitungan referensi yang ditunda dapat mengurangi overhead, itu juga dapat menunda reklamasi memori, yang berpotensi meningkatkan penggunaan memori.

4. Mark and Sweep Parsial

Alih-alih melakukan Mark and Sweep penuh pada seluruh ruang memori, Mark and Sweep parsial dapat dilakukan pada wilayah memori yang lebih kecil, seperti objek yang dapat dijangkau dari objek tertentu atau sekelompok objek. Ini dapat mengurangi waktu jeda yang terkait dengan pengumpulan sampah.

Implementasi:

• Algoritma dimulai dari serangkaian objek yang dicurigai (objek yang cenderung menjadi bagian dari siklus).
• Ia melintasi grafik objek yang dapat dijangkau dari objek-objek ini, menandai semua objek yang dapat dijangkau.
• Kemudian menyapu wilayah yang ditandai, melepaskan semua objek yang tidak ditandai.

Menerapkan Pengumpulan Sampah Siklik dalam Bahasa yang Berbeda

Implementasi pengumpulan sampah siklik dapat bervariasi tergantung pada bahasa pemrograman dan sistem manajemen memori yang mendasarinya. Berikut adalah beberapa contoh:

Python

Python menggunakan kombinasi penghitungan referensi dan pengumpul sampah pelacakan untuk mengelola memori. Komponen penghitungan referensi menangani dealokasi objek langsung, sementara pengumpul sampah pelacakan mendeteksi dan memutus siklus objek yang tidak dapat dijangkau.

Pengumpul sampah di Python diimplementasikan dalam modul `gc`. Anda dapat menggunakan fungsi `gc.collect()` untuk memicu pengumpulan sampah secara manual. Pengumpul sampah juga berjalan secara otomatis pada interval reguler.

Contoh:

import gc

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

node1 = Node(1)
node2 = Node(2)

node1.next = node2
node2.next = node1  # Referensi melingkar dibuat

del node1
del node2

gc.collect()  # Paksa pengumpulan sampah untuk memutus siklus

C++

C++ tidak memiliki pengumpulan sampah bawaan. Manajemen memori biasanya ditangani secara manual menggunakan `new` dan `delete` atau menggunakan pointer pintar.

Untuk menerapkan pengumpulan sampah siklik di C++, Anda dapat menggunakan pointer pintar dengan deteksi siklus. Satu pendekatan adalah dengan menggunakan `std::weak_ptr` untuk memutus siklus. `weak_ptr` adalah pointer pintar yang tidak meningkatkan jumlah referensi dari objek yang ditunjuknya. Ini memungkinkan Anda untuk membuat siklus objek tanpa mencegahnya dibebaskan.

Contoh:

#include 
#include 

class Node {
public:
    int data;
    std::shared_ptr next;
    std::weak_ptr prev;  // Gunakan weak_ptr untuk memutus siklus

    Node(int data) : data(data) {}
    ~Node() { std::cout << "Node destroyed with data: " << data << std::endl; }
};

int main() {
    std::shared_ptr node1 = std::make_shared(1);
    std::shared_ptr node2 = std::make_shared(2);

    node1->next = node2;
    node2->prev = node1; // Siklus dibuat, tetapi prev adalah weak_ptr

    node2.reset();
    node1.reset(); // Node sekarang akan dihancurkan

    return 0;
}

Dalam contoh ini, `node2` menyimpan `weak_ptr` ke `node1`. Ketika `node1` dan `node2` keluar dari cakupan, pointer bersama mereka dihancurkan, dan objek dibebaskan karena pointer lemah tidak berkontribusi pada jumlah referensi.

Java

Java menggunakan pengumpul sampah otomatis yang menangani pelacakan dan beberapa bentuk penghitungan referensi secara internal. Pengumpul sampah bertanggung jawab untuk mendeteksi dan mereklamasi objek yang tidak dapat dijangkau, termasuk yang terlibat dalam referensi melingkar. Anda umumnya tidak perlu secara eksplisit menerapkan pengumpulan sampah siklik di Java.

Namun, memahami cara kerja pengumpul sampah dapat membantu Anda menulis kode yang lebih efisien. Anda dapat menggunakan alat seperti profiler untuk memantau aktivitas pengumpulan sampah dan mengidentifikasi potensi kebocoran memori.

JavaScript

JavaScript mengandalkan pengumpulan sampah (seringkali algoritma mark-and-sweep) untuk mengelola memori. Sementara penghitungan referensi adalah bagian dari bagaimana mesin dapat melacak objek, pengembang tidak secara langsung mengontrol pengumpulan sampah. Mesin bertanggung jawab untuk mendeteksi siklus.

Namun, waspadalah terhadap pembuatan grafik objek yang secara tidak sengaja besar yang dapat memperlambat siklus pengumpulan sampah. Memutus referensi ke objek ketika tidak lagi diperlukan membantu mesin mereklamasi memori lebih efisien.

Praktik Terbaik untuk Penghitungan Referensi dan Pengumpulan Sampah Siklik

• Minimalkan Referensi Melingkar: Rancang struktur data Anda untuk meminimalkan pembuatan referensi melingkar. Pertimbangkan untuk menggunakan struktur data atau teknik alternatif untuk menghindari siklus sama sekali.
• Gunakan Referensi Lemah: Dalam bahasa yang mendukung referensi lemah, gunakan mereka untuk memutus siklus. Referensi lemah tidak meningkatkan jumlah referensi dari objek yang mereka tunjuk, memungkinkan objek dibebaskan bahkan jika itu adalah bagian dari siklus.
• Terapkan Deteksi Siklus: Jika Anda menggunakan penghitungan referensi dalam bahasa tanpa deteksi siklus bawaan, terapkan algoritma deteksi siklus untuk mengidentifikasi dan memutus siklus objek yang tidak dapat dijangkau.
• Pantau Penggunaan Memori: Pantau penggunaan memori untuk mendeteksi potensi kebocoran memori. Gunakan alat profil untuk mengidentifikasi objek yang tidak dibebaskan dengan benar.
• Optimalkan Operasi Penghitungan Referensi: Optimalkan operasi penghitungan referensi untuk mengurangi overhead. Pertimbangkan untuk menggunakan teknik seperti penghitungan referensi yang ditunda atau penghalang tulis untuk meningkatkan kinerja.
• Pertimbangkan Trade-off: Evaluasi trade-off antara penghitungan referensi dan teknik manajemen memori lainnya. Penghitungan referensi mungkin bukan pilihan terbaik untuk semua aplikasi. Pertimbangkan kompleksitas, overhead, dan keterbatasan penghitungan referensi saat membuat keputusan Anda.

Kesimpulan

Penghitungan referensi adalah teknik manajemen memori yang berharga yang menawarkan reklamasi segera dan kesederhanaan. Namun, ketidakmampuannya untuk menangani referensi melingkar adalah batasan yang signifikan. Dengan menerapkan teknik pengumpulan sampah siklik, seperti Mark and Sweep atau algoritma deteksi siklus, Anda dapat mengatasi batasan ini dan menuai manfaat dari penghitungan referensi tanpa risiko kebocoran memori. Memahami trade-off dan praktik terbaik yang terkait dengan penghitungan referensi sangat penting untuk membangun sistem perangkat lunak yang kuat dan efisien. Pertimbangkan dengan cermat persyaratan spesifik aplikasi Anda dan pilih strategi manajemen memori yang paling sesuai dengan kebutuhan Anda, menggabungkan pengumpulan sampah siklik jika perlu untuk mengurangi tantangan referensi melingkar. Ingatlah untuk memprofilkan dan mengoptimalkan kode Anda untuk memastikan penggunaan memori yang efisien dan mencegah potensi kebocoran memori.