Logo ROOT  
Reference Guide
ROOT::TExecutorCRTP< SubC > Class Template Reference

template<class SubC>
class ROOT::TExecutorCRTP< SubC >

This class defines an interface to execute the same task multiple times, possibly in parallel and with different arguments every time.

ROOT::TExecutorCRTP<SubC>::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

The Map function forwards the call to MapImpl, to be implemented by the child classes.

For either signature, func is executed as many times as needed by a pool of n workers, where n typically defaults to the number of available 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::TExecutorCRTP derived classes never delete what they return, they simply forget it.

Parameters
funca 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).
argsa 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. The ordering of the elements corresponds to the ordering of the arguments.

ROOT::TExecutorCRTP<SubC>::Reduce

These set of methods combine all elements from a std::vector into a single value.

Parameters
redfunca callable object, such as a lambda expression, an std::function, a functor object or a function that takes an std::vector and combines all its elements into a single result.
[args]a standard vector

ROOT::TExecutorCRTP<SubC>::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. This function should be independent of the size of the vector returned by Map due to optimization of the number of chunks.

Examples:

Generate 1 ten times and sum those tens
root[] ROOT::TProcessExecutor pool; auto ten = pool.MapReduce([]() { return 1; }, 10, [](const std::vector<int> &v) { return std::accumulate(v.begin(), v.end(), 0); })
root[] ROOT::TProcessExecutor pool; auto tenOnes = pool.Map([]() { return 1; }, 10); auto ten = Reduce([](const std::vector<int> &v) { return std::accumulate(v.begin(), v.end(), 0); }, tenOnes)
Create 10 histograms and merge them into one
root[] ROOT::TThreadExecutor pool; auto hist = pool.MapReduce(CreateAndFillHists, 10, PoolUtils::ReduceObjects);
Merge collection of TObjects.
Definition: PoolUtils.h:35
auto Map(F func, unsigned nTimes) -> std::vector< InvokeResult_t< F > >
Execute a function without arguments several times.
T * Reduce(const std::vector< T * > &mergeObjs)
"Reduce" an std::vector into a single object by using the object's Merge method.
This class provides a simple interface to execute the same task multiple times in parallel,...
auto MapReduce(F func, unsigned nTimes, R redfunc) -> InvokeResult_t< F >
Execute a function nTimes in parallel (Map) and accumulate the results into a single value (Reduce).
This class provides a simple interface to execute the same task multiple times in parallel threads,...
auto MapReduce(F func, unsigned nTimes, R redfunc) -> InvokeResult_t< F >
Execute a function nTimes in parallel (Map) and accumulate the results into a single value (Reduce).

Definition at line 103 of file TExecutorCRTP.hxx.

Public Types

template<class F , class... T>
using noReferenceCond = std::enable_if_t<"Function can't return a reference" &&!std::is_reference< InvokeResult_t< F, T... > >::value >
 type definition in used in templated functions for not allowing mapping functions that return references. More...
 

Public Member Functions

 TExecutorCRTP ()=default
 
 TExecutorCRTP (const TExecutorCRTP &)=delete
 
template<class F , class T , class Cond = noReferenceCond<F, T>>
auto Map (F func, const std::vector< T > &args) -> std::vector< InvokeResult_t< F, T > >
 Execute a function over the elements of an immutable vector. More...
 
template<class F , class INTEGER , class Cond = noReferenceCond<F, INTEGER>>
auto Map (F func, ROOT::TSeq< INTEGER > args) -> std::vector< InvokeResult_t< F, INTEGER > >
 Execute a function over a sequence of indexes. More...
 
template<class F , class T , class Cond = noReferenceCond<F, T>>
auto Map (F func, std::initializer_list< T > args) -> std::vector< InvokeResult_t< F, T > >
 Execute a function over the elements of an initializer_list. More...
 
template<class F , class T , class Cond = noReferenceCond<F, T>>
auto Map (F func, std::vector< T > &args) -> std::vector< InvokeResult_t< F, T > >
 Execute a function over the elements of a vector. More...
 
template<class F , class Cond = noReferenceCond<F>>
auto Map (F func, unsigned nTimes) -> std::vector< InvokeResult_t< F > >
 Execute a function without arguments several times. More...
 
template<class F , class T , class Cond = noReferenceCond<F, T>>
T * MapReduce (F func, const std::vector< T * > &args)
 Execute a function over the TObject-inheriting elements of an immutable vector (Map) and merge the objects into a single one (Reduce). More...
 
