Booster les performances C++ avec Folly

La bibliothèque Folly, développée par Facebook, est une collection de composants C++ réutilisables conçue pour compléter la bibliothèque standard C++ et booster les performances des applications C++. Folly met l’accent sur l’efficacité et fournit des composants hautement optimisés, particulièrement utiles dans les applications critiques en performance. Voici quelques-unes des fonctionnalités clés de la bibliothèque orientées performance :

1. Des structures de données efficaces

Folly fournit plusieurs structures de données optimisées pour la performance :

folly::small_vector: Un conteneur optimisé de type vecteur qui inclut un petit tampon pour le stockage en ligne. Cela réduit les allocations sur le tas pour les petites tailles, améliorant la localité des caches et les performances.

  #include <folly/small_vector.h>

  void example() {
      folly::small_vector<int, 5> vec;
      for (int i = 0; i < 10; ++i) {
          vec.push_back(i);
      }
  }

folly::F14 Les tables de hachage: Des implémentations de tables de hachage hautement efficaces (F14ValueMap, F14NodeMap, F14VectorMapet leurs équivalents en set). Ces tables de hachage offrent de meilleures performances d’insertion et de recherche, ainsi qu’un usage mémoire plus efficace, que les tables de hachage traditionnelles.

  #include <folly/container/F14Map.h>

  void example() {
      folly::F14FastMap<int, std::string> map;
      map[1] = "one";
      map[2] = "two";
  }

folly::AtomicHashMap: Une hash map hautement concurrente, conçue pour les scénarios exigeant des opérations rapides et lock-free.

  #include <folly/AtomicHashMap.h>

  void example() {
      folly::AtomicHashMap<int, std::string> map(100);
      map.insert(1, "one");
      map.insert(2, "two");
  }

2. Concurrence et parallélisme

Folly offre des primitives et utilitaires de concurrence avancés qui améliorent les performances dans les environnements multithread :

folly::Future et folly::Promise: Ils offrent un moyen pratique de gérer les calculs asynchrones et les callbacks, permettant une concurrence efficace et évolutive.

  #include <folly/futures/Future.h>
  #include <iostream>

  void example() {
      folly::Promise<int> promise;
      auto future = promise.getFuture();

      future.thenValue([](int value) {
          std::cout << "Received: " << value << std::endl;
      });

      promise.setValue(42);
  }

folly::CPUThreadPoolExecutor: Une implémentation de pool de threads optimisée pour les tâches liées au CPU, offrant des niveaux de concurrence configurables et une planification efficace des tâches.

  #include <folly/executors/CPUThreadPoolExecutor.h>
  #include <folly/futures/Future.h>
  #include <iostream>

  void example() {
      folly::CPUThreadPoolExecutor executor(4); // 4 threads
      auto future = folly::makeFuture()
                      .via(&executor)
                      .thenValue([](auto) {
                          std::cout << "Task executed in thread pool." << std::endl;
                          return 42;
                      });
      future.wait();
  }

3. La gestion de la mémoire

Folly inclut des utilitaires et des allocateurs qui optimisent la gestion mémoire, réduisent la fragmentation et améliorent les performances d’allocation et de désallocation :

folly::Arena: Un allocateur mémoire efficace conçu pour les scénarios où de nombreuses petites allocations et désallocations se produisent, minimisant le surcoût et améliorant la localité des caches.

  #include <folly/memory/Arena.h>

  void example() {
      folly::SysArena arena;
      int* p = static_cast<int*>(arena.allocate(sizeof(int)));
      *p = 42;
  }

4. La manipulation de chaînes

Folly offre plusieurs utilitaires de chaînes optimisés, conçus pour surpasser leurs équivalents de la bibliothèque standard :

folly::fbstring: Une implémentation de chaîne hautement optimisée, conçue pour surpasser std::string dans de nombreux scénarios, notamment en matière d’optimisation des petites chaînes et de réduction du surcoût mémoire.

  #include <folly/FBString.h>

  void example() {
      folly::fbstring str = "Hello, Folly!";
      std::cout << str << std::endl;
  }

5. Sérialisation et désérialisation

Folly fournit des utilitaires efficaces de sérialisation et désérialisation :

folly::io::Cursor et folly::io::QueueAppender: Ces classes fournissent des mécanismes efficaces pour lire et écrire des flux d’octets, ce qui est critique dans les applications réseau haute performance.

  #include <folly/io/IOBuf.h>
  #include <folly/io/Cursor.h>

  void example() {
      auto buf = folly::IOBuf::create(100);
      folly::io::QueueAppender appender(buf.get(), 0);
      appender.writeBE<uint32_t>(42);

      folly::io::Cursor cursor(buf.get());
      uint32_t value = cursor.readBE<uint32_t>();
      std::cout << value << std::endl;
  }

6. Benchmarking et tests

Folly inclut des utilitaires de benchmarking et de tests qui aident les développeurs à mesurer et optimiser efficacement les performances :

folly::Benchmark: Un framework de benchmarking léger pour mesurer les performances d’extraits de code.

  #include <folly/Benchmark.h>

  void example() {
      folly::runBenchmarks();
  }

En exploitant ces composants et utilitaires de la bibliothèque Folly, les développeurs C++ peuvent écrire des applications performantes, évolutives et maintenables. La combinaison de structures de données optimisées, d’une gestion mémoire efficace, de primitives de concurrence avancées et de puissants outils de manipulation de chaînes fait de Folly un atout inestimable pour le développement logiciel critique en performance.