PTL::TaskManager Class Reference

#include <TaskManager.hh>

Public Types
typedef ThreadPool::size_type	size_type
typedef TaskManager	this_type

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

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

Protected Attributes
ThreadPool *	m_pool = nullptr

Static Private Member Functions
static TaskManager *&	fgInstance ()

Detailed Description

Definition at line 50 of file TaskManager.hh.

Member Typedef Documentation

size_type

typedef ThreadPool::size_type PTL::TaskManager::size_type

Definition at line 54 of file TaskManager.hh.

this_type

typedef TaskManager PTL::TaskManager::this_type

Definition at line 53 of file TaskManager.hh.

Constructor & Destructor Documentation

TaskManager() [1/3]

PTL::TaskManager::TaskManager ( ThreadPool *  _pool )

inlineexplicit

Definition at line 241 of file TaskManager.hh.

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

References fgInstance().

~TaskManager()

PTL::TaskManager::~TaskManager ( )

inlinevirtual

Definition at line 250 of file TaskManager.hh.

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

TaskManager() [2/3]

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

delete

TaskManager() [3/3]

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

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 111 of file TaskManager.hh.

    {
        typedef PackagedTask<RetT> task_type;
 
        auto _ptask = std::make_shared<task_type>(std::forward<FuncT>(func));
        m_pool->add_task(_ptask);
        return _ptask;
    }

References PTL::ThreadPool::add_task(), and m_pool.

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 100 of file TaskManager.hh.

    {
        typedef PackagedTask<RetT, Args...> task_type;
 
        auto _ptask = std::make_shared<task_type>(std::forward<FuncT>(func),
                                                  std::forward<Args>(args)...);
        m_pool->add_task(_ptask);
        return _ptask;
    }

References PTL::ThreadPool::add_task(), args, and m_pool.

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 121 of file TaskManager.hh.

    {
        using RetT = decay_t<decltype(func(args...))>;
        typedef PackagedTask<RetT, Args...> task_type;
 
        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 91 of file TaskManager.hh.

    {
        m_pool->add_task(_task);
    }

References PTL::ThreadPool::add_task(), and m_pool.

exec() [2/3]

template<typename RetT , typename ArgT , typename FuncT >

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

inline

Definition at line 162 of file TaskManager.hh.

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

References PTL::TaskGroup< Tp, Arg, MaxDepth >::exec().

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 156 of file TaskManager.hh.

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

References args, and PTL::TaskGroup< Tp, Arg, MaxDepth >::exec().

fgInstance()

PTL::TaskManager *& PTL::TaskManager::fgInstance ( )

inlinestaticprivate

Definition at line 210 of file TaskManager.hh.

{
    static thread_local TaskManager* _instance = nullptr;
    return _instance;
}

Referenced by TaskManager().

finalize()

void PTL::TaskManager::finalize ( )

inline

Definition at line 83 of file TaskManager.hh.

{ m_pool->destroy_threadpool(); }

References PTL::ThreadPool::destroy_threadpool(), and m_pool.

GetInstance()

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

inlinestatic

get the singleton pointer

Definition at line 219 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();
}

References PTL::TaskRunManager::GetMasterRunManager().

GetInstanceIfExists()

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

inlinestatic

Definition at line 234 of file TaskManager.hh.

{
    return fgInstance();
}

ncores()

static unsigned PTL::TaskManager::ncores ( )

inlinestatic

Definition at line 70 of file TaskManager.hh.

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

operator=() [1/2]

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

delete

operator=() [2/2]

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

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 174 of file TaskManager.hh.

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

References PTL::TaskGroup< Tp, Arg, MaxDepth >::exec().

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 168 of file TaskManager.hh.

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

References args, and PTL::TaskGroup< Tp, Arg, MaxDepth >::exec().

rexec() [3/4]

template<typename FuncT >

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

inline

Definition at line 188 of file TaskManager.hh.

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

References PTL::TaskGroup< Tp, Arg, MaxDepth >::exec().

rexec() [4/4]

template<typename FuncT , typename... Args>

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

inline

Definition at line 182 of file TaskManager.hh.

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

References args, and PTL::TaskGroup< Tp, Arg, MaxDepth >::exec().

size()

size_type PTL::TaskManager::size ( ) const

inline

Definition at line 79 of file TaskManager.hh.

{ return m_pool->size(); }

References m_pool, and PTL::ThreadPool::size().

thread_pool()

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

inline

Definition at line 75 of file TaskManager.hh.

{ return m_pool; }

References 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 146 of file TaskManager.hh.

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

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

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 139 of file TaskManager.hh.

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

References args, and PTL::TaskGroup< Tp, Arg, MaxDepth >::wrap().

Field Documentation

m_pool

ThreadPool* PTL::TaskManager::m_pool = nullptr

protected

Definition at line 196 of file TaskManager.hh.

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

---

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

• source/externals/ptl/include/PTL/TaskManager.hh