template<class F , class T , class R , class Cond = noReferenceCond<F, T>>
auto MapReduce (F func, const std::vector< T > &args, R redfunc) -> InvokeResult_t< F, T >
 Execute a function over the elements of an immutable vector (Map) and accumulate the results into a single value (Reduce). More...
 
template<class F , class INTEGER , class R , class Cond = noReferenceCond<F, INTEGER>>
auto MapReduce (F func, ROOT::TSeq< INTEGER > args, R redfunc) -> InvokeResult_t< F, INTEGER >
 Execute a function over a sequence of indexes (Map) and accumulate the results into a single value (Reduce). More...
 
template<class F , class T , class R , class Cond = noReferenceCond<F, T>>
auto MapReduce (F func, std::initializer_list< T > args, R redfunc) -> InvokeResult_t< F, T >
 Execute a function over the elements of an initializer_list (Map) and accumulate the results into a single value (Reduce). More...
 
template<class F , class T , class Cond = noReferenceCond<F, T>>
T * MapReduce (F func, std::vector< T * > &args)
 Execute a function over the TObject-inheriting elements of a vector (Map) and merge the objects into a single one (Reduce). More...
 
template<class F , class T , class R , class Cond = noReferenceCond<F, T>>
auto MapReduce (F func, std::vector< T > &args, R redfunc) -> InvokeResult_t< F, T >
 Execute a function over the elements of a vector (Map) and accumulate the results into a single value (Reduce). More...
 
template<class F , class R , class Cond = noReferenceCond<F>>
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). More...
 
TExecutorCRTPoperator= (const TExecutorCRTP &)=delete
 
template<class T >
T * Reduce (const std::vector< T * > &mergeObjs)
 "Reduce" an std::vector into a single object by using the object's Merge method. More...
 
template<class T , class R >
auto Reduce (const std::vector< T > &objs, R redfunc) -> decltype(redfunc(objs))
 "Reduce" an std::vector into a single object by passing a function as the second argument defining the reduction operation. More...
 

Private Types

template<typename F , typename... Args>
using InvokeResult_t = ROOT::TypeTraits::InvokeResult_t< F, Args... >
 

Private Member Functions

SubC & Derived ()
 
template<class F , class T , class Cond = noReferenceCond<F, T>>
auto MapImpl (F func, const std::vector< T > &args) -> std::vector< InvokeResult_t< F, T > >=delete
 Implementation of the Map method, left to the derived classes. More...
 
template<class F , class INTEGER , class Cond = noReferenceCond<F, INTEGER>>
auto MapImpl (F func, ROOT::TSeq< INTEGER > args) -> std::vector< InvokeResult_t< F, INTEGER > >=delete
 Implementation of the Map method, left to the derived classes. More...
 
template<class F , class T , class Cond = noReferenceCond<F, T>>
auto MapImpl (F func, std::vector< T > &args) -> std::vector< InvokeResult_t< F, T > >=delete
 Implementation of the Map method, left to the derived classes. More...
 
template<class F , class Cond = noReferenceCond<F>>
auto MapImpl (F func, unsigned nTimes) -> std::vector< InvokeResult_t< F > >=delete
 Implementation of the Map method, left to the derived classes. More...
 

#include <ROOT/TExecutorCRTP.hxx>

Member Typedef Documentation

◆ InvokeResult_t

template<class SubC >
template<typename F , typename... Args>
using ROOT::TExecutorCRTP< SubC >::InvokeResult_t = ROOT::TypeTraits::InvokeResult_t<F, Args...>
private

Definition at line 106 of file TExecutorCRTP.hxx.

◆ noReferenceCond

template<class SubC >
template<class F , class... T>
using ROOT::TExecutorCRTP< SubC >::noReferenceCond = std::enable_if_t<"Function can't return a reference" && !std::is_reference<InvokeResult_t<F, T...> >::value>

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

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

Definition at line 116 of file TExecutorCRTP.hxx.

Constructor & Destructor Documentation

◆ TExecutorCRTP() [1/2]

template<class SubC >
ROOT::TExecutorCRTP< SubC >::TExecutorCRTP ( )
default

◆ TExecutorCRTP() [2/2]

template<class SubC >
ROOT::TExecutorCRTP< SubC >::TExecutorCRTP ( const TExecutorCRTP< SubC > &  )
delete

Member Function Documentation

◆ Derived()

