I'm stuck with a problem I quite don't understand and that involve either
boost::future/promise or tbb::concurrent_queue,
or my understanding of using both.
I think there is a high probability that someone here will point to the
problem, but I will report too to the tbb forum
Some context:
- I'm using VS2012 Update 2
- it's 32 bit DEBUG mode
- I use Boost.Thread V4 (in CMake I set "add_definitions(
-DBOOST_THREAD_VERSION=4 )" to force it )
- I use TBB 4.1 Update 2
I've setup a test (using GTest) which reproduce the problem:
############
int TRUC = 42;
TEST( Test_WorkQueue, future_promise_shared_work )
{
WorkQueue work_queue;
// I'm doing this like that because it reflect the use case I have,
// I didn't find another way to have the promise alive in a
container which don't allow move semantic
auto do_some_work = [&]()-> boost::future
{
struct K
{
boost::promise promise;
void foo()
{
promise.set_value( &TRUC );
}
};
auto object_ptr = std::make_shared<K>(); // D:
work_queue.push( [=]
{
object_ptr->foo();
});
return object_ptr->promise.get_future();
};
auto ft_value = do_some_work();
work_queue.execute();
auto value = ft_value.get();
ASSERT_EQ( &TRUC, value ); // this fails, value == 0xfeeefeee
}
##########
My WorkQueue type use tbb::concurrent_queue and is defined as:
##########
class WorkQueue
{
public:
template< class WorkTask >
void push( WorkTask&& task )
{
m_task_queue.push( std::forward<WorkTask>( task ) );
}
/** Execute all the work queued until now. */
void execute()
{
if( m_task_queue.empty() )
return;
bool end_of_work = false;
m_task_queue.push( [&]{ end_of_work = true; } );
std::function work;
while( !end_of_work && m_task_queue.try_pop( work ) )
{
work();
}
}
private:
mutable tbb::concurrent_queue< std::function > m_task_queue;
};
############
It's basically a simple wrapper around the concurrent_queue, but maybe the
execute() code have an impact.
THE PROBLEM:
The test fails.
value == 0xfeeefeee as soon as the get() call is done.
Using the debugger, I can't figure where the data is lost. It seem that
everything is correct until when all
the hierarchy of function call returns the result...which is different and
wrong once out of the function.
I first wrote this test with std::vector< std::function >
instead of the concurrent queue to check if it was boost::future/promise
which was not working well with Boost.Thread V4.
With the vector instead of concurrent_queue, the code works perfectly.
Does someone have an idea what is going on?
Joel Lamotte
