ROOT::TSequentialExecutor Class Reference

Definition at line 26 of file TSequentialExecutor.hxx.

Public Member Functions
	TSequentialExecutor ()=default
	TSequentialExecutor (const TSequentialExecutor &)=delete
template<class F , class T >
void	Foreach (F func, const std::vector< T > &args)
	Execute a function over the elements of an immutable vector, dividing the execution in nChunks.
template<class F , class INTEGER >
void	Foreach (F func, ROOT::TSeq< INTEGER > args)
	Execute a function over a sequence of indexes, dividing the execution in nChunks.
template<class F , class T >
void	Foreach (F func, std::initializer_list< T > args)
	Execute a function over the elements of an initializer_list, dividing the execution in nChunks.
template<class F , class T >
void	Foreach (F func, std::vector< T > &args)
	Execute a function over the elements of a vector, dividing the execution in nChunks.
template<class F >
void	Foreach (F func, unsigned nTimes)
	Execute a function without arguments several times, dividing the execution in nChunks.
unsigned	GetPoolSize () const
	Return the number of workers in the sequential executor: a single one.
TSequentialExecutor &	operator= (const TSequentialExecutor &)=delete
Public Member Functions inherited from ROOT::TExecutorCRTP< TSequentialExecutor >
	TExecutorCRTP ()=default
	TExecutorCRTP (const TExecutorCRTP &)=delete
auto	Map (F func, const std::vector< T > &args) -> std::vector< typename std::result_of< F(T)>::type >
	Execute a function over the elements of an immutable vector.
auto	Map (F func, ROOT::TSeq< INTEGER > args) -> std::vector< typename std::result_of< F(INTEGER)>::type >
	Execute a function over a sequence of indexes.
auto	Map (F func, std::initializer_list< T > args) -> std::vector< typename std::result_of< F(T)>::type >
	Execute a function over the elements of an initializer_list.
auto	Map (F func, std::vector< T > &args) -> std::vector< typename std::result_of< F(T)>::type >
	Execute a function over the elements of a vector.
auto	Map (F func, unsigned nTimes) -> std::vector< typename std::result_of< F()>::type >
	Execute a function without arguments several times.
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).
auto	MapReduce (F func, const std::vector< T > &args, R redfunc) -> typename std::result_of< F(T)>::type
	Execute a function over the elements of an immutable vector (Map) and accumulate the results into a single value (Reduce).
auto	MapReduce (F func, ROOT::TSeq< INTEGER > args, R redfunc) -> typename std::result_of< F(INTEGER)>::type
	Execute a function over a sequence of indexes (Map) and accumulate the results into a single value (Reduce).
auto	MapReduce (F func, std::initializer_list< T > args, R redfunc) -> typename std::result_of< F(T)>::type
	Execute a function over the elements of an initializer_list (Map) and accumulate the results into a single value (Reduce).
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).
auto	MapReduce (F func, std::vector< T > &args, R redfunc) -> typename std::result_of< F(T)>::type
	Execute a function over the elements of a vector (Map) and accumulate the results into a single value (Reduce).
auto	MapReduce (F func, unsigned nTimes, R redfunc) -> typename std::result_of< F()>::type
	Execute a function without arguments several times (Map) and accumulate the results into a single value (Reduce).
TExecutorCRTP &	operator= (const TExecutorCRTP &)=delete
T *	Reduce (const std::vector< T * > &mergeObjs)
	"Reduce" an std::vector into a single object by using the object's Merge method.
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.

Private Member Functions
template<class F , class T , class Cond = noReferenceCond<F, T>>
auto	MapImpl (F func, const std::vector< T > &args) -> std::vector< typename std::result_of< F(T)>::type >
	Execute a function over the elements of an immutable vector.
template<class F , class INTEGER , class Cond = noReferenceCond<F, INTEGER>>
auto	MapImpl (F func, ROOT::TSeq< INTEGER > args) -> std::vector< typename std::result_of< F(INTEGER)>::type >
	Execute a function over a sequence of indexes.
template<class F , class T , class Cond = noReferenceCond<F, T>>
auto	MapImpl (F func, std::vector< T > &args) -> std::vector< typename std::result_of< F(T)>::type >
	Execute a function over the elements of a vector in parallel Implementation of the Map method.
template<class F , class Cond = noReferenceCond<F>>
auto	MapImpl (F func, unsigned nTimes) -> std::vector< typename std::result_of< F()>::type >
	Execute a function without arguments several times.

Private Attributes
friend	TExecutorCRTP

Additional Inherited Members
Public Types inherited from ROOT::TExecutorCRTP< TSequentialExecutor >
using	noReferenceCond = typename std::enable_if<"Function can't return a reference" &&!(std::is_reference< typename std::result_of< F(T...)>::type >::value)>::type
	type definition in used in templated functions for not allowing mapping functions that return references.

