[Boost-users] [Thread] Beginner question regarding thread groups

From: Michel Lestrade (michel.lestrade_at_[hidden])
Date: 2008-08-24 18:58:44

Hi,

I am considering rewriting part of our ray tracing code to use the Boost 
thread library. As many of you might know, ray tracing is a task that 
lends itself well to a parallel approach since each ray is independent 
from the other. However, the code right now is in Fortran which doesn't 
support task level parallelism easily ... The thread_group class seems 
ideally suited to my needs (one thread == one ray) but there is at least 
one problem I envision that I would like to solve before embarking on 
this fairly time-consuming rewrite.

Just to give you some background, what we are doing is not ray tracing 
in the visualization/render sense: rather, it is a scientific 
application used to determine the light emission pattern of certain 
devices without waveguides (such as LEDs). So keep in mind that not all 
the conventional ray tracing approaches will work for me. I also come 
from a physics/engineering background so I am not up to date on all the 
newer object-oriented techniques and concepts.

Now to the heart of the matter: in our approach, each of the initial 
rays is split into a reflected/refracted ray every time a material 
interface is reached which generates a secondary ray. Each secondary ray 
can generate other secondary rays when they hit an interface and so on 
... This goes on until the power in each ray has decayed sufficiently 
(the material is usually absorbing), all rays exit the device or a 
maximum number of rays has been reached. That means that I do not know 
ahead of time how many rays (or threads) that I will have.

This brings me to my question: can I add new threads to thread group 
while it is running ? All of the code samples for thread_group seem to 
call add_thread() on a fixed number of objects before calling 
join_all(). So it seems that the execution of the thread does not start 
at the moment it is added to the group but at the moment join_all() is 
called.

In my case, I would have a join_all() first and then periodically add 
new threads: so this is basically a dynamic queue with new rays being 
pushed at the end.  How can I start these threads automatically if 
add_thread does not start the execution ? Should I call join() on the 
new threads before adding them to the thread group instead of using 
join_all() ?

Should I give up on thread_group and store my thread objects in some 
other container ?

Any alternative solutions or a code sample with a dynamically changing 
thread_group would be appreciated. I am hoping someone has faced a 
similar problem in another context ...

Regards,

Michel Lestrade
Crosslight Software

P.S. Since I am a new user of Boost, I will go ahead and use the latest 
version (1.36.0). I already built the binaries for my tool set (VS 2008).