[boost] [thread library rework] Ready to start

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 
presentation-paper:

http://www.two-sdg.demon.co.uk/curbralan/papers/accu/MoreC++Threading.pdf

  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 
(http://www.caravan.net/ec2plus/) 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 
future.

  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.

  Regards,

Ion

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.