Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Progettazione orientata ai dati: AoS, SoA e località della cache

Scegli la disposizione in base a come il programma usa i dati: confronta i record completi con le colonne separate e misura l’effetto su un carico rappresentativo.

Versione: ISO C++23; implementation support may vary

Sintassi

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

La progettazione orientata ai dati consiste nello scegliere come rappresentare i dati in base alle operazioni del programma. Parti dai cicli più importanti: individua quali campi leggono o scrivono, in quale ordine e con quale frequenza. AoS e SoA sono disposizioni in memoria, non parole chiave né funzionalità specifiche di C++23.

Un array di strutture (AoS) memorizza record completi in modo contiguo: aos[i].energy e aos[i].id appartengono allo stesso oggetto. Una struttura di array (SoA) memorizza ogni campo in un proprio array contiguo: soa.energy[i] e soa.id[i] descrivono lo stesso record logico. Mantieni uguali la lunghezza delle colonne e l’ordine dei record, anche durante ordinamenti, inserimenti e cancellazioni.

La località della cache migliora quando gli accessi successivi usano dati già caricati in cache. Se un ciclo legge solo la colonna energy, usata di frequente (calda), SoA può far entrare più valori utili in una linea di cache e ridurre il caricamento di dati inutilizzati. AoS può essere preferibile quando un’operazione richiede di solito la maggior parte dei campi di ogni record insieme.

Nessuna disposizione garantisce un aumento di velocità. Qui la conversione copia entrambi i campi di ogni record; conservare entrambe le disposizioni occupa più memoria e richiede di sincronizzare le modifiche. Confronta build ottimizzate sull’hardware di destinazione con dimensioni dei dati e schemi di accesso rappresentativi. Includi la conversione nella misurazione se fa parte del carico reale.

Esempi

#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';
}

Risultato

AoS sum: 12
SoA sum: 12

Entrambi i cicli sommano solo `energy` e stampano `12` per la rispettiva disposizione. Il risultato identico mostra la stessa operazione su due disposizioni, non un vantaggio prestazionale.

Lezioni correlate

  • C++ · Lezione 21 · Avanzato · Versione: 3

Fonti