This class implements the interface to execute the same task multiple times, sequentially or in parallel depending on the execution policy passed as a first parameter on construction, and possibly with different arguments every time.

ROOT::Internal::TExecutor::Map

The two possible usages of the Map method are:

Map(F func, unsigned nTimes): func is executed nTimes with no arguments
Map(F func, T& args): func is executed on each element of the collection of arguments args

For either signature, func is executed as many times as needed by a pool of n workers; where n tipically defaults to the number of cores.
A collection containing the result of each execution is returned.
Note: the user is responsible for the deletion of any object that might be created upon execution of func, returned objects included. ROOT::::Internal::TExecutor never deletes what it returns, it simply forgets it.

Parameters

func	a callable object, such as a lambda expression, an std::function, a functor object or a function that takes zero arguments (for the first signature) or one (for the second signature).
args	a standard vector, a ROOT::TSeq of integer type or an initializer list for the second signature. An integer only for the first.

Note: in cases where the function to be executed takes more than zero/one argument but all are fixed except zero/one, the function can be wrapped in a lambda or via std::bind to give it the right signature.

Return value:

An std::vector. The elements in the container will be the objects returned by func.

ROOT::Internal::TExecutor::MapReduce

This set of methods behaves exactly like Map, but takes an additional function as a third argument. This function is applied to the set of objects returned by the corresponding Map execution to "squash" them into a single object. The signature of the reduce function should be (const std::vector<T>) -> T

An integer can be passed as the fourth argument indicating the number of chunks we want to divide our work in. (Note: Please be aware that chunking is only available when the policy is kMultiThread, ignoring this argument in other cases) This may be useful to avoid the overhead introduced when running really short tasks. In this case, the reduction function should be independent of the size of the vector returned by Map due to optimization of the number of chunks.

Examples:

root[] ROOT::Internal::TExecutor pool; auto ten = pool.MapReduce([]() { return 1; }, 10, [](const std::vector<int>
&v) { return std::accumulate(v.begin(), v.end(), 0); })
root[] ROOT::Internal::TExecutor
pool(ROOT::EExecutionPolicy::kMultiProcess); auto hist = pool.MapReduce(CreateAndFillHists, 10,
PoolUtils::ReduceObjects);

Definition at line 37 of file TExecutor.hxx.

Classes
struct	MapRetType
	Helper class to get the correct return type from the Map function, necessary to infer the ResolveExecutorAndMap function type. More...
struct	MapRetType< F, unsigned >

Public Member Functions
	TExecutor (const TExecutor &)=delete
	TExecutor (ROOT::EExecutionPolicy execPolicy, unsigned nWorkers=0)
	Class constructor.
	TExecutor (unsigned nWorkers=0)
	Class constructor.
unsigned	GetPoolSize () const
	Return the number of pooled workers.
auto	Map (F func, unsigned nTimes) -> std::vector< InvokeResult_t< F > >
	Execute a function without arguments several times.
template<class F, class T, class R, class Cond = validMapReturnCond<F, T>>
auto	MapReduce (F func, const std::vector< T > &args, R redfunc, unsigned nChunks) -> InvokeResult_t< F, T >
	Execute a function over the elements of an immutable vector (Map) and accumulate the results into a single value (Reduce).
template<class F, class INTEGER, class R, class Cond = validMapReturnCond<F, INTEGER>>
auto	MapReduce (F func, ROOT::TSeq< INTEGER > args, R redfunc, unsigned nChunks) -> InvokeResult_t< F, INTEGER >
	Execute a function over a sequence of indexes (Map) and accumulate the results into a single value (Reduce).
template<class F, class T, class R, class Cond = validMapReturnCond<F, T>>
auto	MapReduce (F func, std::initializer_list< T > args, R redfunc, unsigned nChunks) -> InvokeResult_t< F, T >
	Execute a function over the elements of an initializer_list (Map) and accumulate the results into a single value (Reduce).
template<class F, class T, class R, class Cond = validMapReturnCond<F, T>>
auto	MapReduce (F func, std::vector< T > &args, R redfunc, unsigned nChunks) -> InvokeResult_t< F, T >
	Execute a function over the elements of a vector (Map) and accumulate the results into a single value (Reduce).
