Diseños de datos favorables a la caché
Diseñe estructuras de arrays y empaquete los datos para favorecer la localidad de caché.
Diseños de datos favorables a la caché es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.
La jerarquía de memoria
Las CPU tienen varios niveles de caché (L1, L2, L3), mucho más rápidos que la memoria principal. El código que aprovecha la caché mantiene los datos activos cerca de la CPU.
Líneas de caché
La memoria se obtiene en líneas de caché, normalmente de 64 bytes. Leer un byte carga la línea completa. Aproveche este comportamiento.
Localidad de referencia
Hay dos propiedades importantes:
- Localidad espacial: utilizar pronto la memoria cercana
- Localidad temporal: reutilizar pronto la misma memoria
Contiguos frente a enlazados
Los vectores almacenan los datos de forma contigua, por lo que iterar sobre ellos aprovecha la caché. Las listas enlazadas dispersan la memoria y provocan fallos de caché en cada paso.
// 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 frente a SoA
Hay dos disposiciones para arrays de registros:
- AoS (Array of Structs): natural, pero al iterar sobre un campo se accede a todos los campos
- SoA (Struct of Arrays): mejor cuando la mayoría de los bucles utiliza solo algunos 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;
};Empaquetado de estructuras
Ordene los miembros del más grande al más pequeño para minimizar el relleno. Herramientas como pahole muestran la disposición real.
struct Bad { char c; double d; char c2; }; // padded
struct Good { double d; char c; char c2; }; // smallerCompartición falsa
Cuando dos subprocesos escriben en variables distintas de la misma línea de caché, invalidan las cachés del otro. Esto resulta catastrófico para el rendimiento. Añada relleno hasta 64 bytes.
struct alignas(64) Counter {
std::atomic<int> value;
};Separación de datos activos e inactivos
Separe los datos activos (a los que se accede con frecuencia) de los inactivos (a los que se accede rara vez) en estructuras diferentes. La CPU solo almacena en caché la parte activa.
Asignación anticipada
Asigne los vectores por anticipado con reserve para evitar realocaciones repetidas. Cada realocación copia todos los elementos, lo que resulta costoso y provoca muchos fallos de caché.
Gana el acceso secuencial
Los recorridos lineales de arrays son los más rápidos. El precargador de hardware predice y carga automáticamente las siguientes líneas de caché.
Evite la indirección
Los punteros obligan a la CPU a seguir dependencias. std::vector<T*> es más lento que std::vector<T> al recorrerlo. Utilice la indirección solo cuando sea necesario.
Perfile antes de optimizar
«Amigable con la caché» es una orientación, no una regla. Mida con herramientas como perf o VTune para comprobar dónde perjudican los fallos de caché y, después, optimice.
Comprobación rápida
¿Por qué iterar sobre un std::vector suele ser mucho más rápido que iterar sobre un std::list del mismo tamaño?
Resumen
Las CPU modernas dependen de las cachés. Prefiera contenedores contiguos, utilice SoA para acceder selectivamente a los campos, empaquete las estructuras, evite la compartición falsa y perfile los fallos de caché con perf o VTune para encontrar los puntos críticos.
Preguntas frecuentes
¿La lección «Diseños de datos favorables a la caché» es gratis?
Sí — el texto completo de «Diseños de datos favorables a la caché» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Diseños de datos favorables a la caché»?
Diseñe estructuras de arrays y empaquete los datos para favorecer la localidad de caché. Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C++ Academy?
No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Diseños de datos favorables a la caché»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C++ Academy?
Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Diseños de datos favorables a la caché
- Predicción de saltos y bucles críticos
- Perfilado con perf, VTune y sanitizers
- Microbenchmarking con Google Benchmark