Fonctionnement de la mémoire vive d’un ordinateur

Les modules mémoire doivent respecter les normes établies par le « Joint Electron Device Engineering Council » (JEDEC). Cet organisme regroupe de nombreuses entreprises dont Apple, Samsung, Kingston, Microsoft, Huawey, Realtek, Texas Instrument….
La norme détaille le fonctionnement de la mémoire vive : tensions d’alimentation d’un module, vitesses, commandes pour manipuler les données, dimensions, et ainsi de suite.

Une barrette DIMM contient entre 8 et 32 puces de mémoire DDR-SDRAM. Les puces sont manipulées et utilisées en parallèle, formant un ensemble nommé rang (en anglais, « rank »).

Une puce DDR-SDRAM contient plusieurs banques de données (banks). Une banque de données peut être illustrée par un tableau à deux dimensions dans lequel chaque cellule stocke un bit, grâce à un condensateur.

Un module mémoire DDR-SDRAM dispose d’un bus de données utiles de 64 bits. Chaque puce d’un même rang remplit une partie de ce bus.

La lecture d’une donnée depuis la mémoire vive suit le processus suivant :

• le CPU envoie une requête pour obtenir une donnée située à une adresse physique spécifique (l’adresse étant une valeur comprise entre 0 et l’espace d’adressage physique de la mémoire) ;
• le contrôleur mémoire décode cette adresse physique afin d’obtenir l’emplacement exact de la donnée sur le module mémoire, le rang, la banque, la ligne et la colonne ;
• la ligne contenant la donnée souhaitée est activée (Row Address Strobe, RAS). Son contenu est amplifié grâce aux amplificateurs de détection (« sense amplifiers »). La ligne est alors dite ouverte. Il faut ensuite accéder à une colonne donnée (Column Adress Strobe, CAS) pour remplir les bits d’entrée/sortie de la puce. Cette opération est réalisée en parallèle sur les différentes puces intégrant le même rang permettant ainsi le remplissage des 64 bits de données à envoyer au processeur.

Le processus d’écriture est similaire (ouverture de la ligne puis de la colonne). Simplement, au lieu de lire la donnée stockée, les données provenant du processeur sont appliquées aux amplificateurs de détection, qui modifient l’état des condensateurs des cellules mémoire correspondantes.

Les constructeurs de modules mémoire indiquent les performances de leur produit grâce à quatre temps (exprimés en cycles d’horloge du contrôleur mémoire) :

• CL (CAS Latency) : le nombre exact de cycles d’attente entre la réception d’une commande de lecture par la puce et le début de l’envoi des données (lorsque la ligne est déjà ouverte) ;
• T_RCD (Row Address to Column Address Delay) : le nombre minimal de cycles d’horloge nécessaires pour ouvrir une ligne, puis accéder à une colonne de cette ligne. Par conséquent, si la donnée est stockée sur une ligne qui n’est pas ouverte, le nombre minimal de cycles d’attente sera T_RCD + CL.
  Certains constructeurs indiquent deux valeurs pour ce temps : une pour la lecture et une pour l’écriture (T_RCDwr et T_RCDrd) ;
• T_RP (Row Precharge Time) : le nombre minimal de cycles d’horloge entre la demande de préchargement de ligne et l’ouverture de celle-ci. Autrement dit, cela équivaut au temps nécessaire pour fermer une ligne afin d’en charger une autre. Par conséquent, si la donnée est stockée sur une ligne autre que celle ouverte, il faut attendre, au minimum T_RP + T_RCD + CL cycles d’horloges ;
• T_RAS (Row Active Time) : nombre de cycles d’horloge minimal pendant lesquels une ligne doit rester active après son activation avant de pouvoir être préchargée (refermée). Ce temps est généralement égal ou supérieur à T_RCD + CL..

I-B-1. Vitesse▲

Des erreurs peuvent survenir lorsque le contrôleur essaie de lire ou d’écrire des données sur les puces DRAM (changement de bit, appelé « bit flip »). Un module de mémoire de type ECC (« Error Correcting Code ») est doté d’un code correcteur d’erreur permettant de détecter, voire de corriger, de telles erreurs. Pour cela, un module contiendra une ou plusieurs puces DRAM supplémentaires et transférera 8 bits supplémentaires aux 64 bits de données utiles. Grâce à ces 8 bits supplémentaires, le contrôleur mémoire peut détecter l’erreur et en informer le reste du système. Les mémoires ECC sont principalement utilisées dans les stations de travail et les serveurs.

Lorsqu’une erreur affecte une donnée stockée en mémoire vive sans code correcteur d’erreur, le changement dans les données est invisible pour le système. Par exemple, si cela se produit lors de la copie d’un fichier, ce dernier sera modifié, voire corrompu, sans que la copie échoue. Selon l’utilisation de la donnée stockée, les conséquences peuvent être nulles, entraîner la corruption d’un fichier ou d’une information utile aux calculs d’un programme, voire entraîner le plantage complet du système.

