C++ 11 atomica e conteggio di riferimento del puntatore condiviso intrusivo

Question

Sto scrivendo un puntatore condiviso intrusivo e sto utilizzando le strutture C++ 11 <atomic> per il contatore di riferimento. Qui ci sono i frammenti pertinenti del mio codice:

//... 
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; 
} 

ho iniziato con memory_order_acquire e memory_order_release primo momento, ma poi mi sono convinto che memory_order_consume dovrebbe essere abbastanza buono. Dopo un'ulteriore riflessione, mi sembra che anche memory_order_relaxed dovrebbe funzionare.

Ora, la domanda è se io possa usare memory_order_consume per le operazioni o potrei usare un ordine più debole (memory_order_relaxed) o dovrei usare un ordine più severo?

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; 
    } 
} 

si desidera utilizzare atomic_thread_fence tale che il delete è strettamente dopo la fetch_sub. Reference

Citazione dal testo collegato:

Aumentare il contatore di riferimento può sempre essere fatto con memory_order_relaxed: Nuovi riferimenti a un oggetto possono essere formati solo da un riferimento esistente, e passando un riferimento esistente da un thread a un altro deve già fornire la sincronizzazione richiesta.

È importante rispettare ogni possibile accesso all'oggetto in uno filo (attraverso un riferimento esistente) accadere prima di eliminare l'oggetto in un thread diverso. Ciò si ottiene eseguendo un'operazione di "rilascio" dopo aver rilasciato un riferimento (qualsiasi accesso all'oggetto tramite questo riferimento deve ovviamente verificarsi prima) e un'operazione "acquisisci" prima di eliminare l'oggetto.

Sarebbe possibile utilizzare memory_order_acq_rel per l'operazione fetch_sub , ma ciò comporta inutili operazioni di "acquisire" quando il contatore riferimento non ha ancora raggiunto il valore zero e può imporre una penalizzazione delle prestazioni .