69天探索操作系统-第65天：为内核操作构建可扩展和线程安全的内存分配器

1. 介绍

在内核级别实现自定义堆是一项具有挑战性的任务，需要深入理解内存管理原理。目标是创建一个内存分配器，该分配器能够高效地管理内存块，同时最小化碎片并确保线程安全。本指南探讨了构建高性能内存分配器的架构、实现和优化技术。分配器必须处理小和大内存分配，管理空闲列表，并确保缓存友好的内存访问模式。

这里讨论的自定义堆实现旨在高效且可扩展。它结合了空闲列表、大小类和内存合并来管理内存块。分配器还包括调试功能，用于跟踪内存分配和释放，这对于诊断内存相关问题非常有价值。在本指南结束时，您将全面了解如何设计和实现适用于内核级操作的自定义内存分配器。

2. 内存分配器架构

内存分配器的架构围绕几个核心组件构建。首先是块管理，涉及跟踪和组织内存块。每个内存块包含元数据，如大小、分配状态和对齐要求。元数据存储在头部和尾部，用于边界管理和合并操作。合并是将相邻的空闲块合并在一起的过程，以减少碎片。

另一个关键组件是空闲列表管理。分配器使用多个空闲列表，每个列表对应一个特定的尺寸类别。这种方法通过确保内存请求从最合适的列表中满足，从而减少碎片并加快分配速度。分配器还直接与系统的物理内存管理交互，针对小和大分配使用不同的策略。小分配使用slab分配器处理，而大分配则通过直接内存映射进行管理。

3. 自定义内存分配器的实现

实现过程从定义block_header结构开始，该结构包含每个内存块的元数据。这包括块的大小、分配状态以及指向空闲列表中下一个和前一个块的指针。heap_allocator结构管理空闲列表并跟踪总内存和已使用内存。

c 复制代码

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/mm.h>
#include <linux/spinlock.h>
#include <linux/list.h>

#define HEAP_MAGIC 0xDEADBEEF
#define MIN_BLOCK_SIZE 32
#define MAX_SMALL_ALLOCATION 4096
#define NUM_SIZE_CLASSES 32

struct block_header {
    unsigned long magic;
    size_t size;
    unsigned int is_free:1;
    unsigned int has_prev:1;
    struct block_header *next;
    struct block_header *prev;
    unsigned long padding;
} __attribute__((aligned(16)));

struct heap_allocator {
    struct block_header *free_lists[NUM_SIZE_CLASSES];
    spinlock_t lock;
    unsigned long total_memory;
    unsigned long used_memory;
    struct list_head large_blocks;
};

static struct heap_allocator allocator;

size_class_index 函数计算给定分配大小的适当大小类。这确保内存请求能够被适当的空闲列表高效处理。

c 复制代码

static inline int size_class_index(size_t size)
{
    size_t adjusted_size = size - 1;
    return fls(adjusted_size) - 5;
}

create_block 函数分配一个新的内存块。对于小分配，它使用 kmalloc，而对于大分配，它使用 vmalloc。

c 复制代码

static struct block_header *create_block(size_t size)
{
    struct block_header *block;
    size_t total_size = size + sizeof(struct block_header);
    
    if (size > MAX_SMALL_ALLOCATION) {
        block = vmalloc(total_size);
    } else {
        block = kmalloc(total_size, GFP_KERNEL);
    }
    
    if (!block)
        return NULL;
        
    block->magic = HEAP_MAGIC;
    block->size = size;
    block->is_free = 1;
    block->has_prev = 0;
    block->next = NULL;
    block->prev = NULL;
    
    return block;
}

heap_alloc 函数负责分配内存。它首先对请求的大小进行对齐，然后搜索适当的空闲列表以找到合适的块。如果没有找到合适的块，它会创建一个新的块并将其插入到空闲列表中

c 复制代码

static void *heap_alloc(size_t size)
{
    struct block_header *block;
    int index;
    unsigned long flags;
    
    size = ALIGN(size, 16);
    if (size > MAX_SMALL_ALLOCATION)
        return allocate_large_block(size);
        
    index = size_class_index(size);
    
    spin_lock_irqsave(&allocator.lock, flags);
    
    block = find_free_block(index, size);
    if (!block) {
        block = create_block(size);
        if (!block) {
            spin_unlock_irqrestore(&allocator.lock, flags);
            return NULL;
        }
        insert_into_free_list(block, index);
    }
    
    split_block_if_needed(block, size);
    block->is_free = 0;
    allocator.used_memory += size;
    
    spin_unlock_irqrestore(&allocator.lock, flags);
    
    return (void *)(block + 1);
}

