dash Namespace Reference

This class is a simple memory pool which holds allocates elements of size ValueType. More...

Namespaces
	atomic
	Routines to perform atomic operations on atomics residing in the global address space.
	io
	Specification of the DASH Container IO interfaces.

Classes
struct	allocation_dynamic
struct	allocation_static
	Allocation Policy. More...
struct	allocator_traits
class	Array
	A distributed array. More...
class	ArrayRef
	Proxy type representing an access modifier on elements in a dash::Array. More...
class	ArrayRefView
	Proxy type representing a view specifier on elements in a dash::Array. More...
class	Atomic
	Type wrapper to mark any trivial type atomic. More...
struct	bit_and
	Reduce operands with binary AND. More...
struct	bit_or
	Reduce operands with binary OR. More...
struct	bit_xor
	Reduce operands with binary XOR. More...
class	BlockPattern
	Defines how a list of global indices is mapped to single units within a Team. More...
class	BlockPattern< 1, Arrangement, IndexType >
	Defines how a list of global indices is mapped to single units within a Team. More...
class	BytesPerCycleMeasure
class	CartesianIndexSpace
	Defines a cartesian, totally-ordered index space by mapping linear indices to cartesian coordinates depending on memory order. More...
class	CartesianSpace
	Cartesian space defined by extents in n dimensions. More...
struct	CartView
	Cartesian view class. More...
class	CartViewBase
	Base class for a cartesian view, i.e. More...
class	Coarray
	A fortran style coarray. More...
class	Coevent
	A fortran style coevent. More...
class	CompositeView
class	Comutex
	A fortran style comutex. More...
struct	conjunction
struct	conjunction< Cond0 >
struct	conjunction< Cond0, CondN... >
class	CSRPattern< 1, Arrangement, IndexType >
	Irregular Pattern for Compressed Sparse Row Storage. More...
struct	dart_datatype
	Type trait for mapping to DART data types. More...
struct	dart_operation
	Query the underlying dart_operation_t for arbitrary binary operations. More...
struct	dart_punned_datatype
	Type trait for mapping to punned DART data type for reduce operations. More...
struct	dart_storage
	Convencience wrapper to determine the DART type and number of elements required for the given template parameter type T and the desired number of values nvalues. More...
class	DefaultDeleter
class	Deferred
class	Dimensional
	Base class for dimensional attributes, stores an n-dimensional value with identical type all dimensions. More...
class	Distribution
	Specifies how a Pattern distributes elements to units in a specific dimension. More...
class	DistributionSpec
	DistributionSpec describes distribution patterns of all dimensions,. More...
class	Domain
class	DynamicPattern< 1, Arrangement, IndexType >
	Irregular dynamic pattern. More...
class	EpochSynchronizedAllocator
	Encapsulates a memory allocation and deallocation strategy of global memory regions distributed across local memory of units in a specified team. More...
struct	Extent
struct	first
	Returns second operand. More...
class	Future
	Implementation of a future used to wait for an operation to complete and access the value returned by that operation. More...
class	Future< void >
	Overload of dash::Future for operations returning void. More...
class	GlobalAllocator
class	GlobalMemorySpaceBase
class	GlobAsyncIter
class	GlobAsyncRef
	Global value reference for asynchronous / non-blocking operations. More...
class	GlobAsyncRef< dash::Atomic< T > >
	Specialization for atomic values. More...
class	GlobHeapLocalPtr
	Iterator on local buckets. More...
class	GlobHeapMem
	Global memory region with dynamic size. More...
class	GlobHeapPtr
	Iterator on global buckets. More...
class	GlobIter
	Iterator on Partitioned Global Address Space. More...
class	GlobListIter
	Bi-directional global iterator on elements of a dash::List instance. More...
class	GlobLocalMemoryPool
class	GlobPtr
	Pointer in global memory space with random access arithmetics. More...
class	GlobRef
class	GlobRef< dash::Atomic< T > >
	Specialization for atomic values. More...
class	GlobSharedRef
class	GlobStaticMem
	Global memory with address space of static size. More...
class	GlobViewIter
	Global iterator on an index set specified by a view modifier. More...
struct	has_operator_equal
struct	has_operator_equal_impl
	Type trait indicating whether a type has a comparision operator== defined. More...
class	HashLocal
class	HBWSpace
class	HIter
class	HostSpace
class	HView
class	HView< ContainerType, -1 >
class	IndexRange
class	IndexRange< 1, IndexType >
struct	is_arithmetic
	Type trait indicating whether a type can be used for arithmetic operations in global memory space. More...
struct	is_atomic
	type traits for dash::Atomic More...
struct	is_atomic< dash::Atomic< T > >
struct	is_atomic_compatible
	Type trait indicating whether a type can be used for global atomic operations. More...
struct	is_container_compatible
	Type trait indicating whether the specified type is eligible for elements of DASH containers. More...
struct	is_range
	Definition of type trait dash::is_range<T> with static member value indicating whether type T is a model of the Range concept. More...
struct	iterator_traits
class	IteratorRange
	Adapter template for range concept, wraps begin and end iterators in range type. More...
class	IteratorRange< LocalIterator *, LocalSentinel * >
	Specialization of adapter template for range concept, wraps begin and end pointers in range type. More...
class	IteratorViewOrigin
class	List
	Usage examples: More...
class	ListRef
	Proxy type referencing a dash::List. More...
class	LoadBalancePattern
	Irregular dynamic pattern. More...
class	LoadBalancePattern< 1, CompBasedMeasure, MemBasedMeasure, Arrangement, IndexType >
	Irregular dynamic pattern. More...
class	LocalArrayRef
	Proxy type representing local access to elements in a dash::Array. More...
struct	LocalIndexRange
class	LocalListRef
	Proxy type representing a local view on a referenced dash::List. More...
class	LocalMatrixRef
	Forward-declaration. More...
class	LocalMemoryLayout
	Specifies how local element indices are arranged in a specific number of dimensions. More...
class	LocalMemorySpaceBase
struct	LocalRange
class	Matrix
	Forward-declaration. More...
class	MatrixRef
	Forward-declaration. More...
class	MatrixRefView
	Stores information needed by subscripting and subdim selection. More...
struct	max
	Reduce operands to their maximum value. More...
struct	memory_domain_global
	The MemorySpace concept follows the STL std::pmr::memory_resource. More...
struct	memory_domain_local
struct	memory_space_contiguous
struct	memory_space_cuda_tag
struct	memory_space_hbw_tag
struct	memory_space_host_tag
struct	memory_space_noncontiguous
struct	memory_space_pmem_tag
struct	memory_space_traits
class	MemorySpace
class	MemorySpace< memory_domain_global, Args... >
class	MemorySpace< memory_domain_local, Args... >
struct	multiply
	Reduce operands to their product. More...
class	MultiView
	Multidimensional view. More...
class	Mutex
	Behaves similar to std::mutex and is used to ensure mutual exclusion within a dash team. More...
struct	Pair
	A trivially-copyable implementation of std::pair to be used as element type of DASH containers. More...
struct	pattern_constraints
	Traits for compile-time pattern constraints checking, suitable as a helper for template definitions employing SFINAE where no verbose error reporting is required. More...
struct	pattern_layout_properties
	{} More...
struct	pattern_layout_tag
	{} More...
struct	pattern_layout_traits
struct	pattern_mapping_properties
	Generic type of mapping properties of a model satisfying the Pattern concept. More...
struct	pattern_mapping_tag
	Container type for mapping properties of models satisfying the Pattern concept. More...
struct	pattern_mapping_traits
struct	pattern_partitioning_properties
	{} More...
struct	pattern_partitioning_tag
	{} More...
struct	pattern_partitioning_traits
struct	pattern_traits
class	PatternConcept
	Defines how a list of global indices is mapped to single units within a Team. More...
class	PatternIterator
	{}Usage: More...
struct	plus
	Reduce operands to their sum. More...
struct	Point
class	RangeBase
struct	remove_atomic
	type traits for dash::Atomic More...
struct	remove_atomic< dash::Atomic< T > >
struct	second
	Returns second operand. More...
class	SeqTilePattern
	Defines how a list of global indices is mapped to single units within a Team. More...
class	Shared
	Shared access to a value in global memory across a team. More...
class	SharedCounter
	A simple shared counter that allows atomic increment- and decrement operations. More...
class	ShiftTilePattern
	Defines how a list of global indices is mapped to single units within a Team. More...
class	SimpleMemoryPoolResource
class	SizeSpec
	Specifies cartesian extents in a specific number of dimensions. More...
class	StridedView
struct	synchronization_collective
	Synchronization Policy. More...
struct	synchronization_independent
struct	synchronization_single
class	Team
	A Team instance specifies a subset of all available units. More...
class	TeamPtr
class	TeamSpec
	Specifies the arrangement of team units in a specified number of dimensions. More...
class	TilePattern
	Defines how a list of global indices is mapped to single units within a Team. More...
class	UnitClockFreqMeasure
class	UniversalMember
	Utility class template to capture values from both moved temporaries (rvalues) and named references to avoid temporary copies. More...
class	UnorderedMap
	Usage examples: More...
class	UnorderedMapGlobIter
class	UnorderedMapLocalIter
class	UnorderedMapLocalRef
	Local view specifier of a dynamic map container with support for workload balancing. More...
struct	view_traits
	View type traits. More...
struct	view_traits< dash::IteratorRange< IteratorT, SentinelT > >
	Specialization of dash::view_traits for IteratorRange. More...
struct	view_traits< IteratorViewOrigin< Iterator, Sentinel > >
struct	view_traits< ViewLocalMod< DomainType, NDim > >
struct	view_traits< ViewOrigin< NDim > >
struct	view_traits< ViewSubMod< DomainType, SubDim, NDim > >
class	ViewBlockMod
class	ViewIterator
class	ViewIterator< DomainIterator *, IndexSetType >
class	ViewLocalMod
class	ViewModBase
class	ViewOrigin
	Monotype for the logical symbol that represents a view origin. More...
struct	ViewPair
	Offset and extent in a single dimension. More...
struct	ViewRange
struct	ViewRegion
	Representation of a ViewPair as region specified by origin and end coordinates. More...
class	ViewSpec
	Specifies view parameters for implementing submat, rows and cols. More...
class	ViewSubMod

Typedefs
typedef dash::pattern_partitioning_properties< dash::pattern_partitioning_tag::rectangular, dash::pattern_partitioning_tag::balanced, dash::pattern_partitioning_tag::ndimensional >	summa_pattern_partitioning_constraints
	Constraints on pattern partitioning properties of matrix operands passed to dash::summa. More...
typedef dash::pattern_mapping_properties< dash::pattern_mapping_tag::multiple, dash::pattern_mapping_tag::unbalanced >	summa_pattern_mapping_constraints
	Constraints on pattern mapping properties of matrix operands passed to dash::summa. More...
typedef dash::pattern_layout_properties< dash::pattern_layout_tag::blocked, dash::pattern_layout_tag::linear >	summa_pattern_layout_constraints
	Constraints on pattern layout properties of matrix operands passed to dash::summa. More...
template<typename MatrixType >
using	summa_pattern_constraints = typename dash::pattern_constraints< dash::summa_pattern_partitioning_constraints, dash::summa_pattern_mapping_constraints, dash::summa_pattern_layout_constraints, typename MatrixType::pattern_type >
template<typename T , dim_t NumDimensions, typename IndexT = dash::default_index_t, class PatternT = Pattern<NumDimensions, ROW_MAJOR, IndexT>, typename LocalMemSpaceT = HostSpace>
using	NArray = dash::Matrix< T, NumDimensions, IndexT, PatternT, LocalMemSpaceT >
	Template alias for dash::Matrix with the same default template arguments. More...
template<class T >
using	GlobMemAllocPtr = decltype(dash::memalloc< T >(size_t{}))
	Convenience Wrapper to retrieve easily the type allocated by dash::memalloc<T> More...
typedef dash::pattern_partitioning_properties< pattern_partitioning_tag::rectangular, pattern_partitioning_tag::unbalanced >	pattern_partitioning_default_properties
typedef dash::pattern_mapping_properties< pattern_mapping_tag::unbalanced >	pattern_mapping_default_properties
typedef dash::pattern_layout_properties< pattern_layout_tag::row_major, pattern_layout_tag::canonical, pattern_layout_tag::linear >	pattern_layout_default_properties
template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>
using	Pattern = dash::BlockPattern< NumDimensions, Arrangement, IndexType >
	Template alias for dash::Pattern with the same default template arguments. More...
typedef enum dash::MemArrange	MemArrange
typedef int	dim_t
	Scalar type for a dimension value, with 0 indicating the first dimension. More...
typedef internal::default_signed_index	default_index_t
	Signed integer type used as default for index values. More...
typedef internal::default_unsigned_index	default_extent_t
	Unsigned integer type used as default for extent values. More...
typedef internal::default_unsigned_index	default_size_t
	Unsigned integer type used as default for size values. More...
typedef internal::default_signed_index	gptrdiff_t
	Difference type for global pointers. More...
typedef struct dash::unit_id< dash::local_unit, dart_team_unit_t >	team_unit_t
	Unit ID to use for team-local IDs. More...
typedef struct dash::unit_id< dash::global_unit, dart_global_unit_t >	global_unit_t
	Unit ID to use for global IDs. More...
typedef std::max_align_t	max_align_t

Enumerations
enum	global_allocation_policy : uint8_t { global_allocation_policy::collective, global_allocation_policy::non_collective, global_allocation_policy::epoch_synchronized }
enum	launch : uint16_t { launch::sync = 0x1, launch::async = 0x2 }
enum	MemArrange { MEM_ARRANGE_UNDEFINED = 0, ROW_MAJOR, COL_MAJOR }

Functions
template<typename GlobIter , typename UnaryPredicate >
bool	all_of (GlobIter first, GlobIter last, UnaryPredicate p)
	Check whether all element in the range satisfy predicate p. More...
