KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Structuur van arrays (SoA) tegenover array van structs (AoS) in C++

Vergelijk opslag per record met opslag per veld. Kies een indeling op basis van het toegangspatroon, cachelokaliteit en de kosten van omzetting.

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

Syntax

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

Datagericht ontwerpen begint bij de manier waarop het programma gegevens gebruikt. Een array van structs (AoS) slaat opeenvolgende records op en groepeert de velden per record. Een structuur van arrays (SoA) slaat elk veld in een aparte array op: values[i] en tags[i] horen bij hetzelfde logische record. SoA is een indelingspatroon, geen apart taalconstruct of type uit de standaardbibliotheek van C++23.

Bij het sequentieel doorlopen van een hete kolom, oftewel een vaak gebruikt veld, staan de nuttige waarden bij SoA naast elkaar. Een cacheregel kan zo meer nuttige waarden en minder ongebruikte gegevens bevatten dan bij het lezen van hetzelfde veld uit opeenvolgende AoS-records. Dat kan de cachelokaliteit verbeteren. Gebruikt een bewerking de meeste velden van een record samen, dan kan AoS beter passen.

De getoonde omzetting kopieert de velden en gebruikt extra geheugen zolang beide indelingen naast elkaar bestaan. Geen van beide garandeert snelheidswinst: de werklast, het toegangspatroon, de compiler en de hardware spelen allemaal mee. Meet geoptimaliseerde builds met representatieve gegevens en tel ook de omzetting mee die het echte programma uitvoert.

Houd de kolommen even lang en zorg dat posities blijven corresponderen. In het voorbeeld delen de std::array-kolommen de grootteparameter N. Scherm bij dynamische std::vector-kolommen wijzigingen af, zodat de kolommen synchroon blijven als invoegen mislukt. Herallocatie van een vector maakt pointers, referenties en iteratoren naar de elementen ervan ongeldig.

Voorbeelden

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

Resultaat

AoS: 15
SoA: 15

Het programma kopieert dezelfde drie records van AoS naar SoA. Beide lussen tellen alleen `value` op en komen uit op `15`. Dit vergelijkt resultaten en meet geen prestaties.

Gerelateerde lessen

  • C++ · Les 21 · Gevorderd · Versie: 3

Bronnen