Concurrency::array_view< _Value_type, _Rank > Class Template Reference

An array_view is an N-dimensional view over data held in another container (such as array<T,N> or other container. It exposes an indexing interface congruent to that of array<T,N>). More...

#include <amp.h>

Inheritance diagram for Concurrency::array_view< _Value_type, _Rank >:

Public Types
typedef _Value_type	value_type
Public Types inherited from Concurrency::details::_Array_view_base< _Rank, sizeof(_Value_type)/sizeof(int)>
typedef details::_Buffer_descriptor	_Buffer_descriptor

Public Member Functions
	~array_view () __GPU
	Destroys this array_view and reclaims resources. More...
	array_view (array< _Value_type, _Rank > &_Src) __GPU
	Construct an array_view which is bound to the data contained in the _Src array. The extent of the array_view is that of the _Src array, and the origin of the array view is at zero. More...
	array_view (const array_view &_Other) __GPU
	Copy constructor. Shallow copy. More...
	array_view (const Concurrency::extent< _Rank > &_Extent) __CPU_ONLY
	Construct an array_view which is not bound to a data source. More...
template<typename _Container >
	array_view (const Concurrency::extent< _Rank > &_Extent, _Container &_Src) __CPU_ONLY
	Construct an array_view which is bound to the data contained in the _Src container. More...
	array_view (const Concurrency::extent< _Rank > &_Extent, _Value_type *_Src) __GPU
	Construct an array_view which is bound to the data pointed to by _Src. More...
	array_view (int _E0) __CPU_ONLY
	Construct an array_view which is not bound to a data source. More...
template<typename _Container >
	array_view (_Container &_Src, typename std::enable_if< details::_Is_container< _Container >::type::value, void ** >::type=0) __CPU_ONLY
	Construct an array_view which is bound to the data contained in the _Src container. More...
template<typename _Container >
	array_view (int _E0, _Container &_Src) __CPU_ONLY
	Construct an array_view which is bound to the data contained in the _Src container. More...
	array_view (int _E0, int _E1) __CPU_ONLY
	Construct an array_view which is not bound to a data source. More...
template<typename _Container >
	array_view (int _E0, int _E1, _Container &_Src) __CPU_ONLY
	Construct an array_view which is bound to the data contained in the _Src container. More...
	array_view (int _E0, int _E1, int _E2) __CPU_ONLY
	Construct an array_view which is not bound to a data source. More...
template<typename _Container >
	array_view (int _E0, int _E1, int _E2, _Container &_Src) __CPU_ONLY
	Construct an array_view which is bound to the data contained in the _Src container. More...
	array_view (int _E0, _In_ _Value_type *_Src) __GPU
	Construct an array_view which is bound to the data pointed to by _Src. More...
template<typename _Arr_type , int _Size>
	array_view (_In_ _Arr_type(&_Src)[_Size]) __GPU
	Construct an array_view which is bound to the array _Src. More...
	array_view (int _E0, int _E1, _In_ _Value_type *_Src) __GPU
	Construct an array_view which is bound to the data pointed to by _Src. More...
	array_view (int _E0, int _E1, int _E2, _In_ _Value_type *_Src) __GPU
	Construct an array_view which is bound to the data pointed to by _Src. More...
array_view &	operator= (const array_view &_Other) __GPU
	Copy Assignment operator. Shallow copy. More...
void	copy_to (array< _Value_type, _Rank > &_Dest) const __CPU_ONLY
	Copies elements from this array_view to the destination array. More...
void	copy_to (const array_view< _Value_type, _Rank > &_Dest) const __CPU_ONLY
	Copies elements from this array_view to the destination array_view. More...
details::_Projection_result_type< _Value_type, _Rank >::_Result_type	operator[] (int _I) const __GPU
	Projects the most-significant dimension of this array_view. If the array_view rank is 1, this produces a single element; otherwise it produces an array_view with one fewer dimensions. More...
value_type &	get_ref (const index< _Rank > &_Index) const __GPU
	Get a reference to the element indexed by _Index. Unlike the other indexing operators for accessing the array_view on the CPU, this method does not implicitly synchronize this array_view's contents to the CPU. After accessing the array_view on a remote location or performing a copy operation involving this array_view users are responsible to explicitly synchronize the array_view to the CPU before calling this method. Failure to do so results in undefined behavior. More...
value_type &	operator[] (const index< _Rank > &_Index) const __GPU
	Get the element value indexed by _I More...
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) const __GPU
	Projects the most-significant dimension of this array_view. If the array_view rank is 1, this produces a single element; otherwise it produces an array_view with one fewer dimensions. More...
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) const __GPU
	Get the element value indexed by (_I0,_I1,_I2) More...
array_view	section (const Concurrency::index< _Rank > &_Section_origin, const Concurrency::extent< _Rank > &_Section_extent) const __GPU
	Produces a subsection of the source array_view at the given origin and extent. More...
