RAJA Namespace Reference

Namespaces
	basic_mempool
	concepts
	detail
	expt
	impl
	internal
	iteration_mapping
	Iterators
	omp
	operators
	policy
	policy_by_value_interface
	The RAJA::policy_by_value_interface forall functions provide an interface with value-based policies. It also enforces the interface and performs static checks as well as triggering plugins and loop body updates.
	reduce
	resources
	sequential
	statement
	type_traits
	util
	wrap
	The RAJA::wrap layer unwraps dynamic policies before dispatch.

Classes
class	TypedIndexSet
class	TypedIndexSet< T0, TREST... >
	Class representing an index set which is a collection of segment objects. More...
class	TypedIndexSet<>
struct	IndexValueBase
struct	IndexValue
	Strongly typed "integer" class. More...
class	TypedListSegment
class	TypedRangeSegment
	Segment class representing a contiguous range of typed indices. More...
class	TypedRangeStrideSegment
	Segment class representing a strided range of typed indices. More...
struct	FreeAligned
struct	FreeAlignedType
class	RAJAVec
	Class template that provides a simple vector implementation sufficient to insulate RAJA entities from the STL. More...
class	AtomicRef
	Atomic wrapper object. More...
struct	dynamic_helper
struct	dynamic_helper< 0, POLICY_LIST >
struct	TileSize
struct	tile_fixed
	! tag for a tiling loop More...
struct	tile_dynamic
struct	IterableWrapperTuple
struct	IterableWrapperTuple< camp::tuple< Ts... > >
class	LaunchContextT
struct	null_launch_t
struct	LoopPolicy
struct	LaunchPolicy
struct	Teams
struct	Threads
struct	Lanes
struct	LaunchParams
class	LaunchContextBase
class	LaunchContextT< LaunchContextHostPolicy >
struct	LaunchExecute
struct	LoopExecute
struct	LoopICountExecute
struct	TileExecute
struct	TileTCountExecute
struct	MultiReduceMin
	Min multi reducer class template. More...
struct	MultiReduceMax
	Max multi reducer class template. More...
struct	MultiReduceSum
	Sum multi reducer class template. More...
struct	MultiReduceBitOr
	Bitwise OR multi reducer class template. More...
struct	MultiReduceBitAnd
	Bitwise AND multi reducer class template. More...
class	ReduceMin
	Min reducer class template. More...
class	ReduceMinLoc
	Min-loc reducer class template. More...
class	ReduceMax
	Max reducer class template. More...
class	ReduceMaxLoc
	Max-loc reducer class template. More...
class	ReduceSum
	Sum reducer class template. More...
class	ReduceBitOr
	Bitwise OR reducer class template. More...
class	ReduceBitAnd
	Bitwise AND reducer class template. More...
struct	WorkPool
	WorkPool class template. More...
struct	WorkGroup
	WorkGroup class template. Owns loops from an instantiated WorkPool. More...
struct	WorkSite
	WorkSite class template. Owns per run objects from a single run of a WorkGroup. More...
struct	WorkPool< WorkGroupPolicy< EXEC_POLICY_T, ORDER_POLICY_T, STORAGE_POLICY_T, DISPATCH_POLICY_T >, INDEX_T, xargs< Args... >, ALLOCATOR_T >
struct	WorkGroup< WorkGroupPolicy< EXEC_POLICY_T, ORDER_POLICY_T, STORAGE_POLICY_T, DISPATCH_POLICY_T >, INDEX_T, xargs< Args... >, ALLOCATOR_T >
struct	WorkSite< WorkGroupPolicy< EXEC_POLICY_T, ORDER_POLICY_T, STORAGE_POLICY_T, DISPATCH_POLICY_T >, INDEX_T, xargs< Args... >, ALLOCATOR_T >
struct	auto_atomic
	Atomic policy that automatically does "the right thing". More...
struct	builtin_atomic
	Atomic policy that uses the compilers builtin __atomic_XXX routines. More...
class	LaunchContextT< cuda::LaunchContextIndicesAndDimsPolicy< IndicesAndDimsT > >
struct	LaunchExecute< RAJA::policy::cuda::cuda_launch_explicit_t< async, named_usage::unspecified, named_usage::unspecified > >
struct	LaunchExecute< RAJA::policy::cuda::cuda_launch_explicit_t< async, nthreads, BLOCKS_PER_SM > >
struct	LoopExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_flatten_indexer< RAJA::iteration_mapping::DirectUnchecked, sync, IndexMapper0 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_flatten_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_flatten_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_flatten_indexer< RAJA::iteration_mapping::Direct, sync, IndexMapper0 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_flatten_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_flatten_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_flatten_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, sync, IndexMapper0 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_flatten_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopExecute< RAJA::policy::cuda::cuda_flatten_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	TileExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	TileExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	TileExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	TileExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	TileExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	TileExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	TileExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	TileExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	TileExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::cuda::cuda_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
class	LaunchContextT< hip::LaunchContextIndicesAndDimsPolicy< IndicesAndDimsT > >
struct	LaunchExecute< RAJA::policy::hip::hip_launch_t< async, named_usage::unspecified > >
struct	LaunchExecute< RAJA::policy::hip::hip_launch_t< async, nthreads > >
struct	LoopExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopICountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_flatten_indexer< RAJA::iteration_mapping::DirectUnchecked, sync, IndexMapper0 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_flatten_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_flatten_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_flatten_indexer< RAJA::iteration_mapping::Direct, sync, IndexMapper0 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_flatten_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_flatten_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_flatten_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, sync, IndexMapper0 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_flatten_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	LoopExecute< RAJA::policy::hip::hip_flatten_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	TileExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	TileExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	TileExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	TileExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	TileExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	TileExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	TileExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	TileExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	TileExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::DirectUnchecked, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::Direct, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1 >, SEGMENT >
struct	TileTCountExecute< RAJA::policy::hip::hip_indexer< RAJA::iteration_mapping::StridedLoop< named_usage::unspecified >, kernel_sync_requirement::none, IndexMapper0, IndexMapper1, IndexMapper2 >, SEGMENT >
struct	LaunchExecute< RAJA::omp_launch_t >
struct	LoopExecute< omp_parallel_for_exec, SEGMENT >
struct	LoopExecute< omp_for_exec, SEGMENT >
struct	LoopICountExecute< omp_for_exec, SEGMENT >
struct	LoopExecute< omp_parallel_nested_for_exec, SEGMENT >
struct	LoopICountExecute< omp_parallel_nested_for_exec, SEGMENT >
struct	TileExecute< omp_parallel_for_exec, SEGMENT >
struct	TileTCountExecute< omp_parallel_for_exec, SEGMENT >
struct	TileExecute< omp_for_exec, SEGMENT >
struct	TileTCountExecute< omp_for_exec, SEGMENT >
struct	PolicyBase
struct	PolicyBaseT
struct	policy_of
struct	pattern_of
struct	launch_of
struct	platform_of
struct	policy_is
struct	policy_any_of
struct	pattern_is
struct	launch_is
struct	platform_is
struct	policy_has_trait_impl
struct	policy_has_trait_impl< PolicyBaseT< Policy_, Pattern_, Launch_, Platform_, Traits... >, Trait >
struct	wrapper
struct	LaunchExecute< RAJA::null_launch_t >
struct	LaunchExecute< RAJA::seq_launch_t >
struct	LoopExecute< seq_exec, SEGMENT >
struct	LoopICountExecute< seq_exec, SEGMENT >
struct	TileExecute< seq_exec, SEGMENT >
struct	TileTCountExecute< seq_exec, SEGMENT >
struct	LoopExecute< simd_exec, SEGMENT >
struct	LoopICountExecute< simd_exec, SEGMENT >
struct	LaunchExecute< RAJA::sycl_launch_t< async, 0 > >
struct	sycl_global_item
struct	LoopExecute< sycl_global_item< DIM >, SEGMENT >
struct	LoopExecute< sycl_global_item< DIM0, DIM1 >, SEGMENT >
struct	LoopExecute< sycl_global_item< DIM0, DIM1, DIM2 >, SEGMENT >
struct	sycl_flatten_group_local_direct
struct	sycl_flatten_group_local_loop
struct	LoopExecute< sycl_flatten_group_local_direct< DIM0, DIM1 >, SEGMENT >
struct	LoopExecute< sycl_flatten_group_local_loop< DIM0, DIM1 >, SEGMENT >
struct	LoopExecute< sycl_flatten_group_local_direct< DIM0, DIM1, DIM2 >, SEGMENT >
struct	LoopExecute< sycl_flatten_group_local_loop< DIM0, DIM1, DIM2 >, SEGMENT >
struct	LoopExecute< sycl_local_012_loop< DIM >, SEGMENT >
struct	LoopExecute< sycl_local_012_direct< DIM >, SEGMENT >
struct	LoopExecute< sycl_group_012_loop< DIM >, SEGMENT >
struct	LoopExecute< sycl_group_012_direct< DIM >, SEGMENT >
struct	LoopICountExecute< sycl_local_012_loop< DIM >, SEGMENT >
struct	LoopICountExecute< sycl_local_012_direct< DIM >, SEGMENT >
struct	LoopICountExecute< sycl_group_012_loop< DIM >, SEGMENT >
struct	LoopICountExecute< sycl_group_012_direct< DIM >, SEGMENT >
struct	LoopExecute< sycl_group_012_direct< DIM0, DIM1 >, SEGMENT >
struct	LoopExecute< sycl_group_012_direct< DIM0, DIM1, DIM2 >, SEGMENT >
struct	LoopICountExecute< sycl_group_012_direct< DIM0, DIM1 >, SEGMENT >
struct	LoopICountExecute< sycl_group_012_direct< DIM0, DIM1, DIM2 >, SEGMENT >
struct	LoopExecute< sycl_group_012_loop< DIM0, DIM1 >, SEGMENT >
struct	LoopExecute< sycl_group_012_loop< DIM0, DIM1, DIM2 >, SEGMENT >
struct	LoopICountExecute< sycl_group_012_loop< DIM0, DIM1 >, SEGMENT >
struct	LoopICountExecute< sycl_group_012_loop< DIM0, DIM1, DIM2 >, SEGMENT >
struct	TileExecute< sycl_local_012_loop< DIM >, SEGMENT >
struct	TileExecute< sycl_local_012_direct< DIM >, SEGMENT >
struct	TileExecute< sycl_group_012_loop< DIM >, SEGMENT >
struct	TileExecute< sycl_group_012_direct< DIM >, SEGMENT >
struct	TileTCountExecute< sycl_local_012_loop< DIM >, SEGMENT >
struct	TileTCountExecute< sycl_local_012_direct< DIM >, SEGMENT >
struct	TileTCountExecute< sycl_group_012_loop< DIM >, SEGMENT >
struct	TileTCountExecute< sycl_group_012_direct< DIM >, SEGMENT >
struct	LogBase2
struct	LogBase2< 0 >
struct	BitMask
struct	CombiningAdapter
	A holder for adapting lambdas meant for multidimensional index spaces to allow their use in 1-dimensional index spaces. More...
struct	DirectIndex
struct	IndexList
struct	ConditionalIndexList
struct	IndexLayout
struct	TypedLayout
struct	TypedLayout< IdxLin, camp::tuple< DimTypes... >, StrideOne >
struct	AtomicTypedLocalArray
struct	AtomicTypedLocalArray< AtomicPolicy, DataType, camp::idx_seq< Perm... >, RAJA::SizeList< Sizes... >, IndexTypes... >
struct	OffsetLayout
struct	TypedOffsetLayout
struct	TypedOffsetLayout< IdxLin, camp::tuple< DimTypes... > >
struct	GetOffsetLeft
struct	GetOffsetRight
struct	GetOffsetLeftBunched
struct	as_array
struct	as_array< camp::idx_seq< Indices... > >
struct	LeftFoldReduce
	Reduce class that does a reduction with a left fold. More...
struct	BinaryTreeReduce
	Reduce class that does a reduction with a binary tree. More...
struct	KahanSum
	Reduce class that does a reduction with a left fold. More...
struct	RepeatView
	A view of a single object repeated a certain number of times. More...
struct	Span
	A view to a sequence of objects. More...
class	Timer
struct	SizeList
struct	Fraction
struct	add_offset
struct	add_offset< RAJA::TypedLayout< IdxLin, camp::tuple< DimTypes... > > >
struct	cat_seq
struct	cat_seq< camp::idx_seq< Idxs1... >, camp::idx_seq< Idxs2... > >
struct	offset_seq
struct	offset_seq< Offset, camp::idx_seq< Idxs... > >
struct	MultiView
struct	AtomicViewWrapper
struct	AtomicViewWrapper< ViewType, RAJA::seq_atomic >
struct	layout_left
struct	layout_right
struct	ZipIterator
	ZipIterator class for simultaneously iterating over multiple iterators. This is not a standards compliant iterator. More...
struct	CompareFirst
	Comparator object that compares the first member of tuple like objects. More...
struct	zip_tuple
	Tuple used by ZipIterator for storing multiple references and values. Acts like a reference to its members allowing copy/move construction/assignment based on the reference type of the zip_tuple. More...
struct	zip_tuple_element
struct	zip_tuple_element< I, zip_tuple< is_val, Ts... > >

Typedefs
template<typename FROM >
using	strip_index_type_t = typename internal::StripIndexTypeT< FROM >::type
	Strips a strongly typed index to its underlying type In the case of a non-strongly typed index, the original type is returned. More...
template<typename FROM >
using	make_signed_t = typename std::conditional< std::is_floating_point< FROM >::value, std::common_type< FROM >, std::make_signed< FROM > >::type::type
	Converts a type into a signed type. Also handles floating point types as std::make_signed only supports integral types. More...
using	ListSegment = TypedListSegment< Index_type >
	Alias for A TypedListSegment<Index_type> More...
using	RangeSegment = TypedRangeSegment< Index_type >
	Alias for TypedRangeSegment<Index_type> More...
using	RangeStrideSegment = TypedRangeStrideSegment< Index_type >
	Alias for TypedRangeStrideSegment<Index_type> More...
template<camp::idx_t... args>
using	Segs = camp::list< internal::LambdaArg< internal::lambda_arg_seg_t, args >... >
template<camp::idx_t... args>
using	Offsets = camp::list< internal::LambdaArg< internal::lambda_arg_offset_t, args >... >
template<camp::idx_t... args>
using	Params = camp::list< internal::LambdaArg< internal::lambda_arg_param_t, args >... >
template<typename T , camp::idx_t... values>
using	ValuesT = camp::list< internal::LambdaArg< internal::lambda_arg_value_t< T >, values >... >
template<typename... Stmts>
using	KernelPolicy = internal::StatementList< Stmts... >
template<camp::idx_t... ArgumentId>
using	ArgList = camp::idx_seq< ArgumentId... >
using	LaunchContext = LaunchContextT< LaunchContextHostPolicy >
template<typename POLICY_LIST >
using	loop_policy = typename POLICY_LIST::host_policy_t
template<typename... Args>
using	xargs = camp::list< Args... >
	xargs alias. More...
using	LaunchContextType = typename RAJA::detail::launch_context_type< BODY >::type
template<typename PolicyType , typename Trait >
using	policy_has_trait = policy_has_trait_impl< camp::decay< PolicyType >, Trait >
template<Policy Pol, Pattern Pat, typename... Args>
using	make_policy_pattern_t = PolicyBaseT< Pol, Pat, Launch::undefined, Platform::undefined, Args... >
template<Policy Policy_, Pattern Pattern_, Launch Launch_, Platform Platform_, typename... Args>
using	make_policy_pattern_launch_platform_t = PolicyBaseT< Policy_, Pattern_, Launch_, Platform_, Args... >
template<Policy Policy_, Pattern Pattern_, Launch Launch_, typename... Args>
using	make_policy_pattern_launch_t = PolicyBaseT< Policy_, Pattern_, Launch_, Platform::undefined, Args... >
template<Policy Policy_, Pattern Pattern_, Platform Platform_, typename... Args>
using	make_policy_pattern_platform_t = PolicyBaseT< Policy_, Pattern_, Launch::undefined, Platform_, Args... >
using	sycl_global_item_0 = sycl_global_item< 0 >
using	sycl_global_item_1 = sycl_global_item< 1 >
using	sycl_global_item_2 = sycl_global_item< 2 >
using	sycl_global_item_01 = sycl_global_item< 0, 1 >
using	sycl_global_item_02 = sycl_global_item< 0, 2 >
using	sycl_global_item_10 = sycl_global_item< 1, 0 >
using	sycl_global_item_12 = sycl_global_item< 1, 2 >
using	sycl_global_item_20 = sycl_global_item< 2, 0 >
using	sycl_global_item_21 = sycl_global_item< 2, 1 >
using	sycl_global_item_012 = sycl_global_item< 0, 1, 2 >
using	sycl_global_item_021 = sycl_global_item< 0, 2, 1 >
using	sycl_global_item_102 = sycl_global_item< 1, 0, 2 >
using	sycl_global_item_120 = sycl_global_item< 1, 2, 0 >
using	sycl_global_item_201 = sycl_global_item< 2, 0, 1 >
using	sycl_global_item_210 = sycl_global_item< 2, 1, 0 >
using	sycl_flatten_group_local_01_direct = sycl_flatten_group_local_direct< 0, 1 >
using	sycl_flatten_group_local_02_direct = sycl_flatten_group_local_direct< 0, 2 >
using	sycl_flatten_group_local_10_direct = sycl_flatten_group_local_direct< 1, 0 >
using	sycl_flatten_group_local_12_direct = sycl_flatten_group_local_direct< 1, 2 >
using	sycl_flatten_group_local_20_direct = sycl_flatten_group_local_direct< 2, 0 >
using	sycl_flatten_group_local_21_direct = sycl_flatten_group_local_direct< 2, 1 >
using	sycl_flatten_group_local_012_direct = sycl_flatten_group_local_direct< 0, 1, 2 >
using	sycl_flatten_group_local_021_direct = sycl_flatten_group_local_direct< 0, 2, 1 >
using	sycl_flatten_group_local_102_direct = sycl_flatten_group_local_direct< 1, 0, 2 >
using	sycl_flatten_group_local_120_direct = sycl_flatten_group_local_direct< 1, 2, 0 >
using	sycl_flatten_group_local_201_direct = sycl_flatten_group_local_direct< 2, 0, 1 >
using	sycl_flatten_group_local_210_direct = sycl_flatten_group_local_direct< 2, 1, 0 >
using	sycl_flatten_group_local_01_loop = sycl_flatten_group_local_loop< 0, 1 >
using	sycl_flatten_group_local_02_loop = sycl_flatten_group_local_loop< 0, 2 >
using	sycl_flatten_group_local_10_loop = sycl_flatten_group_local_loop< 1, 0 >
using	sycl_flatten_group_local_12_loop = sycl_flatten_group_local_loop< 1, 2 >
using	sycl_flatten_group_local_20_loop = sycl_flatten_group_local_loop< 2, 0 >
using	sycl_flatten_group_local_21_loop = sycl_flatten_group_local_loop< 2, 1 >
using	sycl_flatten_group_local_012_loop = sycl_flatten_group_local_loop< 0, 1, 2 >
using	sycl_flatten_group_local_021_loop = sycl_flatten_group_local_loop< 0, 2, 1 >
using	sycl_flatten_group_local_102_loop = sycl_flatten_group_local_loop< 1, 0, 2 >
using	sycl_flatten_group_local_120_loop = sycl_flatten_group_local_loop< 1, 2, 0 >
using	sycl_flatten_group_local_201_loop = sycl_flatten_group_local_loop< 2, 0, 1 >
using	sycl_flatten_group_local_210_loop = sycl_flatten_group_local_loop< 2, 1, 0 >
using	sycl_group_01_nested_direct = sycl_group_012_direct< 0, 1 >
using	sycl_group_02_nested_direct = sycl_group_012_direct< 0, 2 >
using	sycl_group_10_nested_direct = sycl_group_012_direct< 1, 0 >
using	sycl_group_12_nested_direct = sycl_group_012_direct< 1, 2 >
using	sycl_group_20_nested_direct = sycl_group_012_direct< 2, 0 >
using	sycl_group_21_nested_direct = sycl_group_012_direct< 2, 1 >
using	sycl_group_012_nested_direct = sycl_group_012_direct< 0, 1, 2 >
using	sycl_group_021_nested_direct = sycl_group_012_direct< 0, 2, 1 >
using	sycl_group_102_nested_direct = sycl_group_012_direct< 1, 0, 2 >
using	sycl_group_120_nested_direct = sycl_group_012_direct< 1, 2, 0 >
using	sycl_group_201_nested_direct = sycl_group_012_direct< 2, 0, 1 >
using	sycl_group_210_nested_direct = sycl_group_012_direct< 2, 1, 0 >
using	sycl_group_01_nested_loop = sycl_group_012_loop< 0, 1 >
using	sycl_group_02_nested_loop = sycl_group_012_loop< 0, 2 >
using	sycl_group_10_nested_loop = sycl_group_012_loop< 1, 0 >
using	sycl_group_12_nested_loop = sycl_group_012_loop< 1, 2 >
using	sycl_group_20_nested_loop = sycl_group_012_loop< 2, 0 >
using	sycl_group_21_nested_loop = sycl_group_012_loop< 2, 1 >
using	sycl_group_012_nested_loop = sycl_group_012_loop< 0, 1, 2 >
using	sycl_group_021_nested_loop = sycl_group_012_loop< 0, 2, 1 >
using	sycl_group_102_nested_loop = sycl_group_012_loop< 1, 0, 2 >
using	sycl_group_120_nested_loop = sycl_group_012_loop< 1, 2, 0 >
using	sycl_group_201_nested_loop = sycl_group_012_loop< 2, 0, 1 >
using	sycl_group_210_nested_loop = sycl_group_012_loop< 2, 1, 0 >
template<size_t n_dims, typename IdxLin = Index_type, ptrdiff_t StrideOne = -1>
using	Layout = detail::LayoutBase_impl< camp::make_idx_seq_t< n_dims >, IdxLin, StrideOne >
	A mapping of n-dimensional index space to a linear index space. More...
