Sending to One or Multiple Successors

An important characteristic of the predefined nodes is whether they push their output to a single successor or broadcast to all successors. The following predefined nodes push messages to a single successor:

• buffer_node

• queue_node

• priority_queue_node

• sequencer_node

Other nodes push messages to all successors that will accept them.

The nodes that push to only a single successor are all buffer nodes. Their purpose is to hold messages temporarily, until they are consumed downstream. Consider the example below:

void use_buffer_and_two_nodes() {
  graph g;


  function_node< int, int, rejecting > f1( g, 1, []( int i ) -> int {
    spin_for(0.1);
    cout << "f1 consuming " << i << "\n";
    return i;
  } );


  function_node< int, int, rejecting > f2( g, 1, []( int i ) -> int {
    spin_for(0.2);
    cout << "f2 consuming " << i << "\n";
    return i;
  } );


  priority_queue_node< int > q(g);


  make_edge( q, f1 );
  make_edge( q, f2 );
  for ( int i = 10; i > 0; --i ) {
    q.try_put( i );
  }
  g.wait_for_all();
}

First, function_nodes by default queue up the messages they receive at their input. To make a priority_queue_node work properly with a function_node, the example above constructs its function_nodes with its buffer policy set to rejecting. So, f1 and f2 do not internally buffer incoming messages, but instead rely on upstream buffering in the priority_queue_node.

In the above example, each message buffered by the priority_queue_node is sent to either f1 or f2, but not both.

Let’s consider the alternative behavior; that is; what if the priority_queue_node broadcasts to all successors. What if some, but not all, nodes accept a message? Should the message be buffered until all nodes accept it, or be only delivered to the accepting subset? If the node continues to buffer the message, should it eventually deliver the messages in the same order to all nodes or in the current priority order at the time the node accepts the next message? For example, assume a priority_queue_node only contains “9” when a successor node, f1, accepts “9” but another successor node, f2, rejects it. Later a value “100” arrives and f2 is available to accept messages. Should f2 receive “9” next or “100”, which has a higher priority? In any case, trying to ensure that all successors receive each message creates a garbage collection problem and complicates reasoning. Therefore, these buffering nodes push each message to only one successor. And, you can use this characteristic to create useful graph structures such as the one shown in the graph above, where each message will be processed in priority order, by either f1 or f2.

But what if you really do want both f1 and f2 to receive all of the values, and in priority order? You can easily create this behavior by creating one priority_queue_node for each function_node, and pushing each value to both queues through a broadcast_node, as shown below:

graph g;


function_node< int, int, rejecting > f1( g, 1, []( int i ) -> int {
  spin_for(0.1);
  cout << "f1 consuming " << i << "\n";
  return i;
} );


function_node< int, int, rejecting > f2( g, 1, []( int i ) -> int {
  spin_for(0.2);
  cout << "f2 consuming " << i << "\n";
  return i;
} );


priority_queue_node< int > q1(g);
priority_queue_node< int > q2(g);
broadcast_node< int > b(g);


make_edge( b, q1 );
make_edge( b, q2 );
make_edge( q1, f1 );
make_edge( q2, f2 );
for ( int i = 10; i > 0; --i ) {
  b.try_put( i );
}
g.wait_for_all();

So, when connecting a node in your graph to multiple successors, be sure to understand whether the output will broadcast to all of the successors, or just a single successor.