PTL::TaskGroup< Tp, Arg, MaxDepth > Class Template Reference

#include <TaskGroup.hh>

Public Types
template<typename Up >
using	container_type = std::vector<Up>
using	tid_type = std::thread::id
using	size_type = uintmax_t
using	lock_t = Mutex
using	atomic_int = std::atomic_intmax_t
using	atomic_uint = std::atomic_uintmax_t
using	condition_t = Condition
using	ArgTp = decay_t<Arg>
using	result_type = Tp
using	task_pointer = std::shared_ptr<TaskFuture<ArgTp>>
using	task_list_t = container_type<task_pointer>
using	this_type = TaskGroup<Tp, Arg, MaxDepth>
using	promise_type = std::promise<ArgTp>
using	future_type = std::future<ArgTp>
using	packaged_task_type = std::packaged_task<ArgTp()>
using	future_list_t = container_type<future_type>
using	join_type = typename JoinFunction<Tp, Arg>::Type
using	iterator = typename future_list_t::iterator
using	reverse_iterator = typename future_list_t::reverse_iterator
using	const_iterator = typename future_list_t::const_iterator
using	const_reverse_iterator = typename future_list_t::const_reverse_iterator
template<typename... Args>
using	task_type = Task<ArgTp, decay_t<Args>...>

Public Member Functions
template<typename Func >
	TaskGroup (Func &&_join, ThreadPool *_tp=internal::get_default_threadpool())
template<typename Up = Tp>
	TaskGroup (ThreadPool *_tp=internal::get_default_threadpool(), enable_if_t< std::is_void< Up >::value, int >=0)
	~TaskGroup ()
	TaskGroup (const this_type &)=delete
	TaskGroup (this_type &&rhs)=default
TaskGroup &	operator= (const this_type &rhs)=delete
TaskGroup &	operator= (this_type &&rhs)=default
template<typename Up >
std::shared_ptr< Up >	operator+= (std::shared_ptr< Up > &&_task)
void	wait ()
intmax_t	operator++ ()
intmax_t	operator++ (int)
intmax_t	operator-- ()
intmax_t	operator-- (int)
intmax_t	size () const
lock_t &	task_lock ()
condition_t &	task_cond ()
uintmax_t	id () const
void	set_pool (ThreadPool *tp)
ThreadPool *&	pool ()
ThreadPool *	pool () const
bool	is_native_task_group () const
bool	is_main () const
intmax_t	pending ()
ScopeDestructor	get_scope_destructor ()
void	notify ()
void	notify_all ()
void	reserve (size_t _n)
template<typename Func , typename... Args>
std::shared_ptr< task_type< Args... > >	wrap (Func func, Args... args)
template<typename Func , typename... Args, typename Up = Tp>
enable_if_t< std::is_void< Up >::value, void >	exec (Func func, Args... args)
template<typename Func , typename... Args, typename Up = Tp>
enable_if_t<!std::is_void< Up >::value, void >	exec (Func func, Args... args)
template<typename Func , typename... Args>
void	run (Func func, Args... args)
future_list_t &	get_tasks ()
const future_list_t &	get_tasks () const
itr_t	begin ()
itr_t	end ()
citr_t	begin () const
citr_t	end () const
citr_t	cbegin () const
citr_t	cend () const
ritr_t	rbegin ()
ritr_t	rend ()
critr_t	rbegin () const
critr_t	rend () const
template<typename Up = Tp, enable_if_t<!std::is_void< Up >::value, int > = 0>
Up	join (Up accum={})
template<typename Up = Tp, typename Rp = Arg, enable_if_t< std::is_void< Up >::value &&std::is_void< Rp >::value, int > = 0>
void	join ()
template<typename Up = Tp, typename Rp = Arg, enable_if_t< std::is_void< Up >::value &&!std::is_void< Rp >::value, int > = 0>
void	join ()
void	clear ()

Static Public Member Functions
static void	set_verbose (int level)

Protected Types
using	itr_t = iterator
using	citr_t = const_iterator
using	ritr_t = reverse_iterator
using	critr_t = const_reverse_iterator

