Boost logo

Boost :

From: Talbot, George (Gtalbot_at_[hidden])
Date: 2006-11-22 16:48:07


I've attached to this e-mail a working prototype of a wrapper for
shared_ptr that uses a spinlock so that the shared_ptr may be updated
atomically from multiple threads. For example, two threads can both
attempt to set the value of the same shared_ptr, and the last one will
win. This wrapper includes a "compare_and_set" method for performing
lock-free-style "read, copy, attempt swap, repeat" updating to a data
structure, though, of course because the wrapper uses a spinlock, it
isn't truly lock free.

This is a demonstration to see if there's interest out there. It's
useful in my multithreaded application, and I would like to contribute
it to BOOST if it's wanted. There are several issues and questions I'd
want to resolve first, though:

   - This prototype only compiles on platforms that have
     pthread_spinlock_t available.

   - Does weak_ptr<> need to be similarly wrapped?

   - If weak_ptr<> needs to be wrapped, that would imply that
     enable_atomic_shared_from_this would need to be defined,
     as its implementation uses weak_ptr<>.

   - Is it possible to use locked compare-and-exchange instructions
     to swap the entire shared_ptr<> 8-byte (x86) structure and get
     rid of the spinlock? Instead of a bunch of assembly, would it
     make more sense to use the prototype atomic_ops library from
     Hans Boehm at HP?

   - There's also Chris Thomasson's refcount library.

   - Is anyone else working on something like this? I wouldn't want
     to duplicate effort. Specifically, is anyone working on
     something that tries to stick to the public interface of

My major interest in this is that I like the public API of shared_ptr
very much, and since it appears to be headed for standardization, I'm
interested in a variant that's any of:

   - A shared_ptr<> implementation with atomic safety guarantees.

                        - or -

   - A wrapper that can be used to wrap shared_ptr<> that has as
     close an interface as I can get to shared_ptr<>,
     a-la the prototype I've attached.

                        - or -

   - Some other template class that doesn't use shared_ptr<> at
     all but shares a most/all of the public API of shared_ptr<>.

Ideally, I want a solution to be lock-free. My next steps will be to
investigate prototypes using (either/both) the HP library and/or the
Thomasson library.

Please let me know if you think I'm going down a dead-end here, or if
you'd like to help.


George T. Talbot
P.S.  Right now I have, in my large multithreaded program, a single
typedef, previously using shared_ptr<> when it was single-threaded,
currently using atomic_shared<> now that it's multithreaded, that I can
replace with something else, so alternate implementations are not
drastically hard to try out.

Boost list run by bdawes at, gregod at, cpdaniel at, john at