Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Estructura de arrays (SoA) frente a array de estructuras (AoS) en C++

Compara el almacenamiento por registros y por campos según el patrón de acceso, la localidad de caché y el coste de convertir entre las dos disposiciones.

Versión: ISO C++23; implementation support may vary

Sintaxis

#include <array>
#include <cstddef>

struct Sample { int value; int tag; };

// AoS: one element per record.
std::array<Sample, 3> aos{};

// SoA: one array per field.
template<std::size_t N>
struct SamplesSoA {
    std::array<int, N> values{};
    std::array<int, N> tags{};
};
SamplesSoA<3> soa{};

// For 0 <= i < 3: aos[i].value corresponds to soa.values[i].

El diseño orientado a datos parte de cómo utiliza los datos el programa. Un array de estructuras (AoS) almacena registros consecutivos y agrupa los campos de cada registro. Una estructura de arrays (SoA) almacena cada campo en un array distinto: values[i] y tags[i] pertenecen al mismo registro lógico. SoA es un patrón de disposición de datos, no una construcción del lenguaje ni un tipo de la biblioteca estándar de C++23.

Al recorrer secuencialmente una columna caliente, es decir, un campo de uso frecuente, SoA coloca los valores útiles uno junto a otro. Así, una línea de caché puede contener más valores útiles y menos datos sin usar que al leer el mismo campo en registros AoS consecutivos. Esto puede mejorar la localidad de caché. Si una operación usa juntos la mayoría de los campos de un registro, AoS puede ser más adecuado.

La conversión del ejemplo copia los campos y requiere memoria adicional mientras coexisten las dos disposiciones. Ninguna garantiza una mejora de velocidad: influyen la carga de trabajo, el patrón de acceso, el compilador y el hardware. Mide versiones optimizadas con datos representativos e incluye cualquier conversión que realice el programa real.

Mantén las columnas con la misma longitud y conserva la correspondencia entre posiciones. En el ejemplo, las columnas std::array comparten el parámetro de tamaño N. Si usas columnas dinámicas de tipo std::vector, encapsula los cambios para que las columnas sigan sincronizadas incluso si falla una inserción. La reasignación de memoria de un vector invalida los punteros, las referencias y los iteradores a sus elementos.

Ejemplos

#include <array>
#include <cstddef>
#include <iostream>

struct Sample {
    int value;
    int tag;
};

template<std::size_t N>
struct SamplesSoA {
    std::array<int, N> values{};
    std::array<int, N> tags{};
};

int main() {
    const std::array<Sample, 3> aos{{{3, 100}, {5, 200}, {7, 300}}};
    SamplesSoA<aos.size()> soa{};

    for (std::size_t i = 0; i < aos.size(); ++i) {
        soa.values[i] = aos[i].value;
        soa.tags[i] = aos[i].tag;
    }

    int aos_sum = 0;
    for (const Sample& sample : aos) {
        aos_sum += sample.value;
    }

    int soa_sum = 0;
    for (int value : soa.values) {
        soa_sum += value;
    }

    std::cout << "AoS: " << aos_sum << '\n'
              << "SoA: " << soa_sum << '\n';
}

Resultado

AoS: 15
SoA: 15

El programa copia los mismos tres registros de AoS a SoA. Ambos recorridos suman solo `value` y dan `15`. Se comparan resultados, no se mide el rendimiento.

Lecciones relacionadas

  • C++ · Lección 21 · Avanzado · Versión: 3

Fuentes