array_view	section (const Concurrency::index< _Rank > &_Idx) const __GPU
	Produces a subsection of the source array_view with origin specified by an index, with an extent of (this->exent - _Idx). More...
array_view	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	section (int _I0, int _E0) const __GPU
	Produces a one-dimensional subsection of the source array_view with origin specified by the index components _I0, with extent _E0. More...
array_view	section (int _I0, int _I1, int _E0, int _E1) const __GPU
	Produces a two-dimensional subsection of the source array_view with origin specified by the index components (_I0,_I1), with extent (_E0,_E1). More...
array_view	section (int _I0, int _I1, int _I2, int _E0, int _E1, int _E2) const __GPU
	Produces a three-dimensional subsection of the source array_view with origin specified by the index components (_I0,_I1,_I2), with extent (_E0,_E1,_E2). More...
template<typename _Value_type2 >
array_view< _Value_type2, _Rank >	reinterpret_as () const __GPU
	Produces a (possibly unsafe) reinterpretation of this array_view that is linear and with a different element type. The size of _Value_type2 must evenly divide into the size of this array. More...
template<int _New_rank>
array_view< _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_view's data. More...
_Ret_ _Value_type *	data () const __GPU
	Returns a pointer to the raw data of this array_view. More...
void	refresh () const __CPU_ONLY
	Informs the array_view that its bound memory has been modified outside the array_view interface. This will render all cached information stale. More...
concurrency::completion_future	synchronize_to_async (const accelerator_view &_Accl_view, access_type _Access_type=access_type_read) const __CPU_ONLY
	Asynchronously synchronizes any modifications made to "this" array_view to the specified accelerator_view. More...
concurrency::completion_future	synchronize_async (access_type _Access_type=access_type_read) const __CPU_ONLY
	Asynchronously synchronizes any modifications made to "this" array_view to its source data. More...
void	synchronize_to (const accelerator_view &_Accl_view, access_type _Access_type=access_type_read) const __CPU_ONLY
	Synchronizes any modifications made to "this" array_view to the specified accelerator_view. More...
void	synchronize (access_type _Access_type=access_type_read) const __CPU_ONLY
	Synchronizes any modifications made to "this" array_view to its source data. More...
void	discard_data () const __CPU_ONLY
	Discards the current data underlying this view. This is an optimization hint to the runtime used to avoid copying the current contents of the view to a target accelerator_view that it is accessed on, and its use is recommended if the existing content is not needed. This method is only available in a restrict(cpu) context and cannot be used in a restrict(amp) context. More...
accelerator_view	get_source_accelerator_view () const
	Returns the accelerator_view where the data source of the array_view is located. If the array_view does not have a data source, this API throws a runtime_exception More...
	__declspec (property(get=get_source_accelerator_view)) accelerator_view source_accelerator_view
Public Member Functions inherited from Concurrency::details::_Array_view_base< _Rank, sizeof(_Value_type)/sizeof(int)>
	~_Array_view_base () __GPU
Public Member Functions inherited from Concurrency::details::_Array_view_shape< _Rank, _Element_size >
__declspec(property(get=get_extent)) Concurrency Concurrency::extent< _Rank >	get_extent () const __GPU
	The extent of this array or view. More...
	~_Array_view_shape () __GPU

Static Public Attributes
static const int	rank = _Rank

Private Types
typedef _Array_view_base< _Rank, sizeof(_Value_type)/sizeof(int)>	_Base

Private Member Functions
	_CPP_AMP_VERIFY_RANK (_Rank, array_view)
void	_Project0 (int _I, array_view< _Value_type, _Rank-1 > &_Projected_view) const __GPU
	array_view () __GPU
	array_view (const array_view &_Other, const Concurrency::index< _Rank > &_Section_origin, const Concurrency::extent< _Rank > &_Section_extent) __GPU
	array_view (_Buffer_descriptor &_Src_buffer, const Concurrency::extent< _Rank > &_Extent) __GPU
void	_Initialize () __GPU
void	_Initialize (size_t _Src_data_size, bool _Discard_data=false) __CPU_ONLY

Static Private Member Functions
template<typename _T , int _R>
static array_view< _T, _R >	_Convert (const _Array_view_base< _R, sizeof(_T)/sizeof(int)> &_Other) __GPU

Friends
class	details::_Array_view_projection_helper< _Value_type, _Rank >
class	details::_Array_view_projection_helper< _Value_type, _Rank+1 >
class	array_view< _Value_type, _Rank >
class	array_view< const _Value_type, _Rank >
class	array_view< _Value_type, _Rank+1 >
class	array_view< const _Value_type, _Rank+1 >
template<typename _T , int _R>
class	array
const _Buffer_descriptor &	details::_Get_buffer_descriptor (const array_view< _Value_type, _Rank > &_Array) __GPU