template<camp::idx_t... Sizes>
using	ParamList = camp::idx_seq< Sizes... >
template<typename ValueType , typename Perm , typename Sizes , typename... IndexTypes>
using	TypedLocalArray = internal::TypedViewBase< ValueType, ValueType *, internal::getStaticLayoutType< Perm, Sizes >, camp::list< IndexTypes... > >
template<typename ValueType , typename Perm , typename Sizes >
using	LocalArray = internal::TypedViewBase< ValueType, ValueType *, internal::getStaticLayoutType< Perm, Sizes >, internal::getDefaultIndexTypes< Perm > >
using	PERM_I = camp::idx_seq< 0 >
using	PERM_IJ = camp::idx_seq< 0, 1 >
using	PERM_JI = camp::idx_seq< 1, 0 >
using	PERM_IJK = camp::idx_seq< 0, 1, 2 >
using	PERM_IKJ = camp::idx_seq< 0, 2, 1 >
using	PERM_JIK = camp::idx_seq< 1, 0, 2 >
using	PERM_JKI = camp::idx_seq< 1, 2, 0 >
using	PERM_KIJ = camp::idx_seq< 2, 0, 1 >
using	PERM_KJI = camp::idx_seq< 2, 1, 0 >
using	PERM_IJKL = camp::idx_seq< 0, 1, 2, 3 >
using	PERM_IJLK = camp::idx_seq< 0, 1, 3, 2 >
using	PERM_IKJL = camp::idx_seq< 0, 2, 1, 3 >
using	PERM_IKLJ = camp::idx_seq< 0, 2, 3, 1 >
using	PERM_ILJK = camp::idx_seq< 0, 3, 1, 2 >
using	PERM_ILKJ = camp::idx_seq< 0, 3, 2, 1 >
using	PERM_JIKL = camp::idx_seq< 1, 0, 2, 3 >
using	PERM_JILK = camp::idx_seq< 1, 0, 3, 2 >
using	PERM_JKIL = camp::idx_seq< 1, 2, 0, 3 >
using	PERM_JKLI = camp::idx_seq< 1, 2, 3, 0 >
using	PERM_JLIK = camp::idx_seq< 1, 3, 0, 2 >
using	PERM_JLKI = camp::idx_seq< 1, 3, 2, 0 >
using	PERM_KIJL = camp::idx_seq< 2, 0, 1, 3 >
using	PERM_KILJ = camp::idx_seq< 2, 0, 3, 1 >
using	PERM_KJIL = camp::idx_seq< 2, 1, 0, 3 >
using	PERM_KJLI = camp::idx_seq< 2, 1, 3, 0 >
using	PERM_KLIJ = camp::idx_seq< 2, 3, 0, 1 >
using	PERM_KLJI = camp::idx_seq< 2, 3, 1, 0 >
using	PERM_LIJK = camp::idx_seq< 3, 0, 1, 2 >
using	PERM_LIKJ = camp::idx_seq< 3, 0, 2, 1 >
using	PERM_LJIK = camp::idx_seq< 3, 1, 0, 2 >
using	PERM_LJKI = camp::idx_seq< 3, 1, 2, 0 >
using	PERM_LKIJ = camp::idx_seq< 3, 2, 0, 1 >
using	PERM_LKJI = camp::idx_seq< 3, 2, 1, 0 >
using	PERM_IJKLM = camp::idx_seq< 0, 1, 2, 3, 4 >
using	PERM_IJKML = camp::idx_seq< 0, 1, 2, 4, 3 >
using	PERM_IJLKM = camp::idx_seq< 0, 1, 3, 2, 4 >
using	PERM_IJLMK = camp::idx_seq< 0, 1, 3, 4, 2 >
using	PERM_IJMKL = camp::idx_seq< 0, 1, 4, 2, 3 >
using	PERM_IJMLK = camp::idx_seq< 0, 1, 4, 3, 2 >
using	PERM_IKJLM = camp::idx_seq< 0, 2, 1, 3, 4 >
using	PERM_IKJML = camp::idx_seq< 0, 2, 1, 4, 3 >
using	PERM_IKLJM = camp::idx_seq< 0, 2, 3, 1, 4 >
using	PERM_IKLMJ = camp::idx_seq< 0, 2, 3, 4, 1 >
using	PERM_IKMJL = camp::idx_seq< 0, 2, 4, 1, 3 >
using	PERM_IKMLJ = camp::idx_seq< 0, 2, 4, 3, 1 >
using	PERM_ILJKM = camp::idx_seq< 0, 3, 1, 2, 4 >
using	PERM_ILJMK = camp::idx_seq< 0, 3, 1, 4, 2 >
using	PERM_ILKJM = camp::idx_seq< 0, 3, 2, 1, 4 >
using	PERM_ILKMJ = camp::idx_seq< 0, 3, 2, 4, 1 >
using	PERM_ILMJK = camp::idx_seq< 0, 3, 4, 1, 2 >
using	PERM_ILMKJ = camp::idx_seq< 0, 3, 4, 2, 1 >
using	PERM_IMJKL = camp::idx_seq< 0, 4, 1, 2, 3 >
using	PERM_IMJLK = camp::idx_seq< 0, 4, 1, 3, 2 >
using	PERM_IMKJL = camp::idx_seq< 0, 4, 2, 1, 3 >
using	PERM_IMKLJ = camp::idx_seq< 0, 4, 2, 3, 1 >
using	PERM_IMLJK = camp::idx_seq< 0, 4, 3, 1, 2 >
using	PERM_IMLKJ = camp::idx_seq< 0, 4, 3, 2, 1 >
using	PERM_JIKLM = camp::idx_seq< 1, 0, 2, 3, 4 >
using	PERM_JIKML = camp::idx_seq< 1, 0, 2, 4, 3 >
using	PERM_JILKM = camp::idx_seq< 1, 0, 3, 2, 4 >
using	PERM_JILMK = camp::idx_seq< 1, 0, 3, 4, 2 >
using	PERM_JIMKL = camp::idx_seq< 1, 0, 4, 2, 3 >
using	PERM_JIMLK = camp::idx_seq< 1, 0, 4, 3, 2 >
using	PERM_JKILM = camp::idx_seq< 1, 2, 0, 3, 4 >
using	PERM_JKIML = camp::idx_seq< 1, 2, 0, 4, 3 >
using	PERM_JKLIM = camp::idx_seq< 1, 2, 3, 0, 4 >
using	PERM_JKLMI = camp::idx_seq< 1, 2, 3, 4, 0 >
using	PERM_JKMIL = camp::idx_seq< 1, 2, 4, 0, 3 >
using	PERM_JKMLI = camp::idx_seq< 1, 2, 4, 3, 0 >
using	PERM_JLIKM = camp::idx_seq< 1, 3, 0, 2, 4 >
using	PERM_JLIMK = camp::idx_seq< 1, 3, 0, 4, 2 >
using	PERM_JLKIM = camp::idx_seq< 1, 3, 2, 0, 4 >
using	PERM_JLKMI = camp::idx_seq< 1, 3, 2, 4, 0 >
using	PERM_JLMIK = camp::idx_seq< 1, 3, 4, 0, 2 >
using	PERM_JLMKI = camp::idx_seq< 1, 3, 4, 2, 0 >
using	PERM_JMIKL = camp::idx_seq< 1, 4, 0, 2, 3 >
using	PERM_JMILK = camp::idx_seq< 1, 4, 0, 3, 2 >
using	PERM_JMKIL = camp::idx_seq< 1, 4, 2, 0, 3 >
using	PERM_JMKLI = camp::idx_seq< 1, 4, 2, 3, 0 >
using	PERM_JMLIK = camp::idx_seq< 1, 4, 3, 0, 2 >
using	PERM_JMLKI = camp::idx_seq< 1, 4, 3, 2, 0 >
using	PERM_KIJLM = camp::idx_seq< 2, 0, 1, 3, 4 >
using	PERM_KIJML = camp::idx_seq< 2, 0, 1, 4, 3 >
using	PERM_KILJM = camp::idx_seq< 2, 0, 3, 1, 4 >
using	PERM_KILMJ = camp::idx_seq< 2, 0, 3, 4, 1 >
using	PERM_KIMJL = camp::idx_seq< 2, 0, 4, 1, 3 >
using	PERM_KIMLJ = camp::idx_seq< 2, 0, 4, 3, 1 >
using	PERM_KJILM = camp::idx_seq< 2, 1, 0, 3, 4 >
using	PERM_KJIML = camp::idx_seq< 2, 1, 0, 4, 3 >
using	PERM_KJLIM = camp::idx_seq< 2, 1, 3, 0, 4 >
using	PERM_KJLMI = camp::idx_seq< 2, 1, 3, 4, 0 >
using	PERM_KJMIL = camp::idx_seq< 2, 1, 4, 0, 3 >
using	PERM_KJMLI = camp::idx_seq< 2, 1, 4, 3, 0 >
using	PERM_KLIJM = camp::idx_seq< 2, 3, 0, 1, 4 >
using	PERM_KLIMJ = camp::idx_seq< 2, 3, 0, 4, 1 >
using	PERM_KLJIM = camp::idx_seq< 2, 3, 1, 0, 4 >
using	PERM_KLJMI = camp::idx_seq< 2, 3, 1, 4, 0 >
using	PERM_KLMIJ = camp::idx_seq< 2, 3, 4, 0, 1 >
using	PERM_KLMJI = camp::idx_seq< 2, 3, 4, 1, 0 >
using	PERM_KMIJL = camp::idx_seq< 2, 4, 0, 1, 3 >
using	PERM_KMILJ = camp::idx_seq< 2, 4, 0, 3, 1 >
using	PERM_KMJIL = camp::idx_seq< 2, 4, 1, 0, 3 >
using	PERM_KMJLI = camp::idx_seq< 2, 4, 1, 3, 0 >
using	PERM_KMLIJ = camp::idx_seq< 2, 4, 3, 0, 1 >
using	PERM_KMLJI = camp::idx_seq< 2, 4, 3, 1, 0 >
using	PERM_LIJKM = camp::idx_seq< 3, 0, 1, 2, 4 >
using	PERM_LIJMK = camp::idx_seq< 3, 0, 1, 4, 2 >
using	PERM_LIKJM = camp::idx_seq< 3, 0, 2, 1, 4 >
using	PERM_LIKMJ = camp::idx_seq< 3, 0, 2, 4, 1 >
using	PERM_LIMJK = camp::idx_seq< 3, 0, 4, 1, 2 >
using	PERM_LIMKJ = camp::idx_seq< 3, 0, 4, 2, 1 >
using	PERM_LJIKM = camp::idx_seq< 3, 1, 0, 2, 4 >
using	PERM_LJIMK = camp::idx_seq< 3, 1, 0, 4, 2 >
using	PERM_LJKIM = camp::idx_seq< 3, 1, 2, 0, 4 >
using	PERM_LJKMI = camp::idx_seq< 3, 1, 2, 4, 0 >
using	PERM_LJMIK = camp::idx_seq< 3, 1, 4, 0, 2 >
using	PERM_LJMKI = camp::idx_seq< 3, 1, 4, 2, 0 >
using	PERM_LKIJM = camp::idx_seq< 3, 2, 0, 1, 4 >
using	PERM_LKIMJ = camp::idx_seq< 3, 2, 0, 4, 1 >
using	PERM_LKJIM = camp::idx_seq< 3, 2, 1, 0, 4 >
using	PERM_LKJMI = camp::idx_seq< 3, 2, 1, 4, 0 >
using	PERM_LKMIJ = camp::idx_seq< 3, 2, 4, 0, 1 >
using	PERM_LKMJI = camp::idx_seq< 3, 2, 4, 1, 0 >
using	PERM_LMIJK = camp::idx_seq< 3, 4, 0, 1, 2 >
using	PERM_LMIKJ = camp::idx_seq< 3, 4, 0, 2, 1 >
using	PERM_LMJIK = camp::idx_seq< 3, 4, 1, 0, 2 >
using	PERM_LMJKI = camp::idx_seq< 3, 4, 1, 2, 0 >
using	PERM_LMKIJ = camp::idx_seq< 3, 4, 2, 0, 1 >
using	PERM_LMKJI = camp::idx_seq< 3, 4, 2, 1, 0 >
using	PERM_MIJKL = camp::idx_seq< 4, 0, 1, 2, 3 >
using	PERM_MIJLK = camp::idx_seq< 4, 0, 1, 3, 2 >
using	PERM_MIKJL = camp::idx_seq< 4, 0, 2, 1, 3 >
using	PERM_MIKLJ = camp::idx_seq< 4, 0, 2, 3, 1 >
using	PERM_MILJK = camp::idx_seq< 4, 0, 3, 1, 2 >
using	PERM_MILKJ = camp::idx_seq< 4, 0, 3, 2, 1 >
using	PERM_MJIKL = camp::idx_seq< 4, 1, 0, 2, 3 >
using	PERM_MJILK = camp::idx_seq< 4, 1, 0, 3, 2 >
using	PERM_MJKIL = camp::idx_seq< 4, 1, 2, 0, 3 >
using	PERM_MJKLI = camp::idx_seq< 4, 1, 2, 3, 0 >
using	PERM_MJLIK = camp::idx_seq< 4, 1, 3, 0, 2 >
using	PERM_MJLKI = camp::idx_seq< 4, 1, 3, 2, 0 >
using	PERM_MKIJL = camp::idx_seq< 4, 2, 0, 1, 3 >
using	PERM_MKILJ = camp::idx_seq< 4, 2, 0, 3, 1 >
using	PERM_MKJIL = camp::idx_seq< 4, 2, 1, 0, 3 >
using	PERM_MKJLI = camp::idx_seq< 4, 2, 1, 3, 0 >
using	PERM_MKLIJ = camp::idx_seq< 4, 2, 3, 0, 1 >
using	PERM_MKLJI = camp::idx_seq< 4, 2, 3, 1, 0 >
using	PERM_MLIJK = camp::idx_seq< 4, 3, 0, 1, 2 >
using	PERM_MLIKJ = camp::idx_seq< 4, 3, 0, 2, 1 >
using	PERM_MLJIK = camp::idx_seq< 4, 3, 1, 0, 2 >
using	PERM_MLJKI = camp::idx_seq< 4, 3, 1, 2, 0 >
using	PERM_MLKIJ = camp::idx_seq< 4, 3, 2, 0, 1 >
using	PERM_MLKJI = camp::idx_seq< 4, 3, 2, 1, 0 >
template<typename Perm >
using	invert_permutation = typename internal::InversePermutationHelper< camp::make_idx_seq_t< camp::size< Perm >::value >, Perm >::type
template<camp::idx_t... Ints>
using	Perm = camp::idx_seq< Ints... >
template<camp::idx_t N>
using	MakePerm = typename camp::make_idx_seq< N >::type
template<typename T , typename BinaryOp >
using	HighAccuracyReduce = std::conditional_t< RAJA::operators::is_fp_associative< T >::value, BinaryTreeReduce< T, BinaryOp >, LeftFoldReduce< T, BinaryOp > >
template<typename Perm , typename IdxLin , camp::idx_t... Sizes>
using	StaticLayoutT = typename detail::StaticLayoutMaker< Perm, IdxLin, camp::int_seq< IdxLin, Sizes... >, camp::make_int_seq_t< IdxLin, sizeof...(Sizes)>, void >::type
template<typename Perm , camp::idx_t... Sizes>
using	StaticLayout = StaticLayoutT< Perm, camp::idx_t, Sizes... >
template<typename Perm , typename IdxLin , typename TypeList , camp::idx_t... Sizes>
using	TypedStaticLayout = typename detail::StaticLayoutMaker< Perm, IdxLin, camp::int_seq< IdxLin, Sizes... >, camp::make_int_seq_t< IdxLin, sizeof...(Sizes)>, TypeList >::type
using	Index_type = std::ptrdiff_t
using	TDRAReal_ptr = Real_type *RAJA_RESTRICT
	RAJA scalar type definitions. More...
using	const_TDRAReal_ptr = const TDRAReal_ptr
template<typename ValueType , typename LayoutType , typename PointerType = ValueType*>
using	View = internal::ViewBase< ValueType, PointerType, LayoutType >
template<typename ValueType , typename LayoutType , typename... IndexTypes>
using	TypedView = internal::TypedViewBase< ValueType, ValueType *, LayoutType, camp::list< IndexTypes... > >
template<typename Seq1 , typename Seq2 >
using	cat_seq_t = typename cat_seq< Seq1, Seq2 >::type
template<camp::idx_t Offset, typename Seq >
using	offset_seq_t = typename offset_seq< Offset, Seq >::type
template<camp::idx_t I, typename ZT >
using	zip_tuple_element_t = typename zip_tuple_element< I, ZT >::type
template<typename... Ts>
using	zip_ref = zip_tuple< false, Ts... >
template<typename... Ts>
using	zip_val = zip_tuple< true, Ts... >

Enumerations
enum	PushEnd { PUSH_FRONT , PUSH_BACK }
enum	PushCopy { PUSH_COPY , PUSH_NOCOPY }
enum class	ExecPlace : int { HOST , DEVICE , NUM_PLACES }
enum class	Policy {   undefined , sequential , simd , openmp ,   target_openmp , cuda , hip , sycl }
enum class	Pattern {   undefined , forall , region , reduce ,   multi_reduce , taskgraph , synchronize , workgroup ,   workgroup_exec , workgroup_order , workgroup_storage , workgroup_dispatch }
enum class	Launch { undefined , sync , async }
enum class	KahanSumImplementation { Default , Volatile }
enum	named_usage : int { ignored = -1 , unspecified = 0 }
enum class	named_dim : int { x = 0 , y = 1 , z = 2 }
enum class	kernel_sync_requirement : int { none = 0 , sync = 1 }
enum	IndexOwnership { Unowned , Owned }

Functions
void	buildIndexSetAligned (RAJA::TypedIndexSet< RAJA::RangeSegment, RAJA::ListSegment > &iset, camp::resources::Resource work_res, const RAJA::Index_type *const indices_in, RAJA::Index_type length, RAJA::Index_type range_min_length, RAJA::Index_type range_align)
	Generate an index set with aligned Range segments and List segments, as needed, from given array of indices. More...
void	buildLockFreeBlockIndexset (RAJA::TypedIndexSet< RAJA::RangeSegment > &iset, int fastDim, int midDim, int slowDim)
	Generate a lock-free "block" index set (planar division) containing range segments. More...
void	buildLockFreeColorIndexset (RAJA::TypedIndexSet< RAJA::RangeSegment, RAJA::ListSegment > &iset, camp::resources::Resource work_res, RAJA::Index_type const *domainToRange, int numEntity, int numRangePerDomain, int numEntityRange, RAJA::Index_type *elemPermutation=nullptr, RAJA::Index_type *ielemPermutation=nullptr)
	Generate a lock-free "color" index set containing range and list segments. More...
template<typename TO , typename FROM >
constexpr RAJA_HOST_DEVICE RAJA_INLINE TO	convertIndex (FROM const val)
	Function provides a way to take either an int or any Index<> type, and convert it to another type, possibly another Index or an int. More...
template<typename FROM >
constexpr RAJA_HOST_DEVICE RAJA_INLINE std::enable_if< std::is_base_of< IndexValueBase, FROM >::value, typename FROM::value_type >::type	stripIndexType (FROM const val)
	Function that strips the strongly typed Index<> and returns its underlying value_type value. More...
template<typename FROM >
constexpr RAJA_HOST_DEVICE RAJA_INLINE std::enable_if<!std::is_base_of< IndexValueBase, FROM >::value, FROM >::type	stripIndexType (FROM const val)
template<typename BeginT , typename EndT , typename Common = detail::common_type_t<BeginT, EndT>>
RAJA_HOST_DEVICE TypedRangeSegment< Common >	make_range (BeginT &&begin, EndT &&end)
	Function to make a TypedRangeSegment for the interval [begin, end) More...
template<typename BeginT , typename EndT , typename StrideT , typename Common = detail::common_type_t<BeginT, EndT>>
RAJA_HOST_DEVICE TypedRangeStrideSegment< Common >	make_strided_range (BeginT &&begin, EndT &&end, StrideT &&stride)
	Function to make a TypedRangeStride Segment for the interval [begin, end) with given stride. More...
class	RAJA_ALIGNED_ATTR (256) DepGraphNode
	Class defining a simple semephore-based data structure for managing a node in a dependency graph. More...
