---
title: "Page Allocator em Zig — O que é e Como Usar"
url: "https://ziglang.com.br/glossario/page-allocator-em-zig-o-que-%C3%A9-e-como-usar/"
markdown_url: "https://ziglang.com.br/glossario/page-allocator-em-zig-o-que-%C3%A9-e-como-usar.MD"
description: "Entenda o Page Allocator em Zig: alocador que usa páginas do sistema operacional diretamente. Simples, sem fragmentação. Guia completo em pt-BR."
date: "2026-02-21"
author: "Zig Brasil"
---

# Page Allocator em Zig — O que é e Como Usar

Entenda o Page Allocator em Zig: alocador que usa páginas do sistema operacional diretamente. Simples, sem fragmentação. Guia completo em pt-BR.


# Page Allocator em Zig — O que é e Como Usar

## Definição

O **Page Allocator** (`std.heap.page_allocator`) em Zig é o alocador mais simples disponível na biblioteca padrão. Ele solicita memória diretamente ao **sistema operacional** em unidades de páginas (tipicamente 4KB em x86_64). Cada chamada a `alloc` resulta em uma chamada de sistema (`mmap` no Linux, `VirtualAlloc` no Windows).

É o "alocador de último recurso" — confiável e simples, mas não eficiente para alocações pequenas ou frequentes.

## Por que Page Allocator Importa

1. **Simplicidade**: Sem estado interno, sem configuração. Está sempre disponível.
2. **Sem fragmentação**: Cada alocação é independente no espaço de endereçamento.
3. **Base para outros alocadores**: O `ArenaAllocator` e o `GeneralPurposeAllocator` podem usar o page allocator como backend.
4. **Ideal para alocações grandes**: Quando você precisa de buffers de megabytes, é a escolha natural.

## Exemplo Prático

### Uso Básico

```zig
const std = @import("std");

pub fn main() !void {
    const allocator = std.heap.page_allocator;

    // Aloca pelo menos 1 página (4096 bytes no x86_64)
    const buffer = try allocator.alloc(u8, 1000);
    defer allocator.free(buffer);

    @memset(buffer, 'Z');
    std.debug.print("Alocado {} bytes\n", .{buffer.len});
}
```

### Como Backend para Arena

```zig
const std = @import("std");

pub fn main() !void {
    // Arena usa page_allocator como fonte de memória
    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
    defer arena.deinit();

    const allocator = arena.allocator();

    // Muitas alocações pequenas — eficientes com arena
    var i: usize = 0;
    while (i < 1000) : (i += 1) {
        _ = try allocator.alloc(u8, 64);
    }
    // Tudo liberado de uma vez com arena.deinit()
}
```

### Alocação de Buffer Grande

```zig
fn carregarArquivoGrande(caminho: []const u8) ![]u8 {
    const allocator = std.heap.page_allocator;

    const arquivo = try std.fs.cwd().openFile(caminho, .{});
    defer arquivo.close();

    const stat = try arquivo.stat();
    const buffer = try allocator.alloc(u8, stat.size);
    errdefer allocator.free(buffer);

    const lidos = try arquivo.readAll(buffer);
    return buffer[0..lidos];
}
```

### Comparação de Tamanho de Alocação

```zig
const std = @import("std");

pub fn main() !void {
    const allocator = std.heap.page_allocator;

    // Mesmo pedindo 1 byte, o SO aloca uma página inteira (4096)
    const um_byte = try allocator.alloc(u8, 1);
    defer allocator.free(um_byte);

    // Pedindo exatamente uma página
    const uma_pagina = try allocator.alloc(u8, 4096);
    defer allocator.free(uma_pagina);

    std.debug.print("Pedido: 1 byte, recebido: {} bytes\n", .{um_byte.len});
    std.debug.print("Pedido: 4096 bytes, recebido: {} bytes\n", .{uma_pagina.len});
}
```

## Quando Usar Page Allocator

| Situação | Recomendado? |
|----------|-------------|
| Alocações grandes (> 4KB) | Sim |
| Muitas alocações pequenas | Não (use Arena ou GPA) |
| Backend para outros alocadores | Sim |
| Prototipação rápida | Sim |
| Sistemas embarcados | Não (sem SO) |

## Boas Práticas

- **Use como backend, não diretamente**: Na maioria dos programas, use `GeneralPurposeAllocator` ou `ArenaAllocator` que internamente chamam o `page_allocator`. Isso é mais eficiente para alocações pequenas.
- **Para buffers grandes e de vida longa**: Se você está carregando um arquivo inteiro na memória ou alocando um buffer de comunicação de megabytes, o `page_allocator` é adequado.
- **Em testes rápidos e protótipos**: `std.heap.page_allocator` dispensa configuração e é a escolha mais simples para experimentar algo rapidamente.
- **Sempre libere com `defer`**: Chame `defer allocator.free(buffer)` logo após a alocação para evitar vazamentos mesmo em casos de erro.

## Como Funciona Internamente

No Linux, cada chamada a `alloc` chama `mmap` com `MAP_ANONYMOUS | MAP_PRIVATE`. O sistema operacional reserva páginas virtuais que só são mapeadas para memória física quando acessadas (lazy allocation). Isso significa que alocar 1 MB não necessariamente usa 1 MB de RAM imediatamente — apenas quando os bytes são escritos.

No Windows, o equivalente é `VirtualAlloc` com `MEM_COMMIT | MEM_RESERVE`. O comportamento é similar, mas o tamanho mínimo de alocação pode ser maior (tipicamente 64KB por região).

Quando `free` é chamado, o Zig emite `munmap` (Linux) ou `VirtualFree` (Windows), devolvendo as páginas ao sistema operacional imediatamente — diferente de `malloc/free` do C, que mantém as páginas em um pool interno.

## Armadilhas Comuns

- **Desperdício para alocações pequenas**: Pedir 1 byte aloca uma página inteira (4096 bytes). Para dados pequenos, use `GeneralPurposeAllocator` ou `ArenaAllocator`.
- **Performance em alocações frequentes**: Cada `alloc`/`free` é uma syscall. Para muitas alocações, use um alocador que faz buffering.
- **Não disponível em freestanding**: Em plataformas sem SO (embarcados), não há page allocator. Use `FixedBufferAllocator`.
- **Alinhamento fixo**: O page allocator sempre alinha a páginas. Isso é mais que suficiente para qualquer tipo de dado.

## Termos Relacionados

- [Allocator](/glossario/allocator/) — Interface de alocação de memória
- [Arena Allocator](/glossario/arena-allocator/) — Alocador de arena
- [General Purpose Allocator](/glossario/general-purpose-allocator/) — Alocador de uso geral
- [Fixed Buffer Allocator](/glossario/fixed-buffer-allocator/) — Alocador com buffer fixo
- [Stack vs Heap](/glossario/stack-vs-heap/) — Diferença entre pilha e heap

## Tutoriais Relacionados

- [Gerenciamento de Memória em Zig](/tutoriais/gerenciamento-de-memoria-zig/)
- [Introdução ao Zig](/tutoriais/introducao-ao-zig/)