Pourquoi std :: atomic <T> :: is_lock_free () n'est-il pas aussi statique que constexpr?

Quelqu'un peut-il me dire si std :: atomic :: is_lock_free () n'est pas statique aussi bien que constexpr? L'avoir non statique et / ou non constexpr n'a pas de sens pour moi.

Comme expliqué sur cppreference :

Tous les types atomiques à l'exception de std :: atomic_flag peuvent être implémentés en utilisant des mutex ou d'autres opérations de verrouillage, plutôt qu'en utilisant les instructions CPU atomiques sans verrouillage. Les types atomiques peuvent également être parfois sans verrouillage, par exemple si seuls les accès mémoire alignés sont naturellement atomiques sur une architecture donnée, les objets mal alignés du même type doivent utiliser des verrous.

La norme C ++ recommande (mais n'exige pas) que les opérations atomiques sans verrouillage soient également sans adresse, c'est-à-dire adaptées à la communication entre les processus utilisant la mémoire partagée.

Comme mentionné par plusieurs autres, c'est std::is_always_lock_freepeut-être ce que vous recherchez vraiment.

Edit: Pour clarifier, les types d'objets C ++ ont une valeur d'alignement qui restreint les adresses de leurs instances à seulement certains multiples de puissances de deux ( [basic.align]). Ces valeurs d'alignement sont définies par l'implémentation pour les types fondamentaux et n'ont pas besoin d'être égales à la taille du type. Ils peuvent également être plus stricts que ce que le matériel pourrait réellement prendre en charge.

Par exemple, x86 (principalement) prend en charge les accès non alignés. Cependant, vous trouverez la plupart des compilateurs ayant alignof(double) == sizeof(double) == 8pour x86, car les accès non alignés ont une foule d'inconvénients (vitesse, mise en cache, atomicité ...). Mais par exemple, #pragma pack(1) struct X { char a; double b; };ou alignas(1) double x;vous permet d'avoir des "non alignés" double. Ainsi, lorsque cppreference parle d '"accès à la mémoire alignés", il le fait probablement en termes d'alignement naturel du type pour le matériel, n'utilisant pas un type C ++ d'une manière qui contredit ses exigences d'alignement (qui seraient UB).

Voici plus d'informations: Quel est l'effet réel des accès non alignés réussis sur x86?

Veuillez également consulter les commentaires perspicaces de @Peter Cordes ci-dessous!

Vous pouvez utiliser std::is_always_lock_free

is_lock_free dépend du système réel et ne peut pas être déterminé au moment de la compilation.

Explication pertinente:

Les types atomiques peuvent également être parfois sans verrouillage, par exemple si seuls les accès mémoire alignés sont naturellement atomiques sur une architecture donnée, les objets mal alignés du même type doivent utiliser des verrous.

J'ai installé Visual Studio 2019 sur mon PC Windows et ce devenv a également un compilateur ARMv8. ARMv8 autorise les accès non alignés, mais la comparaison et les échanges, les ajouts verrouillés, etc. doivent être alignés. De plus, la charge pure / stockage pur utilisant ldpou stp(paire de charge ou paire de magasins de registres 32 bits) ne sont garantis atomiques que lorsqu'ils sont naturellement alignés.

J'ai donc écrit un petit programme pour vérifier ce que is_lock_free () renvoie pour un pointeur atomique arbitraire. Voici donc le code:

#include <atomic>
#include <cstddef>

using namespace std;

bool isLockFreeAtomic( atomic<uint64_t> *a64 )
{
    return a64->is_lock_free();
}

Et c'est le démontage de isLockFreeAtomic

|?isLockFreeAtomic@@YA_NPAU?$atomic@_K@std@@@Z| PROC
    movs        r0,#1
    bx          lr
ENDP

C'est juste returns true, aka 1.

Cette implémentation choisit d'utiliser alignof( atomic<int64_t> ) == 8afin que chaque atomic<int64_t>soit correctement aligné. Cela évite d'avoir à effectuer des vérifications d'alignement d'exécution sur chaque chargement et chaque magasin.

(Note de l'éditeur: c'est courant; la plupart des implémentations C ++ réelles fonctionnent de cette façon. C'est pourquoi std::is_always_lock_freec'est si utile: parce que c'est généralement vrai pour les types où is_lock_free()c'est toujours vrai.)