Class List

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Hierarchy
- Class Members

Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 12345]

rml | The namespace rml contains components of low-level memory pool interface
MemPoolPolicy |
tbb | The namespace tbb contains all components of the library
flow |
interface7 |
internal |
successor_cache |
broadcast_cache |
round_robin_cache |
edge_container |
async_gateway | Pure virtual template class that defines interface for async communication
null_type |
continue_msg | An empty class used for messages that mean "I'm done"
sender | Pure virtual template class that defines a sender of messages of type T
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
graph_iterator |
graph | The graph class
graph_node | The base of all graph nodes
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
overwrite_node |
write_once_node |
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, tag_matching > |
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 a async node
interface5 |
internal |
use_element_copy_constructor |
use_element_copy_constructor< T, false > |
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 |
concurrent_priority_queue | Concurrent priority queue
concurrent_unordered_map_traits |
value_compare |
concurrent_unordered_map |
concurrent_unordered_multimap |
concurrent_unordered_set_traits |
concurrent_unordered_set |
concurrent_unordered_multiset |
reader_writer_lock | Writer-preference reader-writer lock with local-only spinning on readers
scoped_lock | The scoped lock pattern for write locks
scoped_lock_read | The scoped lock pattern for read locks
interface6 |
internal |
basic_operation_base |
basic_operation |
basic_handler |
concrete_filter |
aggregator_operation |
aggregator_ext | Aggregator base class and expert interface
aggregator | Basic aggregator interface
concurrent_lru_cache |
enumerable_thread_specific | The enumerable_thread_specific container
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 |
flow_control | Input_filter control to signal end-of-input for parallel_pipeline
filter_t | Class representing a chain of type-safe pipeline filters
runtime_loader | Load TBB at runtime
task_scheduler_observer |
interface7 |
task_arena |
interface9 |
global_control |
internal |
critical_section_v4 |
scoped_lock |
task_handle_task |
task_group_base |
task_scheduler_observer_v3 |
tbb_exception_ptr | Exception container that preserves the exact copy of the original exception
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 |
strict_ppl |
concurrent_queue | A high-performance thread-safe non-blocking concurrent queue
aligned_space | Block of space aligned sufficiently to construct an array T with N elements
atomic | Primary template for atomic
atomic< void * > | Specialization for atomic<void*>, for sake of not allowing arithmetic or operator->
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
tbb_hash_compare | Hash_compare that is default argument for concurrent_hash_map
concurrent_bounded_queue | A high-performance thread-safe blocking concurrent bounded queue
concurrent_vector | Concurrent vector container
vector_iterator |
mutex | Wrapper around the platform's native reader-writer lock
scoped_lock | The scoped locking pattern
null_mutex | A mutex which does nothing
scoped_lock | Represents acquisition of a mutex
null_rw_mutex | A rw mutex which does nothing
scoped_lock | Represents acquisition of a mutex
parallel_do_feeder | Class the user supplied algorithm body uses to add new tasks
task_group_context |
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
filter | A stage in a pipeline
thread_bound_filter | A stage in a pipeline served by a user thread
pipeline | A processing pipeline that applies filters to items
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
recursive_mutex |
scoped_lock | The scoped locking pattern
scalable_allocator | Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5
rebind |
scalable_allocator< void > | Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1
rebind |
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_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
tick_count | Absolute timestamp
interval_t | Relative time interval
__TBB_malloc_proxy_caller |

Copyright © 2005-2015 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.