RAJA::internal::expt::ET Namespace Reference

Classes
class	TensorBinaryOperator
struct	TensorOperatorAdd
struct	TensorOperatorSubtract
struct	OperatorTraits
struct	OperatorTraits< LHS_TYPE, RHS_TYPE, typename std::enable_if< LHS_TYPE::s_num_dims==0 >::type >
struct	OperatorTraits< LHS_TYPE, RHS_TYPE, typename std::enable_if< RHS_TYPE::s_num_dims==0 >::type >
class	BlockLiteral
class	TensorLoadStore
class	TensorMultiply
class	TensorDivide
class	TensorNegate
class	TensorTranspose
class	TensorExpressionConcreteBase
class	TensorExpressionBase
struct	MultiplyOperator
struct	MultiplyOperator< LEFT_OPERAND_TYPE, RIGHT_OPERAND_TYPE, typename std::enable_if< LEFT_OPERAND_TYPE::s_num_dims==0 >::type >
struct	MultiplyOperator< LEFT_OPERAND_TYPE, RIGHT_OPERAND_TYPE, typename std::enable_if< RIGHT_OPERAND_TYPE::s_num_dims==0 >::type >
struct	MultiplyOperator< LEFT_OPERAND_TYPE, RIGHT_OPERAND_TYPE, typename std::enable_if< LEFT_OPERAND_TYPE::s_num_dims==2 &&RIGHT_OPERAND_TYPE::s_num_dims==1 >::type >
class	TensorMultiplyAdd
struct	MultiplyOperator< LEFT_OPERAND_TYPE, RIGHT_OPERAND_TYPE, typename std::enable_if< LEFT_OPERAND_TYPE::s_num_dims==1 &&RIGHT_OPERAND_TYPE::s_num_dims==2 >::type >
struct	MultiplyOperator< LEFT_OPERAND_TYPE, RIGHT_OPERAND_TYPE, typename std::enable_if< LEFT_OPERAND_TYPE::s_num_dims==2 &&RIGHT_OPERAND_TYPE::s_num_dims==2 >::type >
class	RestrictExtents
struct	MultiplyOperator< LEFT_OPERAND_TYPE, RIGHT_OPERAND_TYPE, typename std::enable_if< std::is_base_of< TensorBlockConcreteBase, typename RIGHT_OPERAND_TYPE::tensor_type >::value &&LEFT_OPERAND_TYPE::s_num_dims==2 &&RIGHT_OPERAND_TYPE::s_num_dims==2 >::type >
struct	NormalizeOperandHelper
struct	NormalizeOperandHelper< RHS, typename std::enable_if< std::is_base_of< TensorExpressionConcreteBase, RHS >::value >::type >
struct	DivideOperator
struct	DivideOperator< LEFT_OPERAND_TYPE, RIGHT_OPERAND_TYPE, typename std::enable_if< LEFT_OPERAND_TYPE::s_num_dims==0 &&RIGHT_OPERAND_TYPE::s_num_dims==1 >::type >
struct	DivideOperator< LEFT_OPERAND_TYPE, RIGHT_OPERAND_TYPE, typename std::enable_if< LEFT_OPERAND_TYPE::s_num_dims==1 &&RIGHT_OPERAND_TYPE::s_num_dims==0 >::type >
struct	DivideOperator< LEFT_OPERAND_TYPE, RIGHT_OPERAND_TYPE, typename std::enable_if< LEFT_OPERAND_TYPE::s_num_dims==1 &&RIGHT_OPERAND_TYPE::s_num_dims==1 >::type >
struct	DivideOperator< LEFT_OPERAND_TYPE, RIGHT_OPERAND_TYPE, typename std::enable_if< LEFT_OPERAND_TYPE::s_num_dims==0 &&RIGHT_OPERAND_TYPE::s_num_dims==2 >::type >
struct	DivideOperator< LEFT_OPERAND_TYPE, RIGHT_OPERAND_TYPE, typename std::enable_if< LEFT_OPERAND_TYPE::s_num_dims==2 &&RIGHT_OPERAND_TYPE::s_num_dims==0 >::type >
struct	DivideOperator< LEFT_OPERAND_TYPE, RIGHT_OPERAND_TYPE, typename std::enable_if< LEFT_OPERAND_TYPE::s_num_dims==2 &&RIGHT_OPERAND_TYPE::s_num_dims==2 >::type >
class	TensorLiteral
struct	NormalizeOperandHelper< RHS, typename std::enable_if< std::is_base_of< TensorRegisterConcreteBase, RHS >::value >::type >
struct	TensorStoreFunctor
class	TensorScalarLiteral
struct	NormalizeOperandHelper< RHS, typename std::enable_if< std::is_arithmetic< RHS >::value >::type >

