Classes | |
class | tbb::aligned_space< T, N > |
Block of space aligned sufficiently to construct an array T with N elements. More... | |
struct | tbb::atomic< T > |
Primary template for atomic. More... | |
struct | tbb::atomic< T * > |
struct | tbb::atomic< void * > |
struct | tbb::atomic< bool > |
class | tbb::blocked_range< Value > |
A range over which to iterate. More... | |
class | tbb::blocked_range2d< RowValue, ColValue > |
A 2-dimensional range that models the Range concept. More... | |
class | tbb::blocked_range3d< PageValue, RowValue, ColValue > |
A 3-dimensional range that models the Range concept. More... | |
class | tbb::cache_aligned_allocator< T > |
Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5 More... | |
struct | tbb::cache_aligned_allocator< T >::rebind< U > |
class | tbb::cache_aligned_allocator< void > |
Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1. More... | |
struct | tbb::cache_aligned_allocator< void >::rebind< U > |
class | tbb::concurrent_hash_map< Key, T, HashCompare, A > |
Unordered map from Key to T. More... | |
class | tbb::concurrent_hash_map< Key, T, HashCompare, A >::const_accessor |
Combines data access, locking, and garbage collection. More... | |
class | tbb::concurrent_hash_map< Key, T, HashCompare, A >::accessor |
Allows write access to elements and combines data access, locking, and garbage collection. More... | |
struct | tbb::concurrent_hash_map< Key, T, HashCompare, A >::node |
Basic unit of storage used in chain. | |
struct | tbb::concurrent_hash_map< Key, T, HashCompare, A >::chain |
A linked-list of nodes. | |
struct | tbb::concurrent_hash_map< Key, T, HashCompare, A >::segment |
Segment of the table. | |
class | tbb::concurrent_queue< T, A > |
A high-performance thread-safe queue. More... | |
class | tbb::concurrent_queue< T, A >::destroyer |
Class used to ensure exception-safety of method "pop". | |
class | tbb::concurrent_vector< T, A > |
Concurrent vector container More... | |
class | tbb::concurrent_vector< T, A >::generic_range_type< I > |
class | tbb::concurrent_vector< T, A >::internal_loop_guide |
Exception-aware helper class for filling a segment by exception-danger operators of user class. | |
class | tbb::mutex |
Wrapper around the platform's native reader-writer lock. More... | |
class | tbb::mutex::scoped_lock |
The scoped locking pattern. More... | |
class | tbb::parallel_do_feeder< Item > |
Class the user supplied algorithm body uses to add new tasks More... | |
struct | tbb::pre_scan_tag |
Used to indicate that the initial scan is being performed. More... | |
struct | tbb::final_scan_tag |
Used to indicate that the final scan is being performed. More... | |
class | tbb::parallel_while< Body > |
Parallel iteration over a stream, with optional addition of more work. More... | |
class | tbb::simple_partitioner |
A simple partitioner More... | |
class | tbb::simple_partitioner::partition_type |
class | tbb::auto_partitioner |
An auto partitioner. More... | |
class | tbb::auto_partitioner::partition_type |
class | tbb::affinity_partitioner |
An affinity partitioner. More... | |
class | tbb::filter |
A stage in a pipeline. More... | |
class | tbb::pipeline |
A processing pipeling that applies filters to items. More... | |
class | tbb::queuing_mutex |
Queuing lock with local-only spinning. More... | |
class | tbb::queuing_mutex::scoped_lock |
The scoped locking pattern. More... | |
class | tbb::queuing_rw_mutex |
Reader-writer lock with local-only spinning. More... | |
class | tbb::queuing_rw_mutex::scoped_lock |
The scoped locking pattern. More... | |
class | tbb::recursive_mutex |
Mutex that allows recursive mutex acquisition. More... | |
class | tbb::recursive_mutex::scoped_lock |
The scoped locking pattern. More... | |
class | tbb::spin_mutex |
A lock that occupies a single byte. More... | |
class | tbb::spin_mutex::scoped_lock |
Represents acquisition of a mutex. More... | |
class | tbb::spin_rw_mutex_v3 |
Fast, unfair, spinning reader-writer lock with backoff and writer-preference. More... | |
class | tbb::spin_rw_mutex_v3::scoped_lock |
The scoped locking pattern. More... | |
class | tbb::task |
Base class for user-defined tasks. More... | |
class | tbb::empty_task |
task that does nothing. Useful for synchronization. More... | |
class | tbb::task_list |
A list of children. More... | |
class | tbb::task_scheduler_init |
Class representing reference to tbb scheduler. More... | |
class | tbb::tbb_allocator< T > |
Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5 More... | |
struct | tbb::tbb_allocator< T >::rebind< U > |
class | tbb::tbb_allocator< void > |
Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1. More... | |
struct | tbb::tbb_allocator< void >::rebind< U > |
class | tbb::bad_last_alloc |
Exception for concurrent containers. More... | |
class | tbb::split |
Dummy type that distinguishes splitting constructor from copy constructor. More... | |
class | tbb::tick_count |
Absolute timestamp. More... | |
class | tbb::tick_count::interval_t |
Relative time interval. More... | |
parallel_do | |
See also requirements on parallel_do Body. * | |
template<typename Iterator, typename Body> | |
void | parallel_do (Iterator first, Iterator last, const Body &body) |
Parallel iteration over a range, with optional addition of more work. | |
parallel_for | |
See also requirements on Range and parallel_for Body. * | |
template<typename Range, typename Body> | |
void | parallel_for (const Range &range, const Body &body, const simple_partitioner &partitioner=simple_partitioner()) |
Parallel iteration over range with simple partitioner, or default partitioner if no partitioner is specified. | |
template<typename Range, typename Body> | |
void | parallel_for (const Range &range, const Body &body, const auto_partitioner &partitioner) |
Parallel iteration over range with auto_partitioner. | |
template<typename Range, typename Body> | |
void | parallel_for (const Range &range, const Body &body, affinity_partitioner &partitioner) |
Parallel iteration over range with affinity_partitioner. | |
parallel_reduce | |
See also requirements on Range and parallel_reduce Body. * | |
template<typename Range, typename Body> | |
void | parallel_reduce (const Range &range, Body &body, const simple_partitioner &partitioner=simple_partitioner()) |
Parallel iteration with reduction and simple_partitioner, or default partitioner if no partitioner is specified. | |
template<typename Range, typename Body> | |
void | parallel_reduce (const Range &range, Body &body, const auto_partitioner &partitioner) |
Parallel iteration with reduction and auto_partitioner. | |
template<typename Range, typename Body> | |
void | parallel_reduce (const Range &range, Body &body, affinity_partitioner &partitioner) |
Parallel iteration with reduction and auto_partitioner. | |
parallel_scan | |
See also requirements on Range and parallel_scan Body. * | |
template<typename Range, typename Body> | |
void | parallel_scan (const Range &range, Body &body, const simple_partitioner &partitioner=simple_partitioner()) |
Parallel prefix with simple_partitioner. | |
template<typename Range, typename Body> | |
void | parallel_scan (const Range &range, Body &body, const auto_partitioner &partitioner) |
Parallel prefix with auto_partitioner. | |
parallel_sort | |
See also requirements on iterators for parallel_sort. * | |
template<typename RandomAccessIterator, typename Compare> | |
void | parallel_sort (RandomAccessIterator begin, RandomAccessIterator end, const Compare &comp) |
Sorts the data in [begin,end) using the given comparator. | |
template<typename RandomAccessIterator> | |
void | parallel_sort (RandomAccessIterator begin, RandomAccessIterator end) |
Sorts the data in [begin,end) with a default comparator std::less<RandomAccessIterator> . | |
template<typename T> | |
void | parallel_sort (T *begin, T *end) |
Sorts the data in the range [begin,end) with a default comparator std::less<T> . | |
Typedefs | |
typedef spin_rw_mutex_v3 | spin_rw_mutex |
typedef std::size_t | stack_size_type |
typedef internal::task_scheduler_observer_v3 | task_scheduler_observer |
typedef void(* | assertion_handler_type )(const char *filename, int line, const char *expression, const char *comment) |
Type for an assertion handler. | |
typedef internal::tbb_thread_v3 | tbb_thread |
Users reference thread class by name tbb_thread. | |
Enumerations | |
enum | memory_semantics { __TBB_full_fence, acquire, release } |
Specifies memory fencing. More... | |
Functions | |
template<typename T, typename U> | |
bool | operator== (const cache_aligned_allocator< T > &, const cache_aligned_allocator< U > &) |
template<typename T, typename U> | |
bool | operator!= (const cache_aligned_allocator< T > &, const cache_aligned_allocator< U > &) |
template<typename Key, typename T, typename HashCompare, typename A1, typename A2> | |
bool | operator== (const concurrent_hash_map< Key, T, HashCompare, A1 > &a, const concurrent_hash_map< Key, T, HashCompare, A2 > &b) |
template<typename Key, typename T, typename HashCompare, typename A1, typename A2> | |
bool | operator!= (const concurrent_hash_map< Key, T, HashCompare, A1 > &a, const concurrent_hash_map< Key, T, HashCompare, A2 > &b) |
template<typename Key, typename T, typename HashCompare, typename A> | |
void | swap (concurrent_hash_map< Key, T, HashCompare, A > &a, concurrent_hash_map< Key, T, HashCompare, A > &b) |
template<typename T, class A1, class A2> | |
bool | operator== (const concurrent_vector< T, A1 > &a, const concurrent_vector< T, A2 > &b) |
template<typename T, class A1, class A2> | |
bool | operator!= (const concurrent_vector< T, A1 > &a, const concurrent_vector< T, A2 > &b) |
template<typename T, class A1, class A2> | |
bool | operator< (const concurrent_vector< T, A1 > &a, const concurrent_vector< T, A2 > &b) |
template<typename T, class A1, class A2> | |
bool | operator> (const concurrent_vector< T, A1 > &a, const concurrent_vector< T, A2 > &b) |
template<typename T, class A1, class A2> | |
bool | operator<= (const concurrent_vector< T, A1 > &a, const concurrent_vector< T, A2 > &b) |
template<typename T, class A1, class A2> | |
bool | operator>= (const concurrent_vector< T, A1 > &a, const concurrent_vector< T, A2 > &b) |
template<typename T, class A> | |
void | swap (concurrent_vector< T, A > &a, concurrent_vector< T, A > &b) |
template<typename T, typename U> | |
bool | operator== (const tbb_allocator< T > &, const tbb_allocator< U > &) |
template<typename T, typename U> | |
bool | operator!= (const tbb_allocator< T > &, const tbb_allocator< U > &) |
void | swap (internal::tbb_thread_v3 &t1, internal::tbb_thread_v3 &t2) |
void | move (tbb_thread &t1, tbb_thread &t2) |
tick_count::interval_t | operator- (const tick_count &t1, const tick_count &t0) |
|
Specifies memory fencing.
|