#include <ROOT/TSequentialExecutor.hxx>

Inheritance diagram for ROOT::TSequentialExecutor:

Constructor & Destructor Documentation

TSequentialExecutor() [1/2]

ROOT::TSequentialExecutor::TSequentialExecutor ( )

default

TSequentialExecutor() [2/2]

ROOT::TSequentialExecutor::TSequentialExecutor ( const TSequentialExecutor &  )

delete

Member Function Documentation

Foreach() [1/5]

template<class F , class T >

void ROOT::TSequentialExecutor::Foreach	(	F	func,
		const std::vector< T > &	args
	)

Execute a function over the elements of an immutable vector, dividing the execution in nChunks.

Parameters

func	Function to be executed on the elements of the immutable vector passed as second parameter.
args	Immutable vector of elements passed as an argument to func.

Definition at line 131 of file TSequentialExecutor.hxx.

Foreach() [2/5]

template<class F , class INTEGER >

void ROOT::TSequentialExecutor::Foreach	(	F	func,
		ROOT::TSeq< INTEGER >	args
	)

Execute a function over a sequence of indexes, dividing the execution in nChunks.

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.

Definition at line 98 of file TSequentialExecutor.hxx.

Foreach() [3/5]

template<class F , class T >

void ROOT::TSequentialExecutor::Foreach	(	F	func,
		std::initializer_list< T >	args
	)

Execute a function over the elements of an initializer_list, dividing the execution in nChunks.

Parameters

func	Function to be executed on the elements of the initializer_list passed as second parameter.
args	initializer_list for a vector to apply func on.

Definition at line 108 of file TSequentialExecutor.hxx.

Foreach() [4/5]

template<class F , class T >

void ROOT::TSequentialExecutor::Foreach	(	F	func,
		std::vector< T > &	args
	)

Execute a function over the elements of a vector, dividing the execution in nChunks.

Parameters

func	Function to be executed on the elements of the vector passed as second parameter.
args	Vector of elements passed as an argument to func.

Definition at line 119 of file TSequentialExecutor.hxx.

Foreach() [5/5]

template<class F >

void ROOT::TSequentialExecutor::Foreach	(	F	func,
		unsigned	nTimes
	)

Execute a function without arguments several times, dividing the execution in nChunks.

Parameters

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

Definition at line 88 of file TSequentialExecutor.hxx.

GetPoolSize()

unsigned ROOT::TSequentialExecutor::GetPoolSize ( ) const

inline

Return the number of workers in the sequential executor: a single one.

Returns

The number of workers in the pool, one.

Definition at line 65 of file TSequentialExecutor.hxx.

MapImpl() [1/4]

template<class F , class T , class Cond >

auto ROOT::TSequentialExecutor::MapImpl ( F  func, const std::vector< T > &  args  ) -> std::vector<typename std::result_of<F(T)>::type>

private

Execute a function over the elements of an immutable vector.

Implementation of the Map method.

Parameters

func	Function to be executed on the elements of the vector passed as second parameter.
args	Vector of elements passed as an argument to func.

Returns

A vector with the results of the function calls.

Definition at line 191 of file TSequentialExecutor.hxx.

MapImpl() [2/4]

template<class F , class INTEGER , class Cond >

auto ROOT::TSequentialExecutor::MapImpl ( F  func, ROOT::TSeq< INTEGER >  args  ) -> std::vector<typename std::result_of<F(INTEGER)>::type>

private

Execute a function over a sequence of indexes.

Implementation of the Map method.

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.

Returns

A vector with the results of the function calls.

Definition at line 159 of file TSequentialExecutor.hxx.

MapImpl() [3/4]

template<class F , class T , class Cond >

auto ROOT::TSequentialExecutor::MapImpl ( F  func, std::vector< T > &  args  ) -> std::vector<typename std::result_of<F(T)>::type>

private

Execute a function over the elements of a vector in parallel Implementation of the Map method.

Parameters

func	Function to be executed on the elements of the vector passed as second parameter.
args	Vector of elements passed as an argument to func.

Returns

A vector with the results of the function calls.

Definition at line 174 of file TSequentialExecutor.hxx.

MapImpl() [4/4]

template<class F , class Cond >

auto ROOT::TSequentialExecutor::MapImpl ( F  func, unsigned  nTimes  ) -> std::vector<typename std::result_of<F()>::type>

private

Execute a function without arguments several times.

Implementation of the Map method.

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 143 of file TSequentialExecutor.hxx.

operator=()

TSequentialExecutor & ROOT::TSequentialExecutor::operator= ( const TSequentialExecutor &  )

delete

Member Data Documentation

TExecutorCRTP

friend ROOT::TSequentialExecutor::TExecutorCRTP

private

Definition at line 27 of file TSequentialExecutor.hxx.