CKTIS / C++
Conception orientée données : AoS, SoA et localité du cache
Adaptez l’organisation des données aux accès du programme : comparez les enregistrements complets aux colonnes séparées, puis mesurez l’effet sur une charge représentative.
Version : ISO C++23; implementation support may vary
Syntaxe
// 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 conception orientée données consiste à choisir une représentation des données d’après les opérations du programme. Commencez par les boucles importantes : quels champs lisent-elles ou écrivent-elles, dans quel ordre et à quelle fréquence ? AoS et SoA sont des organisations en mémoire, pas des mots-clés ni des fonctionnalités propres à C++23.
Un tableau de structures (AoS) stocke des enregistrements complets de façon contiguë : aos[i].energy et aos[i].id appartiennent au même objet. Une structure de tableaux (SoA) stocke chaque champ dans son propre tableau contigu : soa.energy[i] et soa.id[i] décrivent le même enregistrement logique. Les colonnes doivent conserver la même longueur et le même ordre des enregistrements, y compris lors des tris, insertions et suppressions.
La localité du cache s’améliore lorsque des accès successifs utilisent des données déjà chargées dans le cache. Si une boucle ne lit que la colonne energy, fréquemment utilisée (dite chaude), SoA peut placer davantage de valeurs utiles dans une ligne de cache et réduire le chargement de données inutilisées. AoS peut être préférable lorsqu’une opération utilise généralement la plupart des champs d’un enregistrement ensemble.
Aucune des deux organisations ne garantit un gain de vitesse. Ici, la conversion copie les deux champs de chaque enregistrement ; conserver les deux représentations consomme plus de mémoire et impose de synchroniser les modifications. Comparez des versions compilées avec optimisation sur le matériel cible, avec des volumes et des modes d’accès représentatifs. Incluez la conversion dans la mesure si elle fait partie de la charge réelle.
Exemples
#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';
}Résultat
AoS sum: 12 SoA sum: 12
Les deux boucles additionnent uniquement `energy` et affichent `12` pour leur organisation respective. Ce résultat identique montre la même opération sur deux organisations, pas un avantage de performance.
Leçons associées
- C++ · Leçon 21 · Avancé · Version : 3