[Boost-users] [boost-users] [boost_thread] Condition

Subject: [Boost-users] [boost-users] [boost_thread] Condition
From: Eloi Du Bois (eloi.du.bois_at_[hidden])
Date: 2010-11-26 05:48:16

Hi all,

I would like to know how can I do the following:

I have n working threads. Each one has a loop preceded by a wait condition
(1).
When the wait condition is unlocked, the thread takes a task on a queue, and
process the task.

I need to make something in the submit task function that wait until all
processes are on the wait condition (1).

How can I do that ?
I tried a while(!_nWorking) {} but this is not clean.

Here follows my threads function:

void ProcessingThread::dispatcher( const int idx )
{
    using namespace boost;
    mutex::scoped_lock readyLocker( _dispatchMutex[idx] );

    while( !_bDispStop )
    {
        --_nWorking;
        // Wait for a task
        _condProcessIn[idx].wait( readyLocker );
        ++_nWorking;
        while( !_bDispStop && !_pendingQueues[idx].empty() )
        {
            _pendingQueuesMutex[idx].lock();
            Task task = _pendingQueues[idx].front();
            _pendingQueues[idx].pop_front();
            _pendingQueuesMutex[idx].unlock();

            // Process node
            assert( task._proc );
            assert( task._procData );
            task._proc->execute( task._range, *task._procData );
        }
    }
}

Launched via:

    _nWorking = _nCpu;

    for( std::size_t i = 0; i < _nCpu; ++i )
    {
        // Create dispatcher thread
        _dispThrdGroup.create_thread( boost::bind(
&ProcessingThread::dispatcher, this, i ) );
    }

Submit task function:

void ProcessingThread::submitProcess( ProcessLauncher * proc, const
FrameRange & range, ProcessData & procData )
{
    // Get the index of the less used queue
    std::size_t idx = getLessUsedQueueIdx();

    _pendingQueuesMutex[idx].lock();
    // Append a task to the less used queue
    _pendingQueues[ idx ].push_back( Task( proc, range, procData ) );
    // Signal that a task is ready
    _condProcessIn[idx].notify_one();
    _pendingQueuesMutex[idx].unlock();

        /// UGLY !
        while( _nWorking ) {
        }
}

Thank you in advance,
Eloi Du Bois.