.rst .pdf

open issue suggest edit

oneTBB Developer Guide

oneAPI Threading Building Blocks (oneTBB)

• Package Contents
  • Debug Versus Release Libraries
  • Scalable Memory Allocator
  • Windows*
  • Linux*
  • macOS*
• Parallelizing Simple Loops
  • Initializing and Terminating the Library
    • Explicit Library Finalization
  • parallel_for
    • Lambda Expressions
    • Automatic Chunking
    • Controlling Chunking
    • Bandwidth and Cache Affinity
    • Partitioner Summary
  • 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
    • Using Circular Buffers
    • Throughput of pipeline
    • Non-Linear Pipelines
  • Summary of Loops and Pipelines
• Parallelizing Data Flow and Dependence Graphs
  • Parallelizing Data Flow and Dependency Graphs
  • Basic Flow Graph Concepts
    • 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
    • Data Flow Graph
    • Dependence Graph
  • Predefined Node Types
  • Flow Graph Tips and Tricks
    • Flow Graph Tips for Waiting for and Destroying a Flow Graph
      • Always Use wait_for_all()
      • Avoid Dynamic Node Removal
      • Destroying Graphs That Run Outside the Main Thread
    • Flow Graph Tips on Making Edges
      • 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
      • Use Nested Algorithms to Increase Scalability
      • Use Nested Flow Graphs
    • Flow Graph Tips for Limiting Resource Consumption
      • Using limiter_node
      • Use Concurrency Limits
      • Create a Token-Based System
      • Attach Flow Graph to an Arbitrary Task Arena
    • Flow Graph Tips for Exception Handling and Cancellation
      • Catching Exceptions Inside the Node that Throws the Exception
      • Cancel a Graph Explicitly
      • Use graph::reset() to Reset a Canceled Graph
      • Canceling Nested Parallelism
  • Estimating Flow Graph Performance
• Work Isolation
• Exceptions and Cancellation
  • Cancellation Without An Exception
  • Cancellation and Nested Parallelism
• Containers
  • concurrent_hash_map
    • More on HashCompare
  • concurrent_vector
  • Concurrent Queue Classes
    • Iterating Over a Concurrent Queue for Debugging
    • When Not to Use Queues
  • 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
    • Windows* OS C/C++ Dynamic Memory Interface Replacement
    • Linux* OS C/C++ Dynamic Memory Interface Replacement
• 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
    • Managing the number of threads
      • Querying the default number of threads
      • Setting the maximum concurrency
      • Examples
    • Setting thread stack size
    • Terminating oneTBB scheduler
  • Migrating from low-level task API
    • Spawning of individual tasks
      • Using oneapi::tbb::task_group
      • Using oneapi::tbb::parallel_invoke
    • Adding more work during task execution
    • Task recycling
      • Recycling as child or continuation
    • Scheduler Bypass
    • Deferred task creation
  • Mixing two runtimes
• Constrained APIs
• Appendix A Costs of Time Slicing
• Appendix B Mixing With Other Threading Packages
• References

previous

oneTBB Benefits

next

Package Contents