PTL::VTaskGroup Class Reference

#include <VTaskGroup.hh>

Inheritance diagram for PTL::VTaskGroup:

Public Types
template<typename Tp >
using	container_type = std::vector< Tp >
template<typename Tp >
using	list_type = std::vector< Tp >
typedef VTaskGroup	this_type
typedef std::thread::id	tid_type
typedef VTask	task_type
typedef uintmax_t	size_type
typedef Mutex	lock_t
typedef std::atomic_intmax_t	atomic_int
typedef std::atomic_uintmax_t	atomic_uint
typedef Condition	condition_t
typedef task_type *	task_pointer
typedef container_type< task_pointer >	vtask_list_type

Public Member Functions
	VTaskGroup (ThreadPool *tp=nullptr)
virtual	~VTaskGroup ()
	VTaskGroup (const this_type &)=delete
	VTaskGroup (this_type &&rhs)=default
this_type &	operator= (const this_type &)=delete
this_type &	operator= (this_type &&rhs)=default
virtual void	wait ()
intmax_t	operator++ ()
intmax_t	operator++ (int)
intmax_t	operator-- ()
intmax_t	operator-- (int)
intmax_t	size () const
std::shared_ptr< condition_t >	task_cond ()
const uintmax_t &	id () const
void	set_pool (ThreadPool *tp)
ThreadPool *&	pool ()
ThreadPool *	pool () const
void	clear ()
virtual bool	is_native_task_group () const
virtual bool	is_master () const
virtual intmax_t	pending ()

Static Public Member Functions
static void	set_verbose (int level)

Protected Member Functions
atomic_int &	task_count ()
const atomic_int &	task_count () const

Static Protected Member Functions
static tid_type	this_tid ()

Protected Attributes
uintmax_t	m_id
ThreadPool *	m_pool
std::shared_ptr< atomic_int >	m_tot_task_count = std::make_shared<atomic_int>(0)
std::shared_ptr< condition_t >	m_task_cond = std::make_shared<condition_t>()
std::shared_ptr< lock_t >	m_task_lock = std::make_shared<lock_t>()
tid_type	m_main_tid
vtask_list_type	vtask_list

Static Protected Attributes
static int	f_verbose = GetEnv<int>("PTL_VERBOSE", 0)

Detailed Description

Definition at line 53 of file VTaskGroup.hh.

Member Typedef Documentation

atomic_int

typedef std::atomic_intmax_t PTL::VTaskGroup::atomic_int

Definition at line 66 of file VTaskGroup.hh.

atomic_uint

typedef std::atomic_uintmax_t PTL::VTaskGroup::atomic_uint

Definition at line 67 of file VTaskGroup.hh.

condition_t

typedef Condition PTL::VTaskGroup::condition_t

Definition at line 68 of file VTaskGroup.hh.

container_type

template<typename Tp >

using PTL::VTaskGroup::container_type = std::vector<Tp>

Definition at line 57 of file VTaskGroup.hh.

list_type

template<typename Tp >

using PTL::VTaskGroup::list_type = std::vector<Tp>

Definition at line 59 of file VTaskGroup.hh.

lock_t

typedef Mutex PTL::VTaskGroup::lock_t

Definition at line 65 of file VTaskGroup.hh.

size_type

typedef uintmax_t PTL::VTaskGroup::size_type

Definition at line 64 of file VTaskGroup.hh.

task_pointer

typedef task_type* PTL::VTaskGroup::task_pointer

Definition at line 69 of file VTaskGroup.hh.

task_type

typedef VTask PTL::VTaskGroup::task_type

Definition at line 63 of file VTaskGroup.hh.

this_type

typedef VTaskGroup PTL::VTaskGroup::this_type

Definition at line 61 of file VTaskGroup.hh.

tid_type

typedef std::thread::id PTL::VTaskGroup::tid_type

Definition at line 62 of file VTaskGroup.hh.

vtask_list_type

