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 lock with local-only spinning. More... | |
| class | queuing_rw_mutex |
| Reader-writer lock 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, 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 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. | |
Enumerations | |
| enum | memory_semantics { full_fence, acquire, release, relaxed } |
| Specifies memory fencing. 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. | |
| assertion_handler_type __TBB_EXPORTED_FUNC | set_assertion_handler (assertion_handler_type new_handler) |
| Set assertion handler and return previous value of it. | |
| void __TBB_EXPORTED_FUNC | assertion_failure (const char *filename, int line, const char *expression, const char *comment) |
| Process an assertion failure. | |
| 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 futher. 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.
Prerequisites for each architecture port ---------------------------------------- The following functions 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_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 Itanium). 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 an empty definition where implied by the architecture either specifically (Itanium) or because generally stronger C++0x "acquire" semantics are enforced (like x86).
__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.
| void __TBB_EXPORTED_FUNC tbb::assertion_failure | ( | const char * | filename, | |
| int | line, | |||
| const char * | expression, | |||
| const char * | comment | |||
| ) |
Process an assertion failure.
Normally called from __TBB_ASSERT macro. If assertion handler is null, print message for assertion failure and abort. Otherwise call the assertion handler.
| 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.