tbb::internal::concurrent_monitor Class Reference

concurrent_monitor More...

`#include <concurrent_monitor.h>`

Inheritance diagram for tbb::internal::concurrent_monitor:
Collaboration diagram for tbb::internal::concurrent_monitor:

## Classes

class | thread_context

## Public Member Functions

| concurrent_monitor ()
| ctor More...
| ~concurrent_monitor ()
| dtor More...
void | prepare_wait (thread_context &thr, uintptr_t ctx=0)
| prepare wait by inserting 'thr' into the wait queue More...
bool | commit_wait (thread_context &thr)
| Commit wait if event count has not changed; otherwise, cancel wait. More...
void | cancel_wait (thread_context &thr)
| Cancel the wait. Removes the thread from the wait queue if not removed yet. More...
template<typename WaitUntil , typename Context >
void | wait (WaitUntil until, Context on)
| Wait for a condition to be satisfied with waiting-on context. More...
void | notify_one ()
| Notify one thread about the event. More...
void | notify_one_relaxed ()
| Notify one thread about the event. Relaxed version. More...
void | notify_all ()
| Notify all waiting threads of the event. More...
void | notify_all_relaxed ()
| Notify all waiting threads of the event; Relaxed version. More...
template<typename P >
void | notify (const P &predicate)
| Notify waiting threads of the event that satisfies the given predicate. More...
template<typename P >
void | notify_relaxed (const P &predicate)
| Notify waiting threads of the event that satisfies the given predicate; Relaxed version. More...
void | abort_all ()
| Abort any sleeping threads at the time of the call. More...
void | abort_all_relaxed ()
| Abort any sleeping threads at the time of the call; Relaxed version. More...

## Private Member Functions

thread_context * | to_thread_context (waitset_node_t *n)
Private Member Functions inherited from tbb::internal::no_copy
| no_copy (const no_copy &)=delete
| no_copy ()=default

## Private Attributes

tbb::spin_mutex | mutex_ec
waitset_t | waitset_ec
__TBB_atomic unsigned | epoch

## Detailed Description

concurrent_monitor

fine-grained concurrent_monitor implementation

Definition at line 93 of file concurrent_monitor.h.

## Constructor & Destructor Documentation

## concurrent_monitor()

tbb::internal::concurrent_monitor::concurrent_monitor | ( |  | ) |

inline

ctor

Definition at line 125 of file concurrent_monitor.h.

{__TBB_store_relaxed(epoch, 0);}

References tbb::internal::__TBB_store_relaxed(), and epoch.

Here is the call graph for this function:

## ~concurrent_monitor()

tbb::internal::concurrent_monitor::~concurrent_monitor | ( |  | ) |

dtor

Definition at line 27 of file concurrent_monitor.cpp.

{
abort_all();
__TBB_ASSERT( waitset_ec.empty(), "waitset not empty?" );
}

References __TBB_ASSERT, abort_all(), tbb::internal::circular_doubly_linked_list_with_sentinel::empty(), and waitset_ec.

Here is the call graph for this function:

## Member Function Documentation

## abort_all()

void tbb::internal::concurrent_monitor::abort_all | ( |  | ) |

inline

Abort any sleeping threads at the time of the call.

Definition at line 175 of file concurrent_monitor.h.

{atomic_fence(); abort_all_relaxed(); }

References abort_all_relaxed(), and tbb::atomic_fence().

Referenced by tbb::internal::concurrent_queue_base_v3::internal_abort(), and ~concurrent_monitor().

Here is the call graph for this function:
Here is the caller graph for this function:

## abort_all_relaxed()

void tbb::internal::concurrent_monitor::abort_all_relaxed | ( |  | ) |

Abort any sleeping threads at the time of the call; Relaxed version.

Definition at line 107 of file concurrent_monitor.cpp.

{
if( waitset_ec.empty() )
return;
waitset_t temp;
const waitset_node_t* end;
{
tbb::spin_mutex::scoped_lock l( mutex_ec );
__TBB_store_relaxed( epoch, __TBB_load_relaxed(epoch) + 1 );
waitset_ec.flush_to( temp );
end = temp.end();
for( waitset_node_t* n=temp.front(); n!=end; n=n->next )
to_thread_context(n)->in_waitset = false;
}
waitset_node_t* nxt;
for( waitset_node_t* n=temp.front(); n!=end; n=nxt ) {
nxt = n->next;
to_thread_context(n)->aborted = true;
to_thread_context(n)->semaphore().V();
}
#if TBB_USE_ASSERT
temp.clear();
#endif
}

