An array is a multi-dimensional data aggregate on a accelerator_view. More...

#include <amp.h>

Public Types
typedef _Value_type	value_type

Public Member Functions
	array (const Concurrency::extent< _Rank > &_Extent) __CPU_ONLY
	Construct an array from extents More...

	array (int _E0) __CPU_ONLY
	Construct array<T,1> with the extent _E0 More...

	array (int _E0, int _E1) __CPU_ONLY
	Construct an array<T,2> from two integer extents. More...

	array (int _E0, int _E1, int _E2) __CPU_ONLY
	Construct an array<T,3> from three integer extents. More...

	array (const Concurrency::extent< _Rank > &_Extent, Concurrency::accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct an array from extents, bound to a specific accelerator_view. More...

	array (int _E0, Concurrency::accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct array<T,1> with the extent _E0, bound to a specific accelerator_view. More...

	array (int _E0, int _E1, Concurrency::accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct an array<T,2> from two integer extents, bound to a specific accelerator_view. More...

	array (int _E0, int _E1, int _E2, Concurrency::accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct an array<T,3> from three integer extents, bound to a specific accelerator_view. More...

	array (const Concurrency::extent< _Rank > &_Extent, Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av) __CPU_ONLY
	Construct a staging array between two associated accelerator_view. More...

	array (int _E0, accelerator_view _Av, Concurrency::accelerator_view _Associated_Av) __CPU_ONLY
	Construct a staging array between two associated accelerator_view. More...

	array (int _E0, int _E1, Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av) __CPU_ONLY
	Construct a staging array between two associated accelerator_view. More...

	array (int _E0, int _E1, int _E2, Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av) __CPU_ONLY
	Construct a staging array between two associated accelerator_view. More...

template<typename _InputIterator >
	array (const Concurrency::extent< _Rank > &_Extent, _InputIterator _Src_first, _InputIterator _Src_last) __CPU_ONLY
	Construct an array initialized from a pair of iterators into a container. More...

template<typename _InputIterator >
	array (const Concurrency::extent< _Rank > &_Extent, _InputIterator _Src_first) __CPU_ONLY
	Construct an array initialized from an iterator. More...

template<typename _InputIterator >
	array (int _E0, _InputIterator _Src_first, _InputIterator _Src_last) __CPU_ONLY
	Construct an array initialized from a pair of iterators into a container. More...

template<typename _InputIterator >
	array (int _E0, _InputIterator _Src_first) __CPU_ONLY
	Construct an array initialized from an iterator. More...

template<typename _InputIterator >
	array (int _E0, int _E1, _InputIterator _Src_first, _InputIterator _Src_last) __CPU_ONLY
	Construct an array initialized from a pair of iterators into a container. More...

template<typename _InputIterator >
	array (int _E0, int _E1, _InputIterator _Src_first) __CPU_ONLY
	Construct an array initialized from an iterator. More...

template<typename _InputIterator >
	array (int _E0, int _E1, int _E2, _InputIterator _Src_first, _InputIterator _Src_last) __CPU_ONLY
	Construct an array initialized from an iterator. More...

template<typename _InputIterator >
	array (int _E0, int _E1, int _E2, _InputIterator _Src_first) __CPU_ONLY
	Construct an array initialized from an iterator. More...

template<typename _InputIterator >
	array (const Concurrency::extent< _Rank > &_Extent, _InputIterator _Src_first, _InputIterator _Src_last, Concurrency::accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct an array initialized from a pair of iterators into a container, bound to a specific accelerator_view. More...

template<typename _InputIterator >
	array (const Concurrency::extent< _Rank > &_Extent, _InputIterator _Src_first, Concurrency::accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct an array initialized from an iterator into a container, bound to a specific accelerator_view. More...

template<typename _InputIterator >
	array (int _E0, _InputIterator _Src_first, _InputIterator _Src_last, Concurrency::accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct an array initialized from a pair of iterators into a container, bound to a specific accelerator_view. More...

template<typename _InputIterator >
	array (int _E0, _InputIterator _Src_first, Concurrency::accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct an array initialized from an iterator into a container, bound to a specific accelerator_view. More...

template<typename _InputIterator >
	array (int _E0, int _E1, _InputIterator _Src_first, _InputIterator _Src_last, Concurrency::accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct an array initialized from a pair of iterators into a container, bound to a specific accelerator_view. More...

template<typename _InputIterator >
	array (int _E0, int _E1, _InputIterator _Src_first, Concurrency::accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct an array initialized from an iterator into a container, bound to a specific accelerator_view. More...

template<typename _InputIterator >
	array (int _E0, int _E1, int _E2, _InputIterator _Src_first, _InputIterator _Src_last, Concurrency::accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct an array initialized from a pair of iterators into a container, bound to a specific accelerator_view. More...

template<typename _InputIterator >
	array (int _E0, int _E1, int _E2, _InputIterator _Src_first, Concurrency::accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct an array initialized from an iterator into a container, bound to a specific accelerator_view. More...

template<typename _InputIterator >
	array (const Concurrency::extent< _Rank > &_Extent, _InputIterator _Src_first, _InputIterator _Src_last, Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av) __CPU_ONLY
	Construct a staging array between two associated accelerator_view, initialized from a pair of iterators into a container. More...

template<typename _InputIterator >
	array (const Concurrency::extent< _Rank > &_Extent, _InputIterator _Src_first, Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av) __CPU_ONLY
	Construct a staging array between two associated accelerator_view, initialized from an iterator into a container. More...

template<typename _InputIterator >
	array (int _E0, _InputIterator _Src_first, _InputIterator _Src_last, Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av) __CPU_ONLY
	Construct a staging array between two associated accelerator_view, initialized from a pair of iterators into a container. More...

template<typename _InputIterator >
	array (int _E0, _InputIterator _Src_first, Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av)
	Construct a staging array between two associated accelerator_view, initialized from an iterator into a container. More...

template<typename _InputIterator >
	array (int _E0, int _E1, _InputIterator _Src_first, _InputIterator _Src_last, Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av) __CPU_ONLY
	Construct a staging array between two associated accelerator_view, initialized from a pair of iterators into a container. More...

template<typename _InputIterator >
	array (int _E0, int _E1, _InputIterator _Src_first, Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av) __CPU_ONLY
	Construct a staging array between two associated accelerator_view, initialized from an iterator into a container. More...

template<typename _InputIterator >
	array (int _E0, int _E1, int _E2, _InputIterator _Src_first, _InputIterator _Src_last, Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av) __CPU_ONLY
	Construct a staging array between two associated accelerator_view, initialized from a pair of iterators into a container. More...

template<typename _InputIterator >
	array (int _E0, int _E1, int _E2, _InputIterator _Src_first, Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av) __CPU_ONLY
	Construct a staging array between two associated accelerator_view, initialized from an iterator into a container. More...

	array (const array_view< const _Value_type, _Rank > &_Src) __CPU_ONLY
	Construct an array initialized from an array_view. More...

	array (const array_view< const _Value_type, _Rank > &_Src, accelerator_view _Av, access_type _Cpu_access_type=access_type_auto) __CPU_ONLY
	Construct an array initialized from an array_view, bound to a specific accelerator_view. More...

	array (const array_view< const _Value_type, _Rank > &_Src, accelerator_view _Av, accelerator_view _Associated_Av) __CPU_ONLY
	Construct a staging array between two associated accelerator_views, initialized from an array_view. More...

	array (const array &_Other) __CPU_ONLY
	Copy constructor. Deep copy. More...

	array (array &&_Other) __CPU_ONLY
	Move constructor. More...

array &	operator= (const array &_Other) __CPU_ONLY
	Copy Assignment operator. Deep copy. More...

array &	operator= (array &&_Other) __CPU_ONLY
	Move Assignment operator. More...

array &	operator= (const array_view< const _Value_type, _Rank > &_Src) __CPU_ONLY
	Assignment operator from an array_view More...

void	copy_to (array< _Value_type, _Rank > &_Dest) const __CPU_ONLY
	Copies elements from this array to the destination array. More...

void	copy_to (const array_view< _Value_type, _Rank > &_Dest) const __CPU_ONLY
	Copies elements from this array to the destination array_view. More...

__declspec(property(get=get_extent)) Concurrency Concurrency::extent< _Rank >	get_extent () const __GPU
	Returns the extent that defines the shape of this array. More...

__declspec(property(get=get_accelerator_view)) Concurrency Concurrency::accelerator_view	get_accelerator_view () const __CPU_ONLY
	Returns the accelerator_view where this array is located. More...

__declspec(property(get=get_associated_accelerator_view)) Concurrency Concurrency::accelerator_view	get_associated_accelerator_view () const __CPU_ONLY
	Returns the accelerator_view that is the preferred target where this array can be copied. More...

	__declspec (property(get=get_cpu_access_type)) access_type cpu_access_type
	Returns the CPU access_type allowed for this array. More...

access_type	get_cpu_access_type () const __CPU_ONLY

_Value_type &	operator[] (const index< _Rank > &_Index) __GPU
	Get the element value indexed by _I More...

const _Value_type &	operator[] (const index< _Rank > &_Index) const __GPU
	Get the element value indexed by _I More...

details::_Projection_result_type< _Value_type, _Rank >::_Result_type	operator[] (int _I) __GPU
	Projects the most-significant dimension of this array. If the array rank is 1, this produces a single element; otherwise it produces an array_view with one fewer dimensions. More...

details::_Projection_result_type< _Value_type, _Rank >::_Const_result_type	operator[] (int _I) const __GPU
	Projects the most-significant dimension of this array. If the array rank is 1, this produces a single element; otherwise it produces an array_view with one fewer dimensions. More...

_Value_type &	operator() (const index< _Rank > &_Index) __GPU
	Get the element value indexed by _I More...

const _Value_type &	operator() (const index< _Rank > &_Index) const __GPU
	Get the element value indexed by _Index More...

_Value_type &	operator() (int _I0, int _I1) __GPU
	Get the element value indexed by (_I0,_I1) More...

const _Value_type &	operator() (int _I0, int _I1) const __GPU
	Get the element value indexed by (_I0,_I1) More...

_Value_type &	operator() (int _I0, int _I1, int _I2) __GPU
	Get the element value indexed by (_I0,_I1,_I2) More...

const _Value_type &	operator() (int _I0, int _I1, int _I2) const __GPU
	Get the element value indexed by (_I0,_I1,_I2) More...

details::_Projection_result_type< _Value_type, _Rank >::_Result_type	operator() (int _I) __GPU
	Projects the most-significant dimension of this array. If the array rank is 1, this produces a single element; otherwise it produces an array_view with one fewer dimensions. More...

details::_Projection_result_type< _Value_type, _Rank >::_Const_result_type	operator() (int _I) const __GPU
	Projects the most-significant dimension of this array. If the array rank is 1, this produces a single element; otherwise it produces an array_view with one fewer dimensions. More...

array_view< _Value_type, _Rank >	section (const Concurrency::index< _Rank > &_Section_origin, const Concurrency::extent< _Rank > &_Section_extent) __GPU
	Produces a subsection of the source array at the given origin and extent. More...

array_view< const _Value_type, _Rank >	section (const Concurrency::index< _Rank > &_Section_origin, const Concurrency::extent< _Rank > &_Section_extent) const __GPU
	Produces a subsection of the source array at the given origin and extent. More...

array_view< _Value_type, _Rank >	section (const Concurrency::extent< _Rank > &_Ext) __GPU
	Produces a subsection of the source array_view with origin of zero, with an extent of _Ext. More...

array_view< const _Value_type, _Rank >	section (const Concurrency::extent< _Rank > &_Ext) const __GPU
	Produces a subsection of the source array_view with origin of zero, with an extent of _Ext. More...

array_view< _Value_type, _Rank >	section (const index< _Rank > &_Idx) __GPU
	Produces a subsection of the source array with origin specified by an index, with an extent of (this->exent - _Idx). More...

array_view< const _Value_type, _Rank >	section (const index< _Rank > &_Idx) const __GPU
	Produces a subsection of the source array with origin specified by an index, with an extent of (this->exent - _Idx). More...

array_view< _Value_type, 1 >	section (int _I0, int _E0) __GPU
	Produces a one-dimensional subsection of the source array with origin specified by the index components _I0, with extent _E0. More...

array_view< const _Value_type, 1 >	section (int _I0, int _E0) const __GPU
	Produces a one-dimensional subsection of the source array with origin specified by the index components _I0, with extent _E0. More...

array_view< _Value_type, 2 >	section (int _I0, int _I1, int _E0, int _E1) __GPU
	Produces a two-dimensional subsection of the source array with origin specified by the index components (_I0,_I1), with extent (_E0,_E1). More...

array_view< const _Value_type, 2 >	section (int _I0, int _I1, int _E0, int _E1) const __GPU
	Produces a two-dimensional subsection of the source array with origin specified by the index components (_I0,_I1), with extent (_E0,_E1). More...

array_view< _Value_type, 3 >	section (int _I0, int _I1, int _I2, int _E0, int _E1, int _E2) __GPU
	Produces a three-dimensional subsection of the source array with origin specified by the index components (_I0,_I1,_I2), with extent (_E0,_E1,_E2). More...

array_view< const _Value_type, 3 >	section (int _I0, int _I1, int _I2, int _E0, int _E1, int _E2) const __GPU
	Produces a three-dimensional subsection of the source array with origin specified by the index components (_I0,_I1,_I2), with extent (_E0,_E1,_E2). More...

template<typename _Value_type2 >
array_view< _Value_type2, 1 >	reinterpret_as () __GPU
	Produces a (possibly unsafe) reinterpretation of this array that is linear and with a different element type. More...

template<typename _Value_type2 >
array_view< const _Value_type2, 1 >	reinterpret_as () const __GPU
	Produces a (possibly unsafe) reinterpretation of this array that is linear and with a different element type. More...

template<int _New_rank>
array_view< _Value_type, _New_rank >	view_as (const Concurrency::extent< _New_rank > &_View_extent) __GPU
	Produces an array_view of a different rank over this array's data. More...

template<int _New_rank>
array_view< const _Value_type, _New_rank >	view_as (const Concurrency::extent< _New_rank > &_View_extent) const __GPU
	Produces an array_view of a different rank over this array's data. More...

	operator std::vector< _Value_type > () const __CPU_ONLY
	Implicitly converts this array into a vector by copying. More...

_Ret_ _Value_type *	data () __GPU
	Returns a pointer to the raw data of this array. More...

const _Value_type *	data () const __GPU
	Returns a pointer to the raw data of this array. More...

	~array () __CPU_ONLY noexcept(false)
	Destroys this array and reclaims resources. More...

Static Public Attributes
static const int	rank = _Rank

Private Types
typedef details::_Buffer_descriptor	_Buffer_descriptor

typedef _Array_flatten_helper< _Rank, typename Concurrency::extent< _Rank >::value_type, typename Concurrency::index< _Rank >::value_type >	_Flatten_helper

Private Member Functions
	_CPP_AMP_VERIFY_RANK (_Rank, array)

	array () __CPU_ONLY

	array (const Concurrency::extent< _Rank > &_Extent, _Buffer_descriptor _Buffer_descriptor)

unsigned int	_Initialize () __CPU_ONLY

void	_Initialize (Concurrency::accelerator_view _Av, access_type _Cpu_access_type) __CPU_ONLY

template<typename _InputIterator >
void	_Initialize (Concurrency::accelerator_view _Av, _InputIterator _Src_first, _InputIterator _Src_last, access_type _Cpu_access_type) __CPU_ONLY

void	_Initialize (Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av) __CPU_ONLY

template<typename _InputIterator >
void	_Initialize (Concurrency::accelerator_view _Av, Concurrency::accelerator_view _Associated_Av, _InputIterator _Src_first, _InputIterator _Src_last) __CPU_ONLY

void	_Register () __CPU_ONLY

void	_Register_copy (const array &_Other) __CPU_ONLY

void	_Unregister () __CPU_ONLY

_Ret_ _Ubiquitous_buffer *	_Get_buffer () const __CPU_ONLY

_Event	_Get_access_async (_Access_mode _Mode, _Buffer_ptr &_Buf_ptr, bool _Zero_copy_cpu_access=false) const __CPU_ONLY

_Ret_ _View_shape *	_Create_buffer_view_shape () const

bool	_Has_cpu_access () const __CPU_ONLY

void	_Refresh_data_ptr (_Access_mode _Requested_mode, bool _Exception=true) __CPU_ONLY

void	_Refresh_data_ptr (_Access_mode, bool=true) __GPU_ONLY

Private Attributes
Concurrency::extent< _Rank >	_M_extent

_Buffer_descriptor	_M_buffer_descriptor

Concurrency::extent< _Rank >	_M_multiplier

Friends
template<typename _Value_type , int _Rank>
array< _Value_type, _Rank >	direct3d::make_array (const Concurrency::extent< _Rank > &_Extent, const Concurrency::accelerator_view &_Av, _In_ IUnknown *_D3D_buffer) __CPU_ONLY

const _Buffer_descriptor &	details::_Get_buffer_descriptor (const array< _Value_type, _Rank > &_Array) __GPU

_Ret_ _Ubiquitous_buffer *	details::_Get_buffer (const array< _Value_type, _Rank > &_Array) __CPU_ONLY

_Event	details::_Get_access_async (const array< _Value_type, _Rank > &_Array, _Access_mode _Mode, _Buffer_ptr &_Buf_ptr) __CPU_ONLY

Detailed Description

template<typename _Value_type, int _Rank = 1>
class Concurrency::array< _Value_type, _Rank >

An array is a multi-dimensional data aggregate on a accelerator_view.

Parameters

_Rank	The dimensionality of this array.
_Value_type	The type of the elements in the array.

Member Typedef Documentation

template<typename _Value_type, int _Rank = 1>

typedef details::_Buffer_descriptor Concurrency::array< _Value_type, _Rank >::_Buffer_descriptor

private

template<typename _Value_type, int _Rank = 1>

typedef _Array_flatten_helper<_Rank, typename Concurrency::extent<_Rank>::value_type, typename Concurrency::index<_Rank>::value_type> Concurrency::array< _Value_type, _Rank >::_Flatten_helper

private

template<typename _Value_type, int _Rank = 1>

typedef _Value_type Concurrency::array< _Value_type, _Rank >::value_type

Constructor & Destructor Documentation

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array ( const Concurrency::extent< _Rank > & _Extent )

inlineexplicit

Construct an array from extents

Parameters

_Extent An extent that describes the shape of the array.

         : _M_extent(_Extent)
     {                        
         _Initialize(details::_Select_default_accelerator().default_view, access_type_auto);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array ( int _E0 )

inlineexplicit

Construct array<T,1> with the extent _E0

Parameters

_E0	An integer that is the length of this array.

         : _M_extent(Concurrency::extent<_Rank>(_E0))
     {                        
         static_assert(_Rank == 1, "array(int) is only permissible on array<T, 1>");
         _Initialize(details::_Select_default_accelerator().default_view, access_type_auto);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1
	)

inlineexplicit

Construct an array<T,2> from two integer extents.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the least-significant dimension of this array.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1))
     {                        
         static_assert(_Rank == 2, "array(int, int) is only permissible on array<T, 2>");
         _Initialize(details::_Select_default_accelerator().default_view, access_type_auto);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		int	_E2
	)

inlineexplicit

Construct an array<T,3> from three integer extents.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the next-to-most-significant dimension of this array.
_E2	An integer that is the length of the least-significant dimension of this array.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {                        
         static_assert(_Rank == 3, "array(int, int, int) is only permissible on array<T, 3>");
         _Initialize(details::_Select_default_accelerator().default_view, access_type_auto);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	const Concurrency::extent< _Rank > &	_Extent,
		Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct an array from extents, bound to a specific accelerator_view.

Parameters

_Extent	An extent that describes the shape of the array.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         : _M_extent(_Extent)
     {                        
         _Initialize(_Av, _Cpu_access_type);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct array<T,1> with the extent _E0, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of this array.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         : _M_extent(Concurrency::extent<_Rank>(_E0))
     {                        
         static_assert(_Rank == 1, "array(int, accelerator_view) is only permissible on array<T, 1>");
         _Initialize(_Av, _Cpu_access_type);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct an array<T,2> from two integer extents, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the least-significant dimension of this array.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1))
     {                        
         static_assert(_Rank == 2, "array(int, int, accelerator_view) is only permissible on array<T, 2>");
         _Initialize(_Av, _Cpu_access_type);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		int	_E2,
		Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct an array<T,3> from three integer extents, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the next-to-most-significant dimension of this array.
_E2	An integer that is the length of the least-significant dimension of this array.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {                        
         static_assert(_Rank == 3, "array(int, int, int, accelerator_view) is only permissible on array<T, 3>");
         _Initialize(_Av, _Cpu_access_type);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	const Concurrency::extent< _Rank > &	_Extent,
		Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_view.

Parameters

_Extent	An extent that describes the shape of the array.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	An accelerator_view which specifies the preferred target location of the array.

         : _M_extent(_Extent)
     {
         _Initialize(_Av, _Associated_Av);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_view.

Parameters

_E0	An integer that is the length of this array.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	An accelerator_view which specifies the preferred target location of the array.

         : _M_extent(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "array(int, accelerator_view, accelerator_view) is only permissible on array<T, 1>");
         _Initialize(_Av, _Associated_Av);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the least-significant dimension of this array.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	An accelerator_view which specifies the preferred target location of the array.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "array(int, int, accelerator_view, accelerator_view) is only permissible on array<T, 2>");
         _Initialize(_Av, _Associated_Av);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		int	_E2,
		Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the next-to-most-significant dimension of this array.
_E2	An integer that is the length of the least-significant dimension of this array.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	An accelerator_view which specifies the preferred target location of the array.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "array(int, int, int, accelerator_view, accelerator_view) is only permissible on array<T, 3>");
         _Initialize(_Av, _Associated_Av);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	const Concurrency::extent< _Rank > &	_Extent,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last
	)

inline

Construct an array initialized from a pair of iterators into a container.

Parameters

_Extent	An extent that describes the shape of the array.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.

         : _M_extent(_Extent)
     {
         _Initialize(details::_Select_default_accelerator().default_view, _Src_first, _Src_last, access_type_auto);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	const Concurrency::extent< _Rank > &	_Extent,
		_InputIterator	_Src_first
	)

inline

Construct an array initialized from an iterator.

Parameters

_Extent	An extent that describes the shape of the array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.

         : _M_extent(_Extent)
     {
         _InputIterator _Src_last = _Src_first;
         std::advance(_Src_last, this->extent.size());
 
         _Initialize(details::_Select_default_accelerator().default_view, _Src_first, _Src_last, access_type_auto);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last
	)

inline

Construct an array initialized from a pair of iterators into a container.

Parameters

_E0	An integer that is the length of this array.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.

         : _M_extent(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "array(int, iterator, iterator) is only permissible on array<T, 1>");
         _Initialize(details::_Select_default_accelerator().default_view, _Src_first, _Src_last, access_type_auto);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		_InputIterator	_Src_first
	)

inline

Construct an array initialized from an iterator.

Parameters

_E0	An integer that is the length of this array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.

         : _M_extent(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "array(int, iterator) is only permissible on array<T, 1>");
 
         _InputIterator _Src_last = _Src_first;
         std::advance(_Src_last, this->extent.size());
 
         _Initialize(details::_Select_default_accelerator().default_view, _Src_first, _Src_last, access_type_auto);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last
	)

inline

Construct an array initialized from a pair of iterators into a container.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the least-significant dimension of this array.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "array(int, int, iterator, iterator) is only permissible on array<T, 2>");
         _Initialize(details::_Select_default_accelerator().default_view, _Src_first, _Src_last, access_type_auto);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		_InputIterator	_Src_first
	)

inline

Construct an array initialized from an iterator.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the least-significant dimension of this array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "array(int, int, iterator) is only permissible on array<T, 2>");
 
         _InputIterator _Src_last = _Src_first;
         std::advance(_Src_last, this->extent.size());
 
         _Initialize(details::_Select_default_accelerator().default_view, _Src_first, _Src_last, access_type_auto);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		int	_E2,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last
	)

inline

Construct an array initialized from an iterator.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the next-to-most-significant dimension of this array.
_E2	An integer that is the length of the least-significant dimension of this array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "array(int, int, int, iterator, iterator) is only permissible on array<T, 3>");
         _Initialize(details::_Select_default_accelerator().default_view, _Src_first, _Src_last, access_type_auto);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		int	_E2,
		_InputIterator	_Src_first
	)

inline

Construct an array initialized from an iterator.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the next-to-most-significant dimension of this array.
_E2	An integer that is the length of the least-significant dimension of this array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "array(int, int, int, iterator) is only permissible on array<T, 3>");
 
         _InputIterator _Src_last = _Src_first;
         std::advance(_Src_last, this->extent.size());
 
         _Initialize(details::_Select_default_accelerator().default_view, _Src_first, _Src_last, access_type_auto);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	const Concurrency::extent< _Rank > &	_Extent,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last,
		Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct an array initialized from a pair of iterators into a container, bound to a specific accelerator_view.

Parameters

_Extent	An extent that describes the shape of the array.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         : _M_extent(_Extent)
     {
         _Initialize(_Av, _Src_first, _Src_last, _Cpu_access_type);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	const Concurrency::extent< _Rank > &	_Extent,
		_InputIterator	_Src_first,
		Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct an array initialized from an iterator into a container, bound to a specific accelerator_view.

Parameters

_Extent	An extent that describes the shape of the array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         : _M_extent(_Extent)
     {
         _InputIterator _Src_last = _Src_first;
         std::advance(_Src_last, this->extent.size());
 
         _Initialize(_Av, _Src_first, _Src_last, _Cpu_access_type);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last,
		Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct an array initialized from a pair of iterators into a container, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of this array.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         : _M_extent(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "array(int, iterator, iterator) is only permissible on array<T, 1>");
         _Initialize(_Av, _Src_first, _Src_last, _Cpu_access_type);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		_InputIterator	_Src_first,
		Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct an array initialized from an iterator into a container, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of this array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         : _M_extent(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "array(int, iterator) is only permissible on array<T, 1>");
 
         _InputIterator _Src_last = _Src_first;
         std::advance(_Src_last, this->extent.size());
 
         _Initialize(_Av, _Src_first, _Src_last, _Cpu_access_type);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last,
		Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct an array initialized from a pair of iterators into a container, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the least-significant dimension of this array.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "array(int, int, iterator, iterator) is only permissible on array<T, 2>");
         _Initialize(_Av, _Src_first, _Src_last, _Cpu_access_type);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		_InputIterator	_Src_first,
		Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct an array initialized from an iterator into a container, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the least-significant dimension of this array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "array(int, int, iterator) is only permissible on array<T, 2>");
 
         _InputIterator _Src_last = _Src_first;
         std::advance(_Src_last, this->extent.size());
 
         _Initialize(_Av, _Src_first, _Src_last, _Cpu_access_type);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		int	_E2,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last,
		Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct an array initialized from a pair of iterators into a container, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the next-to-most-significant dimension of this array.
_E2	An integer that is the length of the least-significant dimension of this array.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "array(int, int, int, iterator, iterator) is only permissible on array<T, 3>");
         _Initialize(_Av, _Src_first, _Src_last, _Cpu_access_type);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		int	_E2,
		_InputIterator	_Src_first,
		Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct an array initialized from an iterator into a container, bound to a specific accelerator_view.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the next-to-most-significant dimension of this array.
_E2	An integer that is the length of the least-significant dimension of this array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "array(int, int, int, iterator) is only permissible on array<T, 3>");
 
         _InputIterator _Src_last = _Src_first;
         std::advance(_Src_last, this->extent.size());
 
         _Initialize(_Av, _Src_first, _Src_last, _Cpu_access_type);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	const Concurrency::extent< _Rank > &	_Extent,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last,
		Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_view, initialized from a pair of iterators into a container.

Parameters

_Extent	An extent that describes the shape of the array.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	An accelerator_view which specifies the preferred target location of the array.

         : _M_extent(_Extent)
     {
         _Initialize(_Av, _Associated_Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	const Concurrency::extent< _Rank > &	_Extent,
		_InputIterator	_Src_first,
		Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_view, initialized from an iterator into a container.

Parameters

_Extent	An extent that describes the shape of the array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	An accelerator_view which specifies the preferred target location of the array.

         : _M_extent(_Extent)
     {
         _InputIterator _Src_last = _Src_first;
         std::advance(_Src_last, this->extent.size());
 
         _Initialize(_Av, _Associated_Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last,
		Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_view, initialized from a pair of iterators into a container.

Parameters

_E0	An integer that is the length of this array.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	An accelerator_view which specifies the preferred target location of the array.

         : _M_extent(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "array(int, iterator, iterator, accelerator_view, accelerator_view) is only permissible on array<T, 1>");
         _Initialize(_Av, _Associated_Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		_InputIterator	_Src_first,
		Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_view, initialized from an iterator into a container.

Parameters

_E0	An integer that is the length of this array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	An accelerator_view which specifies the preferred target location of the array.

         : _M_extent(Concurrency::extent<_Rank>(_E0))
     {
         static_assert(_Rank == 1, "array(int, iterator, accelerator_view, accelerator_view) is only permissible on array<T, 1>");
 
         _InputIterator _Src_last = _Src_first;
         std::advance(_Src_last, this->extent.size());
 
         _Initialize(_Av, _Associated_Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last,
		Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_view, initialized from a pair of iterators into a container.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the least-significant dimension of this array.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	An accelerator_view which specifies the preferred target location of the array.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "array(int, int, iterator, iterator, accelerator_view, accelerator_view) is only permissible on array<T, 2>");
         _Initialize(_Av, _Associated_Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		_InputIterator	_Src_first,
		Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_view, initialized from an iterator into a container.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the least-significant dimension of this array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	An accelerator_view which specifies the preferred target location of the array.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1))
     {
         static_assert(_Rank == 2, "array(int, int, iterator, accelerator_view, accelerator_view) is only permissible on array<T, 2>");
 
         _InputIterator _Src_last = _Src_first;
         std::advance(_Src_last, this->extent.size());
 
         _Initialize(_Av, _Associated_Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		int	_E2,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last,
		Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_view, initialized from a pair of iterators into a container.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the next-to-most-significant dimension of this array.
_E2	An integer that is the length of the least-significant dimension of this array.
_Src_first	A beginning iterator into the source container.
_Src_last	An ending iterator into the source container.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	An accelerator_view which specifies the preferred target location of the array.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "array(int, int, int, iterator, iterator, accelerator_view, accelerator_view) is only permissible on array<T, 3>");
         _Initialize(_Av, _Associated_Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

Concurrency::array< _Value_type, _Rank >::array	(	int	_E0,
		int	_E1,
		int	_E2,
		_InputIterator	_Src_first,
		Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_view, initialized from an iterator into a container.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array.
_E1	An integer that is the length of the next-to-most-significant dimension of this array.
_E2	An integer that is the length of the least-significant dimension of this array.
_Src_first	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than this->extent.size(), undefined behavior results.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	An accelerator_view which specifies the preferred target location of the array.

         : _M_extent(Concurrency::extent<_Rank>(_E0, _E1, _E2))
     {
         static_assert(_Rank == 3, "array(int, int, int, iterator, accelerator_view, accelerator_view) is only permissible on array<T, 3>");
 
         _InputIterator _Src_last = _Src_first;
         std::advance(_Src_last, this->extent.size());
 
         _Initialize(_Av, _Associated_Av, _Src_first, _Src_last);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array ( const array_view< const _Value_type, _Rank > & _Src )

inlineexplicit

Construct an array initialized from an array_view.

Parameters

_Src	An array_view to copy from.

         :_M_extent(_Src.extent)
     {
         _Initialize(details::_Select_default_accelerator().default_view, access_type_auto);
         Concurrency::copy(_Src,*this);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	const array_view< const _Value_type, _Rank > &	_Src,
		accelerator_view	_Av,
		access_type	_Cpu_access_type = `access_type_auto`
	)

inline

Construct an array initialized from an array_view, bound to a specific accelerator_view.

Parameters

_Src	An array_view to copy from.
_Av	An accelerator_view where this array resides.
_Cpu_access_type	The desired access_type for the array on the CPU. This parameter has a default value of access_type_auto leaving the CPU access_type determination to the runtime. The actual CPU access_type for the array can be queried using the get_cpu_access_type method.

         :_M_extent(_Src.extent)
     {
         _Initialize(_Av, _Cpu_access_type);
         Concurrency::copy(_Src,*this);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	const array_view< const _Value_type, _Rank > &	_Src,
		accelerator_view	_Av,
		accelerator_view	_Associated_Av
	)

inline

Construct a staging array between two associated accelerator_views, initialized from an array_view.

Parameters

_Src	An array_view to copy from.
_Av	An accelerator_view which specifies the location of the array.
_Associated_Av	The accelerator_view that is associated with _Av.

         :_M_extent(_Src.extent)
     {
         _Initialize(_Av, _Associated_Av);
         Concurrency::copy(_Src,*this);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array ( const array< _Value_type, _Rank > & _Other )

inline

Copy constructor. Deep copy.

         : _M_extent(_Other._M_extent)
     {
         _Initialize(_Other.accelerator_view, _Other.associated_accelerator_view);
         Concurrency::copy(_Other, *this);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array ( array< _Value_type, _Rank > && _Other )

inline

Move constructor.

         : _M_extent(_Other._M_extent), _M_multiplier(_Other._M_multiplier)
         , _M_buffer_descriptor(_Other._M_buffer_descriptor)
     {
         // Register this
         this->_Register_copy(_Other);
 
         // Release the _Other array
         _Other._Unregister();
         _Other._M_buffer_descriptor._M_data_ptr = NULL;
         _Other._M_buffer_descriptor._Set_buffer_ptr(NULL);
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::~array ( )

inlinenoexcept

Destroys this array and reclaims resources.

     {
         bool _Can_throw = (std::current_exception() == nullptr);
 
         // Destructor should not throw if we are already processing
         // an exception and another exception will result in termination
         try {
             _Unregister();
         }
         catch(...) 
         {
             if (_Can_throw) {
                 throw;
             }
         }
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array ( )

private

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::array	(	const Concurrency::extent< _Rank > &	_Extent,
		_Buffer_descriptor	_Buffer_descriptor
	)

inlineprivate

         : _M_extent(_Extent), _M_buffer_descriptor(_Buffer_descriptor)
     {
         _Initialize();
 
         // Register this
         this->_Register();
     }

Member Function Documentation

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::__declspec ( property(get=get_cpu_access_type) )

Returns the CPU access_type allowed for this array.

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::_CPP_AMP_VERIFY_RANK	(	_Rank	,
		array< _Value_type, _Rank >
	)

private

template<typename _Value_type, int _Rank = 1>

_Ret_ _View_shape* Concurrency::array< _Value_type, _Rank >::_Create_buffer_view_shape ( ) const

inlineprivate

     {
         _ASSERTE(_Get_buffer()->_Get_master_buffer_elem_size() == sizeof(_Value_type));
 
         unsigned int _ZeroOffset[_Rank] = {0};
         unsigned int _View_extent[_Rank];
         for(int i=0; i<_Rank; ++i)
         {
             _View_extent[i] = static_cast<unsigned int>(this->_M_extent[i]);
         }
         return _View_shape::_Create_view_shape(static_cast<unsigned int>(_Rank), 0, &_View_extent[0], &_ZeroOffset[0], &_View_extent[0]);
     }

template<typename _Value_type, int _Rank = 1>

_Event Concurrency::array< _Value_type, _Rank >::_Get_access_async	(	_Access_mode	_Mode,
		_Buffer_ptr &	_Buf_ptr,
		bool	_Zero_copy_cpu_access = `false`
	)		const

inlineprivate

     {
         _ASSERTE(!_Zero_copy_cpu_access || (_Get_buffer()->_Get_master_buffer()->_Get_allowed_host_access_mode() != _No_access));
 
         _Buffer_ptr _PBuf;
         Concurrency::accelerator_view _Access_av = _Zero_copy_cpu_access ? accelerator(accelerator::cpu_accelerator).default_view : this->accelerator_view;
         _Event _Ev = details::_Get_access_async(_M_buffer_descriptor._Get_view_key(),
                                                 _Access_av,
                                                 _Mode, _PBuf);
         _Buf_ptr = _PBuf;
 
         if (_Is_cpu_accelerator(_Access_av.accelerator)) {
             _Ev = _Ev._Add_continuation(std::function<_Event()>([_PBuf, this]() mutable -> _Event {
                 const_cast<array*>(this)->_M_buffer_descriptor._M_data_ptr = _PBuf->_Get_host_ptr();
                 return _Event();
             }));
         }
 
         return _Ev;
     }

template<typename _Value_type, int _Rank = 1>

_Ret_ _Ubiquitous_buffer* Concurrency::array< _Value_type, _Rank >::_Get_buffer ( ) const

inlineprivate

     {
         return _M_buffer_descriptor._Get_buffer_ptr(); 
     }

template<typename _Value_type, int _Rank = 1>

bool Concurrency::array< _Value_type, _Rank >::_Has_cpu_access ( ) const

inlineprivate

     {
         return (_Get_buffer()->_Get_master_buffer()->_Get_allowed_host_access_mode() != _No_access);
     }

template<typename _Value_type, int _Rank = 1>

unsigned int Concurrency::array< _Value_type, _Rank >::_Initialize ( )

inlineprivate

     {
         details::_Is_valid_extent(_M_extent);
 
         // Arrays always have a type access mode of '_Is_array_mode'
         // This is the mechanism for differentiating between arrays and array_views by the runtime
         _M_buffer_descriptor._M_type_access_mode = _Is_array_mode;
         unsigned int totalExtent = _M_extent[_Rank-1];
         details::_Array_init_helper<Concurrency::extent<_Rank>, Concurrency::extent<_Rank>>::func(totalExtent, _M_multiplier, _M_extent);
 
         return totalExtent;
     }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array< _Value_type, _Rank >::_Initialize	(	Concurrency::accelerator_view	_Av,
		access_type	_Cpu_access_type
	)

inlineprivate

     {
         unsigned int totalExtent = _Initialize();
         // release the existing buffer if any before allocation new one
         _M_buffer_descriptor._Set_buffer_ptr(NULL);
 
         _Buffer_ptr _PBuf = _Buffer::_Create_buffer(_Av, _Av, totalExtent, sizeof(_Value_type), false /* _Is_temp */, _Cpu_access_type);
 
         _M_buffer_descriptor._Set_buffer_ptr(_Ubiquitous_buffer::_Create_ubiquitous_buffer(_PBuf));
         _Register();
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

void Concurrency::array< _Value_type, _Rank >::_Initialize	(	Concurrency::accelerator_view	_Av,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last,
		access_type	_Cpu_access_type
	)

inlineprivate

     {
         _Initialize(_Av, _Cpu_access_type);
         copy(_Src_first, _Src_last, *this);
     }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array< _Value_type, _Rank >::_Initialize	(	Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av
	)

inlineprivate

     {
         unsigned int totalExtent = _Initialize();
 
         // Staging arrays can only be created if the accelerator_view is on the cpu_accelerator
         _Buffer_ptr _PBuf = NULL;
 
         // release the existing buffer if any before allocation new one
         _M_buffer_descriptor._Set_buffer_ptr(NULL);
 
         if (_Is_cpu_accelerator(_Av.accelerator)) 
         {
             // If the accelerator _Associated_Av supports zero-copy and the default cpu access type
             // for the accelerator is access_type_read_write, create a zero-copy buffer instead of a
             // staging buffer
             if (_Associated_Av.accelerator.supports_cpu_shared_memory && (_Get_recommended_buffer_host_access_mode(_Associated_Av) == _Read_write_access)) {
                 _PBuf = _Buffer::_Create_buffer(_Associated_Av, _Av, totalExtent, sizeof(_Value_type), false /* _Is_temp */, access_type_read_write);
             }
             else {
                 _PBuf = _Buffer::_Create_stage_buffer(_Associated_Av, _Av, totalExtent, sizeof(_Value_type));
             }
 
             _PBuf->_Map_buffer(_Read_write_access, true /* _Wait */);
         }
         else 
         {
             _PBuf = _Buffer::_Create_buffer(_Av, _Av, totalExtent, sizeof(_Value_type), false /* _Is_temp */, access_type_auto);
         }
 
         _M_buffer_descriptor._Set_buffer_ptr(_Ubiquitous_buffer::_Create_ubiquitous_buffer(_PBuf));
         _Register();
     }

template<typename _Value_type, int _Rank = 1>

template<typename _InputIterator >

void Concurrency::array< _Value_type, _Rank >::_Initialize	(	Concurrency::accelerator_view	_Av,
		Concurrency::accelerator_view	_Associated_Av,
		_InputIterator	_Src_first,
		_InputIterator	_Src_last
	)

inlineprivate

     {
         _Initialize(_Av, _Associated_Av);
         copy(_Src_first, _Src_last, *this);
     }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array< _Value_type, _Rank >::_Refresh_data_ptr	(	_Access_mode	_Requested_mode,
		bool	_Exception = `true`
	)

inlineprivate

     {
         _ASSERTE(_Is_valid_access_mode(_Requested_mode));
 
         // For an array that has CPU access, the maximum CPU access allowed is that allowed by
         // the underlying _Buffer allocation
         _Requested_mode = static_cast<_Access_mode>(_Requested_mode & _Get_buffer()->_Get_master_buffer()->_Get_allowed_host_access_mode());
 
         // Refresh the data ptr if we do not have requested access
         if ((_Requested_mode == _No_access) || ((_M_buffer_descriptor._M_curr_cpu_access_mode & _Requested_mode) != _Requested_mode)) 
         {
             if (_Has_cpu_access() && (_Requested_mode != _No_access)) 
             {
                 auto _Span_id = details::_Get_amp_trace()->_Start_array_view_synchronize_event_helper(_M_buffer_descriptor);
                 _Buffer_ptr _PBuf;
                 bool _Zero_copy_cpu_access = !_Is_cpu_accelerator(this->accelerator_view.accelerator);
                 this->_Get_access_async(_Requested_mode, _PBuf, _Zero_copy_cpu_access)._Get();
                 details::_Get_amp_trace()->_Write_end_event(_Span_id);
             }
             else 
             {
                 if (_Exception) 
                 {
                     if (!_Has_cpu_access()) {
                         throw runtime_exception("The array is not accessible on CPU.", E_FAIL);
                     }
                     else {
                         throw runtime_exception("The array is not accessible for reading on CPU.", E_FAIL);
                     }
                 }
             }
         }
     }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array< _Value_type, _Rank >::_Refresh_data_ptr	(	_Access_mode	,
		bool	= `true`
	)

inlineprivate

5743 {

5744 }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array< _Value_type, _Rank >::_Register ( )

inlineprivate

     {
         Concurrency::accelerator_view cpuAv = _Is_cpu_accelerator(this->accelerator_view.accelerator) ?
                                                this->accelerator_view : accelerator(accelerator::cpu_accelerator).default_view;
         _M_buffer_descriptor._Get_buffer_ptr()->_Register_view(_M_buffer_descriptor._Get_view_key(), cpuAv, _Create_buffer_view_shape());
 
         _M_buffer_descriptor._Get_buffer_ptr()->_Discard(_M_buffer_descriptor._Get_view_key());
 
         // If the array is on the CPU accelerator then we will ensure that the descriptor
         // indicates CPU access
         if (_Is_cpu_accelerator(this->accelerator_view.accelerator)) 
         {
             _Buffer_ptr _PBuf = NULL;
             this->_Get_access_async(_Read_write_access, _PBuf, false)._Get();
         }
     }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array< _Value_type, _Rank >::_Register_copy ( const array< _Value_type, _Rank > & _Other )

inlineprivate

     {
         _M_buffer_descriptor._Get_buffer_ptr()->_Register_view_copy(_M_buffer_descriptor._Get_view_key(), _Other._M_buffer_descriptor._Get_view_key());
     }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array< _Value_type, _Rank >::_Unregister ( )

inlineprivate

     {
         // No need to unregister if the array was moved causing the buffer ptr to be set to NULL
         if (_M_buffer_descriptor._Get_buffer_ptr() != NULL) {
             _M_buffer_descriptor._Get_buffer_ptr()->_Unregister_view(_M_buffer_descriptor._Get_view_key());
         }
     }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array< _Value_type, _Rank >::copy_to ( array< _Value_type, _Rank > & _Dest ) const

inline

Copies elements from this array to the destination array.

     {
         Concurrency::copy(*this, _Dest);
     }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array< _Value_type, _Rank >::copy_to ( const array_view< _Value_type, _Rank > & _Dest ) const

inline

Copies elements from this array to the destination array_view.

     {
         Concurrency::copy(*this,_Dest);
     }

template<typename _Value_type, int _Rank = 1>

_Ret_ _Value_type* Concurrency::array< _Value_type, _Rank >::data ( )

inline

Returns a pointer to the raw data of this array.

     {
         _Refresh_data_ptr(_Read_write_access, false /* _Exception */);
         return reinterpret_cast<_Value_type*>(_M_buffer_descriptor._M_data_ptr);
     }

template<typename _Value_type, int _Rank = 1>

const _Value_type* Concurrency::array< _Value_type, _Rank >::data ( ) const

inline

Returns a pointer to the raw data of this array.

     {
 #pragma warning( push )
 #pragma warning( disable : 4880 )
         // Casting away constness in amp restricted scope might result in 
         // undefined behavior, therefore, the compiler will report a level 1 warning
         // for it. But the following const_cast is harmless thus we are suppressing
         // this warning just for this line.
         const_cast<array*>(this)->_Refresh_data_ptr(_Read_access, false /* _Exception */);
 #pragma warning( pop )
         return reinterpret_cast<const _Value_type*>(_M_buffer_descriptor._M_data_ptr);
     }

template<typename _Value_type, int _Rank = 1>

__declspec (property(get=get_accelerator_view)) Concurrency Concurrency::accelerator_view Concurrency::array< _Value_type, _Rank >::get_accelerator_view ( ) const

inline

Returns the accelerator_view where this array is located.

     {
         return _Get_buffer()->_Get_master_buffer()->_Get_access_on_accelerator_view();
     }

template<typename _Value_type, int _Rank = 1>

__declspec (property(get=get_associated_accelerator_view)) Concurrency Concurrency::accelerator_view Concurrency::array< _Value_type, _Rank >::get_associated_accelerator_view ( ) const

inline

Returns the accelerator_view that is the preferred target where this array can be copied.

     {
         return _Get_buffer()->_Get_master_buffer()->_Get_accelerator_view();
     }

template<typename _Value_type, int _Rank = 1>

access_type Concurrency::array< _Value_type, _Rank >::get_cpu_access_type ( ) const

inline

     {
         return _Get_buffer()->_Get_master_buffer()->_Get_allowed_host_access_type();
     }

template<typename _Value_type, int _Rank = 1>

__declspec (property(get=get_extent)) Concurrency Concurrency::extent<_Rank> Concurrency::array< _Value_type, _Rank >::get_extent ( ) const

inline

Returns the extent that defines the shape of this array.

     {
         return _M_extent;
     }

template<typename _Value_type, int _Rank = 1>

Concurrency::array< _Value_type, _Rank >::operator std::vector< _Value_type > ( ) const

inline

Implicitly converts this array into a vector by copying.

     {
         std::vector<_Value_type> _return_vector(extent.size());
         Concurrency::copy(*this, _return_vector.begin());
         
         return _return_vector;
     }

template<typename _Value_type, int _Rank = 1>

_Value_type& Concurrency::array< _Value_type, _Rank >::operator() ( const index< _Rank > & _Index )

inline

Get the element value indexed by _I

Parameters

_I	The index.

Returns: The element value indexed by _I

     {
         return this->operator[](_Index);
     }

template<typename _Value_type, int _Rank = 1>

const _Value_type& Concurrency::array< _Value_type, _Rank >::operator() ( const index< _Rank > & _Index ) const

inline

Get the element value indexed by _Index

Parameters

_Index The index.

Returns: The element value indexed by _Index

     {
         return this->operator[](_Index);
     }

template<typename _Value_type, int _Rank = 1>

_Value_type& Concurrency::array< _Value_type, _Rank >::operator()	(	int	_I0,
		int	_I1
	)

inline

Get the element value indexed by (_I0,_I1)

Parameters

_I0	The most-significant component of the index
_I1	The least-significant component of the index

Returns: The element value indexed by (_I0,_I1)

     {
         static_assert(_Rank == 2, "value_type& array::operator()(int, int) is only permissible on array<T, 2>");
         return this->operator[](index<2>(_I0, _I1));
     }

template<typename _Value_type, int _Rank = 1>

const _Value_type& Concurrency::array< _Value_type, _Rank >::operator()	(	int	_I0,
		int	_I1
	)		const

inline

Get the element value indexed by (_I0,_I1)

Parameters

_I0	The most-significant component of the index
_I1	The least-significant component of the index

Returns: The element value indexed by (_I0,_I1)

     {
         static_assert(_Rank == 2, "const value_type& array::operator()(int, int) is only permissible on array<T, 2>");
         return this->operator[](index<2>(_I0, _I1));
     }

template<typename _Value_type, int _Rank = 1>

_Value_type& Concurrency::array< _Value_type, _Rank >::operator()	(	int	_I0,
		int	_I1,
		int	_I2
	)

inline

Get the element value indexed by (_I0,_I1,_I2)

Parameters

_I0	The most-significant component of the index
_I1	The next-to-most-significant component of the index
_I2	The least-significant component of the index

Returns: The element value indexed by (_I0,_I1,_I2)

     {
         static_assert(_Rank == 3, "value_type& array::operator()(int, int, int) is only permissible on array<T, 3>");
         return this->operator[](index<3>(_I0, _I1, _I2));
     }

template<typename _Value_type, int _Rank = 1>

const _Value_type& Concurrency::array< _Value_type, _Rank >::operator()	(	int	_I0,
		int	_I1,
		int	_I2
	)		const

inline

Get the element value indexed by (_I0,_I1,_I2)

Parameters

_I0	The most-significant component of the index
_I1	The next-to-most-significant component of the index
_I2	The least-significant component of the index

Returns: The element value indexed by (_I0,_I1,_I2)

     {
         static_assert(_Rank == 3, "const value_type& array::operator()(int, int, int) const is only permissible on array<T, 3>");
         return this->operator[](index<3>(_I0, _I1, _I2));
     }

template<typename _Value_type, int _Rank = 1>

details::_Projection_result_type<_Value_type,_Rank>::_Result_type Concurrency::array< _Value_type, _Rank >::operator() ( int _I )

inline

Projects the most-significant dimension of this array. If the array rank is 1, this produces a single element; otherwise it produces an array_view with one fewer dimensions.

Parameters

_I	The most-significant index component

Returns: The element at index component _I, or an array_view projected on the most-significant dimension.

     { 
         return details::_Array_projection_helper<_Value_type,_Rank>::_Project0(this,_I);
     }

template<typename _Value_type, int _Rank = 1>

details::_Projection_result_type<_Value_type,_Rank>::_Const_result_type Concurrency::array< _Value_type, _Rank >::operator() ( int _I ) const

inline

Projects the most-significant dimension of this array. If the array rank is 1, this produces a single element; otherwise it produces an array_view with one fewer dimensions.

Parameters

_I	The most-significant index component

Returns: The element at index component _I, or an array_view projected on the most-significant dimension.

     { 
         return details::_Const_array_projection_helper<_Value_type,_Rank>::_Project0(this,_I);
     }

template<typename _Value_type, int _Rank = 1>

array& Concurrency::array< _Value_type, _Rank >::operator= ( const array< _Value_type, _Rank > & _Other )

inline

Copy Assignment operator. Deep copy.

     {
         if (this != &_Other)
         {
             // First unregister myself from the current buffer
             _Unregister();
 
             _M_extent = _Other._M_extent;
             _Initialize(_Other.accelerator_view, _Other.associated_accelerator_view);
             Concurrency::copy(_Other, *this);
         }
         return *this;
     }

template<typename _Value_type, int _Rank = 1>

array& Concurrency::array< _Value_type, _Rank >::operator= ( array< _Value_type, _Rank > && _Other )

inline

Move Assignment operator.

     {
         if (this != &_Other)
         {
             // First unregister myself from the current buffer
             _Unregister();
 
             _M_extent = _Other._M_extent;
             _M_multiplier = _Other._M_multiplier;
             _M_buffer_descriptor = _Other._M_buffer_descriptor;
             this->_Register_copy(_Other);
 
             // Release the _Other array
             _Other._Unregister();
             _Other._M_buffer_descriptor._M_data_ptr = NULL;
             _Other._M_buffer_descriptor._Set_buffer_ptr(NULL);
         }
         return *this;
     }

template<typename _Value_type, int _Rank = 1>

array& Concurrency::array< _Value_type, _Rank >::operator= ( const array_view< const _Value_type, _Rank > & _Src )

inline

Assignment operator from an array_view

     {
         Concurrency::copy(_Src,*this);
         return *this;
     }

template<typename _Value_type, int _Rank = 1>

_Value_type& Concurrency::array< _Value_type, _Rank >::operator[] ( const index< _Rank > & _Index )

inline

Get the element value indexed by _I

Parameters

_I	The index.

Returns: The element value indexed by _I

     {
         // Refresh the data ptr if needed
         _Refresh_data_ptr(_Read_write_access);
 
         _Value_type * _Ptr = reinterpret_cast<_Value_type *>(_M_buffer_descriptor._M_data_ptr);
         return _Ptr[_Flatten_helper::func(_M_multiplier._M_base, _Index._M_base)]; 
     }

template<typename _Value_type, int _Rank = 1>

const _Value_type& Concurrency::array< _Value_type, _Rank >::operator[] ( const index< _Rank > & _Index ) const

inline

Get the element value indexed by _I

Parameters

_I	The index.

Returns: The element value indexed by _I

     {
         // Refresh the data ptr if needed
 #pragma warning( push )
 #pragma warning( disable : 4880 )
         // Casting away constness in amp restricted scope might result in 
         // undefined behavior, therefore, the compiler will report a level 1 warning
         // for it. But the following const_cast is harmless thus we are suppressing
         // this warning just for this line.
         const_cast<array*>(this)->_Refresh_data_ptr(_Read_access);
 #pragma warning( pop ) 
 
         _Value_type * _Ptr = reinterpret_cast<_Value_type *>(_M_buffer_descriptor._M_data_ptr);
         return _Ptr[_Flatten_helper::func(_M_multiplier._M_base, _Index._M_base)]; 
     }

template<typename _Value_type, int _Rank = 1>

details::_Projection_result_type<_Value_type,_Rank>::_Result_type Concurrency::array< _Value_type, _Rank >::operator[] ( int _I )

inline

Projects the most-significant dimension of this array. If the array rank is 1, this produces a single element; otherwise it produces an array_view with one fewer dimensions.

Parameters

_I	The most-significant index component

Returns: The element at index component _I, or an array_view projected on the most-significant dimension.

     { 
         return details::_Array_projection_helper<_Value_type,_Rank>::_Project0(this,_I);
     }

template<typename _Value_type, int _Rank = 1>

details::_Projection_result_type<_Value_type,_Rank>::_Const_result_type Concurrency::array< _Value_type, _Rank >::operator[] ( int _I ) const

inline

Projects the most-significant dimension of this array. If the array rank is 1, this produces a single element; otherwise it produces an array_view with one fewer dimensions.

Parameters

_I	The most-significant index component

Returns: The element at index component _I, or an array_view projected on the most-significant dimension.

     { 
         return details::_Const_array_projection_helper<_Value_type,_Rank>::_Project0(this,_I);
     }

template<typename _Value_type, int _Rank = 1>

template<typename _Value_type2 >

array_view<_Value_type2,1> Concurrency::array< _Value_type, _Rank >::reinterpret_as ( )

inline

Produces a (possibly unsafe) reinterpretation of this array that is linear and with a different element type.

Returns: A linear array_view with a reinterpreted element type.

     {
         return array_view<_Value_type,1>(_M_buffer_descriptor, Concurrency::extent<1>(extent.size())).template reinterpret_as<_Value_type2>();
     }

template<typename _Value_type, int _Rank = 1>

template<typename _Value_type2 >

array_view<const _Value_type2,1> Concurrency::array< _Value_type, _Rank >::reinterpret_as ( ) const

inline

Produces a (possibly unsafe) reinterpretation of this array that is linear and with a different element type.

Returns: A linear array_view with a reinterpreted element type.

     {
 #pragma warning( push )
 #pragma warning( disable : 4880 )
         // Casting away constness in amp restricted scope might result in 
         // undefined behavior, therefore, the compiler will report a level 1 warning
         // for it. But the following const_cast is harmless thus we are suppressing
         // this warning just for this line.
         return const_cast<array*>(this)->reinterpret_as<_Value_type2>();
 #pragma warning( pop ) 
     }

template<typename _Value_type, int _Rank = 1>

array_view<_Value_type,_Rank> Concurrency::array< _Value_type, _Rank >::section	(	const Concurrency::index< _Rank > &	_Section_origin,
		const Concurrency::extent< _Rank > &	_Section_extent
	)

inline

Produces a subsection of the source array at the given origin and extent.

Parameters

_Section_origin	The origin of the section.
_Section_extent	The extent of the section

Returns: A subsection of the array.

     {
         array_view<_Value_type,_Rank> _T1(*this);
         return _T1.section(_Section_origin, _Section_extent);
     }

template<typename _Value_type, int _Rank = 1>

array_view<const _Value_type,_Rank> Concurrency::array< _Value_type, _Rank >::section	(	const Concurrency::index< _Rank > &	_Section_origin,
		const Concurrency::extent< _Rank > &	_Section_extent
	)		const

inline

Produces a subsection of the source array at the given origin and extent.

Parameters

_Section_origin	The origin of the section.
_Section_extent	The extent of the section

Returns: A subsection of the array.

     {
         array_view<const _Value_type,_Rank> _T1(*this);
         return _T1.section(_Section_origin, _Section_extent);
     }

template<typename _Value_type, int _Rank = 1>

array_view<_Value_type,_Rank> Concurrency::array< _Value_type, _Rank >::section ( const Concurrency::extent< _Rank > & _Ext )

inline

Produces a subsection of the source array_view with origin of zero, with an extent of _Ext.

Parameters

_Ext	The extent of this section

Returns: A subsection of the array_view.

     {
         return section(Concurrency::index<_Rank>(), _Ext);
     }

template<typename _Value_type, int _Rank = 1>

array_view<const _Value_type,_Rank> Concurrency::array< _Value_type, _Rank >::section ( const Concurrency::extent< _Rank > & _Ext ) const

inline

Produces a subsection of the source array_view with origin of zero, with an extent of _Ext.

Parameters

_Ext	The extent of this section

Returns: A subsection of the array_view.

     {
         return section(Concurrency::index<_Rank>(), _Ext);
     }

template<typename _Value_type, int _Rank = 1>

array_view<_Value_type,_Rank> Concurrency::array< _Value_type, _Rank >::section ( const index< _Rank > & _Idx )

inline

Produces a subsection of the source array with origin specified by an index, with an extent of (this->exent - _Idx).

Parameters

_Idx	The index that specifies the origin of this section.

Returns: A subsection of the array.

     {
         array_view<_Value_type,_Rank> _T1(*this);
         return _T1.section(_Idx);
     }

template<typename _Value_type, int _Rank = 1>

array_view<const _Value_type,_Rank> Concurrency::array< _Value_type, _Rank >::section ( const index< _Rank > & _Idx ) const

inline

Produces a subsection of the source array with origin specified by an index, with an extent of (this->exent - _Idx).

Parameters

_Idx	The index that specifies the origin of this section.

Returns: A subsection of the array.

     {
         array_view<const _Value_type,_Rank> _T1(*this);
         return _T1.section(_Idx);
     }

template<typename _Value_type, int _Rank = 1>

array_view<_Value_type,1> Concurrency::array< _Value_type, _Rank >::section	(	int	_I0,
		int	_E0
	)

inline

Produces a one-dimensional subsection of the source array with origin specified by the index components _I0, with extent _E0.

Parameters

_I0	The origin of this section.
_E0	The extent of this section.

Returns: A subsection of the array.

     {
         array_view<_Value_type,_Rank> _T1(*this);
         return _T1.section(_I0,_E0);
     }

template<typename _Value_type, int _Rank = 1>

array_view<const _Value_type,1> Concurrency::array< _Value_type, _Rank >::section	(	int	_I0,
		int	_E0
	)		const

inline

Produces a one-dimensional subsection of the source array with origin specified by the index components _I0, with extent _E0.

Parameters

_I0	The origin of this section.
_E0	The extent of this section.

Returns: A subsection of the array.

     {
         array_view<const _Value_type,_Rank> _T1(*this);
         return _T1.section(_I0,_E0);
     }

template<typename _Value_type, int _Rank = 1>

array_view<_Value_type,2> Concurrency::array< _Value_type, _Rank >::section	(	int	_I0,
		int	_I1,
		int	_E0,
		int	_E1
	)

inline

Produces a two-dimensional subsection of the source array with origin specified by the index components (_I0,_I1), with extent (_E0,_E1).

Parameters

_I0	The most-significant component of the origin of this section.
_I1	The least-significant component of the origin of this section.
_E0	The most-significant component of the extent of this section.
_E1	The least-significant component of the extent of this section.

Returns: A subsection of the array.

     {
         array_view<_Value_type,_Rank> _T1(*this);
         return _T1.section(_I0,_I1,_E0,_E1);
     }

template<typename _Value_type, int _Rank = 1>

array_view<const _Value_type,2> Concurrency::array< _Value_type, _Rank >::section	(	int	_I0,
		int	_I1,
		int	_E0,
		int	_E1
	)		const

inline

Produces a two-dimensional subsection of the source array with origin specified by the index components (_I0,_I1), with extent (_E0,_E1).

Parameters

_I0	The most-significant component of the origin of this section.
_I1	The least-significant component of the origin of this section.
_E0	The most-significant component of the extent of this section.
_E1	The least-significant component of the extent of this section.

Returns: A subsection of the array.

     {
         array_view<const _Value_type,_Rank> _T1(*this);
         return _T1.section(_I0,_I1,_E0,_E1);
     }

template<typename _Value_type, int _Rank = 1>

array_view<_Value_type,3> Concurrency::array< _Value_type, _Rank >::section	(	int	_I0,
		int	_I1,
		int	_I2,
		int	_E0,
		int	_E1,
		int	_E2
	)

inline

Produces a three-dimensional subsection of the source array with origin specified by the index components (_I0,_I1,_I2), with extent (_E0,_E1,_E2).

Parameters

_I0	The most-significant component of the origin of this section.
_I1	The next-to-most-significant component of the origin of this section.
_I2	The least-significant component of the origin of this section.
_E0	The most-significant component of the extent of this section.
_E1	The next-to-most-significant component of the extent of this section.
_E2	The least-significant component of the extent of this section.

Returns: A subsection of the array.

     {
         array_view<_Value_type,_Rank> _T1(*this);
         return _T1.section(_I0,_I1,_I2,_E0,_E1,_E2);
     }

template<typename _Value_type, int _Rank = 1>

array_view<const _Value_type,3> Concurrency::array< _Value_type, _Rank >::section	(	int	_I0,
		int	_I1,
		int	_I2,
		int	_E0,
		int	_E1,
		int	_E2
	)		const

inline

Produces a three-dimensional subsection of the source array with origin specified by the index components (_I0,_I1,_I2), with extent (_E0,_E1,_E2).

Parameters

_I0	The most-significant component of the origin of this section.
_I1	The next-to-most-significant component of the origin of this section.
_I2	The least-significant component of the origin of this section.
_E0	The most-significant component of the extent of this section.
_E1	The next-to-most-significant component of the extent of this section.
_E2	The least-significant component of the extent of this section.

Returns: A subsection of the array.

     {
         array_view<const _Value_type,_Rank> _T1(*this);
         return _T1.section(_I0,_I1,_I2,_E0,_E1,_E2);
     }

template<typename _Value_type, int _Rank = 1>

template<int _New_rank>

array_view<_Value_type,_New_rank> Concurrency::array< _Value_type, _Rank >::view_as ( const Concurrency::extent< _New_rank > & _View_extent )

inline

Produces an array_view of a different rank over this array's data.

Parameters

_View_extent The reshaping extent.

Returns: A reshaped array_view.

     {
         return array_view<_Value_type,_New_rank>(_M_buffer_descriptor, _View_extent);
     }

template<typename _Value_type, int _Rank = 1>

template<int _New_rank>

array_view<const _Value_type,_New_rank> Concurrency::array< _Value_type, _Rank >::view_as ( const Concurrency::extent< _New_rank > & _View_extent ) const

inline

Produces an array_view of a different rank over this array's data.

Parameters

_View_extent The reshaping extent.

Returns: A reshaped array_view.

     {
 #pragma warning( push )
 #pragma warning( disable : 4880 )
         // Casting away constness in amp restricted scope might result in 
         // undefined behavior, therefore, the compiler will report a level 1 warning
         // for it. But the following const_cast is harmless thus we are suppressing
         // this warning just for this line.
         return const_cast<array*>(this)->view_as<_New_rank>(_View_extent);
 #pragma warning( pop ) 
     }

Friends And Related Function Documentation

template<typename _Value_type, int _Rank = 1>

_Event details::_Get_access_async	(	const array< _Value_type, _Rank > &	_Array,
		_Access_mode	_Mode,
		_Buffer_ptr &	_Buf_ptr
	)

friend

template<typename _Value_type, int _Rank = 1>

_Ret_ _Ubiquitous_buffer* details::_Get_buffer ( const array< _Value_type, _Rank > & _Array )

friend

template<typename _Value_type, int _Rank = 1>

const _Buffer_descriptor& details::_Get_buffer_descriptor ( const array< _Value_type, _Rank > & _Array )

friend

template<typename _Value_type, int _Rank = 1>

template<typename _Value_type , int _Rank>

array<_Value_type,_Rank> direct3d::make_array	(	const Concurrency::extent< _Rank > &	_Extent,
		const Concurrency::accelerator_view &	_Av,
		_In_ IUnknown *	_D3D_buffer
	)

friend

Member Data Documentation

template<typename _Value_type, int _Rank = 1>

_Buffer_descriptor Concurrency::array< _Value_type, _Rank >::_M_buffer_descriptor

private

template<typename _Value_type, int _Rank = 1>

Concurrency::extent<_Rank> Concurrency::array< _Value_type, _Rank >::_M_extent

private

template<typename _Value_type, int _Rank = 1>

Concurrency::extent<_Rank> Concurrency::array< _Value_type, _Rank >::_M_multiplier

private

template<typename _Value_type, int _Rank = 1>

const int Concurrency::array< _Value_type, _Rank >::rank = _Rank

static

The documentation for this class was generated from the following file:

VS2015/inc/amp.h

Public Types

Public Member Functions

Static Public Attributes

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

template<typename _Value_type, int _Rank = 1> class Concurrency::array< _Value_type, _Rank >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation

template<typename _Value_type, int _Rank = 1>
class Concurrency::array< _Value_type, _Rank >