Class List
Here are the classes, structs, unions and interfaces with brief descriptions:

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

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

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

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