Typedefs
template<typename LHS , typename RHS >
using	TensorAdd = TensorBinaryOperator< TensorOperatorAdd, LHS, RHS >
template<typename LHS , typename RHS >
using	TensorSubtract = TensorBinaryOperator< TensorOperatorSubtract, LHS, RHS >
template<typename RHS >
using	normalize_operand_t = typename NormalizeOperandHelper< RHS >::return_type

Functions
template<typename LEFT_OPERAND , typename RIGHT_OPERAND , typename std::enable_if< std::is_arithmetic< LEFT_OPERAND >::value, bool >::type = true, typename std::enable_if< std::is_base_of< TensorExpressionConcreteBase, RIGHT_OPERAND >::value, bool >::type = true>
RAJA_INLINE RAJA_HOST_DEVICE auto	operator+ (LEFT_OPERAND const &left, RIGHT_OPERAND const &right) -> TensorAdd< typename NormalizeOperandHelper< LEFT_OPERAND >::return_type, RIGHT_OPERAND >
template<typename LEFT_OPERAND , typename RIGHT_OPERAND , typename std::enable_if< std::is_arithmetic< LEFT_OPERAND >::value, bool >::type = true, typename std::enable_if< std::is_base_of< TensorExpressionConcreteBase, RIGHT_OPERAND >::value, bool >::type = true>
RAJA_INLINE RAJA_HOST_DEVICE auto	operator- (LEFT_OPERAND const &left, RIGHT_OPERAND const &right) -> TensorSubtract< typename NormalizeOperandHelper< LEFT_OPERAND >::return_type, RIGHT_OPERAND >
template<typename OPERAND , typename TILE >
RestrictExtents< OPERAND, TILE >	restrictExtents (OPERAND const &operand, TILE const &tile)
template<typename RHS >
RAJA_INLINE RAJA_HOST_DEVICE auto	normalizeOperand (RHS const &rhs) -> typename NormalizeOperandHelper< RHS >::return_type
template<typename LHS , typename RHS , typename std::enable_if< std::is_arithmetic< LHS >::value, bool >::type = true, typename std::enable_if< std::is_base_of< TensorExpressionConcreteBase, RHS >::value, bool >::type = true>
RAJA_INLINE RAJA_HOST_DEVICE auto	operator/ (LHS const &left_operand, RHS const &right_operand) -> TensorDivide< typename NormalizeOperandHelper< LHS >::return_type, RHS >
template<typename STORAGE , typename LHS_TYPE , typename RHS_TYPE >
RAJA_HOST_DEVICE constexpr RAJA_INLINE auto	makeTensorStoreFunctor (LHS_TYPE const &lhs, RHS_TYPE const &rhs) -> TensorStoreFunctor< STORAGE, LHS_TYPE, RHS_TYPE >
template<typename LHS , typename RHS , typename std::enable_if< std::is_arithmetic< LHS >::value, bool >::type = true, typename std::enable_if< std::is_base_of< TensorExpressionConcreteBase, RHS >::value, bool >::type = true>
RAJA_INLINE RAJA_HOST_DEVICE auto	operator* (LHS const &left_operand, RHS const &right_operand) -> TensorMultiply< typename NormalizeOperandHelper< LHS >::return_type, RHS >

Typedef Documentation

TensorAdd

template<typename LHS , typename RHS >

