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< InvokeResult_t< F, T > >
	Execute a function over the elements of an immutable vector.
auto	Map (F func, ROOT::TSeq< INTEGER > args) -> std::vector< InvokeResult_t< F, INTEGER > >
	Execute a function over a sequence of indexes.
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.
auto	Map (F func, std::vector< T > &args) -> std::vector< InvokeResult_t< F, T > >
	Execute a function over the elements of a vector.
auto	Map (F func, unsigned nTimes) -> std::vector< InvokeResult_t< F > >
	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) -> InvokeResult_t< F, T >
	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) -> InvokeResult_t< F, INTEGER >
	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) -> InvokeResult_t< F, T >
	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) -> InvokeResult_t< F, T >
	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) -> InvokeResult_t< F >
	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 Types
template<typename F , typename... Args>
using	InvokeResult_t = ROOT::TypeTraits::InvokeResult_t< F, Args... >

Private Member Functions
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 > >
	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< InvokeResult_t< F, INTEGER > >
	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< InvokeResult_t< F, T > >
	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< InvokeResult_t< F > >
	Execute a function without arguments several times.

Private Attributes
friend	TExecutorCRTP

Additional Inherited Members
Public Types inherited from ROOT::TExecutorCRTP< TSequentialExecutor >
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.

#include <ROOT/TSequentialExecutor.hxx>

Inheritance diagram for ROOT::TSequentialExecutor:

Member Typedef Documentation

InvokeResult_t

template<typename F , typename... Args>

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

private

Definition at line 30 of file TSequentialExecutor.hxx.

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 135 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 102 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 112 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 123 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 92 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 69 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<InvokeResult_t<F, T>>

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 195 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<InvokeResult_t<F, INTEGER>>

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 163 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<InvokeResult_t<F, T>>

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

MapImpl() [4/4]

template<class F , class Cond >

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

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