[boost] Atomic Operations Library

From: Matt Calabrese (rivorus_at_[hidden])
Date: 2007-07-14 04:48:26

Hello, everyone. I haven't been active around here lately, but I was a
summer of code participant
last year working on the concurrency library (Act) which aimed to bring
active objects, futures, lockfree datastructures, and parallel algorithms to
Boost. For numerous reasons, after summer of code,
my library went through some redesigns
and I eventually came to the conclusion that the scope of the library was
just much too big to be tackling all at once. For a little while I stopped
work entirely, but in the past couple of months I have started to go back
and salvage what I had done. Thanks to Dave, Jeff, and others for nudging me
back on track.

Anyway, I'm taking things a bit slower this time around and I am breaking
everything up into smaller pieces before I pull everything back together.
The first thing I've been working on since Boostcon
is making a more formal and exposed atomic operations library, with a
design influenced by the numerous C++ 0x proposals
(In particular, it's generally most similar to Peter Dimov's proposal).
It's still got a ways to go, but I have the general design out and
documented, along with a little bit of implementation
and trivial tests up and working with VC 8 and Intel 10 for windows.
I don't recommend anyone using it yet, as its only partially
implemented and not ported to other systems.
Documentation is up at http://rivorus.cupofdirt.net/ and code is in the
sandbox in soc/2006/concurrency/trunk. At this point, I'm more just looking
to see if there is any interest in me continuing with this portion of the
library as its own separate library, to potentially get it completed and up
for review sooner if interest is there, and I'd like to hear opinions on the
design (please read the rationale in the docs first, though, as I'm sure it
will attempt to answer the most obvious question about the design). Also
note that although I do not mention additional atomic
types with overloaded operators that always use interlocked operations, they
are planned.

For a while I was considering just working on an implementation of N2324,
but I personally am not a fan of its design choices and felt that this
library may be better for my own personal needs. If others don't feel the
same, I'll just leave this library internal to my own and continue on. As it
stands, it is to have a superset of the functionality of C++0x proposals
which means that it would be able to be used to implement the proposals
fairly easily, and it would also be easy to implement this library if an
implementation of one of the proposals is present. If anyone is interested
in this project and would like to help port to other compilers and
architectures, that'd be great too, but at this point I'm more just looking
for design criticism. I'm going to be away from civilization this coming
week on vacation until next Saturday, but I'll try to poke my head in once
every day or two.

Again, docs are up at :
http://rivorus.cupofdirt.net/

And source is in the sandbox under soc/2006/concurrency/trunk

Thanks.

-- 
-Matt Calabrese