Geant4-11
Public Types | Public Member Functions | Static Public Member Functions | Protected Attributes | Static Private Member Functions
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.

242: m_pool(_pool)
243{
244 if(!fgInstance())
245 fgInstance() = this;
246}
PTL::TaskManager::fgInstance
static TaskManager *& fgInstance()
Definition: TaskManager.hh:210
PTL::TaskManager::m_pool
ThreadPool * m_pool
Definition: TaskManager.hh:196

References fgInstance().

◆ ~TaskManager()

PTL::TaskManager::~TaskManager ( )
inlinevirtual

Definition at line 250 of file TaskManager.hh.

251{
252 finalize();
253 if(fgInstance() == this)
254 fgInstance() = nullptr;
255}

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

112 {
113 typedef PackagedTask<RetT> task_type;
114
115 auto _ptask = std::make_shared<task_type>(std::forward<FuncT>(func));
116 m_pool->add_task(_ptask);
117 return _ptask;
118 }
PTL::ThreadPool::add_task
size_type add_task(task_pointer &&task, int bin=-1)
Definition: ThreadPool.hh:380

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.

101 {
102 typedef PackagedTask<RetT, Args...> task_type;
103
104 auto _ptask = std::make_shared<task_type>(std::forward<FuncT>(func),
105 std::forward<Args>(args)...);
106 m_pool->add_task(_ptask);
107 return _ptask;
108 }
args
static char ** args
Definition: G4Xt.cc:51

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.

123 {
124 using RetT = decay_t<decltype(func(args...))>;
125 typedef PackagedTask<RetT, Args...> task_type;
126
127 auto _ptask = std::make_shared<task_type>(std::forward<FuncT>(func),
128 std::forward<Args>(args)...);
129 m_pool->add_task(_ptask);
130 return _ptask;
131 }
PTL::decay_t
typename std::decay< T >::type decay_t
Definition: Globals.hh:68

◆ exec() [1/3]

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

Definition at line 91 of file TaskManager.hh.

92 {
93 m_pool->add_task(_task);
94 }

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.

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

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.

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

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

◆ fgInstance()

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

Definition at line 210 of file TaskManager.hh.

211{
212 static thread_local TaskManager* _instance = nullptr;
213 return _instance;
214}
PTL::TaskManager::TaskManager
TaskManager(ThreadPool *)
Definition: TaskManager.hh:241

Referenced by TaskManager().

◆ finalize()

void PTL::TaskManager::finalize ( )
inline

Definition at line 83 of file TaskManager.hh.

83{ m_pool->destroy_threadpool(); }
PTL::ThreadPool::destroy_threadpool
size_type destroy_threadpool()
Definition: ThreadPool.cc:364

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.

220{
221 if(!fgInstance())
222 {
223 auto nthreads = std::thread::hardware_concurrency();
224 std::cout << "Allocating mad::TaskManager with " << nthreads << " thread(s)..."
225 << std::endl;
226 new TaskManager(TaskRunManager::GetMasterRunManager()->GetThreadPool());
227 }
228 return fgInstance();
229}
PTL::TaskRunManager::GetMasterRunManager
static TaskRunManager * GetMasterRunManager(bool useTBB=false)
Definition: TaskRunManager.cc:49

References PTL::TaskRunManager::GetMasterRunManager().

◆ GetInstanceIfExists()

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

Definition at line 234 of file TaskManager.hh.

235{
236 return fgInstance();
237}

◆ ncores()

static unsigned PTL::TaskManager::ncores ( )
inlinestatic

Definition at line 70 of file TaskManager.hh.

70{ 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.

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

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.

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

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.

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

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.

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

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.

79{ return m_pool->size(); }
PTL::ThreadPool::size
size_type size() const
Definition: ThreadPool.hh:163

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

◆ thread_pool()

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

Definition at line 75 of file TaskManager.hh.

75{ 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.

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

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.

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

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:
Generated by doxygen 1.9.3