Mengapakah Go menggunakan kurang memori untuk sekeping panjang 100k berbanding untuk susunan panjang 100k?

Apabila bahasa Go mengendalikan kepingan dan tatasusunan, kepingan dengan panjang 100k menggunakan kurang memori berbanding tatasusunan dengan panjang 100k. Ini kerana kepingan menggunakan gabungan penunjuk dan panjang dalam pelaksanaan asasnya, manakala tatasusunan memerlukan ruang memori bersebelahan untuk menyimpan data. Memandangkan panjang kepingan adalah berubah-ubah, memori boleh diperuntukkan dan dikeluarkan secara dinamik, manakala tatasusunan perlu mempunyai panjang tetap yang ditentukan apabila ia diisytiharkan. Oleh itu, apabila memproses sejumlah besar data, menggunakan penghirisan boleh menggunakan ruang memori dengan lebih cekap dan mengurangkan penggunaan memori. Ini juga merupakan salah satu kelebihan bahasa Go apabila memproses data berskala besar.

Kandungan soalan

Pertimbangkan kod berikut, saya memperuntukkan 4000 tatasusunan, setiap satu daripada 100k panjang:

parentmap := make(map[int][100_000]int)
    for i := 0; i < 4000; i++ {
        parentmap[i] = [100_000]int{}
        time.sleep(3 * time.millisecond)
    }

Jika saya menjalankan program secara tempatan dan menganalisis penggunaan memorinya, ia mula menggunakan >2gb memori.

Sekarang jika kita menukar sedikit kod untuk menggunakan kepingan tatasusunan (tetapi juga panjang 100k) seperti ini:

parentMap := make(map[int][]int)
    for i := 0; i < 4000; i++ {
        parentMap[i] = make([]int, 100_000)
        time.Sleep(3 * time.Millisecond)
    }

Pada mesin saya, memori memuncak pada sekitar 73mb. Kenapa ni?

Saya rasa kedua-dua serpihan akan menggunakan memori yang hampir sama atas sebab-sebab berikut:

• Dalam kedua-dua kes, masa jalan pergi akan memperuntukkan parentmap 的值。 go 这样做是因为如果它在堆栈上分配这些值，那么一旦当前函数超出范围，parentmap pada timbunan dan semua nilai akan dikosongkan.
• Jadi coretan kod pertama memperuntukkan tatasusunan 4k terus pada timbunan.
• Selain itu, serpihan kedua memperuntukkan pengepala hirisan 4k pada timbunan. Setiap pengepala kepingan mempunyai penuding kepada tatasusunan unik bersaiz 100k (juga pada timbunan).
• Dalam kedua-dua kes, terdapat tatasusunan 4k pada timbunan saiz 100k. Oleh itu, lebih kurang jumlah memori yang sama harus digunakan dalam mana-mana kes.

Saya membaca: https://go.dev/blog/slices-intro. Tetapi tidak dapat mencari butiran pelaksanaan yang menjelaskan perkara ini.

Penyelesaian

Versi dengan penghirisan mungkin mendapat manfaat daripada peruntukan malas. Tiada apa-apa yang akan cuba menulis kepada penimbal data dalam salah satu kepingan ini, jadi sistem pengendalian bebas untuk tidak benar-benar memperuntukkan memori untuk penimbal ini sehingga penulisan benar-benar cuba. (Sistem pengendalian juga boleh dengan malas sifar memulakan penimbal supaya peruntukan tidak dipaksa.)

Sementara itu, versi dengan tatasusunan memerlukan tatasusunan sebenarnya disalin ke dalam peta, yang bermaksud sebenarnya melaksanakan penulisan. Walaupun nilai yang ditulis adalah semua sifar, mereka masih menulis, jadi sistem pengendalian mesti benar-benar memperuntukkan memori untuk data ditulis.

Cuba tulis data pada kepingan ini, versi yang dihiris juga harus menggunakan memori gigabait. (Saya rasa satu nilai setiap halaman memori sepatutnya mencukupi, tetapi mungkin lebih mudah untuk mengisi kepingan itu dengan 1s.)

Atas ialah kandungan terperinci Mengapakah Go menggunakan kurang memori untuk sekeping panjang 100k berbanding untuk susunan panjang 100k?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!