Todos os artigos
176 artigos · atualizado semanalmente Veja nossas Ferramentas
Todos os artigos
Tutoriais

Hierarquia de memória: cache, RAM e disco na prática

Registradores, cache, RAM e disco: veja a latência de cada nível, por que a RAM é volátil e o que acontece quando ela acaba e o sistema recorre ao swap.

Hierarquia de memória: cache, RAM e disco na prática
COVER · Tutoriais

Seu computador ficou lento depois de abrir o décimo terminal, três abas do Chrome e o VS Code com um projeto grande. Você culpou o processador, depois o SSD, e o gargalo era a RAM: ocupada quase toda, o sistema começou a mandar páginas de memória para o disco. Cada acesso que antes levava nanossegundos passou a levar dezenas ou centenas de microssegundos, e o sistema inteiro sentiu.

Para entender por que isso dói tanto, não basta saber o que é memória RAM. É preciso ver onde ela fica na hierarquia de memória, com números de verdade. Este post mede cada nível (cache, RAM, SSD) numa máquina real, explica a diferença entre SRAM e DRAM e mostra, com free, vmstat e um container que estoura a memória de propósito, o que acontece quando a RAM acaba. Quanto de RAM comprar é assunto de outro post: como escolher notebook para programação.

O que é memória RAM, em duas frases

RAM (Random Access Memory) é a memória de trabalho do computador: qualquer endereço pode ser lido ou escrito diretamente, sem percorrer os anteriores, e o conteúdo some quando a energia acaba. Essa volatilidade não é defeito: é o preço da velocidade. O processador não executa nada direto do disco; tudo que roda passa pela RAM, e é por isso que a quantidade e o uso dela determinam quanta coisa você consegue fazer ao mesmo tempo.

A analogia que funciona é a da oficina: o disco é o armário com todas as peças, a RAM é a bancada. Quanto maior a bancada, menos viagens ao armário.

Hierarquia de memória: do registrador ao disco

Entre o processador e os seus dados existem vários níveis, e a regra que organiza todos é simples: quanto mais perto da CPU, menor, mais rápido e mais caro por byte.

  • Registradores: dentro do núcleo, poucas dezenas de valores, acessados no próprio ciclo de clock.
  • Cache L1, L2 e L3: memória SRAM no chip do processador. L1 e L2 são por núcleo; L3 é compartilhado.
  • RAM: módulos DRAM fora do processador, ligados por um barramento de memória.
  • Armazenamento (SSD, HDD): persistente, ordens de grandeza maior e mais lento.

Números de latência costumam ser citados da tabela que Peter Norvig publicou em Teach Yourself Programming in Ten Years (2001, depois popularizada por Jeff Dean): L1 a 0,5 ns, L2 a 7 ns, RAM a 100 ns, seek de disco a 8 ms. São números de duas décadas atrás e sem SSD. Por isso medi os meus.

A máquina: notebook com Intel Core Ultra 7 255HX (48 KB de L1d e 3 MB de L2 por núcleo, 30 MB de L3, segundo o lscpu), 32 GB de DDR5-6400 e SSD NVMe de 512 GB, medindo dentro de um container Docker no WSL2, em novembro de 2026. Para cache e RAM usei pointer chasing: uma lista encadeada embaralhada aleatoriamente, de modo que cada leitura depende da anterior e o prefetcher não consegue adivinhar o próximo endereço. O tempo por salto, em função do tamanho do buffer, mostra cada nível da hierarquia:

/* cada elemento aponta para outro, em ordem aleatória, um por linha de cache (64 bytes) */
for (size_t i = 0; i < iters; i++)
    p = (void **)*p;   /* a próxima leitura depende desta: latência pura */

Para o SSD usei fio com leitura aleatória de 4 KiB, uma requisição por vez (--rw=randread --bs=4k --iodepth=1 --direct=1). Não tenho HDD na máquina, então essa linha é calculada: o seek de 8 ms da tabela do Norvig mais a latência rotacional média de um disco de 7.200 rpm (meia volta: 60 / 7.200 / 2 = 4,17 ms).

