CKTIS / C++
Projektowanie zorientowane na dane: AoS, SoA i lokalność pamięci podręcznej
Dobierz układ danych do sposobu, w jaki program ich używa: porównaj pełne rekordy z osobnymi kolumnami i zmierz efekt w rzeczywistym obciążeniu.
Wersja: ISO C++23; implementation support may vary
Składnia
// 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].Projektowanie zorientowane na dane polega na doborze reprezentacji danych do operacji wykonywanych przez program. Zacznij od najważniejszych pętli: sprawdź, które pola odczytują lub zapisują, w jakiej kolejności i jak często. AoS i SoA to dwa układy danych, a nie słowa kluczowe ani osobne mechanizmy C++23.
Tablica struktur (AoS) przechowuje kompletne rekordy obok siebie: aos[i].energy i aos[i].id należą do tego samego obiektu. Struktura tablic (SoA) przechowuje każde pole w osobnej, ciągłej tablicy: soa.energy[i] i soa.id[i] opisują ten sam logiczny rekord. Kolumny muszą zachowywać tę samą długość i kolejność rekordów, także przy sortowaniu, wstawianiu i usuwaniu.
Lokalność pamięci podręcznej poprawia się, gdy kolejne odczyty trafiają do danych już pobranych do pamięci podręcznej. Gdy pętla czyta tylko często używaną (gorącą) kolumnę energy, SoA może umieścić więcej potrzebnych wartości w jednej linii pamięci podręcznej i ograniczyć pobieranie nieużywanych pól. Gdy operacja zwykle potrzebuje większości pól rekordu naraz, korzystniejsze może być AoS.
Żaden układ nie gwarantuje przyspieszenia. W tym przykładzie konwersja kopiuje oba pola każdego rekordu; utrzymywanie obu postaci zwiększa zużycie pamięci i wymaga synchronizacji zmian. Porównuj zoptymalizowane kompilacje na docelowym sprzęcie, używając reprezentatywnych rozmiarów danych i wzorców dostępu. Uwzględnij konwersję, jeśli jest częścią rzeczywistego obciążenia.
Przykłady
#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';
}Wynik
AoS sum: 12 SoA sum: 12
Obie pętle sumują tylko `energy` i wypisują `12` dla każdego układu. Zgodność wyników pokazuje tę samą operację na dwóch układach danych, a nie przewagę wydajnościową.
Powiązane lekcje
- C++ · Lekcja 21 · Zaawansowany · Wersja: 3