template<class F, class R, class Cond = validMapReturnCond<F>>
auto	MapReduce (F func, unsigned nTimes, R redfunc, unsigned nChunks) -> InvokeResult_t< F >
	Execute a function nTimes (Map) and accumulate the results into a single value (Reduce).
auto	MapReduce (F func, unsigned nTimes, R redfunc) -> InvokeResult_t< F >
	Execute a function without arguments several times (Map) and accumulate the results into a single value (Reduce).
TExecutor &	operator= (const TExecutor &)=delete
ROOT::EExecutionPolicy	Policy () const
	Return the execution policy the executor is set to.
T *	Reduce (const std::vector< T * > &mergeObjs)
	"Reduce" an std::vector into a single object by using the object's Merge method.

Protected Types
using	InvokeResult_t
using	validMapReturnCond
	type definition used in templated functions for not allowing mapping functions that return references or void.

Private Types
using	Unused_t = ROOT::TSequentialExecutor

Private Member Functions
TExecutor &	Derived ()
template<class F, class T, class Cond = validMapReturnCond<F, T>>
auto	MapImpl (F func, const std::vector< T > &args) -> std::vector< InvokeResult_t< F, T > >
	Execute a function over the elements of an immutable vector.
template<class F, class INTEGER, class Cond = validMapReturnCond<F, INTEGER>>
auto	MapImpl (F func, ROOT::TSeq< INTEGER > args) -> std::vector< InvokeResult_t< F, INTEGER > >
	Execute a function over a sequence of indexes.
template<class F, class T, class Cond = validMapReturnCond<F, T>>
auto	MapImpl (F func, std::vector< T > &args) -> std::vector< InvokeResult_t< F, T > >
	Execute a function over the elements of a vector.
template<class F, class Cond = validMapReturnCond<F>>
auto	MapImpl (F func, unsigned nTimes) -> std::vector< InvokeResult_t< F > >
	Execute a function without arguments several times.
template<class F, class T>
auto	ResolveExecutorAndMap (F func, T &&args) -> std::vector< typename MapRetType< F, typename std::decay< T >::type >::type >
	Function called from Map to select and execute the correct Executor according to the set Execution Policy.

Private Attributes
ROOT::EExecutionPolicy	fExecPolicy
std::unique_ptr< ROOT::TProcessExecutor >	fProcessExecutor
std::unique_ptr< ROOT::TSequentialExecutor >	fSequentialExecutor
std::unique_ptr< ROOT::TThreadExecutor >	fThreadExecutor
friend	TExecutorCRTP

#include <ROOT/TExecutor.hxx>

Inheritance diagram for ROOT::Internal::TExecutor:

Member Typedef Documentation

◆ InvokeResult_t

using ROOT::TExecutorCRTP< TExecutor >::InvokeResult_t

protectedinherited

Definition at line 107 of file TExecutorCRTP.hxx.

◆ Unused_t

using ROOT::Internal::TExecutor::Unused_t = ROOT::TSequentialExecutor

private

Definition at line 101 of file TExecutor.hxx.

◆ validMapReturnCond

using ROOT::TExecutorCRTP< TExecutor >::validMapReturnCond

protectedinherited

type definition used in templated functions for not allowing mapping functions that return references or void.

The resulting vector elements must be assignable, references aren't.

Definition at line 112 of file TExecutorCRTP.hxx.

Constructor & Destructor Documentation

◆ TExecutor() [1/3]

ROOT::Internal::TExecutor::TExecutor ( unsigned nWorkers = 0 )

inlineexplicit

Class constructor.

Sets the default execution policy and initializes the corresponding executor. Defaults to multithreaded execution policy if ROOT is compiled with IMT=ON and IsImplicitMTEnabled. Otherwise it defaults to a serial execution policy

Parameters

nWorkers [optional] Number of parallel workers, only taken into account if the execution policy is kMultiThread

Definition at line 45 of file TExecutor.hxx.

◆ TExecutor() [2/3]

