Namespace List
Here is a list of all namespaces with brief descriptions:

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

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.