#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;
}

Referenced by GetInstance(), operator=(), operator=(), TaskManager(), and TaskManager().

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

Referenced by ~TaskManager().

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

Referenced by operator=().

◆ GetInstanceIfExists()

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

inlinestatic

Definition at line 251 of file TaskManager.hh.

{
    return fgInstance();
}

Referenced by operator=().

◆ ncores()

static unsigned PTL::TaskManager::ncores ( )

inlinestatic

Definition at line 68 of file TaskManager.hh.

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

Referenced by ncores().

◆ 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.

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

◆ thread_pool()

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

inline

Definition at line 73 of file TaskManager.hh.

73{ 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(), and TaskManager().

◆ m_pool

ThreadPool* PTL::TaskManager::m_pool = nullptr

protected

Definition at line 212 of file TaskManager.hh.

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

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

TaskManager.hh

Public Types

Public Member Functions

Static Public Member Functions

Protected Attributes

Detailed Description

Member Typedef Documentation

◆ size_type

◆ this_type

Constructor & Destructor Documentation

◆ TaskManager() [1/3]

◆ ~TaskManager()

◆ TaskManager() [2/3]

◆ TaskManager() [3/3]

Member Function Documentation

◆ async() [1/3]

◆ async() [2/3]

◆ async() [3/3]

◆ exec() [1/3]

◆ exec() [2/3]

◆ exec() [3/3]

◆ finalize()

◆ GetInstance()

◆ GetInstanceIfExists()

◆ ncores()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ rexec() [1/4]

◆ rexec() [2/4]

◆ rexec() [3/4]

◆ rexec() [4/4]

◆ size()

◆ thread_pool()

◆ wrap() [1/2]

◆ wrap() [2/2]

Member Data Documentation

◆ m_is_finalized

◆ m_pool