template<typename Op , typename Arg1 >
RAJA_HOST_DEVICE constexpr RAJA_INLINE auto	foldl (Op &&RAJA_UNUSED_ARG(operation), Arg1 &&arg) -> typename detail::foldl_impl< Op, Arg1 >::Ret
template<typename Op , typename Arg1 , typename Arg2 >
RAJA_HOST_DEVICE constexpr RAJA_INLINE auto	foldl (Op &&operation, Arg1 &&arg1, Arg2 &&arg2) -> typename detail::foldl_impl< Op, Arg1, Arg2 >::Ret
template<typename Op , typename Arg1 , typename Arg2 , typename Arg3 , typename... Rest>
RAJA_HOST_DEVICE constexpr RAJA_INLINE auto	foldl (Op &&operation, Arg1 &&arg1, Arg2 &&arg2, Arg3 &&arg3, Rest &&... rest) -> typename detail::foldl_impl< Op, Arg1, Arg2, Arg3, Rest... >::Ret
template<typename Result , typename... Args>
RAJA_HOST_DEVICE constexpr RAJA_INLINE Result	sum (Args... args)
template<typename Result , typename... Args>
RAJA_HOST_DEVICE constexpr RAJA_INLINE Result	product (Args... args)
template<typename Result , typename... Args>
RAJA_HOST_DEVICE constexpr RAJA_INLINE Result	max (Args... args)
template<typename Result , typename... Args>
RAJA_HOST_DEVICE constexpr RAJA_INLINE Result	min (Args... args)
void *	allocate_aligned (size_t alignment, size_t size)
template<typename T >
T *	allocate_aligned_type (size_t alignment, size_t size)
void	free_aligned (void *ptr)
template<typename ThreadPolicy = RAJA::detail::active_auto_thread>
RAJA_INLINE int	getMaxOMPThreadsCPU ()
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicLoad (T *acc)
	Atomic load. More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE void	atomicStore (T *acc, T value)
	Atomic store. More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicAdd (T *acc, T value)
	Atomic add. More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicSub (T *acc, T value)
	Atomic subtract. More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicMin (T *acc, T value)
	Atomic minimum equivalent to (*acc) = std::min(*acc, value) More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicMax (T *acc, T value)
	Atomic maximum equivalent to (*acc) = std::max(*acc, value) More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicInc (T *acc)
	Atomic increment. More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicInc (T *acc, T compare)
	Atomic increment with bound Equivalent to *acc = ((*acc >= compare) ? 0 : ((*acc)+1)) This is for compatability with the CUDA atomicInc. More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicDec (T *acc)
	Atomic decrement. More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicDec (T *acc, T compare)
	Atomic decrement with bound Equivalent to *acc = (((*acc==0)|(*acc>compare))?compare:((*acc)-1)) This is for compatability with the CUDA atomicDec. More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicAnd (T *acc, T value)
	Atomic bitwise AND equivalent to (*acc) = (*acc) & value This only works with integral data types. More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicOr (T *acc, T value)
	Atomic bitwise OR equivalent to (*acc) = (*acc) | value This only works with integral data types. More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicXor (T *acc, T value)
	Atomic bitwise XOR equivalent to (*acc) = (*acc) ^ value This only works with integral data types. More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicExchange (T *acc, T value)
	Atomic value exchange. More...
template<typename Policy , typename T >
RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T	atomicCAS (T *acc, T compare, T value)
	Atomic compare and swap. More...
template<typename Iter >
RAJA_HOST_DEVICE RAJA_INLINE void	safe_iter_swap (Iter lhs, Iter rhs)
	swap values at iterators lhs and rhs More...
template<typename Iter >
RAJA_HOST_DEVICE RAJA_INLINE Iter	next (Iter it)
	returns iterator to next item More...
template<typename Iter >
RAJA_HOST_DEVICE RAJA_INLINE Iter	prev (Iter it)
	returns iterator to next item More...
template<typename ExecutionPolicy , typename Res , typename IdxSet , typename... Params>
RAJA_INLINE resources::EventProxy< Res >	forall_Icount (ExecutionPolicy &&p, Res r, IdxSet &&c, Params &&... params)
	Generic dispatch over index set with icount with a value-based policy. More...
template<typename ExecutionPolicy , typename IdxSet , typename LoopBody , typename Res = typename resources::get_resource<ExecutionPolicy>::type>
RAJA_INLINE resources::EventProxy< Res >	forall_Icount (ExecutionPolicy &&p, IdxSet &&c, LoopBody &&loop_body)
template<typename ExecutionPolicy , typename Res , typename IdxSet , typename... Params>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_indexset_policy< ExecutionPolicy > >	forall (ExecutionPolicy &&p, Res r, IdxSet &&c, Params &&... params)
	Generic dispatch over index set with a value-based policy. More...
template<typename ExecutionPolicy , typename IdxSet , typename LoopBody , typename Res = typename resources::get_resource<ExecutionPolicy>::type>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_indexset_policy< ExecutionPolicy > >	forall (ExecutionPolicy &&p, IdxSet &&c, LoopBody &&loop_body)
template<typename ExecutionPolicy , typename Container , typename LoopBody , typename Res = typename resources::get_resource<ExecutionPolicy>::type>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_multi_policy< ExecutionPolicy >, type_traits::is_range< Container > >	forall (ExecutionPolicy &&p, Container &&c, LoopBody &&loop_body)
	Generic dispatch over containers with a multi policy. More...
template<typename ExecutionPolicy , typename Res , typename Container , typename IndexType , typename FirstParam , typename... Params>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_range< Container >, type_traits::is_integral< IndexType > >	forall_Icount (ExecutionPolicy &&p, Res r, Container &&c, IndexType icount, FirstParam &&first, Params &&... params)
	Generic dispatch over containers with icount with a value-based policy. More...
template<typename ExecutionPolicy , typename Container , typename IndexType , typename LoopBody , typename Res = typename resources::get_resource<ExecutionPolicy>::type>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_range< Container >, concepts::negate< type_traits::is_indexset_policy< ExecutionPolicy > >, type_traits::is_integral< IndexType > >	forall_Icount (ExecutionPolicy &&p, Container &&c, IndexType icount, LoopBody &&loop_body)
template<typename ExecutionPolicy , typename Res , typename Container , typename... Params>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, concepts::negate< type_traits::is_indexset_policy< ExecutionPolicy > >, concepts::negate< type_traits::is_multi_policy< ExecutionPolicy > >, type_traits::is_range< Container > >	forall (ExecutionPolicy &&p, Res r, Container &&c, Params &&... params)
	Generic dispatch over containers with a value-based policy. More...
template<typename ExecutionPolicy , typename Container , typename LoopBody , typename Res = typename resources::get_resource<ExecutionPolicy>::type>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, concepts::negate< type_traits::is_indexset_policy< ExecutionPolicy > >, concepts::negate< type_traits::is_multi_policy< ExecutionPolicy > >, type_traits::is_range< Container > >	forall (ExecutionPolicy &&p, Container &&c, LoopBody &&loop_body)
template<typename ExecutionPolicy , typename... Args, typename Res = typename resources::get_resource<ExecutionPolicy>::type>
RAJA_INLINE resources::EventProxy< Res >	forall (Args &&... args)
	Conversion from template-based policy to value-based policy for forall. More...
template<typename ExecutionPolicy , typename Res , typename... Args>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_resource< Res > >	forall (Res r, Args &&... args)
template<typename ExecutionPolicy , typename... Args, typename Res = typename resources::get_resource<ExecutionPolicy>::type>
RAJA_INLINE resources::EventProxy< Res >	forall_Icount (Args &&... args)
	Conversion from template-based policy to value-based policy for forall_Icount. More...
template<typename ExecutionPolicy , typename Res , typename... Args>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_resource< Res > >	forall_Icount (Res r, Args &&... args)
template<typename POLICY_LIST , typename SEGMENT , typename... PARAMS>
void	dynamic_forall (const int pol, SEGMENT const &seg, PARAMS &&... params)
template<typename POLICY_LIST , typename SEGMENT , typename... PARAMS>
resources::EventProxy< resources::Resource >	dynamic_forall (RAJA::resources::Resource r, const int pol, SEGMENT const &seg, PARAMS &&... params)
template<class Tuple >
constexpr RAJA_INLINE auto	make_wrapped_tuple (Tuple &&t) -> decltype(internal::make_wrapped_tuple_impl(std::forward< Tuple >(t), camp::make_idx_seq_t< camp::tuple_size< camp::decay< Tuple >>::value > {}))
template<typename PolicyType , typename SegmentTuple , typename ParamTuple , typename Resource , typename... Bodies>
RAJA_INLINE resources::EventProxy< Resource >	kernel_param_resource (SegmentTuple &&segments, ParamTuple &&params, Resource resource, Bodies &&... bodies)
template<typename PolicyType , typename SegmentTuple , typename Resource , typename... Bodies>
RAJA_INLINE resources::EventProxy< Resource >	kernel_resource (SegmentTuple &&segments, Resource resource, Bodies &&... bodies)
template<typename PolicyType , typename SegmentTuple , typename ParamTuple , typename... Bodies>
RAJA_INLINE resources::EventProxy< resources::resource_from_pol_t< PolicyType > >	kernel_param (SegmentTuple &&segments, ParamTuple &&params, Bodies &&... bodies)
template<typename PolicyType , typename SegmentTuple , typename... Bodies>
RAJA_INLINE resources::EventProxy< resources::resource_from_pol_t< PolicyType > >	kernel (SegmentTuple &&segments, Bodies &&... bodies)
template<typename LAUNCH_POLICY , typename... ReduceParams>
void	launch (LaunchParams const &launch_params, ReduceParams &&... rest_of_launch_args)
template<typename POLICY_LIST , typename BODY >
void	launch (ExecPlace place, LaunchParams const &params, BODY const &body)
template<typename POLICY_LIST , typename... ReduceParams>
void	launch (ExecPlace place, const LaunchParams &launch_params, ReduceParams &&... rest_of_launch_args)
template<typename T >
RAJA::resources::Resource	Get_Host_Resource (T host_res, RAJA::ExecPlace device)
template<typename POLICY_LIST , typename... ReduceParams>
resources::EventProxy< resources::Resource >	launch (RAJA::resources::Resource res, LaunchParams const &launch_params, ReduceParams &&... rest_of_launch_args)
template<typename POLICY_LIST , typename CONTEXT , typename SEGMENT , typename BODY >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE void	loop (CONTEXT const &ctx, SEGMENT const &segment, BODY const &body)
template<typename POLICY_LIST , typename CONTEXT , typename SEGMENT , typename BODY >
RAJA_HOST_DEVICE RAJA_INLINE void	loop_icount (CONTEXT const &ctx, SEGMENT const &segment, BODY const &body)
template<typename POLICY_LIST , typename CONTEXT , typename TILE_T , typename SEGMENT , typename BODY >
RAJA_HOST_DEVICE RAJA_INLINE void	tile (CONTEXT const &ctx, TILE_T tile_size, SEGMENT const &segment, BODY const &body)
template<typename POLICY_LIST , typename CONTEXT , typename TILE_T , typename SEGMENT , typename BODY >
RAJA_HOST_DEVICE RAJA_INLINE void	tile_tcount (CONTEXT const &ctx, TILE_T tile_size, SEGMENT const &segment, BODY const &body)
auto	Name (const char *n)
template<typename ExecutionPolicy , typename LoopBody >
void	region (LoopBody &&loop_body)
template<typename ExecutionPolicy , typename OuterBody , typename InnerBody >
void	region (OuterBody &&outer_body, InnerBody &&inner_body)
template<typename ExecPolicy , typename Res , typename Container , typename Function = operators::plus<RAJA::detail::ContainerVal<Container>>>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res >, std::is_constructible< camp::resources::Resource, Res >, type_traits::is_range< Container > >	inclusive_scan_inplace (ExecPolicy &&p, Res r, Container &&c, Function binop=Function {})
	inclusive in-place scan execution pattern More...
template<typename ExecPolicy , typename Container , typename Function = operators::plus<RAJA::detail::ContainerVal<Container>>, typename Res = typename resources::get_resource<ExecPolicy>::type>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_range< Container >, concepts::negate< std::is_constructible< camp::resources::Resource, Container > > >	inclusive_scan_inplace (ExecPolicy &&p, Container &&c, Function binop=Function {})
template<typename ExecPolicy , typename Res , typename Container , typename T = RAJA::detail::ContainerVal<Container>, typename Function = operators::plus<T>>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res >, std::is_constructible< camp::resources::Resource, Res >, type_traits::is_range< Container > >	exclusive_scan_inplace (ExecPolicy &&p, Res r, Container &&c, Function binop=Function {}, T value=Function::identity())
	exclusive in-place scan execution pattern More...
template<typename ExecPolicy , typename Container , typename T = RAJA::detail::ContainerVal<Container>, typename Function = operators::plus<T>, typename Res = typename resources::get_resource<ExecPolicy>::type>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_range< Container >, concepts::negate< std::is_constructible< camp::resources::Resource, Container > > >	exclusive_scan_inplace (ExecPolicy &&p, Container &&c, Function binop=Function {}, T value=Function::identity())
template<typename ExecPolicy , typename Res , typename InContainer , typename OutContainer , typename Function = operators::plus<RAJA::detail::ContainerVal<InContainer>>>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res >, std::is_constructible< camp::resources::Resource, Res >, type_traits::is_range< InContainer >, type_traits::is_range< OutContainer > >	inclusive_scan (ExecPolicy &&p, Res r, InContainer &&in, OutContainer &&out, Function binop=Function {})
	inclusive scan execution pattern More...
template<typename ExecPolicy , typename InContainer , typename OutContainer , typename Function = operators::plus<RAJA::detail::ContainerVal<InContainer>>, typename Res = typename resources::get_resource<ExecPolicy>::type>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_range< InContainer >, concepts::negate< std::is_constructible< camp::resources::Resource, InContainer > >, type_traits::is_range< OutContainer > >	inclusive_scan (ExecPolicy &&p, InContainer &&in, OutContainer &&out, Function binop=Function {})
template<typename ExecPolicy , typename Res , typename InContainer , typename OutContainer , typename T = RAJA::detail::ContainerVal<InContainer>, typename Function = operators::plus<T>>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res >, std::is_constructible< camp::resources::Resource, Res >, type_traits::is_range< InContainer >, type_traits::is_range< OutContainer > >	exclusive_scan (ExecPolicy &&p, Res r, InContainer &&in, OutContainer &&out, Function binop=Function {}, T value=Function::identity())
	exclusive scan execution pattern More...
template<typename ExecPolicy , typename InContainer , typename OutContainer , typename T = RAJA::detail::ContainerVal<InContainer>, typename Function = operators::plus<T>, typename Res = typename resources::get_resource<ExecPolicy>::type>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_range< InContainer >, concepts::negate< std::is_constructible< camp::resources::Resource, InContainer > >, type_traits::is_range< OutContainer > >	exclusive_scan (ExecPolicy &&p, InContainer &&in, OutContainer &&out, Function binop=Function {}, T value=Function::identity())
template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy > >	exclusive_scan (Args &&... args)
	Conversion from template-based policy to value-based policy for exclusive_scan. More...
template<typename ExecPolicy , typename Res , typename... Args>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > >	exclusive_scan (Res r, Args &&... args)
template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy > >	inclusive_scan (Args &&... args)
	Conversion from template-based policy to value-based policy for inclusive_scan. More...
template<typename ExecPolicy , typename Res , typename... Args>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > >	inclusive_scan (Res r, Args &&... args)
template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy > >	exclusive_scan_inplace (Args &&... args)
	Conversion from template-based policy to value-based policy for exclusive_scan_inplace. More...
template<typename ExecPolicy , typename Res , typename... Args>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > >	exclusive_scan_inplace (Res r, Args &&... args)
template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy > >	inclusive_scan_inplace (Args &&... args)
	Conversion from template-based policy to value-based policy for inclusive_scan_inplace. More...
template<typename ExecPolicy , typename Res , typename... Args>
RAJA_INLINE concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > >	inclusive_scan_inplace (Res r, Args &&... args)
template<typename ExecPolicy , typename Res , typename Container , typename Compare = operators::less<RAJA::detail::ContainerVal<Container>>>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res >, std::is_constructible< camp::resources::Resource, Res >, type_traits::is_range< Container > >	sort (ExecPolicy &&p, Res r, Container &&c, Compare comp=Compare {})
	sort execution pattern More...
template<typename ExecPolicy , typename Container , typename Compare = operators::less<RAJA::detail::ContainerVal<Container>>, typename Res = typename resources::get_resource<ExecPolicy>::type>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_range< Container >, concepts::negate< std::is_constructible< camp::resources::Resource, Container > > >	sort (ExecPolicy &&p, Container &&c, Compare comp=Compare {})
template<typename ExecPolicy , typename Res , typename Container , typename Compare = operators::less<RAJA::detail::ContainerVal<Container>>>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res >, std::is_constructible< camp::resources::Resource, Res >, type_traits::is_range< Container > >	stable_sort (ExecPolicy &&p, Res r, Container &&c, Compare comp=Compare {})
	stable sort execution pattern More...
template<typename ExecPolicy , typename Container , typename Compare = operators::less<RAJA::detail::ContainerVal<Container>>, typename Res = typename resources::get_resource<ExecPolicy>::type>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_range< Container >, concepts::negate< std::is_constructible< camp::resources::Resource, Container > > >	stable_sort (ExecPolicy &&p, Container &&c, Compare comp=Compare {})
template<typename ExecPolicy , typename Res , typename KeyContainer , typename ValContainer , typename Compare = operators::less<RAJA::detail::ContainerVal<KeyContainer>>>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res >, std::is_constructible< camp::resources::Resource, Res >, type_traits::is_range< KeyContainer >, type_traits::is_range< ValContainer > >	sort_pairs (ExecPolicy &&p, Res r, KeyContainer &&keys, ValContainer &&vals, Compare comp=Compare {})
	sort pairs execution pattern More...
template<typename ExecPolicy , typename KeyContainer , typename ValContainer , typename Compare = operators::less<RAJA::detail::ContainerVal<KeyContainer>>, typename Res = typename resources::get_resource<ExecPolicy>::type>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_range< KeyContainer >, concepts::negate< std::is_constructible< camp::resources::Resource, KeyContainer > >, type_traits::is_range< ValContainer > >	sort_pairs (ExecPolicy &&p, KeyContainer &&keys, ValContainer &&vals, Compare comp=Compare {})
template<typename ExecPolicy , typename Res , typename KeyContainer , typename ValContainer , typename Compare = operators::less<RAJA::detail::ContainerVal<KeyContainer>>>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res >, std::is_constructible< camp::resources::Resource, Res >, type_traits::is_range< KeyContainer >, type_traits::is_range< ValContainer > >	stable_sort_pairs (ExecPolicy &&p, Res r, KeyContainer &&keys, ValContainer &&vals, Compare comp=Compare {})
	stable sort pairs execution pattern More...
template<typename ExecPolicy , typename KeyContainer , typename ValContainer , typename Compare = operators::less<RAJA::detail::ContainerVal<KeyContainer>>, typename Res = typename resources::get_resource<ExecPolicy>::type>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_range< KeyContainer >, concepts::negate< std::is_constructible< camp::resources::Resource, KeyContainer > >, type_traits::is_range< ValContainer > >	stable_sort_pairs (ExecPolicy &&p, KeyContainer &&keys, ValContainer &&vals, Compare comp=Compare {})
template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy > >	sort (Args &&... args)
	Conversion from template-based policy to value-based policy for sort. More...
template<typename ExecPolicy , typename Res , typename... Args>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > >	sort (Res r, Args &&... args)
template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy > >	stable_sort (Args &&... args)
	Conversion from template-based policy to value-based policy for stable_sort. More...
template<typename ExecPolicy , typename Res , typename... Args>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > >	stable_sort (Res r, Args &&... args)
template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy > >	sort_pairs (Args &&... args)
	Conversion from template-based policy to value-based policy for sort_pairs. More...
template<typename ExecPolicy , typename Res , typename... Args>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > >	sort_pairs (Res r, Args &&... args)
template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy > >	stable_sort_pairs (Args &&... args)
	Conversion from template-based policy to value-based policy for sort_pairs. More...
template<typename ExecPolicy , typename Res , typename... Args>
concepts::enable_if_t< resources::EventProxy< Res >, type_traits::is_execution_policy< ExecPolicy >, type_traits::is_resource< Res > >	stable_sort_pairs (Res r, Args &&... args)
template<typename Policy >
void	synchronize ()
	Synchronize all current RAJA executions for the specified policy. More...
template<typename Policy >
RAJA_INLINE RAJA_HOST_DEVICE int	get_max_threads ()
	Get maximum number of threads. More...
