#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

Detailed Description

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

Definition at line 83 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 96 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 93 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 94 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 214 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 95 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 108 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 109 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 88 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 216 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 104 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 102 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 106 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 213 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 105 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 92 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 103 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 101 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 97 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 107 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 215 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 91 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 99 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 98 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 112 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 100 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 90 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 291 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 300 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 310 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();
}

Referenced by ~TaskGroup().

◆ 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 228 of file TaskGroup.hh.

228{ return m_future_list.begin(); }

PTL::TaskGroup::begin

itr_t begin()

Definition TaskGroup.hh:228

◆ 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 230 of file TaskGroup.hh.

230{ 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 232 of file TaskGroup.hh.

232{ 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 233 of file TaskGroup.hh.

233{ return m_future_list.end(); }

PTL::TaskGroup::end

itr_t end()

Definition TaskGroup.hh:229

◆ clear()

template<typename Tp, typename Arg, intmax_t MaxDepth>

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

Definition at line 709 of file TaskGroup.hh.

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

Referenced by clear(), join(), join(), and ~TaskGroup().

◆ 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 229 of file TaskGroup.hh.

229{ 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 231 of file TaskGroup.hh.

231{ 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 532 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 exec(), PTL::TaskManager::exec(), PTL::TaskManager::exec(), PTL::TaskManager::rexec(), PTL::TaskManager::rexec(), PTL::TaskManager::rexec(), PTL::TaskManager::rexec(), and 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 577 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 498 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();
        }
    } };
}

Referenced by get_scope_destructor().

◆ 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 222 of file TaskGroup.hh.

222{ 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 223 of file TaskGroup.hh.

223{ 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 159 of file TaskGroup.hh.

159{ 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 167 of file TaskGroup.hh.

167{ return this_tid() == m_main_tid; }

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

static tid_type this_tid()

Definition TaskGroup.hh:260

◆ 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 166 of file TaskGroup.hh.

166{ return (m_tbb_task_group) == nullptr; }

Referenced by wait(), and 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 676 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 655 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 join(), and join().

◆ 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 624 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);
}

Referenced by exec(), and local_exec().

◆ 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 640 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 515 of file TaskGroup.hh.

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

Referenced by notify().

◆ notify_all()

template<typename Tp, typename Arg, intmax_t MaxDepth>

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

Definition at line 523 of file TaskGroup.hh.

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

Referenced by 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 146 of file TaskGroup.hh.

146{ return ++(m_tot_task_count); }

Referenced by operator+=().

◆ 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 147 of file TaskGroup.hh.

147{ 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 333 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 operator+=(), and 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 148 of file TaskGroup.hh.

148{ 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 149 of file TaskGroup.hh.

149{ 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 170 of file TaskGroup.hh.

170{ return m_tot_task_count.load(); }

Referenced by wait().

◆ pool() [1/2]

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

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

inline

Definition at line 163 of file TaskGroup.hh.

163{ 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 164 of file TaskGroup.hh.

164{ 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 234 of file TaskGroup.hh.

234{ return m_future_list.rbegin(); }

PTL::TaskGroup::rbegin

ritr_t rbegin()

Definition TaskGroup.hh:234

◆ 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 236 of file TaskGroup.hh.

236{ 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 235 of file TaskGroup.hh.

235{ return m_future_list.rend(); }

PTL::TaskGroup::rend

ritr_t rend()

Definition TaskGroup.hh:235

◆ 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 237 of file TaskGroup.hh.

237{ 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 179 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 200 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 162 of file TaskGroup.hh.

162{ 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 172 of file TaskGroup.hh.

172{ 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 152 of file TaskGroup.hh.

152{ 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 156 of file TaskGroup.hh.

156{ return m_task_cond; }

Referenced by exec(), and get_scope_destructor().

◆ 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 264 of file TaskGroup.hh.

264{ return m_tot_task_count; }

Referenced by wait().

◆ 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 265 of file TaskGroup.hh.

265{ 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 155 of file TaskGroup.hh.

155{ return m_task_lock; }

Referenced by exec(), and get_scope_destructor().

◆ 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 260 of file TaskGroup.hh.

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

Referenced by is_main().

◆ wait()

template<typename Tp, typename Arg, intmax_t MaxDepth>

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

Definition at line 345 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 join(), join(), and wait().

◆ 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 187 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 exec(), PTL::TaskManager::wrap(), and PTL::TaskManager::wrap().

Member Data Documentation

◆ f_verbose

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

int PTL::TaskGroup< Tp, Arg, MaxDepth >::f_verbose

staticprotected

Definition at line 268 of file TaskGroup.hh.

Referenced by wait().

◆ 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 271 of file TaskGroup.hh.

◆ 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 280 of file TaskGroup.hh.

280{};

Referenced by clear(), join(), join(), and local_exec().

◆ 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 270 of file TaskGroup.hh.

◆ 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 276 of file TaskGroup.hh.

276{};

Referenced by join(), join(), TaskGroup(), and TaskGroup().

◆ 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 272 of file TaskGroup.hh.

◆ 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 277 of file TaskGroup.hh.

Referenced by exec(), TaskGroup(), wait(), and ~TaskGroup().

◆ 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 275 of file TaskGroup.hh.

275{};

Referenced by notify(), notify_all(), and wait().

◆ 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 279 of file TaskGroup.hh.

279{};

Referenced by clear(), join(), join(), and operator+=().

◆ 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 274 of file TaskGroup.hh.

274{};

Referenced by notify(), notify_all(), wait(), and ~TaskGroup().

◆ 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 278 of file TaskGroup.hh.

Referenced by exec(), wait(), and ~TaskGroup().

◆ 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 273 of file TaskGroup.hh.

273{ 0 };

Referenced by exec(), and get_scope_destructor().

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

TaskGroup.hh

Public Types

Public Member Functions

Static Public Member Functions

Protected Types

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Member Typedef Documentation

◆ ArgTp

◆ atomic_int

◆ atomic_uint

◆ citr_t

◆ condition_t

◆ const_iterator

◆ const_reverse_iterator

◆ container_type

◆ critr_t

◆ future_list_t

◆ future_type

◆ iterator

◆ itr_t

◆ join_type

◆ lock_t

◆ packaged_task_type

◆ promise_type

◆ result_type

◆ reverse_iterator

◆ ritr_t

◆ size_type

◆ task_list_t

◆ task_pointer

◆ task_type

◆ this_type

◆ tid_type

Constructor & Destructor Documentation

◆ TaskGroup() [1/4]

◆ TaskGroup() [2/4]

◆ ~TaskGroup()

◆ TaskGroup() [3/4]

◆ TaskGroup() [4/4]

Member Function Documentation

◆ begin() [1/2]

◆ begin() [2/2]

◆ cbegin()

◆ cend()

◆ clear()

◆ end() [1/2]

◆ end() [2/2]

◆ exec() [1/2]

◆ exec() [2/2]

◆ get_scope_destructor()

◆ get_tasks() [1/2]

◆ get_tasks() [2/2]

◆ id()

◆ is_main()

◆ is_native_task_group()

◆ join() [1/3]

◆ join() [2/3]

◆ join() [3/3]

◆ local_exec() [1/2]

◆ local_exec() [2/2]

◆ notify()

◆ notify_all()

◆ operator++() [1/2]

◆ operator++() [2/2]

◆ operator+=()

◆ operator--() [1/2]

◆ operator--() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ pending()

◆ pool() [1/2]

◆ pool() [2/2]

◆ rbegin() [1/2]

◆ rbegin() [2/2]

◆ rend() [1/2]

◆ rend() [2/2]

◆ reserve()