ROOT::Internal::TExecutor::TExecutor	(	ROOT::EExecutionPolicy	execPolicy,
		unsigned	nWorkers = 0 )

explicit

Class constructor.

Sets the execution policy and initializes the corresponding executor.

Parameters

execPolicy	Execution policy(kMultiThread, kMultiprocess, kSerial) to process the data
nWorkers	[optional] Number of parallel workers, only taken into account if the execution policy is kMultiThread

Definition at line 78 of file TExecutor.cxx.

◆ TExecutor() [3/3]

ROOT::Internal::TExecutor::TExecutor ( const TExecutor & )

delete

Member Function Documentation

◆ Derived()

TExecutor & ROOT::TExecutorCRTP< TExecutor >::Derived ( )

inlineprivateinherited

Definition at line 156 of file TExecutorCRTP.hxx.

◆ GetPoolSize()

unsigned ROOT::Internal::TExecutor::GetPoolSize ( ) const

inline

Return the number of pooled workers.

Returns: The number of workers in the pool in the executor used as a backend.

Definition at line 320 of file TExecutor.hxx.

◆ Map()

auto ROOT::TExecutorCRTP< TExecutor >::Map	(	F	func,
		unsigned	nTimes )-> std::vector< InvokeResult_t< F > >

inherited

Execute a function without arguments several times.

Parameters

func	Function to be executed.
nTimes	Number of times function should be called.

Returns: A vector with the results of the function calls. Functions that take arguments can be executed (with fixed arguments) by wrapping them in a lambda or with std::bind.

Definition at line 123 of file TExecutorCRTP.hxx.

◆ MapImpl() [1/4]

template<class F, class T, class Cond>

auto ROOT::Internal::TExecutor::MapImpl	(	F	func,
		const std::vector< T > &	args ) -> std::vector< InvokeResult_t< F, T > >

private

Execute a function over the elements of an immutable vector.

Implementation of the Map method.

Definition at line 195 of file TExecutor.hxx.

◆ MapImpl() [2/4]

template<class F, class INTEGER, class Cond>

auto ROOT::Internal::TExecutor::MapImpl	(	F	func,
		ROOT::TSeq< INTEGER >	args ) -> std::vector< InvokeResult_t< F, INTEGER > >

private

Execute a function over a sequence of indexes.

Implementation of the Map method.

Definition at line 173 of file TExecutor.hxx.

◆ MapImpl() [3/4]

template<class F, class T, class Cond>

auto ROOT::Internal::TExecutor::MapImpl	(	F	func,
		std::vector< T > &	args ) -> std::vector< InvokeResult_t< F, T > >

private

Execute a function over the elements of a vector.

Implementation of the Map method.

Definition at line 184 of file TExecutor.hxx.

◆ MapImpl() [4/4]

template<class F, class Cond>

auto ROOT::Internal::TExecutor::MapImpl	(	F	func,
		unsigned	nTimes ) -> std::vector< InvokeResult_t< F > >

private

Execute a function without arguments several times.

Implementation of the Map method.

Definition at line 162 of file TExecutor.hxx.

◆ MapReduce() [1/6]

template<class F, class T, class R, class Cond>

auto ROOT::Internal::TExecutor::MapReduce	(	F	func,
		const std::vector< T > &	args,
		R	redfunc,
		unsigned	nChunks ) -> InvokeResult_t< F, T >

Execute a function over the elements of an immutable vector (Map) and accumulate the results into a single value (Reduce).

Benefits from partial reduction into nChunks intermediate results if the execution policy is multithreaded. Otherwise, it ignores the nChunks argument and performs a normal MapReduce operation.

Parameters

func	Function to be executed. Must take an element of the sequence passed assecond argument as a parameter.
args	Immutable vector, whose elements are passed as an argument to func.
redfunc	Reduction function to combine the results of the calls to func into partial results, and these into a final result. Must return the same type as func and should be callable with const std::vector<T> where T is the output of func.
nChunks	Number of chunks to split the input data for processing.

Returns: A value result of "reducing" the vector returned by the Map operation into a single object.

Definition at line 305 of file TExecutor.hxx.

