Get Link
|
Sync TOC
|
<<
|
>>
Search Options:
Search Titles Only
Match All Words
Match Whole Words
Show Results in Tree
Intel® Threading Building Blocks
Legal Information
Getting Help and Support
Introducing Intel® Threading Building Blocks
Intel® Threading Building Blocks Benefits
Notational Conventions
Intel® Threading Building Blocks (Intel® TBB) Developer Guide
Package Contents
Debug Versus Release Libraries
Scalable Memory Allocator
Windows* OS
Microsoft Visual Studio* Code Examples
Integration Plug-In for Microsoft Visual Studio* Projects
Linux* OS
macOS* Systems
Open Source Version
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_do
Working on the Assembly Line: 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 source_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
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
Advanced Idiom: Waiting on an Element
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
Atomic Operations
Why atomic<T> Has No Constructors in C++03 mode
Memory Consistency
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
macOS* C/C++ Dynamic Memory Interface Replacement
The Task Scheduler
Task-Based Programming
When Task-Based Programming Is Inappropriate
Simple Example: Fibonacci Numbers
How Task Scheduling Works
Useful Task Techniques
Recursive Chain Reaction
Continuation Passing
Scheduler Bypass
Recycling
Empty Tasks
General Acyclic Graphs of Tasks
Task Scheduler Summary
Design Patterns
Agglomeration
Elementwise
Odd-Even Communication
Wavefront
Reduction
Divide and Conquer
GUI Thread
Non-Preemptive Priorities
Local Serializer
Fenced Data Transfer
Lazy Initialization
Reference Counting
Compare and Swap Loop
General References
Appendix A Costs of Time Slicing
Appendix B Mixing With Other Threading Packages
References
Intel® Threading Building Blocks Developer Reference
General Conventions
Terminology
Identifiers
Namespaces
Thread Safety
Environment
Version Information
Enabling Debugging Features
Feature macros
Algorithms
Splittable Concept
split Class
proportional_split Class
Range Concept
blocked_range Template Class
blocked_range2d Template Class
blocked_range3d Template Class
Partitioners
auto_partitioner Class
affinity_partitioner
static_partitioner Class
simple_partitioner Class
parallel_for Template Function
parallel_reduce Template Function
parallel_deterministic_reduce Template Function
parallel_scan Template Function
pre_scan_tag and final_scan_tag Classes
parallel_do Template Function
parallel_do_feeder<item> class
parallel_for_each Template Function
pipeline Class
filter Class
thread_bound_filter Class
parallel_pipeline Function
filter_t Template Class
flow_control Class
parallel_sort Template Function
parallel_invoke Template Function
Iterators
Counting Iterator
Zip Iterator
Containers Overview
Container Range Concept
tbb_hash_compare Class and tbb_hash Class
concurrent_unordered_map and concurrent_unordered_multimap Template Classes
Construct, Destroy, Copy
Size and capacity
Iterators
Modifiers
Observers
Lookup
Parallel Iteration
Bucket Interface
Hash Policy
concurrent_unordered_set and concurrent_unordered_multiset Template Classes
Construct, Destroy, Copy
Size and Capacity
Iterators
Modifiers
Observers
Lookup
Parallel Iteration
Bucket Interface
Hash Policy
concurrent_hash_map Template Class
Whole Table Operations
Concurrent Access
Concurrent Operations
Parallel Iteration
Capacity
Iterators
Global Functions
concurrent_queue Template Class
concurrent_bounded_queue Template Class
concurrent_priority_queue Template Class
concurrent_vector
Construction, Copy, and Assignment
Whole Vector Operations
Concurrent Growth
Access
Parallel Iteration
Capacity
Iterators
Flow Graph
Overview
Dependency Flow Graph Example
Message Flow Graph Example
Body Objects
Message Passing Protocol
Fowarding, Buffering and Reception Policy
Lightweight policy for functional nodes
graph Class
Abstract Interfaces
sender Template Class
receiver Template Class
continue_receiver Class
graph_node Class
Special Message Types
continue_msg Class
flow::tuple Template Class
tagged_msg Template Class
Functional Nodes
continue_node Template Class
function_node Template Class
source_node Class
multifunction_node Template Class
async_node Template Class
copy_body Template Function
Buffering Nodes
overwrite_node Template Class
write_once_node Template Class
buffer_node Class
queue_node Template Class
priority_queue_node Template Class
sequencer_node Template Class
Service Nodes
limiter_node Template Class
broadcast_node Template Class
join_node Template Class
split_node Template Class
indexer_node Template Class
composite_node Template Class
Ports And Edges
input_port Template Function
output_port Template Function
make_edge Template Function
remove_edge Template Function
Thread Local Storage
combinable Template Class
enumerable_thread_specific Template Class
Whole Container Operations
Concurrent Operations
Combining
Parallel Iteration
Iterators
flattened2d Template Class
Whole Container Operations
Concurrent Operations
Iterators
Utility Functions
Memory Allocation
Allocator Concept
tbb_allocator Template Class
scalable_allocator Template Class
C Interface to Scalable Allocator
cache_aligned_allocator Template Class
zero_allocator
aligned_space Template Class
Synchronization
Mutexes
Mutex Concept
Speculative locking (Transactional Lock Elision)
mutex Class
recursive_mutex Class
spin_mutex Class
speculative_spin_mutex Class
queuing_mutex Class
ReaderWriterMutex Concept
spin_rw_mutex Class
speculative_spin_rw_mutex Class
queuing_rw_mutex Class
null_mutex Class
null_rw_mutex Class
atomic Template Class
PPL Compatibility
critical_section
reader_writer_lock Class
C++11 Synchronization
Timing
tick_count Class
tick_count Class Members
tick_count::interval_t Class
Task Groups
task_group Class
task_group_status Enum
task_handle Template Class
make_task Template Function
structured_task_group Class
is_current_task_group_canceling Function
Task Scheduler
Scheduling Algorithm
task_scheduler_init Class
task_scheduler_init( int max_threads=automatic, stack_size_type thread_stack_size=0 )
~task_scheduler_init()
task Class
task Derivation
task Allocation
Explicit task Destruction
Recycling Tasks
Synchronization
task Context
Cancellation
Priorities
Floating-point Settings
Affinity
task Debugging
empty_task Class
task_list Class
task_group_context
task_arena Class and this_task_arena Namespace
task_scheduler_observer
task_scheduler_observer Members
Catalog of Recommended task Patterns
Exceptions
tbb_exception
captured_exception
movable_exception<ExceptionData>
Specific Exceptions
Threads
thread Class
thread Class Members
thread::id
this_thread Namespace
Appendices
PPL Compatibility
Preview Features
What is a Preview Feature?
Enabling a Preview Feature
Flow Graph
async_msg Template Class
streaming_node Template Class
opencl_node Template Class
gfx_factory Class
Type-specified message keys for join_node
Run-time loader
runtime_loader Class
error_code load(char const * path[],int min_ver = TBB_INTERFACE_VERSION, int max_ver = INT_MAX)
Scalable Memory Pools
memory_pool Template Class
fixed_pool Class
memory_pool_allocator Template Class
Serial subset
tbb::serial::parallel_for()
concurrent_lru_cache Template Class
concurrent_lru_cache::handle class
aggregator Class
aggregator Class Basic Interface
aggregator Class Expert Interface
task_scheduler_observer Class extensions
parallel_invoke Variadic Template Function
global_control class
task_scheduler_init Class extensions
blocked_rangeNd Template Class
Compatibility Features
parallel_while Template Class
Interface for constructing a pipeline filter
Task Enqueuing Flow Graph
Interface for class task
tbb_thread Class
Copyable mutexes
Node Extraction for flow::graph
Message ordering for serial flow::function_node
Known Issues
Windows* OS
Linux* OS
Interoperability Issues