Skip to main content
Ctrl+K

oneTBB Documentation

About

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

Get Started

  • Get Started with oneAPI Threading Building Blocks (oneTBB)
  • System Requirements
  • Installation
  • Next Steps
  • Integrate oneTBB
  • 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
        • 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 with Tasks
      • Creating Tasks with parallel_invoke
      • Creating Tasks with task_group
      • task_group Thread Safety
    • 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
        • 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
      • Estimating Flow Graph Performance
    • Work Isolation
    • Exceptions and Cancellation
      • Cancellation Without An Exception
      • Cancellation and Nested Parallelism
    • Floating-point Settings
    • 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
      • Migrating from low-level task API
      • Mixing two runtimes
    • Constrained APIs
    • Invoke a Callable Object
    • Appendix A Costs of Time Slicing
    • Appendix B Mixing With Other Threading Packages
    • References

Developer Reference

  • oneTBB API Reference
    • TBB_malloc_replacement_log Function
    • Parallel Reduction for rvalues
    • Custom Assertion Handler
    • Type-specified message keys for join_node
    • Scalable Memory Pools
      • memory_pool
      • fixed_pool
      • memory_pool_allocator
    • Helper Functions for Expressing Graphs
      • Constructors for Flow Graph nodes
      • follows and precedes function templates
      • make_node_set function template
      • make_edges function template
    • concurrent_lru_cache
    • task_group extensions
      • Task Bypass Support for task_group
      • task_group Dynamic Dependencies
    • The customizing mutex type for concurrent_hash_map
    • Waiting for Single Messages in Flow Graph
    • parallel_phase Interface for Task Arena

Index

Symbols | A | C | E | F | G | H | L | M | O | R | S | T | V

Symbols

  • ~concurrent_lru_cache (C++ function)
  • ~handle (C++ function)

A

  • assertion_handler_type (C++ type)

C

  • concurrent_lru_cache (C++ function)

E

  • end_parallel_phase (C++ function)

F

  • fixed_pool (C++ function)
  • Func::operator() (C++ function), [1]

G

  • get_assertion_handler (C++ function)

H

  • handle (C++ function), [1]

L

  • leave_policy::automatic (C++ enum)
  • leave_policy::fast (C++ enum)

M

  • memory_pool (C++ function)
  • memory_pool_allocator (C++ function), [1]

O

  • operator bool (C++ function)
  • operator= (C++ function)
  • operator[] (C++ function)

R

  • ReaderWriterMutex::scoped_lock::is_writer (C++ function)
  • Reduction::operator() (C++ function), [1]

S

  • scoped_parallel_phase (C++ class)
  • scoped_parallel_phase::scoped_parallel_phase (C++ function)
  • set_assertion_handler (C++ function)
  • start_parallel_phase (C++ function)

T

  • task_arena (C++ function)
  • this_task_arena::end_parallel_phase (C++ function)
  • this_task_arena::start_parallel_phase (C++ function)

V

  • value (C++ function)

© Copyright UXL Foundation Contributors.