Reductions and Scans

Performance-portable reduction and scan operations in AMReX. More...

Classes
struct	amrex::ReduceOpSum
struct	amrex::ReduceOpMin
struct	amrex::ReduceOpMax
struct	amrex::ReduceOpLogicalAnd
struct	amrex::ReduceOpLogicalOr
class	amrex::ReduceData< Ts >
class	amrex::ReduceOps< Ps >

Functions
template<typename T , typename N , typename M = std::enable_if_t<std::is_integral_v<N>>>
T	amrex::Reduce::Sum (N n, T const *v, T init_val=0)
template<typename T , typename N , typename F , typename M = std::enable_if_t<std::is_integral_v<N>>>
T	amrex::Reduce::Sum (N n, F const &f, T init_val=0)
template<typename T , typename N , typename M = std::enable_if_t<std::is_integral_v<N>>>
T	amrex::Reduce::Min (N n, T const *v, T init_val=std::numeric_limits< T >::max())
template<typename T , typename N , typename F , typename M = std::enable_if_t<std::is_integral_v<N>>>
T	amrex::Reduce::Min (N n, F const &f, T init_val=std::numeric_limits< T >::max())
template<typename T , typename N , typename M = std::enable_if_t<std::is_integral_v<N>>>
T	amrex::Reduce::Max (N n, T const *v, T init_val=std::numeric_limits< T >::lowest())
template<typename T , typename N , typename F , typename M = std::enable_if_t<std::is_integral_v<N>>>
T	amrex::Reduce::Max (N n, F const &f, T init_val=std::numeric_limits< T >::lowest())
template<typename T , typename N , typename M = std::enable_if_t<std::is_integral_v<N>>>
std::pair< T, T >	amrex::Reduce::MinMax (N n, T const *v)
template<typename T , typename N , typename F , typename M = std::enable_if_t<std::is_integral_v<N>>>
std::pair< T, T >	amrex::Reduce::MinMax (N n, F const &f)
template<typename T , typename N , typename P , typename M = std::enable_if_t<std::is_integral_v<N>>>
bool	amrex::Reduce::AnyOf (N n, T const *v, P const &pred)
template<typename P >
bool	amrex::Reduce::AnyOf (Box const &box, P const &pred)
template<typename T , typename N , typename FIN , typename FOUT , typename TYPE , typename M = std::enable_if_t<std::is_integral_v<N> && (std::is_same<std::decay_t<TYPE>,Type::Inclusive>::value || std::is_same<std::decay_t<TYPE>,Type::Exclusive>::value)>>
T	amrex::Scan::PrefixSum (N n, FIN const &fin, FOUT const &fout, TYPE, RetSum a_ret_sum=retSum)
template<typename N , typename T , typename M = std::enable_if_t<std::is_integral_v<N>>>
T	amrex::Scan::InclusiveSum (N n, T const *in, T *out, RetSum a_ret_sum=retSum)
	Inclusive sum.
template<typename N , typename T , typename M = std::enable_if_t<std::is_integral_v<N>>>
T	amrex::Scan::ExclusiveSum (N n, T const *in, T *out, RetSum a_ret_sum=retSum)
	Exclusive sum.
template<class InIter , class OutIter >
OutIter	amrex::Gpu::inclusive_scan (InIter begin, InIter end, OutIter result)
template<class InIter , class OutIter >
OutIter	amrex::Gpu::exclusive_scan (InIter begin, InIter end, OutIter result)

Detailed Description

Performance-portable reduction and scan operations in AMReX.

These interfaces provide reductions (e.g., sum, min, max) and scan operations (prefix sums) over index spaces and ranges on both CPUs and GPUs. They do not use MPI and operate on data local to the process.

Key functions and classes include:

• amrex::ReduceOpSum
• amrex::ReduceOpMin
• amrex::ReduceOpMax
• amrex::ReduceOpLogicalAnd
• amrex::ReduceOpLogicalOr
• amrex::ReduceOps
• amrex::ReduceData
• amrex::Reduce::Sum
• amrex::Reduce::Min
• amrex::Reduce::Max
• amrex::Reduce::MinMax
• amrex::Reduce::AnyOf
• amrex::Scan::PrefixSum
• amrex::Scan::InclusiveSum
• amrex::Scan::ExclusiveSum
• amrex::Gpu::inclusive_scan
• amrex::Gpu::exclusive_scan

