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.
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.
- 01 Nota do PageSpeed influencia o SEO? 100/100 e reprovado O Google não usa a nota de 0 a 100 do PageSpeed no ranking, e sim os Core Web Vitals de usuários reais. Veja por que dá 100/100 e reprova no campo.
- 02 Teste unitário vs teste de integração: diferença na prática A diferença entre teste unitário e de integração com exemplos de API e banco de dados: o que cada um pega, quanto custa e quando usar cada um no seu projeto.