Threaded Building Blocks (TBB) enqueue task with l

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.

Answer 1

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.