Penyelarasan dan Pemisahan
Buat blok yang dapat digunakan dan tertata.
Penyelarasan dan Pemisahan adalah pelajaran C Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar C Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus C Academy mencakup 4 pelajaran total.
Mengapa Penyelarasan Penting
Setiap tipe memiliki persyaratan penyelarasan: alamatnya harus merupakan kelipatan dari suatu pangkat dua. double biasanya memerlukan penyelarasan 8 byte.
Karena malloc tidak mengetahui apa yang akan Anda simpan, fungsi tersebut harus mengembalikan pointer yang selaras untuk tipe dengan persyaratan paling ketat, biasanya 16 byte pada sistem 64-bit.
#include <stdalign.h>
/* the strictest fundamental alignment */
size_t strict = alignof(max_align_t); /* often 16 */Trik align_up
Membulatkan ukuran ke atas hingga kelipatan berikutnya dari penyelarasan berpangkat dua adalah trik bit klasik: tambahkan a - 1, lalu samarkan bit-bit rendah.
Ini hanya berfungsi jika a merupakan pangkat dua, sebagaimana semua penyelarasan nyata.
static size_t align_up(size_t n, size_t a) {
return (n + a - 1) & ~(a - 1);
}
/* align_up(13, 8) == 16, align_up(16, 8) == 16 */Membuktikan Perhitungannya Berjalan
Mari verifikasi align_up dengan program yang dapat dijalankan. Program ini membulatkan beberapa ukuran ke atas hingga batas 8 dan 16 byte, lalu mencetak hasilnya.
#include <stdio.h>
#include <stddef.h>
static size_t align_up(size_t n, size_t a) {
return (n + a - 1) & ~(a - 1);
}
int main(void) {
printf("%zu\n", align_up(13, 8)); /* 16 */
printf("%zu\n", align_up(16, 8)); /* 16 */
printf("%zu\n", align_up(1, 16)); /* 16 */
printf("%zu\n", align_up(33, 16)); /* 48 */
return 0;
}Menyelaraskan Ukuran yang Diminta
Di dalam pengalokasi, langkah pertama setiap permintaan adalah membulatkan ukuran yang diminta ke atas hingga batas penyelarasan. Ini menjamin blok berikutnya juga dimulai dalam keadaan selaras.
Byte padding merupakan fragmentasi internal, yaitu biaya untuk mendapatkan penyelarasan universal.
#define ALIGN 16
void *my_alloc(size_t size) {
size = align_up(size, ALIGN);
/* now find a block of this aligned size */
/* ... */
return NULL;
}Masalah Penggunaan Kembali Seluruh Blok
Pada pelajaran sebelumnya, kita mengembalikan seluruh blok bebas bahkan untuk permintaan kecil. Blok bebas berukuran 4000 byte yang diberikan untuk permintaan 16 byte menyia-nyiakan bagian sisanya.
Pembagian memotong blok menjadi bagian yang kita gunakan dan sisa yang tetap bebas.
Membagi Blok
Jika blok yang dipilih jauh lebih besar daripada yang diperlukan, kita menempatkan header baru di akhir wilayah yang diminta. Sisa ruang menjadi blok bebas yang lebih kecil di dalam daftar.
Kita hanya membagi jika sisa ruang cukup besar untuk menampung header dan sebagian payload; jika tidak, fragmen tersebut tidak berguna.
void split(block_t *b, size_t size) {
size_t rem = b->size - size;
if (rem < sizeof(block_t) + ALIGN) return; /* too small */
block_t *nb = (block_t *)((char *)(b + 1) + size);
nb->size = rem - sizeof(block_t);
nb->free = 1;
nb->next = b->next;
b->size = size;
b->next = nb;
}Mengalokasikan, Menyelaraskan, Membagi
Alur alokasi lengkap kini menyelaraskan ukuran, menemukan kecocokan, memisahkan sisa yang besar, lalu menandai blok sebagai digunakan.
Hal ini menjaga ukuran blok tetap rapat dan menyisakan ruang bebas yang dapat digunakan.
void *my_alloc(size_t size) {
size = align_up(size, ALIGN);
block_t *b = first_fit(size);
if (!b) return NULL;
split(b, size);
b->free = 0;
return (void *)(b + 1);
}Menjaga Kumpulan Memori Tetap Selaras
Agar benar, alamat awal kumpulan memori dan ukuran header juga harus mengikuti penyelarasan, sehingga setiap payload berada pada batas yang tepat.
Menggunakan alignas pada buffer statis menjamin seluruh skema dimulai dalam keadaan selaras.
#include <stdalign.h>
alignas(16) static unsigned char pool[4096];
/* pool now begins on a 16-byte boundary */Alokasi Selaras yang Dapat Dijalankan
Program ini mengalokasikan dari kumpulan memori yang selaras dan mencetak alamat yang dikembalikan modulo 16, menunjukkan bahwa hasilnya selalu nol, yaitu benar-benar selaras.
#include <stdio.h>
#include <stddef.h>
#include <stdalign.h>
static size_t align_up(size_t n, size_t a){ return (n+a-1)&~(a-1); }
alignas(16) static unsigned char pool[1024];
static size_t off = 0;
void *alloc16(size_t s){ off=align_up(off,16); if(off+s>sizeof(pool)) return NULL; void*p=&pool[off]; off+=s; return p; }
int main(void){
void *a = alloc16(1);
void *b = alloc16(20);
printf("a %% 16 = %lu\n", (unsigned long)((size_t)a % 16));
printf("b %% 16 = %lu\n", (unsigned long)((size_t)b % 16));
return 0;
}Membandingkan Pembagian dan Coalescing
Pembagian dan coalescing merupakan kebalikan yang saling menyeimbangkan. Alokasi membagi blok besar menjadi lebih kecil; pembebasan menggabungkan kembali blok-blok kecil.
Bersama-sama, keduanya memungkinkan kumpulan memori yang sama melayani campuran ukuran permintaan yang berubah-ubah tanpa membocorkan ruang atau mengalami fragmentasi permanen.
Dari Mainan Menjadi Pengalokasi Nyata
Sekarang Anda memiliki keempat pilar: sumber memori, header yang selaras, penggunaan kembali melalui daftar bebas dengan coalescing, dan pembagian. Pengalokasi nyata menambahkan bin kelas ukuran, cache utas, dan integrasi OS demi kecepatan dan skala.
Namun, gagasan inti yang Anda bangun di sini menjadi dasar setiap implementasi malloc.
Pemeriksaan Singkat
Pikirkan mengapa blok dibagi selama alokasi.
Ringkasan
Penyelarasan membulatkan ukuran ke atas dengan trik bit (n + a - 1) & ~(a - 1) agar setiap payload sesuai untuk tipe apa pun. Pembagian memotong blok bebas yang terlalu besar menjadi bagian yang digunakan dan sisa yang bebas, sedangkan coalescing membalikkan proses tersebut saat pembebasan.
Keempat pilar ini bersama-sama membentuk pengalokasi memori yang lengkap dan benar.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Penyelarasan dan Pemisahan” gratis?
Ya — teks lengkap “Penyelarasan dan Pemisahan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus C Academy, upgrade ke CoddyKit PRO. Kursus C Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Penyelarasan dan Pemisahan”?
Buat blok yang dapat digunakan dan tertata. Kamu berlatih C Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai C Academy?
Tidak diperlukan pengalaman sebelumnya. C Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.
Berapa lama pelajaran “Penyelarasan dan Pemisahan” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran C Academy ini?
Ya. Setiap pelajaran C Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Cara Kerja malloc
- Alokator Bump Sederhana
- Daftar Memori Bebas dan Penggunaan Ulang
- Penyelarasan dan Pemisahan