How to start all TBB continue_nodes which have no dependencies

Question

With TBB you can make a nice DAG of tasks and it can automatically run them in parallel. Example from the documentation:

typedef continue_node< continue_msg > node_t;
typedef const continue_msg & msg_t;

int main() {
  tbb::flow::graph g;
  node_t A(g, [](msg_t){ a(); } );
  node_t B(g, [](msg_t){ b(); } );
  node_t C(g, [](msg_t){ c(); } );
  node_t D(g, [](msg_t){ d(); } );
  node_t E(g, [](msg_t){ e(); } );
  node_t F(g, [](msg_t){ f(); } );
  make_edge(A, B);
  make_edge(B, C);
  make_edge(B, D);
  make_edge(A, E);
  make_edge(E, D);
  make_edge(E, F);
  A.try_put( continue_msg() );
  g.wait_for_all();
  return 0;
}

That works fine, however it assumes I have some well-known root node and all nodes are dependants of that node. What if I have some more generic network that might have multiple root nodes?

int main() {
  tbb::flow::graph g;

  // Imagine a function did this but in a generic way:      
  node_t A(g, [](msg_t){ a(); } );
  node_t B(g, [](msg_t){ b(); } );
  node_t C(g, [](msg_t){ c(); } );
  node_t D(g, [](msg_t){ d(); } );
  node_t E(g, [](msg_t){ e(); } );
  node_t F(g, [](msg_t){ f(); } );
  make_edge(A, B);
  make_edge(B, C);
  make_edge(D, E);

  // Now how do I now do this?
  A.try_put( continue_msg() );
  D.try_put( continue_msg() );
  F.try_put( continue_msg() );

  g.wait_for_all();
  return 0;
}

I hope that example is clear - basically I have a load of tasks, but the dependencies between them are dynamic so they might end up not depending on each other at all. How do I say to TBB: "Ok I want all these tasks run."

(Obviously I can manually count the number of dependencies for each task but I'm asking if TBB does that already.)

Edit: To be clear I'm asking if there is a function that automatically starts all the root nodes. Obviously I can do it manually - that's what the example above does!

Answer 1

This is probably a misunderstanding about flow::graph itself. You must specify dependencies programmatically by adding arcs between nodes. You try_put to the first node of the graph to start it. This is the only way to start a graph.

If you have external events that you want to trigger a graph to run, you must create a listener to that event which try_puts to start the graph.

You can create a multifunction_node that never returns, which you can have looking for events and sending messages, but this is poor TBB design. You would be permanently locking a TBB task to that multifunction_node, a no-no. And you still have to try_put something to the multifunction_node to start it.