写一份关于buddy system 的C语言代码

以下是一个简单的Buddy System的C语言代码实现，用于分配和释放内存块：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAX_LEVEL 10  // 最大层数
#define MIN_SIZE 8    // 最小内存块大小

// 内存块结构体
typedef struct buddy_block {
    int level;             // 当前层数
    int is_free;           // 是否空闲
    struct buddy_block *next;  // 下一个内存块
} buddy_block;

// 内存池结构体
typedef struct buddy_pool {
    int size;             // 内存池大小
    int max_level;        // 最大层数
    buddy_block *blocks;  // 内存块数组
} buddy_pool;

// 初始化内存池
void init_buddy_pool(buddy_pool *pool, int size) {
    int i, block_size;
    pool->size = size;
    pool->max_level = log2(size) - log2(MIN_SIZE) + 1;
    pool->blocks = (buddy_block *) malloc(sizeof(buddy_block) * size);
    for (i = 0; i < size; i++) {
        pool->blocks[i].level = -1;
        pool->blocks[i].is_free = 1;
        pool->blocks[i].next = NULL;
    }
    // 初始化每个层级的内存块
    for (i = 0; i < pool->max_level; i++) {
        block_size = pow(2, i + log2(MIN_SIZE));
        pool->blocks[size / block_size].level = i;
        pool->blocks[size / block_size].is_free = 1;
        pool->blocks[size / block_size].next = NULL;
    }
}

// 分配内存块
void *buddy_alloc(buddy_pool *pool, int size) {
    int i, level = ceil(log2(size)) - log2(MIN_SIZE);
    if (level >= pool->max_level) {
        return NULL;
    }
    // 在当前及以上层级查找空闲块
    for (i = level; i <= pool->max_level; i++) {
        if (pool->blocks[pool->size / pow(2, i)].is_free == 1) {
            break;
        }
    }
    // 没有找到空闲块
    if (i > pool->max_level) {
        return NULL;
    } else {
        // 分裂块
        while (i > level) {
            buddy_block *block = &pool->blocks[pool->size / pow(2, i)];
            block->is_free = 0;
            // 将块分裂为左右两块
            block->next = &pool->blocks[pool->size / pow(2, i - 1)];
            i--;
        }
        buddy_block *block = &pool->blocks[pool->size / pow(2, level)];
        block->is_free = 0;
        return (void *) block;
    }
}

// 释放内存块
void buddy_free(buddy_pool *pool, void *ptr) {
    buddy_block *block = (buddy_block *) ptr;
    block->is_free = 1;
    // 合并块
    while (block->level < pool->max_level) {
        buddy_block *buddy = block->next;
        if (buddy->is_free == 0 || buddy->level != block->level) {
            break;
        }
        // 合并块
        block->next = buddy->next;
        block = &pool->blocks[pool->size / pow(2, block->level + 1)];
        block->level = buddy->level + 1;
    }
}

// 打印内存池状态
void print_buddy_pool(buddy_pool *pool) {
    int i, level = -1;
    for (i = 0; i < pool->size; i++) {
        if (pool->blocks[i].level != level) {
            level = pool->blocks[i].level;
            printf("\nLevel %d:\n", level);
        }
        printf("%d ", pool->blocks[i].is_free);
    }
    printf("\n");
}

int main() {
    buddy_pool pool;
    init_buddy_pool(&pool, 128);
    void *p1 = buddy_alloc(&pool, 16);
    void *p2 = buddy_alloc(&pool, 64);
    void *p3 = buddy_alloc(&pool, 32);
    print_buddy_pool(&pool);
    buddy_free(&pool, p2);
    buddy_free(&pool, p3);
    print_buddy_pool(&pool);
    return 0;
}

在上面的代码中，我们使用buddy_block结构体表示内存块，其中level表示当前块所在的层数，is_free表示该块是否空闲，next表示该块的下一个块。buddy_pool结构体表示内存池，其中size表示内存池大小，max_level表示最大层数，blocks表示内存块数组。

在初始化内存池时，我们根据内存池大小和最小内存块大小计算出最大层数，然后初始化每个层级的内存块。在分配内存块时，我们根据请求的内存大小计算出所需的层数，然后在当前及以上层级查找空闲块，如果没有找到，则返回NULL；如果找到，则将块分裂为左右两块，直到分裂到所需层数。在释放内存块时，我们将块标记为空闲，并尝试合并块，直到无法再合并为止。在打印内存池状态时，我们根据块的层数将块分组，并打印出每个块的空闲状态。

这是一个简单的Buddy System的C语言实现，具有基本的分配和释放功能。在实际使用时，需要根据具体情况进行调整和优化。