Stack VS Heap

Versi Bahasa Indonesia. Baca dalam Bahasa Inggris

Heap dan stack adalah dua area memori yang digunakan dalam pemrograman, terutama untuk mengelola siklus hidup dan organisasi variabel serta data. Berikut adalah perbandingan antara keduanya:

Heap

• Tujuan: Digunakan untuk alokasi memori dinamis, di mana memori dialokasikan dan dialokasikan kembali secara manual oleh programmer (di beberapa bahasa pemrograman).
• Masa Hidup: Objek atau data ada selama programmer mengelolanya secara eksplisit (atau sampai garbage collection di bahasa seperti Java atau Python).
• Akses: Dikelola melalui pointer atau reference. Programmer harus secara eksplisit melacak memori yang dialokasikan.
• Ukuran: Biasanya jauh lebih besar dari stack.
• Performa: Akses lebih lambat dibandingkan stack karena alokasi dan dealokasi memori melibatkan lebih banyak overhead.
• Fragmentasi: Rawan fragmentasi seiring waktu karena memori dialokasikan dan dialokasikan kembali secara tidak teratur.

Stack

• Tujuan: Digunakan untuk alokasi memori statis, biasanya untuk panggilan fungsi, variabel lokal, dan aliran kontrol.
• Masa Hidup: Memori dikelola secara otomatis. Variabel dialokasikan ketika fungsi dipanggil dan dialokasikan kembali ketika fungsi kembali.
• Akses: Beroperasi dengan cara LIFO (Last In, First Out). Akses sangat cepat.
• Ukuran: Lebih kecil dan terbatas ukurannya dibandingkan heap.
• Performa: Lebih cepat dari memori heap karena alokasi dan dealokasi sederhana dan otomatis.
• Fragmentasi: Tidak rentan terhadap fragmentasi karena sifatnya yang sekuensial.
• Scope: Variabel hanya dapat diakses dalam scope fungsi atau blok tempat mereka dideklarasikan.

Golang

Di Go, apakah suatu variabel dialokasikan di stack atau heap ditentukan oleh compiler Go melalui proses yang disebut escape analysis. Berikut cara mengidentifikasi dan memahami di mana variabel Anda dialokasikan:

Escape Analysis

Compiler Go menganalisis kode Anda selama kompilasi untuk memutuskan:

• Jika suatu variabel dapat tetap aman di stack (lokal dan berumur pendek).
• Jika suatu variabel melarikan diri (escape) dari fungsi atau scope-nya, maka akan dialokasikan di heap.

Indikator Utama untuk Alokasi Heap:

• Reference suatu variabel dikembalikan dari suatu fungsi.
• Suatu variabel digunakan dalam goroutine.
• Alamat variabel diambil (&) dan digunakan di luar scope langsungnya.

Cara Memeriksa Alokasi (Menggunakan go build atau go run)

Anda dapat secara eksplisit melihat keputusan compiler dengan mengaktifkan diagnostik escape analysis.

Perintah untuk Melihat Escape Analysis:

go build -gcflags="-m" main.go

• -gcflags="-m": Mengaktifkan pesan escape analysis selama kompilasi.
• Compiler akan mencetak pesan seperti:
  • main.go:10: variable x escapes to heap (menunjukkan alokasi heap).
  • main.go:15: can inline func f (menunjukkan alokasi stack).

Contoh Alokasi Stack vs Heap

Contoh Alokasi Stack

func stackExample() {
    x := 42 // x disimpan di stack
    fmt.Println(x)
}

Di sini, x adalah variabel lokal, dan tidak melarikan diri dari fungsi. Ini akan dialokasikan di stack.

Contoh Alokasi Heap

func heapExample() *int {
    x := 42
    return &x // x melarikan diri ke heap karena alamatnya dikembalikan
}

Karena x dikembalikan oleh reference, ia harus dialokasikan di heap untuk memastikan tetap valid setelah fungsi kembali.

Mengapa Ini Penting?

• Alokasi heap lebih mahal (lebih lambat) karena melibatkan garbage collection.
• Alokasi stack lebih cepat dan dibersihkan secara otomatis ketika fungsi keluar.

Memahami ini membantu mengoptimalkan program Go, terutama dalam aplikasi yang kritis terhadap performa.

Best Practices

• Prioritaskan alokasi stack jika memungkinkan dengan menghindari escape variabel yang tidak perlu.
• Gunakan tooling Go untuk menganalisis program Anda (-gcflags="-m").
• Jangan optimasi secara prematur; percayalah pada garbage collector dan compiler Go kecuali profiling menunjukkan kebutuhan.