Additional Inherited Members
Protected Member Functions inherited from Concurrency::details::_Array_view_base< _Rank, sizeof(_Value_type)/sizeof(int)>
	_Array_view_base () __GPU
	_Array_view_base (const _Buffer_descriptor &_Buffer_desc, const _Array_view_shape &_Shape) __GPU
	_Array_view_base (const _Array_view_base &_Other) __GPU
	_Array_view_base (const _Array_view_base &_Other, const Concurrency::extent< _Rank > &_Array_extent) __GPU
	_Array_view_base (const _Array_view_base &_Other, const Concurrency::index< _Rank > &_Section_origin, const Concurrency::extent< _Rank > &_Section_extent) __GPU
	_Array_view_base (const _Buffer_descriptor &_Buffer_desc, const Concurrency::extent< _Rank > &_Array_extent) __GPU
	_Array_view_base (const _Buffer_descriptor &_Buffer_desc, int _Base_linear_offset, const Concurrency::extent< _Rank > &_Array_extent) __GPU
	_Array_view_base (const _Buffer_descriptor &_Buffer_desc, int _Base_linear_offset, const Concurrency::extent< _Rank > &_Array_extent, const Concurrency::index< _Rank > &_View_offset, const Concurrency::extent< _Rank > &_View_extent) __GPU
	_Array_view_base (const _Buffer_descriptor &_Buffer_desc, const Concurrency::extent< _Rank > &_Array_extent, const Concurrency::index< _Rank > &_Section_origin, const Concurrency::extent< _Rank > &_Section_extent) __GPU
	_Array_view_base (const Concurrency::extent< _Rank > &_Array_extent) __CPU_ONLY
	_Array_view_base (_In_ void *_Data, const Concurrency::extent< _Rank > &_Array_extent) __CPU_ONLY
	_Array_view_base (_In_ void *_Data, const Concurrency::extent< _Rank > &_Array_extent) __GPU_ONLY
	_Array_view_base (const void *_Data, const Concurrency::extent< _Rank > &_Array_extent) __CPU_ONLY
	_Array_view_base (const void *_Data, const Concurrency::extent< _Rank > &_Array_extent) __GPU_ONLY
_Array_view_base &	operator= (const _Array_view_base &_Other) __GPU
_Ret_ void *	_Access (const index< _Rank > &_Index) const __GPU
_Ret_ void *	_Access (_Access_mode _Requested_mode, const index< _Rank > &_Index) const __CPU_ONLY
_Ret_ void *	_Access (_Access_mode _Requested_mode, const index< _Rank > &_Index) const __GPU_ONLY
_Array_view_base	_Section (const Concurrency::index< _Rank > &_Section_origin, const Concurrency::extent< _Rank > &_Section_extent) const __GPU
_Array_view_base	_Section (const index< _Rank > &_Idx) const __GPU
void	_Project0 (int _I, _Array_view_base< _Rank-1, _Element_size > &_Projected_view) const __GPU
_Array_view_base< _Rank, _New_element_size >	_Reinterpret_as () const __GPU
_Array_view_base< _New_rank, _Element_size >	_View_as (const Concurrency::extent< _New_rank > &_View_extent) const __GPU
_Ret_ _View_shape *	_Create_buffer_view_shape () const __CPU_ONLY
Protected Member Functions inherited from Concurrency::details::_Array_view_shape< _Rank, _Element_size >
int	_Base_linear_offset () const __GPU
	_Array_view_shape (const _Array_view_shape &_Other) __GPU
	_Array_view_shape (const _Array_view_shape &_Other, const Concurrency::index< _Rank > &_Section_origin, const Concurrency::extent< _Rank > &_Section_extent) __GPU
	_Array_view_shape (int _Base_linear_offset, const Concurrency::extent< _Rank > &_Array_extent) __GPU
	_Array_view_shape (int _Base_linear_offset, const Concurrency::extent< _Rank > &_Array_extent, const Concurrency::index< _Rank > &_Section_origin, const Concurrency::extent< _Rank > &_Section_extent) __GPU
_Array_view_shape &	operator= (const _Array_view_shape &_Other) __GPU
void	_Project0 (int _I, _Array_view_shape< _Rank-1, _Element_size > &_Projected_shape) const __GPU
	_Array_view_shape () __GPU
Protected Attributes inherited from Concurrency::details::_Array_view_base< _Rank, sizeof(_Value_type)/sizeof(int)>
_Buffer_descriptor	_M_buffer_descriptor
Protected Attributes inherited from Concurrency::details::_Array_view_shape< _Rank, _Element_size >
Concurrency::extent< _Rank >	_M_array_extent
Concurrency::extent< _Rank >	_M_array_multiplier
Concurrency::index< _Rank >	_M_view_offset
int	_M_total_linear_offset
Concurrency::extent< _Rank >	_M_view_extent