Nível Tamanho nesta máquina Latência Norvig (2001) Se 1 ns fosse 1 segundo
Registrador dezenas de valores ~0,2 ns (1 ciclo a ~5 GHz, não medido) não lista 0,2 s
Cache L1 48 KB por núcleo 0,8 ns 0,5 ns 0,8 s
Cache L2 3 MB por núcleo ~5 ns 7 ns 5 s
Cache L3 30 MB ~15 ns não lista 15 s
RAM (DDR5) 32 GB ~150 ns 100 ns 2,5 minutos
SSD NVMe (leitura 4 KiB aleatória) 512 GB ~122 µs (média) não lista 1,4 dia
HDD 7.200 rpm não medido ~12 ms (calculado) 8 ms (só o seek) 141 dias

Dois avisos honestos sobre esses números. A RAM medida (~150 ns com buffer de 256 MB) inclui o custo de falhas de TLB e da camada de virtualização do WSL2, por isso fica acima dos 100 ns clássicos. E a leitura do NVMe passa pelo disco virtual do WSL2: a média foi de 122 µs, com mínimo de 65 µs e metade das leituras abaixo de 100 µs. Os valores absolutos variam de máquina para máquina; as ordens de grandeza, não.

E as ordens de grandeza são o que importa. Na minha medição, a RAM é cerca de 800 vezes mais rápida que o SSD NVMe e cerca de 80.000 vezes mais rápida que o HDD; o L1 é cerca de 190 vezes mais rápido que a RAM. É por isso que o swap é tão perceptível: quando uma página precisa voltar do disco, um acesso que custaria 2,5 minutos na escala humana da última coluna passa a custar um dia e meio. Para entender por que o NVMe é tão mais rápido que o SATA e o HDD, veja SSD SATA vs NVMe.

SRAM vs DRAM: por que o cache é tão pequeno

Cache e RAM são tecnologias diferentes, e isso explica o tamanho de cada um.

O cache é SRAM (static RAM): cada bit é guardado num circuito de vários transistores (a célula clássica tem seis) que mantém o valor enquanto houver energia, sem manutenção. É rápido, mas ocupa muita área de silício por bit. Por isso o L3 de um processador de notebook tem dezenas de megabytes, não gigabytes.

A RAM do PC é DRAM (dynamic RAM): cada bit é a carga de um capacitor minúsculo controlado por um transistor. Cabe muito mais por chip e custa muito menos por byte, mas o capacitor vaza. Cada linha precisa ser lida e regravada periodicamente (o refresh), dentro de uma janela de dezenas de milissegundos: 64 ms no DDR4 e 32 ms no DDR5 em temperatura normal, segundo a especificação resumida na Wikipedia. Somado ao caminho até fora do chip, isso deixa a DRAM uma ordem de grandeza mais lenta que o cache.

A sigla DDR (Double Data Rate) diz que o módulo transfere dados nas duas bordas do clock. DDR4 e DDR5 não são intercambiáveis: o chanfro do pente fica em posição diferente justamente para impedir o encaixe errado, e o DDR5 trabalha com tensão menor (1,1 V contra 1,2 V do DDR4). Em notebook há um detalhe a mais: muitos modelos têm RAM soldada, e aí não existe upgrade nenhum.

Outro ponto que os guias de compra repetem com razão é o dual channel: dois módulos iguais nos slots corretos permitem que o controlador de memória acesse dois canais em paralelo, dobrando a largura de banda teórica. A latência não muda; a quantidade de dados por segundo, sim.

Memória virtual, paginação e swap

