Dlaczego std :: atomic <T> :: is_lock_free () nie jest statyczny tak samo jak constexpr?

Czy ktoś może mi powiedzieć, czy std :: atomic :: is_lock_free () nie jest statyczny tak dobrze jak constexpr? Posiadanie go jako niestatycznego i / lub jako non-constexpr nie ma dla mnie sensu.

Jak wyjaśniono na cppreference :

Wszystkie typy atomowe z wyjątkiem std :: atomic_flag mogą być implementowane przy użyciu muteksów lub innych operacji blokowania, zamiast instrukcji atomowych bez blokowania instrukcji. Typy atomowe mogą być czasami wolne od blokowania, np. Jeśli tylko wyrównane dostępy do pamięci są naturalnie atomowe w danej architekturze, niedopasowane obiekty tego samego typu muszą używać blokad.

Standard C ++ zaleca (ale nie wymaga), aby operacje atomowe bez blokowania były również pozbawione adresu, czyli odpowiednie do komunikacji między procesami wykorzystującymi pamięć współdzieloną.

Jak wspomniano przez wiele innych, std::is_always_lock_freemoże być tym, czego naprawdę szukasz.

Edycja: Aby wyjaśnić, typy obiektów C ++ mają wartość wyrównania, która ogranicza adresy ich instancji do tylko niektórych wielokrotności potęg dwóch ( [basic.align]). Te wartości wyrównania są zdefiniowane w implementacji dla typów podstawowych i nie muszą być równe wielkości typu. Mogą być również bardziej rygorystyczne niż to, co sprzęt może faktycznie obsługiwać.

Na przykład x86 (głównie) obsługuje niezrównane dostępy. Znajdziesz jednak większość kompilatorów mających alignof(double) == sizeof(double) == 8x86, ponieważ nieprzypisane dostępy mają wiele wad (szybkość, buforowanie, atomowość ...). Ale np #pragma pack(1) struct X { char a; double b; };lub alignas(1) double x;pozwala mieć „niewyrównany” doubles. Kiedy więc cppreference mówi o „wyrównanym dostępie do pamięci”, przypuszczalnie robi to w kategoriach naturalnego wyrównania typu dla sprzętu, nie używając typu C ++ w sposób sprzeczny z jego wymaganiami dotyczącymi wyrównania (którym byłby UB).

Oto więcej informacji: Jaki jest rzeczywisty wpływ udanego niezaangażowanego dostępu na x86?

Sprawdź także wnikliwe komentarze @Peter Cordes poniżej!

Możesz użyć std::is_always_lock_free

is_lock_free zależy od rzeczywistego systemu i nie można go ustalić w czasie kompilacji.

Odpowiednie wyjaśnienie:

Typy atomowe mogą być czasami wolne od blokowania, np. Jeśli tylko wyrównane dostępy do pamięci są naturalnie atomowe w danej architekturze, niedopasowane obiekty tego samego typu muszą używać blokad.

Mam zainstalowany program Visual Studio 2019 na moim komputerze z systemem Windows, a to devenv ma również kompilator ARMv8. ARMv8 pozwala na niezrównany dostęp, ale porównywanie i zamiana, zablokowane dodawanie itp. Są obowiązkowe do wyrównania. A także czyste ładowanie / przechowywanie za pomocą ldplub stp(para ładująca lub para 32-bitowych rejestrów) gwarantuje, że będą atomowe tylko wtedy, gdy są naturalnie wyrównane.

Napisałem więc mały program, aby sprawdzić, co is_lock_free () zwraca dla dowolnego wskaźnika atomowego. Oto kod:

#include <atomic>
#include <cstddef>

using namespace std;

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

I to jest demontaż isLockFreeAtomic

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

To tylko returns trueaka 1.

Ta implementacja decyduje się na użycie, alignof( atomic<int64_t> ) == 8więc każda atomic<int64_t>jest poprawnie wyrównana. Pozwala to uniknąć konieczności sprawdzania wyrównania środowiska wykonawczego dla każdego ładunku i magazynu.

(Uwaga redaktora: jest to powszechne; większość rzeczywistych implementacji C ++ działa w ten sposób. Dlatego std::is_always_lock_freejest tak przydatna: ponieważ zazwyczaj jest prawdziwa dla typów, w których is_lock_free()zawsze jest prawdziwa.)