C++ 11 atomics y cuenta de referencia de puntero compartido intrusivo

Question

Estoy escribiendo puntero compartido intrusivo y estoy usando C++ 11 <atomic> instalaciones para el contador de referencia. Estos son los fragmentos relevantes de mi código:

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

he empezado con memory_order_acquire y memory_order_release principio, pero luego me convencí de que memory_order_consume debe ser lo suficientemente bueno. Después de una mayor deliberación, me parece que incluso memory_order_relaxed debería funcionar.

Ahora, la pregunta es si puedo usar memory_order_consume para las operaciones o podría usar un orden más débil (memory_order_relaxed) o debería usar un orden más estricto?

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

que desea utilizar atomic_thread_fence tal que el delete es estrictamente después de la fetch_sub. Reference

Cita del texto vinculado:

El aumento del contador de referencia siempre se puede hacer con memory_order_relaxed: New referencias a un objeto sólo se pueden formar de una referencia existente, y que pasa una referencia existente desde un hilo a otro ya debe proporcionar cualquier sincronización requerida.

Es importante hacer cumplir cualquier posible acceso al objeto en un hilo (a través de una referencia existente) antes de eliminar el objeto en un hilo diferente. Esto se logra mediante una operación de "liberación" después de eliminar una referencia (cualquier acceso al objeto a través de esta referencia debe obviamente ocurrir antes), y una operación "adquirir" antes de eliminar el objeto.

Sería posible utilizar memory_order_acq_rel para la operación fetch_sub , pero esto se traduce en operaciones que no sean necesarios "adquirir" cuando el contador referencia todavía no llega a cero y puede imponer una penalización de rendimiento .