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