Um alocador bump simples
Distribua memória linearmente.
Um alocador bump simples é uma aula grátis de C Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C Academy inclui 4 aulas no total.
A ideia do alocador bump
Um alocador bump (ou de arena) é o design mais simples. Você mantém um buffer grande e um único deslocamento. Cada alocação apenas retorna o deslocamento atual e depois o "avança" pelo tamanho solicitado.
Não há metadados por bloco nem busca. A alocação é essencialmente uma única soma de ponteiros, o que a torna extremamente rápida.
Um buffer estático de apoio
Para um exemplo independente, usamos um vetor estático como base do alocador, em vez do heap do OS. O programa compila e é executado em qualquer lugar, sem sbrk ou mmap.
O vetor nos fornece um conjunto fixo de bytes para dividir.
#define POOL_SIZE 1024
static unsigned char pool[POOL_SIZE];
static size_t offset = 0;A função bump principal
A alocação verifica se ainda há espaço suficiente, registra o início, avança o deslocamento e retorna o ponteiro inicial. Se a solicitação ultrapassar o conjunto disponível, retorna NULL.
Essa verificação de excesso é a única proteção oferecida pelo alocador bump.
void *bump_alloc(size_t size) {
if (offset + size > POOL_SIZE)
return NULL; /* out of pool */
void *p = &pool[offset];
offset += size;
return p;
}Um alocador bump completo e executável
Aqui está um programa completo. Ele aloca dois inteiros e uma string curta do conjunto disponível e os imprime, comprovando que o alocador funciona.
Observe como ele exige pouco código em comparação com um malloc real.
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#define POOL_SIZE 1024
static unsigned char pool[POOL_SIZE];
static size_t offset = 0;
void *bump_alloc(size_t size) {
if (offset + size > POOL_SIZE) return NULL;
void *p = &pool[offset];
offset += size;
return p;
}
int main(void) {
int *a = bump_alloc(sizeof(int));
int *b = bump_alloc(sizeof(int));
char *s = bump_alloc(6);
*a = 10; *b = 32;
strcpy(s, "hi");
printf("%d %d %s\n", *a, *b, s);
printf("used = %zu\n", offset);
return 0;
}Sem liberação individual
O problema é que um alocador bump não pode liberar uma única alocação. Como não há metadados, ele não sabe onde um bloco termina e o próximo começa para poder reutilizá-los.
Você só pode redefinir toda a arena de uma vez, definindo o deslocamento novamente como zero.
void bump_reset(void) {
offset = 0; /* frees everything at once */
}Por que redefinir é útil
Esse modelo de tudo ou nada é perfeito para trabalhos divididos em fases: aloque muitos objetos durante uma solicitação ou quadro e depois redefina a arena quando a fase terminar.
Motores de jogos e compiladores usam arenas intensamente porque redefini-las custa O(1) e evita acompanhar milhares de liberações individuais.
/* Per-frame pattern */
for (int frame = 0; frame < 3; frame++) {
void *tmp = bump_alloc(128);
/* ... use tmp this frame ... */
bump_reset(); /* reclaim instantly */
}Acompanhamento do Espaço Restante
É útil expor quanto espaço ainda resta. Isso é simplesmente o tamanho do pool menos o deslocamento atual.
Os chamadores podem usar esse valor para decidir se devem liberar ou aumentar o pool antes de solicitar mais espaço.
size_t bump_remaining(void) {
return POOL_SIZE - offset;
}Uma Demonstração Executável de Redefinição
Este programa preenche parte do pool, imprime o uso, faz a redefinição e mostra o deslocamento retornando a zero, para que o espaço possa ser reutilizado.
#include <stdio.h>
#include <stddef.h>
#define POOL_SIZE 256
static unsigned char pool[POOL_SIZE];
static size_t offset = 0;
void *bump_alloc(size_t s){ if(offset+s>POOL_SIZE) return NULL; void *p=&pool[offset]; offset+=s; return p; }
void bump_reset(void){ offset = 0; }
int main(void) {
bump_alloc(100);
printf("after alloc: used=%zu\n", offset);
bump_reset();
printf("after reset: used=%zu\n", offset);
return 0;
}Alinhamento em um Alocador bump
O incremento bruto byte a byte pode retornar ponteiros desalinhados. Para garantir a segurança, arredonde o deslocamento para cima até um limite de alinhamento antes de retornar um ponteiro.
Abordaremos a matemática em detalhes mais adiante, mas o alinhamento é especialmente importante no alocador bump, pois, caso contrário, não há preenchimento.
static size_t align_up(size_t n, size_t a) {
return (n + a - 1) & ~(a - 1); /* a must be power of 2 */
}Um Alocador bump Alinhado
Combinando as partes, alinhamos o deslocamento antes de cada alocação. Isso garante que todo ponteiro retornado seja adequado para qualquer tipo comum.
O custo é uma pequena fragmentação interna causada pelos bytes de preenchimento.
#define ALIGN 16
void *bump_aligned(size_t size) {
offset = align_up(offset, ALIGN);
if (offset + size > POOL_SIZE) return NULL;
void *p = &pool[offset];
offset += size;
return p;
}Pontos Fortes e Limitações
Os alocadores bump são incomparavelmente rápidos e trivialmente simples, com zero sobrecarga por objeto. Eles são ideais quando os objetos compartilham um tempo de vida.
O ponto fraco é a falta de liberação individual. Quando os tempos de vida diferem, é necessário usar o projeto de lista livre abordado na próxima lição.
Verificação Rápida
Considere como um alocador bump recupera memória.
Recapitulação
Um alocador bump fornece memória avançando um único deslocamento por um buffer, tornando a alocação tão barata quanto uma soma de ponteiros.
Ele troca a liberação individual por velocidade e simplicidade, recuperando memória somente por meio de uma redefinição completa. Alinhe o deslocamento para manter válidos os ponteiros retornados para todos os tipos.
Perguntas Frequentes
A aula “Um alocador bump simples” é grátis?
Sim — o texto completo de “Um alocador bump simples” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C Academy, atualize para CoddyKit PRO. O curso de C Academy inclui 4 aulas no total.
O que vou aprender em “Um alocador bump simples”?
Distribua memória linearmente. Você pratica C Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar C Academy?
Nenhuma experiência prévia é necessária. C Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Um alocador bump simples”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de C Academy?
Sim. Cada aula de C Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Como funciona malloc
- Um alocador bump simples
- Listas livres e reutilização
- Alinhamento e divisão