Boost logo

Boost :

From: Ion Gaztañaga (igaztanaga_at_[hidden])
Date: 2005-08-26 12:08:26

Hi to all,

  As previously discussed here, I'm trying to organize a boost thread
rework in order to help C++ thread standarization. In this moment,
Kevlin Henney is working on a paper to be presented int the next ISO
meeting based in his C++ thread work which is available here, in this

  This approach proposes futures approach to C++ threads, and also
defines lock mechanisms similar to boost::mutex and boost::condition
with some changes. I've contacted with Kevlin and he is ready to help as
much as he can with the Boost community to develop a good thread
proposal. The idea is that we could have a working implementation of the
  proposal above boost threads. The presentation-paper does not
currently cover all the functionality we have, like thread specific
storage, barriers and read-write locks neither proposed message-queue,
so there is a lot of work to do.

  There is an active discussion on futures that can be added to this
effort since it proposes future-operations that are not incompatible
with the proposal, but an extension. We need to keep the thread
discussion constructive and effective, although any of us has strong
opinions on threading. It would be nice if we could first concentrate in
"basic" functionality that does not forbid future proposals. For
example, thread cancellation is a hard issue, but it can be added later
if the proposal allows to do that.

  I'm also concerned with (in my opinion) needed compatibility with
Embedded C++. C++ will grow a lot in this area and obviously, threads
are very used. Embedded C++ specification
( avoids templates and exceptions, so we
need to think some alternatives (apart from exceptions, just like
iostreams do) to do error checking. And provide some low-resource
specializations or alternatives to the full-scale C++ threading.

  There are many areas to cover, but in this post I would like to say
that the reworking effort is alive and we need to do some serious work.
Like always, ideas are good but work is better, so let's try to avoid
extremely long discussions so that we can have C++ threads in the
following standard.

  I'm ready to try to organize a bit the effort and Michael Glassford,
mantainer of boost threads, is ready to help, although he has no much
time. Anyway, we know there are some good thread implementations out
there, and we can take some ideas. And let's try to create a basic,
simple, working thread tools but without forbidding extensions in the

  For the moment I've implemented the thread-launching mechanism
(threader and joiner classes) described in Kevlin's paper above boost
threads. It's in Boost Vault, in thread_ex directory. I plan to add more
features detailed in the paper soon (mutexes, conditions, etc...) above
boost threads, because it provides a good portable framework. Currently
there is no other documentation that Kevlin's presentation, but I will
start making some boost documentation in this library, once we start
defining more elements.

  I will try to write some posts regarding concrete issues, like
barriers, read-write mutexes or message-queues so that we can focus the
work. Obviously if anyone wants to join this effort with ideas, code,
organization etc... we can split the work on several issues.



P.D.: I plan to continue Shmem development although, I will have less
time to work on it because of this threading work. I plan to upload a
new snapshot soon.

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