Comment puis-je implémenter un compteur ABA sans verrouillage dans C 11 à l'aide de CAS et minimiser les frais de performances ?

Comment puis-je implémenter le compteur ABA avec c 11 CAS ?

Pour mettre à jour atomiquement deux valeurs simultanément, créez une structure atomique adjacente. Supposons que vous utilisiez std::atomic pour mettre en œuvre cela. Ensuite, les actions suivantes se produiront :

1. Utilisez l'instruction lock cmpxchg16b sur les processeurs x86-64 via la compilation gcc.
2. Évitez l'assemblage en ligne et préférez la syntaxe C pour plus d'efficacité.
3. Employer des syndicats pour permettre un chargement efficace des membres individuels de la structure.
4. Assurer 16B (ou 8B pour les pointeurs 32 bits) pour éviter les problèmes de performances sur les architectures x86.
5. Utilisez -mcx16 pour les versions x86-64, car cmpxchg16b n'était pas systématiquement pris en charge par les premiers processeurs x86-64.

Notez que l'objet atomique doit être sans verrouillage, en particulier pour les processeurs x86. Les compilateurs comme gcc7 et versions ultérieures peuvent appeler libatomic au lieu d'utiliser le verrouillage en ligne cmpxchg16b. Dans de tels scénarios, considérez les éléments suivants :

• Vérifiez que le compilateur génère un code efficace pour lire les membres individuels sans recourir à un verrou cmpxchg16b de la paire.
• Assurez-vous que l'accès à un membre du syndicat après en avoir modifié un autre, c'est bien défini pour l'implémentation. Ceci est légal dans GNU C mais peut entraîner un comportement indéfini si vous adhérez strictement à ISO C.
• Assurez-vous que l'objet est correctement aligné, car un mauvais alignement peut entraîner une dégradation des performances sur les architectures x86.
• Conservez l'alignement pour les pointeurs 32 bits, car les objets atomiques plus grands que les pointeurs peuvent utiliser des verrous sur x86-64 Processeurs.

Voici un exemple de code C 11 qui présente ces caractéristiques :

#include <atomic>
#include <stdint.h>

using namespace std;

struct node {
  struct alignas(2*sizeof(node*)) counted_ptr {
    node *    ptr;
    uintptr_t count;  // use pointer-sized integers to avoid padding
  };

  // hack to allow reading just the pointer without lock-cmpxchg16b,
  // but still without any C++ data race
  struct counted_ptr_separate {
    atomic<node *>    ptr;
    atomic<uintptr_t> count_separate;  // var name emphasizes that accessing this way isn't atomic with ptr
  };

  static_assert(sizeof(atomic<counted_ptr>) == sizeof(counted_ptr_separate), "atomic<counted_ptr> isn't the same size as the separate version; union type-punning will be bogus");
  // TODO: write member functions to read next.ptr or read/write next_and_count

  union {  // anonymous union: the members are directly part of struct node
    alignas(2*sizeof(node*)) atomic<counted_ptr> next_and_count;
    counted_ptr_separate  next;
  };
};

En résumé, la modification atomique de deux valeurs simultanément nécessite une conception minutieuse, des considérations du compilateur et des optimisations d'alignement. . En suivant ces directives, vous pouvez implémenter des compteurs ABA sans verrouillage en C 11 avec un code efficace et correct.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!