Mise en cache en C++ : accélérez vos applications 10 fois

Mise en cache des données en C++ : quand la mémoire est plus rapide que le disque

Imaginez que votre application C++ soit un bibliothécaire. Chaque fois qu'un lecteur demande un livre, le bibliothécaire court vers un lointain dépôt (autrement dit, la base de données ou le système de fichiers). C'est lent. Mais si le bibliothécaire commence à garder les livres les plus populaires sur son bureau (dans la mémoire vive), la vitesse de délivrance est multipliée. C'est ce qu'on appelle la mise en cache des données en C++.

Aujourd'hui, nous allons voir comment transformer votre application de tortue en guépard. Nous aborderons non seulement la théorie, mais aussi l'écriture de code réel. Vous découvrirez quelles stratégies de mise en cache existent, comment éviter les pièges de la gestion de la mémoire et où trouver des solutions prêtes à l'emploi pour ne pas réinventer la roue.

Pourquoi la mise en cache est un must-have pour le développeur C++ ?

C++ est un langage pour les systèmes à forte charge. Robots de trading, moteurs de jeux, serveurs de bases de données – partout où chaque microseconde compte, la mise en cache devient un salut. Sans elle, vous buterez constamment sur les E/S (entrées/sorties) ou les calculs répétés.

Les principaux avantages de l'implémentation de la mise en cache :

• Réduction du temps de réponse – les données en RAM se lisent 100 000 fois plus vite que sur un HDD.
• Diminution de la charge sur la base de données – moins de requêtes = moins de latence.
• Économie de ressources de calcul – inutile de recalculer des fonctions lourdes.

Mais il y a aussi des pièges : fuites de mémoire, données obsolètes (stale data) et baisses de performance en cas d'implémentation incorrecte. Alors, procédons dans l'ordre.

Les principales stratégies de mise en cache en C++

Le choix de la stratégie dépend des données que vous mettez en cache et de leur fréquence de modification. Examinons les trois plus populaires.

1. LRU (Least Recently Used) – on évince ce qui n'a pas été consulté depuis le plus longtemps

C'est un classique. Imaginez que vous ayez une boîte de 10 livres. Quand un nouveau arrive et que la boîte est pleine, vous jetez le livre qui n'a pas été lu depuis le plus longtemps. Le cache LRU en C++ fonctionne de la même manière.

Implémentation en C++ avec std::list et std::unordered_map :

#include <iostream>#include <list>#include <unordered_map>#include <string>

template <typename K, typename V>class LRUCache {private:    size_t capacity;    std::list<std::pair<K, V>> items;    std::unordered_map<K, typename std::list<std::pair<K, V>>::iterator> cache;

public:    LRUCache(size_t cap) : capacity(cap) {}

    V get(const K& key) {        auto it = cache.find(key);        if (it == cache.end()) {            return V(); // Retourne la valeur par défaut si la clé n'est pas trouvée        }        // Déplace l'élément au début de la liste (le plus récent)        items.splice(items.begin(), items, it->second);        return it->second->second;    }

    void put(const K& key, const V& value) {        auto it = cache.find(key);        if (it != cache.end()) {            // Met à jour l'élément existant            it->second->second = value;            items.splice(items.begin(), items, it->second);            return;        }

        if (cache.size() >= capacity) {            // Supprime l'élément le plus ancien (le dernier de la liste)            auto last = items.back();            cache.erase(last.first);            items.pop_back();        }

        // Insère le nouvel élément au début        items.emplace_front(key, value);        cache[key] = items.begin();    }};

int main() {    LRUCache<std::string, int> lru(3);    lru.put("one", 1);    lru.put("two", 2);    lru.put("three", 3);    lru.get("one"); // On accède à "one" – il devient récent    lru.put("four", 4); // "two" sera évincé, car il n'a pas été consulté depuis le plus longtemps\