CODEWITHSUNDEEP
c++visual-studio-2010concurrencyasynchronoustask-parallel-library
Michael Repucci
Michael Repucci

Reputation: 1663

In the Concurrency Runtime, can I use parallel_invoke or task_group with non-const function objects?

I'm using the Concurrency Runtime with Visual C++ 2010, and am interested in the capabilities of parallel_invoke and task_group (parts of the PPL or Parallel Patterns Library). I'd like to be able to start two parallel actions via function objects (rather than lambda functions or function pointers), but I can't get the code to compile, because of an error:

error C3848: expression having type 'const C' would lose some const-volatile qualifiers in order to call 'void C::operator ()(void)'

But if I make the C::operator()() const, then I lose a lot of the benefits of a function object, namely, that its state is mutable and maintained internally between calls. Am I missing something here? Is there a way that I could invoke non-const function objects in parallel?

BTW, I realize that I could use the Asynchronous Agents Library, and derive the classes from the Concurrency::agent class, but please consider that beyond the scope of this question (in part due to the lack of exception handling and cancellation options).

I'm just interested in what I can do with the PPL, and while there are examples with lambda functions and function pointers, I couldn't find or create any examples with function objects that do more than a parallel "Hello World". I'm looking for something that really takes advantage of function objects, and, if possible, also concurrent containers.

Upvotes: 1

Views: 1969

Answers (2)

Rick
Rick

Reputation: 3353

The functors are required to be immutable because when they are scheduled via parallel_invoke and task_group::run they are copied and the potential for race conditions during state accumulations is high. Particularly with task_group::run the lifetime of the task has the potential to outlive where the task was declared (i.e. you declare it on the stack and the stack exits but the task hasn't run yet)

The simplest technique that can be used to work around this is to capture the functor by reference in a lambda (yes I know you said that you didn't want to use lambdas directly).

   NonConstFunctor func;
   Concurrency::task_group tasks;
   // c3848
   //tasks.run(func);
   //work around this by capturing func by reference
   tasks.run([&func](){func();});

You can also use the 'lightweight task' facilities of the scheduler class (see Scheduler::ScheduleTask) which doesn't require const since it has a typical void* API.

You'll need to build a wrapper function to handle this, but this is straightforward and there is one in the sample pack at http://code.msdn.com/concrtextras

-Rick

Upvotes: 2

Puppy
Puppy

Reputation: 146978

Why not just make operator()() const and use mutable to keep the state?

But, of course, you're running some serious risks here, because you'd be responsible for all thread-safety related issues with mutating that state. These function objects are not supposed to be doing that.

Edit: Seriously. Just use lambdas. Function objects are dead in VS2010. Why should a C++0x compiler post code showing the function idiom of the past that they spent time and money replacing? It's contradictory and insane.

Upvotes: 0

Related Questions