Melaksanakan malloc() dan free() — membelah blok besar

Dalam siaran sebelumnya siri ini, kami melihat bagaimana susunan kami memilih blok memori untuk digunakan semula boleh membawa kepada penggunaan memori yang lebih besar atau lebih kecil, dan kami menukar fungsi kami untuk mengelakkan perkara ini. pembaziran. Tetapi kita perlu menyelesaikan masalah lain yang lebih serius: kadangkala, blok memori yang sangat besar boleh menduduki ruang yang boleh digunakan oleh beberapa blok yang lebih kecil. Pertimbangkan kes di bawah, di mana kita memperuntukkan sebahagian besar memori, mengagihkannya, dan kemudian memperuntukkan dua blok yang lebih kecil:

void *ptr1 = abmalloc(128);
void *ptr2 = abmalloc(8);
abfree(ptr1);
void *ptr3 = abmalloc(8);
void *ptr4 = abmalloc(8);

Di sini, kami mempunyai blok memori 128 bait percuma dan apabila kami memperuntukkan blok hanya 8 bait, semua 128 bait menjadi tidak tersedia. Apabila kita memperuntukkan satu lagi blok 8-bait, timbunan itu perlu berkembang semula. Ini bukan penggunaan ingatan yang cekap.

Terdapat sekurang-kurangnya dua penyelesaian popular untuk kes ini. Satu, lebih cekap, ialah menggunakan tong sampah: menyenaraikan blok kumpulan mengikut saiz. Ini adalah pendekatan yang lebih canggih dan cekap, tetapi lebih kompleks. Pilihan lain, lebih mudah, ialah mencari blok besar dan bahagikannya kepada blok yang lebih kecil. Kami akan mengikut pendekatan ini.

Tetapi ingat: lebih ringkas tidak bermakna mudah ;-)

Pemfaktoran Semula Awal

Sebelum bermula, mari lakukan pemfaktoran semula kecil. Pada masa ini, fungsi header_new() melakukan dua perkara: ia memperuntukkan lebih banyak memori untuk blok baharu dan memulakan pengepalanya, menetapkan metadata dan penunjuk kepada blok sebelumnya. Bahagian memulakan pengepala mungkin berguna, jadi mari kita ekstraknya. Kami akan mencipta dua fungsi baharu untuk meningkatkan kebolehbacaan:

• Fungsi header_plug(), yang "memalamkan" blok yang dimulakan ke blok sebelumnya dan seterusnya.
• Fungsi header_init(), yang menetapkan nilai awal metadata blok (saiz dan ketersediaan).

Begini rupa mereka:

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;
    }
}

Sekarang, kita hanya perlu mengubah suai header_new() untuk menggunakan fungsi baharu ini:

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;
}

(Selain itu, kita boleh mengalih keluar baris terakhir->sebelumnya->seterusnya = terakhir; daripada fungsi abmalloc(), memandangkan header_plug() kini mengurusnya.)

Membelah Blok

Dengan alatan ini di tangan, mari buat fungsi header_split(). Memandangkan pengepala dan saiz minimum yang diperlukan, fungsi ini membahagikan blok memori kepada dua jika blok asal cukup besar untuk mengandungi

• saiz yang diperlukan,
• pengepala baharu untuk blok baharu dan
• sedikit ingatan tambahan.

Pertama, kami menyemak sama ada blok itu cukup besar:

Header *header_split(Header *header, size_t size) {
    size_t original_size = header->size;
    if (original_size >= size + sizeof(Header)) {

Jika syarat ini dipenuhi, kami belah blok. Mula-mula, kami mengurangkan saiz blok semasa dengan menolak saiz pengepala dan ruang yang diminta oleh abmalloc:

void *ptr1 = abmalloc(128);
void *ptr2 = abmalloc(8);
abfree(ptr1);
void *ptr3 = abmalloc(8);
void *ptr4 = abmalloc(8);

Ini meninggalkan ruang memori selepas blok semasa, yang akan kami gunakan untuk mencipta blok baharu. Kami mengira penunjuk untuk blok baharu ini:

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;
    }
}

Sekarang kita mempunyai penuding ke blok baharu, kita mulakan pengepalanya dengan header_init():

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;
}

Dan kami menyambungkan blok baharu ke blok sebelumnya dan seterusnya menggunakan header_plug():

Header *header_split(Header *header, size_t size) {
    size_t original_size = header->size;
    if (original_size >= size + sizeof(Header)) {

Jika blok asal adalah yang terakhir, blok baharu kini akan menjadi yang terakhir, jadi kami mengemas kini penunjuk terakhir:

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

Akhir sekali, kami mengembalikan blok baharu:

Header *new_header = header + sizeof(Header) + header->size;

Jika blok asal tidak cukup besar, kami hanya mengembalikan blok asal:

header_init(new_header, size, true);

Mengemas kini abmalloc()

Sekarang, kita hanya perlu kembali ke fungsi abmalloc() dan di tempat kita menemui blok yang boleh digunakan, kita menggunakan header_split() untuk cuba memisahkannya:

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

Jika blok boleh dibelah, blok baru akan dikembalikan. Jika tidak, blok asal akan disimpan dan dikembalikan seperti sebelumnya.

Nota tentang Pemisahan Blok

Perhatikan bahawa kami mencipta blok baharu pada penghujung blok asal. Kami boleh menciptanya pada mulanya, tetapi dengan mencipta blok terpakai baharu pada penghujungnya, blok percuma baharu kekal lebih dekat dengan blok lama. Dengan cara ini, ia akan ditemui dahulu apabila abmalloc() digunakan seterusnya.

Memisahkan blok memori yang besar adalah satu langkah ke hadapan, tetapi terdapat masalah sebaliknya: blok memori yang kecil boleh menyebabkan pemecahan, membuat permintaan yang lebih besar menyebabkan timbunan berkembang. Kita akan lihat cara menyelesaikannya dalam siaran seterusnya.

Atas ialah kandungan terperinci Melaksanakan malloc() dan free() — membelah blok besar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!