Protected Member Functions
template<typename Up , typename Func , typename... Args>
enable_if_t< std::is_void< Up >::value, void >	local_exec (Func func, Args... args)
template<typename Up , typename Func , typename... Args>
enable_if_t<!std::is_void< Up >::value, void >	local_exec (Func func, Args... args)
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 = internal::task_group_counter()++
intmax_t	m_depth = internal::get_task_depth()
tid_type	m_main_tid = std::this_thread::get_id()
atomic_int	m_tot_task_count { 0 }
lock_t	m_task_lock = {}
condition_t	m_task_cond = {}
join_type	m_join {}
ThreadPool *	m_pool = internal::get_default_threadpool()
tbb_task_group_t *	m_tbb_task_group = nullptr
task_list_t	m_task_list = {}
future_list_t	m_future_list = {}

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

Detailed Description

template<typename Tp, typename Arg = Tp, intmax_t MaxDepth = 0>
class PTL::TaskGroup< Tp, Arg, MaxDepth >

Definition at line 82 of file TaskGroup.hh.

Member Typedef Documentation

ArgTp

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::ArgTp = decay_t<Arg>

Definition at line 95 of file TaskGroup.hh.

atomic_int

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::atomic_int = std::atomic_intmax_t

Definition at line 92 of file TaskGroup.hh.

atomic_uint

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::atomic_uint = std::atomic_uintmax_t

Definition at line 93 of file TaskGroup.hh.

citr_t

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::citr_t = const_iterator

protected

Definition at line 213 of file TaskGroup.hh.

condition_t

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::condition_t = Condition

Definition at line 94 of file TaskGroup.hh.

const_iterator

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::const_iterator = typename future_list_t::const_iterator

Definition at line 107 of file TaskGroup.hh.

const_reverse_iterator

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::const_reverse_iterator = typename future_list_t::const_reverse_iterator

Definition at line 108 of file TaskGroup.hh.

container_type

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

template<typename Up >

using PTL::TaskGroup< Tp, Arg, MaxDepth >::container_type = std::vector<Up>

Definition at line 87 of file TaskGroup.hh.

critr_t

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::critr_t = const_reverse_iterator

protected

Definition at line 215 of file TaskGroup.hh.

future_list_t

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::future_list_t = container_type<future_type>

Definition at line 103 of file TaskGroup.hh.

future_type

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::future_type = std::future<ArgTp>

Definition at line 101 of file TaskGroup.hh.

iterator

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::iterator = typename future_list_t::iterator

Definition at line 105 of file TaskGroup.hh.

itr_t

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::itr_t = iterator

protected

Definition at line 212 of file TaskGroup.hh.

join_type

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::join_type = typename JoinFunction<Tp, Arg>::Type

Definition at line 104 of file TaskGroup.hh.

lock_t

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::lock_t = Mutex

Definition at line 91 of file TaskGroup.hh.

packaged_task_type

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::packaged_task_type = std::packaged_task<ArgTp()>

Definition at line 102 of file TaskGroup.hh.

promise_type

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::promise_type = std::promise<ArgTp>

Definition at line 100 of file TaskGroup.hh.

result_type

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::result_type = Tp

Definition at line 96 of file TaskGroup.hh.

reverse_iterator

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::reverse_iterator = typename future_list_t::reverse_iterator

Definition at line 106 of file TaskGroup.hh.

ritr_t

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::ritr_t = reverse_iterator

protected

Definition at line 214 of file TaskGroup.hh.

size_type

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::size_type = uintmax_t

Definition at line 90 of file TaskGroup.hh.

task_list_t

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::task_list_t = container_type<task_pointer>

Definition at line 98 of file TaskGroup.hh.

task_pointer

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::task_pointer = std::shared_ptr<TaskFuture<ArgTp>>

Definition at line 97 of file TaskGroup.hh.

task_type

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

template<typename... Args>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::task_type = Task<ArgTp, decay_t<Args>...>

Definition at line 111 of file TaskGroup.hh.

this_type

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::this_type = TaskGroup<Tp, Arg, MaxDepth>

Definition at line 99 of file TaskGroup.hh.

tid_type

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

using PTL::TaskGroup< Tp, Arg, MaxDepth >::tid_type = std::thread::id

