Знакомы ли вы с аллокатором?

Аллокатор — это компонент, управляющий выделением и освобождением памяти для программы. В большинстве языков высокого уровня (Java, Go) работа с аллокатором скрыта за garbage collector или глобальным хипом. Но в системных языках (C, C++, Rust) мы либо используем стандартный аллокатор (malloc/free, new/delete), либо пишем собственный под конкретные требования.

Стандартный аллокатор (например, malloc в glibc) универсален: он поддерживает произвольные размеры, потоки, гарантирует выравнивание. Но за универсальность платим: фрагментация, латентность из-за поиска свободного блока, затраты на служебные структуры. В high-load сервисах или embedded системах кастомный аллокатор даёт предсказуемую задержку и снижает фрагментацию.

Основные виды кастомных аллокаторов:

• Линейный (Arena, Bump allocator) — выделяет память последовательно, освобождает только всё сразу. Идеален для одноразовых или транзакционных данных.
• Pool allocator — пул объектов фиксированного размера. Освобождение за O(1), нет фрагментации. Часто используется для небольших объектов (например, узлов в дереве).
• Stack allocator — выделяет и освобождает по принципу LIFO. Подходит для вложенных структур.

Пример реализации pool allocator на C++ для объектов размера size:

class PoolAllocator {  
    struct Chunk { Chunk* next; };  
    Chunk* free_list = nullptr;  
    char* memory = nullptr;  
    size_t block_size;  
    size_t alignment;  

public:  
    PoolAllocator(size_t size, size_t align = alignof(std::max_align_t))  
        : block_size((size + align - 1) & ~(align - 1)), alignment(align) {}  

    void init(size_t num_blocks) {  
        memory = static_cast<char*>(std::aligned_alloc(alignment, num_blocks * block_size));  
        for (size_t i = 0; i < num_blocks; ++i) {  
            auto* chunk = reinterpret_cast<Chunk*>(memory + i * block_size);  
            chunk->next = free_list;  
            free_list = chunk;  
        }  
    }  

    void* allocate() {  
        if (!free_list) return nullptr;  
        auto* chunk = free_list;  
        free_list = chunk->next;  
        return chunk;  
    }  

    void deallocate(void* ptr) {  
        auto* chunk = static_cast<Chunk*>(ptr);  
        chunk->next = free_list;  
        free_list = chunk;  
    }  

    ~PoolAllocator() { std::free(memory); }  
};  

В реальных проектах я сталкивался с линейным аллокатором в игровом движке: каждый кадр выделял временные данные, в конце кадра сбрасывал указатель — это дало прирост производительности на 15% и исключило фрагментацию. В Rust аллокатор — это трейт Allocator, можно подменить глобальный аллокатор (например, jemalloc или собственный) через #[global_allocator].

Вывод: знание аллокаторов позволяет писать эффективный системный код, контролировать память и избегать проблем, связанных со стандартным хипом.