typedef container_type<task_pointer> PTL::VTaskGroup::vtask_list_type

Definition at line 70 of file VTaskGroup.hh.

Constructor & Destructor Documentation

VTaskGroup() [1/3]

VTaskGroup::VTaskGroup ( ThreadPool *  tp = nullptr )

explicit

Definition at line 56 of file VTaskGroup.cc.

: m_id(vtask_group_counter()++)
, m_pool(tp)
, m_tot_task_count(std::make_shared<atomic_int>(0))
, m_task_cond(std::make_shared<condition_t>())
, m_task_lock(std::make_shared<lock_t>())
, m_main_tid(std::this_thread::get_id())
{
    if(!m_pool && TaskRunManager::GetMasterRunManager())
        m_pool = TaskRunManager::GetMasterRunManager()->GetThreadPool();
 
    if(!m_pool)
    {
        std::cerr << __FUNCTION__ << "@" << __LINE__ << " :: Warning! "
                  << "nullptr to thread pool!" << std::endl;
    }
}

~VTaskGroup()

VTaskGroup::~VTaskGroup ( )

virtual

Definition at line 76 of file VTaskGroup.cc.

{}

VTaskGroup() [2/3]

PTL::VTaskGroup::VTaskGroup ( const this_type &  )

delete

VTaskGroup() [3/3]

PTL::VTaskGroup::VTaskGroup ( this_type &&  rhs )

default

Member Function Documentation

clear()

void PTL::VTaskGroup::clear ( )

inline

Definition at line 146 of file VTaskGroup.hh.

{
    for(auto& itr : vtask_list)
        delete itr;
    vtask_list.clear();
}

Referenced by PTL::TaskGroup< Tp, Arg >::clear().

id()

const uintmax_t & PTL::VTaskGroup::id ( ) const

inline

Definition at line 106 of file VTaskGroup.hh.

{ return m_id; }

is_master()

virtual bool PTL::VTaskGroup::is_master ( ) const

inlinevirtual

Definition at line 115 of file VTaskGroup.hh.

{ return this_tid() == m_main_tid; }

is_native_task_group()

virtual bool PTL::VTaskGroup::is_native_task_group ( ) const

inlinevirtual

Definition at line 114 of file VTaskGroup.hh.

{ return true; }

Referenced by PTL::VTask::is_native_task(), and wait().

operator++() [1/2]

intmax_t PTL::VTaskGroup::operator++ ( )

inline

Definition at line 92 of file VTaskGroup.hh.

{ return ++(*m_tot_task_count); }

Referenced by PTL::TaskGroup< Tp, Arg >::operator+=().

operator++() [2/2]

intmax_t PTL::VTaskGroup::operator++ ( int  )

inline

Definition at line 93 of file VTaskGroup.hh.

{ return (*m_tot_task_count)++; }

operator--() [1/2]

intmax_t PTL::VTaskGroup::operator-- ( )

inline

Definition at line 96 of file VTaskGroup.hh.

{ return --(*m_tot_task_count); }

operator--() [2/2]

intmax_t PTL::VTaskGroup::operator-- ( int  )

inline

Definition at line 97 of file VTaskGroup.hh.

{ return (*m_tot_task_count)--; }

operator=() [1/2]

this_type & PTL::VTaskGroup::operator= ( const this_type &  )

delete

operator=() [2/2]

this_type & PTL::VTaskGroup::operator= ( this_type &&  rhs )

default

pending()

virtual intmax_t PTL::VTaskGroup::pending ( )

inlinevirtual

Definition at line 119 of file VTaskGroup.hh.

{ return m_tot_task_count->load(); }

Referenced by wait().

pool() [1/2]

ThreadPool *& PTL::VTaskGroup::pool ( )

inline

Definition at line 110 of file VTaskGroup.hh.

{ return m_pool; }

Referenced by PTL::VTask::pool().

pool() [2/2]

ThreadPool * PTL::VTaskGroup::pool ( ) const