O sistema operacional não entrega RAM física diretamente aos programas. Cada processo enxerga o seu próprio espaço de endereços virtual, e o SO mantém, por processo, uma tabela de páginas que traduz endereços virtuais em físicos, em blocos de 4 KB na maioria das configurações. Isso isola processos (um bug num programa não sobrescreve a memória de outro) e dá ao SO liberdade para decidir onde cada página mora.

Quando um processo acessa uma página que não está na RAM, acontece um page fault: o SO busca a página (no executável em disco, no arquivo mapeado ou no swap), coloca na RAM e retoma a execução. Quando a RAM aperta, o SO faz o caminho inverso: escolhe páginas pouco usadas e as despeja, gravando no swap as que não têm cópia em outro lugar.

O SO também usa a RAM sobrando como cache de disco. "RAM livre é RAM desperdiçada" é literal no Linux, e é por isso que o número que importa no free não é free, é available:

$ free -h
               total        used        free      shared  buff/cache   available
Mem:            15Gi       1.7Gi       6.9Gi        30Mi       7.0Gi        13Gi
Swap:          4.0Gi          0B       4.0Gi

(O total de 15 Gi é a fatia de RAM que o WSL2 entrega à VM onde o Docker roda.) Só 6,9 GB livres, mas 13 GB disponíveis: os 7 GB de buff/cache são arquivos em cache que o kernel descarta na hora se um processo precisar da memória. Se o seu monitor mostra a RAM "90% ocupada" e o available está alto, não há problema algum.

O que acontece quando a RAM acaba

O sintoma de RAM insuficiente não é o used alto: é o swap em atividade. O vmstat mostra isso nas colunas si e so (KB/s entrando e saindo do swap). Para ver acontecer sem travar a máquina, rodei um script Python que aloca 100 MB por vez dentro de um container limitado a 512 MB de RAM e 512 MB de swap (--memory=512m --memory-swap=1g), com vmstat 1 ao lado:

 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st gu
 0  0    396 13490188  35080 746456    0      0     0      0 1077 1528  0  1 99  0  0  0
 0  0 124512 13450164  35000 699396  472 123980   760 146272 1786 6040  0  1 99  0  0  0
 0  0 230036 13450220  35000 699368   16 105524    28 105524  676 3979  0  1 99  0  0  0
 0  0 416376 13443968  34992 688032    4 186344     4 186344 1578 1502  0  1 99  0  0  0
 0  0    804 13915276  34696 682472   96 108308   796 108568 2379 3403  0  1 99  0  0  0

Quando o processo passou de 512 MB, o kernel começou a mandar páginas para o swap a 100 a 180 MB/s (so) e o swpd subiu até 416 MB. Pouco depois de 1.000 MB alocados, RAM e swap do container se esgotaram e o processo morreu com código 137 (SIGKILL). O memory.events do cgroup registrou oom_kill 1 e o Docker marcou OOMKilled=true. Na última linha o swap volta a quase zero: a memória do processo morto foi liberada.

Esse é o comportamento do OOM killer do Linux, e ele só entra em ação quando RAM e swap se esgotam, não quando "o disco acaba". O swap é uma partição ou arquivo de tamanho fixo; o espaço livre no resto do disco não conta. A descrição clássica do kernel, no capítulo sobre OOM de Mel Gorman (escrito para o 2.4/2.6), começa exatamente por esse teste: se ainda há swap livre, o sistema não está sem memória. O processo escolhido não é "primeiro os de background": a documentação do /proc explica que cada processo recebe uma pontuação de 0 a 1000 proporcional à fração da memória permitida que ele usa, ajustável por /proc/<pid>/oom_score_adj, e em geral morre o que mais consome. Num container ou serviço com limite de memória, a conta é feita contra o limite do cgroup, como no teste acima.

No Windows o mecanismo é outro. O limite de memória comprometida é a soma da RAM com o arquivo de paginação (pagefile.sys), e um arquivo de paginação gerenciado pelo sistema cresce sozinho quando o uso chega a 90% desse limite, até três vezes a RAM ou 4 GB (o que for maior), se houver espaço em disco, segundo a documentação da Microsoft. Se mesmo assim o limite for atingido, aparece o aviso de memória insuficiente e programas podem travar ou fechar.

