tim::ert::thread_barrier Class Reference

#include "timemory/ert/barrier.hpp"

Collaboration diagram for tim::ert::thread_barrier:

Public Types
using	size_type = int64_t
using	mutex_t = std::mutex
using	condvar_t = std::condition_variable
using	atomic_t = std::atomic< size_type >
using	lock_t = std::unique_lock< mutex_t >

Public Member Functions
	thread_barrier (size_t nthreads)
	thread_barrier (const thread_barrier &)=delete
	thread_barrier (thread_barrier &&)=delete
thread_barrier &	operator= (const thread_barrier &)=delete
thread_barrier &	operator= (thread_barrier &&)=delete
size_type	size () const
void	spin_wait ()
void	cv_wait ()
void	notify_wait ()
bool	is_master () const

Detailed Description

Definition at line 50 of file barrier.hpp.

Member Typedef Documentation

atomic_t

using tim::ert::thread_barrier::atomic_t = std::atomic<size_type>

Definition at line 56 of file barrier.hpp.

condvar_t

using tim::ert::thread_barrier::condvar_t = std::condition_variable

Definition at line 55 of file barrier.hpp.

lock_t

using tim::ert::thread_barrier::lock_t = std::unique_lock<mutex_t>

Definition at line 57 of file barrier.hpp.

mutex_t

using tim::ert::thread_barrier::mutex_t = std::mutex

Definition at line 54 of file barrier.hpp.

size_type

using tim::ert::thread_barrier::size_type = int64_t

Definition at line 53 of file barrier.hpp.

Constructor & Destructor Documentation

thread_barrier() [1/3]

tim::ert::thread_barrier::thread_barrier ( size_t  nthreads )

inlineexplicit

Definition at line 60 of file barrier.hpp.

    : m_master(std::this_thread::get_id())
    , m_num_threads(nthreads)
    , m_notify(0)
    , m_future(m_promise.get_future().share())
    {}

thread_barrier() [2/3]

tim::ert::thread_barrier::thread_barrier ( const thread_barrier &  )

delete

thread_barrier() [3/3]

tim::ert::thread_barrier::thread_barrier ( thread_barrier &&  )

delete

Member Function Documentation

cv_wait()

void tim::ert::thread_barrier::cv_wait ( )

inline

Definition at line 109 of file barrier.hpp.

    {
        if(is_master())
        {
#if defined(TIMEMORY_INTERNAL_TESTING)
            TIMEMORY_EXCEPTION("master thread calling worker wait function\n");
#else
            return;
#endif
        }
 
        lock_t lk(m_mutex);
        ++m_counter;
        ++m_waiting;
        m_cv.wait(lk, [&] { return m_counter >= m_num_threads; });
        m_cv.notify_one();
        --m_waiting;
        if(m_waiting == 0)
            m_counter = 0;  // reset barrier
    }

References is_master(), and TIMEMORY_EXCEPTION.

is_master()

bool tim::ert::thread_barrier::is_master ( ) const

inline

Definition at line 161 of file barrier.hpp.

{ return std::this_thread::get_id() == m_master; }

Referenced by cv_wait(), notify_wait(), and spin_wait().

notify_wait()

void tim::ert::thread_barrier::notify_wait ( )

inline

Definition at line 132 of file barrier.hpp.

    {
        if(is_master())
        {
            lock_t lk(m_mutex);
            while(m_notify.load() < m_num_threads)
                m_cv.wait(lk);
            m_promise.set_value();
            while(m_notify.load() > 0)
            {
            }
            std::promise<void>       _ptmp;
            std::shared_future<void> _ftmp = _ptmp.get_future().share();
            std::swap(m_promise, _ptmp);
            std::swap(m_future, _ftmp);
        }
        else
        {
            {
                lock_t lk(m_mutex);
                ++m_notify;
                m_cv.notify_one();
            }
            m_future.wait();
            --m_notify;
        }
    }

References is_master().

operator=() [1/2]

thread_barrier & tim::ert::thread_barrier::operator= ( const thread_barrier &  )

delete

operator=() [2/2]

thread_barrier & tim::ert::thread_barrier::operator= ( thread_barrier &&  )

delete

size()

size_type tim::ert::thread_barrier::size ( ) const

inline

Definition at line 73 of file barrier.hpp.

{ return m_num_threads; }

spin_wait()

void tim::ert::thread_barrier::spin_wait ( )

inline

Definition at line 76 of file barrier.hpp.

    {
        if(is_master())
        {
#if defined(TIMEMORY_INTERNAL_TESTING)
            TIMEMORY_EXCEPTION("master thread calling worker wait function\n");
#else
            return;
#endif
        }
 
        {
            lock_t lk(m_mutex);
            ++m_counter;
            ++m_waiting;
        }
 
        while(m_counter < m_num_threads)
        {
            while(spin_lock.test_and_set(std::memory_order_acquire))  // acquire lock
                ;                                                     // spin
            spin_lock.clear(std::memory_order_release);
        }
 
        {
            lock_t lk(m_mutex);
            --m_waiting;
            if(m_waiting == 0)
                m_counter = 0;  // reset barrier
        }
    }

References is_master(), and TIMEMORY_EXCEPTION.

---

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

• timemory/ert/barrier.hpp