Alocadores Customizados em Zig — Estratégias Avançadas de Memória

O sistema de alocadores do Zig é um dos seus diferenciais mais importantes. Em vez de ter um alocador global oculto (como malloc em C ou o GC em linguagens gerenciadas), o Zig exige que todo código que aloca memória receba um alocador explicitamente como parâmetro. Isso traz transparência, testabilidade e a capacidade de escolher a estratégia de alocação ideal para cada caso de uso.

A Interface do Allocator

Todo alocador em Zig implementa a mesma interface std.mem.Allocator:

const std = @import("std");

// Qualquer função que aloca memória recebe o alocador
fn processarDados(allocator: std.mem.Allocator, dados: []const u8) ![]u8 {
    var resultado = try allocator.alloc(u8, dados.len * 2);
    // ... processar ...
    return resultado;
}

// O chamador decide qual alocador usar
pub fn main() !void {
    // Opção 1: General Purpose Allocator
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();

    const resultado = try processarDados(gpa.allocator(), "dados");
    defer gpa.allocator().free(resultado);
}

Alocadores da Biblioteca Padrão

GeneralPurposeAllocator (GPA)

O alocador de uso geral, recomendado para a maioria dos casos:

var gpa = std.heap.GeneralPurposeAllocator(.{
    .safety = true,              // Detecta erros (double free, use after free)
    .thread_safety = .safe,      // Thread-safe
    .never_unmap = false,        // Retorna memória ao OS
    .stack_trace_frames = 10,    // Stack traces para debug
}){};
defer {
    const status = gpa.deinit();
    if (status == .leak) {
        std.debug.print("Memory leak detectado!\n", .{});
    }
}

const allocator = gpa.allocator();

var lista = std.ArrayList(u8).init(allocator);
defer lista.deinit();

ArenaAllocator

Ideal para alocações temporárias que podem ser liberadas em bloco:

pub fn processarRequisicao(request: Request) !Response {
    // Todas as alocações são liberadas de uma vez ao final
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit(); // Libera TUDO de uma vez

    const allocator = arena.allocator();

    // Alocações múltiplas sem preocupação individual
    const path = try allocator.dupe(u8, request.path);
    const headers = try parseHeaders(allocator, request.raw_headers);
    const body = try processarBody(allocator, request.body);

    // Construir resposta (sem necessidade de free individual)
    return Response{
        .status = 200,
        .body = try gerarResposta(allocator, path, headers, body),
    };
    // arena.deinit() libera tudo automaticamente
}

FixedBufferAllocator

Aloca a partir de um buffer fixo, sem recorrer ao OS:

// Perfeito para embarcados e situações sem heap
var buf: [4096]u8 = undefined;
var fba = std.heap.FixedBufferAllocator.init(&buf);
const allocator = fba.allocator();

// Alocações limitadas ao tamanho do buffer
var dados = try allocator.alloc(u8, 100);
allocator.free(dados);

page_allocator

Aloca diretamente do sistema operacional em páginas:

const allocator = std.heap.page_allocator;

// Cada alocação é pelo menos uma página (4KB no Linux)
var dados = try allocator.alloc(u8, 8192);
defer allocator.free(dados);

c_allocator

Wrapper sobre malloc/free do C, útil para interoperabilidade:

const allocator = std.heap.c_allocator;

// Usa malloc/free internamente
var dados = try allocator.alloc(u8, 1024);
defer allocator.free(dados);