template<class SubC >
SubC & ROOT::TExecutorCRTP< SubC >::Derived ( )
inlineprivate

Definition at line 155 of file TExecutorCRTP.hxx.

◆ Map() [1/5]

template<class SubC >
template<class F , class T , class Cond >
auto ROOT::TExecutorCRTP< SubC >::Map ( F  func,
const std::vector< T > &  args 
) -> std::vector<InvokeResult_t<F, T>>

Execute a function over the elements of an immutable vector.

Parameters
funcFunction to be executed on the elements of the vector passed as second parameter.
argsVector of elements passed as an argument to func.
Returns
A vector with the results of the function calls.

Definition at line 239 of file TExecutorCRTP.hxx.

◆ Map() [2/5]

template<class SubC >
template<class F , class INTEGER , class Cond >
auto ROOT::TExecutorCRTP< SubC >::Map ( F  func,
ROOT::TSeq< INTEGER >  args 
) -> std::vector<InvokeResult_t<F, INTEGER>>

Execute a function over a sequence of indexes.

Parameters
funcFunction to be executed. Must take an element of the sequence passed assecond argument as a parameter.
argsSequence of indexes to execute func on.
Returns
A vector with the results of the function calls.

Definition at line 197 of file TExecutorCRTP.hxx.

◆ Map() [3/5]

template<class SubC >
template<class F , class T , class Cond >
auto ROOT::TExecutorCRTP< SubC >::Map ( F  func,
std::initializer_list< T >  args 
) -> std::vector<InvokeResult_t<F, T>>

Execute a function over the elements of an initializer_list.

Parameters
funcFunction to be executed on the elements of the initializer_list passed as second parameter.
argsinitializer_list for a vector to apply func on.
Returns
A vector with the results of the function calls.

Definition at line 210 of file TExecutorCRTP.hxx.

◆ Map() [4/5]

template<class SubC >
template<class F , class T , class Cond >
auto ROOT::TExecutorCRTP< SubC >::Map ( F  func,
std::vector< T > &  args 
) -> std::vector<InvokeResult_t<F, T>>

Execute a function over the elements of a vector.

Parameters
funcFunction to be executed on the elements of the vector passed as second parameter.
argsVector of elements passed as an argument to func.
Returns
A vector with the results of the function calls.

Definition at line 225 of file TExecutorCRTP.hxx.

◆ Map() [5/5]

template<class SubC >
template<class F , class Cond >
auto ROOT::TExecutorCRTP< SubC >::Map ( F  func,
unsigned  nTimes 
) -> std::vector<InvokeResult_t<F>>

Execute a function without arguments several times.

Parameters
funcFunction to be executed.
nTimesNumber 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 184 of file TExecutorCRTP.hxx.

◆ MapImpl() [1/4]

template<class SubC >
template<class F , class T , class Cond = noReferenceCond<F, T>>
auto ROOT::TExecutorCRTP< SubC >::MapImpl ( F  func,
const std::vector< T > &  args 
) -> std::vector< InvokeResult_t< F, T > >=delete
privatedelete

Implementation of the Map method, left to the derived classes.

◆ MapImpl() [2/4]

template<class SubC >
template<class F , class INTEGER , class Cond = noReferenceCond<F, INTEGER>>
auto ROOT::TExecutorCRTP< SubC >::MapImpl ( F  func,
ROOT::TSeq< INTEGER >  args 
) -> std::vector< InvokeResult_t< F, INTEGER > >=delete
privatedelete

Implementation of the Map method, left to the derived classes.

◆ MapImpl() [3/4]

template<class SubC >
template<class F , class T , class Cond = noReferenceCond<F, T>>
auto ROOT::TExecutorCRTP< SubC >::MapImpl ( F  func,
std::vector< T > &  args 
) -> std::vector< InvokeResult_t< F, T > >=delete
privatedelete

Implementation of the Map method, left to the derived classes.

◆ MapImpl() [4/4]

template<class SubC >
template<class F , class Cond = noReferenceCond<F>>
auto ROOT::TExecutorCRTP< SubC >::MapImpl ( F  func,
unsigned  nTimes 
) -> std::vector< InvokeResult_t< F > >=delete
privatedelete

Implementation of the Map method, left to the derived classes.

◆ MapReduce() [1/7]

template<class SubC >
template<class F , class T , class Cond >
T * ROOT::TExecutorCRTP< SubC >::MapReduce ( F  func,
const std::vector< T * > &  args 
)

