WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Datenorientiertes Design: AoS, SoA und Cache-Lokalität

Richte das Datenlayout an den tatsächlichen Zugriffen aus: Vergleiche vollständige Datensätze mit getrennten Spalten und miss den Effekt unter repräsentativer Last.

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

Syntax

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

Datenorientiertes Design bedeutet, die Datendarstellung nach den Operationen des Programms auszuwählen. Untersuche zuerst die wichtigen Schleifen: Welche Felder lesen oder schreiben sie, in welcher Reihenfolge und wie oft? AoS und SoA sind Speicherlayouts, keine Schlüsselwörter oder eigenen Sprachmerkmale von C++23.

Ein Array von Strukturen (AoS) speichert vollständige Datensätze zusammenhängend: aos[i].energy und aos[i].id gehören zum selben Objekt. Eine Struktur aus Arrays (SoA) speichert jedes Feld in einem eigenen zusammenhängenden Array: soa.energy[i] und soa.id[i] beschreiben denselben logischen Datensatz. Länge und Datensatzreihenfolge der Spalten müssen auch beim Sortieren, Einfügen und Löschen übereinstimmen.

Die Cache-Lokalität verbessert sich, wenn aufeinanderfolgende Zugriffe bereits in den Cache geladene Daten nutzen. Liest eine Schleife nur die häufig genutzte (heiße) Spalte energy, kann SoA mehr benötigte Werte pro Cache-Zeile unterbringen und weniger ungenutzte Daten laden. AoS kann günstiger sein, wenn eine Operation meist die meisten Felder eines Datensatzes gemeinsam benötigt.

Keines der Layouts garantiert einen Geschwindigkeitsgewinn. Die Konvertierung kopiert hier beide Felder jedes Datensatzes; beide Layouts gleichzeitig vorzuhalten kostet zusätzlichen Speicher und erfordert abgestimmte Änderungen. Vergleiche optimierte Builds auf der Zielhardware mit repräsentativen Datenmengen und Zugriffsmustern. Berücksichtige die Konvertierung, wenn sie zur tatsächlichen Workload gehört.

Beispiele

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

Ergebnis

AoS sum: 12
SoA sum: 12

Beide Schleifen summieren nur `energy` und geben für ihr jeweiliges Layout `12` aus. Das gleiche Ergebnis zeigt dieselbe Operation auf zwei Layouts, aber keinen Geschwindigkeitsvorteil.

Zugehörige Lektionen

  • C++ · Lektion 21 · Fortgeschritten · Version: 3

Quellen