CKTIS / C++
Diseño orientado a datos: AoS, SoA y localidad de caché
Elige la disposición según cómo usa los datos el programa: compara los registros completos con las columnas separadas y mide el efecto con una carga representativa.
Versión: ISO C++23; implementation support may vary
Sintaxis
// ISO C++23 — alternative layouts for N records
// T and U are field types; N is a compile-time element count.
#include <array>
#include <cstddef>
template<class T, class U>
struct Record { T x; U y; };
template<class T, class U, std::size_t N>
using AoS = std::array<Record<T, U>, N>;
template<class T, class U, std::size_t N>
struct SoA {
std::array<T, N> x;
std::array<U, N> y;
};
// Record i: aos[i].x and aos[i].y, or soa.x[i] and soa.y[i].El diseño orientado a datos consiste en elegir cómo representar los datos según las operaciones del programa. Empieza por los bucles más importantes: identifica qué campos leen o escriben, en qué orden y con qué frecuencia. AoS y SoA son disposiciones de almacenamiento, no palabras clave ni funciones específicas de C++23.
Un array de estructuras (AoS) almacena registros completos de forma contigua: aos[i].energy y aos[i].id pertenecen al mismo objeto. Una estructura de arrays (SoA) almacena cada campo en su propio array contiguo: soa.energy[i] y soa.id[i] describen el mismo registro lógico. Mantén la misma longitud y el mismo orden de los registros en todas las columnas, también al ordenar, insertar o eliminar.
La localidad de caché mejora cuando los accesos sucesivos aprovechan datos ya cargados en la caché. Si un bucle solo lee la columna energy, de uso frecuente (caliente), SoA puede reunir más valores útiles en una línea de caché y reducir la carga de datos que no se usan. AoS puede ser más conveniente cuando una operación suele necesitar juntos la mayoría de los campos de cada registro.
Ninguna disposición garantiza una mejora de velocidad. En este ejemplo, la conversión copia los dos campos de cada registro; mantener ambos formatos consume más memoria y obliga a sincronizar los cambios. Compara compilaciones optimizadas en el hardware de destino con tamaños de datos y patrones de acceso representativos. Incluye la conversión en la medición si forma parte de la carga real.
Ejemplos
#include <array>
#include <cstddef>
#include <iostream>
struct Particle {
int energy;
int id;
};
struct ParticleColumns {
std::array<int, 3> energy;
std::array<int, 3> id;
};
int main() {
const std::array<Particle, 3> aos{{{2, 101}, {4, 102}, {6, 103}}};
ParticleColumns soa{};
for (std::size_t i = 0; i < aos.size(); ++i) {
soa.energy[i] = aos[i].energy;
soa.id[i] = aos[i].id;
}
int aosSum = 0;
for (const Particle& particle : aos) {
aosSum += particle.energy;
}
int soaSum = 0;
for (int energy : soa.energy) {
soaSum += energy;
}
std::cout << "AoS sum: " << aosSum << '\n'
<< "SoA sum: " << soaSum << '\n';
}Resultado
AoS sum: 12 SoA sum: 12
Ambos bucles suman solo `energy` e imprimen `12` para su disposición respectiva. Que el resultado coincida muestra la misma operación en dos disposiciones, no una ventaja de rendimiento.
Lecciones relacionadas
- C++ · Lección 21 · Avanzado · Versión: 3