Finalement, la présence du code correcteur d’erreur entraîne une légère dégradation des performances, due à des timings plus élevés, comme mentionné dans la vidéo de Linus Tech Tips dédiée au sujet. Ce coût dépend de la configuration de la machine (processeur, génération de la mémoire, contrôleur, timings, etc).

En tant que développeur, il est intéressant de se demander s’il est possible d’optimiser ces accès à la mémoire vive.
Le graphe suivant montre les performances pouvant être obtenues lors du calcul de la somme des éléments d’un tableau, avec un accès linéaire (qui profite donc des caches) en comparaison avec un accès aléatoire :

Il est important de veiller à ce que le programme puisse tirer le meilleur parti des caches afin que le processeur accède aux données nécessaires aussi rapidement que possible. En effet, si les données dont il a besoin se trouvent dans la mémoire vive, le processeur attendra et dépendra de la vitesse et des latences de cette dernière. Pour favoriser l’utilisation des caches, deux principes sont à considérer :

• une proximité temporelle : les données sont mises en cache après avoir été récupérées. Il faut donc essayer de les utiliser immédiatement avant qu’elles ne soient déchargées du cache ;
• une proximité spatiale : le processeur dispose de plusieurs mécanismes et optimisations pour récupérer les données. Il est possible que le processeur récupère non seulement la donnée utile à un moment T, mais aussi celles qui suivent (récupération en amont ou « prefetch »).

La proximité temporelle peut être améliorée par un réagencement des boucles et des variables utilisées, de façon à regrouper les différentes utilisations des mêmes données. Par exemple, au lieu de découper un programme travaillant sur plusieurs ensembles de valeurs en étapes logiques : initialisation, calcul, affichage des résultats, il peut être plus efficace de réorganiser le programme pour effectuer les trois étapes sur un ensemble de valeurs à la fois.

III-A-1. Organisation des données▲

struct Values {
    double v1;
    double v2;
    double v3;
};
using AoSValues = std::vector<Values>;
double sum(const AoSValues& values)
{
    double sum = 0;
    for (auto const& v : values)
    {
        sum += v.v1 + v.v2 + v.v3;
    }
    return sum;
}

struct SoAValues {
    std::vector<double> v1;
    std::vector<double> v2;
    std::vector<double> v3;
};
double sum(const SoAValues& values)
{
    double sum = 0;
    for (size_t i = 0 ; i < values.v1.size() ; ++i)
    {
        sum += values.v1[i] + values.v2[i] + values.v3[i];
    }
    return sum;
}

III-A-2. Faux partage▲

struct FalseSharing {
    std::atomic<size_t> count1{0};
    std::atomic<size_t> count2{0};
};

struct AlignedSharing {
    alignas(hardware_destructive_interference_size) std::atomic<size_t> count1{0};
    alignas(hardware_destructive_interference_size) std::atomic<size_t> count2{0};
};

double run(size_t iterations) {
    AlignedSharing data;
    // FalseSharing data;
    auto work1 = [&data, iterations]() {
        for (size_t i = 0; i < iterations; ++i) {
            data.count1.fetch_add(1, std::memory_order_relaxed);
        }
    };
    auto work2 = [&data, iterations]() {
        for (size_t i = 0; i < iterations; ++i) {
            data.count2.fetch_add(1, std::memory_order_relaxed);
        }
    };

    std::thread t1(work1);
    std::thread t2(work2);
    t1.join();
    t2.join();

    return static_cast<double>(data.count1 + data.count2);
}

III-A-3. Outils▲

Il est possible d’accélérer la lecture et l’écriture des données mémoire en les répartissant sur plusieurs modules mémoire. Le contrôleur mémoire peut alors utiliser les modules en parallèle et ainsi transférer une plus grande quantité de données pour une même unité de temps. Cette technique s’appelle double canal (ou « dual channel »), et peut également être aussi triple, quadruple, etc. Elle est directement gérée au niveau de la carte mère et du contrôleur mémoire.
Pour obtenir un fonctionnement optimal, les modules doivent toutefois offrir les mêmes caractéristiques.

Pour rappel, le D de l’acronyme DRAM signifie « Dynamic ». Au sein des puces, les bits sont stockés à l’aide de condensateurs. Ce composant électronique peut être comparé à une pile que l’on peut charger et décharger. Toutefois, le condensateur se décharge rapidement.
Dans un ordinateur, une charge élevée est interprétée comme un 1 binaire. Sinon, c’est un 0. Si un condensateur est chargé afin de stocker un 1 et qu’il se décharge spontanément, alors le 1 devient un 0 et la donnée est donc altérée.
Pour contrer cet effet de décharge, la puce DRAM relit et réécrit régulièrement les valeurs stockées afin de restaurer la charge des condensateurs. Ce processus s’appelle un rafraîchissement (« refresh »). Plus précisément, la puce effectue ce rafraîchissement ligne par ligne, en suivant un processus interne de balayage des lignes de mémoire. C’est automatique et géré par la puce elle-même.
Par contre, cela implique une contrainte : certaines opérations mémoire doivent attendre que le rafraîchissement soit effectué et cela ne peut être contrôlé ni directement monitoré par le processeur.

III-C-1. Contourner la latence du rafraîchissement▲