Intel® Threading Building Blocks (Intel® TBB) Version 3 Update 5 introduced the class graph as a Community Preview (CP) feature . There is an introductory post that provides an overview of the class and the nodes that can be used with it. You can download the open-source version of this release at www.threadingbuildingblocks.org and are encouraged to provide feedback about the graph via the forum . In a previous post, I provided an example that created a dependency graph . In this post, I describe how to make simple message graph using class graph . This example will calculate the sum of x*x + x*x*x for all x = 1 to 10. This is a simple syntactic example only. Since each node in a graph may execute as an independent task, the granularity of each node should follow the general guidelines for tasks as described in Section 3.2.3 of the Intel® Threading Building Blocks Tutorial. But for demonstration purposes, I will use an artificial, tiny example here and inflate the time spent in each node by sleeping for 1 second after each operation.  I use the Linux function sleep for this. If you want to enter this example yourself, you’ll have to use the appropriate sleep function for your system. The basic layout of the graph that I’ll create is shown in the figure below. Each value enters through the input node. This node will broadcast the value to both squarer and cuber , which will calculate x*x and x*x*x respectively (and sleep for 1 second). The output of each of these nodes will be placed in an unbounded buffer. A tuple containing both values will be created by the join node and forwarded to summer , which will add both values to the running total (and sleep for 1 second). The squarer and cuber will allow unlimited concurreny, that is they will be allowed to process multiple values simultaneously. The final summer , which updates a shared total, will be only allowed process a single in-coming tuple at a time, eliminating the need for a lock around the shared value. As with all Community Preview Features, the graph must be explicitly enabled. This is done by defining its macro, TBB_PREVIEW_GRAPH , before including the header file as shown below. #define TBB_PREVIEW_GRAPH 1 #include “tbb/graph.h” This example performs three basic types of operations: square, cube and sum. The classes below define these operations and will be use as the body objects for my function_node s. struct square {   int operator()(int v) {     printf(“squaring %dn”, v);     sleep(1);     return v*v;   } }; struct cube {   int operator()(int v) {     printf(“cubing %dn”, v);     sleep(1);     return v*v*v;   } }; class sum {   int &my_sum; public:   sum( int &s ) : my_sum(s) {}   int operator()( std::tuple v ) {     printf(“adding %d and %d to %dn”, std::get(v), std::get(v), my_sum);     my_sum += std::get(v) + std::get(v);     return my_sum;   } }; In function main , the graph is setup and then the values 1 – 10 are put into the input node. All the nodes in this example pass around values of type int . The nodes used below are all class templates and therefore can be used with any type that supports copy construction, including pointers and objects. It should be noted that values are copied as they pass between nodes, so passing around large objects should be avoided. using namespace tbb; int main() {   int result = 0;   graph g;   broadcast_node input;   function_node squarer( g, graph::unlimited, square() );   buffer_node square_buffer(g);   function_node cuber( g, graph::unlimited, cube() );   buffer_node cube_buffer(g);   join_node j( g );   function_node summer( g, graph::serial, sum(result) );   make_edge( input, squarer );   make_edge( input, cuber );   make_edge( squarer, square_buffer );   make_edge( square_buffer, std::get( j.inputs() ) );   make_edge( cuber, cube_buffer );   make_edge( cube_buffer, std::get( j.inputs() ) );   make_edge( j, summer );   for (int i = 1; i