Concurrent Growth
concurrent_hash_map Template Class
Construction, Copy, and Assignment
Counting Iterator
filter Class
join_node Template Class
Type-specified message keys for join_node
type-specified message keys
parallel_sort Template Function
Whole Table Operations
Zip Iterator
~task_scheduler_init
abstract flow graph interfaces
accept
Access
Advanced Example
Advanced Idiom: Waiting on an Element
Advanced Topic: Other Kinds of Iteration Spaces
Affinity
affinity_partitioner
Agglomeration
aggregator Class
aggregator Class Basic Interface
aggregator Class Expert Interface
Algorithms
Algorithms
Iterators
aligned space
allocation mode
allocator
tbb_allocator Template Class
zero_allocator
scalable_allocator Template Class
aligned_space Template Class
cache_aligned_allocator Template Class
ALLOCATOR
Allocator Concept
allocator configuration
Appendix A Costs of Time Slicing
Appendix B Mixing With Other Threading Packages
async_msg Template Class
async_node Template Class
Atomic Operations
atomic Template Class
atomic
auto_partitioner Class
Automatic Chunking
Automatically Replacing malloc and Other C/C++ Functions for Dynamic Memory Allocation
avoid dynamic node removal
avoid dynamic node removal
avoiding data races
Bandwidth and Cache Affinity
Basic Concepts
Basic Flow Graph Concepts
Flow Graph
Benefits
blocked_range Template Class
blocked_range2d Template Class
blocked_range3d Template Class
blocked_rangeNd Template Class
Body Objects
broadcast_node Template Class
broadcast-push
Bucket Interface
Bucket Interface
Bucket Interface
buffer_node Class
buffering
Buffering Nodes
Buffering policy
C Interface to Scalable Allocator
C++11 Support
C++11 Synchronization
cache aligned allocator
cancel a graph explicitly
canceling nested parallelism
Cancellation
Cancellation and Nested Parallelism
Cancellation Without An Exception
Capacity
Capacity
Capacity
captured_exception
Catalog of Recommended task Patterns
catch exceptions inside the node that throws the exception
Categories
Graph Application Categories
Flow Graph
combinable Template Class
Combining
communication between graphs
Compare and Swap Loop
compatibility
Compatibility Features
composite_node Template Class
concurrency limits
Concurrent Access
Concurrent Operations
Concurrent Operations
Concurrent Operations
Concurrent Operations
Concurrent Queue Classes
concurrent_bounded_queue Template Class
concurrent_hash_map
concurrent_lru_cache Template Class
concurrent_lru_cache::handle class
concurrent_priority_queue Template Class
concurrent_queue Template Class
concurrent_unordered_map
concurrent_unordered_multimap
concurrent_unordered_multiset
concurrent_unordered_set
concurrent_vector
concurrent_vector
concurrent_vector
Construct, Destroy, Copy
Construct, Destroy, Copy
Construct, Destroy, Copy
constructors
Why atomic
atomic
Container Range Concept
Containers
Continuation Passing
continue_msg Class
continue_node Template Class
continue_receiver Class
Controlling Chunking
Cook Until Done: parallel_do
copy_body Template Function
critical_section
data flow
Parallelizing Data Flow and Dependence Graphs
parallelizing
Data Flow Graph
Debug Versus Release Libraries
dependence graph
Parallelizing Data Flow and Dependence Graphs
parallelizing
Dependence Graph
Dependency Flow Graph Example
destroying graphs that run outside the main thread
destroying graphs that run outside the main thread
discarding
Divide and Conquer
DO_ITT_NOTIFY
dynamic memory allocation
Edges
Flow Graph Basics: Edges
Edges
Elementwise
Empty Tasks
empty_task Class
Enabling a Preview Feature
Enabling Debugging Features
enumerable_thread_specific Template Class
Environment
error_code load(char const * path[],int min_ver = TBB_INTERFACE_VERSION, int max_ver = INT_MAX)
exception cancelling
exception handling
Exceptions
Exceptions and Cancellation
Explicit task Destruction
Feature macros
Fenced Data Transfer
fixed_pool Class
flattened2d Template Class
Floating-point Settings
Flow Graph
Flow Graph
Flow Graph
Data Flow Graph
Flow Graph Basics
Flow Graph Basics: Buffering and Forwarding
Flow Graph Basics: Message Passing Protocol
Flow Graph Basics: Reservation
Flow Graph Basics: Single-push vs. Broadcast-push
Buffering and Forwarding
Message Passing Protocol
Reservations
Single vs. Broadcast Policy
Flow Graph Categories
Flow Graph Concepts
Flow Graph Basics: Nodes
Flow Graph Basics: Mapping Nodes to Tasks
Basic Flow Graph Concepts
Flow Graph Basics: Edges
Graph Object
Flow Graph overview
Flow Graph Performance
flow graph tips
Use make_edge and remove_edge
Avoid Dynamic Node Removal
Destroying Graphs That Run Outside the Main Thread
always use wait_for_all
avoid data races
cancel a graph explicitly
canceling nested parallelism
catching excpetions
communicating with nodes in different graphs
token-based system
use concurrency limits
use graph::reset() to reset a cancelled graph
use limiter_node
use nested algorithms
use nested flow graphs
using source_node
Flow Graph Tips
Flow Graph Tips and Tricks
destroying a flow graph
exception handling
limiting resources
making edges
nested parallelism
waiting for a flow graph
Flow Graph Tips
Sending to One or Multiple Successors
Broadcasting to all successors
Sending to a single successor
flow_control Class
flow::tuple
Forwarding and Buffering Policies
Forwarding Policy
FP Settings
function_node Template Class
Functional Nodes
General Acyclic Graphs of Tasks
General Conventions
General References
gfx_factory Class
Global Functions
global_control class
graph Class
Graph Object
graph_node Class
graph::reset to reset a canceled graph
GUI Thread
Hash policy
Hash Policy
Hash Policy
Help
How Task Scheduling Works
huge memory pages
Identifiers
increase scalability
indexer_node Template Class
Initializing and Terminating the Library
input_port Template Function
Integration Plug-In for Microsoft Visual Studio* Projects
IntelĀ® Threading Building Blocks
Introducing IntelĀ® Threading Building Blocks
Overview
Interface for class task
Interface for constructing a pipeline filter
interoperability
is_current_task_group_canceling Function
Iterating Over a Concurrent Queue for Debugging
Iterators
Iterators
Iterators
Iterators
Iterators
Iterators
Iterators
join_node Template Class
known issues
Known Issues
Windows* OS
Interoperability Issues
Linux* OS
Known Issues
Lambda Expressions
Lazy Initialization
lightweight policy
limit messages in sub-graph
limiter_node
limiter_node Template Class
Linux* OS
Linux* OS
Linux* OS
Linux* OS C/C++ Dynamic Memory Interface Replacement
Local Serializer
Lock Elision
Lock Pathologies
Lookup
Lookup
Lookup
macOS* C/C++ Dynamic Memory Interface Replacement
macOS* Systems
make_edge Template Function
make_task Template Function
malloc replacement
Mapping Nodes to Tasks
Flow Graph Basics: Mapping Nodes to Tasks
Mapping Nodes to Tasks
Memory Allocation
Memory Allocation
Memory Allocation
Memory Consistency
memory footprint
memory usage limit
memory_pool Template Class
memory_pool_allocator Template Class
Message Flow Graph Example
Message Passing Protocol
Message reception policy
Microsoft Visual Studio* Code Examples
Modifiers
Modifiers
Modifiers
More on HashCompare
movable_exception
multifunction_node Template Class
mutex Class
Mutex Concept
Mutex Flavors
Mutexes
Mutual Exclusion
Namespaces
nested algorithms
nested flow graphs
Node
Node Extraction for flow::graph
Nodes
Flow Graph Basics: Nodes
Nodes
Non-Linear Pipelines
Non-Preemptive Priorities
Notation
null_mutex Class
null_rw_mutex Class
Observers
Observers
Observers
Odd-Even Communication
Open Source Version
opencl_node Template Class
output_port Template Function
overwrite_node Template Class
Package Contents
Parallel Iteration
Parallel Iteration
Parallel Iteration
Parallel Iteration
Parallel Iteration
Parallel Iteration
parallel_deterministic_reduce Template Function
parallel_do Template Function
parallel_for
parallel_for Template Function
parallel_for_each Template Function
parallel_invoke Template Function
parallel_invoke Variadic Template Function
parallel_pipeline Function
parallel_reduce
parallel_reduce Template Function
parallel_scan Template Function
parallel_while Template Class
Parallelizing Complex Loops
Parallelizing Data Flow
Parallelizing Data Flow and Dependence Graphs
Parallelizing Dependency Graphs
Parallelizing Simple Loops
Partitioner Summary
Partitioners
Performance
Estimating Flow Graph Performance
Flow Graph
pipeline Class
Ports And Edges
PPL Compatibility
PPL Compatibility
PPL Compatibility
predefined types
Predefined Node Types
predefined node types
Preview Features
Priority
priority_queue_node Template Class
proportional_split Class
queue_node Template Class
queuing_mutex Class
queuing_rw_mutex Class
Range Concept
Reader Writer Mutexes
reader_writer_lock Class
ReaderWriterMutex Concept
receiver Template Class
Recursive Chain Reaction
recursive_mutex Class
Recycling
Recycling Tasks
Reduction
Reference Counting
References
remove_edge Template Function
Reservation
Run-time loader
runtime_loader Class
Scalable Memory Allocator
Scalable Memory Pools
scalable_allocator
scalable_free
scalable_malloc
Scheduler Bypass
Scheduling Algorithm
sender Template Class
sequencer_node Template Class
Serial subset
Service Nodes
Simple Example: Fibonacci Numbers
simple_partitioner Class
single-push
Size and Capacity
Size and capacity
Size and Capacity
source_node Class
Special Message Types
Specific Exceptions
Speculative Locking
speculative_spin_mutex Class
speculative_spin_rw_mutex Class
spin_mutex Class
spin_rw_mutex Class
split Class
split_node Template Class
Splittable Concept
static_partitioner Class
streaming_node Template Class
structured_task_group Class
Summary of Containers
Summary of Loops and Pipelines
Support
switch
Synchronization
Synchronization
Synchronization
tagged_msg Template Class
task Allocation
task Class
task Context
task Debugging
task Derivation
Task Groups
Task Scheduler
Task Scheduler Summary
task_arena Class
task_group Class
task_group_context
task_group_status Enum
task_handle Template Class
task_list Class
task_scheduler_init
task_scheduler_init Class
task_scheduler_init Class extensions
task_scheduler_observer
task_scheduler_observer Members
task_scheduler_observer
task_scheduler_observer Class extensions
Task-Based Programming
tbb
tbb_allocator
TBB_COMPATIBLE_INTERFACE_VERSION
TBB_DEPRECATED
Namespaces
Feature macros
tbb_exception
tbb_hash Class
tbb_hash_compare Class
TBB_INTERFACE_VERSION
TBB_INTERFACE_VERSION_MAJOR
TBB_INTERFACE_VERSION/1000
tbb_thread Class
TBB_USE_ASSERT
Enabling Debugging Features
Version Information
TBB_USE_CAPTURED_EXCEPTION
TBB_USE_DEBUG
TBB_USE_EXCEPTIONS
TBB_USE_PERFORMANCE_WARNINGS
TBB_USE_THREADING_TOOLS
tbb::deprecated
tbb::interface
tbb::interfacex
tbb::internal
tbb::serial::parallel_for()
tbb::strict_ppl
template class
Terminology
The Task Scheduler
this_task_arena Namespace
this_thread Namespace
thread Class
thread Class Members
Thread Local Storage
Thread Safety
thread_bound_filter Class
thread::id
Threads
Throughput of pipeline
tick_count Class
tick_count Class Members
tick_count::interval_t Class
Timing
Timing
Timing
token-based system
Upgrade/Downgrade
use make_edge and remove_edge
use make_edge and remove_edge
use nested algorithms
use nested flow graphs
use wait_for_all
Useful Task Techniques
Using Circular Buffers
using source_node
Utility Functions
Version Information
wait_for_all
Wavefront
What is a Preview Feature?
When Not to Use Queues
When Task-Based Programming Is Inappropriate
Which Dynamic Libraries to Use
Whole Container Operations
Whole Container Operations
Whole Container Operations
Whole Vector Operations
Windows* OS
Windows* OS
Windows* OS
Windows* OS C/C++ Dynamic Memory Interface Replacement
work isolation
Working on the Assembly Line: pipeline
write_once_node Template Class
zero allocator