Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

___itt_api_info |
___itt_api_info_20101001 |
___itt_global |
___itt_group_alias |
___itt_group_list |
___itt_thread_info |
__cilk_tbb_stack_op_thunk |
__cilk_tbb_unwatch_thunk |
__itt_counter_info |
tbb::internal::__TBB_InitOnce | Class that supports TBB initialization
__TBB_malloc_proxy_caller |
internal::Wrapper< T[N]>::_unwind_class |
internal::Wrapper< T >::_unwind_space |
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::accessor_not_used |
tbb::interface6::internal::aggregated_operation< Derived > | Aggregated_operation base class
internal::function_input_base< Input, Policy, A, ImplType >::operation_type |
internal::indexer_node_base< InputTuple, OutputType, StructTypes >::indexer_node_base_operation |
internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple >::key_matching_FE_operation |
internal::join_node_base< JP, InputTuple, OutputTuple >::join_node_base_operation |
internal::key_matching_port< TraitsType >::key_matching_port_operation |
internal::queueing_port< T >::queueing_port_operation |
internal::reserving_port< T >::reserving_port_operation |
tbb::flow::interface11::buffer_node< T, Allocator >::buffer_operation |
tbb::interface5::concurrent_priority_queue< T, Compare, A >::cpq_operation |
tbb::interface6::concurrent_lru_cache< key_type, value_type, value_functor_type >::aggregator_operation |
tbb::interface6::concurrent_lru_cache< key_type, value_type, value_functor_type >::retrieve_aggregator_operation |
tbb::interface6::concurrent_lru_cache< key_type, value_type, value_functor_type >::signal_end_of_usage_aggregator_operation |
tbb::interface6::internal::aggregated_operation< aggregator_operation > |
tbb::interface6::internal::aggregated_operation< buffer_operation > |
tbb::interface6::internal::aggregated_operation< cpq_operation > |
tbb::interface6::internal::aggregated_operation< indexer_node_base_operation > |
tbb::interface6::internal::aggregated_operation< join_node_base_operation > |
tbb::interface6::internal::aggregated_operation< key_matching_FE_operation > |
tbb::interface6::internal::aggregated_operation< key_matching_port_operation > |
tbb::interface6::internal::aggregated_operation< operation_type > |
tbb::interface6::internal::aggregated_operation< queueing_port_operation > |
tbb::interface6::internal::aggregated_operation< reserving_port_operation > |
tbb::interface6::internal::aggregating_functor< aggregating_class, operation_list > |
tbb::interface6::internal::aggregator_generic< operation_type > | Aggregator base class
tbb::interface6::internal::aggregator< tbb::interface6::internal::aggregating_functor, key_matching_FE_operation > |
tbb::interface6::internal::aggregator< tbb::interface6::internal::aggregating_functor, internal::key_matching_port::key_matching_port_operation > |
tbb::interface6::internal::aggregator< my_functor_t, cpq_operation > |
tbb::interface6::internal::aggregator< tbb::interface6::internal::aggregating_functor, internal::reserving_port::reserving_port_operation > |
tbb::interface6::internal::aggregator< tbb::interface6::internal::aggregating_functor, internal::queueing_port::queueing_port_operation > |
tbb::interface6::internal::aggregator< tbb::interface6::internal::aggregating_functor, internal::join_node_base::join_node_base_operation > |
tbb::interface6::internal::aggregator< aggregator_function_type, aggregated_operation_type > |
tbb::interface6::internal::aggregator< tbb::interface6::internal::aggregating_functor, internal::indexer_node_base::indexer_node_base_operation > |
tbb::interface6::internal::aggregator< tbb::interface6::internal::aggregating_functor, tbb::flow::interface11::buffer_node::buffer_operation > |
tbb::interface6::internal::aggregator< tbb::interface6::internal::aggregating_functor, internal::function_input_base::operation_type > |
tbb::interface6::internal::aggregator< handler_type, operation_type > |
tbb::interface6::aggregator_operation |
tbb::interface6::internal::basic_operation_base |
tbb::interface6::internal::basic_operation< Body > |
internal::aligned_pair< T1, T2 > |
tbb::internal::aligned_storage< value_type, size > |
tbb::internal::aligned_storage< I, sizeof(I)> |
tbb::internal::aligned_storage< T, sizeof(T)> |
tbb::internal::aligned_storage< value_type, 1 > |
internal::alignment_of< U > |
Allocator |
tbb::zero_allocator< void, Allocator > | Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1
tbb::internal::allocator_base< T, A > |
tbb::concurrent_vector< T, A > | Concurrent vector container
tbb::internal::allocator_base< padded_element, padded_allocator_type > |
tbb::concurrent_vector< padded_element, padded_allocator_type > |
tbb::internal::allocator_rebind< Alloc, T > |
tbb::internal::allocator_rebind< A, T > |
tbb::internal::allocator_rebind< Allocator, node > |
tbb::internal::allocator_rebind< allocator_type, raw_iterator > |
tbb::internal::allocator_rebind< allocator_type, tbb::interface5::internal::split_ordered_list::node > |
tbb::internal::allocator_rebind< cache_aligned_allocator< T >, char > |
tbb::internal::allocator_traits< Alloc > |
tbb::internal::allocator_traits< allocator_type > |
tbb::internal::allocator_type< T > | Class for determining type of std::allocator<T>::value_type
tbb::internal::arena_slot_line1 |
tbb::internal::arena_slot_line2 |
tbb::flow::interface11::internal::async_helpers< T, typename > |
tbb::flow::interface11::internal::async_helpers< T, typename std::enable_if< std::is_base_of< async_msg< typename T::async_msg_data_type >, T >::value >::type > |
async_msg< T > |
internal::streaming_node_traits< JP, StreamFactory, Ports >::async_msg_type< T > |
internal::async_storage< T > |
tbb::flow::interface11::internal::async_storage< T > |
tbb::internal::atomic_impl< T > | Base class that provides basic functionality for atomic<T> without fetch_and_add
tbb::internal::atomic_impl< I > |
tbb::internal::atomic_impl_with_arithmetic< I, D, StepType > | Base class that provides basic functionality for atomic<T> with fetch_and_add
tbb::internal::atomic_load_store_traits< M > |
tbb::internal::atomic_rep< S > |
tbb::internal::atomic_rep< 1 > |
tbb::internal::atomic_rep< 2 > |
tbb::internal::atomic_rep< 4 > |
tbb::internal::atomic_rep< 8 > |
tbb::internal::atomic_rep< sizeof(value_type)> |
tbb::internal::atomic_selector< S > |
tbb::internal::atomic_selector< 1 > |
tbb::internal::atomic_selector< 2 > |
tbb::internal::atomic_selector< 4 > |
tbb::internal::atomic_selector< 8 > |
tbb::internal::atomic_traits< Size, M > |
tbb::interface7::task_arena::attach | Tag class used to indicate the "attaching" constructor
tbb::internal::auto_empty_task | Smart holder for the empty task class with automatic destruction
tbb::auto_partitioner | An auto partitioner
tbb::interface6::internal::basic_handler |
tbb::internal::basic_tls< T > | Basic cross-platform wrapper class for TLS operations
tbb::internal::tls< T > | More advanced TLS support template class
tbb::internal::basic_tls< intptr_t > |
tbb::internal::basic_tls< T * > |
tbb::internal::tls< T * > |
tbb::internal::basic_tls< uintptr_t > |
tbb::internal::binding_handler |
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< I > |
tbb::concurrent_vector< T, A >::generic_range_type< I > |
tbb::interface6::enumerable_thread_specific< T, Allocator, ETS_key_type >::generic_range_type< I > | A generic range, used to create range objects from the iterators
tbb::blocked_range< PageValue > |
tbb::blocked_range< RowValue > |
tbb::internal::blocked_rangeNd_impl< Value, N, typename > |
tbb::internal::body_arg_detector< F > |
tbb::internal::body_arg_detector< ReturnType(Callable::*)(T) const > |
tbb::internal::body_arg_detector< ReturnType(Callable::*)(T)> |
tbb::internal::bool_constant< v > |
tbb::internal::bool_constant< has_policy< ExpectedPolicy, FirstPolicy >::value||has_policy< ExpectedPolicy, Policies... >::value > |
internal::has_policy< ExpectedPolicy, FirstPolicy, Policies... > |
tbb::internal::bool_constant< tbb::internal::is_same_type< ExpectedPolicy, SinglePolicy >::value > |
internal::has_policy< ExpectedPolicy, SinglePolicy > |
tbb::flow::interface11::internal::broadcast_cache< T, M > |
tbb::flow::interface11::internal::broadcast_cache< input_type > |
tbb::flow::interface11::internal::broadcast_cache< input_type, tbb::null_rw_mutex > |
tbb::flow::interface11::internal::broadcast_cache< T > |
buffer_element_type< ValueType > |
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::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::call_clear_on_leave |
tbb::interface5::internal::concurrent_unordered_base< Traits >::call_internal_clear_on_exit |
internal::clear_element< N > |
internal::clear_element< 1 > |
tbb::internal::co_context |
tbb::combinable< T > | Thread-local storage with optional reduction
composite_node |
streaming_node< tuple< Ports... >, JP, StreamFactory > |
tbb::flow::interface11::composite_node< InputTuple, OutputTuple > |
tbb::interface10::internal::concurrent_geometric_level_generator< MAX_LEVEL > |
tbb::interface5::concurrent_priority_queue< T, Compare, A > | Concurrent priority queue
tbb::interface5::concurrent_priority_queue< graph_task *, graph_task_comparator > |
tbb::interface5::concurrent_priority_queue< T, Compare, A > |
tbb::internal::concurrent_queue_iterator_base_v3 | Type-independent portion of concurrent_queue_iterator
tbb::internal::concurrent_queue_iterator< Container, Value > | Meets requirements of a forward iterator for STL
tbb::strict_ppl::internal::concurrent_queue_iterator_base_v3< Value > | Constness-independent portion of concurrent_queue_iterator
tbb::strict_ppl::internal::concurrent_queue_iterator_base_v3< tbb_remove_cv< Value >::type > |
tbb::strict_ppl::internal::concurrent_queue_iterator< Container, Value > | Meets requirements of a forward iterator for STL
tbb::strict_ppl::internal::concurrent_queue_page_allocator | Abstract class to define interface for page allocation/deallocation
tbb::strict_ppl::internal::concurrent_queue_base_v3< T > | Base class of concurrent_queue
tbb::strict_ppl::concurrent_queue< T, A > | A high-performance thread-safe non-blocking concurrent queue
tbb::internal::concurrent_queue_rep | Internal representation of a ConcurrentQueue
tbb::interface10::internal::concurrent_skip_list< Traits > |
tbb::interface5::concurrent_unordered_map_traits< Key, T, Hash_compare, Allocator, Allow_multimapping > |
tbb::interface5::concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< std::pair< const Key, T > >, false > |
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< std::pair< const Key, T > >, false > > |
tbb::interface5::concurrent_unordered_map< Key, T, Hasher, Key_equality, Allocator > |
tbb::interface5::concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< std::pair< const Key, T > >, true > |
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_map_traits< Key, T, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< std::pair< const Key, T > >, true > > |
tbb::interface5::concurrent_unordered_multimap< Key, T, Hasher, Key_equality, Allocator > |
tbb::interface5::concurrent_unordered_set_traits< Key, Hash_compare, Allocator, Allow_multimapping > |
tbb::interface5::concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > |
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, false > > |
tbb::interface5::concurrent_unordered_set< Key, Hasher, Key_equality, Allocator > |
tbb::interface5::concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, true > |
tbb::interface5::internal::concurrent_unordered_base< concurrent_unordered_set_traits< Key, internal::hash_compare< Key, tbb::tbb_hash< Key >, std::equal_to< Key > >, tbb::tbb_allocator< Key >, true > > |
tbb::interface5::concurrent_unordered_multiset< Key, Hasher, Key_equality, Allocator > |
tbb::internal::concurrent_vector_base_v3 | Base class of concurrent vector implementation
tbb::concurrent_vector< padded_element, padded_allocator_type > |
tbb::concurrent_vector< T, A > | Concurrent vector container
tbb::internal::conditional< C, T, U > |
tbb::internal::conditional< tbb::internal::is_same_type< DereferenceType, T >::value, intrusive_list_node *, const intrusive_list_node * > |
tbb::internal::conditional< true, T, U > |
tbb::internal::conjunction< Args > |
tbb::internal::context_guard_helper< T > |
tbb::internal::context_list_node_t |
tbb::flow::interface11::continue_msg | An empty class used for messages that mean "I'm done"
continue_receiver |
internal::continue_input< Output, internal::Policy< void > > |
tbb::flow::interface11::continue_node< Output, Policy > | Implements an executable node that supports continue_msg -> Output
internal::continue_input< Output, Policy > | Implements methods for an executable node that takes continue_msg as input
internal::decrementer< T, continue_msg, void > |
tbb::internal::control_storage |
internal::convert_and_call_impl< Args1 > |
internal::convert_and_call_impl< A1, Args1... > |
internal::convert_and_call_impl<> |
tbb::internal::atomic_impl< T >::converter< value_type > | Union type used to convert type T to underlying integral type
tbb::internal::coroutine_type |
internal::count_element< K > |
tbb::internal::cpu_ctl_env |
tbb::internal::cpu_ctl_env_space |
internal::decrementer< T, DecrementType, DummyType > |
internal::decrementer< tbb::flow::interface11::limiter_node< T, continue_msg >, continue_msg > |
internal::default_constructed |
tbb::flow::interface11::opencl_info::default_device_filter |
tbb::flow::interface11::opencl_info::default_device_selector< Factory > |
tbb::internal::DefaultSchedulerTraits | Traits classes for scheduler
tbb::internal::concurrent_vector_base_v3::helper::destroy_body |
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector_base |
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector< UserFunctor > |
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector_body |
tbb::interface9::internal::do_group_task< Body > |
internal::do_if< T, BUILD_IT > |
internal::do_if< T, false > |
internal::do_if< T, true > |
hash_buffer< Key, ValueType, ValueToKey, HashCompare, Allocator >::DoCleanup |
dynamic_link_descriptor | Association between a handler name and location of pointer to it
internal::emit_element< N > |
internal::emit_element< 1 > |
internal::empty_body< Input, Output > | An empty functor that takes an Input and returns a default constructed Output
tbb::internal::enable_if< Condition, T > | Enables one or the other code branches
tbb::internal::enable_if< true, T > |
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector< UserFunctor >::epoch_desc |
internal::ERROR_Type_Not_allowed_In_Tagged_Msg_Not_Member_Of_Tuple< T > |
internal::ets_base |
tbb::interface6::enumerable_thread_specific< std::mt19937_64 > |
tbb::interface6::enumerable_thread_specific< T, my_alloc, ets_no_key > |
tbb::interface6::enumerable_thread_specific< T, Allocator, ETS_key_type > | The enumerable_thread_specific container
std::exception | STL class
std::bad_alloc | STL class
tbb::bad_last_alloc | Exception for concurrent containers
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::internal::fast_reverse_vector< T, max_segments > | Vector that grows without reallocations, and stores items in the reverse order
tbb::internal::FastRandom | A fast random number generator
tbb::internal::fgt_internal_input_alias_helper< PortsTuple, N > |
tbb::internal::fgt_internal_output_alias_helper< PortsTuple, N > |
tbb::flow::interface11::opencl_program< Factory >::file_reader |
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
tbb::interface9::global_control |
tbb::internal::governor | The class handles access to the single instance of market, and to TLS to keep scheduler instances
tbb::flow::interface11::graph_iterator< GraphContainerType, GraphNodeType > |
graph_node |
internal::indexer_node_base< InputTuple, OutputType, StructTypes > | Indexer_node_base
internal::unfolded_indexer_node< tuple< T0, T1, T2, T3 > > |
tbb::flow::interface11::indexer_node< T0, T1, T2, T3 > |
internal::unfolded_indexer_node< tuple< T0, T1 > > |
tbb::flow::interface11::indexer_node< T0, T1 > |
internal::unfolded_indexer_node< tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 > > |
tbb::flow::interface11::indexer_node< T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 > |
internal::unfolded_indexer_node< tuple< T0, T1, T2, T3, T4 > > |
tbb::flow::interface11::indexer_node< T0, T1, T2, T3, T4 > |
internal::unfolded_indexer_node< tuple< T0, T1, T2, T3, T4, T5, T6, T7 > > |
tbb::flow::interface11::indexer_node< T0, T1, T2, T3, T4, T5, T6, T7 > |
internal::unfolded_indexer_node< tuple< T0, T1, T2 > > |
tbb::flow::interface11::indexer_node< T0, T1, T2 > |
internal::unfolded_indexer_node< tuple< T0, T1, T2, T3, T4, T5, T6, T7, T8 > > |
tbb::flow::interface11::indexer_node< T0, T1, T2, T3, T4, T5, T6, T7, T8 > |
internal::unfolded_indexer_node< tuple< T0, T1, T2, T3, T4, T5 > > |
tbb::flow::interface11::indexer_node< T0, T1, T2, T3, T4, T5 > |
internal::unfolded_indexer_node< tuple< T0, T1, T2, T3, T4, T5, T6 > > |
tbb::flow::interface11::indexer_node< T0, T1, T2, T3, T4, T5, T6 > |
internal::unfolded_indexer_node< tuple< T0 > > |
tbb::flow::interface11::indexer_node< T0 > |
internal::unfolded_indexer_node< OutputTuple > |
internal::join_node_base< JP, InputTuple, OutputTuple > | Join_node_base
internal::unfolded_join_node< tbb::flow::tuple_size< OutputTuple >::value, reserving_port, OutputTuple, reserving > |
tbb::flow::interface11::join_node< OutputTuple, reserving > |
internal::unfolded_join_node< tbb::flow::tuple_size< OutputTuple >::value, queueing_port, OutputTuple, queueing > |
tbb::flow::interface11::join_node< OutputTuple, queueing > |
internal::unfolded_join_node< tbb::flow::tuple_size< OutputTuple >::value, key_matching_port, OutputTuple, key_matching< K, KHash > > |
tbb::flow::interface11::join_node< OutputTuple, key_matching< K, KHash > > |
internal::unfolded_join_node< N, PT, OutputTuple, JP > | Unfolded_join_node : passes input_ports_type to join_node_base. We build the input port type
internal::unfolded_join_node< 2, key_matching_port, OutputTuple, key_matching< K, KHash > > |
internal::unfolded_join_node< 3, key_matching_port, OutputTuple, key_matching< K, KHash > > |
internal::unfolded_join_node< 4, key_matching_port, OutputTuple, key_matching< K, KHash > > |
internal::unfolded_join_node< 5, key_matching_port, OutputTuple, key_matching< K, KHash > > |
tbb::flow::interface11::graph_proxy | Pure virtual template classes that define interfaces for async communication
tbb::flow::interface11::receiver_gateway< Output > |
tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::receiver_gateway_impl |
tbb::flow::interface10::graph | The graph class
tbb::flow::interface11::receiver_gateway< Input > |
graph_task |
internal::apply_body_task_bypass< NodeType, Input > | A task that calls a node's apply_body_bypass function, passing in an input of type Input
internal::forward_task_bypass< NodeType > | A task that calls a node's forward_task function
internal::source_task_bypass< NodeType > | A task that calls a node's apply_body_bypass function with no input
tbb::flow::interface11::internal::graph_task_comparator |
tbb::interface6::concurrent_lru_cache< key_type, value_type, value_functor_type >::handle_object |
internal::has_policy< Policies > |
internal::has_policy< ExpectedPolicy, Policies... > |
internal::has_policy< ExpectedPolicy, Policy< Policies... > > |
tbb::interface5::internal::hash_compare< Key, Hasher, Key_equality > |
tbb::interface5::internal::hash_map_base | Base class of concurrent_hash_map
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator > | Unordered map from Key to T
tbb::interface5::internal::hash_map_range< Iterator > | Range class used with concurrent_hash_map
tbb::internal::hash_map_segment_base |
HashCompare |
hash_buffer< Key, ValueType, ValueToKey, HashCompare, Allocator > |
tbb::internal::tbb_thread_v3::id |
tbb::internal::index_sequence< S > |
internal::indexer_helper< TupleTypes, N > |
internal::indexer_helper< TupleTypes, 1 > |
internal::indexer_node_FE< InputTuple, OutputType, StructTypes > |
internal::indexer_node_base< InputTuple, OutputType, StructTypes > | Indexer_node_base
tbb::internal::concurrent_vector_base_v3::helper::init_body | TODO: turn into lambda functions when available
internal::init_output_ports< OutputTuple > |
internal::initializer_list_wrapper< T > |
internal::input_types< N, InputTuple > |
internal::input_types< 1, InputTuple > |
internal::input_types< 10, InputTuple > |
internal::input_types< 2, InputTuple > |
internal::input_types< 3, InputTuple > |
internal::input_types< 4, InputTuple > |
internal::input_types< 5, InputTuple > |
internal::input_types< 6, InputTuple > |
internal::input_types< 7, InputTuple > |
internal::input_types< 8, InputTuple > |
internal::input_types< 9, InputTuple > |
internal::input_types< tuple_size< OutputTuple >::value, OutputTuple > |
internal::indexer_types< OutputTuple > |
tbb::internal::int_to_type< int > | Utility helper structure to ease overload resolution
tbb::internal::IntelSchedulerTraits |
tbb::internal::concurrent_vector_base_v3::internal_segments_table | Internal structure for compact()
tbb::tick_count::interval_t | Relative time interval
tbb::internal::intrusive_list_base< List, T > | List of element of type T, where T is derived from intrusive_list_node
tbb::internal::intrusive_list< arena > |
tbb::internal::intrusive_list_base< intrusive_list< T >, T > |
tbb::internal::intrusive_list< T > | Double linked list of items of type T that is derived from intrusive_list_node class
tbb::internal::intrusive_list_base< memptr_intrusive_list< T, U, NodePtr >, T > |
tbb::internal::memptr_intrusive_list< T, U, NodePtr > | Double linked list of items of type T containing a member of type intrusive_list_node
tbb::internal::intrusive_list_node | Data structure to be inherited by the types that can form intrusive lists
tbb::internal::generic_scheduler | Work stealing task scheduler
tbb::internal::custom_scheduler< SchedulerTraits > | A scheduler with a customized evaluation loop
internal::is_element_of< Q, N, Tuple > |
internal::is_element_of< Q, 0, Tuple > |
tbb::concurrent_vector< T, A >::is_integer_tag< B > | True/false function override helper
tbb::internal::is_integral_impl< T > | Partial support for std::is_integral
tbb::internal::is_integral_impl< bool > |
tbb::internal::is_integral_impl< char > |
tbb::internal::is_integral_impl< int > |
tbb::internal::is_integral_impl< long > |
tbb::internal::is_integral_impl< long long > |
tbb::internal::is_integral_impl< short > |
tbb::internal::is_integral_impl< strip< T >::type > |
tbb::internal::is_integral< T > |
tbb::internal::is_integral_impl< wchar_t > |
internal::is_port_ref< T > |
internal::is_port_ref_impl< T > |
internal::is_port_ref_impl< port_ref_impl< N1, N2 > > |
internal::is_port_ref_impl< port_ref_impl< N1, N2 >(*)() > |
tbb::internal::is_ref< T > |
tbb::internal::is_ref< U & > |
tbb::internal::is_same_type< U, V > | Detects whether two given types are the same
tbb::internal::is_same_type< W, W > |
internal::item_buffer< T, A > |
internal::queueing_port< T > | Queueing join_port
internal::item_buffer< OutputTuple > |
internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple > |
internal::item_buffer< T, A > |
internal::function_input_queue< T, A > |
internal::item_buffer< T, cache_aligned_allocator< T > > |
internal::reservable_item_buffer< T, cache_aligned_allocator< T > > |
tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) > |
tbb::flow::interface11::queue_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) > |
tbb::flow::interface11::sequencer_node< T, Allocator > | Forwards messages in sequence order
tbb::flow::interface11::priority_queue_node< T, Compare, Allocator > | Forwards messages in priority order
tbb::flow::interface11::queue_node< T, Allocator > | Forwards messages in FIFO order
tbb::flow::interface11::buffer_node< T, Allocator > | Forwards messages in arbitrary order
internal::reservable_item_buffer< T, A > | Item_buffer with reservable front-end. NOTE: if reserving, do not
std::iterator |
tbb::interface5::internal::flist_iterator< Solist, Value > |
tbb::interface5::internal::solist_iterator< Solist, Value > |
tbb::interface5::internal::hash_map_iterator< Container, Value > | Meets requirements of a forward iterator for STL *‍/
tbb::internal::concurrent_queue_iterator< Container, Value > | Meets requirements of a forward iterator for STL
tbb::strict_ppl::internal::concurrent_queue_iterator< Container, Value > | Meets requirements of a forward iterator for STL
tbb::internal::intrusive_list_base< List, T >::iterator_impl< DereferenceType > |
rml::job |
tbb::internal::generic_scheduler | Work stealing task scheduler
internal::join_base< N, PT, OutputTuple, JP > |
internal::join_base< N, key_matching_port, OutputTuple, key_matching< K, KHash > > |
internal::join_helper< N > |
internal::join_helper< 1 > |
tbb::flow::interface11::join_node< OutputTuple, JP > |
internal::join_node_FE< JP, InputTuple, OutputTuple > | Join_node_FE : implements input port policy
internal::join_node_base< JP, InputTuple, OutputTuple > | Join_node_base
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename > |
internal::kernel_executor_helper< StreamFactory, internal::streaming_node_traits< JP, StreamFactory, Ports... >::kernel_input_tuple > |
streaming_node< tuple< Ports... >, JP, StreamFactory > |
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type > |
internal::key_from_policy< JP > |
internal::key_from_policy< key_matching< Key & > > |
internal::key_from_policy< key_matching< Key > > |
internal::graph_policy_namespace::key_matching< K, KHash > | Field of type K being used for matching
internal::key_to_count_functor< K > |
internal::KeyTrait< Kp, KHashp, Tp > |
KHash |
hash_buffer< tbb::internal::strip< K >::type &, count_element< tbb::internal::strip< K >::type >, internal::type_to_key_function_body< count_element< tbb::internal::strip< K >::type >, tbb::internal::strip< K >::type & >, KHash > |
internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple > |
TraitsType::KHash |
hash_buffer< TraitsType::K, TraitsType::T, TraitsType::TtoK, TraitsType::KHash > |
internal::key_matching_port< TraitsType > |
tbb::internal::lambda_reduce_body< Range, Value, RealBody, Reduction > | Auxiliary class for parallel_reduce; for internal use only
internal::graph_policy_namespace::lightweight |
tbb::internal::machine_load_store< T, S > |
tbb::internal::machine_load_store_relaxed< T, S > |
tbb::internal::machine_load_store_seq_cst< T, S > |
tbb::internal::mail_inbox | Class representing source of mail
tbb::internal::make_index_sequence_impl< 0, S... > |
tbb::internal::make_index_sequence_impl< N - 1, N - 1, S... > |
tbb::internal::make_index_sequence_impl< N, S > |
internal::make_sequence< N, S > |
internal::make_sequence< 0, S... > |
tbb::interface6::concurrent_lru_cache< key_type, value_type, value_functor_type >::map_value_type |
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
tbb::internal::micro_queue | A queue using simple locking
Mode |
tbb::interface9::internal::dynamic_grainsize_mode< Mode > |
tbb::interface5::concurrent_priority_queue< T, Compare, A >::my_functor_t |
tbb::internal::no_assign | Base class for types that should not be assigned
internal::function_body< T, size_t > |
internal::function_body< Input, continue_msg > |
internal::function_body_leaf< Input, continue_msg, B > | Leaf for function_body specialized for Output of continue_msg
internal::function_body< continue_msg, continue_msg > |
internal::function_body_leaf< continue_msg, continue_msg, B > | Leaf for function_body specialized for Input and output of continue_msg
internal::function_body< continue_msg, Output > |
internal::function_body_leaf< continue_msg, Output, B > | Leaf for function_body specialized for Input of continue_msg
internal::function_input_base< Input, Policy, A, function_input< Input, Output, Policy, A > > |
internal::function_input< Input, Output, Policy, A > | Implements methods for a function node that takes a type Input as input and sends
internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > > |
internal::multifunction_input< Input, OutputPortSet, Policy, A > | Implements methods for a function node that takes a type Input as input
tbb::flow::interface11::multifunction_node< Input, tuple< Output >, queueing_lightweight, __TBB_DEFAULT_NODE_ALLOCATOR(Input) > |
tbb::flow::interface11::async_node< Input, Output, Policy, Allocator > | Implements async node
internal::input_body< output_type > |
internal::source_body< output_type > |
internal::type_to_key_function_body< count_element< tbb::internal::strip< K >::type >, tbb::internal::strip< K >::type & > |
tbb::strict_ppl::internal::concurrent_queue_iterator_rep< Value > |
internal::forwarding_base |
internal::matching_forwarding_base< key_type > |
internal::matching_forwarding_base< K > |
internal::join_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple > |
internal::join_node_FE< queueing, InputTuple, OutputTuple > |
internal::join_node_FE< reserving, InputTuple, OutputTuple > |
internal::matching_forwarding_base< KeyType > |
internal::function_body< Input, Output > | A functor that takes an Input and generates an Output
internal::function_body_leaf< Input, Output, B > | Leaf for function_body
internal::function_input_base< Input, Policy, A, ImplType > | Input and scheduling for a function node that takes a type Input as input
internal::function_input< Input, continue_msg, queueing, cache_aligned_allocator< Input > > |
tbb::flow::interface11::function_node< Input, Output, Policy, Allocator > | Implements a function node that supports Input -> Output
internal::multifunction_input< Input, internal::wrap_tuple_elements< tbb::flow::tuple_size< Output >::value, internal::multifunction_output, Output >::type, queueing, cache_aligned_allocator< Input > > |
tbb::flow::interface11::multifunction_node< Input, Output, Policy, Allocator > | Implements a function node that supports Input -> (set of outputs)
internal::input_body< Output > | A functor that takes no input and generates a value of type Output
internal::input_body_leaf< Output, Body > | The leaf for input_body
internal::multifunction_body< Input, OutputSet > | Function_body that takes an Input and a set of output ports
internal::multifunction_body_leaf< Input, OutputSet, B > | Leaf for multifunction. OutputSet can be a std::tuple or a vector
internal::source_body< Output > |
internal::source_body_leaf< Output, Body > | The leaf for source_body
internal::type_to_key_function_body< Input, Output > |
internal::type_to_key_function_body_leaf< Input, Output, B > |
internal::type_to_key_function_body< Input, Output & > |
internal::type_to_key_function_body_leaf< Input, Output &, B > |
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage< Args >::run_finalize_func< FinalizeFn > |
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage< Args >::run_finalize_func< FinalizeFn >::finalize_func |
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage< Args >::run_kernel_func |
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage< Args >::send_func |
streaming_node< tuple< Ports... >, JP, StreamFactory >::device_selector< UserFunctor > |
streaming_node< tuple< Ports... >, JP, StreamFactory >::kernel_body |
tbb::flow::interface10::graph::spawn_functor | A functor that spawns a task
tbb::flow::interface11::internal::async_body_base< Gateway > |
tbb::flow::interface11::internal::async_body< Input, Ports, Gateway, Body > |
tbb::flow::interface11::opencl_factory< DeviceFilter >::finalize_fn |
tbb::flow::interface11::opencl_factory< DeviceFilter >::finalize_fn_leaf< Fn > |
tbb::flow::interface11::opencl_factory< DeviceFilter >::kernel |
tbb::flow::interface11::opencl_program< Factory > |
tbb::interface10::internal::concurrent_skip_list< Traits >::const_range_type |
tbb::interface10::internal::concurrent_skip_list< Traits >::range_type |
tbb::interface5::internal::concurrent_unordered_base< Traits >::const_range_type |
tbb::interface5::internal::concurrent_unordered_base< Traits >::range_type |
tbb::interface5::internal::split_ordered_list< T, Allocator >::node |
tbb::interface6::concurrent_lru_cache< key_type, value_type, value_functor_type > |
tbb::interface6::concurrent_lru_cache< key_type, value_type, value_functor_type >::retrieve_aggregator_operation |
tbb::interface6::concurrent_lru_cache< key_type, value_type, value_functor_type >::signal_end_of_usage_aggregator_operation |
tbb::interface6::internal::basic_operation< Body > |
tbb::interface7::internal::delegate_base |
tbb::interface7::internal::delegated_function< F, R > |
tbb::interface7::internal::delegated_function< F, void > |
tbb::interface9::internal::quick_sort_pretest_body< RandomAccessIterator, Compare > | Body class used to test if elements in a range are presorted
tbb::interface9::internal::quick_sort_range< RandomAccessIterator, Compare > | Range used in quicksort to split elements into subranges based on a value
tbb::internal::allocate_additional_child_of_proxy |
tbb::internal::allocate_child_proxy |
tbb::internal::allocate_continuation_proxy |
tbb::internal::allocate_root_proxy |
tbb::internal::allocate_root_with_context_proxy |
tbb::internal::concurrent_queue_iterator_rep |
tbb::internal::concurrent_vector_base_v3::helper |
tbb::internal::concurrent_vector_base_v3::helper::segment_not_used_predicate |
tbb::internal::lambda_scan_body< Range, Value, Scan, ReverseJoin > |
tbb::internal::no_copy | Base class for types that should not be copied or assigned
internal::successor_cache< T, spin_rw_mutex > |
internal::broadcast_cache< T, M > | A cache of successors that are broadcast to
internal::round_robin_cache< T, M > | A cache of successors that are put in a round-robin fashion
tbb::interface6::aggregator_ext< internal::basic_handler > |
tbb::interface6::aggregator | Basic aggregator interface
tbb::internal::task_stream< num_priority_levels > |
internal::decrementer< T, DecrementType, typename tbb::internal::enable_if< tbb::internal::is_integral< DecrementType >::value, void >::type > |
internal::decrementer< T, continue_msg, void > |
internal::successor_cache< T, M > | An abstract cache of successors
internal::broadcast_cache< output_type, null_rw_mutex > |
internal::broadcast_cache< output_type > |
internal::successor_cache< continue_msg, M > | An abstract cache of successors, specialized to continue_msg
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage< Args >::run_kernel_func::kernel_func |
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage_base |
streaming_node< tuple< Ports... >, JP, StreamFactory >::args_storage< Args > |
tbb::concurrent_bounded_queue< T, A >::destroyer | Class used to ensure exception-safety of method "pop"
tbb::concurrent_vector< T, A >::internal_loop_guide | Exception-aware helper class for filling a segment by exception-danger operators of user class
tbb::concurrent_vector< T, A >::push_back_helper |
tbb::concurrent_vector< T, A >::push_back_helper::element_construction_guard |
tbb::filter | A stage in a pipeline
tbb::interface6::internal::concrete_filter< T, U, Body > |
tbb::interface6::internal::concrete_filter< T, void, Body > |
tbb::interface6::internal::concrete_filter< void, U, Body > |
tbb::interface6::internal::concrete_filter< void, void, Body > |
tbb::thread_bound_filter | A stage in a pipeline served by a user thread
tbb::flow::interface10::graph | The graph class
tbb::flow::interface11::callback_base |
tbb::flow::interface11::callback< Callback, T > |
tbb::flow::interface11::graph_node | The base of all graph nodes
tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) > |
tbb::flow::interface11::multifunction_node< Input, tuple< Output >, queueing_lightweight, __TBB_DEFAULT_NODE_ALLOCATOR(Input) > |
tbb::flow::interface11::broadcast_node< T > | Forwards messages of type T to all successors
tbb::flow::interface11::buffer_node< T, Allocator > | Forwards messages in arbitrary order
tbb::flow::interface11::composite_node< tbb::flow::tuple< InputTypes... >, tbb::flow::tuple< OutputTypes... > > |
tbb::flow::interface11::composite_node< tbb::flow::tuple< InputTypes... >, tbb::flow::tuple<> > |
tbb::flow::interface11::composite_node< tbb::flow::tuple<>, tbb::flow::tuple< OutputTypes... > > |
tbb::flow::interface11::continue_node< Output, Policy > | Implements an executable node that supports continue_msg -> Output
tbb::flow::interface11::function_node< Input, Output, Policy, Allocator > | Implements a function node that supports Input -> Output
tbb::flow::interface11::input_node< Output > | An executable node that acts as a source, i.e. it has no predecessors
tbb::flow::interface11::limiter_node< T, DecrementType > | Forwards messages only if the threshold has not been reached
tbb::flow::interface11::multifunction_node< Input, Output, Policy, Allocator > | Implements a function node that supports Input -> (set of outputs)
tbb::flow::interface11::overwrite_node< T > |
tbb::flow::interface11::write_once_node< T > |
tbb::flow::interface11::source_node< Output > | An executable node that acts as a source, i.e. it has no predecessors
tbb::flow::interface11::split_node< TupleType, Allocator > | Split_node: accepts a tuple as input, forwards each element of the tuple to its
tbb::flow::interface11::opencl_info::default_opencl_factory |
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::node_scoped_guard |
tbb::interface5::internal::hash_map_base::bucket | Bucket type
tbb::interface5::internal::hash_map_base::enable_segment_failsafe | Exception safety helper
tbb::interface5::internal::hash_map_node_base | Node base type
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::node |
tbb::interface5::internal::task_base | Base class for methods that became static in TBB 3.0
tbb::interface6::aggregator_ext< handler_type > | Aggregator base class and expert interface
tbb::interface6::internal::filter_node | Abstract base class that represents a node in a parse tree underlying a filter_t
tbb::interface6::internal::filter_node_join | Node in parse tree representing join of two filters
tbb::interface6::internal::filter_node_leaf< T, U, Body > | Node in parse tree representing result of make_filter
tbb::interface6::internal::pool_base | Base of thread-safe pool allocator for variable-size requests
tbb::interface6::fixed_pool |
tbb::interface6::memory_pool< Alloc > | Thread-safe growable pool allocator for variable-size requests
tbb::interface6::runtime_loader | Load TBB at runtime
tbb::interface7::internal::padded_mutex< Mutex, false >::scoped_lock | Represents acquisition of a mutex
tbb::interface7::internal::padded_mutex< Mutex, true >::scoped_lock | Represents acquisition of a mutex
tbb::interface9::parallel_do_feeder< Item > | Class the user supplied algorithm body uses to add new tasks
tbb::interface9::internal::parallel_do_feeder_impl< Body, Item > | For internal use only
tbb::internal::affinity_helper |
tbb::internal::affinity_partitioner_base_v3 | Defines entry point for affinity partitioner into TBB run-time library
tbb::affinity_partitioner | An affinity partitioner
tbb::internal::atomic_backoff | Class that implements exponential backoff
tbb::internal::binary_semaphore | Binary_semaphore for concurrent monitor
tbb::internal::circular_doubly_linked_list_with_sentinel | Circular doubly-linked list with sentinel
tbb::internal::concurrent_monitor | Concurrent_monitor
tbb::internal::concurrent_monitor::thread_context |
tbb::internal::concurrent_queue_base_v3 | For internal use only
tbb::internal::concurrent_queue_base_v8 | For internal use only
tbb::concurrent_bounded_queue< T, A > | A high-performance thread-safe blocking concurrent bounded queue
tbb::internal::critical_section_v4 |
tbb::internal::critical_section_v4::scoped_lock |
tbb::internal::input_buffer | A buffer of input items for a filter
tbb::internal::lane_selector_base |
tbb::internal::preceding_lane_selector |
tbb::internal::subsequent_lane_selector |
tbb::internal::market |
tbb::internal::micro_queue_pop_finalizer |
tbb::internal::mutex_copy_deprecated_and_disabled |
tbb::interface7::internal::padded_mutex< Mutex, false > |
tbb::interface7::internal::padded_mutex< Mutex, true > |
tbb::null_mutex | A mutex which does nothing
tbb::null_rw_mutex | A rw mutex which does nothing
tbb::queuing_mutex | Queuing mutex with local-only spinning
tbb::queuing_rw_mutex | Queuing reader-writer mutex with local-only spinning
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::internal::nested_arena_context |
tbb::internal::parallel_invoke_cleaner |
tbb::internal::pipeline_cleaner |
tbb::internal::random_lane_selector |
tbb::internal::rml::private_server |
tbb::internal::rml::private_worker |
tbb::internal::rml::padded_private_worker |
tbb::internal::scheduler |
tbb::internal::generic_scheduler | Work stealing task scheduler
tbb::internal::semaphore | Edsger Dijkstra's counting semaphore
tbb::internal::task_group_base |
tbb::structured_task_group |
tbb::task_group |
tbb::internal::task_group_base::ref_count_guard |
tbb::internal::task_stream< Levels > | The container for "fairness-oriented" aka "enqueued" tasks
tbb::internal::task_stream_base |
tbb::internal::task_stream_accessor< accessor > |
tbb::internal::task_stream< num_priority_levels > |
tbb::internal::task_stream< Levels > | The container for "fairness-oriented" aka "enqueued" tasks
tbb::internal::task_stream_accessor< back_nonnull_accessor > |
tbb::null_mutex::scoped_lock | Represents acquisition of a mutex
tbb::null_rw_mutex::scoped_lock | Represents acquisition of a mutex
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::serial::interface9::start_for< Range, Body, Partitioner > |
tbb::spin_mutex::scoped_lock | Represents acquisition of a mutex
tbb::spin_rw_mutex_v3::scoped_lock | The scoped locking pattern
tbb::strict_ppl::internal::concurrent_queue_rep_base | Parts of concurrent_queue_rep that do not have references to micro_queue
tbb::strict_ppl::internal::concurrent_queue_rep< T > | Representation of concurrent_queue_base
tbb::strict_ppl::internal::micro_queue< T > | A queue using simple locking
tbb::strict_ppl::internal::micro_queue< T >::destroyer | Class used to ensure exception-safety of method "pop"
tbb::strict_ppl::internal::micro_queue_pop_finalizer< T > |
tbb::task_group_context | Used to form groups of tasks
tbb::task_list | A list of children
tbb::task_scheduler_init | Class delimiting the scope of task scheduler activity
tbb::tricky_atomic_pointer< T > | A view of a T* with additional functionality for twiddling low-order bits
tbb::internal::parallel_for_body< Function, Index > | Calls the function with values from range [begin, end) with a step provided
tbb::internal::parallel_for_each_body_do< Function, Iterator > |
tbb::internal::parallel_for_each_body_for< Function, Iterator > |
tbb::proportional_split | Type enables transmission of splitting proportion from partitioners to range objects
tbb::strict_ppl::internal::concurrent_queue_iterator_rep< T > |
tbb::task_handle< F > |
internal::node_cache< T, M > | A node_cache maintains a std::queue of elements of type T. Each operation is protected by a lock
internal::predecessor_cache< input_type, null_mutex > |
internal::node_cache< sender< T >, spin_mutex > |
internal::predecessor_cache< T, spin_mutex > |
internal::reservable_predecessor_cache< T, M > | An cache of predecessors that supports requests and reservations
internal::predecessor_cache< T, M > | A cache of predecessors that only supports try_get
internal::reservable_predecessor_cache< T, null_mutex > |
tbb::internal::node_handle_base< Value, Node, Allocator > |
tbb::internal::node_handle< Key, Value, Node, Allocator > |
tbb::internal::node_handle_base< Key, Node, Allocator > |
tbb::internal::node_handle< Key, Key, Node, Allocator > |
tbb::internal::circular_doubly_linked_list_with_sentinel::node_t |
tbb::internal::concurrent_monitor::thread_context |
tbb::interface10::internal::concurrent_skip_list< Traits >::not_greater_compare |
tbb::flow::interface11::null_type | A generic null type
internal::num_arguments< T > |
internal::num_arguments< port_ref_impl< N1, N2 > > |
internal::num_arguments< port_ref_impl< N1, N2 >(*)()> |
tbb::flow::interface11::opencl_buffer< T, Factory > |
tbb::flow::interface11::opencl_buffer< T, Factory > |
tbb::flow::interface11::opencl_subbuffer< T, Factory > |
tbb::flow::interface11::opencl_device |
tbb::flow::interface11::opencl_program< Factory >::opencl_device_filter |
tbb::flow::interface11::opencl_device_list |
tbb::flow::interface11::opencl_factory< DeviceFilter > |
tbb::flow::interface11::opencl_factory< default_device_filter > |
tbb::flow::interface11::opencl_info::default_opencl_factory |
tbb::flow::interface11::opencl_memory< Factory > |
tbb::flow::interface11::opencl_buffer_impl< Factory > |
tbb::flow::interface11::opencl_program< Factory >::opencl_program_builder |
tbb::flow::interface11::opencl_range |
tbb::interface7::internal::padded_mutex< Mutex, is_rw > |
tbb::internal::concurrent_queue_base_v3::page | Prefix on a page
tbb::internal::concurrent_queue_base_v3::padded_page< T > |
tbb::strict_ppl::internal::concurrent_queue_rep_base::page | Prefix on a page
tbb::strict_ppl::internal::micro_queue< T >::padded_page |
tbb::interface9::internal::parallel_do_operator_selector< Body, Item > | For internal use only
tbb::internal::parallel_for_each_impl< Iterator, Function, Generic > |
tbb::internal::parallel_for_each_impl< Iterator, Function, std::random_access_iterator_tag > |
tbb::internal::parallel_invoke_helper::parallel_invoke_noop |
tbb::interface9::internal::partition_type_base< Partition > | Provides default methods for partition objects and common algorithm blocks
tbb::internal::partition_type_base | Provides backward-compatible methods for partition objects without affinity
tbb::interface9::internal::old_auto_partition_type | Backward-compatible partition for auto and affinity partition objects
tbb::simple_partitioner::partition_type |
tbb::internal::partition_type_base< Partition > |
tbb::interface9::internal::adaptive_mode< Partition > | Provides default splitting strategy for partition objects
tbb::interface9::internal::dynamic_grainsize_mode< adaptive_mode< auto_partition_type > > |
tbb::interface9::internal::auto_partition_type |
tbb::interface9::internal::proportional_mode< Partition > | Provides proportional splitting strategy for partition objects
tbb::interface9::internal::linear_affinity_mode< static_partition_type > |
tbb::interface9::internal::static_partition_type |
tbb::interface9::internal::linear_affinity_mode< Partition > | Provides default linear indexing of partitioner's sequence
tbb::interface9::internal::dynamic_grainsize_mode< linear_affinity_mode< affinity_partition_type > > |
tbb::interface9::internal::affinity_partition_type |
tbb::internal::partition_type_base< simple_partition_type > |
tbb::interface9::internal::simple_partition_type |
internal::pick_max< Selector, T1, T2 > |
internal::pick_one< bool, T1, T2 > |
internal::pick_one< false, T1, T2 > |
internal::pick_one< true, T1, T2 > |
internal::pick_tuple_max< N, Tuple, Selector > |
internal::pick_tuple_max< 0, Tuple, Selector > |
tbb::interface6::internal::pipeline_proxy | The class that represents an object of the pipeline for parallel_pipeline()
tbb::internal::platform_topology |
internal::Policy< Policies > |
internal::port_ref_impl< N1, N2 > |
tbb::pre_scan_tag | Used to indicate that the initial scan is being performed
tbb::flow::interface11::internal::predecessor_cache< T, M > |
tbb::internal::predicate_leq |
tbb::interface9::internal::proportion_helper< Range, typename > | A helper class to create a proportional_split object for a given type of Range
tbb::interface9::internal::proportion_helper< Range, typename enable_if< Range::is_splittable_in_proportion, void >::type > |
tbb::internal::atomic_impl< T >::ptr_converter< value_t > |
tbb::internal::atomic_impl< T >::ptr_converter< value_t * > |
tbb::internal::queue_and_mutex< T, mutex_t > | Essentially, this is just a pair of a queue and a mutex to protect the queue
internal::graph_policy_namespace::queueing |
tbb::interface9::internal::quick_sort_body< RandomAccessIterator, Compare > | Body class used to sort elements in a range that is smaller than the grainsize
tbb::interface9::internal::range_vector< T, MaxCapacity > | Range pool stores ranges of type T in a circular buffer with MaxCapacity
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_wrapper |
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_mapper< N > |
internal::kernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type >::range_value |
tbb::cache_aligned_allocator< T >::rebind< U > |
tbb::cache_aligned_allocator< void >::rebind |
tbb::interface6::memory_pool_allocator< T, P >::rebind< U > |
tbb::interface6::memory_pool_allocator< void, P >::rebind< U > |
tbb::tbb_allocator< T >::rebind< U > |
tbb::tbb_allocator< void >::rebind |
tbb::zero_allocator< T, Allocator >::rebind< U > |
tbb::zero_allocator< void, Allocator >::rebind< U > |
tbb::internal::allocator_traits< Alloc >::rebind_alloc< U > |
receiver |
internal::function_input_base< Input, Policy, A, function_input< Input, Output, Policy, A > > |
internal::function_input_base< Input, Policy, A, multifunction_input< Input, OutputPortSet, Policy, A > > |
internal::decrementer< T, DecrementType, typename tbb::internal::enable_if< tbb::internal::is_integral< DecrementType >::value, void >::type > |
internal::function_input_base< Input, Policy, A, ImplType > | Input and scheduling for a function node that takes a type Input as input
internal::indexer_input_port< T > |
internal::key_matching_port< TraitsType > |
internal::queueing_port< T > | Queueing join_port
internal::reserving_port< T > | The two-phase join port
internal::graph_policy_namespace::rejecting |
tbb::flow::interface11::internal::reservable_predecessor_cache< T, M > |
tbb::flow::interface11::internal::reservable_predecessor_cache< T, tbb::spin_mutex > |
internal::graph_policy_namespace::reserving |
tbb::interface7::internal::return_type_or_void< F > |
tbb::internal::reverse< T > |
tbb::flow::interface11::internal::round_robin_cache< T, M > |
tbb::flow::interface11::internal::round_robin_cache< T, tbb::null_rw_mutex > |
tbb::flow::interface11::run_and_put_task< R, B > |
tbb::internal::concurrent_vector_base_v3::helper::safe_init_body |
tbb::internal::scheduler_properties | Bit-field representing properties of a sheduler
tbb::internal::scheduler_state |
tbb::internal::generic_scheduler | Work stealing task scheduler
bucket::scoped_t |
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::bucket_accessor | Bucket accessor is to find, rehash, acquire a lock, and access a bucket
node::scoped_t |
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::const_accessor | Combines data access, locking, and garbage collection
tbb::interface5::concurrent_hash_map< Key, T, HashCompare, Allocator >::accessor | Allows write access to elements and combines data access, locking, and garbage collection
tbb::internal::concurrent_vector_base_v3::segment_allocated |
tbb::internal::concurrent_vector_base_v3::segment_allocation_failed |
tbb::internal::concurrent_vector_base_v3::segment_not_used |
tbb::internal::concurrent_vector_base_v3::segment_t |
tbb::internal::concurrent_vector_base_v3::segment_value_t |
tbb::internal::select_size_t_constant< u, ull > | A template to select either 32-bit or 64-bit constant as compile time, depending on machine word size
sender |
internal::function_output< continue_msg > |
tbb::flow::interface11::function_node< Input, Output, Policy, Allocator > | Implements a function node that supports Input -> Output
internal::indexer_node_base< InputTuple, OutputType, StructTypes > | Indexer_node_base
internal::join_node_base< JP, InputTuple, OutputTuple > | Join_node_base
internal::sequence< S > |
tbb::simple_partitioner | A simple partitioner
internal::size_of< T > |
tbb::interface10::internal::skip_list_iterator< NodeType, is_const > |
tbb::interface10::internal::skip_list_iterator< list_node_type, true > |
tbb::interface10::internal::skip_list_node< Value, Mutex > |
tbb::split | Dummy type that distinguishes splitting constructor from copy constructor
tbb::interface5::internal::split_ordered_list< T, Allocator > |
tbb::interface5::internal::split_ordered_list< value_type, typename Traits::allocator_type > |
tbb::internal::STATIC_ASSERTION_FAILED< condition > |
tbb::internal::STATIC_ASSERTION_FAILED< false > |
tbb::static_partitioner | A static partitioner
tbb::internal::stored_pack< Types > | Allows to store a function parameter pack as a variable and later pass it to another function
tbb::internal::stored_pack< Args... > |
tbb::internal::stored_pack< Types... > |
tbb::internal::stored_pack< T, Types... > |
tbb::internal::stored_pack<> |
internal::streaming_device_with_key< Device, Key > |
internal::streaming_node_traits< JP, StreamFactory, Ports > |
internal::streaming_node_traits< JP, StreamFactory, Ports... > |
tbb::internal::strip< T > | Strips its template type argument from cv- and ref-qualifiers
tbb::internal::strip< const T & > |
tbb::internal::strip< const T && > |
tbb::internal::strip< const T > |
tbb::internal::strip< const T(&)[N]> |
tbb::internal::strip< const volatile T & > |
tbb::internal::strip< const volatile T && > |
tbb::internal::strip< const volatile T > |
tbb::internal::strip< const volatile T(&)[N]> |
tbb::internal::strip< key_type > |
tbb::internal::strip< KeyType > |
tbb::internal::strip< T & > |
tbb::internal::strip< T && > |
tbb::internal::strip< T(&)()> | Specialization for function pointers
tbb::internal::strip< T(&)[N]> | Specialization for arrays converts to a corresponding pointer
tbb::internal::strip< volatile T & > |
tbb::internal::strip< volatile T && > |
tbb::internal::strip< volatile T > |
tbb::internal::strip< volatile T(&)[N]> |
tbb::flow::interface11::internal::successor_cache< T, M > |
tbb::internal::supports_impl< T, typename, Checks > |
tbb::internal::supports_impl< T, typename void_t< Checks< T >... >::type, Checks... > |
T |
tbb::internal::padded_base< T, NFS_MaxLineSize, sizeof(T) % NFS_MaxLineSize > |
tbb::internal::padded< T, S > | Pads type T to fill out to a multiple of cache line size
tbb::internal::conjunction< T > |
tbb::internal::padded_base< T, S, R > |
tbb::internal::padded< arena_base > |
tbb::internal::arena |
tbb::internal::padded< tbb::internal::queue_and_mutex > |
tbb::internal::padded< intrusive_list_node > |
tbb::internal::arena_base | The structure of an arena, except the array of slots
tbb::internal::padded< control_storage > |
tbb::internal::allowed_parallelism_control |
tbb::internal::stack_size_control |
tbb::internal::padded< unpadded_mail_outbox > |
tbb::internal::mail_outbox | Class representing where mail is put
tbb::internal::padded< arena_slot_line2 > |
tbb::internal::arena_slot |
tbb::internal::padded< arena_slot_line1 > |
tbb::internal::arena_slot |
tbb::internal::padded_base< T, S, 0 > |
internal::tagged_msg< TagType, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 > |
internal::tagged_null_type |
tbb::interface7::internal::task_arena_base |
tbb::interface7::task_arena |
__TBB_TASK_BASE_ACCESS interface5::internal::task_base |
tbb::task | Base class for user-defined tasks
tbb::empty_task | Task that does nothing. Useful for synchronization
tbb::internal::parallel_invoke_helper |
tbb::flow::interface11::graph_task | Base class for tasks generated by graph nodes
tbb::flow::interface10::graph::run_and_put_task< Receiver, Body > |
tbb::flow::interface10::graph::run_task< Body > |
tbb::flow::interface11::overwrite_node< T >::register_predecessor_task | Breaks an infinite loop between the node reservation and register_successor call
tbb::flow::interface11::internal::priority_task_selector |
tbb::interface9::internal::do_group_task_forward< Iterator, Body, Item > | For internal use only
tbb::interface9::internal::do_group_task_input< Body, Item > |
tbb::interface9::internal::do_iteration_task< Body, Item > | For internal use only
tbb::interface9::internal::do_iteration_task_iter< Iterator, Body, Item > |
tbb::interface9::internal::do_task_iter< Iterator, Body, Item > | For internal use only
tbb::interface9::internal::finish_deterministic_reduce< Body > | Task type used to combine the partial results of parallel_deterministic_reduce
tbb::interface9::internal::flag_task | Join task node that contains shared flag for stealing feedback
tbb::interface9::internal::finish_reduce< Body > | Task type used to combine the partial results of parallel_reduce
tbb::interface9::internal::start_deterministic_reduce< Range, Body, Partitioner > | Task type used to split the work of parallel_deterministic_reduce
tbb::interface9::internal::start_for< Range, Body, Partitioner > | Task type used in parallel_for
tbb::interface9::internal::start_reduce< Range, Body, Partitioner > | Task type used to split the work of parallel_reduce
tbb::internal::final_sum< Range, Body > | Performs final scan for a leaf
tbb::internal::finish_scan< Range, Body > | Combine partial results
tbb::internal::function_invoker< function > |
tbb::internal::function_task< F > |
tbb::internal::pipeline_root_task |
tbb::internal::spawner< N, function1, function2, function3 > |
tbb::internal::stage_task |
tbb::internal::start_scan< Range, Body, Partitioner > | Initial task to split the work
tbb::internal::sum_node< Range, Body > | Split work to be done in the scan
tbb::internal::task_handle_task< F > |
tbb::internal::task_proxy |
tbb::internal::while_group_task< Body > | For internal use only
tbb::internal::while_iteration_task< Body > | For internal use only
tbb::internal::while_task< Stream, Body > | For internal use only
tbb::internal::task_info | This structure is used to store task information in a input buffer
tbb::internal::stage_task |
tbb::internal::task_prefix | Memory prefix to a task object
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::zero_allocator< T, Allocator > | 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
rml::tbb_client |
tbb::internal::market |
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::strict_ppl::internal::tbb_remove_cv< T > | Similar to C++0x std::remove_cv
tbb::strict_ppl::internal::tbb_remove_cv< const T > |
tbb::strict_ppl::internal::tbb_remove_cv< const volatile T > |
tbb::strict_ppl::internal::tbb_remove_cv< volatile T > |
tbb_server |
tbb::internal::rml::private_server |
tbb::internal::tbb_thread_v3 | Versioned thread class
tbb::interface6::internal::tbb_trivially_copyable< T > |
tbb::interface6::internal::tbb_trivially_copyable< bool > |
tbb::interface6::internal::tbb_trivially_copyable< char > |
tbb::interface6::internal::tbb_trivially_copyable< double > |
tbb::interface6::internal::tbb_trivially_copyable< float > |
tbb::interface6::internal::tbb_trivially_copyable< int > |
tbb::interface6::internal::tbb_trivially_copyable< long > |
tbb::interface6::internal::tbb_trivially_copyable< long double > |
tbb::interface6::internal::tbb_trivially_copyable< long long > |
tbb::interface6::internal::tbb_trivially_copyable< short > |
tbb::interface6::internal::tbb_trivially_copyable< signed char > |
tbb::interface6::internal::tbb_trivially_copyable< T * > |
tbb::interface6::internal::tbb_trivially_copyable< unsigned char > |
tbb::interface6::internal::tbb_trivially_copyable< unsigned int > |
tbb::interface6::internal::tbb_trivially_copyable< unsigned long > |
tbb::interface6::internal::tbb_trivially_copyable< unsigned long long > |
tbb::interface6::internal::tbb_trivially_copyable< unsigned short > |
tbb::interface6::internal::tbb_trivially_copyable< wchar_t > |
internal::alignment_of< U >::test_alignment |
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
tbb::interface6::internal::token_helper< T, Allocate > |
tbb::interface6::internal::token_helper< T *, false > |
tbb::interface6::internal::token_helper< T, false > |
tbb::interface6::internal::token_helper< T, true > |
Traits |
tbb::interface5::internal::concurrent_unordered_base< Traits > |
std::true_type |
tbb::internal::conjunction<> |
tbb::flow::interface11::async_node< Input, Output, Policy, Allocator >::try_put_functor |
std::conditional::type |
tbb::internal::conjunction< First, Args... > |
internal::type_plus_align< T1, T2, REM > | Type mimicking std::pair but with trailing fill to ensure each element of an array
internal::type_plus_align< T1, T2, 0 > |
tbb::interface6::internal::token_helper< T, false >::type_to_void_ptr_map |
tbb::internal::type_with_alignment< N > |
tbb::internal::type_with_alignment< 1 > |
tbb::internal::type_with_alignment< 16 > |
tbb::internal::type_with_alignment< 2 > |
tbb::internal::type_with_alignment< 32 > |
tbb::internal::type_with_alignment< 4 > |
tbb::internal::type_with_alignment< 64 > |
tbb::internal::type_with_alignment< 8 > |
tbb::internal::unpadded_mail_outbox | Internal representation of mail_outbox, without padding
tbb::flow::interface11::internal::untyped_receiver |
tbb::flow::interface11::receiver< TupleType > |
tbb::flow::interface11::split_node< TupleType, Allocator > | Split_node: accepts a tuple as input, forwards each element of the tuple to its
tbb::flow::interface11::receiver< continue_msg > |
tbb::flow::interface11::continue_receiver | Base class for receivers of completion messages
tbb::flow::interface11::receiver< input_type > |
tbb::flow::interface11::receiver< T > | Pure virtual template class that defines a receiver of messages of type T
tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) > |
tbb::flow::interface11::broadcast_node< T > | Forwards messages of type T to all successors
tbb::flow::interface11::buffer_node< T, Allocator > | Forwards messages in arbitrary order
tbb::flow::interface11::limiter_node< T, DecrementType > | Forwards messages only if the threshold has not been reached
tbb::flow::interface11::overwrite_node< T > |
tbb::flow::interface11::internal::untyped_sender |
tbb::flow::interface11::sender< Output > |
internal::function_output< Output > | Implements methods for both executable and function nodes that puts Output to its successors
internal::multifunction_output< Output > |
tbb::flow::interface11::continue_node< Output, Policy > | Implements an executable node that supports continue_msg -> Output
tbb::flow::interface11::async_node< Input, Output, Policy, Allocator > | Implements async node
tbb::flow::interface11::input_node< Output > | An executable node that acts as a source, i.e. it has no predecessors
tbb::flow::interface11::source_node< Output > | An executable node that acts as a source, i.e. it has no predecessors
tbb::flow::interface11::sender< T > | Forward declaration section
tbb::flow::interface11::buffer_node< T, __TBB_DEFAULT_NODE_ALLOCATOR(T) > |
tbb::flow::interface11::broadcast_node< T > | Forwards messages of type T to all successors
tbb::flow::interface11::buffer_node< T, Allocator > | Forwards messages in arbitrary order
tbb::flow::interface11::limiter_node< T, DecrementType > | Forwards messages only if the threshold has not been reached
tbb::flow::interface11::overwrite_node< T > |
tbb::interface6::internal::use_allocator< T > |
tbb::interface5::internal::use_element_copy_constructor< typename > |
internal::tagged_msg< TagType, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9 >::variant |
tbb::internal::vector_iterator< Container, Value > | Meets requirements of a forward iterator for STL and a Value for a blocked_range.*‍/
tbb::internal::version_tag_v3 |
tbb::internal::void_t<... > | Std::void_t internal implementation (to avoid GCC < 4.7 "template aliases" absence)
tbb::flow::interface10::graph::wait_functor |
internal::wrap_key_tuple_elements< N, PT, KeyTraits, TypeTuple > |
internal::wrap_key_tuple_elements< 1, PT, KeyTraits, TypeTuple > |
internal::wrap_key_tuple_elements< 2, PT, KeyTraits, TypeTuple > |
internal::wrap_key_tuple_elements< 3, PT, KeyTraits, TypeTuple > |
internal::wrap_key_tuple_elements< 4, PT, KeyTraits, TypeTuple > |
internal::wrap_key_tuple_elements< 5, PT, KeyTraits, TypeTuple > |
streaming_node< tuple< Ports... >, JP, StreamFactory >::wrap_to_async< T, U > |
streaming_node< tuple< Ports... >, JP, StreamFactory >::wrap_to_async< T, std::false_type > |
internal::wrap_tuple_elements< N, PT, TypeTuple > |
internal::wrap_tuple_elements< 1, PT, TypeTuple > |
internal::wrap_tuple_elements< 2, PT, TypeTuple > |
internal::wrap_tuple_elements< 3, PT, TypeTuple > |
internal::wrap_tuple_elements< 4, PT, TypeTuple > |
internal::wrap_tuple_elements< 5, PT, TypeTuple > |
internal::wrap_tuple_elements< N, internal::multifunction_output, TupleType > |
internal::WrapperBase |
internal::Wrapper< T > |
internal::Wrapper< T[N]> |
async_msg |
tbb::flow::interface11::opencl_async_msg< T, Factory > |
opencl_node |
tbb::flow::interface11::opencl_node< tuple< Ports... > > |
tbb::flow::interface11::opencl_node< tuple< Ports... >, JP > |
streaming_node |
tbb::flow::interface11::opencl_node< tuple< Ports... >, JP, Factory > |

Copyright © 2005-2020 Intel Corporation. All Rights Reserved.

Intel, Pentium, Intel Xeon, Itanium, Intel XScale and VTune are registered trademarks or trademarks of Intel Corporation or its subsidiaries in the United States and other countries.

* Other names and brands may be claimed as the property of others.