Definition at line 89 of file TaskGroup.hh.

Constructor & Destructor Documentation

TaskGroup() [1/4]

template<typename Tp , typename Arg , intmax_t MaxDepth>

template<typename Func >

PTL::TaskGroup< Tp, Arg, MaxDepth >::TaskGroup	(	Func &&	_join,
		ThreadPool *	_tp = internal::get_default_threadpool() )

Definition at line 290 of file TaskGroup.hh.

: m_join{ std::forward<Func>(_join) }
, m_pool{ _tp }
{
    internal_update();
}

TaskGroup() [2/4]

template<typename Tp , typename Arg , intmax_t MaxDepth>

template<typename Up >

PTL::TaskGroup< Tp, Arg, MaxDepth >::TaskGroup	(	ThreadPool *	_tp = internal::get_default_threadpool(),
		enable_if_t< std::is_void< Up >::value, int >	= 0 )

Definition at line 299 of file TaskGroup.hh.

: m_join{ []() {} }
, m_pool{ _tp }
{
    internal_update();
}

~TaskGroup()

template<typename Tp , typename Arg , intmax_t MaxDepth>

PTL::TaskGroup< Tp, Arg, MaxDepth >::~TaskGroup

(

)

Definition at line 309 of file TaskGroup.hh.

{
    {
        // task will decrement counter and then acquire the lock to notify
        // condition variable so acquiring lock here will prevent the
        // task group from being destroyed before this is completed
        AutoLock _lk{ m_task_lock, std::defer_lock };
        if(!_lk.owns_lock())
            _lk.lock();
    }
 
    if(m_tbb_task_group)
    {
        auto* _arena = m_pool->get_task_arena();
        _arena->execute([this]() { this->m_tbb_task_group->wait(); });
    }
    delete m_tbb_task_group;
    this->clear();
}

TaskGroup() [3/4]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

PTL::TaskGroup< Tp, Arg, MaxDepth >::TaskGroup ( const this_type & )

delete

TaskGroup() [4/4]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

PTL::TaskGroup< Tp, Arg, MaxDepth >::TaskGroup ( this_type && rhs )

default

Member Function Documentation

