Classes | |
| class | aligned_space |
| Block of space aligned sufficiently to construct an array T with N elements. More... | |
| struct | atomic |
| Primary template for atomic. More... | |
| struct | atomic< void * > |
| Specialization for atomic<void*>, for sake of not allowing arithmetic or operator->. More... | |
| class | blocked_range |
| A range over which to iterate. More... | |
| class | blocked_range2d |
| A 2-dimensional range that models the Range concept. More... | |
| class | blocked_range3d |
| A 3-dimensional range that models the Range concept. More... | |
| class | cache_aligned_allocator |
| Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5. More... | |
| class | cache_aligned_allocator< void > |
| Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1. More... | |
| class | combinable |
| Thread-local storage with optional reduction. More... | |
| struct | tbb_hash_compare |
| hash_compare that is default argument for concurrent_hash_map More... | |
| class | concurrent_bounded_queue |
| A high-performance thread-safe blocking concurrent bounded queue. More... | |
| class | concurrent_vector |
| Concurrent vector container. More... | |
| class | mutex |
| Wrapper around the platform's native reader-writer lock. More... | |
| class | null_mutex |
| A mutex which does nothing. More... | |
| class | null_rw_mutex |
| A rw mutex which does nothing. More... | |
| class | parallel_do_feeder |
| Class the user supplied algorithm body uses to add new tasks. More... | |
| struct | task_group_context |
| struct | pre_scan_tag |
| Used to indicate that the initial scan is being performed. More... | |
| struct | final_scan_tag |
| Used to indicate that the final scan is being performed. More... | |
| class | parallel_while |
| Parallel iteration over a stream, with optional addition of more work. More... | |
| class | simple_partitioner |
| A simple partitioner. More... | |
| class | auto_partitioner |
| An auto partitioner. More... | |
| class | affinity_partitioner |
| An affinity partitioner. More... | |
| class | filter |
| A stage in a pipeline. More... | |
| class | thread_bound_filter |
| A stage in a pipeline served by a user thread. More... | |
| class | pipeline |
| A processing pipeline that applies filters to items. More... | |
| class | queuing_mutex |
| Queuing mutex with local-only spinning. More... | |
| class | queuing_rw_mutex |
| Queuing reader-writer mutex with local-only spinning. More... | |
| class | recursive_mutex |
| Mutex that allows recursive mutex acquisition. More... | |
| class | scalable_allocator |
| Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5. More... | |
| class | scalable_allocator< void > |
| Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1. More... | |
| class | spin_mutex |
| A lock that occupies a single byte. More... | |
| class | spin_rw_mutex_v3 |
| Fast, unfair, spinning reader-writer lock with backoff and writer-preference. More... | |
| class | task |
| Base class for user-defined tasks. More... | |
| class | empty_task |
| task that does nothing. Useful for synchronization. More... | |
| class | task_list |
| A list of children. More... | |
| class | task_handle |
| class | task_group |
| class | structured_task_group |
| class | task_scheduler_init |
| Class delimiting the scope of task scheduler activity. More... | |
| class | tbb_allocator |
| Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5. More... | |
| class | tbb_allocator< void > |
| Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1. More... | |
| class | zero_allocator |
| Meets "allocator" requirements of ISO C++ Standard, Section 20.1.5. More... | |
| class | zero_allocator< void, Allocator > |
| Analogous to std::allocator<void>, as defined in ISO C++ Standard, Section 20.4.1. More... | |
| class | bad_last_alloc |
| Exception for concurrent containers. More... | |
| class | improper_lock |
| Exception for PPL locks. More... | |
| class | user_abort |
| Exception for user-initiated abort. More... | |
| class | missing_wait |
| Exception for missing wait on structured_task_group. More... | |
| class | invalid_multiple_scheduling |
| Exception for repeated scheduling of the same task_handle. More... | |
| class | tbb_exception |
| Interface to be implemented by all exceptions TBB recognizes and propagates across the threads. More... | |
| class | captured_exception |
| This class is used by TBB to propagate information about unhandled exceptions into the root thread. More... | |
| class | movable_exception |
| Template that can be used to implement exception that transfers arbitrary ExceptionData to the root thread. More... | |
| class | split |
| Dummy type that distinguishes splitting constructor from copy constructor. More... | |
| class | tick_count |
| Absolute timestamp. 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. | |
| template<typename Iterator, typename Body> | |
| void | parallel_do (Iterator first, Iterator last, const Body &body, task_group_context &context) |
| Parallel iteration over a range, with optional addition of more work and user-supplied context. | |
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) |
| Parallel iteration over range with default partitioner. | |
| template<typename Range, typename Body> | |
| void | parallel_for (const Range &range, const Body &body, const simple_partitioner &partitioner) |
| Parallel iteration over range with simple partitioner. | |
| 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. | |
| template<typename Range, typename Body> | |
| void | parallel_for (const Range &range, const Body &body, task_group_context &context) |
| Parallel iteration over range with default partitioner and user-supplied context. | |
| template<typename Range, typename Body> | |
| void | parallel_for (const Range &range, const Body &body, const simple_partitioner &partitioner, task_group_context &context) |
| Parallel iteration over range with simple partitioner and user-supplied context. | |
| template<typename Range, typename Body> | |
| void | parallel_for (const Range &range, const Body &body, const auto_partitioner &partitioner, task_group_context &context) |
| Parallel iteration over range with auto_partitioner and user-supplied context. | |
| template<typename Range, typename Body> | |
| void | parallel_for (const Range &range, const Body &body, affinity_partitioner &partitioner, task_group_context &context) |
| Parallel iteration over range with affinity_partitioner and user-supplied context. | |
parallel_for_each | |
| template<typename InputIterator, typename Function> | |
| void | parallel_for_each (InputIterator first, InputIterator last, const Function &f, task_group_context &context) |
| Calls function f for all items from [first, last) interval using user-supplied context. | |
| template<typename InputIterator, typename Function> | |
| void | parallel_for_each (InputIterator first, InputIterator last, const Function &f) |
| Uses default context. | |
parallel_invoke | |
| template<typename F0, typename F1> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, tbb::task_group_context &context) |
| Executes a list of tasks in parallel and waits for all tasks to complete. | |
| template<typename F0, typename F1, typename F2> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, tbb::task_group_context &context) |
| template<typename F0, typename F1, typename F2, typename F3> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, tbb::task_group_context &context) |
| template<typename F0, typename F1, typename F2, typename F3, typename F4> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, tbb::task_group_context &context) |
| template<typename F0, typename F1, typename F2, typename F3, typename F4, typename F5> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, tbb::task_group_context &context) |
| template<typename F0, typename F1, typename F2, typename F3, typename F4, typename F5, typename F6> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, const F6 &f6, tbb::task_group_context &context) |
| template<typename F0, typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, const F6 &f6, const F7 &f7, tbb::task_group_context &context) |
| template<typename F0, typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7, typename F8> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, const F6 &f6, const F7 &f7, const F8 &f8, tbb::task_group_context &context) |
| template<typename F0, typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7, typename F8, typename F9> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, const F6 &f6, const F7 &f7, const F8 &f8, const F9 &f9, tbb::task_group_context &context) |
| template<typename F0, typename F1> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1) |
| template<typename F0, typename F1, typename F2> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2) |
| template<typename F0, typename F1, typename F2, typename F3> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3) |
| template<typename F0, typename F1, typename F2, typename F3, typename F4> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4) |
| template<typename F0, typename F1, typename F2, typename F3, typename F4, typename F5> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5) |
| template<typename F0, typename F1, typename F2, typename F3, typename F4, typename F5, typename F6> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, const F6 &f6) |
| template<typename F0, typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, const F6 &f6, const F7 &f7) |
| template<typename F0, typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7, typename F8> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, const F6 &f6, const F7 &f7, const F8 &f8) |
| template<typename F0, typename F1, typename F2, typename F3, typename F4, typename F5, typename F6, typename F7, typename F8, typename F9> | |
| void | parallel_invoke (const F0 &f0, const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, const F6 &f6, const F7 &f7, const F8 &f8, const F9 &f9) |
parallel_reduce | |
| See also requirements on Range and parallel_reduce Body. | |
| template<typename Range, typename Body> | |
| void | parallel_reduce (const Range &range, Body &body) |
| Parallel iteration with reduction and default partitioner. | |
| template<typename Range, typename Body> | |
| void | parallel_reduce (const Range &range, Body &body, const simple_partitioner &partitioner) |
| Parallel iteration with reduction and simple_partitioner. | |
| 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 affinity_partitioner. | |
| template<typename Range, typename Body> | |
| void | parallel_reduce (const Range &range, Body &body, const simple_partitioner &partitioner, task_group_context &context) |
| Parallel iteration with reduction, simple partitioner and user-supplied context. | |
| template<typename Range, typename Body> | |
| void | parallel_reduce (const Range &range, Body &body, const auto_partitioner &partitioner, task_group_context &context) |
| Parallel iteration with reduction, auto_partitioner and user-supplied context. | |
| template<typename Range, typename Body> | |
| void | parallel_reduce (const Range &range, Body &body, affinity_partitioner &partitioner, task_group_context &context) |
| Parallel iteration with reduction, affinity_partitioner and user-supplied context. | |
| template<typename Range, typename Value, typename RealBody, typename Reduction> | |
| Value | parallel_reduce (const Range &range, const Value &identity, const RealBody &real_body, const Reduction &reduction) |
| Parallel iteration with reduction and default partitioner. | |
| template<typename Range, typename Value, typename RealBody, typename Reduction> | |
| Value | parallel_reduce (const Range &range, const Value &identity, const RealBody &real_body, const Reduction &reduction, const simple_partitioner &partitioner) |
| Parallel iteration with reduction and simple_partitioner. | |
| template<typename Range, typename Value, typename RealBody, typename Reduction> | |
| Value | parallel_reduce (const Range &range, const Value &identity, const RealBody &real_body, const Reduction &reduction, const auto_partitioner &partitioner) |
| Parallel iteration with reduction and auto_partitioner. | |
| template<typename Range, typename Value, typename RealBody, typename Reduction> | |
| Value | parallel_reduce (const Range &range, const Value &identity, const RealBody &real_body, const Reduction &reduction, affinity_partitioner &partitioner) |
| Parallel iteration with reduction and affinity_partitioner. | |
| template<typename Range, typename Value, typename RealBody, typename Reduction> | |
| Value | parallel_reduce (const Range &range, const Value &identity, const RealBody &real_body, const Reduction &reduction, const simple_partitioner &partitioner, task_group_context &context) |
| Parallel iteration with reduction, simple partitioner and user-supplied context. | |
| template<typename Range, typename Value, typename RealBody, typename Reduction> | |
| Value | parallel_reduce (const Range &range, const Value &identity, const RealBody &real_body, const Reduction &reduction, const auto_partitioner &partitioner, task_group_context &context) |
| Parallel iteration with reduction, auto_partitioner and user-supplied context. | |
| template<typename Range, typename Value, typename RealBody, typename Reduction> | |
| Value | parallel_reduce (const Range &range, const Value &identity, const RealBody &real_body, const Reduction &reduction, affinity_partitioner &partitioner, task_group_context &context) |
| Parallel iteration with reduction, affinity_partitioner and user-supplied context. | |
| template<typename Range, typename Body> | |
| void | parallel_deterministic_reduce (const Range &range, Body &body) |
| Parallel iteration with deterministic reduction and default partitioner. | |
| template<typename Range, typename Body> | |
| void | parallel_deterministic_reduce (const Range &range, Body &body, task_group_context &context) |
| Parallel iteration with deterministic reduction, simple partitioner and user-supplied context. | |
| template<typename Range, typename Value, typename RealBody, typename Reduction> | |
| Value | parallel_deterministic_reduce (const Range &range, const Value &identity, const RealBody &real_body, const Reduction &reduction) |
| Parallel iteration with deterministic reduction and default partitioner. | |
| template<typename Range, typename Value, typename RealBody, typename Reduction> | |
| Value | parallel_deterministic_reduce (const Range &range, const Value &identity, const RealBody &real_body, const Reduction &reduction, task_group_context &context) |
| Parallel iteration with deterministic reduction, simple partitioner and user-supplied context. | |
parallel_scan | |
| See also requirements on Range and parallel_scan Body. | |
| template<typename Range, typename Body> | |
| void | parallel_scan (const Range &range, Body &body) |
| Parallel prefix with default partitioner. | |
| template<typename Range, typename Body> | |
| void | parallel_scan (const Range &range, Body &body, const simple_partitioner &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 std::less<T>. | |
Typedefs | |
| typedef internal::critical_section_v4 | critical_section |
| typedef spin_rw_mutex_v3 | spin_rw_mutex |
| typedef std::size_t | stack_size_type |
| typedef tbb::internal::task_scheduler_observer_v3 | task_scheduler_observer |
Enumerations | |
| enum | memory_semantics { full_fence, acquire, release, relaxed } |
| Specifies memory semantics. More... | |
| enum | ets_key_usage_type { ets_key_per_instance, ets_no_key } |
| enum for selecting between single key and key-per-instance versions | |
| enum | priority_t { priority_normal = internal::priority_stride_v4 * 2, priority_low = priority_normal - internal::priority_stride_v4, priority_high = priority_normal + internal::priority_stride_v4 } |
| enum | task_group_status { not_complete, complete, canceled } |
Functions | |
| __TBB_DECL_ATOMIC (__TBB_LONG_LONG) __TBB_DECL_ATOMIC(unsigned __TBB_LONG_LONG) __TBB_DECL_ATOMIC(long) __TBB_DECL_ATOMIC(unsigned long) __TBB_DECL_ATOMIC_ALT(unsigned | |
| size_t | __TBB_DECL_ATOMIC_ALT (int, ptrdiff_t) __TBB_DECL_ATOMIC(unsigned) __TBB_DECL_ATOMIC(int) __TBB_DECL_ATOMIC(unsigned short) __TBB_DECL_ATOMIC(short) __TBB_DECL_ATOMIC(char) __TBB_DECL_ATOMIC(signed char) __TBB_DECL_ATOMIC(unsigned char) __TBB_DECL_ATOMIC(wchar_t) template< typename T > struct atomic< T * > |
| Specialization for atomic<T*> with arithmetic and operator->. | |
| template<memory_semantics M, typename T> | |
| T | load (const atomic< T > &a) |
| template<memory_semantics M, typename T> | |
| void | store (atomic< T > &a, T value) |
| 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 scalable_allocator< T > &, const scalable_allocator< U > &) |
| template<typename T, typename U> | |
| bool | operator!= (const scalable_allocator< T > &, const scalable_allocator< U > &) |
| bool | is_current_task_group_canceling () |
| template<class F> | |
| task_handle< F > | make_task (const F &f) |
| 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 > &) |
| template<typename T1, template< typename X1 > class B1, typename T2, template< typename X2 > class B2> | |
| bool | operator== (const zero_allocator< T1, B1 > &a, const zero_allocator< T2, B2 > &b) |
| template<typename T1, template< typename X1 > class B1, typename T2, template< typename X2 > class B2> | |
| bool | operator!= (const zero_allocator< T1, B1 > &a, const zero_allocator< T2, B2 > &b) |
| void | atomic_fence () |
| Sequentially consistent full memory fence. | |
| int __TBB_EXPORTED_FUNC | TBB_runtime_interface_version () |
| The function returns the interface version of the TBB shared library being used. | |
| tick_count::interval_t | operator- (const tick_count &t1, const tick_count &t0) |
This header provides basic platform abstraction layer by hooking up appropriate architecture/OS/compiler specific headers from the /include/tbb/machine directory. If a plug-in header does not implement all the required APIs, it must specify the missing ones by setting one or more of the following macros:
__TBB_USE_GENERIC_PART_WORD_CAS __TBB_USE_GENERIC_PART_WORD_FETCH_ADD __TBB_USE_GENERIC_PART_WORD_FETCH_STORE __TBB_USE_GENERIC_FETCH_ADD __TBB_USE_GENERIC_FETCH_STORE __TBB_USE_GENERIC_DWORD_FETCH_ADD __TBB_USE_GENERIC_DWORD_FETCH_STORE __TBB_USE_GENERIC_HALF_FENCED_LOAD_STORE __TBB_USE_GENERIC_FULL_FENCED_LOAD_STORE __TBB_USE_GENERIC_RELAXED_LOAD_STORE __TBB_USE_FETCHSTORE_AS_FULL_FENCED_STORE
In this case tbb_machine.h will add missing functionality based on a minimal set of APIs that are required to be implemented by all plug-n headers as described further. Note that these generic implementations may be sub-optimal for a particular architecture, and thus should be relied upon only after careful evaluation or as the last resort.
Additionally __TBB_64BIT_ATOMICS can be set to 0 on a 32-bit architecture to indicate that the port is not going to support double word atomics. It may also be set to 1 explicitly, though normally this is not necessary as tbb_machine.h will set it automatically.
__TBB_BIG_ENDIAN macro can be defined by the implementation as well. It is used only if the __TBB_USE_GENERIC_PART_WORD_CAS is set. Possible values are:
Prerequisites for each architecture port ---------------------------------------- The following functions and macros have no generic implementation. Therefore they must be implemented in each machine architecture specific header either as a conventional function or as a functional macro.
__TBB_WORDSIZE This is the size of machine word in bytes, i.e. for 32 bit systems it should be defined to 4.
__TBB_Yield() Signals OS that the current thread is willing to relinquish the remainder of its time quantum.
__TBB_full_memory_fence() Must prevent all memory operations from being reordered across it (both by hardware and compiler). All such fences must be totally ordered (or sequentially consistent).
__TBB_machine_cmpswp4( volatile void *ptr, int32_t value, int32_t comparand ) Must be provided if __TBB_USE_FENCED_ATOMICS is not set.
__TBB_machine_cmpswp8( volatile void *ptr, int32_t value, int64_t comparand ) Must be provided for 64-bit architectures if __TBB_USE_FENCED_ATOMICS is not set, and for 32-bit architectures if __TBB_64BIT_ATOMICS is set
__TBB_machine_<op><S><fence>(...), where <op> = {cmpswp, fetchadd, fetchstore} <S> = {1, 2, 4, 8} <fence> = {full_fence, acquire, release, relaxed} Must be provided if __TBB_USE_FENCED_ATOMICS is set.
__TBB_control_consistency_helper() Bridges the memory-semantics gap between architectures providing only implicit C++0x "consume" semantics (like Power Architecture) and those also implicitly obeying control dependencies (like IA-64). It must be used only in conditional code where the condition is itself data-dependent, and will then make subsequent code behave as if the original data dependency were acquired. It needs only a compiler fence where implied by the architecture either specifically (like IA-64) or because generally stronger "acquire" semantics are enforced (like x86). It is always valid, though potentially suboptimal, to replace control with acquire on the load and then remove the helper.
__TBB_acquire_consistency_helper(), __TBB_release_consistency_helper() Must be provided if __TBB_USE_GENERIC_HALF_FENCED_LOAD_STORE is set. Enforce acquire and release semantics in generic implementations of fenced store and load operations. Depending on the particular architecture/compiler combination they may be a hardware fence, a compiler fence, both or nothing.
| int __TBB_EXPORTED_FUNC tbb::TBB_runtime_interface_version | ( | ) |
The function returns the interface version of the TBB shared library being used.
The version it returns is determined at runtime, not at compile/link time. So it can be different than the value of TBB_INTERFACE_VERSION obtained at compile time.