Detailed Description

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

An array_view is an N-dimensional view over data held in another container (such as array<T,N> or other container. It exposes an indexing interface congruent to that of array<T,N>).

Parameters

_Rank	The number of dimensions of this array_view.
_Value_type	The type of the element.

Member Typedef Documentation

template<typename _Value_type, int _Rank = 1>

typedef _Array_view_base<_Rank, sizeof(_Value_type)/sizeof(int)> Concurrency::array_view< _Value_type, _Rank >::_Base

private

template<typename _Value_type, int _Rank = 1>

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

Constructor & Destructor Documentation

template<typename _Value_type, int _Rank = 1>

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

inline

Destroys this array_view and reclaims resources.

{}

template<typename _Value_type, int _Rank = 1>

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

inline

Construct an array_view which is bound to the data contained in the _Src array. The extent of the array_view is that of the _Src array, and the origin of the array view is at zero.

Parameters

_Src	An array which contains the data that this array_view is bound to.

        : _Base(_Get_buffer_descriptor(_Src), _Src.extent)
    {   
        _Initialize();
    }

template<typename _Value_type, int _Rank = 1>

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

inline

Copy constructor. Shallow copy.

        : _Base(_Other)
    {
        _Initialize();
    }

template<typename _Value_type, int _Rank = 1>

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

inlineexplicit

Construct an array_view which is not bound to a data source.

Parameters

_Extent

The extent of this array view.

        :_Base(_Extent)
    {
        _Initialize(_Extent.size(), true);
    }

template<typename _Value_type, int _Rank = 1>

template<typename _Container >

Concurrency::array_view< _Value_type, _Rank >::array_view ( const Concurrency::extent< _Rank > &  _Extent, _Container &  _Src  )

inline

Construct an array_view which is bound to the data contained in the _Src container.

Parameters

_Extent	The extent of this array view.
_Src	A container which contains the data that this array_view is bound to.

        :_Base(_Src.data(),_Extent)
    {
        static_assert( std::is_same<decltype(_Src.data()), _Value_type*>::value, "container element type and array view element type must match");
        _Initialize(_Src.size());
    }

template<typename _Value_type, int _Rank = 1>

Concurrency::array_view< _Value_type, _Rank >::array_view ( const Concurrency::extent< _Rank > &  _Extent, _Value_type *  _Src  )

inline

Construct an array_view which is bound to the data pointed to by _Src.

Parameters

_Extent	The extent of this array view.
_Src	A pointer to the source data this array_view will bind to. If the number of elements pointed to by _Src is less than the size of _Extent, undefined behavior results.

        :_Base(_Src,_Extent)
    {
        _Initialize();
    }

template<typename _Value_type, int _Rank = 1>

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

inlineexplicit

Construct an array_view which is not bound to a data source.

Parameters

_E0	An integer that is the length of this array_view.

        :_Base(Concurrency::extent<1>(_E0))
    {
        static_assert(_Rank == 1, "rank must be 1");
        _Initialize(get_extent().size(), true);
    }

template<typename _Value_type, int _Rank = 1>

template<typename _Container >

Concurrency::array_view< _Value_type, _Rank >::array_view ( _Container &  _Src, typename std::enable_if< details::_Is_container< _Container >::type::value, void ** >::type  = 0  )

inlineexplicit

Construct an array_view which is bound to the data contained in the _Src container.

The length of the array_view is the same as the length of the container

Parameters

_Src	A container which contains the data that this array_view is bound to.

        :_Base(_Src.data(), Concurrency::extent<1>(static_cast<int>(_Src.size())))
    {
        if (_Src.size() > INT_MAX) {
            throw runtime_exception("Invalid _Src container argument - _Src size is greater than INT_MAX", E_INVALIDARG);
        }
        static_assert( std::is_same<decltype(_Src.data()), _Value_type*>::value, "container element type and array view element type must match");
        static_assert(_Rank == 1, "rank must be 1");
        _Initialize(_Src.size());
    }

template<typename _Value_type, int _Rank = 1>

template<typename _Container >

Concurrency::array_view< _Value_type, _Rank >::array_view ( int  _E0, _Container &  _Src  )

inlineexplicit

Construct an array_view which is bound to the data contained in the _Src container.

Parameters

_E0	An integer that is the length of this array_view.
_Src	A container which contains the data that this array_view is bound to.

        :_Base(_Src.data(), Concurrency::extent<1>(_E0))
    {
        static_assert( std::is_same<decltype(_Src.data()), _Value_type*>::value, "container element type and array view element type must match");
        static_assert(_Rank == 1, "rank must be 1");
        _Initialize(_Src.size());
    }

template<typename _Value_type, int _Rank = 1>

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

inlineexplicit

Construct an array_view which is not bound to a data source.