References tbb::internal::__TBB_load_relaxed(), tbb::internal::__TBB_store_relaxed(), tbb::internal::concurrent_monitor::thread_context::aborted, tbb::internal::circular_doubly_linked_list_with_sentinel::clear(), tbb::internal::circular_doubly_linked_list_with_sentinel::empty(), tbb::internal::circular_doubly_linked_list_with_sentinel::end(), end, epoch, tbb::internal::circular_doubly_linked_list_with_sentinel::flush_to(), tbb::internal::circular_doubly_linked_list_with_sentinel::front(), tbb::internal::concurrent_monitor::thread_context::in_waitset, mutex_ec, tbb::internal::circular_doubly_linked_list_with_sentinel::node_t::next, tbb::internal::concurrent_monitor::thread_context::semaphore(), to_thread_context(), tbb::internal::binary_semaphore::V(), and waitset_ec.

Referenced by abort_all().

Here is the call graph for this function:
Here is the caller graph for this function:

## cancel_wait()

void tbb::internal::concurrent_monitor::cancel_wait | ( | thread_context & | thr | ) |

Cancel the wait. Removes the thread from the wait queue if not removed yet.

Definition at line 50 of file concurrent_monitor.cpp.

{
// possible skipped wakeup will be pumped in the following prepare_wait()
thr.skipped_wakeup = true;
// try to remove node from waitset
bool th_in_waitset = thr.in_waitset;
if( th_in_waitset ) {
tbb::spin_mutex::scoped_lock l( mutex_ec );
if (thr.in_waitset) {
waitset_ec.remove( (waitset_t::node_t&)thr );
// node is removed from waitset, so there will be no wakeup
thr.in_waitset = false;
thr.skipped_wakeup = false;
}
}
}

References tbb::internal::concurrent_monitor::thread_context::in_waitset, mutex_ec, tbb::internal::circular_doubly_linked_list_with_sentinel::remove(), tbb::internal::concurrent_monitor::thread_context::skipped_wakeup, and waitset_ec.

Referenced by commit_wait(), tbb::internal::concurrent_queue_base_v3::internal_insert_item(), tbb::internal::concurrent_queue_base_v3::internal_pop(), and wait().

Here is the call graph for this function:
Here is the caller graph for this function:

## commit_wait()

bool tbb::internal::concurrent_monitor::commit_wait | ( | thread_context & | thr | ) |

inline

Commit wait if event count has not changed; otherwise, cancel wait.

Returns true if committed, false if canceled.

Definition at line 135 of file concurrent_monitor.h.

{
const bool do_it = thr.epoch == __TBB_load_relaxed(epoch);
// this check is just an optimization
if( do_it ) {
__TBB_ASSERT( thr.ready, "use of commit_wait() without prior prepare_wait()");
thr.semaphore().P();
__TBB_ASSERT( !thr.in_waitset, "still in the queue?" );
if( thr.aborted )
throw_exception( eid_user_abort );
} else {
cancel_wait( thr );
}
return do_it;
}

References __TBB_ASSERT, tbb::internal::__TBB_load_relaxed(), tbb::internal::concurrent_monitor::thread_context::aborted, cancel_wait(), tbb::internal::eid_user_abort, tbb::internal::concurrent_monitor::thread_context::epoch, epoch, tbb::internal::concurrent_monitor::thread_context::in_waitset, tbb::internal::binary_semaphore::P(), tbb::internal::concurrent_monitor::thread_context::ready, tbb::internal::concurrent_monitor::thread_context::semaphore(), and tbb::internal::throw_exception().

Referenced by tbb::internal::concurrent_queue_base_v3::internal_insert_item(), tbb::internal::concurrent_queue_base_v3::internal_pop(), and wait().

Here is the call graph for this function:
Here is the caller graph for this function:

## notify()

template<typename P >

void tbb::internal::concurrent_monitor::notify | ( | const P & | predicate | ) |

inline

Notify waiting threads of the event that satisfies the given predicate.

Definition at line 169 of file concurrent_monitor.h.

{atomic_fence(); notify_relaxed( predicate );}

