Organizações de dados favoráveis à cache
Projete estruturas de matrizes e agrupe dados para favorecer a localidade da cache
Organizações de dados favoráveis à cache é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 1 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 hierarquia da memória
As CPUs têm vários níveis de memória cache (L1, L2, L3), muito mais rápidos que a memória principal. O código que favorece a cache mantém os dados ativos próximos da CPU.
Linhas de cache
A memória é buscada em linhas de cache — normalmente com 64 bytes. Ler um byte carrega a linha inteira. Use isso a seu favor.
Localidade de referência
Duas propriedades importantes:
- Localidade espacial — usar em breve uma memória próxima
- Localidade temporal — reutilizar em breve a mesma memória
Contíguo versus encadeado
Os vetores armazenam os dados de forma contígua — percorrê-los favorece a cache. As listas encadeadas espalham a memória, prejudicando a cache a cada etapa.
// Cache friendly
std::vector<int> v(1000);
for (auto& x : v) ++x;
// Cache UNfriendly
std::list<int> l(1000);
for (auto& x : l) ++x;AoS versus SoA
Dois layouts para vetores de registros:
- AoS (vetor de estruturas) — natural, mas percorrer um campo acessa todos os campos
- SoA (estrutura de vetores) — melhor quando a maioria dos laços usa apenas alguns campos
// AoS
struct Particle { float x, y, z, vx, vy, vz; };
std::vector<Particle> particles;
// SoA
struct Particles {
std::vector<float> x, y, z, vx, vy, vz;
};Empacotamento de estruturas
Ordene os membros do maior para o menor para minimizar o preenchimento. Ferramentas como pahole mostram o layout real.
struct Bad { char c; double d; char c2; }; // padded
struct Good { double d; char c; char c2; }; // smallerCompartilhamento falso
Dois threads que escrevem em variáveis diferentes na mesma linha de cache invalidam as memórias cache um do outro. Isso é catastrófico para o desempenho. Adicione preenchimento até 64 bytes.
struct alignas(64) Counter {
std::atomic<int> value;
};Separação de dados quentes e frios
Separe os dados quentes (acessados frequentemente) dos dados frios (acessados raramente) em estruturas diferentes. A CPU armazena em cache apenas a parte quente.
Pré-alocação
Pré-aloque vetores com reserve para evitar realocações repetidas. Cada realocação copia todos os elementos — é dispendiosa e prejudica a cache.
O acesso sequencial é mais rápido
As varreduras lineares em vetores são as mais rápidas. O pré-buscador do hardware prevê e carrega automaticamente as próximas linhas de cache.
Evite a indireção
Os ponteiros obrigam a CPU a seguir dependências. std::vector<T*> é mais lento que std::vector<T> durante a travessia. Use indireção apenas quando necessário.
Analise o desempenho antes de otimizar
"Favorável à cache" é uma orientação, não uma regra. Meça com ferramentas como perf ou VTune para ver onde as falhas de cache prejudicam o desempenho — depois otimize.
Verificação rápida
Por que percorrer um std::vector normalmente é muito mais rápido do que percorrer um std::list do mesmo tamanho?
Recapitulação
As CPUs modernas dependem de memórias cache. Prefira contêineres contíguos, use SoA para acesso seletivo aos campos, empacote as estruturas, evite o compartilhamento falso e analise as falhas de cache com perf ou VTune para encontrar os pontos críticos.
Perguntas Frequentes
A aula “Organizações de dados favoráveis à cache” é grátis?
Sim — o texto completo de “Organizações de dados favoráveis à cache” é 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 “Organizações de dados favoráveis à cache”?
Projete estruturas de matrizes e agrupe dados para favorecer a localidade da cache 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 1 de 4.
Quanto tempo leva a aula “Organizações de dados favoráveis à cache”?
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
- Organizações de dados favoráveis à cache
- Previsão de ramificações e ciclos intensivos
- Criação de perfis com perf, vtune e Sanitizers
- Microavaliação de desempenho com Google Benchmark