Parameters

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

        :_Base(Concurrency::extent<2>(_E0,_E1))
    {
        static_assert(_Rank == 2, "rank must be 2");
        _Initialize(get_extent().size(), true);
    }

template<typename _Value_type, int _Rank = 1>

template<typename _Container >

Concurrency::array_view< _Value_type, _Rank >::array_view ( int  _E0, int  _E1, _Container &  _Src  )

inlineexplicit

Construct an array_view which is bound to the data contained in the _Src container.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array_view.
_E1	An integer that is the length of the least-significant dimension of this array_view.
_Src	A container which contains the data that this array_view is bound to.

        :_Base(_Src.data(), Concurrency::extent<2>(_E0,_E1))
    {
        static_assert( std::is_same<decltype(_Src.data()), _Value_type*>::value, "container element type and array view element type must match");
        static_assert(_Rank == 2, "rank must be 2");
        _Initialize(_Src.size());
    }

template<typename _Value_type, int _Rank = 1>

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

inlineexplicit

Construct an array_view which is not bound to a data source.

Parameters

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

        :_Base(Concurrency::extent<3>(_E0,_E1,_E2))
    {
        static_assert(_Rank == 3, "rank must be 3");
        _Initialize(get_extent().size(), true);
    }

template<typename _Value_type, int _Rank = 1>

template<typename _Container >

Concurrency::array_view< _Value_type, _Rank >::array_view ( int  _E0, int  _E1, int  _E2, _Container &  _Src  )

inlineexplicit

Construct an array_view which is bound to the data contained in the _Src container.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array_view.
_E1	An integer that is the length of the next-to-most-significant dimension of this array_view.
_E2	An integer that is the length of the least-significant dimension of this array_view.
_Src	A container which contains the data that this array_view is bound to.

        :_Base(_Src.data(), Concurrency::extent<3>(_E0,_E1,_E2))
    {
        static_assert( std::is_same<decltype(_Src.data()), _Value_type*>::value, "container element type and array view element type must match");
        static_assert(_Rank == 3, "rank must be 3");
        _Initialize(_Src.size());
    }

template<typename _Value_type, int _Rank = 1>

Concurrency::array_view< _Value_type, _Rank >::array_view ( int  _E0, _In_ _Value_type *  _Src  )

inlineexplicit

Construct an array_view which is bound to the data pointed to by _Src.

Parameters

_E0	An integer that is the length of this array_view.
_Src	A container which contains the data that this array_view is bound to. If the number of elements pointed to by _Src is less than _E0, undefined behavior results.

        :_Base(_Src, Concurrency::extent<1>(_E0))
    {
        static_assert(_Rank == 1, "rank must be 1");
        _Initialize();
    }

template<typename _Value_type, int _Rank = 1>

template<typename _Arr_type , int _Size>

Concurrency::array_view< _Value_type, _Rank >::array_view ( _In_ _Arr_type(&)  _Src[_Size] )

inlineexplicit

Construct an array_view which is bound to the array _Src.

Parameters

_Src	An array which contains the data that this array_view is bound to.

        :_Base(_Src, Concurrency::extent<1>(_Size))
    {
        static_assert( std::is_same<typename std::remove_reference<decltype(*_Src)>::type, _Value_type>::value, "container element type and array view element type must match");
        static_assert(_Rank == 1, "rank must be 1");
        _Initialize();
    }

template<typename _Value_type, int _Rank = 1>

Concurrency::array_view< _Value_type, _Rank >::array_view ( int  _E0, int  _E1, _In_ _Value_type *  _Src  )

inlineexplicit

Construct an array_view which is bound to the data pointed to by _Src.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array_view.
_E1	An integer that is the length of the least-significant dimension of this array_view.
_Src	A container which contains the data that this array_view is bound to. If the number of elements pointed to by _Src is less than _E0*_E1, undefined behavior results.

        :_Base(_Src, Concurrency::extent<2>(_E0,_E1))
    {
        static_assert(_Rank == 2, "rank must be 2");
        _Initialize();
    }

template<typename _Value_type, int _Rank = 1>

Concurrency::array_view< _Value_type, _Rank >::array_view ( int  _E0, int  _E1, int  _E2, _In_ _Value_type *  _Src  )

inlineexplicit

Construct an array_view which is bound to the data pointed to by _Src.

Parameters

_E0	An integer that is the length of the most-significant dimension of this array_view.
_E1	An integer that is the length of the next-to-most-significant dimension of this array_view.
_E2	An integer that is the length of the least-significant dimension of this array_view.
_Src	A container which contains the data that this array_view is bound to. If the number of elements pointed to by _Src is less than _E0*_E1*_E2, undefined behavior results.

        :_Base(_Src, Concurrency::extent<3>(_E0,_E1,_E2))
    {
        static_assert(_Rank == 3, "rank must be 3");
        _Initialize();
    }

