CKTIS / C++
Localidad de caché en C++: AoS y SoA
Elige la disposición de los datos según lo que realmente lee el programa. AoS agrupa los campos de un registro; SoA agrupa los valores del mismo campo de varios registros.
Versión: ISO C++23; implementation support may vary
Sintaxis
// AoS: one contiguous array of records
std::array<Record, N> rows; // access: rows[i].score
// SoA: one contiguous array per field
struct Columns {
std::array<int, N> score;
std::array<int, N> id;
};
Columns cols; // access: cols.score[i]
// Record and N must be defined; initialize values before reading.El diseño orientado a datos parte de las operaciones más frecuentes: ¿qué campos se leen juntos, en qué orden y con qué frecuencia? La localidad de caché consiste en acceder a posiciones de memoria cercanas (localidad espacial) o volver a usar pronto los mismos datos (localidad temporal). La disposición de los datos influye directamente en la localidad espacial.
Un array de estructuras (AoS) almacena los registros consecutivos en una secuencia contigua; rows[i].score es un campo del registro i. Los campos score consecutivos están separados por sizeof(Record) bytes, incluido el posible relleno. Una estructura de arrays (SoA) almacena cada campo en su propia columna contigua; cols.score[i] y cols.id[i] pertenecen al mismo registro lógico. Mantén los índices sincronizados en todas las columnas al redimensionar o reordenar.
Recorrer secuencialmente solo la columna score, de uso frecuente, en SoA puede hacer que quepan más valores útiles por línea de caché y reducir la carga de datos que no se usan. AoS puede encajar mejor cuando una operación usa juntos muchos campos de cada registro. C++23 garantiza que los elementos de std::array son contiguos, pero no fija el tamaño de una línea de caché ni garantiza una mejora de velocidad.
Mide ambas disposiciones con tamaños de datos y patrones de acceso representativos, en una compilación optimizada y en el hardware de destino. Incluye el coste de conversión o indícalo por separado: las copias y el espacio adicional pueden anular las ventajas de recorridos posteriores.
Ejemplos
#include <array>
#include <cstddef>
#include <iostream>
struct Record {
int score;
int id;
};
template<std::size_t N>
struct Columns {
std::array<int, N> score;
std::array<int, N> id;
};
int main() {
const std::array<Record, 3> rows{Record{3, 101}, Record{5, 102}, Record{7, 103}};
Columns<3> cols{};
for (std::size_t i = 0; i < rows.size(); ++i) {
cols.score[i] = rows[i].score;
cols.id[i] = rows[i].id;
}
int aos_sum = 0;
for (const Record& row : rows) {
aos_sum += row.score;
}
int soa_sum = 0;
for (int score : cols.score) {
soa_sum += score;
}
std::cout << "AoS sum: " << aos_sum << '\n'
<< "SoA sum: " << soa_sum << '\n';
}
Resultado
AoS sum: 15 SoA sum: 15
El programa copia ambos campos de `rows` a `cols` y suma solo `score` en cada disposición. Ambas sumas dan 15. El ejemplo muestra la disposición de los datos; no mide el rendimiento.
Lecciones relacionadas
- C++ · Lección 21 · Avanzado · Versión: 3