# Message Flow Graph Example

This example calculates the sum `x*x + x*x*x` for all `x = 1 to 10`. The layout of this example is shown in the figure below.

A simple message flow graph.

Each value enters through the `broadcast_node<int>` `input`. This node broadcasts the value to both `squarer` and `cuber`, which calculate `x*x` and `x*x*x`, respectively. The output of each of these nodes is put to one of `join`’s ports. A tuple containing both values is created by `join_node<std::tuple<int,int>> join` and forwarded to `summer`, which adds both values to the running total. Both `squarer` and `cuber` allow unlimited concurrency, that is they each may process multiple values simultaneously. The final `summer`, which updates a shared total, is only allowed to process a single incoming tuple at a time, eliminating the need for a lock around the shared value.

    #include <cstdio>
    #include "oneapi/tbb/flow_graph.h"

    using namespace oneapi::tbb::flow;

    struct square {
      int operator()(int v) { return v*v; }
    };

    struct cube {
      int operator()(int v) { return v*v*v; }
    };

    class sum {
      int &my_sum;
    public:
      sum( int &s ) : my_sum(s) {}
      int operator()( std::tuple<int, int> v ) {
        my_sum += get<0>(v) + get<1>(v);
        return my_sum;
      }
    };

    int main() {
      int result = 0;

      graph g;
      broadcast_node<int> input(g);
      function_node<int,int> squarer( g, unlimited, square() );
      function_node<int,int> cuber( g, unlimited, cube() );
      join_node<std::tuple<int,int>, queueing> join( g );
      function_node<std::tuple<int,int>,int>
          summer( g, serial, sum(result) );

      make_edge( input, squarer );
      make_edge( input, cuber );
      make_edge( squarer, get<0>( join.input_ports() ) );
      make_edge( cuber, get<1>( join.input_ports() ) );
      make_edge( join, summer );

      for (int i = 1; i <= 10; ++i)
          input.try_put(i);
      g.wait_for_all();

      printf("Final result is %d\n", result);
      return 0;
    }

In the example code above, the classes `square`, `cube`, and `sum` define the three user-defined operations. Each class is used to create a `function_node`.

In function `main`, the flow graph is set up and then the values 1-10 are put into the node `input`. All the nodes in this example pass around values of type `int`. The nodes used in this example are all class templates and therefore can be used with any type that supports copy construction, including pointers and objects.