Flow Graph Basics: Buffering and Forwarding

Intel® oneAPI Threading Building Blocks Developer Guide and API Reference

Download PDF

ID 772616

Date 3/31/2023

Version

Public

A newer version of this document is available. Customers should click here to go to the newest version.

Visible to Intel only — GUID: GUID-CD856CB4-2231-49F6-8407-E4546BF03D0E

View Details

Document Table of Contents

Document Table of Contents x

Intel® oneAPI Threading Building Blocks (oneTBB)

Intel® oneAPI Threading Building Blocks (oneTBB) x

Getting Help and Support Notational Conventions Introduction oneTBB Benefits oneTBB Developer Guide oneTBB API Reference Notices and Disclaimers

oneTBB Developer Guide x

Package Contents Parallelizing Simple Loops Parallelizing Complex Loops Parallelizing Data Flow and Dependence Graphs Work Isolation Exceptions and Cancellation Floating-point Settings Containers Mutual Exclusion Timing Memory Allocation The Task Scheduler Design Patterns Migrating from Threading Building Blocks (TBB) Constrained APIs Appendix A Costs of Time Slicing Appendix B Mixing With Other Threading Packages References

Package Contents x

Debug Versus Release Libraries Scalable Memory Allocator Windows* Linux* macOS*

Parallelizing Simple Loops x

Initializing and Terminating the Library parallel_for parallel_reduce Advanced Example Advanced Topic: Other Kinds of Iteration Spaces

parallel_for x

Lambda Expressions Automatic Chunking Controlling Chunking Bandwidth and Cache Affinity Partitioner Summary

Parallelizing Complex Loops x

Cook Until Done: parallel_for_each Working on the Assembly Line: parallel_pipeline Summary of Loops and Pipelines

Working on the Assembly Line: parallel_pipeline x

Using Circular Buffers Throughput of pipeline Non-Linear Pipelines

Parallelizing Data Flow and Dependence Graphs x

Parallelizing Data Flow and Dependency Graphs Basic Flow Graph Concepts Graph Application Categories Predefined Node Types Flow Graph Tips and Tricks Estimating Flow Graph Performance

Basic Flow Graph Concepts x

Flow Graph Basics: Graph Object Flow Graph Basics: Nodes Flow Graph Basics: Edges Flow Graph Basics: Mapping Nodes to Tasks Flow Graph Basics: Message Passing Protocol Flow Graph Basics: Single-push vs. Broadcast-push Flow Graph Basics: Buffering and Forwarding Flow Graph Basics: Reservation

Graph Application Categories x

Data Flow Graph Dependence Graph

Flow Graph Tips and Tricks x

Flow Graph Tips for Waiting for and Destroying a Flow Graph Flow Graph Tips on Making Edges Flow Graph Tips on Nested Parallelism Flow Graph Tips for Limiting Resource Consumption Flow Graph Tips for Exception Handling and Cancellation

Flow Graph Tips for Waiting for and Destroying a Flow Graph x

Always Use wait_for_all() Avoid Dynamic Node Removal Destroying Graphs That Run Outside the Main Thread

Flow Graph Tips on Making Edges x

Use make_edge and remove_edge Sending to One or Multiple Successors Communication Between Graphs Using input_node Avoiding Data Races

Flow Graph Tips on Nested Parallelism x

Use Nested Algorithms to Increase Scalability Use Nested Flow Graphs

Flow Graph Tips for Limiting Resource Consumption x

Using limiter_node Use Concurrency Limits Create a Token-Based System Attach Flow Graph to an Arbitrary Task Arena

Attach Flow Graph to an Arbitrary Task Arena x

Guiding Task Scheduler Execution Work Isolation

Flow Graph Tips for Exception Handling and Cancellation x

Catching Exceptions Inside the Node that Throws the Exception Cancel a Graph Explicitly Use graph::reset() to Reset a Canceled Graph Canceling Nested Parallelism

Exceptions and Cancellation x

Cancellation Without An Exception Cancellation and Nested Parallelism

Containers x

concurrent_hash_map concurrent_vector Concurrent Queue Classes Summary of Containers

concurrent_hash_map x

Flow Graph Basics: Buffering and Forwarding

Intel® oneAPI Threading Building Blocks (oneTBB) flow graph nodes use messages to communicate data and to enforce dependencies. If a node passes a message successfully to any successor, no further action is taken with the message by that node. As noted in the section on Single-push vs. Broadcast-push, a message may be passed to one or to multiple successors, depending on the type of the node, how many successors are connected to the node, and whether the message is pushed or pulled.

There are times when a node cannot successfully push a message to any successor. In this case what happens to the message depends on the type of the node. The two possibilities are:

The node stores the message to be forwarded later.
The node discards the message.

If a node discards messages that are not forwarded, and this behavior is not desired, the node should be connected to a buffering node that does store messages that cannot be pushed.

If a message has been stored by a node, there are two ways it can be passed to another node:

A successor to the node can pull the message using try_get() or try_reserve().
A successor can be connected using make_edge().

If a try_get() successfully forwards a message, it is removed from the node that stored it. If a node is connected using make_edge the node will attempt to push a stored message to the new successor.

Level Two Title

Flow Graph Basics: Single-push vs. Broadcast-push Flow Graph Basics: Reservation

Select Your Language

Using Intel.com Search

Quick Links

Recent Searches

Advanced Search

Only search in

Intel® oneAPI Threading Building Blocks Developer Guide and API Reference

Flow Graph Basics: Buffering and Forwarding