◆ MapReduce() [2/6]

template<class F, class INTEGER, class R, class Cond>

auto ROOT::Internal::TExecutor::MapReduce	(	F	func,
		ROOT::TSeq< INTEGER >	args,
		R	redfunc,
		unsigned	nChunks ) -> InvokeResult_t< F, INTEGER >

Execute a function over a sequence of indexes (Map) and accumulate the results into a single value (Reduce).

Benefits from partial reduction into nChunks intermediate results if the execution policy is multithreaded. Otherwise, it ignores the nChunks argument and performs a normal MapReduce operation.

Parameters

func	Function to be executed. Must take an element of the sequence passed assecond argument as a parameter.
args	Sequence of indexes to execute func on.
redfunc	Reduction function to combine the results of the calls to func into partial results, and these into a final result. Must return the same type as func and should be callable with std::vector<T> where T is the output of func.
nChunks	Number of chunks to split the input data for processing.

Returns: A value result of "reducing" the vector returned by the Map operation into a single object.

Definition at line 236 of file TExecutor.hxx.

◆ MapReduce() [3/6]

template<class F, class T, class R, class Cond>

auto ROOT::Internal::TExecutor::MapReduce	(	F	func,
		std::initializer_list< T >	args,
		R	redfunc,
		unsigned	nChunks ) -> InvokeResult_t< F, T >

Execute a function over the elements of an initializer_list (Map) and accumulate the results into a single value (Reduce).

Benefits from partial reduction into nChunks intermediate results if the execution policy is multithreaded. Otherwise, it ignores the nChunks argument and performs a normal MapReduce operation.

Parameters

func	Function to be executed. Must take an element of the sequence passed as second argument as a parameter.
args	initializer_list for a vector to apply func on.
redfunc	Reduction function to combine the results of the calls to func into partial results, and these into a final result. Must return the same type as func and should be callable with const std::vector<T> where T is the output of func.
nChunks	Number of chunks to split the input data for processing.

Returns: A value result of "reducing" the vector returned by the Map operation into a single object.

Definition at line 259 of file TExecutor.hxx.

◆ MapReduce() [4/6]

template<class F, class T, class R, class Cond>

auto ROOT::Internal::TExecutor::MapReduce	(	F	func,
		std::vector< T > &	args,
		R	redfunc,
		unsigned	nChunks ) -> InvokeResult_t< F, T >

Execute a function over the elements of a vector (Map) and accumulate the results into a single value (Reduce).

Benefits from partial reduction into nChunks intermediate results if the execution policy is multithreaded. Otherwise, it ignores the nChunks argument and performs a normal MapReduce operation.

Parameters

func	Function to be executed. Must take an element of the sequence passed assecond argument as a parameter.
args	Vector of elements passed as an argument to func.
redfunc	Reduction function to combine the results of the calls to func into partial results, and these into a final result. Must return the same type as func and should be callable with const std::vector<T> where T is the output of func.
nChunks	Number of chunks to split the input data for processing.

Returns: A value result of "reducing" the vector returned by the Map operation into a single object.

Definition at line 282 of file TExecutor.hxx.

◆ MapReduce() [5/6]

template<class F, class R, class Cond>

auto ROOT::Internal::TExecutor::MapReduce	(	F	func,
		unsigned	nTimes,
		R	redfunc,
		unsigned	nChunks ) -> InvokeResult_t< F >

Execute a function nTimes (Map) and accumulate the results into a single value (Reduce).

Benefits from partial reduction into nChunks intermediate results if the execution policy is multithreaded. Otherwise, it ignores the nChunks argument and performs a normal MapReduce operation.

Parameters

func	Function to be executed. Must take an element of the sequence passed as second argument as a parameter.
nTimes	Number of times function should be called.
redfunc	Reduction function to combine the results of the calls to func into partial results, and these into a final result. Must return the same type as func and should be callable with const std::vector<T> where T is the output of func.
nChunks	Number of chunks to split the input data for processing.

Returns: A value result of "reducing" the vector returned by the Map operation into a single object.

Definition at line 213 of file TExecutor.hxx.

◆ MapReduce() [6/6]