inline

Definition at line 111 of file VTaskGroup.hh.

{ return m_pool; }

set_pool()

void PTL::VTaskGroup::set_pool ( ThreadPool *  tp )

inline

Definition at line 109 of file VTaskGroup.hh.

{ m_pool = tp; }

set_verbose()

static void PTL::VTaskGroup::set_verbose ( int  level )

inlinestatic

Definition at line 121 of file VTaskGroup.hh.

{ f_verbose = level; }

size()

intmax_t PTL::VTaskGroup::size ( ) const

inline

Definition at line 100 of file VTaskGroup.hh.

{ return m_tot_task_count->load(); }

task_cond()

std::shared_ptr< condition_t > PTL::VTaskGroup::task_cond ( )

inline

Definition at line 103 of file VTaskGroup.hh.

{ return m_task_cond; }

Referenced by PTL::VTask::operator--().

task_count() [1/2]

atomic_int & PTL::VTaskGroup::task_count ( )

inlineprotected

Definition at line 130 of file VTaskGroup.hh.

{ return *m_tot_task_count; }

Referenced by wait().

task_count() [2/2]

const atomic_int & PTL::VTaskGroup::task_count ( ) const

inlineprotected

Definition at line 131 of file VTaskGroup.hh.

{ return *m_tot_task_count; }

this_tid()

static tid_type PTL::VTaskGroup::this_tid ( )

inlinestaticprotected

Definition at line 126 of file VTaskGroup.hh.

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

Referenced by is_master().

wait()

void VTaskGroup::wait ( )

virtual

Definition at line 81 of file VTaskGroup.cc.

{
    // if no pool was initially present at creation
    if(!m_pool)
    {
        // check for master MT run-manager
        if(TaskRunManager::GetMasterRunManager())
            m_pool = TaskRunManager::GetMasterRunManager()->GetThreadPool();
 
        // if MTRunManager does not exist or no thread pool created
        if(!m_pool)
        {
            if(f_verbose > 0)
            {
                fprintf(stderr, "%s @ %i :: Warning! nullptr to thread-pool (%p)\n",
                        __FUNCTION__, __LINE__, static_cast<void*>(m_pool));
                std::cerr << __FUNCTION__ << "@" << __LINE__ << " :: Warning! "
                          << "nullptr to thread pool!" << std::endl;
            }
            return;
        }
    }
 
    ThreadData* data = ThreadData::GetInstance();
    if(!data)
        return;
 
    ThreadPool*     tpool = (m_pool) ? m_pool : data->thread_pool;
    VUserTaskQueue* taskq = (tpool) ? tpool->get_queue() : data->current_queue;
 
    bool _is_master   = data->is_master;
    bool _within_task = data->within_task;
 
    auto is_active_state = [&]() {
        return (tpool->state()->load(std::memory_order_relaxed) !=
                thread_pool::state::STOPPED);
    };
 
    auto execute_this_threads_tasks = [&]() {
        if(!taskq)
            return;
 
        // only want to process if within a task
        if((!_is_master || tpool->size() < 2) && _within_task)
        {
            int bin = static_cast<int>(taskq->GetThreadBin());
            // const auto nitr = (tpool) ? tpool->size() : Thread::hardware_concurrency();
            while(this->pending() > 0)
            {
                task_pointer _task = taskq->GetTask(bin);
                if(_task)
                    (*_task)();
            }
        }
    };
 
    // checks for validity
    if(!is_native_task_group())
    {
        // for external threads
        if(!_is_master || tpool->size() < 2)
            return;
    }
    else if(f_verbose > 0)
    {
        if(!tpool || !taskq)
        {
            // something is wrong, didn't create thread-pool?
            fprintf(
                stderr,
                "%s @ %i :: Warning! nullptr to thread data (%p) or task-queue (%p)\n",
                __FUNCTION__, __LINE__, static_cast<void*>(tpool),
                static_cast<void*>(taskq));
        }
        // return if thread pool isn't built
        else if(is_native_task_group() && !tpool->is_alive())
        {
            fprintf(stderr, "%s @ %i :: Warning! thread-pool is not alive!\n",
                    __FUNCTION__, __LINE__);
        }
        else if(!is_active_state())
        {
            fprintf(stderr, "%s @ %i :: Warning! thread-pool is not active!\n",
                    __FUNCTION__, __LINE__);
        }
    }
 
    intmax_t wake_size = 2;
    AutoLock _lock(*m_task_lock, std::defer_lock);
 
    while(is_active_state())
    {
        execute_this_threads_tasks();
 
        // while loop protects against spurious wake-ups
        while(_is_master && pending() > 0 && is_active_state())
        {
            // auto _wake = [&]() { return (wake_size > pending() || !is_active_state());
            // };
 
            // lock before sleeping on condition
            if(!_lock.owns_lock())
                _lock.lock();
 
            // Wait until signaled that a task has been competed
            // Unlock mutex while wait, then lock it back when signaled
            // when true, this wakes the thread
            if(pending() >= wake_size)
            {
                m_task_cond->wait(_lock);
            }
            else
            {
                m_task_cond->wait_for(_lock, std::chrono::microseconds(100));
            }
            // unlock
            if(_lock.owns_lock())
                _lock.unlock();
        }
 
        // if pending is not greater than zero, we are joined
        if(pending() <= 0)
            break;
    }
 
    if(_lock.owns_lock())
        _lock.unlock();
 
    intmax_t ntask = this->task_count().load();
    if(ntask > 0)
    {
        std::stringstream ss;
        ss << "\nWarning! Join operation issue! " << ntask << " tasks still "
           << "are running!" << std::endl;
        std::cerr << ss.str();
        this->wait();
    }
}

