| ►Ninternal | |
| ►Ngraph_policy_namespace | |
| Ckey_matching | Field of type K being used for matching |
| Clightweight | |
| Cqueueing | |
| Crejecting | |
| Creserving | |
| Caligned_pair | |
| ►Calignment_of | |
| Ctest_alignment | |
| Capply_body_task_bypass | A task that calls a node's apply_body_bypass function, passing in an input of type Input |
| Casync_storage | |
| Cbroadcast_cache | A cache of successors that are broadcast to |
| Cclear_element | |
| Cclear_element< 1 > | |
| Ccontinue_input | Implements methods for an executable node that takes continue_msg as input |
| Cconvert_and_call_impl | |
| Cconvert_and_call_impl< A1, Args1... > | |
| Cconvert_and_call_impl<> | |
| Ccount_element | |
| Cdecrementer | |
| Cdecrementer< T, continue_msg, void > | |
| Cdecrementer< T, DecrementType, typename tbb::internal::enable_if< tbb::internal::is_integral< DecrementType >::value, void >::type > | |
| Cdefault_constructed | |
| Cdo_if | |
| Cdo_if< T, false > | |
| Cdo_if< T, true > | |
| Cemit_element | |
| Cemit_element< 1 > | |
| Cempty_body | An empty functor that takes an Input and returns a default constructed Output |
| CERROR_Type_Not_allowed_In_Tagged_Msg_Not_Member_Of_Tuple | |
| Cforward_task_bypass | A task that calls a node's forward_task function |
| Cforwarding_base | |
| Cfunction_body | A functor that takes an Input and generates an Output |
| Cfunction_body_leaf | Leaf for function_body |
| Cfunction_body_leaf< continue_msg, continue_msg, B > | Leaf for function_body specialized for Input and output of continue_msg |
| Cfunction_body_leaf< continue_msg, Output, B > | Leaf for function_body specialized for Input of continue_msg |
| Cfunction_body_leaf< Input, continue_msg, B > | Leaf for function_body specialized for Output of continue_msg |
| Cfunction_input | Implements methods for a function node that takes a type Input as input and sends |
| ►Cfunction_input_base | Input and scheduling for a function node that takes a type Input as input |
| Coperation_type | |
| Cfunction_input_queue | |
| Cfunction_output | Implements methods for both executable and function nodes that puts Output to its successors |
| Chas_policy | |
| Chas_policy< ExpectedPolicy, FirstPolicy, Policies... > | |
| Chas_policy< ExpectedPolicy, Policy< Policies... > > | |
| Chas_policy< ExpectedPolicy, SinglePolicy > | |
| Cindexer_helper | |
| Cindexer_helper< TupleTypes, 1 > | |
| Cindexer_input_port | |
| ►Cindexer_node_base | Indexer_node_base |
| Cindexer_node_base_operation | |
| Cindexer_node_FE | |
| Cindexer_types | |
| Cinit_output_ports | |
| Cinitializer_list_wrapper | |
| Cinput_body | A functor that takes no input and generates a value of type Output |
| Cinput_body_leaf | The leaf for input_body |
| Cinput_types | |
| Cinput_types< 1, InputTuple > | |
| Cinput_types< 10, InputTuple > | |
| Cinput_types< 2, InputTuple > | |
| Cinput_types< 3, InputTuple > | |
| Cinput_types< 4, InputTuple > | |
| Cinput_types< 5, InputTuple > | |
| Cinput_types< 6, InputTuple > | |
| Cinput_types< 7, InputTuple > | |
| Cinput_types< 8, InputTuple > | |
| Cinput_types< 9, InputTuple > | |
| Cis_element_of | |
| Cis_element_of< Q, 0, Tuple > | |
| Cis_port_ref | |
| Cis_port_ref_impl | |
| Cis_port_ref_impl< port_ref_impl< N1, N2 > > | |
| Cis_port_ref_impl< port_ref_impl< N1, N2 >(*)() > | |
| Citem_buffer | |
| Cjoin_base | |
| Cjoin_base< N, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cjoin_helper | |
| Cjoin_helper< 1 > | |
| ►Cjoin_node_base | Join_node_base |
| Cjoin_node_base_operation | |
| Cjoin_node_FE | Join_node_FE : implements input port policy |
| ►Cjoin_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple > | |
| Ckey_matching_FE_operation | |
| Cjoin_node_FE< queueing, InputTuple, OutputTuple > | |
| Cjoin_node_FE< reserving, InputTuple, OutputTuple > | |
| Ckernel_executor_helper | |
| ►Ckernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type > | |
| Crange_mapper | |
| Crange_value | |
| Crange_wrapper | |
| Ckey_from_policy | |
| Ckey_from_policy< key_matching< Key & > > | |
| Ckey_from_policy< key_matching< Key > > | |
| ►Ckey_matching_port | |
| Ckey_matching_port_operation | |
| Ckey_to_count_functor | |
| CKeyTrait | |
| Cmake_sequence | |
| Cmake_sequence< 0, S... > | |
| Cmatching_forwarding_base | |
| Cmultifunction_body | Function_body that takes an Input and a set of output ports |
| Cmultifunction_body_leaf | Leaf for multifunction. OutputSet can be a std::tuple or a vector |
| Cmultifunction_input | Implements methods for a function node that takes a type Input as input |
| Cmultifunction_output | |
| Cnode_cache | A node_cache maintains a std::queue of elements of type T. Each operation is protected by a lock |
| Cnum_arguments | |
| Cnum_arguments< port_ref_impl< N1, N2 > > | |
| Cnum_arguments< port_ref_impl< N1, N2 >(*)()> | |
| Cpick_max | |
| Cpick_one | |
| Cpick_one< false, T1, T2 > | |
| Cpick_one< true, T1, T2 > | |
| Cpick_tuple_max | |
| Cpick_tuple_max< 0, Tuple, Selector > | |
| CPolicy | |
| Cport_ref_impl | |
| Cpredecessor_cache | A cache of predecessors that only supports try_get |
| ►Cqueueing_port | Queueing join_port |
| Cqueueing_port_operation | |
| Creservable_item_buffer | Item_buffer with reservable front-end. NOTE: if reserving, do not |
| Creservable_predecessor_cache | An cache of predecessors that supports requests and reservations |
| ►Creserving_port | The two-phase join port |
| Creserving_port_operation | |
| Cround_robin_cache | A cache of successors that are put in a round-robin fashion |
| Csequence | |
| Csize_of | |
| Csource_body | |
| Csource_body_leaf | The leaf for source_body |
| Csource_task_bypass | A task that calls a node's apply_body_bypass function with no input |
| Cstreaming_device_with_key | |
| ►Cstreaming_node_traits | |
| Casync_msg_type | |
| Csuccessor_cache | An abstract cache of successors |
| Csuccessor_cache< continue_msg, M > | An abstract cache of successors, specialized to continue_msg |
| ►Ctagged_msg | |
| Cvariant | |
| Ctagged_null_type | |
| Ctype_plus_align | Type mimicking std::pair but with trailing fill to ensure each element of an array |
| Ctype_plus_align< T1, T2, 0 > | |
| Ctype_to_key_function_body | |
| Ctype_to_key_function_body< Input, Output & > | |
| Ctype_to_key_function_body_leaf | |
| Ctype_to_key_function_body_leaf< Input, Output &, B > | |
| Cunfolded_indexer_node | |
| Cunfolded_join_node | Unfolded_join_node : passes input_ports_type to join_node_base. We build the input port type |
| Cunfolded_join_node< 2, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cunfolded_join_node< 3, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cunfolded_join_node< 4, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cunfolded_join_node< 5, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cwrap_key_tuple_elements | |
| Cwrap_key_tuple_elements< 1, PT, KeyTraits, TypeTuple > | |
| Cwrap_key_tuple_elements< 2, PT, KeyTraits, TypeTuple > | |
| Cwrap_key_tuple_elements< 3, PT, KeyTraits, TypeTuple > | |
| Cwrap_key_tuple_elements< 4, PT, KeyTraits, TypeTuple > | |
| Cwrap_key_tuple_elements< 5, PT, KeyTraits, TypeTuple > | |
| Cwrap_tuple_elements | |
| Cwrap_tuple_elements< 1, PT, TypeTuple > | |
| Cwrap_tuple_elements< 2, PT, TypeTuple > | |
| Cwrap_tuple_elements< 3, PT, TypeTuple > | |
| Cwrap_tuple_elements< 4, PT, TypeTuple > | |
| Cwrap_tuple_elements< 5, PT, TypeTuple > | |
| ►CWrapper | |
| C_unwind_space | |
| ►CWrapper< T[N]> | |
| C_unwind_class | |
| CWrapperBase | |
| ►Ntbb | The graph class |
| ►Nflow | |
| ►Ninterface10 | |
| ►Cgraph | The graph class |
| Crun_and_put_task | |
| Crun_task | |
| Cspawn_functor | A functor that spawns a task |
| Cwait_functor | |
| ►Ninterface11 | |
| ►Ninternal | |
| ►Ngraph_policy_namespace | |
| Ckey_matching | Field of type K being used for matching |
| Clightweight | |
| Cqueueing | |
| Crejecting | |
| Creserving | |
| Caligned_pair | |
| ►Calignment_of | |
| Ctest_alignment | |
| Capply_body_task_bypass | A task that calls a node's apply_body_bypass function, passing in an input of type Input |
| Casync_body | |
| Casync_body_base | |
| Casync_helpers | |
| Casync_helpers< T, typename std::enable_if< std::is_base_of< async_msg< typename T::async_msg_data_type >, T >::value >::type > | |
| Casync_storage | |
| Cbroadcast_cache | A cache of successors that are broadcast to |
| Cbuffer_element_type | |
| Cclear_element | |
| Cclear_element< 1 > | |
| Ccontinue_input | Implements methods for an executable node that takes continue_msg as input |
| Cconvert_and_call_impl | |
| Cconvert_and_call_impl< A1, Args1... > | |
| Cconvert_and_call_impl<> | |
| Ccount_element | |
| Cdecrementer | |
| Cdecrementer< T, continue_msg, void > | |
| Cdecrementer< T, DecrementType, typename tbb::internal::enable_if< tbb::internal::is_integral< DecrementType >::value, void >::type > | |
| Cdefault_constructed | |
| Cdo_if | |
| Cdo_if< T, false > | |
| Cdo_if< T, true > | |
| Cemit_element | |
| Cemit_element< 1 > | |
| Cempty_body | An empty functor that takes an Input and returns a default constructed Output |
| CERROR_Type_Not_allowed_In_Tagged_Msg_Not_Member_Of_Tuple | |
| Cforward_task_bypass | A task that calls a node's forward_task function |
| Cforwarding_base | |
| Cfunction_body | A functor that takes an Input and generates an Output |
| Cfunction_body_leaf | Leaf for function_body |
| Cfunction_body_leaf< continue_msg, continue_msg, B > | Leaf for function_body specialized for Input and output of continue_msg |
| Cfunction_body_leaf< continue_msg, Output, B > | Leaf for function_body specialized for Input of continue_msg |
| Cfunction_body_leaf< Input, continue_msg, B > | Leaf for function_body specialized for Output of continue_msg |
| Cfunction_input | Implements methods for a function node that takes a type Input as input and sends |
| ►Cfunction_input_base | Input and scheduling for a function node that takes a type Input as input |
| Coperation_type | |
| Cfunction_input_queue | |
| Cfunction_output | Implements methods for both executable and function nodes that puts Output to its successors |
| Cgraph_task_comparator | |
| Chas_policy | |
| Chas_policy< ExpectedPolicy, FirstPolicy, Policies... > | |
| Chas_policy< ExpectedPolicy, Policy< Policies... > > | |
| Chas_policy< ExpectedPolicy, SinglePolicy > | |
| ►Chash_buffer | |
| CDoCleanup | |
| Cindexer_helper | |
| Cindexer_helper< TupleTypes, 1 > | |
| Cindexer_input_port | |
| ►Cindexer_node_base | Indexer_node_base |
| Cindexer_node_base_operation | |
| Cindexer_node_FE | |
| Cindexer_types | |
| Cinit_output_ports | |
| Cinitializer_list_wrapper | |
| Cinput_body | A functor that takes no input and generates a value of type Output |
| Cinput_body_leaf | The leaf for input_body |
| Cinput_types | |
| Cinput_types< 1, InputTuple > | |
| Cinput_types< 10, InputTuple > | |
| Cinput_types< 2, InputTuple > | |
| Cinput_types< 3, InputTuple > | |
| Cinput_types< 4, InputTuple > | |
| Cinput_types< 5, InputTuple > | |
| Cinput_types< 6, InputTuple > | |
| Cinput_types< 7, InputTuple > | |
| Cinput_types< 8, InputTuple > | |
| Cinput_types< 9, InputTuple > | |
| Cis_element_of | |
| Cis_element_of< Q, 0, Tuple > | |
| Cis_port_ref | |
| Cis_port_ref_impl | |
| Cis_port_ref_impl< port_ref_impl< N1, N2 > > | |
| Cis_port_ref_impl< port_ref_impl< N1, N2 >(*)() > | |
| Citem_buffer | |
| Cjoin_base | |
| Cjoin_base< N, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cjoin_helper | |
| Cjoin_helper< 1 > | |
| ►Cjoin_node_base | Join_node_base |
| Cjoin_node_base_operation | |
| Cjoin_node_FE | Join_node_FE : implements input port policy |
| ►Cjoin_node_FE< key_matching< K, KHash >, InputTuple, OutputTuple > | |
| Ckey_matching_FE_operation | |
| Cjoin_node_FE< queueing, InputTuple, OutputTuple > | |
| Cjoin_node_FE< reserving, InputTuple, OutputTuple > | |
| Ckernel_executor_helper | |
| ►Ckernel_executor_helper< StreamFactory, KernelInputTuple, typename tbb::internal::void_t< typename StreamFactory::range_type >::type > | |
| Crange_mapper | |
| Crange_value | |
| Crange_wrapper | |
| Ckey_from_message_body | |
| Ckey_from_message_body< K &, T > | |
| Ckey_from_policy | |
| Ckey_from_policy< key_matching< Key & > > | |
| Ckey_from_policy< key_matching< Key > > | |
| ►Ckey_matching_port | |
| Ckey_matching_port_operation | |
| Ckey_to_count_functor | |
| CKeyTrait | |
| Cmake_sequence | |
| Cmake_sequence< 0, S... > | |
| Cmatching_forwarding_base | |
| Cmultifunction_body | Function_body that takes an Input and a set of output ports |
| Cmultifunction_body_leaf | Leaf for multifunction. OutputSet can be a std::tuple or a vector |
| Cmultifunction_input | Implements methods for a function node that takes a type Input as input |
| Cmultifunction_output | |
| Cnode_cache | A node_cache maintains a std::queue of elements of type T. Each operation is protected by a lock |
| Cnum_arguments | |
| Cnum_arguments< port_ref_impl< N1, N2 > > | |
| Cnum_arguments< port_ref_impl< N1, N2 >(*)()> | |
| Cpick_max | |
| Cpick_one | |
| Cpick_one< false, T1, T2 > | |
| Cpick_one< true, T1, T2 > | |
| Cpick_tuple_max | |
| Cpick_tuple_max< 0, Tuple, Selector > | |
| CPolicy | |
| Cport_ref_impl | |
| Cpredecessor_cache | A cache of predecessors that only supports try_get |
| Cpriority_task_selector | |
| ►Cqueueing_port | Queueing join_port |
| Cqueueing_port_operation | |
| Creservable_item_buffer | Item_buffer with reservable front-end. NOTE: if reserving, do not |
| Creservable_predecessor_cache | An cache of predecessors that supports requests and reservations |
| ►Creserving_port | The two-phase join port |
| Creserving_port_operation | |
| Cround_robin_cache | A cache of successors that are put in a round-robin fashion |
| Csequence | |
| Csize_of | |
| Csource_body | |
| Csource_body_leaf | The leaf for source_body |
| Csource_task_bypass | A task that calls a node's apply_body_bypass function with no input |
| Cstreaming_device_with_key | |
| ►Cstreaming_node_traits | |
| Casync_msg_type | |
| Csuccessor_cache | An abstract cache of successors |
| Csuccessor_cache< continue_msg, M > | An abstract cache of successors, specialized to continue_msg |
| ►Ctagged_msg | |
| Cvariant | |
| Ctagged_null_type | |
| Ctype_plus_align | Type mimicking std::pair but with trailing fill to ensure each element of an array |
| Ctype_plus_align< T1, T2, 0 > | |
| Ctype_to_key_function_body | |
| Ctype_to_key_function_body< Input, Output & > | |
| Ctype_to_key_function_body_leaf | |
| Ctype_to_key_function_body_leaf< Input, Output &, B > | |
| Cunfolded_indexer_node | |
| Cunfolded_join_node | Unfolded_join_node : passes input_ports_type to join_node_base. We build the input port type |
| Cunfolded_join_node< 10, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cunfolded_join_node< 2, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cunfolded_join_node< 3, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cunfolded_join_node< 4, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cunfolded_join_node< 5, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cunfolded_join_node< 6, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cunfolded_join_node< 7, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cunfolded_join_node< 8, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cunfolded_join_node< 9, key_matching_port, OutputTuple, key_matching< K, KHash > > | |
| Cuntyped_receiver | |
| Cuntyped_sender | |
| Cwrap_key_tuple_elements | |
| Cwrap_key_tuple_elements< N, PT, KeyTraits, tbb::flow::tuple< Args... > > | |
| Cwrap_tuple_elements | |
| Cwrap_tuple_elements< N, PT, tbb::flow::tuple< Args... > > | |
| ►CWrapper | |
| C_unwind_space | |
| ►CWrapper< T[N]> | |
| C_unwind_class | |
| CWrapperBase | |
| ►Nopencl_info | |
| Cdefault_device_filter | |
| Cdefault_device_selector | |
| Cdefault_opencl_factory | |
| Casync_msg | |
| ►Casync_node | Implements async node |
| Creceiver_gateway_impl | |
| Ctry_put_functor | |
| Cbroadcast_node | Forwards messages of type T to all successors |
| ►Cbuffer_node | Forwards messages in arbitrary order |
| Cbuffer_operation | |
| Ccallback | |
| Ccallback_base | |
| Ccomposite_node | |
| Ccomposite_node< tbb::flow::tuple< InputTypes... >, tbb::flow::tuple< OutputTypes... > > | |
| Ccomposite_node< tbb::flow::tuple< InputTypes... >, tbb::flow::tuple<> > | |
| Ccomposite_node< tbb::flow::tuple<>, tbb::flow::tuple< OutputTypes... > > | |
| Ccontinue_msg | An empty class used for messages that mean "I'm done" |
| Ccontinue_node | Implements an executable node that supports continue_msg -> Output |
| Ccontinue_receiver | Base class for receivers of completion messages |
| Cfunction_node | Implements a function node that supports Input -> Output |
| Cgraph_iterator | |
| Cgraph_node | The base of all graph nodes |
| Cgraph_proxy | Pure virtual template classes that define interfaces for async communication |
| Cgraph_task | Base class for tasks generated by graph nodes |
| Cindexer_node | |
| Cindexer_node< T0 > | |
| Cindexer_node< T0, T1 > | |
| Cindexer_node< T0, T1, T2 > | |
| Cindexer_node< T0, T1, T2, T3 > | |
| Cindexer_node< T0, T1, T2, T3, T4 > | |
| Cindexer_node< T0, T1, T2, T3, T4, T5 > | |
| Cindexer_node< T0, T1, T2, T3, T4, T5, T6 > | |
| Cindexer_node< T0, T1, T2, T3, T4, T5, T6, T7 > | |
| Cindexer_node< T0, T1, T2, T3, T4, T5, T6, T7, T8 > | |
| Cinput_node | An executable node that acts as a source, i.e. it has no predecessors |
| Cjoin_node | |
| Cjoin_node< OutputTuple, key_matching< K, KHash > > | |
| Cjoin_node< OutputTuple, queueing > | |
| Cjoin_node< OutputTuple, reserving > | |
| Climiter_node | Forwards messages only if the threshold has not been reached |
| Cmultifunction_node | Implements a function node that supports Input -> (set of outputs) |
| Cnull_type | A generic null type |
| Copencl_async_msg | |
| Copencl_buffer | |
| Copencl_buffer_impl | |
| Copencl_device | |
| Copencl_device_list | |
| ►Copencl_factory | |
| Cfinalize_fn | |
| Cfinalize_fn_leaf | |
| Ckernel | |
| Copencl_memory | |
| Copencl_node< tuple< Ports... > > | |
| Copencl_node< tuple< Ports... >, JP > | |
| Copencl_node< tuple< Ports... >, JP, Factory > | |
| ►Copencl_program | |
| Cfile_reader | |
| Copencl_device_filter | |
| Copencl_program_builder | |
| Copencl_range | |
| Copencl_subbuffer | |
| ►Coverwrite_node | |
| Cregister_predecessor_task | Breaks an infinite loop between the node reservation and register_successor call |
| Cpriority_queue_node | Forwards messages in priority order |
| Cqueue_node | Forwards messages in FIFO order |
| Creceiver | Pure virtual template class that defines a receiver of messages of type T |
| Creceiver_gateway | |
| Crun_and_put_task | |
| Csender | Forward declaration section |
| Csequencer_node | Forwards messages in sequence order |
| Csource_node | An executable node that acts as a source, i.e. it has no predecessors |
| Csplit_node | Split_node: accepts a tuple as input, forwards each element of the tuple to its |
| ►Cstreaming_node< tuple< Ports... >, JP, StreamFactory > | |
| ►Cargs_storage | |
| ►Crun_finalize_func | |
| Cfinalize_func | |
| ►Crun_kernel_func | |
| Ckernel_func | |
| Csend_func | |
| Cargs_storage_base | |
| ►Cdevice_selector | |
| Cepoch_desc | |
| Cdevice_selector_base | |
| Cdevice_selector_body | |
| Ckernel_body | |
| Cwrap_to_async | |
| Cwrap_to_async< T, std::false_type > | |
| Cwrite_once_node | |
| ►Ninterface10 | |
| ►Ninternal | |
| Cconcurrent_geometric_level_generator | |
| ►Cconcurrent_skip_list | |
| Cconst_range_type | |
| Cnot_greater_compare | |
| Crange_type | |
| Cskip_list_iterator | |
| Cskip_list_node | |
| ►Ninterface5 | |
| ►Ninternal | |
| ►Cconcurrent_unordered_base | |
| Ccall_internal_clear_on_exit | |
| Cconst_range_type | |
| Crange_type | |
| Cflist_iterator | |
| Chash_compare | |
| ►Chash_map_base | Base class of concurrent_hash_map |
| Cbucket | Bucket type |
| Cenable_segment_failsafe | Exception safety helper |
| Chash_map_iterator | Meets requirements of a forward iterator for STL */ |
| Chash_map_node_base | Node base type |
| Chash_map_range | Range class used with concurrent_hash_map |
| Csolist_iterator | |
| ►Csplit_ordered_list | |
| Cnode | |
| Ctask_base | Base class for methods that became static in TBB 3.0 |
| Cuse_element_copy_constructor | |
| ►Cconcurrent_hash_map | Unordered map from Key to T |
| Caccessor | Allows write access to elements and combines data access, locking, and garbage collection |
| Caccessor_not_used | |
| Cbucket_accessor | Bucket accessor is to find, rehash, acquire a lock, and access a bucket |
| Ccall_clear_on_leave | |
| Cconst_accessor | Combines data access, locking, and garbage collection |
| Cnode | |
| Cnode_scoped_guard | |
| ►Cconcurrent_priority_queue | Concurrent priority queue |
| Ccpq_operation | |
| Cmy_functor_t | |
| Cconcurrent_unordered_map | |
| Cconcurrent_unordered_map_traits | |
| Cconcurrent_unordered_multimap | |
| Cconcurrent_unordered_multiset | |
| Cconcurrent_unordered_set | |
| Cconcurrent_unordered_set_traits | |
| ►Ninterface6 | |
| ►Ninternal | |
| Caggregated_operation | Aggregated_operation base class |
| Caggregating_functor | |
| Caggregator | |
| Caggregator_generic | Aggregator base class |
| Cbasic_handler | |
| Cbasic_operation | |
| Cbasic_operation_base | |
| Cconcrete_filter | |
| Cconcrete_filter< T, void, Body > | |
| Cconcrete_filter< void, U, Body > | |
| Cconcrete_filter< void, void, Body > | |
| Cfilter_node | Abstract base class that represents a node in a parse tree underlying a filter_t |
| Cfilter_node_join | Node in parse tree representing join of two filters |
| Cfilter_node_leaf | Node in parse tree representing result of make_filter |
| Cpipeline_proxy | The class that represents an object of the pipeline for parallel_pipeline() |
| Cpool_base | Base of thread-safe pool allocator for variable-size requests |
| Ctbb_trivially_copyable | |
| Ctbb_trivially_copyable< bool > | |
| Ctbb_trivially_copyable< char > | |
| Ctbb_trivially_copyable< double > | |
| Ctbb_trivially_copyable< float > | |
| Ctbb_trivially_copyable< int > | |
| Ctbb_trivially_copyable< long > | |
| Ctbb_trivially_copyable< long double > | |
| Ctbb_trivially_copyable< long long > | |
| Ctbb_trivially_copyable< short > | |
| Ctbb_trivially_copyable< signed char > | |
| Ctbb_trivially_copyable< T * > | |
| Ctbb_trivially_copyable< unsigned char > | |
| Ctbb_trivially_copyable< unsigned int > | |
| Ctbb_trivially_copyable< unsigned long > | |
| Ctbb_trivially_copyable< unsigned long long > | |
| Ctbb_trivially_copyable< unsigned short > | |
| Ctbb_trivially_copyable< wchar_t > | |
| Ctoken_helper | |
| Ctoken_helper< T *, false > | |
| ►Ctoken_helper< T, false > | |
| Ctype_to_void_ptr_map | |
| Ctoken_helper< T, true > | |
| Cuse_allocator | |
| Caggregator | Basic aggregator interface |
| Caggregator_ext | Aggregator base class and expert interface |
| Caggregator_operation | |
| ►Cconcurrent_lru_cache | |
| Caggregator_operation | |
| Chandle_object | |
| Cmap_value_type | |
| Cretrieve_aggregator_operation | |
| Csignal_end_of_usage_aggregator_operation | |
| ►Cenumerable_thread_specific | The enumerable_thread_specific container |
| Cgeneric_range_type | A generic range, used to create range objects from the iterators |
| Cfilter_t | Class representing a chain of type-safe pipeline filters |
| Cfixed_pool | |
| Cflattened2d | |
| Cflow_control | Input_filter control to signal end-of-input for parallel_pipeline |
| Cmemory_pool | Thread-safe growable pool allocator for variable-size requests |
| ►Cmemory_pool_allocator | Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5 |
| Crebind | |
| ►Cmemory_pool_allocator< void, P > | Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1 |
| Crebind | |
| Cruntime_loader | Load TBB at runtime |
| Ctask_scheduler_observer | |
| ►Ninterface7 | |
| ►Ninternal | |
| Cdelegate_base | |
| Cdelegated_function | |
| Cdelegated_function< F, void > | |
| Cpadded_mutex | |
| ►Cpadded_mutex< Mutex, false > | |
| Cscoped_lock | Represents acquisition of a mutex |
| ►Cpadded_mutex< Mutex, true > | |
| Cscoped_lock | Represents acquisition of a mutex |
| Creturn_type_or_void | |
| Ctask_arena_base | |
| ►Ctask_arena | |
| Cattach | Tag class used to indicate the "attaching" constructor |
| ►Ninterface9 | |
| ►Ninternal | |
| Cadaptive_mode | Provides default splitting strategy for partition objects |
| Caffinity_partition_type | |
| Cauto_partition_type | |
| Cdo_group_task | |
| Cdo_group_task_forward | For internal use only |
| Cdo_group_task_input | |
| Cdo_iteration_task | For internal use only |
| Cdo_iteration_task_iter | |
| Cdo_task_iter | For internal use only |
| Cdynamic_grainsize_mode | |
| Cfinish_deterministic_reduce | Task type used to combine the partial results of parallel_deterministic_reduce |
| Cfinish_reduce | Task type used to combine the partial results of parallel_reduce |
| Cflag_task | Join task node that contains shared flag for stealing feedback |
| Clinear_affinity_mode | Provides default linear indexing of partitioner's sequence |
| Cold_auto_partition_type | Backward-compatible partition for auto and affinity partition objects |
| Cparallel_do_feeder_impl | For internal use only |
| Cparallel_do_operator_selector | For internal use only |
| Cpartition_type_base | Provides default methods for partition objects and common algorithm blocks |
| Cproportion_helper | A helper class to create a proportional_split object for a given type of Range |
| Cproportion_helper< Range, typename enable_if< Range::is_splittable_in_proportion, void >::type > | |
| Cproportional_mode | Provides proportional splitting strategy for partition objects |
| Cquick_sort_body | Body class used to sort elements in a range that is smaller than the grainsize |
| Cquick_sort_pretest_body | Body class used to test if elements in a range are presorted |
| Cquick_sort_range | Range used in quicksort to split elements into subranges based on a value |
| Crange_vector | Range pool stores ranges of type T in a circular buffer with MaxCapacity |
| Csimple_partition_type | |
| Cstart_deterministic_reduce | Task type used to split the work of parallel_deterministic_reduce |
| Cstart_for | Task type used in parallel_for |
| Cstart_reduce | Task type used to split the work of parallel_reduce |
| Cstatic_partition_type | |
| Cglobal_control | |
| Cparallel_do_feeder | Class the user supplied algorithm body uses to add new tasks |
| ►Ninternal | Identifiers declared inside namespace internal should never be used directly by client code |
| ►Nrml | |
| Cpadded_private_worker | |
| Cprivate_server | |
| Cprivate_worker | |
| C__TBB_InitOnce | Class that supports TBB initialization |
| Caffinity_helper | |
| Caffinity_partitioner_base_v3 | Defines entry point for affinity partitioner into TBB run-time library |
| Caligned_storage | |
| Caligned_storage< value_type, 1 > | |
| Callocate_additional_child_of_proxy | |
| Callocate_child_proxy | |
| Callocate_continuation_proxy | |
| Callocate_root_proxy | |
| Callocate_root_with_context_proxy | |
| Callocator_base | |
| Callocator_rebind | |
| ►Callocator_traits | |
| Crebind_alloc | |
| Callocator_type | Class for determining type of std::allocator<T>::value_type |
| Callowed_parallelism_control | |
| Carena | |
| Carena_base | The structure of an arena, except the array of slots |
| Carena_slot | |
| Carena_slot_line1 | |
| Carena_slot_line2 | |
| Catomic_backoff | Class that implements exponential backoff |
| ►Catomic_impl | Base class that provides basic functionality for atomic<T> without fetch_and_add |
| Cconverter | Union type used to convert type T to underlying integral type |
| Cptr_converter | |
| Cptr_converter< value_t * > | |
| Catomic_impl_with_arithmetic | Base class that provides basic functionality for atomic<T> with fetch_and_add |
| Catomic_load_store_traits | |
| Catomic_rep | |
| Catomic_rep< 1 > | |
| Catomic_rep< 2 > | |
| Catomic_rep< 4 > | |
| Catomic_rep< 8 > | |
| Catomic_selector | |
| Catomic_selector< 1 > | |
| Catomic_selector< 2 > | |
| Catomic_selector< 4 > | |
| Catomic_selector< 8 > | |
| Catomic_traits | |
| Cauto_empty_task | Smart holder for the empty task class with automatic destruction |
| Cbasic_tls | Basic cross-platform wrapper class for TLS operations |
| Cbinary_semaphore | Binary_semaphore for concurrent monitor |
| Cbinding_handler | |
| Cblocked_rangeNd_impl | |
| Cbody_arg_detector | |
| Cbody_arg_detector< ReturnType(Callable::*)(T) const > | |
| Cbody_arg_detector< ReturnType(Callable::*)(T)> | |
| Cbool_constant | |
| ►Ccircular_doubly_linked_list_with_sentinel | Circular doubly-linked list with sentinel |
| Cnode_t | |
| Cco_context | |
| ►Cconcurrent_monitor | Concurrent_monitor |
| Cthread_context | |
| ►Cconcurrent_queue_base_v3 | For internal use only |
| Cpadded_page | |
| Cpage | Prefix on a page |
| Cconcurrent_queue_base_v8 | For internal use only |
| Cconcurrent_queue_iterator | Meets requirements of a forward iterator for STL |
| Cconcurrent_queue_iterator_base_v3 | Type-independent portion of concurrent_queue_iterator |
| Cconcurrent_queue_iterator_rep | |
| Cconcurrent_queue_rep | Internal representation of a ConcurrentQueue |
| ►Cconcurrent_vector_base_v3 | Base class of concurrent vector implementation |
| ►Chelper | |
| Cdestroy_body | |
| Cinit_body | TODO: turn into lambda functions when available |
| Csafe_init_body | |
| Csegment_not_used_predicate | |
| Cinternal_segments_table | Internal structure for compact() |
| Csegment_allocated | |
| Csegment_allocation_failed | |
| Csegment_not_used | |
| Csegment_t | |
| Csegment_value_t | |
| Cconditional | |
| Cconditional< true, T, U > | |
| Cconjunction | |
| Cconjunction< First, Args... > | |
| Cconjunction< T > | |
| Cconjunction<> | |
| Ccontext_guard_helper | |
| Ccontext_list_node_t | |
| Ccontrol_storage | |
| Ccoroutine_type | |
| Ccpu_ctl_env | |
| Ccpu_ctl_env_space | |
| ►Ccritical_section_v4 | |
| Cscoped_lock | |
| Ccustom_scheduler | A scheduler with a customized evaluation loop |
| CDefaultSchedulerTraits | Traits classes for scheduler |
| Cenable_if | Enables one or the other code branches |
| Cenable_if< true, T > | |
| Cfast_reverse_vector | Vector that grows without reallocations, and stores items in the reverse order |
| CFastRandom | A fast random number generator |
| Cfgt_internal_input_alias_helper | |
| Cfgt_internal_output_alias_helper | |
| Cfinal_sum | Performs final scan for a leaf |
| Cfinish_scan | Combine partial results |
| Cfunction_invoker | |
| Cfunction_task | |
| Cgeneric_scheduler | Work stealing task scheduler |
| Cgovernor | The class handles access to the single instance of market, and to TLS to keep scheduler instances |
| Chash_map_segment_base | |
| Cindex_sequence | |
| Cinput_buffer | A buffer of input items for a filter |
| Cint_to_type | Utility helper structure to ease overload resolution |
| CIntelSchedulerTraits | |
| Cintrusive_list | Double linked list of items of type T that is derived from intrusive_list_node class |
| ►Cintrusive_list_base | List of element of type T, where T is derived from intrusive_list_node |
| Citerator_impl | |
| Cintrusive_list_node | Data structure to be inherited by the types that can form intrusive lists |
| Cis_integral | |
| Cis_integral_impl | Partial support for std::is_integral |
| Cis_integral_impl< bool > | |
| Cis_integral_impl< char > | |
| Cis_integral_impl< int > | |
| Cis_integral_impl< long > | |
| Cis_integral_impl< long long > | |
| Cis_integral_impl< short > | |
| Cis_integral_impl< wchar_t > | |
| Cis_ref | |
| Cis_ref< U & > | |
| Cis_same_type | Detects whether two given types are the same |
| Cis_same_type< W, W > | |
| Clambda_reduce_body | Auxiliary class for parallel_reduce; for internal use only |
| Clambda_scan_body | |
| Clane_selector_base | |
| Cmachine_load_store | |
| Cmachine_load_store_relaxed | |
| Cmachine_load_store_seq_cst | |
| Cmail_inbox | Class representing source of mail |
| Cmail_outbox | Class representing where mail is put |
| Cmake_index_sequence_impl | |
| Cmake_index_sequence_impl< 0, S... > | |
| Cmarket | |
| Cmemptr_intrusive_list | Double linked list of items of type T containing a member of type intrusive_list_node |
| Cmicro_queue | A queue using simple locking |
| Cmicro_queue_pop_finalizer | |
| Cmutex_copy_deprecated_and_disabled | |
| Cnested_arena_context | |
| Cno_assign | Base class for types that should not be assigned |
| Cno_copy | Base class for types that should not be copied or assigned |
| Cnode_handle | |
| Cnode_handle< Key, Key, Node, Allocator > | |
| Cnode_handle_base | |
| Cpadded | Pads type T to fill out to a multiple of cache line size |
| Cpadded_base | |
| Cpadded_base< T, S, 0 > | |
| Cparallel_for_body | Calls the function with values from range [begin, end) with a step provided |
| Cparallel_for_each_body_do | |
| Cparallel_for_each_body_for | |
| Cparallel_for_each_impl | |
| Cparallel_for_each_impl< Iterator, Function, std::random_access_iterator_tag > | |
| Cparallel_invoke_cleaner | |
| ►Cparallel_invoke_helper | |
| Cparallel_invoke_noop | |
| Cpartition_type_base | Provides backward-compatible methods for partition objects without affinity |
| Cpipeline_cleaner | |
| Cpipeline_root_task | |
| Cplatform_topology | |
| Cpreceding_lane_selector | |
| Cpredicate_leq | |
| Cqueue_and_mutex | Essentially, this is just a pair of a queue and a mutex to protect the queue |
| Crandom_lane_selector | |
| Creverse | |
| Cscheduler | |
| Cscheduler_properties | Bit-field representing properties of a sheduler |
| Cscheduler_state | |
| Cselect_size_t_constant | A template to select either 32-bit or 64-bit constant as compile time, depending on machine word size |
| Csemaphore | Edsger Dijkstra's counting semaphore |
| Cspawner | |
| Cstack_size_control | |
| Cstage_task | |
| Cstart_scan | Initial task to split the work |
| CSTATIC_ASSERTION_FAILED | |
| CSTATIC_ASSERTION_FAILED< false > | |
| Cstored_pack | Allows to store a function parameter pack as a variable and later pass it to another function |
| Cstored_pack< T, Types... > | |
| Cstored_pack<> | |
| Cstrip | Strips its template type argument from cv- and ref-qualifiers |
| Cstrip< const T & > | |
| Cstrip< const T && > | |
| Cstrip< const T > | |
| Cstrip< const T(&)[N]> | |
| Cstrip< const volatile T & > | |
| Cstrip< const volatile T && > | |
| Cstrip< const volatile T > | |
| Cstrip< const volatile T(&)[N]> | |
| Cstrip< T & > | |
| Cstrip< T && > | |
| Cstrip< T(&)()> | Specialization for function pointers |
| Cstrip< T(&)[N]> | Specialization for arrays converts to a corresponding pointer |
| Cstrip< volatile T & > | |
| Cstrip< volatile T && > | |
| Cstrip< volatile T > | |
| Cstrip< volatile T(&)[N]> | |
| Csubsequent_lane_selector | |
| Csum_node | Split work to be done in the scan |
| Csupports_impl | |
| Csupports_impl< T, typename void_t< Checks< T >... >::type, Checks... > | |
| ►Ctask_group_base | |
| Cref_count_guard | |
| Ctask_handle_task | |
| Ctask_info | This structure is used to store task information in a input buffer |
| Ctask_prefix | Memory prefix to a task object |
| Ctask_proxy | |
| Ctask_scheduler_observer_v3 | |
| Ctask_stream | The container for "fairness-oriented" aka "enqueued" tasks |
| Ctask_stream_accessor | |
| Ctask_stream_accessor< back_nonnull_accessor > | |
| Ctask_stream_base | |
| Ctbb_exception_ptr | Exception container that preserves the exact copy of the original exception |
| ►Ctbb_thread_v3 | Versioned thread class |
| Cid | |
| Cthread_closure_0 | |
| Cthread_closure_1 | Structure used to pass user function with 1 argument to thread |
| Cthread_closure_2 | |
| Cthread_closure_base | |
| Ctls | More advanced TLS support template class |
| Ctls< T * > | |
| Ctype_with_alignment | |
| Ctype_with_alignment< 1 > | |
| Ctype_with_alignment< 16 > | |
| Ctype_with_alignment< 2 > | |
| Ctype_with_alignment< 32 > | |
| Ctype_with_alignment< 4 > | |
| Ctype_with_alignment< 64 > | |
| Ctype_with_alignment< 8 > | |
| Cunpadded_mail_outbox | Internal representation of mail_outbox, without padding |
| Cvector_iterator | Meets requirements of a forward iterator for STL and a Value for a blocked_range.*/ |
| Cversion_tag_v3 | |
| Cvoid_t | Std::void_t internal implementation (to avoid GCC < 4.7 "template aliases" absence) |
| Cwhile_group_task | For internal use only |
| Cwhile_iteration_task | For internal use only |
| Cwhile_task | For internal use only |
| ►Nserial | |
| ►Ninterface9 | |
| Cstart_for | |
| ►Nstrict_ppl | For internal use only |
| ►Ninternal | |
| Cconcurrent_queue_base_v3 | Base class of concurrent_queue |
| Cconcurrent_queue_iterator | Meets requirements of a forward iterator for STL |
| Cconcurrent_queue_iterator_base_v3 | Constness-independent portion of concurrent_queue_iterator |
| Cconcurrent_queue_iterator_rep | |
| Cconcurrent_queue_page_allocator | Abstract class to define interface for page allocation/deallocation |
| Cconcurrent_queue_rep | Representation of concurrent_queue_base |
| ►Cconcurrent_queue_rep_base | Parts of concurrent_queue_rep that do not have references to micro_queue |
| Cpage | Prefix on a page |
| ►Cmicro_queue | A queue using simple locking |
| Cdestroyer | Class used to ensure exception-safety of method "pop" |
| Cpadded_page | |
| Cmicro_queue_pop_finalizer | |
| Ctbb_remove_cv | Similar to C++0x std::remove_cv |
| Ctbb_remove_cv< const T > | |
| Ctbb_remove_cv< const volatile T > | |
| Ctbb_remove_cv< volatile T > | |
| Cconcurrent_queue | A high-performance thread-safe non-blocking concurrent queue |
| Caffinity_partitioner | An affinity partitioner |
| Cauto_partitioner | An auto partitioner |
| Cbad_last_alloc | Exception for concurrent containers |
| Cblocked_range | A range over which to iterate |
| Cblocked_range2d | A 2-dimensional range that models the Range concept |
| Cblocked_range3d | A 3-dimensional range that models the Range concept |
| ►Ccache_aligned_allocator | Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5 |
| Crebind | |
| ►Ccache_aligned_allocator< void > | Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1 |
| Crebind | |
| Ccaptured_exception | This class is used by TBB to propagate information about unhandled exceptions into the root thread |
| Ccombinable | Thread-local storage with optional reduction |
| ►Cconcurrent_bounded_queue | A high-performance thread-safe blocking concurrent bounded queue |
| Cdestroyer | Class used to ensure exception-safety of method "pop" |
| ►Cconcurrent_vector | Concurrent vector container |
| Cgeneric_range_type | |
| Cinternal_loop_guide | Exception-aware helper class for filling a segment by exception-danger operators of user class |
| Cis_integer_tag | True/false function override helper |
| ►Cpush_back_helper | |
| Celement_construction_guard | |
| Cempty_task | Task that does nothing. Useful for synchronization |
| Cfilter | A stage in a pipeline |
| Cfinal_scan_tag | Used to indicate that the final scan is being performed |
| Cimproper_lock | Exception for PPL locks |
| Cinvalid_multiple_scheduling | Exception for repeated scheduling of the same task_handle |
| Cmissing_wait | Exception for missing wait on structured_task_group |
| Cmovable_exception | Template that can be used to implement exception that transfers arbitrary ExceptionData to the root thread |
| ►Cnull_mutex | A mutex which does nothing |
| Cscoped_lock | Represents acquisition of a mutex |
| ►Cnull_rw_mutex | A rw mutex which does nothing |
| Cscoped_lock | Represents acquisition of a mutex |
| Cparallel_while | Parallel iteration over a stream, with optional addition of more work |
| Cpre_scan_tag | Used to indicate that the initial scan is being performed |
| Cproportional_split | Type enables transmission of splitting proportion from partitioners to range objects |
| ►Cqueuing_mutex | Queuing mutex with local-only spinning |
| Cscoped_lock | The scoped locking pattern |
| ►Cqueuing_rw_mutex | Queuing reader-writer mutex with local-only spinning |
| Cscoped_lock | The scoped locking pattern |
| ►Csimple_partitioner | A simple partitioner |
| Cpartition_type | |
| ►Cspin_mutex | A lock that occupies a single byte |
| Cscoped_lock | Represents acquisition of a mutex |
| ►Cspin_rw_mutex_v3 | Fast, unfair, spinning reader-writer lock with backoff and writer-preference |
| Cscoped_lock | The scoped locking pattern |
| Csplit | Dummy type that distinguishes splitting constructor from copy constructor |
| Cstatic_partitioner | A static partitioner |
| Cstructured_task_group | |
| Ctask | Base class for user-defined tasks |
| Ctask_group | |
| Ctask_group_context | Used to form groups of tasks |
| Ctask_handle | |
| Ctask_list | A list of children |
| Ctask_scheduler_init | Class delimiting the scope of task scheduler activity |
| ►Ctbb_allocator | Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5 |
| Crebind | |
| ►Ctbb_allocator< void > | Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1 |
| Crebind | |
| Ctbb_exception | Interface to be implemented by all exceptions TBB recognizes and propagates across the threads |
| Ctbb_hash_compare | Hash_compare that is default argument for concurrent_hash_map |
| Cthread_bound_filter | A stage in a pipeline served by a user thread |
| ►Ctick_count | Absolute timestamp |
| Cinterval_t | Relative time interval |
| Ctricky_atomic_pointer | A view of a T* with additional functionality for twiddling low-order bits |
| Cuser_abort | Exception for user-initiated abort |
| ►Czero_allocator | Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5 |
| Crebind | |
| ►Czero_allocator< void, Allocator > | Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1 |
| Crebind | |
| C___itt_api_info | |
| C___itt_api_info_20101001 | |
| C___itt_global | |
| C___itt_group_alias | |
| C___itt_group_list | |
| C___itt_thread_info | |
| C__cilk_tbb_stack_op_thunk | |
| C__cilk_tbb_unwatch_thunk | |
| C__itt_counter_info | |
| C__TBB_malloc_proxy_caller | |
| Casync_msg | |
| Cbuffer_element_type | |
| Cdynamic_link_descriptor | Association between a handler name and location of pointer to it |
| ►Chash_buffer | |
| CDoCleanup | |
| ►Cstreaming_node< tuple< Ports... >, JP, StreamFactory > | |
| ►Cargs_storage | |
| ►Crun_finalize_func | |
| Cfinalize_func | |
| ►Crun_kernel_func | |
| Ckernel_func | |
| Csend_func | |
| Cargs_storage_base | |
| ►Cdevice_selector | |
| Cepoch_desc | |
| Cdevice_selector_base | |
| Cdevice_selector_body | |
| Ckernel_body | |
| Cwrap_to_async | |
| Cwrap_to_async< T, std::false_type > | |