auto ROOT::TExecutorCRTP< TExecutor >::MapReduce	(	F	func,
		unsigned	nTimes,
		R	redfunc )-> InvokeResult_t< F >

inherited

Execute a function without arguments several times (Map) and accumulate the results into a single value (Reduce).

Parameters

func	Function to be executed.
nTimes	Number of times function should be called.

Returns: A vector with the results of the function calls.

Parameters

redfunc Reduction function to combine the results of the calls to func. Must return the same type as func.

Returns: A value result of "reducing" the vector returned by the Map operation into a single object.

Definition at line 137 of file TExecutorCRTP.hxx.

◆ operator=()

TExecutor & ROOT::Internal::TExecutor::operator= ( const TExecutor & )

delete

◆ Policy()

ROOT::EExecutionPolicy ROOT::Internal::TExecutor::Policy ( ) const

inline

Return the execution policy the executor is set to.

Definition at line 57 of file TExecutor.hxx.

◆ Reduce()

T * ROOT::TExecutorCRTP< TExecutor >::Reduce ( const std::vector< T * > & mergeObjs )

inherited

"Reduce" an std::vector into a single object by using the object's Merge method.

Parameters

mergeObjs A vector of ROOT objects implementing the Merge method

Returns: An object result of merging the vector elements into one.

Definition at line 151 of file TExecutorCRTP.hxx.

◆ ResolveExecutorAndMap()

template<class F, class T>

auto ROOT::Internal::TExecutor::ResolveExecutorAndMap	(	F	func,
		T &&	args ) -> std::vector< typename MapRetType< F, typename std::decay< T >::type >::type >

inlineprivate

Function called from Map to select and execute the correct Executor according to the set Execution Policy.

Definition at line 136 of file TExecutor.hxx.

Member Data Documentation

◆ fExecPolicy

ROOT::EExecutionPolicy ROOT::Internal::TExecutor::fExecPolicy

private

Definition at line 97 of file TExecutor.hxx.

◆ fProcessExecutor

std::unique_ptr< ROOT::TProcessExecutor > ROOT::Internal::TExecutor::fProcessExecutor

private

Definition at line 114 of file TExecutor.hxx.

◆ fSequentialExecutor

std::unique_ptr<ROOT::TSequentialExecutor> ROOT::Internal::TExecutor::fSequentialExecutor

private

Definition at line 115 of file TExecutor.hxx.

◆ fThreadExecutor

std::unique_ptr< ROOT::TThreadExecutor > ROOT::Internal::TExecutor::fThreadExecutor

private

Definition at line 113 of file TExecutor.hxx.

◆ TExecutorCRTP

friend ROOT::Internal::TExecutor::TExecutorCRTP

private

Definition at line 38 of file TExecutor.hxx.

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

core/imt/inc/ROOT/TExecutor.hxx
core/imt/src/TExecutor.cxx

ROOT::Internal::TExecutor::Map

Return value:

ROOT::Internal::TExecutor::MapReduce

Examples:

Classes

Public Member Functions

Protected Types

Private Types

Private Member Functions

Private Attributes

Member Typedef Documentation

◆ InvokeResult_t

◆ Unused_t

◆ validMapReturnCond

Constructor & Destructor Documentation

◆ TExecutor() [1/3]

◆ TExecutor() [2/3]

◆ TExecutor() [3/3]

Member Function Documentation

◆ Derived()

◆ GetPoolSize()

◆ Map()

◆ MapImpl() [1/4]

◆ MapImpl() [2/4]

◆ MapImpl() [3/4]

◆ MapImpl() [4/4]

◆ MapReduce() [1/6]

◆ MapReduce() [2/6]

◆ MapReduce() [3/6]

◆ MapReduce() [4/6]

◆ MapReduce() [5/6]

◆ MapReduce() [6/6]

◆ operator=()

◆ Policy()

◆ Reduce()

◆ ResolveExecutorAndMap()

Member Data Documentation

◆ fExecPolicy

◆ fProcessExecutor

◆ fSequentialExecutor

◆ fThreadExecutor

◆ TExecutorCRTP