template<typename _Value_type, int _Rank = 1>

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

inlineprivate

{}

template<typename _Value_type, int _Rank = 1>

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

inlineprivate

        :_Base(_Other, _Section_origin, _Section_extent)
    {
        _Initialize();
    }

template<typename _Value_type, int _Rank = 1>

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

inlineprivate

        :_Base(_Src_buffer,_Extent)
    {
        _Initialize();
    }

Member Function Documentation

template<typename _Value_type, int _Rank = 1>

Concurrency::array_view< _Value_type, _Rank >::__declspec

(

property(get=get_source_accelerator_view)

)

template<typename _Value_type, int _Rank = 1>

template<typename _T , int _R>

static array_view<_T,_R> Concurrency::array_view< _Value_type, _Rank >::_Convert ( const _Array_view_base< _R, sizeof(_T)/sizeof(int)> &  _Other )

inlinestaticprivate

    {
        static_assert(sizeof(array_view<_T,_R>) == sizeof(_Array_view_base<_R,sizeof(_T)/sizeof(int)>), "ASSERT FAILURE: implementation relies on binary conversion between the two");
        return (*reinterpret_cast<const array_view<_T,_R>*>(&_Other));
    }

template<typename _Value_type, int _Rank = 1>

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

private

template<typename _Value_type, int _Rank = 1>

void Concurrency::array_view< _Value_type, _Rank >::_Initialize ( )

inlineprivate

    {
        // Set the type access mode
        _M_buffer_descriptor._M_type_access_mode = _Read_write_access;
    }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array_view< _Value_type, _Rank >::_Initialize ( size_t  _Src_data_size, bool  _Discard_data = false  )

inlineprivate

    {
        // Ensure that the _Src_data_size is at least as big as the size
        // of the array_view
        if (_Src_data_size < this->extent.size()) {
            throw runtime_exception("Invalid _Src container argument - _Src size is less than the size of the array_view.", E_INVALIDARG);
        }

        _Initialize();

        if (_Discard_data) {
            discard_data();
        }
    }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array_view< _Value_type, _Rank >::_Project0 ( int  _I, array_view< _Value_type, _Rank-1 > &  _Projected_view  ) const

inlineprivate

    {
        _Base::_Project0(_I, _Projected_view);
        _Projected_view._Initialize();
    }

template<typename _Value_type, int _Rank = 1>

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

inline

Copies elements from this array_view to the destination array.

    {
        copy(*this,_Dest);
    }

template<typename _Value_type, int _Rank = 1>

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

inline

Copies elements from this array_view to the destination array_view.

    {
        copy(*this,_Dest);
    }

template<typename _Value_type, int _Rank = 1>

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

inline

Returns a pointer to the raw data of this array_view.

    {
        static_assert(_Rank == 1, "array_view::data() is only permissible on array_view<T, 1>");
        return &this->operator[](index<_Rank>());
    }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array_view< _Value_type, _Rank >::discard_data ( ) const

inline

Discards the current data underlying this view. This is an optimization hint to the runtime used to avoid copying the current contents of the view to a target accelerator_view that it is accessed on, and its use is recommended if the existing content is not needed. This method is only available in a restrict(cpu) context and cannot be used in a restrict(amp) context.

    {
        _M_buffer_descriptor._Get_buffer_ptr()->_Discard(_M_buffer_descriptor._Get_view_key());
    }

template<typename _Value_type, int _Rank = 1>

value_type& Concurrency::array_view< _Value_type, _Rank >::get_ref ( const index< _Rank > &  _Index ) const

inline

Get a reference to the element indexed by _Index. Unlike the other indexing operators for accessing the array_view on the CPU, this method does not implicitly synchronize this array_view's contents to the CPU. After accessing the array_view on a remote location or performing a copy operation involving this array_view users are responsible to explicitly synchronize the array_view to the CPU before calling this method. Failure to do so results in undefined behavior.

Parameters

_Index

The index.

Returns

Reference to the element indexed by _Index

    {
        void *_Ptr = _Access(_Index);
        return *reinterpret_cast<value_type*>(_Ptr);
    }

template<typename _Value_type, int _Rank = 1>

accelerator_view Concurrency::array_view< _Value_type, _Rank >::get_source_accelerator_view ( ) const

inline

Returns the accelerator_view where the data source of the array_view is located. If the array_view does not have a data source, this API throws a runtime_exception

    {
        if (_M_buffer_descriptor._Get_buffer_ptr()->_Has_data_source()) {
            return _M_buffer_descriptor._Get_buffer_ptr()->_Get_master_accelerator_view();
        }
        else {
            throw runtime_exception("Cannot query source accelerator_view for an array_view without a data source.", E_INVALIDARG);
        }
    }

template<typename _Value_type, int _Rank = 1>

