0Pricing
C++ Academy · Leçon

Organisations des données adaptées au cache

Concevoir des structures de tableaux et regrouper les données pour favoriser la localité du cache

Organisations des données adaptées au cache est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

La hiérarchie mémoire

Les CPU modernes disposent de plusieurs niveaux de cache (L1, L2, L3), bien plus rapides que la mémoire principale. Un code adapté au cache conserve les données fréquemment utilisées près du CPU.

Lignes de cache

La mémoire est récupérée par lignes de cache — généralement de 64 octets. La lecture d’un seul octet charge la ligne entière. Utilisez cela à votre avantage.

Localité des références

Deux propriétés importantes :

  • Localité spatiale — utiliser bientôt une zone mémoire voisine
  • Localité temporelle — réutiliser bientôt la même zone mémoire

Contiguïté contre chaînage

Les vecteurs stockent les données de manière contiguë : les parcourir est favorable au cache. Les listes chaînées dispersent la mémoire et vident le cache à chaque étape.

// Cache friendly
std::vector<int> v(1000);
for (auto& x : v) ++x;

// Cache UNfriendly
std::list<int> l(1000);
for (auto& x : l) ++x;

AoS contre SoA

Deux dispositions pour des tableaux d’enregistrements :

  • AoS (tableau de structures) — naturel, mais parcourir un seul champ touche tous les champs
  • SoA (structure de tableaux) — préférable lorsque la plupart des boucles n’utilisent que certains champs
// AoS
struct Particle { float x, y, z, vx, vy, vz; };
std::vector<Particle> particles;

// SoA
struct Particles {
    std::vector<float> x, y, z, vx, vy, vz;
};

Agencement des structures

Ordonnez les membres du plus grand au plus petit pour réduire le remplissage. Des outils comme pahole affichent la disposition réelle.

struct Bad  { char c; double d; char c2; };  // padded
struct Good { double d; char c; char c2; };  // smaller

Faux partage

Deux fils d’exécution qui écrivent dans des variables différentes situées sur la même ligne de cache invalident mutuellement leurs caches. C’est catastrophique pour les performances. Ajoutez un remplissage jusqu’à 64 octets.

struct alignas(64) Counter {
    std::atomic<int> value;
};

Séparer les données chaudes et froides

Séparez les données chaudes (consultées fréquemment) des données froides (rarement consultées) dans des structures différentes. Le CPU ne met en cache que la partie chaude.

Préallocation

Préallouez les vecteurs avec reserve pour éviter les réallocations répétées. Chaque réallocation copie tous les éléments — c’est coûteux et nuisible au cache.

L’accès séquentiel l’emporte

Les parcours linéaires de tableaux sont les plus rapides. Le dispositif matériel de prélecture prédit et charge automatiquement les lignes de cache suivantes.

Éviter l’indirection

Les pointeurs obligent le CPU à suivre les dépendances. std::vector<T*> est plus lent que std::vector<T> pour un parcours. N’utilisez l’indirection que lorsque c’est nécessaire.

Profiler avant d’optimiser

Le caractère favorable au cache est une recommandation, pas une règle. Mesurez avec des outils comme perf ou VTune pour voir où les défauts de cache pénalisent les performances — puis optimisez.

Vérification rapide

Pourquoi parcourir un std::vector est-il généralement bien plus rapide que parcourir un std::list de même taille ?

Récapitulatif

Les CPU modernes dépendent des caches. Préférez les conteneurs contigus, utilisez SoA pour accéder sélectivement aux champs, compactez les structures, évitez le faux partage et profilez les défauts de cache avec perf ou VTune pour repérer les points chauds.

Questions Fréquemment Posées

La leçon « Organisations des données adaptées au cache » est-elle gratuite ?

Oui — le texte complet de « Organisations des données adaptées au cache » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Organisations des données adaptées au cache » ?

Concevoir des structures de tableaux et regrouper les données pour favoriser la localité du cache Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Organisations des données adaptées au cache » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Organisations des données adaptées au cache
  2. Prédiction des branchements et boucles intensives
  3. Profilage avec perf, vtune et les sanitizers
  4. Micro-évaluation des performances avec Google Benchmark
← Retour à C++ Academy