Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

Estrutura de arrays (SoA) ou array de estruturas (AoS) em C++

Compare o armazenamento por registo e por campo segundo o padrão de acesso, a localidade em cache e o custo de conversão entre as duas disposições.

Versão: ISO C++23; implementation support may vary

Sintaxe

#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].

A conceção orientada aos dados parte da forma como o programa os utiliza. Um array de estruturas (AoS) armazena registos consecutivos e agrupa os campos de cada registo. Uma estrutura de arrays (SoA) armazena cada campo num array separado: values[i] e tags[i] pertencem ao mesmo registo lógico. SoA é um padrão de disposição de dados, não uma construção da linguagem nem um tipo da biblioteca padrão de C++23.

Ao percorrer sequencialmente uma coluna quente, ou seja, um campo usado com frequência, SoA coloca os valores úteis uns ao lado dos outros. Assim, uma linha de cache pode conter mais valores úteis e menos dados que não são usados do que ao ler o mesmo campo em registos AoS consecutivos. Isto pode melhorar a localidade em cache. Se uma operação utilizar em conjunto a maioria dos campos de um registo, AoS pode ser mais adequado.

A conversão apresentada copia os campos e utiliza memória adicional enquanto coexistirem as duas disposições. Nenhuma garante um aumento de velocidade: contam a carga de trabalho, o padrão de acesso, o compilador e o hardware. Meça versões otimizadas com dados representativos, incluindo qualquer conversão feita pelo programa real.

Mantenha as colunas com o mesmo comprimento e preserve a correspondência entre posições. No exemplo, as colunas std::array partilham o parâmetro de tamanho N. Com colunas dinâmicas de tipo std::vector, encapsule as alterações para manter as colunas sincronizadas mesmo que uma inserção falhe. A realocação de um vetor invalida os ponteiros, as referências e os iteradores para os seus elementos.

Exemplos

#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

O programa copia os mesmos três registos de AoS para SoA. Ambos os percursos somam apenas `value` e dão `15`. É uma comparação dos resultados, não uma medição do desempenho.

Lições relacionadas

  • C++ · Lição 21 · Avançado · Versão: 3

Fontes