4. 块管理和合并

coalesce_blocks 函数将相邻的空闲块合并以减少碎片。它会检查前一个和下一个块是否为空闲块，如果是，则将它们与当前块合并。

c 复制代码

static void coalesce_blocks(struct block_header *block)
{
    struct block_header *next_block;
    struct block_header *prev_block;
    
    if (!block->is_free)
        return;
        
    next_block = (struct block_header *)((char *)block + block->size + 
                                       sizeof(struct block_header));
                                       
    if (block->has_prev) {
        prev_block = block->prev;
        if (prev_block->is_free) {
            remove_from_free_list(prev_block);
            prev_block->size += block->size + sizeof(struct block_header);
            prev_block->next = block->next;
            if (block->next)
                block->next->prev = prev_block;
            block = prev_block;
        }
    }
    
    if (next_block && next_block->is_free) {
        remove_from_free_list(next_block);
        block->size += next_block->size + sizeof(struct block_header);
        block->next = next_block->next;
        if (next_block->next)
            next_block->next->prev = block;
    }
}

5. 内存管理流程

内存管理流程通过序列图进行说明。该图展示了应用程序、分配器、空闲列表和物理内存之间的交互。

6. 缓存友好实现

分配器包括一个缓存友好的实现，以优化内存访问模式。cache_aligned_block 结构确保内存块对齐到缓存行边界。

c 复制代码

struct cache_aligned_block {
    struct block_header header;
    unsigned char data[0] __attribute__((aligned(64)));
};

static void *cache_aligned_alloc(size_t size)
{
    struct cache_aligned_block *block;
    size_t aligned_size;
    
    aligned_size = ALIGN(size, 64);
    block = heap_alloc(sizeof(struct cache_aligned_block) + aligned_size);
    
    if (!block)
        return NULL;
        
    return block->data;
}

7. 调试支持

分配器包括调试功能，用于跟踪内存分配和释放。allocation_trace 结构存储有关每次分配的信息。

c 复制代码

struct allocation_trace {
    void *ptr;
    size_t size;
    unsigned long timestamp;
    pid_t pid;
    char task_name[TASK_COMM_LEN];
};

static struct allocation_trace *trace_buffer;
static atomic_t trace_index;

static void record_allocation(void *ptr, size_t size)
{
    int index = atomic_inc_return(&trace_index) % TRACE_BUFFER_SIZE;
    struct allocation_trace *trace = &trace_buffer[index];
    
    trace->ptr = ptr;
    trace->size = size;
    trace->timestamp = ktime_get_real_ns();
    trace->pid = current->pid;
    memcpy(trace->task_name, current->comm, TASK_COMM_LEN);
}

8. 内存布局可视化

分配器的内存布局通过图表进行可视化。图表展示了堆起始、大小类和内存块之间的关系

9. 性能指标

分配器包括性能指标以跟踪其操作。allocator_stats 结构存储了诸如分配和释放的总次数等指标。

c 复制代码

struct allocator_stats {
    atomic64_t total_allocations;
    atomic64_t total_frees;
    atomic64_t fragmentation_bytes;
    atomic64_t cache_misses;
    struct {
        atomic_t count;
        atomic64_t total_size;
    } size_classes[NUM_SIZE_CLASSES];
};

static struct allocator_stats stats;

static void update_stats(size_t size, int is_alloc)
{
    int index = size_class_index(size);
    
    if (is_alloc) {
        atomic64_inc(&stats.total_allocations);
        atomic_inc(&stats.size_classes[index].count);
        atomic64_add(size, &stats.size_classes[index].total_size);
    } else {
        atomic64_inc(&stats.total_frees);
        atomic_dec(&stats.size_classes[index].count);
        atomic64_sub(size, &stats.size_classes[index].total_size);
    }
}

10. 结论

在内核级别实现自定义堆是一项具有挑战性的任务，需要仔细考虑各种因素，包括碎片、线程安全和缓存效率。本指南中讨论的分配器使用自由列表、大小类和内存合并的组合来高效地管理内存块。它还包括调试功能和性能指标，用于跟踪内存使用情况并优化性能。

自定义堆实现旨在高效且可扩展，使其适用于内核级操作。通过遵循本指南中讨论的原则和技术，您可以构建一个高性能的内存分配器，以满足现代应用的需求。