template<typename GlobIter , typename UnaryPredicate >
bool	any_of (GlobIter first, GlobIter last, UnaryPredicate p)
	Check whether any element in the range satisfies predicate p. More...
template<class LocalInputIter , typename = typename std::enable_if< !dash::detail::is_global_iterator<LocalInputIter>::value >::type>
void	broadcast (LocalInputIter in_first, LocalInputIter in_last, dash::team_unit_t root, dash::Team &team=dash::Team::All())
	Broadcast the local range of elements [in_first, in_last) from unit root to all other units in team. More...
template<class ValueType >
ValueType	broadcast (dash::Shared< ValueType > &shared)
	Broadcast the value stored in dash::Shared from the unit owning the value to all other units with access to the shared object. More...
template<typename T >
void	broadcast (Coarray< T > &coarr, const team_unit_t &root)
	Broadcasts the value on root to all other members of this co_array. More...
template<typename ValueType , class InputIt , class OutputIt >
OutputIt	copy (InputIt in_first, InputIt in_last, OutputIt out_first)
	Copies the elements in the range, defined by [in_first, in_last), to another range beginning at out_first. More...
template<typename ValueType , class GlobInputIt >
dash::Future< ValueType * >	copy_async (InputIt in_first, InputIt in_last, OutputIt out_first)
	Asynchronous variant of dash::copy. More...
template<typename GlobIter >
bool	equal (GlobIter first_1, GlobIter last_1, GlobIter first_2)
	Returns true if the range [first1, last1) is equal to the range [first2, first2 + (last1 - first1)), and false otherwise. More...
template<typename GlobIter , class BinaryPredicate >
bool	equal (GlobIter first_1, GlobIter last_1, GlobIter first_2, BinaryPredicate)
	Returns true if the range [first1, last1) is equal to the range [first2, first2 + (last1 - first1)) with respect to a specified predicate, and false otherwise. More...
template<typename GlobIterType >
void	fill (GlobIterType first, GlobIterType last, const typename GlobIterType::value_type &value)
	Assigns the given value to the elements in the range [first, last) More...
template<typename GlobIter , typename ElementType >
GlobIter	find (GlobIter first, GlobIter last, const ElementType &value)
	Returns an iterator to the first element in the range [first,last) that compares equal to val. More...
template<typename GlobIter , typename UnaryPredicate >
GlobIter	find_if (GlobIter first, GlobIter last, UnaryPredicate predicate)
	Returns an iterator to the first element in the range [first,last) that satisfies the predicate p. More...
template<typename GlobIter , class UnaryPredicate >
GlobIter	find_if_not (GlobIter first, GlobIter last, UnaryPredicate predicate)
	Returns an iterator to the first element in the range [first,last) that does not satisfy the predicate p. More...
template<typename GlobInputIt , class UnaryFunction >
void	for_each (const GlobInputIt &first, const GlobInputIt &last, UnaryFunction func)
	Invoke a function on every element in a range distributed by a pattern. More...
template<typename GlobInputIt , class UnaryFunctionWithIndex >
void	for_each_with_index (const GlobInputIt &first, const GlobInputIt &last, UnaryFunctionWithIndex func)
	Invoke a function on every element in a range distributed by a pattern. More...
template<typename GlobInputIt , class UnaryFunction >
void	generate (GlobInputIt first, GlobInputIt last, UnaryFunction gen)
	Assigns each element in range [first, last) a value generated by the given function object g. More...
template<typename GlobInputIt , class UnaryFunction >
void	generate_with_index (GlobInputIt first, GlobInputIt last, UnaryFunction gen)
	Assigns each element in range [first, last) a value generated by the given function object g. More...
template<dim_t SubDim, class DomainT , class OffsetT >
constexpr auto	sub (OffsetT begin, OffsetT end, const DomainT &domain) -> typename std::enable_if< dash::view_traits< DomainT >::rank::value==1, ViewSubMod< DomainT, SubDim > >::type
template<class GlobInputIter >
std::enable_if< !GlobInputIter::has_view::value, LocalIndexRange< typename GlobInputIter::pattern_type::index_type >>::type	local_index_range (const GlobInputIter &first, const GlobInputIter &last)
	Resolves the local index range between global iterators. More...
template<class GlobInputIter >
std::enable_if< GlobInputIter::has_view::value, LocalIndexRange< typename GlobInputIter::pattern_type::index_type >>::type	local_index_range (const GlobInputIter &first, const GlobInputIter &last)
	Resolves the local index range between global view iterators. More...
template<class GlobIterType >
LocalRange< const typename GlobIterType::value_type >	local_range (const GlobIterType &first, const GlobIterType &last)
	Resolves the local address range between global iterators. More...
template<class GlobIterType >
LocalRange< typename GlobIterType::value_type >	local_range (GlobIterType &first, GlobIterType &last)
template<class ElementType , class Compare = std::less<const ElementType &>>
const ElementType *	min_element (const ElementType *l_range_begin, const ElementType *l_range_end, Compare compare=std::less< const ElementType &>())
	Finds an iterator pointing to the element with the smallest value in the range [first,last). More...
template<typename GlobInputIt , class Compare = std::less< const typename dash::iterator_traits<GlobInputIt>::value_type &>>
GlobInputIt	min_element (const typename std::enable_if< dash::iterator_traits< GlobInputIt >::is_global_iterator::value, GlobInputIt >::type &first, const GlobInputIt &last, Compare compare=Compare())
	Finds an iterator pointing to the element with the smallest value in the range [first,last). More...
template<class GlobIter , class Compare = std::greater<const typename GlobIter::value_type &>>
GlobIter	max_element (const GlobIter &first, const GlobIter &last, Compare compare=Compare())
	Finds an iterator pointing to the element with the greatest value in the range [first,last). More...
template<class ElementType , class Compare = std::greater<ElementType &>>
const ElementType *	max_element (const ElementType *first, const ElementType *last, Compare compare=Compare())
	Finds an iterator pointing to the element with the greatest value in the range [first,last). More...