begin() [1/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

itr_t PTL::TaskGroup< Tp, Arg, MaxDepth >::begin ( )

inline

Definition at line 227 of file TaskGroup.hh.

{ return m_future_list.begin(); }

begin() [2/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

citr_t PTL::TaskGroup< Tp, Arg, MaxDepth >::begin ( ) const

inline

Definition at line 229 of file TaskGroup.hh.

{ return m_future_list.begin(); }

cbegin()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

citr_t PTL::TaskGroup< Tp, Arg, MaxDepth >::cbegin ( ) const

inline

Definition at line 231 of file TaskGroup.hh.

{ return m_future_list.begin(); }

cend()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

citr_t PTL::TaskGroup< Tp, Arg, MaxDepth >::cend ( ) const

inline

Definition at line 232 of file TaskGroup.hh.

{ return m_future_list.end(); }

clear()

template<typename Tp , typename Arg , intmax_t MaxDepth>

void PTL::TaskGroup< Tp, Arg, MaxDepth >::clear

(

)

Definition at line 708 of file TaskGroup.hh.

{
    m_future_list.clear();
    m_task_list.clear();
}

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

end() [1/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

itr_t PTL::TaskGroup< Tp, Arg, MaxDepth >::end ( )

inline

Definition at line 228 of file TaskGroup.hh.

{ return m_future_list.end(); }

end() [2/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

citr_t PTL::TaskGroup< Tp, Arg, MaxDepth >::end ( ) const

inline

Definition at line 230 of file TaskGroup.hh.

{ return m_future_list.end(); }

exec() [1/2]

template<typename Tp , typename Arg , intmax_t MaxDepth>

template<typename Func , typename... Args, typename Up >

enable_if_t< std::is_void< Up >::value, void > PTL::TaskGroup< Tp, Arg, MaxDepth >::exec	(	Func	func,
		Args...	args )

Definition at line 531 of file TaskGroup.hh.

{
    if(MaxDepth > 0 && !m_tbb_task_group && ThreadData::GetInstance() &&
       ThreadData::GetInstance()->task_depth > MaxDepth)
    {
        local_exec<Tp>(std::move(func), std::move(args)...);
    }
    else
    {
        auto& _counter   = m_tot_task_count;
        auto& _task_cond = task_cond();
        auto& _task_lock = task_lock();
        auto  _task      = wrap([&_task_cond, &_task_lock, &_counter, func, args...]() {
            auto* _tdata = ThreadData::GetInstance();
            if(_tdata)
                ++(_tdata->task_depth);
            func(args...);
            auto _count = --(_counter);
            if(_tdata)
                --(_tdata->task_depth);
            if(_count < 1)
            {
                AutoLock _lk{ _task_lock };
                _task_cond.notify_all();
            }
        });
 
        if(m_tbb_task_group)
        {
            auto* _arena          = m_pool->get_task_arena();
            auto* _tbb_task_group = m_tbb_task_group;
            auto* _ptask          = _task.get();
            _arena->execute([_tbb_task_group, _ptask]() {
                _tbb_task_group->run([_ptask]() { (*_ptask)(); });
            });
        }
        else
        {
            m_pool->add_task(std::move(_task));
        }
    }
}

Referenced by G4TaskRunManager::AddEventTask(), PTL::TaskManager::exec(), PTL::TaskManager::exec(), PTL::TaskManager::rexec(), PTL::TaskManager::rexec(), PTL::TaskManager::rexec(), PTL::TaskManager::rexec(), and PTL::TaskGroup< Tp, Arg, MaxDepth >::run().

exec() [2/2]

template<typename Tp , typename Arg , intmax_t MaxDepth>

template<typename Func , typename... Args, typename Up >

enable_if_t<!std::is_void< Up >::value, void > PTL::TaskGroup< Tp, Arg, MaxDepth >::exec	(	Func	func,
		Args...	args )

Definition at line 576 of file TaskGroup.hh.

{
    if(MaxDepth > 0 && !m_tbb_task_group && ThreadData::GetInstance() &&
       ThreadData::GetInstance()->task_depth > MaxDepth)
    {
        local_exec<Tp>(std::move(func), std::move(args)...);
    }
    else
    {
        auto& _counter   = m_tot_task_count;
        auto& _task_cond = task_cond();
        auto& _task_lock = task_lock();
        auto  _task      = wrap([&_task_cond, &_task_lock, &_counter, func, args...]() {
            auto* _tdata = ThreadData::GetInstance();
            if(_tdata)
                ++(_tdata->task_depth);
            auto&& _ret   = func(args...);
            auto   _count = --(_counter);
            if(_tdata)
                --(_tdata->task_depth);
            if(_count < 1)
            {
                AutoLock _lk{ _task_lock };
                _task_cond.notify_all();
            }
            return std::forward<decltype(_ret)>(_ret);
        });
 
        if(m_tbb_task_group)
        {
            auto* _arena          = m_pool->get_task_arena();
            auto* _tbb_task_group = m_tbb_task_group;
            auto* _ptask          = _task.get();
            _arena->execute([_tbb_task_group, _ptask]() {
                _tbb_task_group->run([_ptask]() { (*_ptask)(); });
            });
        }
        else
        {
            m_pool->add_task(std::move(_task));
        }
    }
}

get_scope_destructor()

template<typename Tp , typename Arg , intmax_t MaxDepth>

ScopeDestructor PTL::TaskGroup< Tp, Arg, MaxDepth >::get_scope_destructor

(

)

Definition at line 497 of file TaskGroup.hh.

{
    auto& _counter   = m_tot_task_count;
    auto& _task_cond = task_cond();
    auto& _task_lock = task_lock();
    return ScopeDestructor{ [&_task_cond, &_task_lock, &_counter]() {
        auto _count = --(_counter);
        if(_count < 1)
        {
            AutoLock _lk{ _task_lock };
            _task_cond.notify_all();
        }
    } };
}

get_tasks() [1/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

future_list_t & PTL::TaskGroup< Tp, Arg, MaxDepth >::get_tasks ( )

inline

Definition at line 221 of file TaskGroup.hh.

{ return m_future_list; }

get_tasks() [2/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

const future_list_t & PTL::TaskGroup< Tp, Arg, MaxDepth >::get_tasks ( ) const

inline

Definition at line 222 of file TaskGroup.hh.

{ return m_future_list; }

id()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

uintmax_t PTL::TaskGroup< Tp, Arg, MaxDepth >::id ( ) const

inline

Definition at line 158 of file TaskGroup.hh.

{ return m_id; }

is_main()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

bool PTL::TaskGroup< Tp, Arg, MaxDepth >::is_main ( ) const

inline

Definition at line 166 of file TaskGroup.hh.

{ return this_tid() == m_main_tid; }

is_native_task_group()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

bool PTL::TaskGroup< Tp, Arg, MaxDepth >::is_native_task_group ( ) const

inline

Definition at line 165 of file TaskGroup.hh.

{ return (m_tbb_task_group) == nullptr; }

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

join() [1/3]

template<typename Tp , typename Arg , intmax_t MaxDepth>

template<typename Up , typename Rp , enable_if_t< std::is_void< Up >::value &&!std::is_void< Rp >::value, int > >

void PTL::TaskGroup< Tp, Arg, MaxDepth >::join ( )

inline

Definition at line 675 of file TaskGroup.hh.

{
    this->wait();
    for(auto& itr : m_task_list)
        itr->get();
    for(auto& itr : m_future_list)
        itr.get();
    m_join();
    this->clear();
}

join() [2/3]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

template<typename Up = Tp, typename Rp = Arg, enable_if_t< std::is_void< Up >::value &&!std::is_void< Rp >::value, int > = 0>

void PTL::TaskGroup< Tp, Arg, MaxDepth >::join ( )

inline

join() [3/3]

template<typename Tp , typename Arg , intmax_t MaxDepth>

template<typename Up , enable_if_t<!std::is_void< Up >::value, int > >

Up PTL::TaskGroup< Tp, Arg, MaxDepth >::join ( Up accum = {} )

inline

Definition at line 654 of file TaskGroup.hh.

{
    this->wait();
    for(auto& itr : m_task_list)
    {
        using RetT = decay_t<decltype(itr->get())>;
        accum      = std::move(m_join(std::ref(accum), std::forward<RetT>(itr->get())));
    }
    for(auto& itr : m_future_list)
    {
        using RetT = decay_t<decltype(itr.get())>;
        accum      = std::move(m_join(std::ref(accum), std::forward<RetT>(itr.get())));
    }
    this->clear();
    return accum;
}

Referenced by G4TaskRunManager::TerminateWorkers(), and G4TaskRunManager::WaitForEndEventLoopWorkers().

local_exec() [1/2]

template<typename Tp , typename Arg , intmax_t MaxDepth>

template<typename Up , typename Func , typename... Args>

enable_if_t< std::is_void< Up >::value, void > PTL::TaskGroup< Tp, Arg, MaxDepth >::local_exec ( Func func, Args... args )

protected

Definition at line 623 of file TaskGroup.hh.

{
    auto* _tdata = ThreadData::GetInstance();
    if(_tdata)
        ++(_tdata->task_depth);
    promise_type _p{};
    m_future_list.emplace_back(_p.get_future());
    func(args...);
    _p.set_value();
    if(_tdata)
        --(_tdata->task_depth);
}

local_exec() [2/2]

template<typename Tp , typename Arg , intmax_t MaxDepth>

template<typename Up , typename Func , typename... Args>

enable_if_t<!std::is_void< Up >::value, void > PTL::TaskGroup< Tp, Arg, MaxDepth >::local_exec ( Func func, Args... args )

protected

Definition at line 639 of file TaskGroup.hh.

{
    auto* _tdata = ThreadData::GetInstance();
    if(_tdata)
        ++(_tdata->task_depth);
    promise_type _p{};
    m_future_list.emplace_back(_p.get_future());
    _p.set_value(func(args...));
    if(_tdata)
        --(_tdata->task_depth);
}

notify()

template<typename Tp , typename Arg , intmax_t MaxDepth>

void PTL::TaskGroup< Tp, Arg, MaxDepth >::notify

(

)

Definition at line 514 of file TaskGroup.hh.

{
    AutoLock _lk{ m_task_lock };
    m_task_cond.notify_one();
}

notify_all()

template<typename Tp , typename Arg , intmax_t MaxDepth>

void PTL::TaskGroup< Tp, Arg, MaxDepth >::notify_all

(

)

Definition at line 522 of file TaskGroup.hh.

{
    AutoLock _lk{ m_task_lock };
    m_task_cond.notify_all();
}

operator++() [1/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

intmax_t PTL::TaskGroup< Tp, Arg, MaxDepth >::operator++ ( )

inline

Definition at line 145 of file TaskGroup.hh.

{ return ++(m_tot_task_count); }

operator++() [2/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

intmax_t PTL::TaskGroup< Tp, Arg, MaxDepth >::operator++ ( int )

inline

Definition at line 146 of file TaskGroup.hh.

{ return (m_tot_task_count)++; }

operator+=()

template<typename Tp , typename Arg , intmax_t MaxDepth>

template<typename Up >

std::shared_ptr< Up > PTL::TaskGroup< Tp, Arg, MaxDepth >::operator+=

(

std::shared_ptr< Up > &&

_task

)

Definition at line 332 of file TaskGroup.hh.

{
    // thread-safe increment of tasks in task group
    operator++();
    // copy the shared pointer to abstract instance
    m_task_list.push_back(_task);
    // return the derived instance
    return std::move(_task);
}

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

operator--() [1/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

intmax_t PTL::TaskGroup< Tp, Arg, MaxDepth >::operator-- ( )

inline

Definition at line 147 of file TaskGroup.hh.

{ return --(m_tot_task_count); }

operator--() [2/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

intmax_t PTL::TaskGroup< Tp, Arg, MaxDepth >::operator-- ( int )

inline

Definition at line 148 of file TaskGroup.hh.

{ return (m_tot_task_count)--; }

operator=() [1/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

TaskGroup & PTL::TaskGroup< Tp, Arg, MaxDepth >::operator= ( const this_type & rhs )

delete

operator=() [2/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

TaskGroup & PTL::TaskGroup< Tp, Arg, MaxDepth >::operator= ( this_type && rhs )

default

pending()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

intmax_t PTL::TaskGroup< Tp, Arg, MaxDepth >::pending ( )

inline

Definition at line 169 of file TaskGroup.hh.

{ return m_tot_task_count.load(); }

pool() [1/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

ThreadPool *& PTL::TaskGroup< Tp, Arg, MaxDepth >::pool ( )

inline

Definition at line 162 of file TaskGroup.hh.

{ return m_pool; }

pool() [2/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

ThreadPool * PTL::TaskGroup< Tp, Arg, MaxDepth >::pool ( ) const

inline

Definition at line 163 of file TaskGroup.hh.

{ return m_pool; }

rbegin() [1/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

ritr_t PTL::TaskGroup< Tp, Arg, MaxDepth >::rbegin ( )

inline

Definition at line 233 of file TaskGroup.hh.

{ return m_future_list.rbegin(); }

rbegin() [2/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

critr_t PTL::TaskGroup< Tp, Arg, MaxDepth >::rbegin ( ) const

inline

Definition at line 235 of file TaskGroup.hh.

{ return m_future_list.rbegin(); }

rend() [1/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

ritr_t PTL::TaskGroup< Tp, Arg, MaxDepth >::rend ( )

inline

Definition at line 234 of file TaskGroup.hh.

{ return m_future_list.rend(); }

rend() [2/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

critr_t PTL::TaskGroup< Tp, Arg, MaxDepth >::rend ( ) const

inline

Definition at line 236 of file TaskGroup.hh.

{ return m_future_list.rend(); }

reserve()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

void PTL::TaskGroup< Tp, Arg, MaxDepth >::reserve ( size_t _n )

inline

Definition at line 178 of file TaskGroup.hh.

    {
        m_task_list.reserve(_n);
        m_future_list.reserve(_n);
    }

run()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

template<typename Func , typename... Args>

void PTL::TaskGroup< Tp, Arg, MaxDepth >::run ( Func func, Args... args )

inline

Definition at line 199 of file TaskGroup.hh.

    {
        exec(std::move(func), std::move(args)...);
    }

set_pool()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

void PTL::TaskGroup< Tp, Arg, MaxDepth >::set_pool ( ThreadPool * tp )

inline

Definition at line 161 of file TaskGroup.hh.

{ m_pool = tp; }

set_verbose()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

static void PTL::TaskGroup< Tp, Arg, MaxDepth >::set_verbose ( int level )

inlinestatic

Definition at line 171 of file TaskGroup.hh.

{ f_verbose = level; }

size()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

intmax_t PTL::TaskGroup< Tp, Arg, MaxDepth >::size ( ) const

inline

Definition at line 151 of file TaskGroup.hh.

{ return m_tot_task_count.load(); }

task_cond()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

condition_t & PTL::TaskGroup< Tp, Arg, MaxDepth >::task_cond ( )

inline

Definition at line 155 of file TaskGroup.hh.

{ return m_task_cond; }

task_count() [1/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

atomic_int & PTL::TaskGroup< Tp, Arg, MaxDepth >::task_count ( )

inlineprotected

Definition at line 263 of file TaskGroup.hh.

{ return m_tot_task_count; }

task_count() [2/2]

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

const atomic_int & PTL::TaskGroup< Tp, Arg, MaxDepth >::task_count ( ) const

inlineprotected

Definition at line 264 of file TaskGroup.hh.

{ return m_tot_task_count; }

task_lock()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

lock_t & PTL::TaskGroup< Tp, Arg, MaxDepth >::task_lock ( )

inline

Definition at line 154 of file TaskGroup.hh.

{ return m_task_lock; }

this_tid()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

static tid_type PTL::TaskGroup< Tp, Arg, MaxDepth >::this_tid ( )

inlinestaticprotected

Definition at line 259 of file TaskGroup.hh.

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

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

wait()

template<typename Tp , typename Arg , intmax_t MaxDepth>

void PTL::TaskGroup< Tp, Arg, MaxDepth >::wait

(

)

Definition at line 344 of file TaskGroup.hh.

{
    auto _dtor = ScopeDestructor{ [&]() {
        if(m_tbb_task_group)
        {
            auto* _arena = m_pool->get_task_arena();
            _arena->execute([this]() { this->m_tbb_task_group->wait(); });
        }
    } };
 
    ThreadData* data = ThreadData::GetInstance();
    if(!data)
        return;
 
    // if no pool was initially present at creation
    if(!m_pool)
    {
        // check for master MT run-manager
        m_pool = internal::get_default_threadpool();
 
        // if 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;
        }
    }
 
    ThreadPool*     tpool = (m_pool) ? m_pool : data->thread_pool;
    VUserTaskQueue* taskq = (tpool) ? tpool->get_queue() : data->current_queue;
 
    bool _is_main     = data->is_main;
    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_main || 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)
            {
                if(!taskq->empty())
                {
                    auto _task = taskq->GetTask(bin);
                    if(_task)
                        (*_task)();
                }
            }
        }
    };
 
    // checks for validity
    if(!is_native_task_group())
    {
        // for external threads
        if(!_is_main || 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_main && 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().

wrap()

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

template<typename Func , typename... Args>

std::shared_ptr< task_type< Args... > > PTL::TaskGroup< Tp, Arg, MaxDepth >::wrap ( Func func, Args... args )

inline

Definition at line 186 of file TaskGroup.hh.

    {
        return operator+=(std::make_shared<task_type<Args...>>(
            is_native_task_group(), m_depth, std::move(func), std::move(args)...));
    }

Referenced by PTL::TaskManager::wrap(), and PTL::TaskManager::wrap().

Member Data Documentation

f_verbose

template<typename Tp , typename Arg , intmax_t MaxDepth>

int PTL::TaskGroup< Tp, Arg, MaxDepth >::f_verbose = GetEnv<int>("PTL_VERBOSE", 0)

staticprotected

Definition at line 267 of file TaskGroup.hh.

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

m_depth

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

intmax_t PTL::TaskGroup< Tp, Arg, MaxDepth >::m_depth = internal::get_task_depth()

protected

Definition at line 270 of file TaskGroup.hh.

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

m_future_list

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

future_list_t PTL::TaskGroup< Tp, Arg, MaxDepth >::m_future_list = {}

protected

Definition at line 279 of file TaskGroup.hh.

{};

Referenced by PTL::TaskGroup< Tp, Arg, MaxDepth >::begin(), PTL::TaskGroup< Tp, Arg, MaxDepth >::begin(), PTL::TaskGroup< Tp, Arg, MaxDepth >::cbegin(), PTL::TaskGroup< Tp, Arg, MaxDepth >::cend(), PTL::TaskGroup< Tp, Arg, MaxDepth >::end(), PTL::TaskGroup< Tp, Arg, MaxDepth >::end(), PTL::TaskGroup< Tp, Arg, MaxDepth >::get_tasks(), PTL::TaskGroup< Tp, Arg, MaxDepth >::get_tasks(), PTL::TaskGroup< Tp, Arg, MaxDepth >::rbegin(), PTL::TaskGroup< Tp, Arg, MaxDepth >::rbegin(), PTL::TaskGroup< Tp, Arg, MaxDepth >::rend(), PTL::TaskGroup< Tp, Arg, MaxDepth >::rend(), and PTL::TaskGroup< Tp, Arg, MaxDepth >::reserve().

m_id

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

uintmax_t PTL::TaskGroup< Tp, Arg, MaxDepth >::m_id = internal::task_group_counter()++

protected

Definition at line 269 of file TaskGroup.hh.

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

m_join

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

join_type PTL::TaskGroup< Tp, Arg, MaxDepth >::m_join {}

protected

Definition at line 275 of file TaskGroup.hh.

{};

m_main_tid

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

tid_type PTL::TaskGroup< Tp, Arg, MaxDepth >::m_main_tid = std::this_thread::get_id()

protected

Definition at line 271 of file TaskGroup.hh.

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

m_pool

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

ThreadPool* PTL::TaskGroup< Tp, Arg, MaxDepth >::m_pool = internal::get_default_threadpool()

protected

Definition at line 276 of file TaskGroup.hh.

Referenced by PTL::TaskGroup< Tp, Arg, MaxDepth >::pool(), PTL::TaskGroup< Tp, Arg, MaxDepth >::pool(), and PTL::TaskGroup< Tp, Arg, MaxDepth >::set_pool().

m_task_cond

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

condition_t PTL::TaskGroup< Tp, Arg, MaxDepth >::m_task_cond = {}

protected

Definition at line 274 of file TaskGroup.hh.

{};

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

m_task_list

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

task_list_t PTL::TaskGroup< Tp, Arg, MaxDepth >::m_task_list = {}

protected

Definition at line 278 of file TaskGroup.hh.

{};

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

m_task_lock

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

lock_t PTL::TaskGroup< Tp, Arg, MaxDepth >::m_task_lock = {}

protected

Definition at line 273 of file TaskGroup.hh.

{};

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

m_tbb_task_group

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

tbb_task_group_t* PTL::TaskGroup< Tp, Arg, MaxDepth >::m_tbb_task_group = nullptr

protected

Definition at line 277 of file TaskGroup.hh.

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

m_tot_task_count

template<typename Tp , typename Arg = Tp, intmax_t MaxDepth = 0>

atomic_int PTL::TaskGroup< Tp, Arg, MaxDepth >::m_tot_task_count { 0 }

protected

Definition at line 272 of file TaskGroup.hh.

{ 0 };

Referenced by PTL::TaskGroup< Tp, Arg, MaxDepth >::operator++(), PTL::TaskGroup< Tp, Arg, MaxDepth >::operator++(), PTL::TaskGroup< Tp, Arg, MaxDepth >::operator--(), PTL::TaskGroup< Tp, Arg, MaxDepth >::operator--(), PTL::TaskGroup< Tp, Arg, MaxDepth >::pending(), PTL::TaskGroup< Tp, Arg, MaxDepth >::size(), PTL::TaskGroup< Tp, Arg, MaxDepth >::task_count(), and PTL::TaskGroup< Tp, Arg, MaxDepth >::task_count().

---

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

• TaskGroup.hh