References tbb::atomic_fence(), and notify_relaxed().

Referenced by tbb::internal::concurrent_queue_base_v3::internal_insert_if_not_full(), tbb::internal::concurrent_queue_base_v3::internal_insert_item(), tbb::internal::concurrent_queue_base_v3::internal_pop(), and tbb::internal::concurrent_queue_base_v3::internal_pop_if_present().

Here is the call graph for this function:
Here is the caller graph for this function:

## notify_all()

void tbb::internal::concurrent_monitor::notify_all | ( |  | ) |

inline

Notify all waiting threads of the event.

Definition at line 163 of file concurrent_monitor.h.

{atomic_fence(); notify_all_relaxed();}

References tbb::atomic_fence(), and notify_all_relaxed().

Here is the call graph for this function:

## notify_all_relaxed()

void tbb::internal::concurrent_monitor::notify_all_relaxed | ( |  | ) |

Notify all waiting threads of the event; Relaxed version.

Definition at line 84 of file concurrent_monitor.cpp.

{
if( waitset_ec.empty() )
return;
waitset_t temp;
const waitset_node_t* end;
{
tbb::spin_mutex::scoped_lock l( mutex_ec );
__TBB_store_relaxed( epoch, __TBB_load_relaxed(epoch) + 1 );
waitset_ec.flush_to( temp );
end = temp.end();
for( waitset_node_t* n=temp.front(); n!=end; n=n->next )
to_thread_context(n)->in_waitset = false;
}
waitset_node_t* nxt;
for( waitset_node_t* n=temp.front(); n!=end; n=nxt ) {
nxt = n->next;
to_thread_context(n)->semaphore().V();
}
#if TBB_USE_ASSERT
temp.clear();
#endif
}

References tbb::internal::__TBB_load_relaxed(), tbb::internal::__TBB_store_relaxed(), tbb::internal::circular_doubly_linked_list_with_sentinel::clear(), tbb::internal::circular_doubly_linked_list_with_sentinel::empty(), tbb::internal::circular_doubly_linked_list_with_sentinel::end(), end, epoch, tbb::internal::circular_doubly_linked_list_with_sentinel::flush_to(), tbb::internal::circular_doubly_linked_list_with_sentinel::front(), tbb::internal::concurrent_monitor::thread_context::in_waitset, mutex_ec, tbb::internal::circular_doubly_linked_list_with_sentinel::node_t::next, tbb::internal::concurrent_monitor::thread_context::semaphore(), to_thread_context(), tbb::internal::binary_semaphore::V(), and waitset_ec.

Referenced by notify_all().

Here is the call graph for this function:
Here is the caller graph for this function:

## notify_one()

void tbb::internal::concurrent_monitor::notify_one | ( |  | ) |

inline

Notify one thread about the event.

Definition at line 157 of file concurrent_monitor.h.

{atomic_fence(); notify_one_relaxed();}

References tbb::atomic_fence(), and notify_one_relaxed().

Referenced by tbb::internal::generic_scheduler::nested_arena_exit().

Here is the call graph for this function:
Here is the caller graph for this function:

## notify_one_relaxed()

void tbb::internal::concurrent_monitor::notify_one_relaxed | ( |  | ) |

Notify one thread about the event. Relaxed version.

Definition at line 66 of file concurrent_monitor.cpp.

{
if( waitset_ec.empty() )
return;
waitset_node_t* n;
const waitset_node_t* end = waitset_ec.end();
{
tbb::spin_mutex::scoped_lock l( mutex_ec );
__TBB_store_relaxed( epoch, __TBB_load_relaxed(epoch) + 1 );
n = waitset_ec.front();
if( n!=end ) {
waitset_ec.remove( *n );
to_thread_context(n)->in_waitset = false;
}
}
if( n!=end )
to_thread_context(n)->semaphore().V();
}

References tbb::internal::__TBB_load_relaxed(), tbb::internal::__TBB_store_relaxed(), tbb::internal::circular_doubly_linked_list_with_sentinel::empty(), tbb::internal::circular_doubly_linked_list_with_sentinel::end(), end, epoch, tbb::internal::circular_doubly_linked_list_with_sentinel::front(), tbb::internal::concurrent_monitor::thread_context::in_waitset, mutex_ec, tbb::internal::circular_doubly_linked_list_with_sentinel::remove(), tbb::internal::concurrent_monitor::thread_context::semaphore(), to_thread_context(), tbb::internal::binary_semaphore::V(), and waitset_ec.