template<typename BinaryOperation >
struct dash::dart_operation	operator ()(const ValueType &lhs
template<class LocalInputIter , class InitType , class BinaryOperation = dash::plus<typename std::iterator_traits<LocalInputIter>::value_type>, typename = typename std::enable_if< !dash::detail::is_global_iterator<LocalInputIter>::value >::type>
std::iterator_traits< LocalInputIter >::value_type	reduce (LocalInputIter in_first, LocalInputIter in_last, InitType init, BinaryOperation binary_op=BinaryOperation(), bool non_empty=true, dash::Team &team=dash::Team::All())
	Accumulate values in each process' range [in_first, in_last) using the provided binary reduce function binary_op, which must be commutative and associative. More...
template<class LocalInputIter , class InitType = typename std::iterator_traits<LocalInputIter>::value_type, typename = typename std::enable_if< !dash::detail::is_global_iterator<LocalInputIter>::value >::type>
std::iterator_traits< LocalInputIter >::value_type	reduce (LocalInputIter in_first, LocalInputIter in_last, InitType init, bool non_empty, dash::Team &team=dash::Team::All())
	Accumulate values across the local ranges [in_first,in_last) of each process as the sum of all values in the range. More...
template<class GlobInputIt , class InitType = typename dash::iterator_traits<GlobInputIt>::value_type, class BinaryOperation = dash::plus<typename dash::iterator_traits<GlobInputIt>::value_type>, typename = typename std::enable_if< dash::detail::is_global_iterator<GlobInputIt>::value >::type>
dash::iterator_traits< GlobInputIt >::value_type	reduce (GlobInputIt in_first, GlobInputIt in_last, InitType init, BinaryOperation binary_op=BinaryOperation())
	Accumulate values in the global range [in_first, in_last) using the provided binary reduce function binary_op, which must be commutative and linear. More...
template<class GlobRandomIt >
void	sort (GlobRandomIt begin, GlobRandomIt end)
	Sorts the elements in the range, defined by [begin, end) in ascending order. More...
template<class GlobRandomIt , class SortableHash >
void	sort (GlobRandomIt begin, GlobRandomIt end, SortableHash hash)
	Sorts the elements in the range, defined by [begin, end) in ascending order. More...
template<typename MatrixTypeA , typename MatrixTypeB , typename MatrixTypeC >
void	summa (MatrixTypeA &A, MatrixTypeB &B, MatrixTypeC &C)
	Multiplies two matrices using the SUMMA algorithm. More...
template<typename MatrixTypeA , typename MatrixTypeB , typename MatrixTypeC >
void	mmult (MatrixTypeA &A, MatrixTypeB &B, MatrixTypeC &C)
	Function adapter to an implementation of matrix-matrix multiplication (xDGEMM) depending on the matrix distribution patterns. More...
template<typename ValueType , class InputIt , class OutputIt , class UnaryOperation >
OutputIt	transform (InputIt in_first, InputIt in_last, OutputIt out_first, UnaryOperation unary_op)
	Apply a given function to elements in a range and store the result in another range, beginning at out_first. More...
template<class InputIt1 , class GlobInputIt , class GlobOutputIt , class BinaryOperation >
GlobOutputIt	transform (InputIt1 in_a_first, InputIt1 in_a_last, GlobInputIt in_b_first, GlobOutputIt out_first, BinaryOperation binary_op)
	Apply a given function to pairs of elements from two ranges and store the result in another range, beginning at out_first. More...
template<class T , class U , class LocalMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>
bool	operator== (const EpochSynchronizedAllocator< T, LocalMemSpace, AllocationPolicy, LocalAlloc > &lhs, const EpochSynchronizedAllocator< U, LocalMemSpace, AllocationPolicy, LocalAlloc > &rhs)
template<class T , class U , class LocalMemSpace , global_allocation_policy AllocationPolicy, template< class > class LocalAlloc>
bool	operator!= (const EpochSynchronizedAllocator< T, LocalMemSpace, AllocationPolicy, LocalAlloc > &lhs, const EpochSynchronizedAllocator< U, LocalMemSpace, AllocationPolicy, LocalAlloc > &rhs)
template<class T , class GlobMemType >
constexpr bool	operator== (GlobalAllocator< T, GlobMemType > lhs, GlobalAllocator< T, GlobMemType > rhs) noexcept
void *	align (std::size_t alignment, std::size_t size, void *&ptr, std::size_t &space)
	Replacement for missing std::align in gcc < 5.0. More...
template<typename T >
std::ostream &	operator<< (std::ostream &os, const Atomic< T > &at)
template<dash::dim_t NumDimensions, typename SizeType >
std::ostream &	operator<< (std::ostream &os, const dash::CartesianSpace< NumDimensions, SizeType > &cartesian_space)
template<dash::dim_t NumDimensions>
std::ostream &	operator<< (std::ostream &os, const dash::CartesianIndexSpace< NumDimensions > &cartesian_space)
template<typename DimensionalType >
constexpr dim_t	ndim (const DimensionalType &d)
template<typename DimensionalType >
constexpr dim_t	rank (const DimensionalType &d)
template<dim_t Dim, typename DimensionalType >
constexpr DimensionalType::extent_type	extent (const DimensionalType &d)
template<typename DimensionalType >
constexpr DimensionalType::extent_type	extent (dim_t dim, const DimensionalType &d)
template<dim_t NumDimensions>
std::ostream &	operator<< (std::ostream &os, const DistributionSpec< NumDimensions > &distspec)
template<typename IndexType >
std::ostream &	operator<< (std::ostream &os, const ViewRange< IndexType > &viewrange)
template<typename IndexType >
static bool	operator== (const ViewPair< IndexType > &lhs, const ViewPair< IndexType > &rhs)
	Equality comparison operator for ViewPair. More...
template<typename IndexType >
static bool	operator!= (const ViewPair< IndexType > &lhs, const ViewPair< IndexType > &rhs)
	Inequality comparison operator for ViewPair. More...
template<typename IndexType >
std::ostream &	operator<< (std::ostream &os, const ViewPair< IndexType > &viewpair)
template<typename ElementType , dim_t NumDimensions>
std::ostream &	operator<< (std::ostream &os, const Dimensional< ElementType, NumDimensions > &dimensional)
template<dim_t NumDimensions, typename IndexType >
std::ostream &	operator<< (std::ostream &os, const ViewSpec< NumDimensions, IndexType > &viewspec)
template<dim_t D, typename I >
std::ostream &	operator<< (std::ostream &os, const dash::Domain< D, I > &dom)
template<typename ResultT >
std::ostream &	operator<< (std::ostream &os, const Future< ResultT > &future)
template<typename T >
std::ostream &	operator<< (std::ostream &os, const GlobAsyncRef< T > &gar)
template<class T , class MemSpaceT >
dash::gptrdiff_t	distance ( GlobPtr< T, MemSpaceT > gbegin, GlobPtr< T, MemSpaceT > gend)
	Returns the number of hops from gbegin to gend. More...
template<typename T , class MemSpaceT >
std::ostream &	operator<< (std::ostream &os, const GlobPtr< T, MemSpaceT > &gptr)
template<class T , class MemSpaceT >
DASH_CONSTEXPR std::enable_if< std::is_same< typename dash::memory_space_traits< MemSpaceT >::memory_space_layout_tag, memory_space_contiguous >::value, T >::type *	local_begin (GlobPtr< T, MemSpaceT > global_begin, dash::team_unit_t unit)
	Returns the begin of the local memory portion within a global memory segment. More...
template<typename T >
std::ostream &	operator<< (std::ostream &os, const GlobRef< T > &gref)
template<typename T >
void	swap (dash::GlobRef< T > &&a, dash::GlobRef< T > &&b)
	specialization for unqualified calls to swap More...
template<class MemSpaceT , class T >
auto	addressof (dash::GlobRef< T > const &ref)
	specialization for unqualified calls to swap More...
template<typename T , typename P >
std::ostream &	operator<< (std::ostream &os, const GlobSharedRef< T, P > &gref)
void	init (int *argc, char ***argv)
	Initialize the DASH library and the underlying runtime system. More...
void	finalize ()
	Finalize the DASH library and the underlying runtime system. More...
bool	is_initialized ()
	Check whether DASH has been initialized already. More...
bool	is_multithreaded ()
	Check whether DASH has been initialized with support for multi-threaded access. More...
global_unit_t	myid ()
	Shortcut to query the global unit ID of the calling unit. More...
size_t	size ()
	Return the number of units in the global team. More...
void	barrier ()
	A global barrier involving all units. More...
void	abort ()
	Immediately abort the application run. More...
void	abort (int errorcode)
	Immediately abort the application run with the return value errorcode. More...
template<typename ElementType , class Pattern , class GlobStaticMem , class Pointer , class Reference >
std::ostream &	operator<< (std::ostream &os, const dash::GlobIter< ElementType, Pattern, GlobStaticMem, Pointer, Reference > &it)
template<typename ElementType , class Pattern , class GlobStaticMem , class Pointer , class Reference >
auto	distance (const GlobViewIter< ElementType, Pattern, GlobStaticMem, Pointer, Reference > &first, const GlobViewIter< ElementType, Pattern, GlobStaticMem, Pointer, Reference > &last) -> typename Pattern::index_type
	Resolve the number of elements between two global iterators. More...
template<typename ElementType , class Pattern , class GlobStaticMem , class Pointer , class Reference >
std::ostream &	operator<< (std::ostream &os, const dash::GlobViewIter< ElementType, Pattern, GlobStaticMem, Pointer, Reference > &it)
template<class IndexType >
constexpr std::enable_if< std::is_integral< IndexType >::value, IndexType >::type	index (IndexType idx)
template<class Iterator >
constexpr auto	index (Iterator it) -> decltype((++it).gpos())
template<class RandomAccessIt >
RandomAccessIt::difference_type	distance (const RandomAccessIt &first, const RandomAccessIt &last)
	Resolve the number of elements between two iterators. More...
template<typename ElementType , class Pattern , class GlobMemType , class Pointer , class Reference >
Pattern::index_type	distance (const GlobIter< ElementType, Pattern, GlobMemType, Pointer, Reference > &first, const GlobIter< ElementType, Pattern, GlobMemType, Pointer, Reference > &last)
	Resolve the number of elements between two global iterators. More...
template<typename ElementType , class Pattern , class GlobMemType , class Pointer , class Reference >
DASH_CONSTEXPR auto	operator- (const GlobIter< ElementType, Pattern, GlobMemType, Pointer, Reference > &lhs, const GlobIter< ElementType, Pattern, GlobMemType, Pointer, Reference > &rhs) DASH_NOEXCEPT
template<class T >
constexpr std::ptrdiff_t	distance (T *const first, T *const last)
template<class OffsetType >
constexpr std::enable_if< std::is_integral< OffsetType >::value, OffsetType >::type	distance (OffsetType begin, OffsetType end)
template<typename Key , typename Mapped , typename Hash , typename Pred , typename GlobMemType >
std::ostream &	operator<< (std::ostream &os, const dash::UnorderedMapGlobIter< Key, Mapped, Hash, Pred, GlobMemType > &it)
template<typename Key , typename Mapped , typename Hash , typename Pred , typename LMemSpace >
std::ostream &	operator<< (std::ostream &os, const dash::UnorderedMapLocalIter< Key, Mapped, Hash, Pred, LMemSpace > &it)
template<typename T_ , dim_t NumDimensions1, class PatternT_ , typename LocalMemT >
std::ostream &	operator<< (std::ostream &os, const MatrixRefView< T_, NumDimensions1, PatternT_, LocalMemT > &mrefview)
template<typename ElementType , typename IndexType , class Pointer , class Reference >
auto	distance (const dash::GlobHeapLocalPtr< ElementType, IndexType, Pointer, Reference > &first, const dash::GlobHeapLocalPtr< ElementType, IndexType, Pointer, Reference > &last) -> IndexType
	Resolve the number of elements between two local bucket iterators. More...
template<typename ElementType , typename IndexType , class Pointer , class Reference >
std::ostream &	operator<< (std::ostream &os, const dash::GlobHeapLocalPtr< ElementType, IndexType, Pointer, Reference > &it)
template<typename ElementType , class MemSpaceT >
auto	distance (const dash::GlobHeapPtr< ElementType, MemSpaceT > &first, const dash::GlobHeapPtr< ElementType, MemSpaceT > &last) -> typename MemSpaceT::index_type
	Resolve the number of elements between two global bucket pointers. More...
template<typename ElementType , class MemSpaceT >
std::ostream &	operator<< (std::ostream &os, const dash::GlobHeapPtr< ElementType, MemSpaceT > &gptr)
template<class MSpaceDomainCategory , class MSpaceTypeCategory >
MemorySpace< MSpaceDomainCategory, MSpaceTypeCategory > *	get_default_memory_space ()
	Forward declarations. More...
template<>
MemorySpace< memory_domain_local, memory_space_host_tag > *	get_default_memory_space< memory_domain_local, memory_space_host_tag > ()
template<>
MemorySpace< memory_domain_local, memory_space_hbw_tag > *	get_default_memory_space< memory_domain_local, memory_space_hbw_tag > ()
template<>
MemorySpace< memory_domain_global, memory_space_host_tag > *	get_default_memory_space< memory_domain_global, memory_space_host_tag > ()
template<typename T >
GlobPtr< T, GlobLocalMemoryPool< dash::HostSpace > >	memalloc (size_t nelem)
template<class T >
void	memfree (GlobPtr< T, GlobLocalMemoryPool< dash::HostSpace >> gptr, size_t nels)
template<class Allocator >
constexpr bool	operator== (DefaultDeleter< Allocator > const &, DefaultDeleter< Allocator > const &) noexcept
template<class T , class AllocatorT , template< class > class Deleter = dash::DefaultDeleter>
auto	allocate_unique (const AllocatorT &alloc, std::size_t n)
template<class T >
std::string	typestr (const T &obj)
	Returns string containing the type name of the given object. More...
template<class T >
std::string	typestr ()
	Returns string containing the name of the specified type. More...
template<typename T , typename GlobPtrType >
void	fence (const GlobPtrType &gptr)
	Block until local and global completion of operations on a global address. More...
template<typename T , typename GlobPtrType >
void	fence_local (const GlobPtrType &gptr)
	Block until local completion of operations on a global address. More...
template<typename T , typename GlobPtrType >
void	put_value_async (const T &newval, const GlobPtrType &gptr)
	Write a value to a global pointer, non-blocking. More...
template<typename T , typename GlobPtrType >
void	get_value_async (T *ptr, const GlobPtrType &gptr)
	Read a value fom a global pointer, non-blocking. More...
template<typename T , typename GlobPtrType >
void	put_value (const T &newval, const GlobPtrType &gptr)
	Write a value to a global pointer. More...
template<typename T , typename GlobPtrType >
void	get_value (T *ptr, const GlobPtrType &gptr)
	Read a value fom a global pointer. More...
template<class T1 , class T2 >
constexpr bool	operator== (const Pair< T1, T2 > &x, const Pair< T1, T2 > &y)
	Two pairs of the same type are equal iff their members are equal. More...
template<class T1 , class T2 >
constexpr bool	operator< (const Pair< T1, T2 > &x, const Pair< T1, T2 > &y)
	A pair is smaller than another pair if the first member is smaller or the first is equal and the second is smaller. More...
template<class T1 , class T2 >
constexpr bool	operator!= (const Pair< T1, T2 > &x, const Pair< T1, T2 > &y)
	Inequality comparison operator implemented in terms of equality operator. More...
template<class T1 , class T2 >
constexpr bool	operator> (const Pair< T1, T2 > &x, const Pair< T1, T2 > &y)
	Greater-than operator implemented in terms of less-than operator. More...
template<class T1 , class T2 >
constexpr bool	operator<= (const Pair< T1, T2 > &x, const Pair< T1, T2 > &y)
	Less-than-or-equal operator implemented in terms of less-than operator. More...
template<class T1 , class T2 >
constexpr bool	operator>= (const Pair< T1, T2 > &x, const Pair< T1, T2 > &y)
	Greater-than-or-equal operator implemented in terms of less-than operator. More...
template<class T1 , class T2 >
void	swap (Pair< T1, T2 > &x, Pair< T1, T2 > &y) noexcept(noexcept(x.swap(y)))
	Wrapper for Pair::swap. More...
template<class T1 , class T2 >
constexpr Pair< typename internal::decay_and_strip< T1 >::type, typename internal::decay_and_strip< T2 >::type >	make_pair (T1 &&x, T2 &&y)
	Convennience wrapper to create a Pair object. More...
template<class T1 , class T2 >
std::ostream &	operator<< (std::ostream &os, const Pair< T1, T2 > &pair)
template<typename PartitioningTags , typename MappingTags , typename LayoutTags , class SizeSpecType >
TeamSpec< SizeSpecType::ndim::value, typename SizeSpecType::index_type >	make_team_spec (const SizeSpecType &sizespec, int n_units, typename SizeSpecType::size_type n_nodes=0, typename SizeSpecType::size_type n_numa_dom=0, typename SizeSpecType::size_type n_cores=0)
template<typename PartitioningTags , typename MappingTags , typename LayoutTags , class SizeSpecType >
TeamSpec< SizeSpecType::ndim::value, typename SizeSpecType::index_type >	make_team_spec (const SizeSpecType &sizespec, dash::Team &team=dash::Team::All(), typename SizeSpecType::size_type n_nodes=0, typename SizeSpecType::size_type n_numa_dom=0, typename SizeSpecType::size_type n_cores=0)
	{} More...
template<typename PartitioningTags , typename MappingTags , typename LayoutTags , class SizeSpecType , class TeamSpecType >
DistributionSpec< SizeSpecType::ndim::value >	make_distribution_spec (const SizeSpecType &sizespec, const TeamSpecType &teamspec)
	Generic Abstract Factory for instances of dash::DistributionSpec. More...
template<typename PartitioningTags = dash::pattern_partitioning_default_properties, typename MappingTags = dash::pattern_mapping_default_properties, typename LayoutTags = dash::pattern_layout_default_properties, class SizeSpecType , class TeamSpecType >
std::enable_if< !MappingTags::diagonal &&PartitioningTags::rectangular &&PartitioningTags::balanced &&!PartitioningTags::unbalanced &&LayoutTags::blocked, TilePattern< SizeSpecType::ndim::value, dash::ROW_MAJOR, typename SizeSpecType::index_type >>::type	make_pattern (const SizeSpecType &sizespec, const TeamSpecType &teamspec)
	Generic Abstract Factory for models of the Pattern concept. More...
template<typename PartitioningTags = dash::pattern_partitioning_default_properties, typename MappingTags = dash::pattern_mapping_default_properties, typename LayoutTags = dash::pattern_layout_default_properties, class SizeSpecType , class TeamSpecType >
std::enable_if< MappingTags::diagonal &&(LayoutTags::blocked||(PartitioningTags::balanced &&SizeSpecType::ndim::value==1)), ShiftTilePattern< SizeSpecType::ndim::value, dash::ROW_MAJOR, typename SizeSpecType::index_type >>::type	make_pattern (const SizeSpecType &sizespec, const TeamSpecType &teamspec)
	Generic Abstract Factory for models of the Pattern concept. More...
template<typename PartitioningTags = dash::pattern_partitioning_default_properties, typename MappingTags = dash::pattern_mapping_default_properties, typename LayoutTags = dash::pattern_layout_default_properties, class SizeSpecType , class TeamSpecType >
std::enable_if< LayoutTags::canonical, BlockPattern< SizeSpecType::ndim::value, dash::ROW_MAJOR, typename SizeSpecType::index_type >>::type	make_pattern (const SizeSpecType &sizespec, const TeamSpecType &teamspec)
	Generic Abstract Factory for models of the Pattern concept. More...
template<typename PartitioningConstraints , typename MappingConstraints , typename LayoutConstraints , typename PatternType >
bool	check_pattern_constraints (const PatternType &pattern)
	Traits for compile- and run-time pattern constraints checking, suitable for property checks where detailed error reporting is desired. More...
template<dim_t ND, MemArrange Ar, typename Index >
std::ostream &	operator<< (std::ostream &os, const SeqTilePattern< ND, Ar, Index > &pattern)
template<dim_t ND, MemArrange Ar, typename Index >
std::ostream &	operator<< (std::ostream &os, const TilePattern< ND, Ar, Index > &pattern)
template<typename RangeType >
constexpr auto	begin (RangeType &&range) -> decltype(std::forward< RangeType >(range).begin())
template<class RangeType >
constexpr auto	end (RangeType &&range) -> decltype(std::forward< RangeType >(range).end())
template<class RangeType >
constexpr auto	size (RangeType &&r) -> decltype(std::forward< RangeType >(r).size())
template<class Iterator , class Sentinel >
constexpr dash::IteratorRange< const Iterator, const Sentinel >	make_range (const Iterator &begin, const Sentinel &end)
	Adapter utility function. More...
template<class Iterator , class Sentinel >
constexpr dash::IteratorRange< Iterator *, Sentinel * >	make_range (Iterator *begin, Sentinel *end)
	Adapter utility function. More...
template<class Iterator , class Sentinel >
dash::IteratorRange< Iterator, Sentinel >	make_range (Iterator &begin, Sentinel &end)
	Adapter utility function. More...
template<typename T >
void	swap (dash::Shared< T > &a, dash::Shared< T > &b)
std::ostream &	operator<< (std::ostream &os, const Team &team)
bool	operator== (const Team::Deallocator &lhs, const Team::Deallocator &rhs)
template<class ViewTypeA , class ViewTypeB >
constexpr auto	apply (ViewTypeA &view_a, ViewTypeB &view_b) -> decltype(view_a.apply(view_b))
	Inverse operation to dash::domain. More...
template<class ViewType >
constexpr auto	apply (const ViewType &view) -> decltype(view.apply())
template<class ViewType , class OffsetT >
constexpr auto	block (OffsetT block_idx, const ViewType &view) -> typename std::enable_if<(!dash::view_traits< ViewType >::is_local::value), ViewBlockMod< ViewType > >::type
	Blocks view from global view. More...
template<class ViewT , typename ViewValueT = typename std::decay<ViewT>::type>
constexpr auto	domain (ViewT &&view) -> typename std::enable_if< dash::detail::has_type_domain_type< ViewValueT >::value, decltype(std::forward< ViewT >(view).domain()) >::type
template<class ViewT >
constexpr auto	domain (const ViewT &view) -> typename std::enable_if< dash::detail::has_type_domain_type< ViewT >::value, decltype(view.domain()) >::type
template<class ContainerT , typename ContainerValueT = typename std::decay<ContainerT>::type>
constexpr std::enable_if< !dash::detail::has_type_domain_type< ContainerValueT >::value, ContainerT & >::type	domain (ContainerT &container)
template<class ContainerT , typename ContainerValueT = typename std::decay<ContainerT>::type>
constexpr std::enable_if< !dash::detail::has_type_domain_type< ContainerValueT >::value, const ContainerT & >::type	domain (const ContainerT &container)
template<class ViewType >
constexpr std::enable_if< dash::view_traits< ViewType >::is_view::value &&dash::view_traits< ViewType >::is_local::value, const typename ViewType::global_type & >::type	global (const ViewType &v)
template<class ContainerType >
constexpr std::enable_if< !dash::view_traits< ContainerType >::is_view::value||!dash::view_traits< ContainerType >::is_local::value, ContainerType & >::type	global (ContainerType &c)
template<class ViewType , typename ViewValueT = typename std::decay<ViewType>::type>
constexpr auto	local (ViewType &v) -> typename std::enable_if<(std::is_pointer< typename ViewType::iterator >::value||(dash::view_traits< ViewValueT >::is_local::value)), ViewType &>::type
template<class ContainerType , typename ContainerDecayType = typename std::decay<ContainerType>::type>
constexpr std::enable_if<(!dash::view_traits< ContainerDecayType >::is_view::value &&!dash::view_traits< ContainerDecayType >::is_local::value &&dash::view_traits< ContainerDecayType >::is_origin::value), const typename ContainerType::local_type & >::type	local (const ContainerType &c)
template<class ViewType >
constexpr auto	local (const ViewType &v) -> typename std::enable_if< dash::view_traits< ViewType >::is_view::value, decltype(v.local()) >::type
template<class ViewType , typename ViewValueT = typename std::decay<ViewType>::type>
constexpr auto	local (ViewType &&v) -> typename std::enable_if<(dash::view_traits< ViewValueT >::is_view::value &&!dash::view_traits< ViewValueT >::is_local::value), decltype(std::forward< ViewType >(v).local()) >::type
template<class GlobalIterator >
constexpr auto	local (const GlobalIterator &g_it) -> decltype((g_it - g_it.pos()).local())
	Convert global iterator referencing an element the active unit's memory to a corresponding native pointer referencing the element. More...
template<class ViewT >
dash::view_traits< ViewT >::origin_type	origin (ViewT &view)
template<class ViewType >
constexpr auto	remote (dash::team_unit_t unit, const ViewType &v) -> typename std::enable_if< dash::view_traits< ViewType >::is_view::value, decltype(v.local()) >::type
template<class ContainerType >
constexpr std::enable_if< !dash::view_traits< ContainerType >::is_view::value, const typename ContainerType::local_type & >::type	remote (dash::team_unit_t unit, const ContainerType &c)
template<class ViewTypeA , class ViewTypeB >
constexpr auto	intersect (const ViewTypeA &va, const ViewTypeB &vb) -> decltype(dash::sub(0, 0, va))
template<class ComponentViewType >
constexpr CompositeView< ComponentViewType >	set_union (const std::vector< ComponentViewType > &views)
template<class ComponentViewType >
constexpr CompositeView< ComponentViewType >	set_union (std::initializer_list< ComponentViewType > views)
template<dim_t SubDim = 0, dim_t NViewDim, class OffsetFirstT , class OffsetFinalT >
constexpr ViewSubMod< ViewOrigin< NViewDim >, SubDim >	sub (OffsetFirstT begin, OffsetFinalT end)
	Sub-section, view dimensions maintain domain dimensions. More...
template<dim_t SubDim = 0, dim_t NViewDim, class IndexRangeT >
constexpr ViewSubMod< ViewOrigin< NViewDim >, SubDim >	sub (const IndexRangeT &range)
	Sub-section, view dimensions maintain domain dimensions. More...
template<dim_t SubDim = 0, class DomainT , class OffsetFirstT , class OffsetFinalT , typename DomainValueT = typename std::decay<DomainT>::type>
constexpr ViewSubMod< DomainValueT, SubDim, dash::view_traits< DomainValueT >::rank::value >	sub (OffsetFirstT begin, OffsetFinalT end, const DomainT &domain)
template<dim_t SubDim = 0, class DomainT , class OffsetFirstT , class OffsetFinalT , typename DomainValueT = typename std::decay<DomainT>::type>
constexpr ViewSubMod< DomainValueT, SubDim, dash::view_traits< DomainValueT >::rank::value >	sub (OffsetFirstT begin, OffsetFinalT end, DomainT &&domain)
template<class DomainT , class IndexSetT >
std::ostream &	operator<< (std::ostream &os, const ViewIterator< DomainT, IndexSetT > &view_it)
template<class Viewable >
constexpr Viewable::domain_type &	domain (const Viewable &v)
	Returns a reference to the specified object's domain, or the object itself if it is not a View type. More...
template<class Iterator , class Sentinel >
constexpr dash::IteratorViewOrigin< Iterator, Sentinel >	make_view (Iterator begin, Sentinel end)

Variables
struct dash::dart_operation	ValueType
	Reduce operands to their minimum value. More...
struct dash::dart_operation	DART_OP_MIN
struct dash::dart_operation	ARITHMETIC
struct dash::dart_operation const ValueType &rhs	const
dash::max	operator
constexpr team_unit_t	UNDEFINED_TEAM_UNIT_ID { ((dart_unit_t)(-1)) }
	Invalid local unit ID. More...
constexpr global_unit_t	UNDEFINED_GLOBAL_UNIT_ID { ((dart_unit_t)(-1)) }
	Invalid global unit ID. More...

Detailed Description

This class is a simple memory pool which holds allocates elements of size ValueType.

The DASH C++ Library Interface.

Efficient allocation is achieved in terms of the memory regions. Each region represents a chunk of memory blocks and each block is a single element of size ValueType.

Methods

Return Type	Method	Parameters	Description
ValueType *	allocate	nbsp;	Allocates an aligned block to store a single element of size ValueType
void	deallocate	addr	Deallocates the specified memory address and keeps memory internall in a freelist.
void	reserve	nblocks	Reserve a chunk of memory blocks to hold at least n elements of size ValueType.
void	release	nbsp;	Release all memory chunks and deallocate everything at one.

Typedef Documentation

default_extent_t

typedef internal::default_unsigned_index dash::default_extent_t

Unsigned integer type used as default for extent values.

Definition at line 64 of file Types.h.

default_index_t

typedef internal::default_signed_index dash::default_index_t

Signed integer type used as default for index values.

Definition at line 59 of file Types.h.

default_size_t

typedef internal::default_unsigned_index dash::default_size_t

Unsigned integer type used as default for size values.

Definition at line 69 of file Types.h.

dim_t

typedef int dash::dim_t

Scalar type for a dimension value, with 0 indicating the first dimension.

Definition at line 39 of file Types.h.

global_unit_t

typedef struct dash::unit_id< dash::global_unit, dart_global_unit_t > dash::global_unit_t

Unit ID to use for global IDs.

Note that this typed is returned by dash::myid() and dash::Team::GlobalUnitID().

See also

unit_id

team_unit_t

Definition at line 332 of file Types.h.

GlobMemAllocPtr

template<class T >

using dash::GlobMemAllocPtr = typedef decltype(dash::memalloc<T>(size_t{}))

Convenience Wrapper to retrieve easily the type allocated by dash::memalloc<T>

Definition at line 88 of file MemorySpace.h.

gptrdiff_t

typedef internal::default_signed_index dash::gptrdiff_t

Difference type for global pointers.

Definition at line 74 of file Types.h.

NArray

template<typename T , dim_t NumDimensions, typename IndexT = dash::default_index_t, class PatternT = Pattern<NumDimensions, ROW_MAJOR, IndexT>, typename LocalMemSpaceT = HostSpace>

using dash::NArray = typedef dash::Matrix<T, NumDimensions, IndexT, PatternT, LocalMemSpaceT>

Template alias for dash::Matrix with the same default template arguments.

See also

Matrix

Definition at line 782 of file Matrix.h.

Pattern

template<dim_t NumDimensions, MemArrange Arrangement = ROW_MAJOR, typename IndexType = dash::default_index_t>

using dash::Pattern = typedef dash::BlockPattern<NumDimensions, Arrangement, IndexType>

Template alias for dash::Pattern with the same default template arguments.

See also

BlockPattern

Definition at line 644 of file Pattern.h.

summa_pattern_layout_constraints

typedef dash::pattern_layout_properties< dash::pattern_layout_tag::blocked, dash::pattern_layout_tag::linear > dash::summa_pattern_layout_constraints

Constraints on pattern layout properties of matrix operands passed to dash::summa.

Definition at line 122 of file SUMMA.h.

summa_pattern_mapping_constraints

typedef dash::pattern_mapping_properties< dash::pattern_mapping_tag::multiple, dash::pattern_mapping_tag::unbalanced > dash::summa_pattern_mapping_constraints

Constraints on pattern mapping properties of matrix operands passed to dash::summa.

Examples:

ex.06.pattern-block-visualizer/main.cpp.

Definition at line 112 of file SUMMA.h.

summa_pattern_partitioning_constraints

typedef dash::pattern_partitioning_properties< dash::pattern_partitioning_tag::rectangular, dash::pattern_partitioning_tag::balanced, dash::pattern_partitioning_tag::ndimensional > dash::summa_pattern_partitioning_constraints

Constraints on pattern partitioning properties of matrix operands passed to dash::summa.

Examples:

ex.06.pattern-block-visualizer/main.cpp.

Definition at line 103 of file SUMMA.h.

team_unit_t

typedef struct dash::unit_id< dash::local_unit, dart_team_unit_t > dash::team_unit_t

Unit ID to use for team-local IDs.

Note that this is returned by calls to dash::Team::myid(), including dash::Team::All().myid() as it is handled as a team as well.

See also

unit_id

global_unit_t

Definition at line 319 of file Types.h.

Enumeration Type Documentation

global_allocation_policy

enum dash::global_allocation_policy : uint8_t

strong

Enumerator
collective	All units collectively allocate global memory.
non_collective	only one unit allocates in global memory
epoch_synchronized	all units allocate invdividually in local memory and synchronize in epochs

Definition at line 17 of file AllocationPolicy.h.

                                    : uint8_t {
  collective,

  non_collective,

  epoch_synchronized,
};

launch

enum dash::launch : uint16_t

strong

Enumerator
sync	synchronous launch policy
async	async launch policy

Definition at line 8 of file LaunchPolicy.h.

                  : uint16_t {
sync     = 0x1,
async    = 0x2
};

Function Documentation

addressof()

template<class MemSpaceT , class T >

auto dash::addressof ( dash::GlobRef< T > const &  ref )

inline

specialization for unqualified calls to swap

Definition at line 432 of file GlobRef.h.

{
  return dash::GlobPtr<T, MemSpaceT>(ref.dart_gptr());
}

align()

void* dash::align ( std::size_t  alignment, std::size_t  size, void *&  ptr, std::size_t &  space  )

inline

Replacement for missing std::align in gcc < 5.0.

Implementation from original bug report: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57350

Definition at line 21 of file Allocator.h.

{
  auto pn = reinterpret_cast< std::uintptr_t >(ptr);
  auto aligned   = (pn + alignment - 1) & - alignment;
  auto new_space = space - ( aligned - pn );
  if (new_space < size) return nullptr;
  space      = new_space;
  return ptr = reinterpret_cast<void *>(aligned);
}

block()

template<class ViewType , class OffsetT >

constexpr auto dash::block	(	OffsetT	block_idx,
		const ViewType &	view
	)		-> typename std::enable_if< ( !dash::view_traits<ViewType>::is_local::value ), ViewBlockMod<ViewType> >::type

Blocks view from global view.

Blocks view from local view.

Definition at line 49 of file Chunked.h.

References local(), and origin().

Referenced by dash::tools::PatternVisualizer< PatternT >::draw_blocks(), and dash::tools::PatternVisualizer< PatternT >::draw_local_blocks().

         {
  return ViewBlockMod<ViewType>(view, block_idx);
}

distance() [1/4]

template<class T , class MemSpaceT >

dash::gptrdiff_t dash::distance	(	GlobPtr< T, MemSpaceT >	gbegin,
		GlobPtr< T, MemSpaceT >	gend
	)

Returns the number of hops from gbegin to gend.

Equivalent to (gend - gbegin).

Note

The distance is calculate by considering the memory traits of the underlying global memory distances.

Returns

The number of increments to go from gbegin to gend

Implemented concept:

DashMemorySpaceConcept

Definition at line 547 of file GlobPtr.h.

References begin(), and end().

Referenced by dash::GlobPtr< event_ctr_t, globmem_t >::operator-().

{
  using memory_space_traits = dash::memory_space_traits<MemSpaceT>;

  auto const begin = static_cast<dart_gptr_t>(gbegin);
  auto const end = static_cast<dart_gptr_t>(gbegin);

  DASH_ASSERT_EQ(begin.teamid, end.teamid, "teamid must be equal");
  DASH_ASSERT_EQ(begin.segid, end.segid, "segid must be equal");

  auto &      reg = dash::internal::MemorySpaceRegistry::GetInstance();
  auto const *mem_space =
      static_cast<const MemSpaceT *>(reg.lookup(begin));

  return dash::internal::distance<T>(
      static_cast<dart_gptr_t>(gbegin),
      static_cast<dart_gptr_t>(gend),
      mem_space,
      typename memory_space_traits::memory_space_layout_tag{});
}

distance() [2/4]

template<typename ElementType , typename IndexType , class Pointer , class Reference >

auto dash::distance	(	const dash::GlobHeapLocalPtr< ElementType, IndexType, Pointer, Reference > &	first,
		const dash::GlobHeapLocalPtr< ElementType, IndexType, Pointer, Reference > &	last
	)		-> IndexType

Resolve the number of elements between two local bucket iterators.

Time complexity

O(1)

Parameters

first	Global iterator to the first position in the global sequence
last	Global iterator to the final position in the global sequence

Definition at line 469 of file GlobHeapLocalPtr.h.

{
  return last - first;
}

distance() [3/4]

template<typename ElementType , class MemSpaceT >

auto dash::distance	(	const dash::GlobHeapPtr< ElementType, MemSpaceT > &	first,
		const dash::GlobHeapPtr< ElementType, MemSpaceT > &	last
	)		-> typename MemSpaceT::index_type

Resolve the number of elements between two global bucket pointers.

Time complexity

O(1)

Parameters

first	Global pointer to the first position in the global sequence
last	Global pointer to the final position in the global sequence

Definition at line 644 of file GlobHeapPtr.h.

{

  if (last._globmem == first._globmem) {
    return last - first;
  }
  else {
    return std::numeric_limits<typename MemSpaceT::index_type>::max();
  }
}

distance() [4/4]

template<typename ElementType , class Pattern , class GlobStaticMem , class Pointer , class Reference >

auto dash::distance	(	const GlobViewIter< ElementType, Pattern, GlobStaticMem, Pointer, Reference > &	first,
		const GlobViewIter< ElementType, Pattern, GlobStaticMem, Pointer, Reference > &	last
	)		-> typename Pattern::index_type

Resolve the number of elements between two global iterators.

The difference of global pointers is not well-defined if their range spans over more than one block. The corresponding invariant is: g_last == g_first + (l_last - l_first) Example:

unit:            0       1       0
local offset:  | 0 1 2 | 0 1 2 | 3 4 5 | ...
global offset: | 0 1 2   3 4 5   6 7 8   ...
range:          [- - -           - -]

When iterating in local memory range [0,5[ of unit 0, the position of the global iterator to return is 8 != 5

Template Parameters

ElementType

Type of the elements in the range

Time complexity

O(1)

Parameters

last	Global iterator to the final position in the global sequence

Definition at line 1062 of file GlobViewIter.h.

{
  return last - first;
}

fence()

template<typename T , typename GlobPtrType >

void dash::fence

(

const GlobPtrType &

gptr

)

Block until local and global completion of operations on a global address.

Definition at line 152 of file Onesided.h.

References dart_flush(), and DART_OK.

{
  DASH_ASSERT_RETURNS(
    dart_flush(gptr.dart_gptr()),
    DART_OK);
}

fence_local()

template<typename T , typename GlobPtrType >

void dash::fence_local

(

const GlobPtrType &

gptr

)

Block until local completion of operations on a global address.

Definition at line 164 of file Onesided.h.

References dart_flush_local(), and DART_OK.

{
  DASH_ASSERT_RETURNS(
    dart_flush_local(gptr.dart_gptr()),
    DART_OK);
}

get_default_memory_space()

template<class MSpaceDomainCategory , class MSpaceTypeCategory >

MemorySpace< MSpaceDomainCategory, MSpaceTypeCategory > * dash::get_default_memory_space ( )

inline

Forward declarations.

Definition at line 29 of file MemorySpace.h.

Referenced by dash::GlobLocalMemoryPool< dash::HostSpace >::flush_local().

{
  static_assert(
      detail::dependent_false<MSpaceDomainCategory, MSpaceTypeCategory>::
          value,
      "No default memory space for this configuration available");
  // Current we have only a default host space
  return nullptr;
}

get_value()

template<typename T , typename GlobPtrType >

void dash::get_value ( T *  ptr, const GlobPtrType &  gptr  )

inline

Read a value fom a global pointer.

Calls to this routine are blocking

Parameters

[out]	ptr	Local pointer that will contain the value of the global address
[in]	gptr	Global pointer to read

Definition at line 230 of file Onesided.h.

Referenced by dash::GlobHeapMem< ElementType, LocalMemorySpace, AllocationPolicy, LocalAlloc >::get_value().

{
  dash::internal::get_blocking(gptr.dart_gptr(), ptr, 1);
}

get_value_async()

template<typename T , typename GlobPtrType >

void dash::get_value_async ( T *  ptr, const GlobPtrType &  gptr  )

inline

Read a value fom a global pointer, non-blocking.

Requires a later fence operation to guarantee local and/or remote completion.

Parameters

[out]	ptr	Local pointer that will contain the value of the global address
[in]	gptr	Global pointer to read

Definition at line 197 of file Onesided.h.

{
  dash::internal::get(gptr.dart_gptr(), ptr, 1);
}

local()

template<class GlobalIterator >

constexpr auto dash::local

(

const GlobalIterator &

g_it

)

-> decltype((g_it - g_it.pos()).local())

Convert global iterator referencing an element the active unit's memory to a corresponding native pointer referencing the element.

Precondition: g_it is local

Parameters

g_it	Global iterator referencing element in local memory

Definition at line 143 of file Local.h.

                                          {
  return g_it.local();
}

local_begin()

template<class T , class MemSpaceT >

DASH_CONSTEXPR std::enable_if< std::is_same< typename dash::memory_space_traits< MemSpaceT>::memory_space_layout_tag, memory_space_contiguous>::value, T>::type* dash::local_begin ( GlobPtr< T, MemSpaceT >  global_begin, dash::team_unit_t  unit  )

inline

Returns the begin of the local memory portion within a global memory segment.

Parameters

global_begin	The pointer which identifies the global memory segment
unit	The unit_id whose local memory portion is required. This must be a unit which is running locally, i.e. the local memory portion must be reachable with a native pointer (void*)

Returns

returns the local memory portion identified by a global memory segment.

Implemented concept:

DashMemorySpaceConcept

Definition at line 593 of file GlobPtr.h.

Referenced by find(), dash::GlobIter< value_type, Pattern_t, GlobMem_t >::local(), dash::GlobViewIter< ElementT, PatternT, GlobMemT >::local(), local_range(), and min_element().

{
  // reset offset to 0
  auto dart_gptr                = static_cast<dart_gptr_t>(global_begin);
  dart_gptr.unitid              = unit.id;
  dart_gptr.addr_or_offs.offset = 0;
  return GlobPtr<T, MemSpaceT>(dart_gptr).local();
}

local_index_range()

template<class GlobInputIter >

std::enable_if< GlobInputIter::has_view::value, LocalIndexRange<typename GlobInputIter::pattern_type::index_type>>::type dash::local_index_range	(	const GlobInputIter &	first,
		const GlobInputIter &	last
	)

Resolves the local index range between global view iterators.

Todo:

Only all-local or all-nonlocal ranges supported for now.

Example:

Total range	0 1 2 3 4 5 6 7 8 9
Global iterators	first = 4; last = 7;

| 0 1 2 3 [4 5 6 7] 8 9] Local elements | (local index:value) 0:2 1:3 2:6 3:7 Result | (local indices) 2 3

Returns

A local index range consisting of offsets of the first and last element in local memory within the sequence limited by the given global iterators.

Time complexity

O(d), with d dimensions in the global iterators' pattern

Parameters

first	Iterator to the initial position in the global sequence
last	Iterator to the final position in the global sequence

Definition at line 188 of file LocalRange.h.

{
  typedef typename GlobInputIter::pattern_type pattern_t;
  typedef typename pattern_t::index_type       idx_t;
  // Get offsets of iterators within global memory, O(1):
  auto begin_gindex = static_cast<idx_t>(first.pos());
  auto end_gindex   = static_cast<idx_t>(last.pos());
  DASH_LOG_TRACE("local_index_range(ViewIt,ViewIt)",
                 begin_gindex, end_gindex);
  DASH_ASSERT_GT(begin_gindex+1, 0,
                 "local_index_range: begin.gidx must not be negative");
  DASH_ASSERT_GT(end_gindex+1, 0,
                 "local_index_range: end.gidx must not be negative");
  // Check if input range is relative to a view spec (e.g. a block):
  if (first.is_relative() && last.is_relative()) {
    DASH_LOG_TRACE("local_index_range", "input iterators are relative");
    if (first.viewspec() == last.viewspec()) {
      DASH_LOG_TRACE("local_index_range", "input iterators in same view");
      auto l_first        = first.lpos();
      bool first_is_local = l_first.unit == first.team().myid();
      // No need to check if last is local as both are relative to the
      // same view.
      if (first_is_local) {
        auto l_last_idx  = last.lpos().index;
        auto l_first_idx = l_first.index;
        DASH_LOG_TRACE("local_index_range >", l_first_idx, l_last_idx);
        return LocalIndexRange<idx_t> { l_first_idx, l_last_idx };
      }
      DASH_LOG_TRACE("local_index_range >", "not local -> (0,0)");
      return LocalIndexRange<idx_t>{0, 0};
    }
    DASH_THROW(
        dash::exception::InvalidArgument,
        "dash::local_index_range: views of first and last iterators "
        "differ");
  }
  // Get pattern from global iterators, O(1):
  const auto& pattern = first.pattern();
  DASH_LOG_TRACE_VAR("local_index_range", pattern.local_size());
  if (pattern.local_size() == 0) {
    // Local index range is empty
    DASH_LOG_TRACE("local_index_range (lsize:0) ->", 0, 0);
    return LocalIndexRange<idx_t> { 0, 0 };
  }
  // Global index of first element in pattern, O(1):
  idx_t lbegin_gindex = pattern.lbegin();
  // Global index of last element in pattern, O(1):
  idx_t lend_gindex   = pattern.lend();
  DASH_LOG_TRACE_VAR("local_index_range", lbegin_gindex);
  DASH_LOG_TRACE_VAR("local_index_range", lend_gindex);
  if (lend_gindex   <= begin_gindex ||  // local end before global begin
      lbegin_gindex >= end_gindex) {    // local begin after global end
    // No overlap, intersection is empty
    DASH_LOG_TRACE("local_index_range (intersect:0)->", 0, 0);
    return LocalIndexRange<idx_t> { 0, 0 };
  }
  // Intersect local range and global range, in global index domain:
  auto goffset_lbegin = std::max<idx_t>(lbegin_gindex, begin_gindex);
  auto goffset_lend   = std::min<idx_t>(lend_gindex, end_gindex);
  // Global positions of local range to global coordinates, O(d):
  auto lbegin_gcoords = pattern.coords(goffset_lbegin);
  // Subtract 1 from global end offset as it points one coordinate
  // past the last index which is out of the valid coordinates range:
  auto lend_gcoords   = pattern.coords(goffset_lend-1);
  // Global coordinates of local range to local indices, O(d):
  auto lbegin_index   = pattern.at(lbegin_gcoords);
  // Add 1 to local end index to it points one coordinate past the
  // last index:
  auto lend_index     = pattern.at(lend_gcoords);
  if (lend_index
      == std::numeric_limits<typename pattern_t::index_type>::max()) {
    DASH_LOG_ERROR("local_index_range !",
                   "index type too small for for local index range");
  }
  lend_index += 1;
  // Return local index range
  DASH_LOG_TRACE("local_index_range ->", lbegin_index, lend_index);
  return LocalIndexRange<idx_t> { lbegin_index, lend_index };
}

local_range()

template<class GlobIterType >

LocalRange<typename GlobIterType::value_type> dash::local_range	(	GlobIterType &	first,
		GlobIterType &	last
	)

Global iterators to local index range, O(d):

Parameters

first	Iterator to the initial position in the global sequence
last	Iterator to the final position in the global sequence

Definition at line 338 of file LocalRange.h.

References local_begin(), and local_index_range().

{
  typedef typename GlobIterType::pattern_type pattern_t;
  typedef typename GlobIterType::value_type   value_t;
  typedef typename pattern_t::index_type      idx_t;
  DASH_LOG_TRACE("local_range()",
                 "gfirst.pos:", first.pos(),
                 "glast.pos:",  last.pos());
  auto index_range   = dash::local_index_range(first, last);
  idx_t lbegin_index = index_range.begin;
  idx_t lend_index   = index_range.end;
  if (lbegin_index == lend_index) {
    // Local range is empty
    DASH_LOG_TRACE("local_range >", "empty local range",
                   lbegin_index, lend_index);
    return LocalRange<value_t> { nullptr, nullptr };
  }
  // Local start address from global memory:

  auto* lbegin = dash::local_begin(
      static_cast<typename GlobIterType::pointer>(first.globmem().begin()),
      first.team().myid());

  // Add local offsets to local start address:
  if (lbegin == nullptr) {
    DASH_LOG_TRACE("local_range >", "lbegin null");
    return LocalRange<value_t> { nullptr, nullptr };
  }
  DASH_LOG_TRACE("local_range >",
                 "lbegin:",      lbegin,
                 "l_idx_range:", lbegin_index, "-", lend_index);
  return LocalRange<value_t> {
           lbegin + lbegin_index,
           lbegin + lend_index };
}

make_pair()

template<class T1 , class T2 >

constexpr Pair<typename internal::decay_and_strip<T1>::type, typename internal::decay_and_strip<T2>::type> dash::make_pair	(	T1 &&	x,
		T2 &&	y
	)

Convennience wrapper to create a Pair object.

Definition at line 225 of file Pair.h.

References dash::Pair< T1, T2 >::first, dash::Pair< T1, T2 >::second, and typestr().

  {
    typedef typename internal::decay_and_strip<T1>::type ds_type1;
    typedef typename internal::decay_and_strip<T2>::type ds_type2;
    typedef Pair<ds_type1, ds_type2>                     pair_type;
    return pair_type(std::forward<T1>(x), std::forward<T2>(y));
  }

make_pattern() [1/2]

template<typename PartitioningTags = dash::pattern_partitioning_default_properties, typename MappingTags = dash::pattern_mapping_default_properties, typename LayoutTags = dash::pattern_layout_default_properties, class SizeSpecType , class TeamSpecType >

std::enable_if< MappingTags::diagonal && (LayoutTags::blocked || (PartitioningTags::balanced && SizeSpecType::ndim::value == 1)), ShiftTilePattern<SizeSpecType::ndim::value, dash::ROW_MAJOR, typename SizeSpecType::index_type>>::type dash::make_pattern	(	const SizeSpecType &	sizespec,
		const TeamSpecType &	teamspec
	)

Generic Abstract Factory for models of the Pattern concept.

Creates an instance of a Pattern model that satisfies the contiguos linearization property from given pattern traits.

{}

Returns

An instance of dash::ShiftTilePattern if the following constraints are specified: (Mapping: diagonal) and (Layout: blocked or (Partitioning: balanced Dimensions: 1))

Parameters

sizespec	Size spec of cartesian space to be distributed by the pattern.
teamspec	Team spec containing layout of units mapped by the pattern.

Definition at line 439 of file MakePattern.h.

References make_distribution_spec(), and ndim().

{
  // Deduce number of dimensions from size spec:
  const dim_t ndim = SizeSpecType::ndim::value;
  // Deduce index type from size spec:
  typedef typename SizeSpecType::index_type                      index_t;
  typedef dash::ShiftTilePattern<ndim, dash::ROW_MAJOR, index_t> pattern_t;
  DASH_LOG_TRACE("dash::make_pattern", PartitioningTags());
  DASH_LOG_TRACE("dash::make_pattern", MappingTags());
  DASH_LOG_TRACE("dash::make_pattern", LayoutTags());
  DASH_LOG_TRACE_VAR("dash::make_pattern", sizespec.extents());
  DASH_LOG_TRACE_VAR("dash::make_pattern", teamspec.extents());
  // Make distribution spec from template- and run time parameters:
  auto distspec =
    make_distribution_spec<
      PartitioningTags,
      MappingTags,
      LayoutTags,
      SizeSpecType,
      TeamSpecType
    >(sizespec,
      teamspec);
  // Make pattern from template- and run time parameters:
  pattern_t pattern(sizespec,
        distspec,
        teamspec);
  return pattern;
}

make_pattern() [2/2]

template<typename PartitioningTags = dash::pattern_partitioning_default_properties, typename MappingTags = dash::pattern_mapping_default_properties, typename LayoutTags = dash::pattern_layout_default_properties, class SizeSpecType , class TeamSpecType >

std::enable_if< LayoutTags::canonical, BlockPattern<SizeSpecType::ndim::value, dash::ROW_MAJOR, typename SizeSpecType::index_type >>::type dash::make_pattern	(	const SizeSpecType &	sizespec,
		const TeamSpecType &	teamspec
	)

Generic Abstract Factory for models of the Pattern concept.

Creates an instance of a Pattern model that satisfies the canonical (strided) layout property from given pattern traits.

{}

Returns

An instance of dash::BlockPattern if the following constraints are specified:

• Layout: canonical

Parameters

sizespec	Size spec of cartesian space to be distributed by the pattern.
teamspec	Team spec containing layout of units mapped by the pattern.

Definition at line 497 of file MakePattern.h.

References make_distribution_spec(), and ndim().

{
  // Deduce number of dimensions from size spec:
  const dim_t ndim = SizeSpecType::ndim::value;
  // Deduce index type from size spec:
  typedef typename SizeSpecType::index_type             index_t;
  typedef dash::BlockPattern<ndim, dash::ROW_MAJOR, index_t> pattern_t;
  DASH_LOG_TRACE("dash::make_pattern", PartitioningTags());
  DASH_LOG_TRACE("dash::make_pattern", MappingTags());
  DASH_LOG_TRACE("dash::make_pattern", LayoutTags());
  // Make distribution spec from template- and run time parameters:
  auto distspec =
    make_distribution_spec<
      PartitioningTags,
      MappingTags,
      LayoutTags,
      SizeSpecType,
      TeamSpecType
    >(sizespec,
      teamspec);
  // Make pattern from template- and run time parameters:
  pattern_t pattern(sizespec,
                    distspec,
                    teamspec);
  return pattern;
}

make_range() [1/3]

template<class Iterator , class Sentinel >

constexpr dash::IteratorRange<const Iterator, const Sentinel> dash::make_range	(	const Iterator &	begin,
		const Sentinel &	end
	)

Adapter utility function.

Wraps begin and end const iterators in range type.

Definition at line 433 of file Range.h.

References begin(), and end().

                        {
  return dash::IteratorRange<const Iterator, const Sentinel>(
           begin,
           end);
}

make_range() [2/3]

template<class Iterator , class Sentinel >

constexpr dash::IteratorRange<Iterator *, Sentinel *> dash::make_range	(	Iterator *	begin,
		Sentinel *	end
	)

Adapter utility function.

Wraps begin and end pointers in range type.

Definition at line 447 of file Range.h.

References begin(), and end().

                  {
  return dash::IteratorRange<Iterator *, Sentinel *>(
           begin,
           end);
}

make_range() [3/3]

template<class Iterator , class Sentinel >

dash::IteratorRange<Iterator, Sentinel> dash::make_range	(	Iterator &	begin,
		Sentinel &	end
	)

Adapter utility function.

Wraps begin and end iterators in range type.

Definition at line 461 of file Range.h.

References begin(), and end().

                  {
  return dash::IteratorRange<Iterator, Sentinel>(
           begin,
           end);
}

make_team_spec()

template<typename PartitioningTags , typename MappingTags , typename LayoutTags , class SizeSpecType >

TeamSpec<SizeSpecType::ndim::value, typename SizeSpecType::index_type> dash::make_team_spec	(	const SizeSpecType &	sizespec,
		int	n_units,
		typename SizeSpecType::size_type	n_nodes = 0,
		typename SizeSpecType::size_type	n_numa_dom = 0,
		typename SizeSpecType::size_type	n_cores = 0
	)

Parameters

sizespec

Size spec of cartesian space to be distributed by the pattern.

Definition at line 31 of file MakePattern.h.

References ndim(), dash::TeamSpec< MaxDimensions, IndexType >::resize(), and dash::CartesianIndexSpace< MaxDimensions, ROW_MAJOR, IndexType >::size().

Referenced by make_team_spec().

{
  typedef typename SizeSpecType::size_type  extent_t;
  typedef typename SizeSpecType::index_type index_t;

  // Deduce number of dimensions from size spec:
  const dim_t ndim  = SizeSpecType::ndim::value;

  // Default team spec:
  std::array<extent_t, ndim> team_extents{};
  team_extents.fill(1);
  team_extents[1] = n_units;
  dash::TeamSpec<ndim, index_t> teamspec(team_extents);

  DASH_LOG_TRACE("dash::make_team_spec",
                 "step 1 - initial team extents:", team_extents);

  // Check for trivial case first:
  if (ndim == 1) {
    return teamspec;
  }

  auto n_elem_total = sizespec.size();
  // Configure preferable blocking factors:
  std::set<extent_t> blocking;
  if (n_nodes == 1) {
    // blocking by NUMA domains:
    blocking.insert(n_numa_dom);
    team_extents = dash::math::balance_extents(team_extents, blocking);
  } else {
    blocking.insert(n_cores);
  }

  DASH_LOG_TRACE("dash::make_team_spec",
                 "step 2 - team extents after balancing on NUMA domains:",
                 team_extents);
  DASH_LOG_TRACE_VAR("dash::make_team_spec", blocking);
  // Next simple case: Minimal partitioning, i.e. optimizing for minimum
  // number of blocks.
  // In this case, blocking will be minimal with respect to prefered blocking
  // factors:
  if (n_nodes > 1 && (
      PartitioningTags::rectangular ||
       (!MappingTags::diagonal && !MappingTags::neighbor &&
        !MappingTags::multiple))) {
    // Optimize for surface-to-volume ratio:
    DASH_LOG_TRACE("dash::make_team_spec",
                   "- optimizing for minimal number of blocks");
    team_extents = dash::math::balance_extents(team_extents, blocking);
    if (team_extents[0] == n_units) {
      // Could not balance with preferred blocking factors.
      DASH_LOG_TRACE("dash::make_team_spec",
                     "- minimize number of blocks for blocking", blocking);
    }
  }
  DASH_LOG_TRACE("dash::make_team_spec",
                 "step 3 - team extents after minimal partitioning:",
                 team_extents);
  // For minimal partitioning and multiple mapping, the first dimension is
  // partitioned using the smallest possible blocking factor.

  // The smallest factor s.t. team- and data extents are divisible by it:
  extent_t small_factor_found = 0;
  auto team_factors_d0 = dash::math::factorize(team_extents[0]);
  auto team_factors_d1 = dash::math::factorize(team_extents[1]);
  DASH_LOG_TRACE("dash::make_team_spec",
                 "- team extent factors in dim 0:", team_factors_d0);
  DASH_LOG_TRACE("dash::make_team_spec",
                 "- team extent factors in dim 1:", team_factors_d1);
  if (// PartitioningTags::minimal &&
      MappingTags::multiple) {
    DASH_LOG_TRACE("dash::make_team_spec",
                   "optimizing for multiple blocks per unit");
    for (auto small_factor_kv : team_factors_d0) {
      auto small_factor = small_factor_kv.first;
      // Find smallest factor s.t. team- and data extents are divisible by it:
      if (team_extents[0] % small_factor &&
          sizespec.extent(0) % small_factor == 0) {
        team_extents[0] /= small_factor;
        team_extents[1] *= small_factor;
        small_factor_found = small_factor;
        break;
      }
    }
    // No matching factor found in first dimension, try in second dimension:
    if (small_factor_found == 0) {
      for (auto small_factor_kv : team_factors_d1) {
        auto small_factor = small_factor_kv.first;
        if (team_extents[1] % small_factor &&
            sizespec.extent(1) % small_factor == 0) {
          team_extents[1] /= small_factor;
          team_extents[0] *= small_factor;
          small_factor_found = small_factor;
          break;
        }
      }
    }
  }
  DASH_LOG_TRACE("dash::make_team_spec",
                 "- smallest blocking factor:", small_factor_found);
  DASH_LOG_TRACE("dash::make_team_spec",
                 "step 4 - team extents after multiple mapping:",
                 team_extents);

  // Check if the resulting block sizes are within prefered bounds:
  extent_t bulk_min = std::max<extent_t>(
                        dash::util::Config::get<extent_t>(
                          "DASH_BULK_MIN_SIZE_BYTES"),
                        4096);
  if (bulk_min > 0) {
    DASH_LOG_TRACE("dash::make_team_spec",
                   "- optimizing for bulk min size", bulk_min);
    auto team_factors = dash::math::factorize(n_units);
    extent_t block_size = 1;
    for (auto d = 0; d < ndim; ++d) {
      auto block_extent_d = sizespec.extent(d) / team_extents[d];
      block_size *= block_extent_d;
    }
    // TODO: Need sizeof(T) instead of 8:
    if (block_size * 8 < bulk_min && small_factor_found > 0) {
      // Unbalance extents to increase block size:
      auto unbalance_factor = team_factors_d1.begin()->first;
      DASH_LOG_TRACE("dash::make_team_spec",
                     "- unbalancing with factor", unbalance_factor);
      team_extents[0] *= unbalance_factor;
      team_extents[1] /= unbalance_factor;
    }
  }

  DASH_LOG_TRACE("dash::make_team_spec >",
                 "step 5 - team extents after adjusting for bulk min size:",
                 team_extents);

  // Make distribution spec from template- and run time parameters:
  teamspec.resize(team_extents);
  return teamspec;
}

mmult()

template<typename MatrixTypeA , typename MatrixTypeB , typename MatrixTypeC >

void dash::mmult	(	MatrixTypeA &	A,
		MatrixTypeB &	B,
		MatrixTypeC &	C
	)

Function adapter to an implementation of matrix-matrix multiplication (xDGEMM) depending on the matrix distribution patterns.

Delegates dash::mmult<MatrixType> to dash::summa<MatrixType> if MatrixType::pattern_type satisfies the pattern property constraints of the SUMMA implementation.

Parameters

A	Matrix to multiply, extents n x m
B	Matrix to multiply, extents m x p
C	Matrix to contain the multiplication result, extents n x p, initialized with zeros

Referenced by summa().

operator!=() [1/2]

template<class T1 , class T2 >

constexpr bool dash::operator!= ( const Pair< T1, T2 > &  x, const Pair< T1, T2 > &  y  )

inline

Inequality comparison operator implemented in terms of equality operator.

Definition at line 152 of file Pair.h.

  {
    return !(x == y);
  }

operator!=() [2/2]

template<typename IndexType >

static bool dash::operator!= ( const ViewPair< IndexType > &  lhs, const ViewPair< IndexType > &  rhs  )

static

Inequality comparison operator for ViewPair.

Definition at line 406 of file Dimensional.h.

References dash::ViewPair< IndexType >::extent, and dash::ViewPair< IndexType >::offset.

                                   {
  return !(lhs == rhs);
}

operator-()

template<typename ElementType , class Pattern , class GlobMemType , class Pointer , class Reference >

DASH_CONSTEXPR auto dash::operator-	(	const GlobIter< ElementType, Pattern, GlobMemType, Pointer, Reference > &	lhs,
		const GlobIter< ElementType, Pattern, GlobMemType, Pointer, Reference > &	rhs
	)

Parameters

lhs	Global pointer to the initial position in the global sequence
rhs	Global iterator to the final position in the global sequence

Definition at line 147 of file Iterator.h.

Referenced by dash::halo::StencilIteratorTest< CoordsIdxManagerBoundary_t >::operator--(), dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::operator--(), and dash::halo::StencilIterator< Element_t, Pattern_t, typename HaloBlockT::GlobMem_t, StencilSpecT, StencilViewScope::ALL >::operator--().

{
  return lhs.pos() - rhs.pos();
}

operator<()

template<class T1 , class T2 >

constexpr bool dash::operator< ( const Pair< T1, T2 > &  x, const Pair< T1, T2 > &  y  )

inline

A pair is smaller than another pair if the first member is smaller or the first is equal and the second is smaller.

See http://gcc.gnu.org/onlinedocs/libstdc++/manual/utilities.html

Definition at line 140 of file Pair.h.

References dash::Pair< T1, T2 >::first.

Referenced by dash::UnorderedMapGlobIter< Key, Mapped, Hash, Pred, GlobMemType >::operator--(), dash::halo::StencilIteratorTest< CoordsIdxManagerBoundary_t >::operator--(), and dash::halo::StencilIterator< Element_t, Pattern_t, typename HaloBlockT::GlobMem_t, StencilSpecT, StencilViewScope::ALL >::operator--().

  {
    return  x.first < y.first
      || (!(y.first < x.first) && !(x.second >= y.second));
  }

operator<=()

template<class T1 , class T2 >

constexpr bool dash::operator<= ( const Pair< T1, T2 > &  x, const Pair< T1, T2 > &  y  )

inline

Less-than-or-equal operator implemented in terms of less-than operator.

Definition at line 172 of file Pair.h.

Referenced by dash::UnorderedMapGlobIter< Key, Mapped, Hash, Pred, GlobMemType >::operator--(), dash::halo::StencilIteratorTest< CoordsIdxManagerBoundary_t >::operator--(), and dash::halo::StencilIterator< Element_t, Pattern_t, typename HaloBlockT::GlobMem_t, StencilSpecT, StencilViewScope::ALL >::operator--().

  {
    return !(y < x);
  }

operator==() [1/2]

template<class T1 , class T2 >

constexpr bool dash::operator== ( const Pair< T1, T2 > &  x, const Pair< T1, T2 > &  y  )

inline

Two pairs of the same type are equal iff their members are equal.

Definition at line 128 of file Pair.h.

References dash::Pair< T1, T2 >::first, and dash::Pair< T1, T2 >::second.

  {
    return x.first == y.first && x.second == y.second;
  }

operator==() [2/2]

template<typename IndexType >

static bool dash::operator== ( const ViewPair< IndexType > &  lhs, const ViewPair< IndexType > &  rhs  )

static

Equality comparison operator for ViewPair.

Definition at line 391 of file Dimensional.h.

References dash::ViewPair< IndexType >::extent, and dash::ViewPair< IndexType >::offset.

                                   {
  if (&lhs == &rhs) {
    return true;
  }
  return (
    lhs.offset == rhs.offset &&
    lhs.extent == rhs.extent);
}

operator>()

template<class T1 , class T2 >

constexpr bool dash::operator> ( const Pair< T1, T2 > &  x, const Pair< T1, T2 > &  y  )

inline

Greater-than operator implemented in terms of less-than operator.

Definition at line 162 of file Pair.h.

Referenced by dash::UnorderedMapGlobIter< Key, Mapped, Hash, Pred, GlobMemType >::operator--(), dash::halo::StencilIteratorTest< CoordsIdxManagerBoundary_t >::operator--(), and dash::halo::StencilIterator< Element_t, Pattern_t, typename HaloBlockT::GlobMem_t, StencilSpecT, StencilViewScope::ALL >::operator--().

  {
    return y < x;
  }

operator>=()

template<class T1 , class T2 >

constexpr bool dash::operator>= ( const Pair< T1, T2 > &  x, const Pair< T1, T2 > &  y  )

inline

Greater-than-or-equal operator implemented in terms of less-than operator.

Definition at line 182 of file Pair.h.

Referenced by dash::UnorderedMapGlobIter< Key, Mapped, Hash, Pred, GlobMemType >::operator--(), dash::halo::StencilIteratorTest< CoordsIdxManagerBoundary_t >::operator--(), and dash::halo::StencilIterator< Element_t, Pattern_t, typename HaloBlockT::GlobMem_t, StencilSpecT, StencilViewScope::ALL >::operator--().

  {
    return !(x < y);
  }

put_value()

template<typename T , typename GlobPtrType >

void dash::put_value ( const T &  newval, const GlobPtrType &  gptr  )

inline

Write a value to a global pointer.

Calls to this routine are blocking

Parameters

[in]	newval	Value to set
[in]	gptr	Global pointer referencing target address of value

Definition at line 214 of file Onesided.h.

Referenced by dash::GlobHeapMem< ElementType, LocalMemorySpace, AllocationPolicy, LocalAlloc >::put_value().

{
  dash::internal::put_blocking(gptr.dart_gptr(), &newval, 1);
}

put_value_async()

template<typename T , typename GlobPtrType >

void dash::put_value_async ( const T &  newval, const GlobPtrType &  gptr  )

inline

Write a value to a global pointer, non-blocking.

Requires a later fence operation to guarantee local and/or remote completion.

Parameters

[in]	newval	Value to set
[in]	gptr	Global pointer referencing target address of value

Definition at line 180 of file Onesided.h.

{
  dash::internal::put(gptr.dart_gptr(), &newval, 1);
}

summa()

template<typename MatrixTypeA , typename MatrixTypeB , typename MatrixTypeC >

void dash::summa	(	MatrixTypeA &	A,
		MatrixTypeB &	B,
		MatrixTypeC &	C
	)

Multiplies two matrices using the SUMMA algorithm.

Performs (2 * (nunits-1) * nunits^2) async copy operations of submatrices in A and B.

Pseudocode:

C = zeros(n,n) for k = 1:b:n { // k increments in steps of blocksize b u = k:(k+b-1) // u is [k, k+1, ..., k+b-1] C = C + A(:,u) * B(u,:) // Multiply n x b matrix from A with // b x p matrix from B }

Parameters

A	Matrix to multiply, extents n x m
B	Matrix to multiply, extents m x p
C	Matrix to contain the multiplication result, extents n x p, initialized with zeros

Definition at line 151 of file SUMMA.h.

References check_pattern_constraints(), copy(), copy_async(), dash::pattern_mapping_tag::diagonal, dash::pattern_partitioning_tag::minimal, mmult(), and dash::Future< ResultT >::wait().

{
  typedef typename MatrixTypeA::value_type   value_type;
  typedef typename MatrixTypeA::index_type   index_t;
  typedef typename MatrixTypeA::size_type    extent_t;
//typedef typename MatrixTypeA::pattern_type pattern_a_type;
//typedef typename MatrixTypeB::pattern_type pattern_b_type;
//typedef typename MatrixTypeC::pattern_type pattern_c_type;
  typedef std::array<index_t, 2>             coords_t;

  const bool shifted_tiling = dash::pattern_constraints<
                                dash::pattern_partitioning_properties<>,
                                dash::pattern_mapping_properties<
                                  dash::pattern_mapping_tag::diagonal
                                >,
                                dash::pattern_layout_properties<>,
                                typename MatrixTypeC::pattern_type
                              >::satisfied::value;
  const bool minimal_tiling = dash::pattern_constraints<
                                dash::pattern_partitioning_properties<
                                  dash::pattern_partitioning_tag::minimal
                                >,
                                dash::pattern_mapping_properties<>,
                                dash::pattern_layout_properties<>,
                                typename MatrixTypeC::pattern_type
                              >::satisfied::value;

  static_assert(
      std::is_floating_point<value_type>::value,
      "dash::summa expects matrix element type double or float");

  DASH_LOG_DEBUG("dash::summa()");
  // Verify that matrix patterns satisfy pattern constraints:
  if (!dash::check_pattern_constraints<
         summa_pattern_partitioning_constraints,
         summa_pattern_mapping_constraints,
         summa_pattern_layout_constraints
       >(A.pattern())) {
    DASH_THROW(
      dash::exception::InvalidArgument,
      "dash::summa(): "
      "pattern of first matrix argument does not match constraints");
  }
  if (!dash::check_pattern_constraints<
         summa_pattern_partitioning_constraints,
         summa_pattern_mapping_constraints,
         summa_pattern_layout_constraints
       >(B.pattern())) {
    DASH_THROW(
      dash::exception::InvalidArgument,
      "dash::summa(): "
      "pattern of second matrix argument does not match constraints");
  }
  if (!dash::check_pattern_constraints<
         summa_pattern_partitioning_constraints,
         summa_pattern_mapping_constraints,
         summa_pattern_layout_constraints
       >(C.pattern())) {
    DASH_THROW(
      dash::exception::InvalidArgument,
      "dash::summa(): "
      "pattern of result matrix does not match constraints");
  }
  DASH_LOG_TRACE("dash::summa", "matrix pattern properties valid");

  if (shifted_tiling) {
    DASH_LOG_TRACE("dash::summa",
                   "using communication scheme for diagonal-shift mapping");
  }
  if (minimal_tiling) {
    DASH_LOG_TRACE("dash::summa",
                   "using communication scheme for minimal partitioning");
  }
  //    A         B         C
  //  _____     _____     _____
  // |     |   |     |   |     |
  // n     | x m     | = n     |
  // |_ m _|   |_ p _|   |_ p _|
  //
  dash::Team & team = C.team();
  auto unit_id      = team.myid();
  // Check run-time invariants on pattern instances:
  auto pattern_a    = A.pattern();
  auto pattern_b    = B.pattern();
  auto pattern_c    = C.pattern();
  auto m = pattern_a.extent(0); // number of columns in A, rows in B
#if DASH_ENABLE_TRACE_LOGGING
  auto n = pattern_a.extent(1); // number of rows in A and C
  auto p = pattern_b.extent(0); // number of columns in B and C
#endif
  const dash::MemArrange memory_order = pattern_a.memory_order();

  DASH_ASSERT_EQ(
    pattern_a.extent(1),
    pattern_b.extent(0),
    "dash::summa(): "
    "Extents of first operand in dimension 1 do not match extents of "
    "second operand in dimension 0");
  DASH_ASSERT_EQ(
    pattern_c.extent(0),
    pattern_a.extent(0),
    "dash::summa(): "
    "Extents of result matrix in dimension 0 do not match extents of "
    "first operand in dimension 0");
  DASH_ASSERT_EQ(
    pattern_c.extent(1),
    pattern_b.extent(1),
    "dash::summa(): "
    "Extents of result matrix in dimension 1 do not match extents of "
    "second operand in dimension 1");

  DASH_LOG_TRACE("dash::summa", "matrix pattern extents valid");

  // Patterns are balanced, all blocks have identical size:
  auto block_size_m   = pattern_a.block(0).extent(0);
  auto block_size_n   = pattern_b.block(0).extent(1);
  auto block_size_p   = pattern_b.block(0).extent(0);
  auto num_blocks_m   = m / block_size_m;
#if DASH_ENABLE_TRACE_LOGGING
  auto num_blocks_n   = n / block_size_n;
  auto num_blocks_p   = p / block_size_p;
#endif
  // Size of temporary local blocks
  auto block_a_size   = block_size_n * block_size_m;
  auto block_b_size   = block_size_m * block_size_p;
  // Number of units in rows and columns:
  auto teamspec       = C.pattern().teamspec();
  auto unit_ts_coords = teamspec.coords(unit_id);

  DASH_LOG_TRACE("dash::summa", "blocks:",
                 "m:", num_blocks_m, "*", block_size_m,
                 "n:", num_blocks_n, "*", block_size_n,
                 "p:", num_blocks_p, "*", block_size_p);
  DASH_LOG_TRACE("dash::summa",
                 "number of units:",
                 "cols:", teamspec.extent(0),
                 "rows:", teamspec.extent(1),
                 "unit team coords:", unit_ts_coords);
  DASH_LOG_TRACE("dash::summa", "allocating local temporary blocks, sizes:",
                 "A:", block_a_size,
                 "B:", block_b_size);

#ifdef DASH_ENABLE_MKL
  value_type * buf_block_a_get    = (value_type *)(mkl_malloc(
                                      sizeof(value_type) * block_a_size, 64));
  value_type * buf_block_b_get    = (value_type *)(mkl_malloc(
                                      sizeof(value_type) * block_b_size, 64));
  value_type * buf_block_a_comp   = (value_type *)(mkl_malloc(
                                      sizeof(value_type) * block_a_size, 64));
  value_type * buf_block_b_comp   = (value_type *)(mkl_malloc(
                                      sizeof(value_type) * block_b_size, 64));
#else
  auto *buf_block_a_get  = new value_type[block_a_size];
  auto *buf_block_b_get  = new value_type[block_b_size];
  auto *buf_block_a_comp = new value_type[block_a_size];
  auto *buf_block_b_comp = new value_type[block_b_size];
#endif
  // Copy of buffer pointers for swapping, delete[] on swapped pointers tends
  // to crash:
  value_type * local_block_a_get      = buf_block_a_get;
  value_type * local_block_b_get      = buf_block_b_get;
  value_type * local_block_a_comp     = buf_block_a_comp;
  value_type * local_block_b_comp     = buf_block_b_comp;
  value_type * local_block_a_get_bac  = nullptr;
  value_type * local_block_b_get_bac  = nullptr;
  value_type * local_block_a_comp_bac = nullptr;
  value_type * local_block_b_comp_bac = nullptr;
  // -------------------------------------------------------------------------
  // Prefetch blocks from A and B for first local multiplication:
  // -------------------------------------------------------------------------
  // Block coordinates of submatrices of A and B to be prefetched:
  // Local block index of local submatrix of C for multiplication result of
  // blocks to be prefetched:
  auto     l_block_c_get       = C.local.block(0);
  auto     l_block_c_get_view  = l_block_c_get.begin().viewspec();
  index_t  l_block_c_get_row   = l_block_c_get_view.offset(1) / block_size_n;
  index_t  l_block_c_get_col   = l_block_c_get_view.offset(0) / block_size_p;
  // Block coordinates of blocks in A and B to prefetch:
  coords_t block_a_get_coords = coords_t {{ static_cast<index_t>(unit_ts_coords[0]),
           l_block_c_get_row }};
  coords_t block_b_get_coords = coords_t {{ l_block_c_get_col,
           static_cast<index_t>(unit_ts_coords[0]) }};
  // Local block index of local submatrix of C for multiplication result of
  // currently prefetched blocks:
  auto     l_block_c_comp      = l_block_c_get;
  auto     l_block_c_comp_view = l_block_c_comp.begin().viewspec();
  index_t  l_block_c_comp_row  = l_block_c_comp_view.offset(1) / block_size_n;
  index_t  l_block_c_comp_col  = l_block_c_comp_view.offset(0) / block_size_p;
  // Prefetch blocks from A and B for computation in next iteration:
  dash::Future<value_type *> get_a;
  dash::Future<value_type *> get_b;
  auto block_a      = A.block(block_a_get_coords);
  auto block_a_lptr = block_a.begin().local();
  auto block_b      = B.block(block_b_get_coords);
  auto block_b_lptr = block_b.begin().local();
  DASH_LOG_TRACE("dash::summa", "summa.prefetch.block.a",
                 "block:", block_a_get_coords,
                 "local:", block_a_lptr != nullptr,
                 "unit:",  block_a.begin().lpos().unit,
                 "view:",  block_a.begin().viewspec());

  dash::util::Trace trace("SUMMA");

  trace.enter_state("prefetch");
  if (block_a_lptr == nullptr) {
#ifdef DASH_ALGORITHM_SUMMA_ASYNC_INIT_PREFETCH
    get_a = dash::copy_async(block_a.begin(), block_a.end(),
                             local_block_a_comp);
#else
    dash::copy(block_a.begin(), block_a.end(),
               local_block_a_comp);
    get_a = dash::Future<value_type *>(
              [=]() { return local_block_a_comp + block_a.size(); });
#endif
  } else {
    local_block_a_comp_bac = local_block_a_comp;
    local_block_a_comp     = block_a_lptr;
  }

  DASH_LOG_TRACE("dash::summa", "summa.prefetch.block.b",
                 "block:", block_b_get_coords,
                 "local:", block_b_lptr != nullptr,
                 "unit:",  block_b.begin().lpos().unit,
                 "view:",  block_b.begin().viewspec());
  if (block_b_lptr == nullptr) {
#ifdef DASH_ALGORITHM_SUMMA_ASYNC_INIT_PREFETCH
    get_b = dash::copy_async(block_b.begin(), block_b.end(),
                             local_block_b_comp);
#else
    dash::copy(block_b.begin(), block_b.end(),
               local_block_b_comp);
    get_b = dash::Future<value_type *>(
              [=]() { return local_block_b_comp + block_b.size(); });
#endif
  } else {
    local_block_b_comp_bac = local_block_b_comp;
    local_block_b_comp     = block_b_lptr;
  }
#ifdef DASH_ALGORITHM_SUMMA_ASYNC_INIT_PREFETCH
  if (block_a_lptr == nullptr) {
    DASH_LOG_TRACE("dash::summa", "summa.prefetch.block.a.wait",
                   "waiting for prefetching of block A from unit",
                   block_a.begin().lpos().unit);
    get_a.wait();
  }
  if (block_b_lptr == nullptr) {
    DASH_LOG_TRACE("dash::summa", "summa.prefetch.block.b.wait",
                   "waiting for prefetching of block B from unit",
                   block_b.begin().lpos().unit);
    get_b.wait();
  }
#endif
  trace.exit_state("prefetch");

  DASH_LOG_TRACE("dash::summa", "summa.block",
                 "prefetching of blocks completed");
  // -------------------------------------------------------------------------
  // Iterate local blocks in matrix C:
  // -------------------------------------------------------------------------
  extent_t num_local_blocks_c = pattern_c.local_blockspec().size();

  DASH_LOG_TRACE("dash::summa", "summa.block.C",
                 "C.num.local.blocks:",  num_local_blocks_c,
                 "C.num.column.blocks:", num_blocks_m);

  for (extent_t lb = 0; lb < num_local_blocks_c; ++lb) {
    // Block coordinates for current block multiplication result:
    l_block_c_comp      = C.local.block(lb);
    l_block_c_comp_view = l_block_c_comp.begin().viewspec();
    l_block_c_comp_row  = l_block_c_comp_view.offset(1) / block_size_n;
    l_block_c_comp_col  = l_block_c_comp_view.offset(0) / block_size_p;
    // Block coordinates for next block multiplication result:
    l_block_c_get       = l_block_c_comp;
    l_block_c_get_view  = l_block_c_comp_view;
    l_block_c_get_row   = l_block_c_get_row;
    l_block_c_get_col   = l_block_c_get_col;
    DASH_LOG_TRACE("dash::summa", "summa.block.comp", "C.local.block",
                   "l_block_idx:", lb,
                   "row:",         l_block_c_comp_row,
                   "col:",         l_block_c_comp_col,
                   "view:",        l_block_c_comp_view);
    // -----------------------------------------------------------------------
    // Iterate blocks in columns of A / rows of B:
    // -----------------------------------------------------------------------
    for (extent_t block_k = 0; block_k < num_blocks_m; ++block_k) {
      DASH_LOG_TRACE("dash::summa", "summa.block.k", block_k,
                     "active local block in C:", lb);

      // ---------------------------------------------------------------------
      // Prefetch local copy of blocks from A and B for multiplication in
      // next iteration.
      // ---------------------------------------------------------------------
      bool last = (lb == num_local_blocks_c - 1) &&
                  (block_k == num_blocks_m - 1);
      // Do not prefetch blocks in last iteration:
      if (!last) {
        auto block_get_k = static_cast<index_t>(block_k + 1);
        block_get_k = (block_get_k + unit_ts_coords[0]) % num_blocks_m;
        // Block coordinate of local block in matrix C to prefetch:
        if (block_k == num_blocks_m - 1) {
          // Prefetch for next local block in matrix C:
          block_get_k        = unit_ts_coords[0];
          l_block_c_get      = C.local.block(lb + 1);
          l_block_c_get_view = l_block_c_get.begin().viewspec();
          l_block_c_get_row  = l_block_c_get_view.offset(1) / block_size_n;
          l_block_c_get_col  = l_block_c_get_view.offset(0) / block_size_p;
        }
        // Block coordinates of blocks in A and B to prefetch:
        block_a_get_coords = coords_t {{ block_get_k, l_block_c_get_row }};
        block_b_get_coords = coords_t {{ l_block_c_get_col, block_get_k }};

        block_a      = A.block(block_a_get_coords);
        block_a_lptr = block_a.begin().local();
        block_b      = B.block(block_b_get_coords);
        block_b_lptr = block_b.begin().local();
        DASH_LOG_TRACE("dash::summa", "summa.prefetch.block.a",
                       "block:", block_a_get_coords,
                       "local:", block_a_lptr != nullptr,
                       "unit:",  block_a.begin().lpos().unit,
                       "view:",  block_a.begin().viewspec());
        if (block_a_lptr == nullptr) {
          get_a = dash::copy_async(block_a.begin(),
                                   block_a.end(),
                                   local_block_a_get);
          local_block_a_get_bac = nullptr;
        } else {
          local_block_a_get_bac = local_block_a_get;
          local_block_a_get     = block_a_lptr;
        }
        DASH_LOG_TRACE("dash::summa", "summa.prefetch.block.b",
                       "block:", block_b_get_coords,
                       "local:", block_b_lptr != nullptr,
                       "unit:",  block_b.begin().lpos().unit,
                       "view:",  block_b.begin().viewspec());
        if (block_b_lptr == nullptr) {
          get_b = dash::copy_async(block_b.begin(),
                                   block_b.end(),
                                   local_block_b_get);
          local_block_b_get_bac = nullptr;
        } else {
          local_block_b_get_bac = local_block_b_get;
          local_block_b_get     = block_b_lptr;
        }
      } else {
        DASH_LOG_TRACE("dash::summa", " ->",
                       "last block multiplication",
                       "lb:", lb, "bk:", block_k);
      }
      // ---------------------------------------------------------------------
      // Computation of matrix product of local block matrices:
      // ---------------------------------------------------------------------
      DASH_LOG_TRACE("dash::summa", "summa.block.comp.multiply",
                     "multiplying local block matrices",
                     "C.local.block.comp:", lb,
                     "view:", l_block_c_comp.begin().viewspec());

      trace.enter_state("multiply");
      dash::internal::mmult_local<value_type>(
          local_block_a_comp,
          local_block_b_comp,
          l_block_c_comp.begin().local(),
          block_size_m,
          block_size_n,
          block_size_p,
          memory_order);
      trace.exit_state("multiply");

      if (local_block_a_comp_bac != nullptr) {
        local_block_a_comp     = local_block_a_comp_bac;
        local_block_a_comp_bac = nullptr;
      }
      if (local_block_b_comp_bac != nullptr) {
        local_block_b_comp     = local_block_b_comp_bac;
        local_block_b_comp_bac = nullptr;
      }
      if (!last) {
        // -------------------------------------------------------------------
        // Wait for local copies:
        // -------------------------------------------------------------------
        trace.enter_state("prefetch");
        if (block_a_lptr == nullptr) {
          DASH_LOG_TRACE("dash::summa", "summa.prefetch.block.a.wait",
                         "waiting for prefetching of block A from unit",
                         block_a.begin().lpos().unit);
          get_a.wait();
        }
        if (block_b_lptr == nullptr) {
          DASH_LOG_TRACE("dash::summa", "summa.prefetch.block.b.wait",
                         "waiting for prefetching of block B from unit",
                         block_b.begin().lpos().unit);
          get_b.wait();
        }
        DASH_LOG_TRACE("dash::summa", "summa.prefetch.completed",
                       "local copies of next blocks received");
        trace.exit_state("prefetch");

        // -----------------------------------------------------------------
        // Swap communication and computation buffers:
        // -----------------------------------------------------------------
        std::swap(local_block_a_get, local_block_a_comp);
        std::swap(local_block_b_get, local_block_b_comp);
        if (local_block_a_get_bac != nullptr) {
          local_block_a_comp_bac = local_block_a_get_bac;
          local_block_a_get_bac  = nullptr;
        }
        if (local_block_b_get_bac != nullptr) {
          local_block_b_comp_bac = local_block_b_get_bac;
          local_block_b_get_bac  = nullptr;
        }
      }
    }
  } // for lb

  DASH_LOG_TRACE("dash::summa", "locally completed");
#ifdef DASH_ENABLE_MKL
  mkl_free(buf_block_a_get);
  mkl_free(buf_block_b_get);
  mkl_free(buf_block_a_comp);
  mkl_free(buf_block_b_comp);
#else
  delete[] buf_block_a_get;
  delete[] buf_block_b_get;
  delete[] buf_block_a_comp;
  delete[] buf_block_b_comp;
#endif

  DASH_LOG_TRACE("dash::summa", "waiting for other units");
  trace.enter_state("barrier");
  C.barrier();
  trace.exit_state("barrier");

  DASH_LOG_TRACE("dash::summa >", "finished");
}

swap() [1/2]

template<class T1 , class T2 >

void dash::swap ( Pair< T1, T2 > &  x, Pair< T1, T2 > &  y  )

inlinenoexcept

Wrapper for Pair::swap.

Definition at line 192 of file Pair.h.

  {
    x.swap(y);
  }

swap() [2/2]

template<typename T >

void dash::swap ( dash::GlobRef< T > &&  a, dash::GlobRef< T > &&  b  )

inline

specialization for unqualified calls to swap

Definition at line 424 of file GlobRef.h.

Referenced by dash::Coarray< T, IndexType, Arrangement, LocalMemSpaceT >::Coarray(), and dash::GlobSharedRef< T, GlobalPointerType >::operator=().

                                                          {
  a.swap(b);
}

typestr() [1/2]

template<class T >

std::string dash::typestr

(

const T &

obj

)

Returns string containing the type name of the given object.

Similar to the typeid operator but ensures human-readable, demangled format.

Definition at line 20 of file TypeInfo.h.

Referenced by dash::Atomic< T >::Atomic(), dash::LocalMemoryLayout< NumDimensions, Arrangement, IndexType >::coords(), make_pair(), and dash::GlobRef< T >::swap().

                                 {
  return dash::internal::demangle(
           typeid(obj).name()
         );
}

typestr() [2/2]

template<class T >

std::string dash::typestr

(

)

Returns string containing the name of the specified type.

Similar to the typeid operator but ensures human-readable, demangled format.

Definition at line 33 of file TypeInfo.h.

                    {
  return dash::internal::demangle(
           typeid(T).name()
         );
}

Variable Documentation

const

struct dash::dart_operation const ValueType& rhs dash::const

Initial value:

{
    return (lhs < rhs) ? lhs : rhs

Definition at line 131 of file Operation.h.

UNDEFINED_GLOBAL_UNIT_ID

constexpr global_unit_t dash::UNDEFINED_GLOBAL_UNIT_ID { ((dart_unit_t)(-1)) }

Invalid global unit ID.

This is a typed version of DART_UNDEFINED_UNIT_ID.

Definition at line 348 of file Types.h.

UNDEFINED_TEAM_UNIT_ID

constexpr team_unit_t dash::UNDEFINED_TEAM_UNIT_ID { ((dart_unit_t)(-1)) }

Invalid local unit ID.

This is a typed version of DART_UNDEFINED_UNIT_ID.

Definition at line 341 of file Types.h.

Referenced by dash::Team::global_id(), dash::SeqTilePattern< NumDimensions, Arrangement, IndexType >::ndim(), dash::TeamSpec< NumDimensions, IndexType >::neighbor(), and dash::TilePattern< NumDimensions, Arrangement, IndexType >::underfilled_blocksize().