Function Documentation

AnyOf() [1/2]

template<typename P >

bool amrex::Reduce::AnyOf	(	Box const &	box,
		P const &	pred
	)

AnyOf() [2/2]

template<typename T , typename N , typename P , typename M = std::enable_if_t<std::is_integral_v<N>>>

bool amrex::Reduce::AnyOf	(	N	n,
		T const *	v,
		P const &	pred
	)

exclusive_scan()

template<class InIter , class OutIter >

OutIter amrex::Gpu::exclusive_scan	(	InIter	begin,
		InIter	end,
		OutIter	result
	)

ExclusiveSum()

template<typename N , typename T , typename M = std::enable_if_t<std::is_integral_v<N>>>

T amrex::Scan::ExclusiveSum	(	N	n,
		T const *	in,
		T *	out,
		RetSum	a_ret_sum = retSum
	)

Exclusive sum.

Parameters

n	number of elements
in	input
out	output
a_ret_sum	control the return value

Returns

return the total sum if a_ret_sum is true

inclusive_scan()

template<class InIter , class OutIter >

OutIter amrex::Gpu::inclusive_scan	(	InIter	begin,
		InIter	end,
		OutIter	result
	)

InclusiveSum()

template<typename N , typename T , typename M = std::enable_if_t<std::is_integral_v<N>>>

T amrex::Scan::InclusiveSum	(	N	n,
		T const *	in,
		T *	out,
		RetSum	a_ret_sum = retSum
	)

Inclusive sum.

Parameters

n	number of elements
in	input
out	output
a_ret_sum	control the return value

Returns

return the total sum if a_ret_sum is true

Max() [1/2]

template<typename T , typename N , typename F , typename M = std::enable_if_t<std::is_integral_v<N>>>

T amrex::Reduce::Max	(	N	n,
		F const &	f,
		T	init_val = std::numeric_limits<T>::lowest()
	)

Max() [2/2]

template<typename T , typename N , typename M = std::enable_if_t<std::is_integral_v<N>>>

T amrex::Reduce::Max	(	N	n,
		T const *	v,
		T	init_val = std::numeric_limits<T>::lowest()
	)

Min() [1/2]

template<typename T , typename N , typename F , typename M = std::enable_if_t<std::is_integral_v<N>>>

T amrex::Reduce::Min	(	N	n,
		F const &	f,
		T	init_val = std::numeric_limits<T>::max()
	)

Min() [2/2]

template<typename T , typename N , typename M = std::enable_if_t<std::is_integral_v<N>>>

T amrex::Reduce::Min	(	N	n,
		T const *	v,
		T	init_val = std::numeric_limits<T>::max()
	)

MinMax() [1/2]

template<typename T , typename N , typename F , typename M = std::enable_if_t<std::is_integral_v<N>>>

std::pair< T, T > amrex::Reduce::MinMax	(	N	n,
		F const &	f
	)

MinMax() [2/2]

template<typename T , typename N , typename M = std::enable_if_t<std::is_integral_v<N>>>

std::pair< T, T > amrex::Reduce::MinMax	(	N	n,
		T const *	v
	)

PrefixSum()

template<typename T , typename N , typename FIN , typename FOUT , typename TYPE , typename M = std::enable_if_t<std::is_integral_v<N> && (std::is_same<std::decay_t<TYPE>,Type::Inclusive>::value || std::is_same<std::decay_t<TYPE>,Type::Exclusive>::value)>>

T amrex::Scan::PrefixSum	(	N	n,
		FIN const &	fin,
		FOUT const &	fout,
		TYPE	,
		RetSum	a_ret_sum = retSum
	)

Sum() [1/2]

template<typename T , typename N , typename F , typename M = std::enable_if_t<std::is_integral_v<N>>>

T amrex::Reduce::Sum	(	N	n,
		F const &	f,
		T	init_val = 0
	)

Sum() [2/2]

template<typename T , typename N , typename M = std::enable_if_t<std::is_integral_v<N>>>

T amrex::Reduce::Sum	(	N	n,
		T const *	v,
		T	init_val = 0
	)