PTL::TaskManager Class Reference

#include <TaskManager.hh>

Public Types
using	this_type = TaskManager
using	size_type = ThreadPool::size_type

Public Member Functions
	TaskManager (ThreadPool *, bool _manage_pool=true)
virtual	~TaskManager () noexcept(false)
	TaskManager (const TaskManager &)=delete
	TaskManager (TaskManager &&)=default
TaskManager &	operator= (const TaskManager &)=delete
TaskManager &	operator= (TaskManager &&)=default
ThreadPool *	thread_pool () const
size_type	size () const
void	finalize ()
template<typename... Args>
void	exec (Task< Args... > *_task)
template<typename RetT , typename FuncT , typename... Args>
std::shared_ptr< PackagedTask< RetT, Args... > >	async (FuncT &&func, Args &&... args)
template<typename RetT , typename FuncT >
std::shared_ptr< PackagedTask< RetT > >	async (FuncT &&func)
template<typename FuncT , typename... Args>
auto	async (FuncT &&func, Args... args) -> std::shared_ptr< PackagedTask< decay_t< decltype(func(args...))>, Args... > >
template<typename RetT , typename ArgT , typename FuncT , typename... Args>
std::shared_ptr< Task< RetT, ArgT, Args... > >	wrap (TaskGroup< RetT, ArgT > &tg, FuncT &&func, Args &&... args)
template<typename RetT , typename ArgT , typename FuncT >
std::shared_ptr< Task< RetT, ArgT > >	wrap (TaskGroup< RetT, ArgT > &tg, FuncT &&func)
template<typename RetT , typename ArgT , typename FuncT , typename... Args>
void	exec (TaskGroup< RetT, ArgT > &tg, FuncT &&func, Args &&... args)
template<typename RetT , typename ArgT , typename FuncT >
void	exec (TaskGroup< RetT, ArgT > &tg, FuncT &&func)
template<typename RetT , typename ArgT , typename FuncT , typename... Args>
void	rexec (TaskGroup< RetT, ArgT > &tg, FuncT &&func, Args &&... args)
template<typename RetT , typename ArgT , typename FuncT >
void	rexec (TaskGroup< RetT, ArgT > &tg, FuncT &&func)
template<typename FuncT , typename... Args>
void	rexec (TaskGroup< void, void > &tg, FuncT &&func, Args &&... args)
template<typename FuncT >
void	rexec (TaskGroup< void, void > &tg, FuncT &&func)

Static Public Member Functions
static TaskManager *	GetInstance ()
	get the singleton pointer
static TaskManager *	GetInstanceIfExists ()
static unsigned	ncores ()

Protected Attributes
ThreadPool *	m_pool = nullptr
bool	m_is_finalized = false

Detailed Description

Definition at line 48 of file TaskManager.hh.

Member Typedef Documentation

size_type

using PTL::TaskManager::size_type = ThreadPool::size_type

Definition at line 52 of file TaskManager.hh.

this_type

using PTL::TaskManager::this_type = TaskManager

Definition at line 51 of file TaskManager.hh.

Constructor & Destructor Documentation

TaskManager() [1/3]

PTL::TaskManager::TaskManager ( ThreadPool *  _pool, bool  _manage_pool = true  )

inlineexplicit

Definition at line 258 of file TaskManager.hh.

: m_pool(_pool)
, m_is_finalized(!_manage_pool)
{
    if(!fgInstance())
        fgInstance() = this;
}

~TaskManager()

PTL::TaskManager::~TaskManager ( )

inlinevirtual

Definition at line 268 of file TaskManager.hh.

{
    finalize();
    if(fgInstance() == this)
        fgInstance() = nullptr;
}

TaskManager() [2/3]

PTL::TaskManager::TaskManager ( const TaskManager &  )

delete

TaskManager() [3/3]

PTL::TaskManager::TaskManager ( TaskManager &&  )

default

Member Function Documentation

async() [1/3]

template<typename RetT , typename FuncT >

std::shared_ptr< PackagedTask< RetT > > PTL::TaskManager::async ( FuncT &&  func )

inline

Definition at line 121 of file TaskManager.hh.

    {
        using task_type = PackagedTask<RetT>;
 
        if(!m_pool)
            throw std::runtime_error("Nullptr to thread-pool");
 
        auto _ptask = std::make_shared<task_type>(std::forward<FuncT>(func));
        m_pool->add_task(_ptask);
        return _ptask;
    }

async() [2/3]

template<typename RetT , typename FuncT , typename... Args>

std::shared_ptr< PackagedTask< RetT, Args... > > PTL::TaskManager::async ( FuncT &&  func, Args &&...  args  )

inline

Definition at line 107 of file TaskManager.hh.

    {
        using task_type = PackagedTask<RetT, Args...>;
 
        if(!m_pool)
            throw std::runtime_error("Nullptr to thread-pool");
 
        auto _ptask = std::make_shared<task_type>(std::forward<FuncT>(func),
                                                  std::forward<Args>(args)...);
        m_pool->add_task(_ptask);
        return _ptask;
    }

Referenced by G4TaskRunManagerKernel::ExecuteWorkerInit(), G4TaskRunManagerKernel::ExecuteWorkerTask(), and G4TaskRunManagerKernel::InitializeWorker().

async() [3/3]

template<typename FuncT , typename... Args>

auto PTL::TaskManager::async ( FuncT &&  func, Args...  args  ) -> std::shared_ptr<PackagedTask<decay_t<decltype(func(args...))>, Args...>>

inline

