C++ 11 atomów i natarczywa dzielona liczba odnośników wskaźnik

Question

Piszę uciążliwy udostępniony wskaźnik i używam obiektów C++ 11 <atomic> dla licznika odwołań. Oto stosowne fragmenty mojego kodu:

//... 
mutable std::atomic<unsigned> count; 
//... 

void 
SharedObject::addReference() const 
{ 
    std::atomic_fetch_add_explicit (&count, 1u, 
     std::memory_order_consume); 
} 

void 
SharedObject::removeReference() const 
{ 
    bool destroy; 

    destroy = std::atomic_fetch_sub_explicit (&count, 1u, 
     std::memory_order_consume) == 1; 

    if (destroy) 
     delete this; 
} 

zacząłem z memory_order_acquire i memory_order_release ale potem przekonałem się, że memory_order_consume powinny być wystarczająco dobre. Po dalszych rozważaniach wydaje mi się, że powinien zadziałać nawet memory_order_relaxed.

Teraz pytanie brzmi, czy mogę użyć memory_order_consume do operacji lub czy mogę użyć słabszego zamawiania (memory_order_relaxed), czy też powinienem zastosować bardziej rygorystyczne zamówienie?

Answer 1

void 
SharedObject::addReference() const 
{ 
    std::atomic_fetch_add_explicit (&count, 1u, std::memory_order_relaxed); 
} 

void 
SharedObject::removeReference() const 
{ 
    if (std::atomic_fetch_sub_explicit (&count, 1u, std::memory_order_release) == 1) { 
     std::atomic_thread_fence(boost::memory_order_acquire); 
     delete this; 
    } 
} 

Chcesz użyć atomic_thread_fence takie, że delete jest ściśle po fetch_sub. Reference

Cytat połączonego tekstu:

Zwiększenie licznika odniesienia zawsze można zrobić z memory_order_relaxed: Nowe odniesienia do obiektu mogą być tworzone tylko z istniejącego odniesienia i przechodzącej istniejący odwołanie od jeden wątek musi już zapewniać wymaganą synchronizację.

Ważne jest, aby wymusić możliwy dostęp do obiektu w jednym wątku (przez istniejącą referencję) przed usunięciem obiektu w innym wątku. Osiąga się to przez operację "zwolnienie" po zrzuceniu referencji (dowolny dostęp do obiektu poprzez to odniesienie musi oczywiście nastąpić wcześniej) i operację "pozyskiwania" przed usunięciem obiektu.

byłoby możliwe użycie memory_order_acq_rel dla funkcjonowania fetch_sub , ale powoduje to niepotrzebne „zdobyć” operacji, gdy licznik odniesienie jeszcze nie dotrzeć do zera i może nałożyć karę wydajności .