Referenced by notify_one().

Here is the call graph for this function:
Here is the caller graph for this function:

## notify_relaxed()

template<typename P >

void tbb::internal::concurrent_monitor::notify_relaxed | ( | const P & | predicate | ) |

Notify waiting threads of the event that satisfies the given predicate; Relaxed version.

Definition at line 204 of file concurrent_monitor.h.

{
if( waitset_ec.empty() )
return;
waitset_t temp;
waitset_node_t* nxt;
const waitset_node_t* end = waitset_ec.end();
{
tbb::spin_mutex::scoped_lock l( mutex_ec );
__TBB_store_relaxed(epoch, __TBB_load_relaxed(epoch) + 1);
for( waitset_node_t* n=waitset_ec.last(); n!=end; n=nxt ) {
nxt = n->prev;
thread_context* thr = to_thread_context( n );
if( predicate( thr->context ) ) {
waitset_ec.remove( *n );
thr->in_waitset = false;
temp.add( n );
}
}
}
end = temp.end();
for( waitset_node_t* n=temp.front(); n!=end; n=nxt ) {
nxt = n->next;
to_thread_context(n)->semaphore().V();
}
#if TBB_USE_ASSERT
temp.clear();
#endif
}

References tbb::internal::__TBB_load_relaxed(), tbb::internal::__TBB_store_relaxed(), tbb::internal::circular_doubly_linked_list_with_sentinel::add(), tbb::internal::circular_doubly_linked_list_with_sentinel::clear(), tbb::internal::concurrent_monitor::thread_context::context, tbb::internal::circular_doubly_linked_list_with_sentinel::empty(), tbb::internal::circular_doubly_linked_list_with_sentinel::end(), end, epoch, tbb::internal::circular_doubly_linked_list_with_sentinel::front(), tbb::internal::concurrent_monitor::thread_context::in_waitset, tbb::internal::circular_doubly_linked_list_with_sentinel::last(), mutex_ec, tbb::internal::circular_doubly_linked_list_with_sentinel::node_t::next, tbb::internal::circular_doubly_linked_list_with_sentinel::node_t::prev, tbb::internal::circular_doubly_linked_list_with_sentinel::remove(), tbb::internal::concurrent_monitor::thread_context::semaphore(), to_thread_context(), tbb::internal::binary_semaphore::V(), and waitset_ec.

Referenced by notify().

Here is the call graph for this function:
Here is the caller graph for this function:

## prepare_wait()

void tbb::internal::concurrent_monitor::prepare_wait | ( | thread_context & | thr,
|  | uintptr_t | ctx = `0`
| ) |  |

prepare wait by inserting 'thr' into the wait queue

Definition at line 32 of file concurrent_monitor.cpp.

{
if( !thr.ready )
thr.init();
// this is good place to pump previous skipped wakeup
else if( thr.skipped_wakeup ) {
thr.skipped_wakeup = false;
thr.semaphore().P();
}
thr.context = ctx;
thr.in_waitset = true;
{
tbb::spin_mutex::scoped_lock l( mutex_ec );
__TBB_store_relaxed( thr.epoch, __TBB_load_relaxed(epoch) );
waitset_ec.add( (waitset_t::node_t*)&thr );
}
atomic_fence();
}

References tbb::internal::__TBB_load_relaxed(), tbb::internal::__TBB_store_relaxed(), tbb::internal::circular_doubly_linked_list_with_sentinel::add(), tbb::atomic_fence(), tbb::internal::concurrent_monitor::thread_context::context, tbb::internal::concurrent_monitor::thread_context::epoch, epoch, tbb::internal::concurrent_monitor::thread_context::in_waitset, mutex_ec, tbb::internal::binary_semaphore::P(), tbb::internal::concurrent_monitor::thread_context::ready, tbb::internal::concurrent_monitor::thread_context::semaphore(), tbb::internal::concurrent_monitor::thread_context::skipped_wakeup, and waitset_ec.

Referenced by tbb::internal::concurrent_queue_base_v3::internal_insert_item(), tbb::internal::concurrent_queue_base_v3::internal_pop(), and wait().

Here is the call graph for this function:
Here is the caller graph for this function:

## to_thread_context()