Execute a function over the TObject-inheriting elements of an immutable vector (Map) and merge the objects into a single one (Reduce).

Parameters
funcFunction to be executed on the elements of the vector passed as second parameter.
argsImmutable vector of elements passed as an argument to func.
Returns
A value result of "reducing" the vector returned by the Map operation into a single object.

Definition at line 335 of file TExecutorCRTP.hxx.

◆ MapReduce() [2/7]

template<class SubC >
template<class F , class T , class R , class Cond >
auto ROOT::TExecutorCRTP< SubC >::MapReduce ( F  func,
const std::vector< T > &  args,
R  redfunc 
) -> InvokeResult_t<F, T>

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

Parameters
funcFunction to be executed on the elements of the vector passed as second parameter.
argsImmutable vector of elements passed as an argument to func.
redfuncReduction 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 311 of file TExecutorCRTP.hxx.

◆ MapReduce() [3/7]

template<class SubC >
template<class F , class INTEGER , class R , class Cond >
auto ROOT::TExecutorCRTP< SubC >::MapReduce ( F  func,
ROOT::TSeq< INTEGER >  args,
R  redfunc 
) -> InvokeResult_t<F, INTEGER>

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

Parameters
funcFunction to be executed. Must take an element of the sequence passed assecond argument as a parameter.
argsSequence of indexes to execute func on.
redfuncReduction 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 268 of file TExecutorCRTP.hxx.

◆ MapReduce() [4/7]

template<class SubC >
template<class F , class T , class R , class Cond >
auto ROOT::TExecutorCRTP< SubC >::MapReduce ( F  func,
std::initializer_list< T >  args,
R  redfunc 
) -> InvokeResult_t<F, T>

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

Parameters
funcFunction to be executed on the elements of the initializer_list passed as second parameter.
argsinitializer_list for a vector to apply func on.
redfuncReduction 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 282 of file TExecutorCRTP.hxx.

◆ MapReduce() [5/7]

template<class SubC >
template<class F , class T , class Cond >
T * ROOT::TExecutorCRTP< SubC >::MapReduce ( F  func,
std::vector< T * > &  args 
)

Execute a function over the TObject-inheriting elements of a vector (Map) and merge the objects into a single one (Reduce).

Parameters
funcFunction to be executed on the elements of the vector passed as second parameter.
argsVector of elements passed as an argument to func.
Returns
A value result of "reducing" the vector returned by the Map operation into a single object.

Definition at line 323 of file TExecutorCRTP.hxx.

◆ MapReduce() [6/7]

template<class SubC >
template<class F , class T , class R , class Cond >
auto ROOT::TExecutorCRTP< SubC >::MapReduce ( F  func,
std::vector< T > &  args,
R  redfunc 
) -> InvokeResult_t<F, T>

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

Parameters
funcFunction to be executed on the elements of the vector passed as second parameter.
argsVector of elements passed as an argument to func.
redfuncReduction 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 297 of file TExecutorCRTP.hxx.

◆ MapReduce() [7/7]

template<class SubC >
template<class F , class R , class Cond >
auto ROOT::TExecutorCRTP< SubC >::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).

Parameters
funcFunction to be executed.
nTimesNumber of times function should be called.
Returns
A vector with the results of the function calls.
Parameters
redfuncReduction 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 254 of file TExecutorCRTP.hxx.

◆ operator=()

template<class SubC >
TExecutorCRTP & ROOT::TExecutorCRTP< SubC >::operator= ( const TExecutorCRTP< SubC > &  )
delete

◆ Reduce() [1/2]

template<class SubC >
template<class T >
T * ROOT::TExecutorCRTP< SubC >::Reduce ( const std::vector< T * > &  mergeObjs)

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

Parameters
mergeObjsA vector of ROOT objects implementing the Merge method
Returns
An object result of merging the vector elements into one.

Definition at line 346 of file TExecutorCRTP.hxx.

◆ Reduce() [2/2]

template<class SubC >
template<class T , class R >
auto ROOT::TExecutorCRTP< SubC >::Reduce ( const std::vector< T > &  objs,
R  redfunc 
) -> decltype(redfunc(objs))

"Reduce" an std::vector into a single object by passing a function as the second argument defining the reduction operation.

Parameters
objsA vector of elements to combine.
redfuncReduction function to combine the elements of the vector objs
Returns
A value result of combining the vector elements into a single object of the same type.

Definition at line 372 of file TExecutorCRTP.hxx.


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