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

CKTIS / C++

Conceção orientada aos dados: AoS, SoA e localidade da cache

Escolhe a disposição dos dados em função dos acessos do programa: compara registos completos com colunas separadas e mede o efeito numa carga representativa.

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

Sintaxe

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

A conceção orientada aos dados consiste em escolher a representação dos dados de acordo com as operações do programa. Começa pelos ciclos mais importantes: identifica que campos leem ou escrevem, por que ordem e com que frequência. AoS e SoA são disposições em memória, não palavras-chave nem funcionalidades específicas de C++23.

Um array de estruturas (AoS) guarda registos completos de forma contígua: aos[i].energy e aos[i].id pertencem ao mesmo objeto. Uma estrutura de arrays (SoA) guarda cada campo no seu próprio array contíguo: soa.energy[i] e soa.id[i] descrevem o mesmo registo lógico. Mantém o mesmo comprimento e a mesma ordem dos registos em todas as colunas, mesmo ao ordenar, inserir ou eliminar.

A localidade da cache melhora quando acessos sucessivos usam dados que já foram carregados para a cache. Se um ciclo ler apenas a coluna energy, usada com frequência (quente), SoA pode reunir mais valores úteis numa linha de cache e reduzir o carregamento de dados que não são usados. AoS pode ser preferível quando uma operação costuma precisar da maioria dos campos de cada registo em conjunto.

Nenhuma das disposições garante uma melhoria de velocidade. Neste exemplo, a conversão copia ambos os campos de cada registo; manter as duas disposições ocupa mais memória e exige a sincronização das alterações. Compara versões compiladas com otimizações no hardware de destino, com volumes de dados e padrões de acesso representativos. Inclui a conversão na medição se fizer parte da carga de trabalho real.

Exemplos

#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

Os dois ciclos somam apenas `energy` e apresentam `12` para a disposição respetiva. O resultado igual demonstra a mesma operação em duas disposições, não uma vantagem de desempenho.

Lições relacionadas

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

Fontes