thread_context* tbb::internal::concurrent_monitor::to_thread_context | ( | waitset_node_t * | n | ) |

inline private

Definition at line 184 of file concurrent_monitor.h.

{ return static_cast<thread_context*>(n); }

Referenced by abort_all_relaxed(), notify_all_relaxed(), notify_one_relaxed(), and notify_relaxed().

Here is the caller graph for this function:

## wait()

template<typename WaitUntil , typename Context >

void tbb::internal::concurrent_monitor::wait | ( | WaitUntil | until,
|  | Context | on
| ) |  |

Wait for a condition to be satisfied with waiting-on context.

Definition at line 188 of file concurrent_monitor.h.

{
bool slept = false;
thread_context thr_ctx;
prepare_wait( thr_ctx, on() );
while( !until() ) {
if( (slept = commit_wait( thr_ctx ) )==true )
if( until() ) break;
slept = false;
prepare_wait( thr_ctx, on() );
}
if( !slept )
cancel_wait( thr_ctx );
}

References cancel_wait(), commit_wait(), and prepare_wait().

Here is the call graph for this function:

## Member Data Documentation

## epoch

__TBB_atomic unsigned tbb::internal::concurrent_monitor::epoch

private

Definition at line 183 of file concurrent_monitor.h.

Referenced by abort_all_relaxed(), commit_wait(), concurrent_monitor(), notify_all_relaxed(), notify_one_relaxed(), notify_relaxed(), and prepare_wait().

## mutex_ec

tbb::spin_mutex tbb::internal::concurrent_monitor::mutex_ec

private

Definition at line 181 of file concurrent_monitor.h.

Referenced by abort_all_relaxed(), cancel_wait(), notify_all_relaxed(), notify_one_relaxed(), notify_relaxed(), and prepare_wait().

## waitset_ec

waitset_t tbb::internal::concurrent_monitor::waitset_ec

private

Definition at line 182 of file concurrent_monitor.h.

Referenced by abort_all_relaxed(), cancel_wait(), notify_all_relaxed(), notify_one_relaxed(), notify_relaxed(), prepare_wait(), and ~concurrent_monitor().

The documentation for this class was generated from the following files:

- concurrent_monitor.h
- concurrent_monitor.cpp