using RAJA::internal::expt::ET::TensorAdd = typedef TensorBinaryOperator<TensorOperatorAdd, LHS, RHS>

TensorSubtract

template<typename LHS , typename RHS >

using RAJA::internal::expt::ET::TensorSubtract = typedef TensorBinaryOperator<TensorOperatorSubtract, LHS, RHS>

normalize_operand_t

template<typename RHS >

using RAJA::internal::expt::ET::normalize_operand_t = typedef typename NormalizeOperandHelper<RHS>::return_type

Function Documentation

operator+()

template<typename LEFT_OPERAND , typename RIGHT_OPERAND , typename std::enable_if< std::is_arithmetic< LEFT_OPERAND >::value, bool >::type = true, typename std::enable_if< std::is_base_of< TensorExpressionConcreteBase, RIGHT_OPERAND >::value, bool >::type = true>

RAJA_INLINE RAJA_HOST_DEVICE auto RAJA::internal::expt::ET::operator+	(	LEFT_OPERAND const &	left,
		RIGHT_OPERAND const &	right
	)		-> TensorAdd<typename NormalizeOperandHelper<LEFT_OPERAND>::return_type, RIGHT_OPERAND>

operator-()

template<typename LEFT_OPERAND , typename RIGHT_OPERAND , typename std::enable_if< std::is_arithmetic< LEFT_OPERAND >::value, bool >::type = true, typename std::enable_if< std::is_base_of< TensorExpressionConcreteBase, RIGHT_OPERAND >::value, bool >::type = true>

RAJA_INLINE RAJA_HOST_DEVICE auto RAJA::internal::expt::ET::operator-	(	LEFT_OPERAND const &	left,
		RIGHT_OPERAND const &	right
	)		-> TensorSubtract< typename NormalizeOperandHelper<LEFT_OPERAND>::return_type, RIGHT_OPERAND>

restrictExtents()

template<typename OPERAND , typename TILE >

RestrictExtents<OPERAND, TILE> RAJA::internal::expt::ET::restrictExtents	(	OPERAND const &	operand,
		TILE const &	tile
	)

normalizeOperand()

template<typename RHS >

RAJA_INLINE RAJA_HOST_DEVICE auto RAJA::internal::expt::ET::normalizeOperand

(

RHS const &

rhs

)

-> typename NormalizeOperandHelper<RHS>::return_type

Allows uniform packaging up of operands into ExpressionTemplates.

The NormalizeOperandHelper is specialized throughout the code in order to convert non-ET operands into ET objects

ET operators can then take any operand type, and use this to convert them into ET types the same way.

operator/()

template<typename LHS , typename RHS , typename std::enable_if< std::is_arithmetic< LHS >::value, bool >::type = true, typename std::enable_if< std::is_base_of< TensorExpressionConcreteBase, RHS >::value, bool >::type = true>

RAJA_INLINE RAJA_HOST_DEVICE auto RAJA::internal::expt::ET::operator/	(	LHS const &	left_operand,
		RHS const &	right_operand
	)		-> TensorDivide<typename NormalizeOperandHelper<LHS>::return_type, RHS>

makeTensorStoreFunctor()

template<typename STORAGE , typename LHS_TYPE , typename RHS_TYPE >

RAJA_HOST_DEVICE constexpr RAJA_INLINE auto RAJA::internal::expt::ET::makeTensorStoreFunctor ( LHS_TYPE const &  lhs, RHS_TYPE const &  rhs  ) -> TensorStoreFunctor<STORAGE, LHS_TYPE, RHS_TYPE>

constexpr

operator*()

template<typename LHS , typename RHS , typename std::enable_if< std::is_arithmetic< LHS >::value, bool >::type = true, typename std::enable_if< std::is_base_of< TensorExpressionConcreteBase, RHS >::value, bool >::type = true>

RAJA_INLINE RAJA_HOST_DEVICE auto RAJA::internal::expt::ET::operator*	(	LHS const &	left_operand,
		RHS const &	right_operand
	)		-> TensorMultiply<typename NormalizeOperandHelper<LHS>::return_type, RHS>