  rml | The namespace rml contains components of low-level memory pool interface |
   MemPoolPolicy | |
| tbb | The namespace tbb contains all components of the library |
 deprecated | |
| concurrent_queue | A high-performance thread-safe blocking concurrent bounded queue |
| flow | |
 interface7 | |
 internal | |
 successor_cache | |
| broadcast_cache | |
| round_robin_cache | |
| continue_msg | An empty class used for messages that mean "I'm done" |
| sender | Pure virtual template class that defines a sender of messages of type T |
| receiver | Pure virtual template class that defines a receiver of messages of type T |
| limiter_node | Forwards messages only if the threshold has not been reached |
| run_and_put_task | |
| continue_receiver | Base class for receivers of completion messages |
| graph_iterator | |
| graph | The graph class |
| graph_node | The base of all graph nodes |
| source_node | An executable node that acts as a source, i.e. it has no predecessors |
| function_node | Implements a function node that supports Input -> Output |
| function_node< Input, Output, queueing, Allocator > | Implements a function node that supports Input -> Output |
| multifunction_node | Implements a function node that supports Input -> (set of outputs) |
| multifunction_node< Input, Output, queueing, Allocator > | |
| split_node | Split_node: accepts a tuple as input, forwards each element of the tuple to its |
| continue_node | Implements an executable node that supports continue_msg -> Output |
| overwrite_node | |
| write_once_node | |
| broadcast_node | Forwards messages of type T to all successors |
| buffer_node | Forwards messages in arbitrary order |
| buffer_operation | |
| queue_node | Forwards messages in FIFO order |
| sequencer_node | Forwards messages in sequence order |
| priority_queue_node | Forwards messages in priority order |
| join_node | |
| join_node< OutputTuple, reserving > | |
| join_node< OutputTuple, queueing > | |
| join_node< OutputTuple, tag_matching > | |
| or_node | |
| interface5 | |
| concurrent_hash_map | Unordered map from Key to T |
| accessor | Allows write access to elements and combines data access, locking, and garbage collection |
| bucket_accessor | Bucket accessor is to find, rehash, acquire a lock, and access a bucket |
| const_accessor | Combines data access, locking, and garbage collection |
| node | |
| concurrent_priority_queue | Concurrent priority queue |
| concurrent_unordered_map_traits | |
| value_compare | |
| concurrent_unordered_map | |
| concurrent_unordered_multimap | |
| concurrent_unordered_set_traits | |
| concurrent_unordered_set | |
| concurrent_unordered_multiset | |
| reader_writer_lock | Writer-preference reader-writer lock with local-only spinning on readers |
| scoped_lock | The scoped lock pattern for write locks |
| scoped_lock_read | The scoped lock pattern for read locks |
| interface6 | |
| internal | |
| basic_operation_base | |
| basic_operation | |
| basic_handler | |
| concrete_filter | |
| aggregator_operation | |
| aggregator_ext | Aggregator base class and expert interface |
| aggregator | Basic aggregator interface |
| concurrent_lru_cache | |
| enumerable_thread_specific | The enumerable_thread_specific container |
| flattened2d | |
| memory_pool_allocator | Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5 |
| rebind | |
| memory_pool_allocator< void, P > | Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1 |
| rebind | |
| memory_pool | Thread-safe growable pool allocator for variable-size requests |
| fixed_pool | |
| flow_control | Input_filter control to signal end-of-input for parallel_pipeline |
| filter_t | Class representing a chain of type-safe pipeline filters |
| runtime_loader | Load TBB at runtime |
| task_scheduler_observer | |
| interface7 | |
| task_arena | |
| internal | |
| critical_section_v4 | |
| scoped_lock | |
| task_handle_task | |
| task_group_base | |
| task_scheduler_observer_v3 | |
| tbb_exception_ptr | Exception container that preserves the exact copy of the original exception |
| STATIC_ASSERTION_FAILED | |
| STATIC_ASSERTION_FAILED< false > | |
| thread_closure_base | |
| thread_closure_0 | |
| thread_closure_1 | Structure used to pass user function with 1 argument to thread |
| thread_closure_2 | |
| tbb_thread_v3 | Versioned thread class |
| id | |
| strict_ppl | |
| concurrent_queue | A high-performance thread-safe non-blocking concurrent queue |
| aligned_space | Block of space aligned sufficiently to construct an array T with N elements |
| atomic | Primary template for atomic |
| atomic< void * > | Specialization for atomic<void*>, for sake of not allowing arithmetic or operator-> |
| blocked_range | A range over which to iterate |
| blocked_range2d | A 2-dimensional range that models the Range concept |
| blocked_range3d | A 3-dimensional range that models the Range concept |
| cache_aligned_allocator | Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5 |
| rebind | |
| cache_aligned_allocator< void > | Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1 |
| rebind | |
| combinable | Thread-local storage with optional reduction |
| tbb_hash_compare | Hash_compare that is default argument for concurrent_hash_map |
| concurrent_bounded_queue | A high-performance thread-safe blocking concurrent bounded queue |
| concurrent_vector | Concurrent vector container |
| vector_iterator | |
| mutex | Wrapper around the platform's native reader-writer lock |
| scoped_lock | The scoped locking pattern |
| null_mutex | A mutex which does nothing |
| scoped_lock | Represents acquisition of a mutex |
| null_rw_mutex | A rw mutex which does nothing |
| scoped_lock | Represents acquisition of a mutex |
| parallel_do_feeder | Class the user supplied algorithm body uses to add new tasks |
| task_group_context | |
| pre_scan_tag | Used to indicate that the initial scan is being performed |
| final_scan_tag | Used to indicate that the final scan is being performed |
| parallel_while | Parallel iteration over a stream, with optional addition of more work |
| filter | A stage in a pipeline |
| thread_bound_filter | A stage in a pipeline served by a user thread |
| pipeline | A processing pipeline that applies filters to items |
| queuing_mutex | Queuing mutex with local-only spinning |
| scoped_lock | The scoped locking pattern |
| queuing_rw_mutex | Queuing reader-writer mutex with local-only spinning |
| scoped_lock | The scoped locking pattern |
| recursive_mutex | |
| scoped_lock | The scoped locking pattern |
| scalable_allocator | Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5 |
| rebind | |
| scalable_allocator< void > | Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1 |
| rebind | |
| spin_mutex | A lock that occupies a single byte |
| scoped_lock | Represents acquisition of a mutex |
| spin_rw_mutex_v3 | Fast, unfair, spinning reader-writer lock with backoff and writer-preference |
| scoped_lock | The scoped locking pattern |
| task_handle | |
| task_group | |
| structured_task_group | |
| task_scheduler_init | Class delimiting the scope of task scheduler activity |
| tbb_allocator | Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5 |
| rebind | |
| tbb_allocator< void > | Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1 |
| rebind | |
| zero_allocator | Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5 |
| rebind | |
| zero_allocator< void, Allocator > | Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1 |
| rebind | |
| bad_last_alloc | Exception for concurrent containers |
| improper_lock | Exception for PPL locks |
| user_abort | Exception for user-initiated abort |
| missing_wait | Exception for missing wait on structured_task_group |
| invalid_multiple_scheduling | Exception for repeated scheduling of the same task_handle |
| tbb_exception | Interface to be implemented by all exceptions TBB recognizes and propagates across the threads |
| captured_exception | This class is used by TBB to propagate information about unhandled exceptions into the root thread |
| movable_exception | Template that can be used to implement exception that transfers arbitrary ExceptionData to the root thread |
| split | Dummy type that distinguishes splitting constructor from copy constructor |
| tick_count | Absolute timestamp |
| interval_t | Relative time interval |
| __TBB_malloc_proxy_caller | |