value_type& Concurrency::array_view< _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

    {
        void * _Ptr = _Access(_Read_write_access, _Index);
        return *reinterpret_cast<value_type*>(_Ptr);
    }

template<typename _Value_type, int _Rank = 1>

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

inline

Projects the most-significant dimension of this array_view. If the array_view 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_view_projection_helper<_Value_type,_Rank>::_Project0(this, _I);
    }

template<typename _Value_type, int _Rank = 1>

value_type& Concurrency::array_view< _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, "value_type& array_view::operator()(int,int) is only permissible on array_view<T, 2>");
        return this->operator()(index<2>(_I0,_I1));
    }

template<typename _Value_type, int _Rank = 1>

value_type& Concurrency::array_view< _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, "value_type& array_view::operator()(int,int,int) is only permissible on array_view<T, 3>");
        return this->operator()(index<3>(_I0,_I1,_I2));
    }

template<typename _Value_type, int _Rank = 1>

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

inline

Copy Assignment operator. Shallow copy.

    {
        _Base::operator=(_Other);
        return *this;
    }

template<typename _Value_type, int _Rank = 1>

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

inline

Projects the most-significant dimension of this array_view. If the array_view 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_view_projection_helper<_Value_type,_Rank>::_Project0(this, _I);
    }

template<typename _Value_type, int _Rank = 1>

value_type& Concurrency::array_view< _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

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

template<typename _Value_type, int _Rank = 1>

void Concurrency::array_view< _Value_type, _Rank >::refresh ( ) const

inline

Informs the array_view that its bound memory has been modified outside the array_view interface. This will render all cached information stale.

    {
        // If the array_view corresponds to a ubiquitous buffer with no data source,
        // then refresh is a no-op
        if (!_M_buffer_descriptor._Get_buffer_ptr()->_Has_data_source()) {
            return;
        }

        _Buffer_ptr _PBuf;
        _Get_access_async(_M_buffer_descriptor._Get_view_key(), _M_buffer_descriptor._Get_buffer_ptr()->_Get_master_accelerator_view(), _Write_access, _PBuf)._Get();
    }

template<typename _Value_type, int _Rank = 1>

template<typename _Value_type2 >

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

inline

Produces a (possibly unsafe) reinterpretation of this array_view that is linear and with a different element type. The size of _Value_type2 must evenly divide into the size of this array.

Returns

A linear array_view with a reinterpreted element type.

    {
        return _Convert<_Value_type2>(this->template _Reinterpret_as<sizeof(_Value_type2)/sizeof(int)>());
    }

template<typename _Value_type, int _Rank = 1>

array_view Concurrency::array_view< _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_view 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_view.

    {
        return _Convert<_Value_type>(_Section(_Section_origin, _Section_extent));
    }

template<typename _Value_type, int _Rank = 1>

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

inline

Produces a subsection of the source array_view 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_view.

    {
        return section(_Idx, this->extent - _Idx);
    }

template<typename _Value_type, int _Rank = 1>

array_view Concurrency::array_view< _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 Concurrency::array_view< _Value_type, _Rank >::section ( int  _I0, int  _E0  ) const

inline

Produces a one-dimensional subsection of the source array_view 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_view.

    {
        static_assert(_Rank == 1, "rank must be 1");
        return section(Concurrency::index<1>(_I0), Concurrency::extent<1>(_E0));
    }

template<typename _Value_type, int _Rank = 1>

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

inline

Produces a two-dimensional subsection of the source array_view 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_view.

    {
        static_assert(_Rank == 2, "rank must be 2");
        return section(Concurrency::index<2>(_I0,_I1), Concurrency::extent<2>(_E0,_E1));
    }

template<typename _Value_type, int _Rank = 1>

array_view Concurrency::array_view< _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_view 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_view.

    {
        static_assert(_Rank == 3, "rank must be 3");
        return section(Concurrency::index<3>(_I0,_I1,_I2), Concurrency::extent<3>(_E0,_E1,_E2));
    }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array_view< _Value_type, _Rank >::synchronize ( access_type  _Access_type = access_type_read ) const

inline

Synchronizes any modifications made to "this" array_view to its source data.

Parameters

_Access_type

The desired access_type on the target accelerator_view. This parameter has a default value of access_type_read.

    {
        auto _Span_id = details::_Get_amp_trace()->_Start_array_view_synchronize_event_helper(_M_buffer_descriptor);

        _Buffer_ptr _PBuf;

        // If the array_view corresponds to a ubiquitous buffer with no data source, then synchronize is a no-op
        if ((_Access_type != access_type_none) && _M_buffer_descriptor._Get_buffer_ptr()->_Has_data_source()) 
        {
            _Get_access_async(_M_buffer_descriptor._Get_view_key(),
                              _M_buffer_descriptor._Get_buffer_ptr()->_Get_master_accelerator_view(),
                              _Get_synchronize_access_mode(_Access_type),
                              _PBuf)._Get();
        }

        details::_Get_amp_trace()->_Write_end_event(_Span_id);
    }

