C++11 atomics and intrusive shared pointer reference count

Question

I am writing intrusive shared pointer and I am using C++11 <atomic> facilities for reference counter. Here are the relevant fragments of my code:

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

I have started with memory_order_acquire and memory_order_release first but then I convinced myself that memory_order_consume should be good enough. After further deliberation it seems to me that even memory_order_relaxed should work.

Now, the question is whether I can use memory_order_consume for the operations or could I use weaker ordering (memory_order_relaxed) or should I use stricter ordering?

Since the counter essentially acts as a recursive lock for the delete statement, I'd say that "acquire" in the addReference and "release" in the removeReference are the right orderings. But your addReference should also make sure that the counter wasn't zero! — Kerrek SB
– Kerrek SB, Commented Apr 22, 2012 at 14:41
@KerrekSB: The counter can be zero in addReference() after the object is first created before it is assigned to a SharedPtr<>. Acquire/release semantics seems that it should always work. But is it not possible to use weaker ordering constraint and why not? — wilx
– wilx, Commented Apr 22, 2012 at 14:45
About the zero: Suppose the refcount is 1. Now thread 1 wants to delete the object and calls subtract. If at this point thread 2 wants to increase the thread count, it increments zero to one, but thread 1 will go ahead and delete the object anyway. That should be avoided. — Kerrek SB
– Kerrek SB, Commented Apr 22, 2012 at 17:13
@KerrekSB: That sounds like it would be a situation with unbalanced addReference()/removeReference() or with unprotected access to instance of SharedPtr which I would consider undefined behaviour. SharedPtrs as members themselves need to be protected by mutexes etc. the same as other members of its enclosing class. — wilx
– wilx, Commented Apr 22, 2012 at 19:45
@KerrekSB "I'd say that "acquire" in the addReference" acquire of what release? — curiousguy
– curiousguy, Commented Jul 29, 2012 at 3:17

user2k5 · Accepted Answer · 2012-04-23 04:37:25Z

22

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

You want to use atomic_thread_fence such that the delete is strictly after the fetch_sub. Reference

Quote from the linked text:

Increasing the reference counter can always be done with memory_order_relaxed: New references to an object can only be formed from an existing reference, and passing an existing reference from one thread to another must already provide any required synchronization.

It is important to enforce any possible access to the object in one thread (through an existing reference) to happen before deleting the object in a different thread. This is achieved by a "release" operation after dropping a reference (any access to the object through this reference must obviously happened before), and an "acquire" operation before deleting the object.

It would be possible to use memory_order_acq_rel for the fetch_sub operation, but this results in unneeded "acquire" operations when the reference counter does not yet reach zero and may impose a performance penalty.

edited Apr 23, 2012 at 4:37

answered Apr 22, 2012 at 15:26

user2k5

8271 gold badge7 silver badges9 bronze badges

Sign up to request clarification or add additional context in comments.

7 Comments

wilx Over a year ago

While I have already accepted the answer and implemented my intrusive pointer that way, the quote made me think a bit and here is another question. What about relaxing the decrement to memory_order_relaxed and making the true branch of the if() use memory_order_acq_rel?

user2k5 Over a year ago

with your _relaxed, then _acq_rel, there is no strictly ordering of fetch_sub(_relaxed) and fence(_acq_rel) then delete. You may be interested in this page.

wilx Over a year ago

Ok, after reading the page I think I understand that it cannot be fetch_sub(_relaxed). It is because any _relaxed operation is not ordered against other operations at all. But what about fetch_sub(_consume) and fence(_acq_rel)? There it seems to me that fetch_sub(_consume) poses a compiler reordering barrier and fence(_acq_rel) orders all loads and stores against the rest of the machine and the following delete will have consistent view of the memory. Or am I wrong?

user2k5 Over a year ago

2 points here: 1) _consume is for pointers such that no operations related to the pointer after the _consume statement can be moved before it. You don't want to use _consume here. 2) if you are talking about the fetch_sub(_acquire) (instead of _consume) here, _acquire variable does not pose barrier for the delete strictly after fetch_sub, but the other way round.

wilx Over a year ago

Ok, I think I mostly get it now. I have missed this bit from cppreference "The reads from the affected memory location that carry data dependency cannot be reordered before the load; other reads can be. On most platforms, this affects compiler optimization only." This was very enlightening discussion for me. Thank you.

|

Collectives™ on Stack Overflow

C++11 atomics and intrusive shared pointer reference count

1 Answer 1

7 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

7 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related