Referenced by G4TaskRunManager::CreateAndStartWorkers(), PTL::TaskGroup< Tp, Arg >::join(), and wait().

Member Data Documentation

f_verbose

int VTaskGroup::f_verbose = GetEnv<int>("PTL_VERBOSE", 0)

staticprotected

Definition at line 142 of file VTaskGroup.hh.

Referenced by set_verbose(), and wait().

m_id

uintmax_t PTL::VTaskGroup::m_id

protected

Definition at line 135 of file VTaskGroup.hh.

Referenced by id().

m_main_tid

tid_type PTL::VTaskGroup::m_main_tid

protected

Definition at line 140 of file VTaskGroup.hh.

Referenced by is_master().

m_pool

ThreadPool* PTL::VTaskGroup::m_pool

protected

Definition at line 136 of file VTaskGroup.hh.

Referenced by PTL::TaskGroup< Tp, Arg >::exec(), pool(), PTL::TaskGroup< Tp, Arg >::run(), set_pool(), VTaskGroup(), and wait().

m_task_cond

std::shared_ptr<condition_t> PTL::VTaskGroup::m_task_cond = std::make_shared<condition_t>()

protected

Definition at line 138 of file VTaskGroup.hh.

Referenced by task_cond(), and wait().

m_task_lock

std::shared_ptr<lock_t> PTL::VTaskGroup::m_task_lock = std::make_shared<lock_t>()

protected

Definition at line 139 of file VTaskGroup.hh.

Referenced by wait().

m_tot_task_count

std::shared_ptr<atomic_int> PTL::VTaskGroup::m_tot_task_count = std::make_shared<atomic_int>(0)

protected

Definition at line 137 of file VTaskGroup.hh.

Referenced by operator++(), operator--(), pending(), size(), and task_count().

vtask_list

vtask_list_type PTL::VTaskGroup::vtask_list

protected

Definition at line 141 of file VTaskGroup.hh.

Referenced by clear(), and PTL::TaskGroup< Tp, Arg >::operator+=().

---

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

• VTaskGroup.hh
• VTaskGroup.cc