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