oneAPI Threading Building Blocks (oneTBB)

This document contains information about oneTBB. It is a flexible performance library that let you break computation into parallel running tasks.

The following are some important topics for the novice user:

• Get Started with oneAPI Threading Building Blocks (oneTBB) gives you a brief explanation of what oneTBB is.

• oneTBB Benefits describes how oneTBB differs from typical threading packages.

• Package Contents describes dynamic library files and header files for Windows*, Linux*, and macOS* operating systems used in oneTBB.

The following is an important topic for the experienced user:

Migrating from Threading Building Blocks (TBB) describes how to migrate from TBB to oneTBB.

About

• Getting Help and Support
• Notational Conventions
• Introduction
• oneTBB Benefits
• Testing Approach
• Known Limitations

Get Started

• Get Started with oneAPI Threading Building Blocks (oneTBB)
  • To start using oneTBB, follow the next steps:
• System Requirements
• Installation
• Next Steps
  • Set the Environment Variables
  • Build and Run a Sample
  • Hybrid CPU and NUMA Support
• Integrate oneTBB
  • CMake*
  • Compile a Program Using pkg-config
• oneTBB Samples

Developer Guide

• oneTBB Developer Guide
  • Package Contents
    • Debug Versus Release Libraries
    • Scalable Memory Allocator
    • Windows*
    • Linux*
    • macOS*
  • Parallelizing Simple Loops
    • Initializing and Terminating the Library
    • parallel_for
    • parallel_reduce
    • Advanced Example
    • Advanced Topic: Other Kinds of Iteration Spaces
  • Parallelizing Complex Loops
    • Cook Until Done: parallel_for_each
    • Working on the Assembly Line: parallel_pipeline
    • Summary of Loops and Pipelines
  • Parallelizing Data Flow and Dependence Graphs
    • 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
  • Work Isolation
  • Exceptions and Cancellation
    • Cancellation Without An Exception
    • Cancellation and Nested Parallelism
  • Floating-point Settings
  • Containers
    • concurrent_hash_map
    • concurrent_vector
    • Concurrent Queue Classes
    • Summary of Containers
  • Mutual Exclusion
    • Mutex Flavors
    • Reader Writer Mutexes
    • Upgrade/Downgrade
    • Lock Pathologies
  • Timing
  • Memory Allocation
    • Which Dynamic Libraries to Use
    • Configuring the Memory Allocator
    • Automatically Replacing malloc and Other C/C++ Functions for Dynamic Memory Allocation
  • The Task Scheduler
    • Task-Based Programming
    • When Task-Based Programming Is Inappropriate
    • How Task Scheduler Works
    • Task Scheduler Bypass
    • Guiding Task Scheduler Execution
  • Design Patterns
    • Agglomeration
    • Elementwise
    • Odd-Even Communication
    • Wavefront
    • Reduction
    • Divide and Conquer
    • GUI Thread
    • Non-Preemptive Priorities
    • Lazy Initialization
    • Local Serializer
    • Fenced Data Transfer
    • Reference Counting
    • General References
  • Migrating from Threading Building Blocks (TBB)
    • Migrating from tbb::task_scheduler_init
    • Migrating from low-level task API
    • Mixing two runtimes
  • Constrained APIs
  • Invoke a Callable Object
    • range.iterate()
    • std::invoke
    • Find More
  • Appendix A Costs of Time Slicing
  • Appendix B Mixing With Other Threading Packages
  • References

Developer Reference

• oneTBB API Reference
  • Specification extensions
    • parallel_for_each Body semantics and requirements
    • parallel_sort ranges interface extension
    • TBB_malloc_replacement_log Function
    • Parallel Reduction for rvalues
  • Preview features
    • Type-specified message keys for join_node
    • Scalable Memory Pools
    • Helper Functions for Expressing Graphs
    • concurrent_lru_cache
    • task_group extensions
    • The customizing mutex type for concurrent_hash_map
    • Waiting for Single Messages in Flow Graph