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