Threaded Building Blocks (TBB) enqueue task with lambda

Question

The TBB documentation gives this example of using lambda expressions with parallel_for, but doesn't provide an example of using lambda expressions with tbb::task::enqueue.

I am looking for a simple example of tbb::task::enqueue with a lambda expression.

Did you try to adapt it to `task::enqueue`? What did go wrong? — Adri C.S., Mar 12 '14 at 08:37
I'm not sure how to inherit from ```tbb::task``` inside the lambda expression. — Cosmo Harrigan, Mar 12 '14 at 08:43
Note that I have never used lambdas. I commented that because the more info you provide, the higher the chances are for someone to answer your question ASAP. — Adri C.S., Mar 12 '14 at 08:49

score 7 · Accepted Answer · edited May 23 '17 at 11:58

Low-level tasks in TBB do not directly support lambda expressions. But with some extra coding you might create syntax-sugar helpers to do what you want.

You'd need to create a task class that calls a given functor:

template<typename F>
class lambda_task : public tbb::task {
    F my_func;
    /*override*/ tbb::task* execute() {
        my_func();
        return NULL;
    }
public:
    lambda_task( const F& f ) : my_func(f) {}
};

And then, you'd need to create a function template that takes a functor/lambda, wraps it into lambda_task, and enqueues:

template<typename F>
void tbb_enqueue_lambda( const F& f ) {
    tbb::task::enqueue( *new( tbb::task::allocate_root() ) lambda_task<F>(f) );
}

And then you might use this function with lambda expressions:

tbb_enqueue_lambda( []{ /* code here */ } );

The official TBB API classes that support lambda expressions, such as task_group and task_arena, use very similar code internally.

Update: to pass a function pointer and arguments to call it with, the above approach can be extended in some ways:

In C++03, you'd need to add separate class templates for a task with one argument, two arguments, etc., and corresponding overloads of tbb_enqueue_lambda function
In C++11, you could use variadic templates, storing the actual arguments in an std::tuple inside lambda_task, and 'unpacking' those for the function call. Unpacking is not trivial, but there are a few SO topics covering that already: "unpacking" a tuple to call a matching function pointer, How do I expand a tuple into variadic template function's arguments?, and other.

Improvement suggestions: if lambda returns non-void, use its return value to produce the `tbb::task*` to allow chaining. Maybe split the creation of the `lambda_task` from the `enqueue`? Maybe not. — Yakk - Adam Nevraumont, Mar 12 '14 at 16:28
Thank you for the helpful answer! How could you modify this to enqueue a pointer to a function that has arguments directly? This works: ```tbb_enqueue_lambda([=]{doTask(arg);});```, as well as ```tbb_enqueue_lambda(&doTask);```, but how could you pass the arguments without the lambda expression? — Cosmo Harrigan, Mar 12 '14 at 22:09
Why not to add this to TBB? `task::enqueue()` misses any high-level API — Anton, Sep 22 '17 at 17:09

Threaded Building Blocks (TBB) enqueue task with lambda

1 Answers1

Linked