Melaksanakan malloc () dan percuma () - perpecahan besar

Artikel sebelumnya meneroka kesan urutan penggunaan semula blok memori pada penggunaan memori dan fungsi yang dioptimumkan untuk mengurangkan sisa. Walau bagaimanapun, satu lagi masalah yang lebih serius berterusan: blok memori yang besar boleh menduduki pelbagai ruang kecil yang boleh dieksploitasi. Sebagai contoh, peruntukkan sebahagian besar memori, dan selepas pembebasan, peruntukkan dua ketulan yang lebih kecil:

 <code class="c">void *ptr1 = abmalloc(128); void *ptr2 = abmalloc(8); abfree(ptr1); void *ptr3 = abmalloc(8); void *ptr4 = abmalloc(8);</code>

Pada masa ini, blok bebas 128-byte tidak dapat digunakan oleh permintaan 8-bait, mengakibatkan peruntukan blok 8-bait berikutnya yang memerlukan timbunan akan diperluaskan lagi, mengakibatkan penggunaan memori yang rendah.

Cara yang sangat cekap tetapi kompleks untuk menyelesaikan masalah ini ialah menggunakan "tong sampah": senarai ketulan yang dikelompokkan mengikut saiz. Satu lagi penyelesaian yang lebih mudah ialah memecah bahagian besar ke dalam ketulan yang lebih kecil. Artikel ini mengamalkan yang terakhir.

Refactoring kod

Pertama, refactor kod sedikit. Fungsi header_new() bertanggungjawab untuk memperuntukkan memori dan memulakan pengepala blok, yang tidak kondusif untuk pembacaan dan penyelenggaraan kod. Kami membahagikannya kepada dua fungsi:

• header_plug() : Masukkan blok yang diasaskan antara blok sebelumnya dan seterusnya.
• header_init() : Inisialisasi metadata (saiz dan ketersediaan) blok.

Mereka adalah seperti berikut:

 <code class="c">void header_init(header *header, size_t size, bool available) { header->size = size; header->available = available; } void header_plug(header *header, header *previous, header *next) { header->previous = previous; if (previous != NULL) { previous->next = header; } header->next = next; if (next != NULL) { next->previous = header; } }</code>

Fungsi header_new() diubahsuai seperti berikut:

 <code class="c">header *header_new(header *previous, size_t size, bool available) { header *header = sbrk(sizeof(header) size); header_init(header, size, available); header_plug(header, previous, NULL); return header; }</code>

( last->previous->next = last; Dalam fungsi abmalloc() , baris ini boleh dipadam kerana header_plug() kini bertanggungjawab untuk mengendalikan logik ini.)

Blok memori berpecah

Seterusnya, laksanakan fungsi header_split() . Memandangkan tajuk blok dan saiz minimum yang diperlukan, jika blok asal cukup besar, memecahnya menjadi dua bahagian:

• blok saiz yang diperlukan;
• Baki dan blok baru;

Pertama, periksa sama ada blok itu cukup besar:

 <code class="c">header *header_split(header *header, size_t size) { size_t original_size = header->size; if (original_size >= size sizeof(header)) {</code>

Jika cukup besar, pecahkan blok. Pertama, kurangkan saiz blok semasa:

 header->size = original_size - size - sizeof(header);

Kirakan penunjuk ke blok baru:

 header *new_header = (header 1) header->size; // Corrected pointer calculation

Mulakan tajuk blok baru:

 header_init(new_header, size, true);

Sambungkan blok baru ke senarai yang dipautkan:

 header_plug(new_header, header, header->next);

Jika blok asal adalah blok terakhir, kemas kini penunjuk last :

 if (header == last) { last = new_header; }

Kembali ke blok baru:

 return new_header; } else { return header; } }

Kemas kini Abmalloc ()

Akhirnya, ubah fungsi abmalloc() , dan selepas mencari blok yang ada, header_split() untuk cuba memecahnya:

 <code class="c">if (header->available && (header->size >= size)) { header = header_split(header, size); header->available = false; return (void*)(header 1); // Cast to void* for correct return type }</code>

Jika blok boleh dibahagikan, blok baru dikembalikan; Jika tidak, blok asal dikembalikan.

Nota mengenai segmentasi blok

Harus diingat bahawa blok baru dicipta pada akhir blok asal. Walaupun ia juga boleh dibuat pada mulanya, mewujudkan blok baru pada akhirnya boleh membawa blok percuma baru lebih dekat ke blok lama, meningkatkan kecekapan panggilan abmalloc() seterusnya.

Memisahkan potongan memori yang besar adalah satu langkah ke arah meningkatkan pengurusan ingatan, tetapi ia juga boleh menyebabkan ketulan kecil pemecahan ingatan, mengakibatkan permintaan yang lebih besar yang memerlukan pengembangan timbunan. Artikel seterusnya akan meneroka cara menyelesaikan masalah ini.

Atas ialah kandungan terperinci Melaksanakan malloc () dan percuma () - perpecahan besar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!