template<typename Policy >
RAJA_INLINE RAJA_HOST_DEVICE int	get_thread_num ()
	Get current thread number This is based on the OpenMP threading model. Within a parallel team executing a parallel region the threads are numbered 0-N. Returns 0 if called in sequential part of a program or OMP is not active. More...
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicLoad (auto_atomic, T *acc)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE void	atomicStore (auto_atomic, T *acc, T value)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicAdd (auto_atomic, T *acc, T value)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicSub (auto_atomic, T *acc, T value)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicMin (auto_atomic, T *acc, T value)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicMax (auto_atomic, T *acc, T value)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicInc (auto_atomic, T *acc)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicInc (auto_atomic, T *acc, T compare)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicDec (auto_atomic, T *acc)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicDec (auto_atomic, T *acc, T compare)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicAnd (auto_atomic, T *acc, T value)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicOr (auto_atomic, T *acc, T value)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicXor (auto_atomic, T *acc, T value)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicExchange (auto_atomic, T *acc, T value)
template<typename T >
RAJA_INLINE RAJA_HOST_DEVICE T	atomicCAS (auto_atomic, T *acc, T compare, T value)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicLoad (builtin_atomic, T *acc)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE void	atomicStore (builtin_atomic, T *acc, T value)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicAdd (builtin_atomic, T *acc, T value)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicSub (builtin_atomic, T *acc, T value)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicMin (builtin_atomic, T *acc, T value)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicMax (builtin_atomic, T *acc, T value)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicInc (builtin_atomic, T *acc)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicInc (builtin_atomic, T *acc, T value)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicDec (builtin_atomic, T *acc)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicDec (builtin_atomic, T *acc, T value)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicAnd (builtin_atomic, T *acc, T value)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicOr (builtin_atomic, T *acc, T value)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicXor (builtin_atomic, T *acc, T value)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicExchange (builtin_atomic, T *acc, T value)
template<typename T >
RAJA_DEVICE_HIP RAJA_INLINE T	atomicCAS (builtin_atomic, T *acc, T compare, T value)
template<typename BODY , typename ReduceParams >
__global__ void	launch_new_reduce_global_fcn (const RAJA_CUDA_GRID_CONSTANT BODY body_in, ReduceParams reduce_params)
template<typename BODY , int num_threads, size_t BLOCKS_PER_SM, typename ReduceParams >
	__launch_bounds__ (num_threads, BLOCKS_PER_SM) __global__ void launch_new_reduce_global_fcn_fixed(const RAJA_CUDA_GRID_CONSTANT BODY body_in
template<typename BODY , typename ReduceParams >
__global__ void	launch_new_reduce_global_fcn (const BODY body_in, ReduceParams reduce_params)
template<typename BODY , int num_threads, typename ReduceParams >
	__launch_bounds__ (num_threads, 1) __global__ void launch_new_reduce_global_fcn_fixed(const BODY body_in
template<typename... Policies, typename Selector >
auto	make_multi_policy (Selector s) -> MultiPolicy< Selector, Policies... >
template<typename... Policies, typename Selector >
auto	make_multi_policy (std::tuple< Policies... > policies, Selector s) -> MultiPolicy< Selector, Policies... >
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicLoad (seq_atomic, T *acc)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE void	atomicStore (seq_atomic, T *acc, T value)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicAdd (seq_atomic, T *acc, T value)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicSub (seq_atomic, T *acc, T value)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicMin (seq_atomic, T *acc, T value)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicMax (seq_atomic, T *acc, T value)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicInc (seq_atomic, T *acc)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicInc (seq_atomic, T *acc, T val)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicDec (seq_atomic, T *acc)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicDec (seq_atomic, T *acc, T val)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicAnd (seq_atomic, T *acc, T value)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicOr (seq_atomic, T *acc, T value)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicXor (seq_atomic, T *acc, T value)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicExchange (seq_atomic, T *acc, T value)
template<typename T >
RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T	atomicCAS (seq_atomic, T *acc, T compare, T value)
template<>
RAJA_HOST_DEVICE RAJA_INLINE int	get_max_threads (seq_thread)
template<>
RAJA_HOST_DEVICE RAJA_INLINE int	get_thread_num (seq_thread)
template<typename AtomicPolicy >
RAJA_HOST_DEVICE RAJA_INLINE int	get_max_threads (AtomicPolicy)
template<typename AtomicPolicy >
RAJA_HOST_DEVICE RAJA_INLINE int	get_thread_num (AtomicPolicy)
RAJA_INLINE void *	align (size_t alignment, size_t size, void *&ptr, size_t &space)
template<typename Lambda , typename Layout >
RAJA_HOST_DEVICE RAJA_INLINE auto	make_CombiningAdapter_from_layout (Lambda &&lambda, Layout &&layout)
	Creates a CombiningAdapter class from a lambda and segments. More...
template<typename Lambda , typename... IdxTs>
RAJA_SUPPRESS_HD_WARN RAJA_INLINE auto	make_CombiningAdapter (Lambda &&lambda, ::RAJA::TypedRangeSegment< IdxTs > const &... segs)
template<typename Perm , typename Lambda , typename... IdxTs>
RAJA_SUPPRESS_HD_WARN RAJA_INLINE auto	make_PermutedCombiningAdapter (Lambda &&lambda, ::RAJA::TypedRangeSegment< IdxTs > const &... segs)
template<typename Container , typename UnaryFunc >
constexpr RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE concepts::enable_if_t< UnaryFunc, type_traits::is_range< Container > >	for_each (Container &&c, UnaryFunc func)
	Apply func to all the elements in the given range in order using a sequential for loop in O(N) operations and O(1) extra memory see https://en.cppreference.com/w/cpp/algorithm/for_each. More...
template<typename UnaryFunc , typename... Ts>
constexpr RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE UnaryFunc	for_each_type (camp::list< Ts... > const &c, UnaryFunc func)
	Apply func to each type in the given list in order using a compile-time expansion in O(N) operations and O(1) extra memory. More...
template<typename Tuple , typename UnaryFunc >
constexpr RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE UnaryFunc	for_each_tuple (Tuple &&t, UnaryFunc func)
	Apply func to each object in the given tuple or tuple like type in order using a compile-time expansion in O(N) operations and O(1) extra memory. More...
template<typename... IndexTypes>
RAJA_INLINE RAJA_HOST_DEVICE auto	make_index_tuple (IndexTypes... it) -> camp::tuple< IndexTypes... >
template<typename IdxLin = Index_type, typename... Types, typename... IndexTypes>
RAJA_INLINE RAJA_HOST_DEVICE auto	make_index_layout (camp::tuple< IndexTypes... > index_tuple_in, Types... ns) -> IndexLayout< sizeof...(Types), IdxLin, IndexTypes... >
template<ptrdiff_t s1_dim, size_t n_dims, typename IdxLin >
RAJA_INLINE constexpr RAJA_HOST_DEVICE Layout< n_dims, IdxLin, s1_dim >	make_stride_one (Layout< n_dims, IdxLin > const &l)
template<ptrdiff_t s1_dim, typename IdxLin , typename IdxTuple >
RAJA_INLINE constexpr RAJA_HOST_DEVICE TypedLayout< IdxLin, IdxTuple, s1_dim >	make_stride_one (TypedLayout< IdxLin, IdxTuple > const &l)
template<typename T , std::enable_if_t< std::is_integral< T >::value > * = nullptr>
RAJA_HOST_DEVICE constexpr RAJA_INLINE T	log2 (T n) noexcept
	evaluate log base 2 of n More...
template<typename T , std::enable_if_t< std::is_integral< T >::value > * = nullptr>
RAJA_HOST_DEVICE constexpr RAJA_INLINE T	next_pow2 (T n) noexcept
	"round up" to the next greatest power of 2 More...
template<typename T , std::enable_if_t< std::is_integral< T >::value > * = nullptr>
RAJA_HOST_DEVICE constexpr RAJA_INLINE T	prev_pow2 (T n) noexcept
	"round down" to the largest power of 2 that is less than or equal to n More...
template<typename L , typename R , std::enable_if_t< std::is_integral< L >::value &&std::is_integral< R >::value > * = nullptr>
RAJA_HOST_DEVICE constexpr RAJA_INLINE auto	power_of_2_mod (L lhs, R rhs) noexcept
	compute lhs mod rhs where lhs is non-negative and rhs is a power of 2 More...
template<size_t n_dims, typename IdxLin = Index_type>
RAJA_INLINE constexpr RAJA_HOST_DEVICE auto	make_offset_layout (const std::array< IdxLin, n_dims > &begin, const std::array< IdxLin, n_dims > &end) -> OffsetLayout< n_dims, IdxLin >
template<size_t Rank, typename IdxLin = Index_type>
RAJA_INLINE constexpr RAJA_HOST_DEVICE auto	make_permuted_offset_layout (const std::array< IdxLin, Rank > &begin, const std::array< IdxLin, Rank > &end, const std::array< IdxLin, Rank > &permutation) -> decltype(make_offset_layout< Rank, IdxLin >(begin, end))
template<size_t Rank, typename IdxLin = Index_type>
constexpr RAJA_INLINE RAJA_HOST_DEVICE auto	make_permuted_layout (std::array< IdxLin, Rank > sizes, std::array< camp::idx_t, Rank > permutation) -> Layout< Rank, IdxLin >
	Creates a permuted Layout object. More...
template<typename Container , typename T = detail::ContainerVal<Container>, typename BinaryOp = operators::plus<T>>
RAJA_HOST_DEVICE constexpr RAJA_INLINE concepts::enable_if_t< T, type_traits::is_range< Container > >	left_fold_reduce (Container &&c, T init=BinaryOp::identity(), BinaryOp op=BinaryOp {})
	Accumulate given range to a single value using a left fold algorithm in O(N) operations and O(1) extra memory see https://en.cppreference.com/w/cpp/algorithm/accumulate. More...
template<typename Container , typename T = detail::ContainerVal<Container>, typename BinaryOp = operators::plus<T>>
RAJA_HOST_DEVICE constexpr RAJA_INLINE concepts::enable_if_t< T, type_traits::is_range< Container > >	binary_tree_reduce (Container &&c, T init=BinaryOp::identity(), BinaryOp op=BinaryOp {})
	Reduce given range to a single value using a binary tree algorithm in O(N) operations and O(lg(N)) extra memory see https://en.cppreference.com/w/cpp/algorithm/reduce. More...
template<typename Container , typename T = detail::ContainerVal<Container>>
RAJA_HOST_DEVICE constexpr RAJA_INLINE concepts::enable_if_t< T, type_traits::is_range< Container >, std::is_floating_point< T > >	kahan_sum (Container &&c, T init=T())
	Accumulate given range to a single value using a kahan summation algorithm in O(N) operations and O(1) extra memory see https://en.cppreference.com/w/cpp/algorithm/accumulate. More...
template<typename Container , typename T = detail::ContainerVal<Container>>
RAJA_HOST_DEVICE constexpr RAJA_INLINE concepts::enable_if_t< T, type_traits::is_range< Container >, std::is_floating_point< T > >	kahan_sum_volatile (Container &&c, T init=T())
	Accumulate given range to a single value using a kahan summation algorithm in O(N) operations and O(1) extra memory see https://en.cppreference.com/w/cpp/algorithm/accumulate. More...
template<typename Container , typename T = detail::ContainerVal<Container>, typename BinaryOp = operators::plus<T>>
RAJA_HOST_DEVICE constexpr RAJA_INLINE concepts::enable_if_t< T, type_traits::is_range< Container > >	high_accuracy_reduce (Container &&c, T init=BinaryOp::identity(), BinaryOp op=BinaryOp {})
	Reduce given range to a single value using an algorithm with high accuracy when floating point round off is a concern see https://en.cppreference.com/w/cpp/algorithm/reduce. More...
template<typename Container , typename T = detail::ContainerVal<Container>, typename BinaryOp = operators::plus<T>>
RAJA_HOST_DEVICE constexpr RAJA_INLINE concepts::enable_if_t< T, type_traits::is_range< Container > >	accumulate (Container &&c, T init=BinaryOp::identity(), BinaryOp op=BinaryOp {})
	Accumulate given range to a single value using a left fold algorithm in O(N) operations and O(1) extra memory see https://en.cppreference.com/w/cpp/algorithm/accumulate. More...
template<typename Container , typename Compare = operators::less<detail::ContainerVal<Container>>>
RAJA_HOST_DEVICE RAJA_INLINE concepts::enable_if< type_traits::is_range< Container > >	insertion_sort (Container &&c, Compare comp=Compare {})
	stable insertion sort given range inplace using comparison function and using O(N^2) comparisons and O(1) memory More...
template<typename Container , typename Compare = operators::less<detail::ContainerVal<Container>>>
RAJA_HOST_DEVICE RAJA_INLINE concepts::enable_if< type_traits::is_range< Container > >	shell_sort (Container &&c, Compare comp=Compare {})
	unstable shell sort given range inplace using comparison function and using O(N^?) comparisons and O(1) memory More...
template<typename Container , typename Compare = operators::less<detail::ContainerVal<Container>>>
RAJA_HOST_DEVICE RAJA_INLINE concepts::enable_if< type_traits::is_range< Container > >	heap_sort (Container &&c, Compare comp=Compare {})
	unstable heap sort given range inplace using comparison function and using O(N*lg(N)) comparisons and O(1) memory More...
template<typename Container , typename Compare = operators::less<detail::ContainerVal<Container>>>
RAJA_HOST_DEVICE RAJA_INLINE concepts::enable_if< type_traits::is_range< Container > >	intro_sort (Container &&c, Compare comp=Compare {})
	unstable intro sort given range inplace using comparison function and using O(N*lg(N)) comparisons and O(lg(N)) memory More...
template<typename Container , typename Compare = operators::less<detail::ContainerVal<Container>>>
RAJA_INLINE concepts::enable_if< type_traits::is_range< Container > >	merge_sort (Container &&c, Compare comp=Compare {})
	stable merge sort given range inplace using comparison function and using O(N*lg(N)) comparisons and O(N) memory More...
template<typename IterType , typename IndexType >
constexpr RAJA_HOST_DEVICE RAJA_INLINE Span< IterType, IndexType >	make_span (IterType begin, IndexType size)
	Creates a span from a random access iterator and length. More...
template<typename Iter >
constexpr RAJA_HOST_DEVICE RAJA_INLINE auto	make_span (Iter &iterable)
template<typename IndexType , typename ValueType >
RAJA_HOST_DEVICE constexpr RAJA_INLINE View< ValueType, Layout< 1, IndexType, 0 > >	make_view (ValueType *ptr)
template<size_t n_dims, typename IndexType , typename ValueType , typename... IndexTypes>
RAJA_HOST_DEVICE constexpr RAJA_INLINE View< ValueType, IndexLayout< n_dims, IndexType, IndexTypes... > >	make_index_view (ValueType *ptr, IndexLayout< n_dims, IndexType, IndexTypes... > index_layout)
template<typename Lay , typename Tup , camp::idx_t... Idxs>
RAJA_HOST_DEVICE constexpr RAJA_INLINE auto	selecttuple (Lay lyout, Tup &&tup, camp::idx_seq< Idxs... >) -> decltype(lyout(camp::get< Idxs >(std::forward< Tup >(tup))...))
template<typename Lay , RAJA::Index_type Nth = 0, typename Tup >
RAJA_HOST_DEVICE constexpr RAJA_INLINE auto	removenth (Lay lyout, Tup &&tup) -> decltype(selecttuple< Lay >(lyout, std::forward< Tup >(tup), cat_seq_t< camp::make_idx_seq_t< Nth >, offset_seq_t< Nth+1, camp::make_idx_seq_t< camp::tuple_size< Tup >::value - Nth - 1 >> > {}))
template<typename AtomicPolicy , typename ViewType >
RAJA_HOST_DEVICE constexpr RAJA_INLINE AtomicViewWrapper< ViewType, AtomicPolicy >	make_atomic_view (ViewType const &view)
template<typename meta_layout , typename IndexType = RAJA::Index_type, typename T , typename... Extents>
RAJA_HOST_DEVICE constexpr RAJA_INLINE auto	make_permuted_view (T *ptr, Extents &&... extents)
template<typename... Args>
RAJA_HOST_DEVICE constexpr RAJA_INLINE auto	zip (Args &&... args) -> ZipIterator< camp::decay< Args >... >
	Zip multiple iterators together to iterate them simultaneously with a single ZipIterator object. More...
template<typename... Args>
RAJA_HOST_DEVICE constexpr RAJA_INLINE auto	zip_span (Args &&... args) -> Span< ZipIterator< detail::ContainerIter< camp::decay< Args >>... >, typename ZipIterator< detail::ContainerIter< camp::decay< Args >>... >::difference_type >
	Zip multiple containers together to iterate them simultaneously with ZipIterator objects. More...
template<typename T , typename Compare >
RAJA_HOST_DEVICE constexpr RAJA_INLINE auto	compare_first (Compare comp) -> CompareFirst< T, Compare >
	Make a comparator to compare first member of tuple like objects of type T. More...
template<camp::idx_t I, bool is_val, typename... Ts>
RAJA_HOST_DEVICE constexpr RAJA_INLINE RAJA::zip_tuple_element_t< I, zip_tuple< is_val, Ts... > > &	get (zip_tuple< is_val, Ts... > &z) noexcept
template<camp::idx_t I, bool is_val, typename... Ts>
RAJA_HOST_DEVICE constexpr RAJA_INLINE RAJA::zip_tuple_element_t< I, zip_tuple< is_val, Ts... > > const &	get (zip_tuple< is_val, Ts... > const &z) noexcept
template<camp::idx_t I, bool is_val, typename... Ts>
RAJA_HOST_DEVICE constexpr RAJA_INLINE std::remove_reference_t< RAJA::zip_tuple_element_t< I, zip_tuple< is_val, Ts... > > > &&	get (zip_tuple< is_val, Ts... > &&z) noexcept
template<camp::idx_t I, bool is_val, typename... Ts>
RAJA_HOST_DEVICE constexpr RAJA_INLINE std::remove_reference_t< RAJA::zip_tuple_element_t< I, zip_tuple< is_val, Ts... > > > const &&	get (zip_tuple< is_val, Ts... > const &&z) noexcept
Methods to gather indices of segment or index set into a container.
For each method, the given container must be templated on a data type, have default and copy ctors, push_back method, and value_type. Is is assumed that the container data type and segment or index set data type are compatible in the sense that the index set type can be converted to the container data type.
template<typename CONTAINER_T , typename... SEG_TYPES>
RAJA_INLINE void	getIndices (CONTAINER_T &con, const TypedIndexSet< SEG_TYPES... > &iset)
	Copy all indices in given index set to given container. More...
template<typename CONTAINER_T , typename SEGMENT_T >
RAJA_INLINE void	getIndices (CONTAINER_T &con, const SEGMENT_T &seg)
	Copy all indices in given segment to given container. More...
template<typename CONTAINER_T , typename... SEG_TYPES, typename CONDITIONAL >
RAJA_INLINE void	getIndicesConditional (CONTAINER_T &con, const TypedIndexSet< SEG_TYPES... > &iset, CONDITIONAL conditional)
	Copy all indices in given index set that satisfy given conditional to given container. More...
template<typename CONTAINER_T , typename SEGMENT_T , typename CONDITIONAL >
RAJA_INLINE void	getIndicesConditional (CONTAINER_T &con, const SEGMENT_T &seg, CONDITIONAL conditional)
	Copy all indices in given segment that satisfy given conditional to given container. More...

Variables
ReduceParams	reduce_params
auto	privatizer = thread_privatize(body_in)
auto &	body = privatizer.get_priv()
__shared__ char	raja_shmem_ptr []
LaunchContextType	ctx
ctx	shared_mem_ptr = raja_shmem_ptr
const int	UndefinedValue = -9999999

Detailed Description

Segment execution policies

Typedef Documentation

strip_index_type_t

template<typename FROM >

using RAJA::strip_index_type_t = typedef typename internal::StripIndexTypeT<FROM>::type

Strips a strongly typed index to its underlying type In the case of a non-strongly typed index, the original type is returned.

Parameters

FROM	the original type

make_signed_t

template<typename FROM >

using RAJA::make_signed_t = typedef typename std::conditional<std::is_floating_point<FROM>::value, std::common_type<FROM>, std::make_signed<FROM> >::type::type

Converts a type into a signed type. Also handles floating point types as std::make_signed only supports integral types.

Parameters

FROM	the original type

ListSegment

using RAJA::ListSegment = typedef TypedListSegment<Index_type>

Alias for A TypedListSegment<Index_type>

RangeSegment

using RAJA::RangeSegment = typedef TypedRangeSegment<Index_type>

Alias for TypedRangeSegment<Index_type>

RangeStrideSegment

using RAJA::RangeStrideSegment = typedef TypedRangeStrideSegment<Index_type>

Alias for TypedRangeStrideSegment<Index_type>

Segs

template<camp::idx_t... args>

using RAJA::Segs = typedef camp::list<internal::LambdaArg<internal::lambda_arg_seg_t, args>...>

Used in RAJA::statement::Lambda to specify that one or more segment values should be passed into the lambda as an argument

Offsets

template<camp::idx_t... args>

using RAJA::Offsets = typedef camp::list<internal::LambdaArg<internal::lambda_arg_offset_t, args>...>

Used in RAJA::statement::Lambda to specify that one or more segment offsets should be passed into the lambda as an argument

The offset is the distance from the segment begin() that is currently being iterated on.

In the case of tiling (with Tile) the offset is w.r.t. the beginning of the current tile.

Params

template<camp::idx_t... args>

using RAJA::Params = typedef camp::list<internal::LambdaArg<internal::lambda_arg_param_t, args>...>

Used in RAJA::statement::Lambda to specify that one or more parameters that should be passed into the lambda as an argument.

ValuesT

template<typename T , camp::idx_t... values>

using RAJA::ValuesT = typedef camp::list<internal::LambdaArg<internal::lambda_arg_value_t<T>, values>...>

Used in RAJA::statement::Lambda to specify that one or more constant values should be passed into the lambda as an argument.

Values specified in the template parameters

Example: writing: Lambda<0, ValuesT<int, 3>> invokes: lambda0( (int)3 )

writing: Lambda<0, ValuesT<double, 3, 4>> invokes: lambda0( (double)3, (double) 4 )

KernelPolicy

template<typename... Stmts>

using RAJA::KernelPolicy = typedef internal::StatementList<Stmts...>

A RAJA::kernel execution policy.

This is just a list of RAJA::kernel statements.

ArgList

template<camp::idx_t... ArgumentId>

using RAJA::ArgList = typedef camp::idx_seq<ArgumentId...>

Template list of argument indices

LaunchContext

using RAJA::LaunchContext = typedef LaunchContextT<LaunchContextHostPolicy>

loop_policy

template<typename POLICY_LIST >

using RAJA::loop_policy = typedef typename POLICY_LIST::host_policy_t

xargs

template<typename... Args>

using RAJA::xargs = typedef camp::list<Args...>

xargs alias.

Usage example:

  WorkPool<WorkGroup_policy, Index_type, xargs<int*, int>, Allocator>
pool(allocator);

  pool.enqueue(..., [=] (Index_type i, int* xarg0, int xarg1) {
     xarg0[i] = xarg1;
  });

  WorkGroup<WorkGroup_policy, Index_type, xargs<int*, int>, Allocator> group =
pool.instantiate();

  int* xarg0 = ...;
  int xarg1 = ...;
  WorkSite<WorkGroup_policy, Index_type, xargs<int*, int>, Allocator> site =
group.run(xarg0, xarg1);

* 

LaunchContextType

typedef typename RAJA::detail::launch_context_type< BODY >::type RAJA::LaunchContextType

policy_has_trait

template<typename PolicyType , typename Trait >

using RAJA::policy_has_trait = typedef policy_has_trait_impl<camp::decay<PolicyType>, Trait>

make_policy_pattern_t

template<Policy Pol, Pattern Pat, typename... Args>

using RAJA::make_policy_pattern_t = typedef PolicyBaseT<Pol, Pat, Launch::undefined, Platform::undefined, Args...>

make_policy_pattern_launch_platform_t

template<Policy Policy_, Pattern Pattern_, Launch Launch_, Platform Platform_, typename... Args>

using RAJA::make_policy_pattern_launch_platform_t = typedef PolicyBaseT<Policy_, Pattern_, Launch_, Platform_, Args...>

make_policy_pattern_launch_t

template<Policy Policy_, Pattern Pattern_, Launch Launch_, typename... Args>

using RAJA::make_policy_pattern_launch_t = typedef PolicyBaseT<Policy_, Pattern_, Launch_, Platform::undefined, Args...>

make_policy_pattern_platform_t

template<Policy Policy_, Pattern Pattern_, Platform Platform_, typename... Args>

using RAJA::make_policy_pattern_platform_t = typedef PolicyBaseT<Policy_, Pattern_, Launch::undefined, Platform_, Args...>

sycl_global_item_0

using RAJA::sycl_global_item_0 = typedef sycl_global_item<0>

sycl_global_item_1

using RAJA::sycl_global_item_1 = typedef sycl_global_item<1>

sycl_global_item_2

using RAJA::sycl_global_item_2 = typedef sycl_global_item<2>

sycl_global_item_01

using RAJA::sycl_global_item_01 = typedef sycl_global_item<0, 1>

sycl_global_item_02

using RAJA::sycl_global_item_02 = typedef sycl_global_item<0, 2>

sycl_global_item_10

using RAJA::sycl_global_item_10 = typedef sycl_global_item<1, 0>

sycl_global_item_12

using RAJA::sycl_global_item_12 = typedef sycl_global_item<1, 2>

sycl_global_item_20

using RAJA::sycl_global_item_20 = typedef sycl_global_item<2, 0>

sycl_global_item_21

using RAJA::sycl_global_item_21 = typedef sycl_global_item<2, 1>

sycl_global_item_012

using RAJA::sycl_global_item_012 = typedef sycl_global_item<0, 1, 2>

sycl_global_item_021

using RAJA::sycl_global_item_021 = typedef sycl_global_item<0, 2, 1>

sycl_global_item_102

using RAJA::sycl_global_item_102 = typedef sycl_global_item<1, 0, 2>

sycl_global_item_120

using RAJA::sycl_global_item_120 = typedef sycl_global_item<1, 2, 0>

sycl_global_item_201

using RAJA::sycl_global_item_201 = typedef sycl_global_item<2, 0, 1>

sycl_global_item_210

using RAJA::sycl_global_item_210 = typedef sycl_global_item<2, 1, 0>

sycl_flatten_group_local_01_direct

using RAJA::sycl_flatten_group_local_01_direct = typedef sycl_flatten_group_local_direct<0, 1>

sycl_flatten_group_local_02_direct

using RAJA::sycl_flatten_group_local_02_direct = typedef sycl_flatten_group_local_direct<0, 2>

sycl_flatten_group_local_10_direct

using RAJA::sycl_flatten_group_local_10_direct = typedef sycl_flatten_group_local_direct<1, 0>

sycl_flatten_group_local_12_direct

using RAJA::sycl_flatten_group_local_12_direct = typedef sycl_flatten_group_local_direct<1, 2>

sycl_flatten_group_local_20_direct

using RAJA::sycl_flatten_group_local_20_direct = typedef sycl_flatten_group_local_direct<2, 0>

sycl_flatten_group_local_21_direct

using RAJA::sycl_flatten_group_local_21_direct = typedef sycl_flatten_group_local_direct<2, 1>

sycl_flatten_group_local_012_direct

using RAJA::sycl_flatten_group_local_012_direct = typedef sycl_flatten_group_local_direct<0, 1, 2>

sycl_flatten_group_local_021_direct

using RAJA::sycl_flatten_group_local_021_direct = typedef sycl_flatten_group_local_direct<0, 2, 1>

sycl_flatten_group_local_102_direct

using RAJA::sycl_flatten_group_local_102_direct = typedef sycl_flatten_group_local_direct<1, 0, 2>

sycl_flatten_group_local_120_direct

using RAJA::sycl_flatten_group_local_120_direct = typedef sycl_flatten_group_local_direct<1, 2, 0>

sycl_flatten_group_local_201_direct

using RAJA::sycl_flatten_group_local_201_direct = typedef sycl_flatten_group_local_direct<2, 0, 1>

sycl_flatten_group_local_210_direct

using RAJA::sycl_flatten_group_local_210_direct = typedef sycl_flatten_group_local_direct<2, 1, 0>

sycl_flatten_group_local_01_loop

using RAJA::sycl_flatten_group_local_01_loop = typedef sycl_flatten_group_local_loop<0, 1>

sycl_flatten_group_local_02_loop

using RAJA::sycl_flatten_group_local_02_loop = typedef sycl_flatten_group_local_loop<0, 2>

sycl_flatten_group_local_10_loop

using RAJA::sycl_flatten_group_local_10_loop = typedef sycl_flatten_group_local_loop<1, 0>

sycl_flatten_group_local_12_loop

using RAJA::sycl_flatten_group_local_12_loop = typedef sycl_flatten_group_local_loop<1, 2>

sycl_flatten_group_local_20_loop

using RAJA::sycl_flatten_group_local_20_loop = typedef sycl_flatten_group_local_loop<2, 0>

sycl_flatten_group_local_21_loop

using RAJA::sycl_flatten_group_local_21_loop = typedef sycl_flatten_group_local_loop<2, 1>

sycl_flatten_group_local_012_loop

using RAJA::sycl_flatten_group_local_012_loop = typedef sycl_flatten_group_local_loop<0, 1, 2>

sycl_flatten_group_local_021_loop

using RAJA::sycl_flatten_group_local_021_loop = typedef sycl_flatten_group_local_loop<0, 2, 1>

sycl_flatten_group_local_102_loop

using RAJA::sycl_flatten_group_local_102_loop = typedef sycl_flatten_group_local_loop<1, 0, 2>

sycl_flatten_group_local_120_loop

using RAJA::sycl_flatten_group_local_120_loop = typedef sycl_flatten_group_local_loop<1, 2, 0>

sycl_flatten_group_local_201_loop

using RAJA::sycl_flatten_group_local_201_loop = typedef sycl_flatten_group_local_loop<2, 0, 1>

sycl_flatten_group_local_210_loop

using RAJA::sycl_flatten_group_local_210_loop = typedef sycl_flatten_group_local_loop<2, 1, 0>

sycl_group_01_nested_direct

using RAJA::sycl_group_01_nested_direct = typedef sycl_group_012_direct<0, 1>

sycl_group_02_nested_direct

using RAJA::sycl_group_02_nested_direct = typedef sycl_group_012_direct<0, 2>

sycl_group_10_nested_direct

using RAJA::sycl_group_10_nested_direct = typedef sycl_group_012_direct<1, 0>

sycl_group_12_nested_direct

using RAJA::sycl_group_12_nested_direct = typedef sycl_group_012_direct<1, 2>

sycl_group_20_nested_direct

using RAJA::sycl_group_20_nested_direct = typedef sycl_group_012_direct<2, 0>

sycl_group_21_nested_direct

using RAJA::sycl_group_21_nested_direct = typedef sycl_group_012_direct<2, 1>

sycl_group_012_nested_direct

using RAJA::sycl_group_012_nested_direct = typedef sycl_group_012_direct<0, 1, 2>

sycl_group_021_nested_direct

using RAJA::sycl_group_021_nested_direct = typedef sycl_group_012_direct<0, 2, 1>

sycl_group_102_nested_direct

using RAJA::sycl_group_102_nested_direct = typedef sycl_group_012_direct<1, 0, 2>

sycl_group_120_nested_direct

using RAJA::sycl_group_120_nested_direct = typedef sycl_group_012_direct<1, 2, 0>

sycl_group_201_nested_direct

using RAJA::sycl_group_201_nested_direct = typedef sycl_group_012_direct<2, 0, 1>

sycl_group_210_nested_direct

using RAJA::sycl_group_210_nested_direct = typedef sycl_group_012_direct<2, 1, 0>

sycl_group_01_nested_loop

using RAJA::sycl_group_01_nested_loop = typedef sycl_group_012_loop<0, 1>

sycl_group_02_nested_loop

using RAJA::sycl_group_02_nested_loop = typedef sycl_group_012_loop<0, 2>

sycl_group_10_nested_loop

using RAJA::sycl_group_10_nested_loop = typedef sycl_group_012_loop<1, 0>

sycl_group_12_nested_loop

using RAJA::sycl_group_12_nested_loop = typedef sycl_group_012_loop<1, 2>

sycl_group_20_nested_loop

using RAJA::sycl_group_20_nested_loop = typedef sycl_group_012_loop<2, 0>

sycl_group_21_nested_loop

using RAJA::sycl_group_21_nested_loop = typedef sycl_group_012_loop<2, 1>

sycl_group_012_nested_loop

using RAJA::sycl_group_012_nested_loop = typedef sycl_group_012_loop<0, 1, 2>

sycl_group_021_nested_loop

using RAJA::sycl_group_021_nested_loop = typedef sycl_group_012_loop<0, 2, 1>

sycl_group_102_nested_loop

using RAJA::sycl_group_102_nested_loop = typedef sycl_group_012_loop<1, 0, 2>

sycl_group_120_nested_loop

using RAJA::sycl_group_120_nested_loop = typedef sycl_group_012_loop<1, 2, 0>

sycl_group_201_nested_loop

using RAJA::sycl_group_201_nested_loop = typedef sycl_group_012_loop<2, 0, 1>

sycl_group_210_nested_loop

using RAJA::sycl_group_210_nested_loop = typedef sycl_group_012_loop<2, 1, 0>

Layout

template<size_t n_dims, typename IdxLin = Index_type, ptrdiff_t StrideOne = -1>

using RAJA::Layout = typedef detail::LayoutBase_impl<camp::make_idx_seq_t<n_dims>, IdxLin, StrideOne>

A mapping of n-dimensional index space to a linear index space.

This is particularly useful for creating multi-dimensional arrays with the RAJA::View class, and other tasks such as mapping logical i,j,k zone indices to a flattened zone id.

For example:

// Create a layout object
Layout<3> layout(5,7,11);

// Map from 3d index space to linear
int lin = layout(2,3,1);   // lin=198

// Map from linear space to 3d indices
int i, j, k;
layout.toIndices(lin, i, j, k); // i,j,k = {2, 3, 1}

The above example creates a 3-d layout object with dimension sizes 5, 7, and 11. So the total index space covers 5*7*11=385 unique indices. The operator() provides a mapping from 3-d indices to linear, and the toIndices provides the inverse.

The default striding has the first index (left-most)as the longest stride, and the last (right-most) index with stride-1.

To achieve other striding, see the RAJA::make_permuted_layout function which can a permutation to the default striding.

Layout supports projections, 0 or more dimensions may be of size zero. In this case, the linear index space is invariant for those dimensions, and toIndicies(...) will always produce a zero for that dimensions index.

An example of a "projected" Layout:

// Create a layout with a degenerate dimensions
Layout<3> layout(3, 0, 5);

// The second (J) index is projected out
int lin1 = layout(0, 10, 0);   // lin1 = 0
int lin2 = layout(0, 5, 1);    // lin2 = 1

// The inverse mapping always produces a 0 for J
int i,j,k;
layout.toIndices(lin2, i, j, k); // i,j,k = {0, 0, 1}

ParamList

template<camp::idx_t... Sizes>

using RAJA::ParamList = typedef camp::idx_seq<Sizes...>

TypedLocalArray

template<typename ValueType , typename Perm , typename Sizes , typename... IndexTypes>

using RAJA::TypedLocalArray = typedef internal::TypedViewBase<ValueType, ValueType*, internal::getStaticLayoutType<Perm, Sizes>, camp::list<IndexTypes...> >

LocalArray

template<typename ValueType , typename Perm , typename Sizes >

using RAJA::LocalArray = typedef internal::TypedViewBase<ValueType, ValueType*, internal::getStaticLayoutType<Perm, Sizes>, internal::getDefaultIndexTypes<Perm> >

PERM_I

using RAJA::PERM_I = typedef camp::idx_seq<0>

PERM_IJ

using RAJA::PERM_IJ = typedef camp::idx_seq<0, 1>

PERM_JI

using RAJA::PERM_JI = typedef camp::idx_seq<1, 0>

PERM_IJK

using RAJA::PERM_IJK = typedef camp::idx_seq<0, 1, 2>

PERM_IKJ

using RAJA::PERM_IKJ = typedef camp::idx_seq<0, 2, 1>

PERM_JIK

using RAJA::PERM_JIK = typedef camp::idx_seq<1, 0, 2>

PERM_JKI

using RAJA::PERM_JKI = typedef camp::idx_seq<1, 2, 0>

PERM_KIJ

using RAJA::PERM_KIJ = typedef camp::idx_seq<2, 0, 1>

PERM_KJI

using RAJA::PERM_KJI = typedef camp::idx_seq<2, 1, 0>

PERM_IJKL

using RAJA::PERM_IJKL = typedef camp::idx_seq<0, 1, 2, 3>

PERM_IJLK

using RAJA::PERM_IJLK = typedef camp::idx_seq<0, 1, 3, 2>

PERM_IKJL

using RAJA::PERM_IKJL = typedef camp::idx_seq<0, 2, 1, 3>

PERM_IKLJ

using RAJA::PERM_IKLJ = typedef camp::idx_seq<0, 2, 3, 1>

PERM_ILJK

using RAJA::PERM_ILJK = typedef camp::idx_seq<0, 3, 1, 2>

PERM_ILKJ

using RAJA::PERM_ILKJ = typedef camp::idx_seq<0, 3, 2, 1>

PERM_JIKL

using RAJA::PERM_JIKL = typedef camp::idx_seq<1, 0, 2, 3>

PERM_JILK

using RAJA::PERM_JILK = typedef camp::idx_seq<1, 0, 3, 2>

PERM_JKIL

using RAJA::PERM_JKIL = typedef camp::idx_seq<1, 2, 0, 3>

PERM_JKLI

using RAJA::PERM_JKLI = typedef camp::idx_seq<1, 2, 3, 0>

PERM_JLIK

using RAJA::PERM_JLIK = typedef camp::idx_seq<1, 3, 0, 2>

PERM_JLKI

using RAJA::PERM_JLKI = typedef camp::idx_seq<1, 3, 2, 0>

PERM_KIJL

using RAJA::PERM_KIJL = typedef camp::idx_seq<2, 0, 1, 3>

PERM_KILJ

using RAJA::PERM_KILJ = typedef camp::idx_seq<2, 0, 3, 1>

PERM_KJIL

using RAJA::PERM_KJIL = typedef camp::idx_seq<2, 1, 0, 3>

PERM_KJLI

using RAJA::PERM_KJLI = typedef camp::idx_seq<2, 1, 3, 0>

PERM_KLIJ

using RAJA::PERM_KLIJ = typedef camp::idx_seq<2, 3, 0, 1>

PERM_KLJI

using RAJA::PERM_KLJI = typedef camp::idx_seq<2, 3, 1, 0>

PERM_LIJK

using RAJA::PERM_LIJK = typedef camp::idx_seq<3, 0, 1, 2>

PERM_LIKJ

using RAJA::PERM_LIKJ = typedef camp::idx_seq<3, 0, 2, 1>

PERM_LJIK

using RAJA::PERM_LJIK = typedef camp::idx_seq<3, 1, 0, 2>

PERM_LJKI

using RAJA::PERM_LJKI = typedef camp::idx_seq<3, 1, 2, 0>

PERM_LKIJ

using RAJA::PERM_LKIJ = typedef camp::idx_seq<3, 2, 0, 1>

PERM_LKJI

using RAJA::PERM_LKJI = typedef camp::idx_seq<3, 2, 1, 0>

PERM_IJKLM

using RAJA::PERM_IJKLM = typedef camp::idx_seq<0, 1, 2, 3, 4>

PERM_IJKML

using RAJA::PERM_IJKML = typedef camp::idx_seq<0, 1, 2, 4, 3>

PERM_IJLKM

using RAJA::PERM_IJLKM = typedef camp::idx_seq<0, 1, 3, 2, 4>

PERM_IJLMK

using RAJA::PERM_IJLMK = typedef camp::idx_seq<0, 1, 3, 4, 2>

PERM_IJMKL

using RAJA::PERM_IJMKL = typedef camp::idx_seq<0, 1, 4, 2, 3>

PERM_IJMLK

using RAJA::PERM_IJMLK = typedef camp::idx_seq<0, 1, 4, 3, 2>

PERM_IKJLM

using RAJA::PERM_IKJLM = typedef camp::idx_seq<0, 2, 1, 3, 4>

PERM_IKJML

using RAJA::PERM_IKJML = typedef camp::idx_seq<0, 2, 1, 4, 3>

PERM_IKLJM

using RAJA::PERM_IKLJM = typedef camp::idx_seq<0, 2, 3, 1, 4>

PERM_IKLMJ

using RAJA::PERM_IKLMJ = typedef camp::idx_seq<0, 2, 3, 4, 1>

PERM_IKMJL

using RAJA::PERM_IKMJL = typedef camp::idx_seq<0, 2, 4, 1, 3>

PERM_IKMLJ

using RAJA::PERM_IKMLJ = typedef camp::idx_seq<0, 2, 4, 3, 1>

PERM_ILJKM

using RAJA::PERM_ILJKM = typedef camp::idx_seq<0, 3, 1, 2, 4>

PERM_ILJMK

using RAJA::PERM_ILJMK = typedef camp::idx_seq<0, 3, 1, 4, 2>

PERM_ILKJM

using RAJA::PERM_ILKJM = typedef camp::idx_seq<0, 3, 2, 1, 4>

PERM_ILKMJ

using RAJA::PERM_ILKMJ = typedef camp::idx_seq<0, 3, 2, 4, 1>

PERM_ILMJK

using RAJA::PERM_ILMJK = typedef camp::idx_seq<0, 3, 4, 1, 2>

PERM_ILMKJ

using RAJA::PERM_ILMKJ = typedef camp::idx_seq<0, 3, 4, 2, 1>

PERM_IMJKL

using RAJA::PERM_IMJKL = typedef camp::idx_seq<0, 4, 1, 2, 3>

PERM_IMJLK

using RAJA::PERM_IMJLK = typedef camp::idx_seq<0, 4, 1, 3, 2>

PERM_IMKJL

using RAJA::PERM_IMKJL = typedef camp::idx_seq<0, 4, 2, 1, 3>

PERM_IMKLJ

using RAJA::PERM_IMKLJ = typedef camp::idx_seq<0, 4, 2, 3, 1>

PERM_IMLJK

using RAJA::PERM_IMLJK = typedef camp::idx_seq<0, 4, 3, 1, 2>

PERM_IMLKJ

using RAJA::PERM_IMLKJ = typedef camp::idx_seq<0, 4, 3, 2, 1>

PERM_JIKLM

using RAJA::PERM_JIKLM = typedef camp::idx_seq<1, 0, 2, 3, 4>

PERM_JIKML

using RAJA::PERM_JIKML = typedef camp::idx_seq<1, 0, 2, 4, 3>

PERM_JILKM

using RAJA::PERM_JILKM = typedef camp::idx_seq<1, 0, 3, 2, 4>

PERM_JILMK

using RAJA::PERM_JILMK = typedef camp::idx_seq<1, 0, 3, 4, 2>

PERM_JIMKL

using RAJA::PERM_JIMKL = typedef camp::idx_seq<1, 0, 4, 2, 3>

PERM_JIMLK

using RAJA::PERM_JIMLK = typedef camp::idx_seq<1, 0, 4, 3, 2>

PERM_JKILM

using RAJA::PERM_JKILM = typedef camp::idx_seq<1, 2, 0, 3, 4>

PERM_JKIML

using RAJA::PERM_JKIML = typedef camp::idx_seq<1, 2, 0, 4, 3>

PERM_JKLIM

using RAJA::PERM_JKLIM = typedef camp::idx_seq<1, 2, 3, 0, 4>

PERM_JKLMI

using RAJA::PERM_JKLMI = typedef camp::idx_seq<1, 2, 3, 4, 0>

PERM_JKMIL

using RAJA::PERM_JKMIL = typedef camp::idx_seq<1, 2, 4, 0, 3>

PERM_JKMLI

using RAJA::PERM_JKMLI = typedef camp::idx_seq<1, 2, 4, 3, 0>

PERM_JLIKM

using RAJA::PERM_JLIKM = typedef camp::idx_seq<1, 3, 0, 2, 4>

PERM_JLIMK

using RAJA::PERM_JLIMK = typedef camp::idx_seq<1, 3, 0, 4, 2>

PERM_JLKIM

using RAJA::PERM_JLKIM = typedef camp::idx_seq<1, 3, 2, 0, 4>

PERM_JLKMI

using RAJA::PERM_JLKMI = typedef camp::idx_seq<1, 3, 2, 4, 0>

PERM_JLMIK

using RAJA::PERM_JLMIK = typedef camp::idx_seq<1, 3, 4, 0, 2>

PERM_JLMKI

using RAJA::PERM_JLMKI = typedef camp::idx_seq<1, 3, 4, 2, 0>

PERM_JMIKL

using RAJA::PERM_JMIKL = typedef camp::idx_seq<1, 4, 0, 2, 3>

PERM_JMILK

using RAJA::PERM_JMILK = typedef camp::idx_seq<1, 4, 0, 3, 2>

PERM_JMKIL

using RAJA::PERM_JMKIL = typedef camp::idx_seq<1, 4, 2, 0, 3>

PERM_JMKLI

using RAJA::PERM_JMKLI = typedef camp::idx_seq<1, 4, 2, 3, 0>

PERM_JMLIK

using RAJA::PERM_JMLIK = typedef camp::idx_seq<1, 4, 3, 0, 2>

PERM_JMLKI

using RAJA::PERM_JMLKI = typedef camp::idx_seq<1, 4, 3, 2, 0>

PERM_KIJLM

using RAJA::PERM_KIJLM = typedef camp::idx_seq<2, 0, 1, 3, 4>

PERM_KIJML

using RAJA::PERM_KIJML = typedef camp::idx_seq<2, 0, 1, 4, 3>

PERM_KILJM

using RAJA::PERM_KILJM = typedef camp::idx_seq<2, 0, 3, 1, 4>

PERM_KILMJ

using RAJA::PERM_KILMJ = typedef camp::idx_seq<2, 0, 3, 4, 1>

PERM_KIMJL

using RAJA::PERM_KIMJL = typedef camp::idx_seq<2, 0, 4, 1, 3>

PERM_KIMLJ

using RAJA::PERM_KIMLJ = typedef camp::idx_seq<2, 0, 4, 3, 1>

PERM_KJILM

using RAJA::PERM_KJILM = typedef camp::idx_seq<2, 1, 0, 3, 4>

PERM_KJIML

using RAJA::PERM_KJIML = typedef camp::idx_seq<2, 1, 0, 4, 3>

PERM_KJLIM

using RAJA::PERM_KJLIM = typedef camp::idx_seq<2, 1, 3, 0, 4>

PERM_KJLMI

using RAJA::PERM_KJLMI = typedef camp::idx_seq<2, 1, 3, 4, 0>

PERM_KJMIL

using RAJA::PERM_KJMIL = typedef camp::idx_seq<2, 1, 4, 0, 3>

PERM_KJMLI

using RAJA::PERM_KJMLI = typedef camp::idx_seq<2, 1, 4, 3, 0>

PERM_KLIJM

using RAJA::PERM_KLIJM = typedef camp::idx_seq<2, 3, 0, 1, 4>

PERM_KLIMJ

using RAJA::PERM_KLIMJ = typedef camp::idx_seq<2, 3, 0, 4, 1>

PERM_KLJIM

using RAJA::PERM_KLJIM = typedef camp::idx_seq<2, 3, 1, 0, 4>

PERM_KLJMI

using RAJA::PERM_KLJMI = typedef camp::idx_seq<2, 3, 1, 4, 0>

PERM_KLMIJ

using RAJA::PERM_KLMIJ = typedef camp::idx_seq<2, 3, 4, 0, 1>

PERM_KLMJI

using RAJA::PERM_KLMJI = typedef camp::idx_seq<2, 3, 4, 1, 0>

PERM_KMIJL

using RAJA::PERM_KMIJL = typedef camp::idx_seq<2, 4, 0, 1, 3>

PERM_KMILJ

using RAJA::PERM_KMILJ = typedef camp::idx_seq<2, 4, 0, 3, 1>

PERM_KMJIL

using RAJA::PERM_KMJIL = typedef camp::idx_seq<2, 4, 1, 0, 3>

PERM_KMJLI

using RAJA::PERM_KMJLI = typedef camp::idx_seq<2, 4, 1, 3, 0>

PERM_KMLIJ

using RAJA::PERM_KMLIJ = typedef camp::idx_seq<2, 4, 3, 0, 1>

PERM_KMLJI

using RAJA::PERM_KMLJI = typedef camp::idx_seq<2, 4, 3, 1, 0>

PERM_LIJKM

using RAJA::PERM_LIJKM = typedef camp::idx_seq<3, 0, 1, 2, 4>

PERM_LIJMK

using RAJA::PERM_LIJMK = typedef camp::idx_seq<3, 0, 1, 4, 2>

PERM_LIKJM

using RAJA::PERM_LIKJM = typedef camp::idx_seq<3, 0, 2, 1, 4>

PERM_LIKMJ

using RAJA::PERM_LIKMJ = typedef camp::idx_seq<3, 0, 2, 4, 1>

PERM_LIMJK

using RAJA::PERM_LIMJK = typedef camp::idx_seq<3, 0, 4, 1, 2>

PERM_LIMKJ

using RAJA::PERM_LIMKJ = typedef camp::idx_seq<3, 0, 4, 2, 1>

PERM_LJIKM

using RAJA::PERM_LJIKM = typedef camp::idx_seq<3, 1, 0, 2, 4>

PERM_LJIMK

using RAJA::PERM_LJIMK = typedef camp::idx_seq<3, 1, 0, 4, 2>

PERM_LJKIM

using RAJA::PERM_LJKIM = typedef camp::idx_seq<3, 1, 2, 0, 4>

PERM_LJKMI

using RAJA::PERM_LJKMI = typedef camp::idx_seq<3, 1, 2, 4, 0>

PERM_LJMIK

using RAJA::PERM_LJMIK = typedef camp::idx_seq<3, 1, 4, 0, 2>

PERM_LJMKI

using RAJA::PERM_LJMKI = typedef camp::idx_seq<3, 1, 4, 2, 0>

PERM_LKIJM

using RAJA::PERM_LKIJM = typedef camp::idx_seq<3, 2, 0, 1, 4>

PERM_LKIMJ

using RAJA::PERM_LKIMJ = typedef camp::idx_seq<3, 2, 0, 4, 1>

PERM_LKJIM

using RAJA::PERM_LKJIM = typedef camp::idx_seq<3, 2, 1, 0, 4>

PERM_LKJMI

using RAJA::PERM_LKJMI = typedef camp::idx_seq<3, 2, 1, 4, 0>

PERM_LKMIJ

using RAJA::PERM_LKMIJ = typedef camp::idx_seq<3, 2, 4, 0, 1>

PERM_LKMJI

using RAJA::PERM_LKMJI = typedef camp::idx_seq<3, 2, 4, 1, 0>

PERM_LMIJK

using RAJA::PERM_LMIJK = typedef camp::idx_seq<3, 4, 0, 1, 2>

PERM_LMIKJ

using RAJA::PERM_LMIKJ = typedef camp::idx_seq<3, 4, 0, 2, 1>

PERM_LMJIK

using RAJA::PERM_LMJIK = typedef camp::idx_seq<3, 4, 1, 0, 2>

PERM_LMJKI

using RAJA::PERM_LMJKI = typedef camp::idx_seq<3, 4, 1, 2, 0>

PERM_LMKIJ

using RAJA::PERM_LMKIJ = typedef camp::idx_seq<3, 4, 2, 0, 1>

PERM_LMKJI

using RAJA::PERM_LMKJI = typedef camp::idx_seq<3, 4, 2, 1, 0>

PERM_MIJKL

using RAJA::PERM_MIJKL = typedef camp::idx_seq<4, 0, 1, 2, 3>

PERM_MIJLK

using RAJA::PERM_MIJLK = typedef camp::idx_seq<4, 0, 1, 3, 2>

PERM_MIKJL

using RAJA::PERM_MIKJL = typedef camp::idx_seq<4, 0, 2, 1, 3>

PERM_MIKLJ

using RAJA::PERM_MIKLJ = typedef camp::idx_seq<4, 0, 2, 3, 1>

PERM_MILJK

using RAJA::PERM_MILJK = typedef camp::idx_seq<4, 0, 3, 1, 2>

PERM_MILKJ

using RAJA::PERM_MILKJ = typedef camp::idx_seq<4, 0, 3, 2, 1>

PERM_MJIKL

using RAJA::PERM_MJIKL = typedef camp::idx_seq<4, 1, 0, 2, 3>

PERM_MJILK

using RAJA::PERM_MJILK = typedef camp::idx_seq<4, 1, 0, 3, 2>

PERM_MJKIL

using RAJA::PERM_MJKIL = typedef camp::idx_seq<4, 1, 2, 0, 3>

PERM_MJKLI

using RAJA::PERM_MJKLI = typedef camp::idx_seq<4, 1, 2, 3, 0>

PERM_MJLIK

using RAJA::PERM_MJLIK = typedef camp::idx_seq<4, 1, 3, 0, 2>

PERM_MJLKI

using RAJA::PERM_MJLKI = typedef camp::idx_seq<4, 1, 3, 2, 0>

PERM_MKIJL

using RAJA::PERM_MKIJL = typedef camp::idx_seq<4, 2, 0, 1, 3>

PERM_MKILJ

using RAJA::PERM_MKILJ = typedef camp::idx_seq<4, 2, 0, 3, 1>

PERM_MKJIL

using RAJA::PERM_MKJIL = typedef camp::idx_seq<4, 2, 1, 0, 3>

PERM_MKJLI

using RAJA::PERM_MKJLI = typedef camp::idx_seq<4, 2, 1, 3, 0>

PERM_MKLIJ

using RAJA::PERM_MKLIJ = typedef camp::idx_seq<4, 2, 3, 0, 1>

PERM_MKLJI

using RAJA::PERM_MKLJI = typedef camp::idx_seq<4, 2, 3, 1, 0>

PERM_MLIJK

using RAJA::PERM_MLIJK = typedef camp::idx_seq<4, 3, 0, 1, 2>

PERM_MLIKJ

using RAJA::PERM_MLIKJ = typedef camp::idx_seq<4, 3, 0, 2, 1>

PERM_MLJIK

using RAJA::PERM_MLJIK = typedef camp::idx_seq<4, 3, 1, 0, 2>

PERM_MLJKI

using RAJA::PERM_MLJKI = typedef camp::idx_seq<4, 3, 1, 2, 0>

PERM_MLKIJ

using RAJA::PERM_MLKIJ = typedef camp::idx_seq<4, 3, 2, 0, 1>

PERM_MLKJI

using RAJA::PERM_MLKJI = typedef camp::idx_seq<4, 3, 2, 1, 0>

invert_permutation

template<typename Perm >

using RAJA::invert_permutation = typedef typename internal::InversePermutationHelper< camp::make_idx_seq_t<camp::size<Perm>::value>, Perm>::type

Inverts a permutation

Perm

template<camp::idx_t... Ints>

using RAJA::Perm = typedef camp::idx_seq<Ints...>

MakePerm

template<camp::idx_t N>

using RAJA::MakePerm = typedef typename camp::make_idx_seq<N>::type

HighAccuracyReduce

template<typename T , typename BinaryOp >

using RAJA::HighAccuracyReduce = typedef std::conditional_t<RAJA::operators::is_fp_associative<T>::value, BinaryTreeReduce<T, BinaryOp>, LeftFoldReduce<T, BinaryOp> >

StaticLayoutT

template<typename Perm , typename IdxLin , camp::idx_t... Sizes>

using RAJA::StaticLayoutT = typedef typename detail::StaticLayoutMaker< Perm, IdxLin, camp::int_seq<IdxLin, Sizes...>, camp::make_int_seq_t<IdxLin, sizeof...(Sizes)>, void>::type

StaticLayout

template<typename Perm , camp::idx_t... Sizes>

using RAJA::StaticLayout = typedef StaticLayoutT<Perm, camp::idx_t, Sizes...>

TypedStaticLayout

template<typename Perm , typename IdxLin , typename TypeList , camp::idx_t... Sizes>

using RAJA::TypedStaticLayout = typedef typename detail::StaticLayoutMaker< Perm, IdxLin, camp::int_seq<IdxLin, Sizes...>, camp::make_int_seq_t<IdxLin, sizeof...(Sizes)>, TypeList>::type

Index_type

using RAJA::Index_type = typedef std::ptrdiff_t

Type use for all loop indexing in RAJA constructs.

TDRAReal_ptr

using RAJA::TDRAReal_ptr = typedef Real_type* RAJA_RESTRICT

RAJA scalar type definitions.

const_TDRAReal_ptr

using RAJA::const_TDRAReal_ptr = typedef const TDRAReal_ptr

View

template<typename ValueType , typename LayoutType , typename PointerType = ValueType*>

using RAJA::View = typedef internal::ViewBase<ValueType, PointerType, LayoutType>

TypedView

template<typename ValueType , typename LayoutType , typename... IndexTypes>

using RAJA::TypedView = typedef internal:: TypedViewBase<ValueType, ValueType*, LayoutType, camp::list<IndexTypes...> >

cat_seq_t

template<typename Seq1 , typename Seq2 >

using RAJA::cat_seq_t = typedef typename cat_seq<Seq1, Seq2>::type

offset_seq_t

template<camp::idx_t Offset, typename Seq >

using RAJA::offset_seq_t = typedef typename offset_seq<Offset, Seq>::type

zip_tuple_element_t

template<camp::idx_t I, typename ZT >

using RAJA::zip_tuple_element_t = typedef typename zip_tuple_element<I, ZT>::type

zip_ref

template<typename... Ts>

using RAJA::zip_ref = typedef zip_tuple<false, Ts...>

zip_val

template<typename... Ts>

using RAJA::zip_val = typedef zip_tuple<true, Ts...>

Enumeration Type Documentation

PushEnd

enum RAJA::PushEnd

Enumerator
PUSH_FRONT
PUSH_BACK

PushCopy

enum RAJA::PushCopy

Enumerator
PUSH_COPY
PUSH_NOCOPY

ExecPlace

enum RAJA::ExecPlace : int

strong

Enumerator
HOST
DEVICE
NUM_PLACES

Policy

enum RAJA::Policy

strong

Enumerator
undefined
sequential
simd
openmp
target_openmp
cuda
hip
sycl

Pattern

enum RAJA::Pattern

strong

Enumerator
undefined
forall
region
reduce
multi_reduce
taskgraph
synchronize
workgroup
workgroup_exec
workgroup_order
workgroup_storage
workgroup_dispatch

Launch

enum RAJA::Launch

strong

Enumerator
undefined
sync
async

KahanSumImplementation

enum RAJA::KahanSumImplementation

strong

Enumerator
Default
Volatile

named_usage

enum RAJA::named_usage : int

Enum for named values with special usage.

Enumerator
ignored
unspecified

named_dim

enum RAJA::named_dim : int

strong

Enum for named dimensions.

Enumerator
x
y
z

kernel_sync_requirement

enum RAJA::kernel_sync_requirement : int

strong

Enum for synchronization requirements in some kernel constructs.

Enumerator
none
sync

IndexOwnership

enum RAJA::IndexOwnership

Enumeration used to indicate whether ListSegment object owns data representing its indices.

Enumerator
Unowned
Owned

Function Documentation

buildIndexSetAligned()

void RAJASHAREDDLL_API RAJA::buildIndexSetAligned	(	RAJA::TypedIndexSet< RAJA::RangeSegment, RAJA::ListSegment > &	iset,
		camp::resources::Resource	work_res,
		const RAJA::Index_type *const	indices_in,
		RAJA::Index_type	length,
		RAJA::Index_type	range_min_length,
		RAJA::Index_type	range_align
	)

Generate an index set with aligned Range segments and List segments, as needed, from given array of indices.

Routine does no error-checking on argements and assumes RAJA::Index_type array contains valid indices.

Parameters

iset	reference to index set generated with aligned range segments and list segments. Method assumes index set is empty (no segments).
work_res	camp resource object that identifies the memory space in which list segment index data will live (passed to list segment ctor).
indices_in	pointer to start of input array of indices.
length	size of input index array.
range_min_length	min length of any range segment in index set
range_align	"alignment" value for range segments in index set. Starting index each range segment will be a multiple of this value.

buildLockFreeBlockIndexset()

void RAJA::buildLockFreeBlockIndexset	(	RAJA::TypedIndexSet< RAJA::RangeSegment > &	iset,
		int	fastDim,
		int	midDim,
		int	slowDim
	)

Generate a lock-free "block" index set (planar division) containing range segments.

The method chunks a fastDim x midDim x slowDim mesh into blocks that can be dependency-scheduled, removing need for lock constructs.

Parameters

iset	reference to index set generated with range segments. Method assumes index set is empty (no segments).
fastDim	"fast" block dimension (see above).
midDim	"mid" block dimension (see above).
slowDim	"slow" block dimension (see above).

buildLockFreeColorIndexset()

void RAJA::buildLockFreeColorIndexset	(	RAJA::TypedIndexSet< RAJA::RangeSegment, RAJA::ListSegment > &	iset,
		camp::resources::Resource	work_res,
		RAJA::Index_type const *	domainToRange,
		int	numEntity,
		int	numRangePerDomain,
		int	numEntityRange,
		RAJA::Index_type *	elemPermutation = nullptr,
		RAJA::Index_type *	ielemPermutation = nullptr
	)

Generate a lock-free "color" index set containing range and list segments.

TThe domain-set is colored based on connectivity to the range-set. All elements in each segment are independent, and no two segments can be executed in parallel.

Parameters

iset	reference to index set generated. Method assumes index set is empty (no segments).
work_res	camp resource object that identifies the memory space in which list segment index data will live (passed to list segment ctor).

getIndices() [1/2]

template<typename CONTAINER_T , typename... SEG_TYPES>

RAJA_INLINE void RAJA::getIndices	(	CONTAINER_T &	con,
		const TypedIndexSet< SEG_TYPES... > &	iset
	)

Copy all indices in given index set to given container.

getIndices() [2/2]

template<typename CONTAINER_T , typename SEGMENT_T >

RAJA_INLINE void RAJA::getIndices	(	CONTAINER_T &	con,
		const SEGMENT_T &	seg
	)

Copy all indices in given segment to given container.

getIndicesConditional() [1/2]

template<typename CONTAINER_T , typename... SEG_TYPES, typename CONDITIONAL >

RAJA_INLINE void RAJA::getIndicesConditional	(	CONTAINER_T &	con,
		const TypedIndexSet< SEG_TYPES... > &	iset,
		CONDITIONAL	conditional
	)

Copy all indices in given index set that satisfy given conditional to given container.

getIndicesConditional() [2/2]

template<typename CONTAINER_T , typename SEGMENT_T , typename CONDITIONAL >

RAJA_INLINE void RAJA::getIndicesConditional	(	CONTAINER_T &	con,
		const SEGMENT_T &	seg,
		CONDITIONAL	conditional
	)

Copy all indices in given segment that satisfy given conditional to given container.

convertIndex()

template<typename TO , typename FROM >

constexpr RAJA_HOST_DEVICE RAJA_INLINE TO RAJA::convertIndex ( FROM const  val )

constexpr

Function provides a way to take either an int or any Index<> type, and convert it to another type, possibly another Index or an int.

stripIndexType() [1/2]

template<typename FROM >

constexpr RAJA_HOST_DEVICE RAJA_INLINE std::enable_if<std::is_base_of<IndexValueBase, FROM>::value, typename FROM::value_type>::type RAJA::stripIndexType ( FROM const  val )

constexpr

Function that strips the strongly typed Index<> and returns its underlying value_type value.

stripIndexType() [2/2]

template<typename FROM >

constexpr RAJA_HOST_DEVICE RAJA_INLINE std::enable_if<!std::is_base_of<IndexValueBase, FROM>::value, FROM>::type RAJA::stripIndexType ( FROM const  val )

constexpr

make_range()

template<typename BeginT , typename EndT , typename Common = detail::common_type_t<BeginT, EndT>>

RAJA_HOST_DEVICE TypedRangeSegment<Common> RAJA::make_range	(	BeginT &&	begin,
		EndT &&	end
	)

Function to make a TypedRangeSegment for the interval [begin, end)

Returns

a newly constructed TypedRangeSegment where the value_type is equivilent to the common type of @begin and @end. If there is no common type, then a compiler error will be produced.

make_strided_range()

template<typename BeginT , typename EndT , typename StrideT , typename Common = detail::common_type_t<BeginT, EndT>>

RAJA_HOST_DEVICE TypedRangeStrideSegment<Common> RAJA::make_strided_range	(	BeginT &&	begin,
		EndT &&	end,
		StrideT &&	stride
	)

Function to make a TypedRangeStride Segment for the interval [begin, end) with given stride.

Returns

a newly constructed TypedRangeStrideSegment where the value_type is equivilent to the common type of @begin, @end, and @stride. If there is no common type, then a compiler error will be produced.

RAJA_ALIGNED_ATTR()

class RAJA::RAJA_ALIGNED_ATTR

(

256

)

Class defining a simple semephore-based data structure for managing a node in a dependency graph.

Constants for total number of allowable dependent tasks and alignment of semaphore value (should match cache coherence page size?).

These values may need to be set differently for different algorithms and platforms. We haven't determined the best defaults yet!

Default ctor initializes node to default state.

Get/set semaphore value; i.e., the current number of (unsatisfied) dependencies that must be satisfied before this task can execute.

Get/set semaphore "reload" value; i.e., the total number of external task dependencies that must be satisfied before this task can execute.

Ready this task to be used again

Satisfy one incoming dependency

Wait for all dependencies to be satisfied

Get/set the number of "forward-dependencies" for this task; i.e., the number of external tasks that cannot execute until this task completes.

Get/set the forward dependency task number associated with the given index for this task. This is used to notify the appropriate external dependencies when this task completes.

Print task graph object node data to given output stream.

foldl() [1/3]

template<typename Op , typename Arg1 >

RAJA_HOST_DEVICE constexpr RAJA_INLINE auto RAJA::foldl ( Op &&  RAJA_UNUSED_ARGoperation, Arg1 &&  arg  ) -> typename detail::foldl_impl<Op, Arg1>::Ret

constexpr

foldl() [2/3]

template<typename Op , typename Arg1 , typename Arg2 >

RAJA_HOST_DEVICE constexpr RAJA_INLINE auto RAJA::foldl ( Op &&  operation, Arg1 &&  arg1, Arg2 &&  arg2  ) -> typename detail::foldl_impl<Op, Arg1, Arg2>::Ret

constexpr

foldl() [3/3]

template<typename Op , typename Arg1 , typename Arg2 , typename Arg3 , typename... Rest>

RAJA_HOST_DEVICE constexpr RAJA_INLINE auto RAJA::foldl ( Op &&  operation, Arg1 &&  arg1, Arg2 &&  arg2, Arg3 &&  arg3, Rest &&...  rest  ) -> typename detail::foldl_impl<Op, Arg1, Arg2, Arg3, Rest...>::Ret

constexpr

sum()

template<typename Result , typename... Args>

RAJA_HOST_DEVICE constexpr RAJA_INLINE Result RAJA::sum ( Args...  args )

constexpr

product()

template<typename Result , typename... Args>

RAJA_HOST_DEVICE constexpr RAJA_INLINE Result RAJA::product ( Args...  args )

constexpr

max()

template<typename Result , typename... Args>

RAJA_HOST_DEVICE constexpr RAJA_INLINE Result RAJA::max ( Args...  args )

constexpr

min()

template<typename Result , typename... Args>

RAJA_HOST_DEVICE constexpr RAJA_INLINE Result RAJA::min ( Args...  args )

constexpr

allocate_aligned()

void* RAJA::allocate_aligned ( size_t  alignment, size_t  size  )

inline

Portable aligned memory allocation

allocate_aligned_type()

template<typename T >

T* RAJA::allocate_aligned_type ( size_t  alignment, size_t  size  )

inline

Portable aligned memory allocation

free_aligned()

void RAJA::free_aligned ( void *  ptr )

inline

Portable aligned memory free - required for Windows

getMaxOMPThreadsCPU()

template<typename ThreadPolicy = RAJA::detail::active_auto_thread>

RAJA_INLINE int RAJA::getMaxOMPThreadsCPU

(

)

Return max number of available OpenMP threads.

atomicLoad() [1/4]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicLoad

(

T *

acc

)

Atomic load.

Parameters

acc	Pointer to location of value

Returns

Value at acc

atomicStore() [1/4]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE void RAJA::atomicStore	(	T *	acc,
		T	value
	)

Atomic store.

Parameters

acc	Pointer to location of value
value	Value to store at *acc

atomicAdd() [1/4]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicAdd	(	T *	acc,
		T	value
	)

Atomic add.

Parameters

acc	Pointer to location of result value
value	Value to add to *acc

Returns

Returns value at acc immediately before this operation completed

atomicSub() [1/4]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicSub	(	T *	acc,
		T	value
	)

Atomic subtract.

Parameters

acc	Pointer to location of result value
value	Value to subtract from *acc

Returns

Returns value at acc immediately before this operation completed

atomicMin() [1/4]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicMin	(	T *	acc,
		T	value
	)

Atomic minimum equivalent to (*acc) = std::min(*acc, value)

Parameters

acc	Pointer to location of result value
value	Value to compare to *acc

Returns

Returns value at acc immediately before this operation completed

atomicMax() [1/4]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicMax	(	T *	acc,
		T	value
	)

Atomic maximum equivalent to (*acc) = std::max(*acc, value)

Parameters

acc	Pointer to location of result value
value	Value to compare to *acc

Returns

Returns value at acc immediately before this operation completed

atomicInc() [1/8]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicInc

(

T *

acc

)

Atomic increment.

Parameters

acc	Pointer to location of value to increment

Returns

Returns value at acc immediately before this operation completed

atomicInc() [2/8]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicInc	(	T *	acc,
		T	compare
	)

Atomic increment with bound Equivalent to *acc = ((*acc >= compare) ? 0 : ((*acc)+1)) This is for compatability with the CUDA atomicInc.

Parameters

acc	Pointer to location of value to increment
compare	Bound value

Returns

Returns value at acc immediately before this operation completed

atomicDec() [1/8]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicDec

(

T *

acc

)

Atomic decrement.

Parameters

acc	Pointer to location of value to decrement

Returns

Returns value at acc immediately before this operation completed

atomicDec() [2/8]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicDec	(	T *	acc,
		T	compare
	)

Atomic decrement with bound Equivalent to *acc = (((*acc==0)|(*acc>compare))?compare:((*acc)-1)) This is for compatability with the CUDA atomicDec.

Parameters

acc	Pointer to location of value to decrement
compare	Bound value

Returns

Returns value at acc immediately before this operation completed

atomicAnd() [1/4]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicAnd	(	T *	acc,
		T	value
	)

Atomic bitwise AND equivalent to (*acc) = (*acc) & value This only works with integral data types.

Parameters

acc	Pointer to location of result value
value	Value to bitwise AND with *acc

Returns

Returns value at acc immediately before this operation completed

atomicOr() [1/4]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicOr	(	T *	acc,
		T	value
	)

Atomic bitwise OR equivalent to (*acc) = (*acc) | value This only works with integral data types.

Parameters

acc	Pointer to location of result value
value	Value to bitwise OR with *acc

Returns

Returns value at acc immediately before this operation completed

atomicXor() [1/4]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicXor	(	T *	acc,
		T	value
	)

Atomic bitwise XOR equivalent to (*acc) = (*acc) ^ value This only works with integral data types.

Parameters

acc	Pointer to location of result value
value	Value to bitwise XOR with *acc

Returns

Returns value at acc immediately before this operation completed

atomicExchange() [1/4]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicExchange	(	T *	acc,
		T	value
	)

Atomic value exchange.

Parameters

acc	Pointer to location to store value
value	Value to exchange with *acc

Returns

Returns value at *acc immediately before this operation completed

atomicCAS() [1/4]

template<typename Policy , typename T >

RAJA_SUPPRESS_HD_WARN RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicCAS	(	T *	acc,
		T	compare,
		T	value
	)

Atomic compare and swap.

Parameters

acc	Pointer to location to store value
value	Value to exchange with *acc
compare	Value to compare with *acc

Returns

Returns value at *acc immediately before this operation completed

safe_iter_swap()

template<typename Iter >

RAJA_HOST_DEVICE RAJA_INLINE void RAJA::safe_iter_swap	(	Iter	lhs,
		Iter	rhs
	)

swap values at iterators lhs and rhs

next()

template<typename Iter >

RAJA_HOST_DEVICE RAJA_INLINE Iter RAJA::next

(

Iter

it

)

returns iterator to next item

prev()

template<typename Iter >

RAJA_HOST_DEVICE RAJA_INLINE Iter RAJA::prev

(

Iter

it

)

returns iterator to next item

forall() [1/7]

template<typename ExecutionPolicy , typename... Args, typename Res = typename resources::get_resource<ExecutionPolicy>::type>

RAJA_INLINE resources::EventProxy<Res> RAJA::forall

(

Args &&...

args

)

Conversion from template-based policy to value-based policy for forall.

this reduces implementation overhead and perfectly forwards all arguments

forall() [2/7]

template<typename ExecutionPolicy , typename Res , typename... Args>

RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_resource<Res> > RAJA::forall	(	Res	r,
		Args &&...	args
	)

forall_Icount() [1/6]

template<typename ExecutionPolicy , typename... Args, typename Res = typename resources::get_resource<ExecutionPolicy>::type>

RAJA_INLINE resources::EventProxy<Res> RAJA::forall_Icount

(

Args &&...

args

)

Conversion from template-based policy to value-based policy for forall_Icount.

this reduces implementation overhead and perfectly forwards all arguments

forall_Icount() [2/6]

template<typename ExecutionPolicy , typename Res , typename... Args>

RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_resource<Res> > RAJA::forall_Icount	(	Res	r,
		Args &&...	args
	)

dynamic_forall() [1/2]

template<typename POLICY_LIST , typename SEGMENT , typename... PARAMS>

void RAJA::dynamic_forall	(	const int	pol,
		SEGMENT const &	seg,
		PARAMS &&...	params
	)

dynamic_forall() [2/2]

template<typename POLICY_LIST , typename SEGMENT , typename... PARAMS>

resources::EventProxy<resources::Resource> RAJA::dynamic_forall	(	RAJA::resources::Resource	r,
		const int	pol,
		SEGMENT const &	seg,
		PARAMS &&...	params
	)

make_wrapped_tuple()

template<class Tuple >

constexpr RAJA_INLINE auto RAJA::make_wrapped_tuple ( Tuple &&  t ) -> decltype(internal::make_wrapped_tuple_impl( std::forward<Tuple>(t), camp::make_idx_seq_t<camp::tuple_size<camp::decay<Tuple>>::value> {}))

constexpr

kernel_param_resource()

template<typename PolicyType , typename SegmentTuple , typename ParamTuple , typename Resource , typename... Bodies>

RAJA_INLINE resources::EventProxy<Resource> RAJA::kernel_param_resource	(	SegmentTuple &&	segments,
		ParamTuple &&	params,
		Resource	resource,
		Bodies &&...	bodies
	)

kernel_resource()

template<typename PolicyType , typename SegmentTuple , typename Resource , typename... Bodies>

RAJA_INLINE resources::EventProxy<Resource> RAJA::kernel_resource	(	SegmentTuple &&	segments,
		Resource	resource,
		Bodies &&...	bodies
	)

kernel_param()

template<typename PolicyType , typename SegmentTuple , typename ParamTuple , typename... Bodies>

RAJA_INLINE resources::EventProxy<resources::resource_from_pol_t<PolicyType> > RAJA::kernel_param	(	SegmentTuple &&	segments,
		ParamTuple &&	params,
		Bodies &&...	bodies
	)

kernel()

template<typename PolicyType , typename SegmentTuple , typename... Bodies>

RAJA_INLINE resources::EventProxy<resources::resource_from_pol_t<PolicyType> > RAJA::kernel	(	SegmentTuple &&	segments,
		Bodies &&...	bodies
	)

launch() [1/4]

template<typename LAUNCH_POLICY , typename... ReduceParams>

void RAJA::launch	(	LaunchParams const &	launch_params,
		ReduceParams &&...	rest_of_launch_args
	)

launch() [2/4]

template<typename POLICY_LIST , typename BODY >

void RAJA::launch	(	ExecPlace	place,
		LaunchParams const &	params,
		BODY const &	body
	)

launch() [3/4]

template<typename POLICY_LIST , typename... ReduceParams>

void RAJA::launch	(	ExecPlace	place,
		const LaunchParams &	launch_params,
		ReduceParams &&...	rest_of_launch_args
	)

Get_Host_Resource()

template<typename T >

RAJA::resources::Resource RAJA::Get_Host_Resource	(	T	host_res,
		RAJA::ExecPlace	device
	)

launch() [4/4]

template<typename POLICY_LIST , typename... ReduceParams>

resources::EventProxy<resources::Resource> RAJA::launch	(	RAJA::resources::Resource	res,
		LaunchParams const &	launch_params,
		ReduceParams &&...	rest_of_launch_args
	)

loop()

template<typename POLICY_LIST , typename CONTEXT , typename SEGMENT , typename BODY >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE void RAJA::loop	(	CONTEXT const &	ctx,
		SEGMENT const &	segment,
		BODY const &	body
	)

loop_icount()

template<typename POLICY_LIST , typename CONTEXT , typename SEGMENT , typename BODY >

RAJA_HOST_DEVICE RAJA_INLINE void RAJA::loop_icount	(	CONTEXT const &	ctx,
		SEGMENT const &	segment,
		BODY const &	body
	)

tile()

template<typename POLICY_LIST , typename CONTEXT , typename TILE_T , typename SEGMENT , typename BODY >

RAJA_HOST_DEVICE RAJA_INLINE void RAJA::tile	(	CONTEXT const &	ctx,
		TILE_T	tile_size,
		SEGMENT const &	segment,
		BODY const &	body
	)

tile_tcount()

template<typename POLICY_LIST , typename CONTEXT , typename TILE_T , typename SEGMENT , typename BODY >

RAJA_HOST_DEVICE RAJA_INLINE void RAJA::tile_tcount	(	CONTEXT const &	ctx,
		TILE_T	tile_size,
		SEGMENT const &	segment,
		BODY const &	body
	)

Name()

auto RAJA::Name ( const char *  n )

inline

region() [1/2]

template<typename ExecutionPolicy , typename LoopBody >

void RAJA::region

(

LoopBody &&

loop_body

)

region() [2/2]

template<typename ExecutionPolicy , typename OuterBody , typename InnerBody >

void RAJA::region	(	OuterBody &&	outer_body,
		InnerBody &&	inner_body
	)

exclusive_scan() [1/4]

template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>

RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy> > RAJA::exclusive_scan

(

Args &&...

args

)

Conversion from template-based policy to value-based policy for exclusive_scan.

this reduces implementation overhead and perfectly forwards all arguments

exclusive_scan() [2/4]

template<typename ExecPolicy , typename Res , typename... Args>

RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy>, type_traits::is_resource<Res> > RAJA::exclusive_scan	(	Res	r,
		Args &&...	args
	)

inclusive_scan() [1/4]

template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>

RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy> > RAJA::inclusive_scan

(

Args &&...

args

)

Conversion from template-based policy to value-based policy for inclusive_scan.

this reduces implementation overhead and perfectly forwards all arguments

inclusive_scan() [2/4]

template<typename ExecPolicy , typename Res , typename... Args>

RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy>, type_traits::is_resource<Res> > RAJA::inclusive_scan	(	Res	r,
		Args &&...	args
	)

exclusive_scan_inplace() [1/4]

template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>

RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy> > RAJA::exclusive_scan_inplace

(

Args &&...

args

)

Conversion from template-based policy to value-based policy for exclusive_scan_inplace.

this reduces implementation overhead and perfectly forwards all arguments

exclusive_scan_inplace() [2/4]

template<typename ExecPolicy , typename Res , typename... Args>

RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy>, type_traits::is_resource<Res> > RAJA::exclusive_scan_inplace	(	Res	r,
		Args &&...	args
	)

inclusive_scan_inplace() [1/4]

template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>

RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy> > RAJA::inclusive_scan_inplace

(

Args &&...

args

)

Conversion from template-based policy to value-based policy for inclusive_scan_inplace.

this reduces implementation overhead and perfectly forwards all arguments

inclusive_scan_inplace() [2/4]

template<typename ExecPolicy , typename Res , typename... Args>

RAJA_INLINE concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy>, type_traits::is_resource<Res> > RAJA::inclusive_scan_inplace	(	Res	r,
		Args &&...	args
	)

sort() [1/4]

template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>

concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy> > RAJA::sort

(

Args &&...

args

)

Conversion from template-based policy to value-based policy for sort.

this reduces implementation overhead and perfectly forwards all arguments

sort() [2/4]

template<typename ExecPolicy , typename Res , typename... Args>

concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy>, type_traits::is_resource<Res> > RAJA::sort	(	Res	r,
		Args &&...	args
	)

stable_sort() [1/4]

template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>

concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy> > RAJA::stable_sort

(

Args &&...

args

)

Conversion from template-based policy to value-based policy for stable_sort.

this reduces implementation overhead and perfectly forwards all arguments

stable_sort() [2/4]

template<typename ExecPolicy , typename Res , typename... Args>

concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy>, type_traits::is_resource<Res> > RAJA::stable_sort	(	Res	r,
		Args &&...	args
	)

sort_pairs() [1/4]

template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>

concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy> > RAJA::sort_pairs

(

Args &&...

args

)

Conversion from template-based policy to value-based policy for sort_pairs.

this reduces implementation overhead and perfectly forwards all arguments

sort_pairs() [2/4]

template<typename ExecPolicy , typename Res , typename... Args>

concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy>, type_traits::is_resource<Res> > RAJA::sort_pairs	(	Res	r,
		Args &&...	args
	)

stable_sort_pairs() [1/4]

template<typename ExecPolicy , typename... Args, typename Res = typename resources::get_resource<ExecPolicy>::type>

concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy> > RAJA::stable_sort_pairs

(

Args &&...

args

)

Conversion from template-based policy to value-based policy for sort_pairs.

this reduces implementation overhead and perfectly forwards all arguments

stable_sort_pairs() [2/4]

template<typename ExecPolicy , typename Res , typename... Args>

concepts::enable_if_t<resources::EventProxy<Res>, type_traits::is_execution_policy<ExecPolicy>, type_traits::is_resource<Res> > RAJA::stable_sort_pairs	(	Res	r,
		Args &&...	args
	)

synchronize()

template<typename Policy >

void RAJA::synchronize

(

)

Synchronize all current RAJA executions for the specified policy.

The type of synchronization performed depends on the execution policy. For example, to syncrhonize the current CUDA device, use:

RAJA::synchronize<RAJA::cuda_synchronize>();

Template Parameters

Policy

synchronization policy

See also

RAJA::policy::omp::synchronize_impl

RAJA::policy::cuda::synchronize_impl

get_max_threads() [1/3]

template<typename Policy >

RAJA_INLINE RAJA_HOST_DEVICE int RAJA::get_max_threads

(

)

Get maximum number of threads.

This is based on OpenMP threading model. This value is also an upper bound on the number of threads that could be used to form a new team if a parallel region without a num_threads clause were encountered after execution returns from this routine.

Returns 1 if OMP is not active.

Returns

Maximum number of threads

get_thread_num() [1/3]

template<typename Policy >

RAJA_INLINE RAJA_HOST_DEVICE int RAJA::get_thread_num

(

)

Get current thread number This is based on the OpenMP threading model. Within a parallel team executing a parallel region the threads are numbered 0-N. Returns 0 if called in sequential part of a program or OMP is not active.

Returns

Current thread number

atomicLoad() [2/4]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicLoad	(	auto_atomic	,
		T *	acc
	)

atomicStore() [2/4]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE void RAJA::atomicStore	(	auto_atomic	,
		T *	acc,
		T	value
	)

atomicAdd() [2/4]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicAdd	(	auto_atomic	,
		T *	acc,
		T	value
	)

atomicSub() [2/4]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicSub	(	auto_atomic	,
		T *	acc,
		T	value
	)

atomicMin() [2/4]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicMin	(	auto_atomic	,
		T *	acc,
		T	value
	)

atomicMax() [2/4]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicMax	(	auto_atomic	,
		T *	acc,
		T	value
	)

atomicInc() [3/8]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicInc	(	auto_atomic	,
		T *	acc
	)

atomicInc() [4/8]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicInc	(	auto_atomic	,
		T *	acc,
		T	compare
	)

atomicDec() [3/8]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicDec	(	auto_atomic	,
		T *	acc
	)

atomicDec() [4/8]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicDec	(	auto_atomic	,
		T *	acc,
		T	compare
	)

atomicAnd() [2/4]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicAnd	(	auto_atomic	,
		T *	acc,
		T	value
	)

atomicOr() [2/4]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicOr	(	auto_atomic	,
		T *	acc,
		T	value
	)

atomicXor() [2/4]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicXor	(	auto_atomic	,
		T *	acc,
		T	value
	)

atomicExchange() [2/4]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicExchange	(	auto_atomic	,
		T *	acc,
		T	value
	)

atomicCAS() [2/4]

template<typename T >

RAJA_INLINE RAJA_HOST_DEVICE T RAJA::atomicCAS	(	auto_atomic	,
		T *	acc,
		T	compare,
		T	value
	)

atomicLoad() [3/4]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicLoad	(	builtin_atomic	,
		T *	acc
	)

atomicStore() [3/4]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE void RAJA::atomicStore	(	builtin_atomic	,
		T *	acc,
		T	value
	)

atomicAdd() [3/4]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicAdd	(	builtin_atomic	,
		T *	acc,
		T	value
	)

atomicSub() [3/4]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicSub	(	builtin_atomic	,
		T *	acc,
		T	value
	)

atomicMin() [3/4]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicMin	(	builtin_atomic	,
		T *	acc,
		T	value
	)

atomicMax() [3/4]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicMax	(	builtin_atomic	,
		T *	acc,
		T	value
	)

atomicInc() [5/8]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicInc	(	builtin_atomic	,
		T *	acc
	)

atomicInc() [6/8]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicInc	(	builtin_atomic	,
		T *	acc,
		T	value
	)

atomicDec() [5/8]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicDec	(	builtin_atomic	,
		T *	acc
	)

atomicDec() [6/8]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicDec	(	builtin_atomic	,
		T *	acc,
		T	value
	)

atomicAnd() [3/4]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicAnd	(	builtin_atomic	,
		T *	acc,
		T	value
	)

atomicOr() [3/4]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicOr	(	builtin_atomic	,
		T *	acc,
		T	value
	)

atomicXor() [3/4]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicXor	(	builtin_atomic	,
		T *	acc,
		T	value
	)

atomicExchange() [3/4]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicExchange	(	builtin_atomic	,
		T *	acc,
		T	value
	)

atomicCAS() [3/4]

template<typename T >

RAJA_DEVICE_HIP RAJA_INLINE T RAJA::atomicCAS	(	builtin_atomic	,
		T *	acc,
		T	compare,
		T	value
	)

launch_new_reduce_global_fcn() [1/2]

template<typename BODY , typename ReduceParams >

__global__ void RAJA::launch_new_reduce_global_fcn	(	const RAJA_CUDA_GRID_CONSTANT BODY	body_in,
		ReduceParams	reduce_params
	)

__launch_bounds__() [1/2]

template<typename BODY , int num_threads, size_t BLOCKS_PER_SM, typename ReduceParams >

RAJA::__launch_bounds__	(	num_threads	,
		BLOCKS_PER_SM
	)		const

launch_new_reduce_global_fcn() [2/2]

template<typename BODY , typename ReduceParams >

__global__ void RAJA::launch_new_reduce_global_fcn	(	const BODY	body_in,
		ReduceParams	reduce_params
	)

__launch_bounds__() [2/2]

template<typename BODY , int num_threads, typename ReduceParams >

RAJA::__launch_bounds__	(	num_threads	,
		1
	)		const

make_multi_policy() [1/2]

template<typename... Policies, typename Selector >

auto RAJA::make_multi_policy

(

Selector

s

)

-> MultiPolicy<Selector, Policies...>

make_multi_policy - Construct a MultiPolicy from the given selector and Policies

Template Parameters

Policies	list of policies, 0 to N-1
Selector	type of s, should almost always be inferred

Parameters

s	functor called with the segment object passed to forall, must return an int in the set 0 to N-1 selecting the policy to use

Returns

A MultiPolicy containing the given selector s

make_multi_policy() [2/2]

template<typename... Policies, typename Selector >

auto RAJA::make_multi_policy	(	std::tuple< Policies... >	policies,
		Selector	s
	)		-> MultiPolicy<Selector, Policies...>

make_multi_policy - Construct a MultiPolicy from the given selector and Policies

Template Parameters

Policies	list of policies, inferred from policies
Selector	type of s, should almost always be inferred

Parameters

policies	tuple of policies, allows value-carrying policies
s	functor called with the segment object passed to forall, must return an int in the set 0 to N-1 selecting the policy to use

Returns

A MultiPolicy containing the given selector s

atomicLoad() [4/4]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicLoad	(	seq_atomic	,
		T *	acc
	)

atomicStore() [4/4]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE void RAJA::atomicStore	(	seq_atomic	,
		T *	acc,
		T	value
	)

atomicAdd() [4/4]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicAdd	(	seq_atomic	,
		T *	acc,
		T	value
	)

atomicSub() [4/4]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicSub	(	seq_atomic	,
		T *	acc,
		T	value
	)

atomicMin() [4/4]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicMin	(	seq_atomic	,
		T *	acc,
		T	value
	)

atomicMax() [4/4]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicMax	(	seq_atomic	,
		T *	acc,
		T	value
	)

atomicInc() [7/8]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicInc	(	seq_atomic	,
		T *	acc
	)

atomicInc() [8/8]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicInc	(	seq_atomic	,
		T *	acc,
		T	val
	)

atomicDec() [7/8]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicDec	(	seq_atomic	,
		T *	acc
	)

atomicDec() [8/8]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicDec	(	seq_atomic	,
		T *	acc,
		T	val
	)

atomicAnd() [4/4]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicAnd	(	seq_atomic	,
		T *	acc,
		T	value
	)

atomicOr() [4/4]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicOr	(	seq_atomic	,
		T *	acc,
		T	value
	)

atomicXor() [4/4]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicXor	(	seq_atomic	,
		T *	acc,
		T	value
	)

atomicExchange() [4/4]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicExchange	(	seq_atomic	,
		T *	acc,
		T	value
	)

atomicCAS() [4/4]

template<typename T >

RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE T RAJA::atomicCAS	(	seq_atomic	,
		T *	acc,
		T	compare,
		T	value
	)

get_max_threads() [2/3]

template<>

RAJA_HOST_DEVICE RAJA_INLINE int RAJA::get_max_threads

(

seq_thread

)

get_thread_num() [2/3]

template<>

RAJA_HOST_DEVICE RAJA_INLINE int RAJA::get_thread_num

(

seq_thread

)

get_max_threads() [3/3]

template<typename AtomicPolicy >

RAJA_HOST_DEVICE RAJA_INLINE int RAJA::get_max_threads

(

AtomicPolicy

)

get_thread_num() [3/3]

template<typename AtomicPolicy >

RAJA_HOST_DEVICE RAJA_INLINE int RAJA::get_thread_num

(

AtomicPolicy

)

align()

RAJA_INLINE void* RAJA::align	(	size_t	alignment,
		size_t	size,
		void *&	ptr,
		size_t &	space
	)

make_CombiningAdapter_from_layout()

template<typename Lambda , typename Layout >

RAJA_HOST_DEVICE RAJA_INLINE auto RAJA::make_CombiningAdapter_from_layout	(	Lambda &&	lambda,
		Layout &&	layout
	)

Creates a CombiningAdapter class from a lambda and segments.

Parameters

lambda	functional object
segs	range segments defining the multi-dimensional index space

Returns

Returns a CombiningAdapter for the given lambda and segments

Creates a CombiningAdapter object given a lambda and range segments.

NOTE: the stride 1 index is the right-most index

For example:

// lambda to be used in 2D loop
auto lambda = [](int i, int j) {...};

// example lambda usage
for (int i = ibegin; i < iend; ++i) {
  for (int j = jbegin; j < jend; ++j) {
    lambda(i, j);
  }
}

// ranges for 2D loop bounds
RAJA::TypedRangeSegment<int> irange(ibegin, iend);
RAJA::TypedRangeSegment<int> jrange(jbegin, jend);

// adapter class
auto adapter = RAJA::make_CombiningAdapter(lambda, irange, jrange);

// Use with RAJA forall
RAJA::forall<policy>(adapter.getRange(), adapter);

// Use with c++-style loop
auto range = adapter.getRange();
for (auto it = begin(range); it < end(range); ++it) {
  adapter(*it)
}

make_CombiningAdapter()

template<typename Lambda , typename... IdxTs>

RAJA_SUPPRESS_HD_WARN RAJA_INLINE auto RAJA::make_CombiningAdapter	(	Lambda &&	lambda,
		::RAJA::TypedRangeSegment< IdxTs > const &...	segs
	)

make_PermutedCombiningAdapter()

template<typename Perm , typename Lambda , typename... IdxTs>

RAJA_SUPPRESS_HD_WARN RAJA_INLINE auto RAJA::make_PermutedCombiningAdapter	(	Lambda &&	lambda,
		::RAJA::TypedRangeSegment< IdxTs > const &...	segs
	)

for_each()

template<typename Container , typename UnaryFunc >

constexpr RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE concepts::enable_if_t<UnaryFunc, type_traits::is_range<Container> > RAJA::for_each ( Container &&  c, UnaryFunc  func  )

constexpr

Apply func to all the elements in the given range in order using a sequential for loop in O(N) operations and O(1) extra memory see https://en.cppreference.com/w/cpp/algorithm/for_each.

for_each_type()

template<typename UnaryFunc , typename... Ts>

constexpr RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE UnaryFunc RAJA::for_each_type ( camp::list< Ts... > const &  c, UnaryFunc  func  )

constexpr

Apply func to each type in the given list in order using a compile-time expansion in O(N) operations and O(1) extra memory.

for_each_tuple()

template<typename Tuple , typename UnaryFunc >

constexpr RAJA_SUPPRESS_HD_WARN RAJA_HOST_DEVICE RAJA_INLINE UnaryFunc RAJA::for_each_tuple ( Tuple &&  t, UnaryFunc  func  )

constexpr

Apply func to each object in the given tuple or tuple like type in order using a compile-time expansion in O(N) operations and O(1) extra memory.

make_index_tuple()

template<typename... IndexTypes>

RAJA_INLINE RAJA_HOST_DEVICE auto RAJA::make_index_tuple

(

IndexTypes...

it

)

-> camp::tuple<IndexTypes...>

creates of a camp::tuple of index types (such as DirectIndex, IndexList, or ConditionalIndexList)

make_index_layout()

template<typename IdxLin = Index_type, typename... Types, typename... IndexTypes>

RAJA_INLINE RAJA_HOST_DEVICE auto RAJA::make_index_layout	(	camp::tuple< IndexTypes... >	index_tuple_in,
		Types...	ns
	)		-> IndexLayout<sizeof...(Types), IdxLin, IndexTypes...>

creates an index layout based on the input camp::tuple of index types

make_stride_one() [1/2]

template<ptrdiff_t s1_dim, size_t n_dims, typename IdxLin >

RAJA_INLINE constexpr RAJA_HOST_DEVICE Layout<n_dims, IdxLin, s1_dim> RAJA::make_stride_one ( Layout< n_dims, IdxLin > const &  l )

constexpr

Convert a non-stride-one Layout to a stride-1 Layout

make_stride_one() [2/2]

template<ptrdiff_t s1_dim, typename IdxLin , typename IdxTuple >

RAJA_INLINE constexpr RAJA_HOST_DEVICE TypedLayout<IdxLin, IdxTuple, s1_dim> RAJA::make_stride_one ( TypedLayout< IdxLin, IdxTuple > const &  l )

constexpr

Convert a non-stride-one TypedLayout to a stride-1 TypedLayout

log2()

template<typename T , std::enable_if_t< std::is_integral< T >::value > * = nullptr>

RAJA_HOST_DEVICE constexpr RAJA_INLINE T RAJA::log2 ( T  n )

constexprnoexcept

evaluate log base 2 of n

For positive n calculate log base 2 of n, and round the result down to the nearest integer. For zero or negative n return 0

next_pow2()

template<typename T , std::enable_if_t< std::is_integral< T >::value > * = nullptr>

RAJA_HOST_DEVICE constexpr RAJA_INLINE T RAJA::next_pow2 ( T  n )

constexprnoexcept

"round up" to the next greatest power of 2

For a integer n, if n is non-negative, if n is a power of 2, return n if n is not a power of 2, return the next greater power of 2 if n is negative, return 0

prev_pow2()

template<typename T , std::enable_if_t< std::is_integral< T >::value > * = nullptr>

RAJA_HOST_DEVICE constexpr RAJA_INLINE T RAJA::prev_pow2 ( T  n )

constexprnoexcept

"round down" to the largest power of 2 that is less than or equal to n

For an integer n, if n is negative, return 0 else if n is a power of 2, return n else return the largest power of 2 that is less than n

power_of_2_mod()

template<typename L , typename R , std::enable_if_t< std::is_integral< L >::value &&std::is_integral< R >::value > * = nullptr>

RAJA_HOST_DEVICE constexpr RAJA_INLINE auto RAJA::power_of_2_mod ( L  lhs, R  rhs  )

constexprnoexcept

compute lhs mod rhs where lhs is non-negative and rhs is a power of 2

make_offset_layout()

template<size_t n_dims, typename IdxLin = Index_type>

RAJA_INLINE constexpr RAJA_HOST_DEVICE auto RAJA::make_offset_layout ( const std::array< IdxLin, n_dims > &  begin, const std::array< IdxLin, n_dims > &  end  ) -> OffsetLayout<n_dims, IdxLin>

constexpr

make_permuted_offset_layout()

template<size_t Rank, typename IdxLin = Index_type>

RAJA_INLINE constexpr RAJA_HOST_DEVICE auto RAJA::make_permuted_offset_layout ( const std::array< IdxLin, Rank > &  begin, const std::array< IdxLin, Rank > &  end, const std::array< IdxLin, Rank > &  permutation  ) -> decltype(make_offset_layout<Rank, IdxLin>(begin, end))

constexpr

make_permuted_layout()

template<size_t Rank, typename IdxLin = Index_type>

constexpr RAJA_INLINE RAJA_HOST_DEVICE auto RAJA::make_permuted_layout ( std::array< IdxLin, Rank >  sizes, std::array< camp::idx_t, Rank >  permutation  ) -> Layout<Rank, IdxLin>

constexpr

Creates a permuted Layout object.

Allows control over the striding order when creating a Layout.

For example:

// Create a layout object with the default striding order
// The indices, left to right, have longest stride to stride-1
Layout<3> layout(5,7,11);

// The above is equivalent to:
Layout<3> default_layout = make_permuted_layout({5,7,11},

PERM_IJK::value);

// Create a layout object with permuted order
// In this case, J is stride-1, and K has the longest stride
Layout<3> perm_layout = make_permuted_layout({5,7,11}, PERM_KIJ::value);

Permutation of up to rank 5 are provided with PERM_I ... PERM_IJKLM aliases in RAJA/util/Permutations.hpp as a convenience.

Since permutations are represented using std::array<size_t, Rank> object, arbitrary rank permutations can be used.

left_fold_reduce()

template<typename Container , typename T = detail::ContainerVal<Container>, typename BinaryOp = operators::plus<T>>

RAJA_HOST_DEVICE constexpr RAJA_INLINE concepts:: enable_if_t<T, type_traits::is_range<Container> > RAJA::left_fold_reduce ( Container &&  c, T  init = BinaryOp::identity(), BinaryOp  op = BinaryOp {}  )

constexpr

Accumulate given range to a single value using a left fold algorithm in O(N) operations and O(1) extra memory see https://en.cppreference.com/w/cpp/algorithm/accumulate.

binary_tree_reduce()

template<typename Container , typename T = detail::ContainerVal<Container>, typename BinaryOp = operators::plus<T>>

RAJA_HOST_DEVICE constexpr RAJA_INLINE concepts:: enable_if_t<T, type_traits::is_range<Container> > RAJA::binary_tree_reduce ( Container &&  c, T  init = BinaryOp::identity(), BinaryOp  op = BinaryOp {}  )

constexpr

Reduce given range to a single value using a binary tree algorithm in O(N) operations and O(lg(N)) extra memory see https://en.cppreference.com/w/cpp/algorithm/reduce.

kahan_sum()

template<typename Container , typename T = detail::ContainerVal<Container>>

RAJA_HOST_DEVICE constexpr RAJA_INLINE concepts:: enable_if_t<T, type_traits::is_range<Container>, std::is_floating_point<T> > RAJA::kahan_sum ( Container &&  c, T  init = T()  )

constexpr

Accumulate given range to a single value using a kahan summation algorithm in O(N) operations and O(1) extra memory see https://en.cppreference.com/w/cpp/algorithm/accumulate.

kahan_sum_volatile()

template<typename Container , typename T = detail::ContainerVal<Container>>

RAJA_HOST_DEVICE constexpr RAJA_INLINE concepts:: enable_if_t<T, type_traits::is_range<Container>, std::is_floating_point<T> > RAJA::kahan_sum_volatile ( Container &&  c, T  init = T()  )

constexpr

Accumulate given range to a single value using a kahan summation algorithm in O(N) operations and O(1) extra memory see https://en.cppreference.com/w/cpp/algorithm/accumulate.

Note

Uses volatile on intermediate products to keep compiler from optimizing out the compensated summation with fast-math.

high_accuracy_reduce()

template<typename Container , typename T = detail::ContainerVal<Container>, typename BinaryOp = operators::plus<T>>

RAJA_HOST_DEVICE constexpr RAJA_INLINE concepts:: enable_if_t<T, type_traits::is_range<Container> > RAJA::high_accuracy_reduce ( Container &&  c, T  init = BinaryOp::identity(), BinaryOp  op = BinaryOp {}  )

constexpr

Reduce given range to a single value using an algorithm with high accuracy when floating point round off is a concern see https://en.cppreference.com/w/cpp/algorithm/reduce.

accumulate()

template<typename Container , typename T = detail::ContainerVal<Container>, typename BinaryOp = operators::plus<T>>

RAJA_HOST_DEVICE constexpr RAJA_INLINE concepts:: enable_if_t<T, type_traits::is_range<Container> > RAJA::accumulate ( Container &&  c, T  init = BinaryOp::identity(), BinaryOp  op = BinaryOp {}  )

constexpr

Accumulate given range to a single value using a left fold algorithm in O(N) operations and O(1) extra memory see https://en.cppreference.com/w/cpp/algorithm/accumulate.

insertion_sort()

template<typename Container , typename Compare = operators::less<detail::ContainerVal<Container>>>

RAJA_HOST_DEVICE RAJA_INLINE concepts::enable_if<type_traits::is_range<Container> > RAJA::insertion_sort	(	Container &&	c,
		Compare	comp = Compare {}
	)

stable insertion sort given range inplace using comparison function and using O(N^2) comparisons and O(1) memory

shell_sort()

template<typename Container , typename Compare = operators::less<detail::ContainerVal<Container>>>

RAJA_HOST_DEVICE RAJA_INLINE concepts::enable_if<type_traits::is_range<Container> > RAJA::shell_sort	(	Container &&	c,
		Compare	comp = Compare {}
	)

unstable shell sort given range inplace using comparison function and using O(N^?) comparisons and O(1) memory

heap_sort()

template<typename Container , typename Compare = operators::less<detail::ContainerVal<Container>>>

RAJA_HOST_DEVICE RAJA_INLINE concepts::enable_if<type_traits::is_range<Container> > RAJA::heap_sort	(	Container &&	c,
		Compare	comp = Compare {}
	)

unstable heap sort given range inplace using comparison function and using O(N*lg(N)) comparisons and O(1) memory

intro_sort()

template<typename Container , typename Compare = operators::less<detail::ContainerVal<Container>>>

RAJA_HOST_DEVICE RAJA_INLINE concepts::enable_if<type_traits::is_range<Container> > RAJA::intro_sort	(	Container &&	c,
		Compare	comp = Compare {}
	)

unstable intro sort given range inplace using comparison function and using O(N*lg(N)) comparisons and O(lg(N)) memory

merge_sort()

template<typename Container , typename Compare = operators::less<detail::ContainerVal<Container>>>

RAJA_INLINE concepts::enable_if<type_traits::is_range<Container> > RAJA::merge_sort	(	Container &&	c,
		Compare	comp = Compare {}
	)

stable merge sort given range inplace using comparison function and using O(N*lg(N)) comparisons and O(N) memory

make_span() [1/2]

template<typename IterType , typename IndexType >

constexpr RAJA_HOST_DEVICE RAJA_INLINE Span<IterType, IndexType> RAJA::make_span ( IterType  begin, IndexType  size  )

constexpr

Creates a span from a random access iterator and length.

Parameters

begin	beginning of the sequence being spanned
size	length of the sequence being spanned

Returns

Returns a Span representing the given sequence

Creates a span object given a random access iterator and length.

For example:

// the span type will have IndexType size_t
size_t len = ...;

// Create a span object
auto my_span = make_span(begin, len);

// Use with RAJA scan
RAJA::inclusive_scan_inplace<policy>(my_span);

make_span() [2/2]

template<typename Iter >

constexpr RAJA_HOST_DEVICE RAJA_INLINE auto RAJA::make_span ( Iter &  iterable )

constexpr

make_view()

template<typename IndexType , typename ValueType >

RAJA_HOST_DEVICE constexpr RAJA_INLINE View<ValueType, Layout<1, IndexType, 0> > RAJA::make_view ( ValueType *  ptr )

constexpr

make_index_view()

template<size_t n_dims, typename IndexType , typename ValueType , typename... IndexTypes>

RAJA_HOST_DEVICE constexpr RAJA_INLINE View< ValueType, IndexLayout<n_dims, IndexType, IndexTypes...> > RAJA::make_index_view ( ValueType *  ptr, IndexLayout< n_dims, IndexType, IndexTypes... >  index_layout  )

constexpr

selecttuple()

template<typename Lay , typename Tup , camp::idx_t... Idxs>

RAJA_HOST_DEVICE constexpr RAJA_INLINE auto RAJA::selecttuple ( Lay  lyout, Tup &&  tup, camp::idx_seq< Idxs... >    ) -> decltype(lyout(camp::get<Idxs>(std::forward<Tup>(tup))...))

constexpr

removenth()

template<typename Lay , RAJA::Index_type Nth = 0, typename Tup >

RAJA_HOST_DEVICE constexpr RAJA_INLINE auto RAJA::removenth ( Lay  lyout, Tup &&  tup  ) -> decltype(selecttuple<Lay>( lyout, std::forward<Tup>(tup), cat_seq_t< camp::make_idx_seq_t<Nth>, offset_seq_t<Nth + 1, camp::make_idx_seq_t<camp::tuple_size<Tup>::value - Nth - 1>> > {}))

constexpr

make_atomic_view()

template<typename AtomicPolicy , typename ViewType >

RAJA_HOST_DEVICE constexpr RAJA_INLINE AtomicViewWrapper<ViewType, AtomicPolicy> RAJA::make_atomic_view ( ViewType const &  view )

constexpr

make_permuted_view()

template<typename meta_layout , typename IndexType = RAJA::Index_type, typename T , typename... Extents>

RAJA_HOST_DEVICE constexpr RAJA_INLINE auto RAJA::make_permuted_view ( T *  ptr, Extents &&...  extents  )

constexpr

zip()

template<typename... Args>

RAJA_HOST_DEVICE constexpr RAJA_INLINE auto RAJA::zip ( Args &&...  args ) -> ZipIterator<camp::decay<Args>...>

constexpr

Zip multiple iterators together to iterate them simultaneously with a single ZipIterator object.

zip_span()

template<typename... Args>

RAJA_HOST_DEVICE constexpr RAJA_INLINE auto RAJA::zip_span ( Args &&...  args ) -> Span<ZipIterator<detail::ContainerIter<camp::decay<Args>>...>, typename ZipIterator< detail::ContainerIter<camp::decay<Args>>...>::difference_type>

constexpr

Zip multiple containers together to iterate them simultaneously with ZipIterator objects.

compare_first()

template<typename T , typename Compare >

RAJA_HOST_DEVICE constexpr RAJA_INLINE auto RAJA::compare_first ( Compare  comp ) -> CompareFirst<T, Compare>

constexpr

Make a comparator to compare first member of tuple like objects of type T.

get() [1/4]

template<camp::idx_t I, bool is_val, typename... Ts>

RAJA_HOST_DEVICE constexpr RAJA_INLINE RAJA:: zip_tuple_element_t<I, zip_tuple<is_val, Ts...> >& RAJA::get ( zip_tuple< is_val, Ts... > &  z )

constexprnoexcept

get() [2/4]

template<camp::idx_t I, bool is_val, typename... Ts>

RAJA_HOST_DEVICE constexpr RAJA_INLINE RAJA:: zip_tuple_element_t<I, zip_tuple<is_val, Ts...> > const& RAJA::get ( zip_tuple< is_val, Ts... > const &  z )

constexprnoexcept

get() [3/4]

template<camp::idx_t I, bool is_val, typename... Ts>

RAJA_HOST_DEVICE constexpr RAJA_INLINE std::remove_reference_t< RAJA::zip_tuple_element_t<I, zip_tuple<is_val, Ts...> > >&& RAJA::get ( zip_tuple< is_val, Ts... > &&  z )

constexprnoexcept

get() [4/4]

template<camp::idx_t I, bool is_val, typename... Ts>

RAJA_HOST_DEVICE constexpr RAJA_INLINE std::remove_reference_t< RAJA::zip_tuple_element_t<I, zip_tuple<is_val, Ts...> > > const&& RAJA::get ( zip_tuple< is_val, Ts... > const &&  z )

constexprnoexcept

Variable Documentation

reduce_params

ReduceParams RAJA::reduce_params

Initial value:

{
 
  using RAJA::internal::thread_privatize

privatizer

auto RAJA::privatizer = thread_privatize(body_in)

body

auto & RAJA::body = privatizer.get_priv()

raja_shmem_ptr

__shared__ char RAJA::raja_shmem_ptr

extern

ctx

LaunchContextType RAJA::ctx

shared_mem_ptr

ctx RAJA::shared_mem_ptr = raja_shmem_ptr

UndefinedValue

const int RAJA::UndefinedValue = -9999999

Integer value for undefined indices and other integer values. Although this is a magic value, it avoids sprinkling them throughout code.