template<typename _Value_type, int _Rank = 1>

concurrency::completion_future Concurrency::array_view< _Value_type, _Rank >::synchronize_async ( access_type  _Access_type = access_type_read ) const

inline

Asynchronously synchronizes any modifications made to "this" array_view to its source data.

Parameters

_Access_type

The desired access_type on the target accelerator_view. This parameter has a default value of access_type_read.

Returns

A future upon which to wait for the operation to complete.

    {
        auto _Async_op_id = details::_Get_amp_trace()->_Launch_array_view_synchronize_event_helper(_M_buffer_descriptor);

        _Buffer_ptr _PBuf;
        _Event _Ev;

        // If the array_view corresponds to a ubiquitous buffer with no data source, then synchronize is a no-op
        if ((_Access_type != access_type_none) && _M_buffer_descriptor._Get_buffer_ptr()->_Has_data_source())
        {
            _Ev = _Get_access_async(_M_buffer_descriptor._Get_view_key(),
                                    _M_buffer_descriptor._Get_buffer_ptr()->_Get_master_accelerator_view(),
                                    _Get_synchronize_access_mode(_Access_type),
                                    _PBuf);
        }

        return details::_Get_amp_trace()->_Start_async_op_wait_event_helper(_Async_op_id, _Ev);
    }

template<typename _Value_type, int _Rank = 1>

void Concurrency::array_view< _Value_type, _Rank >::synchronize_to ( const accelerator_view &  _Accl_view, access_type  _Access_type = access_type_read  ) const

inline

Synchronizes any modifications made to "this" array_view to the specified accelerator_view.

Parameters

_Accl_view	The target accelerator_view to synchronize to.
_Access_type	The desired access_type on the target accelerator_view. This parameter has a default value of access_type_read.

    {
        auto _Span_id = details::_Get_amp_trace()->_Start_array_view_synchronize_event_helper(_M_buffer_descriptor);

        _Buffer_ptr _PBuf;

        if (_Access_type != access_type_none) {
            _Get_access_async(_M_buffer_descriptor._Get_view_key(), _Accl_view, _Get_synchronize_access_mode(_Access_type), _PBuf)._Get();
        }

        details::_Get_amp_trace()->_Write_end_event(_Span_id);
    }

template<typename _Value_type, int _Rank = 1>

concurrency::completion_future Concurrency::array_view< _Value_type, _Rank >::synchronize_to_async ( const accelerator_view &  _Accl_view, access_type  _Access_type = access_type_read  ) const

inline

Asynchronously synchronizes any modifications made to "this" array_view to the specified accelerator_view.

Parameters

_Accl_view	The target accelerator_view to synchronize to.
_Access_type	The desired access_type on the target accelerator_view. This parameter has a default value of access_type_read.

Returns

A future upon which to wait for the operation to complete.

    {
        auto _Async_op_id = details::_Get_amp_trace()->_Launch_array_view_synchronize_event_helper(_M_buffer_descriptor);

        _Buffer_ptr _PBuf;
        _Event _Ev;

        if (_Access_type != access_type_none) {
            _Ev = _Get_access_async(_M_buffer_descriptor._Get_view_key(), _Accl_view, _Get_synchronize_access_mode(_Access_type), _PBuf);
        }

        return details::_Get_amp_trace()->_Start_async_op_wait_event_helper(_Async_op_id, _Ev);
    }

template<typename _Value_type, int _Rank = 1>

template<int _New_rank>

array_view<_Value_type,_New_rank> Concurrency::array_view< _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_view's data.

Parameters

_View_extent

The reshaping extent.

Returns

A reshaped array_view.

    {
        return _Convert<_Value_type>(_View_as(_View_extent));
    }

Friends And Related Function Documentation

template<typename _Value_type, int _Rank = 1>

template<typename _T , int _R>

friend class array

friend

template<typename _Value_type, int _Rank = 1>

friend class array_view< _Value_type, _Rank >

friend

template<typename _Value_type, int _Rank = 1>

friend class array_view< _Value_type, _Rank+1 >

friend

template<typename _Value_type, int _Rank = 1>

friend class array_view< const _Value_type, _Rank >

friend

template<typename _Value_type, int _Rank = 1>

friend class array_view< const _Value_type, _Rank+1 >

friend

template<typename _Value_type, int _Rank = 1>

friend class details::_Array_view_projection_helper< _Value_type, _Rank >

friend

template<typename _Value_type, int _Rank = 1>

friend class details::_Array_view_projection_helper< _Value_type, _Rank+1 >

friend

template<typename _Value_type, int _Rank = 1>

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

friend

Member Data Documentation

template<typename _Value_type, int _Rank = 1>

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

static

---

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

• VS2013/inc/amp.h