Definition at line 134 of file TaskManager.hh.

    {
        using RetT      = decay_t<decltype(func(args...))>;
        using task_type = PackagedTask<RetT, Args...>;
 
        if(!m_pool)
            throw std::runtime_error("Nullptr to thread-pool");
 
        auto _ptask = std::make_shared<task_type>(std::forward<FuncT>(func),
                                                  std::forward<Args>(args)...);
        m_pool->add_task(_ptask);
        return _ptask;
    }

exec() [1/3]

template<typename... Args>

void PTL::TaskManager::exec ( Task< Args... > *  _task )

inline

Definition at line 96 of file TaskManager.hh.

    {
        if(!m_pool)
            throw std::runtime_error("Nullptr to thread-pool");
        m_pool->add_task(_task);
    }

exec() [2/3]

template<typename RetT , typename ArgT , typename FuncT >

void PTL::TaskManager::exec ( TaskGroup< RetT, ArgT > &  tg, FuncT &&  func  )

inline

Definition at line 178 of file TaskManager.hh.

    {
        tg.exec(std::forward<FuncT>(func));
    }

exec() [3/3]

template<typename RetT , typename ArgT , typename FuncT , typename... Args>

void PTL::TaskManager::exec ( TaskGroup< RetT, ArgT > &  tg, FuncT &&  func, Args &&...  args  )

inline

Definition at line 172 of file TaskManager.hh.

    {
        tg.exec(std::forward<FuncT>(func), std::forward<Args>(args)...);
    }

finalize()

void PTL::TaskManager::finalize ( )

inline

Definition at line 81 of file TaskManager.hh.

    {
        if(m_is_finalized)
            return;
        m_is_finalized = true;
        if(m_pool)
            m_pool->destroy_threadpool();
    }

GetInstance()

PTL::TaskManager * PTL::TaskManager::GetInstance ( )

inlinestatic

get the singleton pointer

Definition at line 236 of file TaskManager.hh.

{
    if(!fgInstance())
    {
        auto nthreads = std::thread::hardware_concurrency();
        std::cout << "Allocating mad::TaskManager with " << nthreads << " thread(s)..."
                  << std::endl;
        new TaskManager(TaskRunManager::GetMasterRunManager()->GetThreadPool());
    }
    return fgInstance();
}

GetInstanceIfExists()

PTL::TaskManager * PTL::TaskManager::GetInstanceIfExists ( )

inlinestatic

Definition at line 251 of file TaskManager.hh.

{
    return fgInstance();
}

ncores()

static unsigned PTL::TaskManager::ncores ( )

inlinestatic

Definition at line 68 of file TaskManager.hh.

{ return std::thread::hardware_concurrency(); }

operator=() [1/2]

TaskManager & PTL::TaskManager::operator= ( const TaskManager &  )

delete

operator=() [2/2]

TaskManager & PTL::TaskManager::operator= ( TaskManager &&  )

default

rexec() [1/4]

template<typename RetT , typename ArgT , typename FuncT >

void PTL::TaskManager::rexec ( TaskGroup< RetT, ArgT > &  tg, FuncT &&  func  )

inline

Definition at line 190 of file TaskManager.hh.

    {
        tg.exec(std::forward<FuncT>(func));
    }

rexec() [2/4]

template<typename RetT , typename ArgT , typename FuncT , typename... Args>

void PTL::TaskManager::rexec ( TaskGroup< RetT, ArgT > &  tg, FuncT &&  func, Args &&...  args  )

inline

Definition at line 184 of file TaskManager.hh.

    {
        tg.exec(std::forward<FuncT>(func), std::forward<Args>(args)...);
    }

rexec() [3/4]

template<typename FuncT >

void PTL::TaskManager::rexec ( TaskGroup< void, void > &  tg, FuncT &&  func  )

inline

Definition at line 204 of file TaskManager.hh.

    {
        tg.exec(std::forward<FuncT>(func));
    }

rexec() [4/4]

template<typename FuncT , typename... Args>

void PTL::TaskManager::rexec ( TaskGroup< void, void > &  tg, FuncT &&  func, Args &&...  args  )

inline

Definition at line 198 of file TaskManager.hh.

    {
        tg.exec(std::forward<FuncT>(func), std::forward<Args>(args)...);
    }

size()

size_type PTL::TaskManager::size ( ) const

inline

Definition at line 77 of file TaskManager.hh.

{ return (m_pool) ? m_pool->size() : 0; }

thread_pool()

ThreadPool * PTL::TaskManager::thread_pool ( ) const

inline

Definition at line 73 of file TaskManager.hh.

{ return m_pool; }

wrap() [1/2]

template<typename RetT , typename ArgT , typename FuncT >

std::shared_ptr< Task< RetT, ArgT > > PTL::TaskManager::wrap ( TaskGroup< RetT, ArgT > &  tg, FuncT &&  func  )

inline

Definition at line 162 of file TaskManager.hh.

    {
        return tg.wrap(std::forward<FuncT>(func));
    }

wrap() [2/2]

template<typename RetT , typename ArgT , typename FuncT , typename... Args>

std::shared_ptr< Task< RetT, ArgT, Args... > > PTL::TaskManager::wrap ( TaskGroup< RetT, ArgT > &  tg, FuncT &&  func, Args &&...  args  )

inline

Definition at line 155 of file TaskManager.hh.

    {
        return tg.wrap(std::forward<FuncT>(func), std::forward<Args>(args)...);
    }

Member Data Documentation

m_is_finalized

bool PTL::TaskManager::m_is_finalized = false

protected

Definition at line 213 of file TaskManager.hh.

Referenced by finalize().

m_pool

ThreadPool* PTL::TaskManager::m_pool = nullptr

protected

Definition at line 212 of file TaskManager.hh.

Referenced by async(), exec(), finalize(), size(), and thread_pool().

---

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

• TaskManager.hh