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 )

inlineprivate

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