C++ 0x | Dlaczego std :: atomic przeciąża każdą metodę za pomocą volatile-qualifier?

Question

Poniższy fragment z obecnego projektu pokazuje, co to znaczy:

namespace std { 
    typedef struct atomic_bool { 
     bool is_lock_free() const volatile; 
     bool is_lock_free() const; 
     void store(bool, memory_order = memory_order_seq_cst) volatile; 
     void store(bool, memory_order = memory_order_seq_cst); 
     bool load(memory_order = memory_order_seq_cst) const volatile; 
     bool load(memory_order = memory_order_seq_cst) const; 
     operator bool() const volatile; 
     operator bool() const; 
     bool exchange(bool, memory_order = memory_order_seq_cst) volatile; 
     bool exchange(bool, memory_order = memory_order_seq_cst); 
     bool compare_exchange_weak(bool&, bool, memory_order, memory_order) volatile; 
     bool compare_exchange_weak(bool&, bool, memory_order, memory_order); 
     bool compare_exchange_strong(bool&, bool, memory_order, memory_order) volatile; 
     bool compare_exchange_strong(bool&, bool, memory_order, memory_order); 
     bool compare_exchange_weak(bool&, bool, memory_order = memory_order_seq_cst) volatile; 
     bool compare_exchange_weak(bool&, bool, memory_order = memory_order_seq_cst); 
     bool compare_exchange_strong(bool&, bool, memory_order = memory_order_seq_cst) volatile; 
     bool compare_exchange_strong(bool&, bool, memory_order = memory_order_seq_cst); 
     atomic_bool() = default; 
     constexpr atomic_bool(bool); 
     atomic_bool(const atomic_bool&) = delete; 
     atomic_bool& operator=(const atomic_bool&) = delete; 
     atomic_bool& operator=(const atomic_bool&) volatile = delete; 
     bool operator=(bool) volatile; 
    } atomic_bool; 
} 

Lotny jest przechodnia. W związku z tym nie można wywołać nielotnej funkcji składowej z obiektu zmiennego. Z drugiej strony dozwolone jest wywoływanie funkcji zmiennej z obiektu nieulotnego.

Czy istnieje zatem różnica w implementacji między lotnymi i nielotnymi funkcjami członków w klasach atomowych? Innymi słowy, czy istnieje potrzeba trwałego przeciążenia?

Answer 1

Myślę, że lotne przeciążenia istnieją ze względów wydajnościowych. Niestabilne odczyty i zapisy są z natury droższe niż nieulotne odczyty i zapisy w C++ 0x, ponieważ model pamięci stawia pewne rygorystyczne wymagania, które zapobiegają buforowaniu wartości zmiennych zmiennych. Jeśli wszystkie funkcje były oznaczone jako niestabilne, kod niekoniecznie musiałby dokonać pewnych optymalizacji, które w przeciwnym razie poprawiłyby wydajność. Posiadanie rozróżnienia umożliwia kompilatorowi optymalizację nieulotnych odczytów i zapisów, o ile jest to możliwe, przy jednoczesnym poniżeniu z wdziękiem, gdy wymagane są ulotne odczyty i zapisy.

Answer 2

Po pierwsze, brzmi to zbędnie, aby stworzyć niestabilny std :: atomowy. Właściwie mogę sobie wyobrazić przydatną sytuację. Zakładając, że mamy stały adres urządzenia (pamięci), na którym chcemy działać. Z uwagi na to, że klasy std :: atomic_xxx oraz std :: atomic <> wielkości klas szablonów powinny być tej samej wielkości co ich wbudowane typy, możesz chcieć obsłużyć oba: Wykonywanie operacji atomowych z kontrolą nad zamawianie pamięci i upewnij się, że dostęp do naszego obiektu atomowego nigdy nie jest zoptymalizowany. Tak więc możemy zadeklarować coś takiego:

std::atomic<long> volatile* vmem_first4 = reinterpret_cast<std::atomic<long> volatile*>(0xxB8000);