tbb::internal::concurrent_monitor::cancel_wait
void cancel_wait(thread_context &thr)
Cancel the wait. Removes the thread from the wait queue if not removed yet.
Definition: concurrent_monitor.cpp:50
tbb::internal::concurrent_monitor::notify_relaxed
void notify_relaxed(const P &predicate)
Notify waiting threads of the event that satisfies the given predicate; Relaxed version.
Definition: concurrent_monitor.h:204
end
void const char const char int ITT_FORMAT __itt_group_sync x void const char ITT_FORMAT __itt_group_sync s void ITT_FORMAT __itt_group_sync p void ITT_FORMAT p void ITT_FORMAT p no args __itt_suppress_mode_t unsigned int void size_t ITT_FORMAT d void ITT_FORMAT p void ITT_FORMAT p __itt_model_site __itt_model_site_instance ITT_FORMAT p __itt_model_task __itt_model_task_instance ITT_FORMAT p void ITT_FORMAT p void ITT_FORMAT p void size_t ITT_FORMAT d void ITT_FORMAT p const wchar_t ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s const char ITT_FORMAT s no args void ITT_FORMAT p size_t ITT_FORMAT d no args const wchar_t const wchar_t ITT_FORMAT s __itt_heap_function void size_t int ITT_FORMAT d __itt_heap_function void ITT_FORMAT p __itt_heap_function void void size_t int ITT_FORMAT d no args no args unsigned int ITT_FORMAT u const __itt_domain __itt_id ITT_FORMAT lu const __itt_domain __itt_id __itt_id __itt_string_handle ITT_FORMAT p const __itt_domain __itt_id ITT_FORMAT p const __itt_domain __itt_id __itt_timestamp __itt_timestamp end
Definition: ittnotify_static.h:182
__TBB_ASSERT
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
Definition: tbb_stddef.h:165
tbb::internal::concurrent_monitor::thread_context::aborted
bool aborted
Definition: concurrent_monitor.h:119
tbb::internal::concurrent_monitor::abort_all
void abort_all()
Abort any sleeping threads at the time of the call.
Definition: concurrent_monitor.h:175
tbb::internal::throw_exception
void throw_exception(exception_id eid)
Versionless convenience wrapper for throw_exception_v4()
Definition: tbb_exception.h:105
tbb::internal::concurrent_monitor::to_thread_context
thread_context * to_thread_context(waitset_node_t *n)
Definition: concurrent_monitor.h:184
tbb::internal::circular_doubly_linked_list_with_sentinel::front
node_t * front() const
Definition: concurrent_monitor.h:48
tbb::internal::circular_doubly_linked_list_with_sentinel::node_t::next
node_t * next
Definition: concurrent_monitor.h:36
tbb::internal::concurrent_monitor::waitset_ec
waitset_t waitset_ec
Definition: concurrent_monitor.h:182
tbb::internal::concurrent_monitor::prepare_wait
void prepare_wait(thread_context &thr, uintptr_t ctx=0)
prepare wait by inserting 'thr' into the wait queue
Definition: concurrent_monitor.cpp:32
tbb::internal::concurrent_monitor::thread_context::semaphore
binary_semaphore & semaphore()
Definition: concurrent_monitor.h:109
tbb::internal::concurrent_monitor::epoch
__TBB_atomic unsigned epoch
Definition: concurrent_monitor.h:183
tbb::internal::__TBB_store_relaxed
void __TBB_store_relaxed(volatile T &location, V value)
Definition: tbb_machine.h:742
tbb::internal::circular_doubly_linked_list_with_sentinel::remove
void remove(node_t &n)
remove node 'n'
Definition: concurrent_monitor.h:63
tbb::internal::circular_doubly_linked_list_with_sentinel::empty
bool empty() const
Definition: concurrent_monitor.h:47
tbb::internal::waitset_t
circular_doubly_linked_list_with_sentinel waitset_t
Definition: concurrent_monitor.h:88
tbb::internal::concurrent_monitor::notify_all_relaxed
void notify_all_relaxed()
Notify all waiting threads of the event; Relaxed version.
Definition: concurrent_monitor.cpp:84
tbb::internal::eid_user_abort
Definition: tbb_exception.h:85
tbb::internal::concurrent_monitor::abort_all_relaxed
void abort_all_relaxed()
Abort any sleeping threads at the time of the call; Relaxed version.
Definition: concurrent_monitor.cpp:107
tbb::internal::circular_doubly_linked_list_with_sentinel::end
const node_t * end() const
Definition: concurrent_monitor.h:51
tbb::internal::concurrent_monitor::mutex_ec
tbb::spin_mutex mutex_ec
Definition: concurrent_monitor.h:181
tbb::internal::waitset_node_t
circular_doubly_linked_list_with_sentinel::node_t waitset_node_t
Definition: concurrent_monitor.h:89
tbb::atomic_fence
void atomic_fence()
Sequentially consistent full memory fence.
Definition: tbb_machine.h:342
tbb::internal::concurrent_monitor::commit_wait
bool commit_wait(thread_context &thr)
Commit wait if event count has not changed; otherwise, cancel wait.
Definition: concurrent_monitor.h:135
tbb::spin_mutex::scoped_lock
Represents acquisition of a mutex.
Definition: spin_mutex.h:53
tbb::internal::concurrent_monitor::thread_context::in_waitset
tbb::atomic< bool > in_waitset
Definition: concurrent_monitor.h:117
tbb::internal::circular_doubly_linked_list_with_sentinel::add
void add(node_t *n)
add to the back of the list
Definition: concurrent_monitor.h:54
tbb::internal::circular_doubly_linked_list_with_sentinel::last
node_t * last() const
Definition: concurrent_monitor.h:49
tbb::internal::concurrent_monitor::notify_one_relaxed
void notify_one_relaxed()
Notify one thread about the event. Relaxed version.
Definition: concurrent_monitor.cpp:66
tbb::internal::binary_semaphore::V
void V()
post/release
Definition: semaphore.h:240
tbb::internal::__TBB_load_relaxed
T __TBB_load_relaxed(const volatile T &location)
Definition: tbb_machine.h:738
tbb::internal::circular_doubly_linked_list_with_sentinel::flush_to
void flush_to(circular_doubly_linked_list_with_sentinel &lst)
move all elements to 'lst' and initialize the 'this' list
Definition: concurrent_monitor.h:71

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.