Se você trabalha com arquivos que não cabem na memória, o problema é de código, não de hardware: processar arquivos grandes sem estourar a memória mostra como fazer streaming em vez de carregar tudo.

Quando mais RAM ajuda (e quando não ajuda)

Mais RAM resolve quando o vmstat mostra si/so diferentes de zero durante o seu trabalho normal, ou quando o available fica perto de zero: navegador com dezenas de abas, containers Docker, emuladores, VMs, compilação de projetos grandes. Mais RAM não resolve quando o gargalo é CPU (veja núcleos e threads), I/O de disco ou rede. Se a RAM já sobra, mais GB não aceleram nada.

Para programar, a recomendação curta é 16 GB como piso e 32 GB se você vive em containers ou VMs; o raciocínio completo, com notebook de RAM soldada no meio, está em como escolher notebook para programação. Para desenvolvimento, a quantidade de RAM costuma importar mais que a velocidade (MT/s), e vale conferir se os módulos estão em dual channel.

Perguntas frequentes

Qual a diferença entre memória RAM e memória ROM?

ROM (Read-Only Memory) é não volátil: guarda dados sem energia e, na forma clássica, não é reescrita em operação normal. Era onde ficava o firmware, como a BIOS do PC. Hoje o firmware fica em memória flash regravável, mas o papel é o mesmo: guardar o que precisa sobreviver ao desligamento. A RAM é a área de trabalho temporária do processador.

Por que o cache é tão menor que a RAM?

Porque é SRAM, que usa vários transistores por bit e ocupa muito mais área de silício que a DRAM, onde cada bit é um transistor e um capacitor. O cache é rápido justamente por ser pequeno e estar dentro do processador; aumentá-lo muito encareceria o chip e aumentaria a própria latência.

O que acontece quando a RAM acaba?

O sistema passa a usar swap (Linux) ou o arquivo de paginação (Windows) e tudo fica mais lento, porque o disco é centenas a dezenas de milhares de vezes mais lento que a RAM. No Linux, se RAM e swap se esgotam, o OOM killer encerra o processo com maior pontuação, em geral o que mais consome memória. No Windows, o arquivo de paginação gerenciado cresce até um limite e, se não bastar, o sistema avisa de memória insuficiente.

Como saber se o problema do meu PC é falta de RAM?

No Linux, rode vmstat 1 durante o uso normal: si e so constantemente acima de zero indicam swap em atividade, e free -h com available perto de zero confirma. No Windows, a aba Desempenho do Gerenciador de Tarefas mostra a memória "Confirmada" contra o limite. RAM "cheia" com available alto é só cache de disco e não é problema.

A RAM só é lenta quando falta

Os números contam a história inteira: L1 em menos de um nanossegundo, RAM em ~150 ns, SSD em ~120 µs, HDD em ~12 ms. Entre os níveis de cache os degraus são de poucas vezes; da RAM para o SSD, o salto é de quase mil vezes. O swap é o momento em que o seu programa desce dois ou três degraus de uma vez. Antes de comprar RAM, olhe si/so no vmstat e o available no free; antes de culpar o hardware, veja se o código não está carregando na memória o que deveria ler em streaming. E quando o OOM killer aparecer no log, lembre que ele não é o problema: é o aviso de que RAM e swap acabaram.

RD
Autor
Rafael Duarte
Desenvolvedor backend com passagem por fintech e SaaS B2B — trabalhou em times que escalaram APIs de zero a milhões de requisições. Carrega cicatrizes de produção suficientes para ter opiniões fortes sobre ferramentas, padrões e decisões de arquitetura. Não é acadêmico: leu a RFC do UUID quando precisou escolher entre v4 e v7 para uma tabela de alta escrita.
Ver perfil