Concurrency::details::_Array_view_base< _Rank, _Element_size > Class Template Reference

#include <amp.h>

Inheritance diagram for Concurrency::details::_Array_view_base< _Rank, _Element_size >:

Public Types
typedef details::_Buffer_descriptor	_Buffer_descriptor

Public Member Functions
	~_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

Protected Member Functions
	_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
template<int _New_element_size>
_Array_view_base< _Rank, _New_element_size >	_Reinterpret_as () const __GPU
template<int _New_rank>
_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
_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

Private Member Functions
void	_Register () __CPU_ONLY
void	_Register_copy (const _Array_view_base &_Other) __CPU_ONLY
void	_Register (_In_ void *_Shape) __CPU_ONLY
void	_Unregister (bool _Throw_exception=true) __CPU_ONLY
void	_Register () __GPU_ONLY
void	_Register_copy (const _Array_view_base &_Other) __GPU_ONLY
void	_Register (_In_ void *_Shape) __GPU_ONLY
void	_Unregister (bool _Throw_exception=true) __GPU_ONLY

Static Private Member Functions
static _Ret_ void *	_Create_projection_buffer_shape (const _Buffer_descriptor &_Descriptor, unsigned int _Dim, int _Dim_offset) __CPU_ONLY
static _Ret_ void *	_Create_section_buffer_shape (const _Buffer_descriptor &_Descriptor, const Concurrency::index< _Rank > &_Section_origin, const Concurrency::extent< _Rank > &_Section_extent) __CPU_ONLY
static _Ret_ void *	_Create_projection_buffer_shape (const _Buffer_descriptor &_Descriptor, int _Dim, int _I) __GPU_ONLY
static _Ret_ void *	_Create_section_buffer_shape (const _Buffer_descriptor &_Descriptor, const Concurrency::index< _Rank > &_Section_origin, const Concurrency::extent< _Rank > &_Section_extent) __GPU_ONLY

Friends
template<int _R, int _S>
class	_Array_view_base

Member Typedef Documentation

template<int _Rank, int _Element_size>

typedef details::_Buffer_descriptor Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Buffer_descriptor

Constructor & Destructor Documentation

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::~_Array_view_base ( )

inline

    {
        // Unregister the view; Do not throw exception
        _Unregister(false);
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Array_view_base ( )

inlineprotected

{}

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Array_view_base ( const _Buffer_descriptor &  _Buffer_desc, const _Array_view_shape &  _Shape  )

inlineprotected

        :
        _M_buffer_descriptor(_Buffer_desc),
        _Array_view_shape<_Rank, _Element_size>(_Shape)
    {
        // Register the view
        _Register();
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Array_view_base ( const _Array_view_base< _Rank, _Element_size > &  _Other )

inlineprotected

        :
        _M_buffer_descriptor(_Other._M_buffer_descriptor),
        _Array_view_shape<_Rank, _Element_size>(_Other)
    {
        // Register the view
        _Register_copy(_Other);
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Array_view_base ( const _Array_view_base< _Rank, _Element_size > &  _Other, const Concurrency::extent< _Rank > &  _Array_extent  )

inlineprotected

        :
        _M_buffer_descriptor(_Other._M_buffer_descriptor),
        _Array_view_shape<_Rank, _Element_size>(_Other._Base_linear_offset(), _Array_extent)
    {
        // Register the view
        _Register();
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Array_view_base ( const _Array_view_base< _Rank, _Element_size > &  _Other, const Concurrency::index< _Rank > &  _Section_origin, const Concurrency::extent< _Rank > &  _Section_extent  )

inlineprotected

        :
        _M_buffer_descriptor(_Other._M_buffer_descriptor),
        _Array_view_shape<_Rank, _Element_size>(_Other, _Section_origin, _Section_extent)
    {
        // Register the view
        _Register();
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Array_view_base ( const _Buffer_descriptor &  _Buffer_desc, const Concurrency::extent< _Rank > &  _Array_extent  )

inlineprotected

        :
        _M_buffer_descriptor(_Buffer_desc),
        _Array_view_shape<_Rank, _Element_size>(0,_Array_extent)
    {
        // Register the view
        _Register();
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Array_view_base ( const _Buffer_descriptor &  _Buffer_desc, int  _Base_linear_offset, const Concurrency::extent< _Rank > &  _Array_extent  )

inlineprotected

        :
        _M_buffer_descriptor(_Buffer_desc),
        _Array_view_shape<_Rank, _Element_size>(_Base_linear_offset,_Array_extent)
    {
        // Register the view
        _Register();
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_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  )

inlineprotected

        :
        _M_buffer_descriptor(_Buffer_desc),
        _Array_view_shape<_Rank, _Element_size>(_Base_linear_offset,_Array_extent,_View_offset,_View_extent)
    {
        // Register the view
        _Register();
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_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  )

inlineprotected

        :
        _M_buffer_descriptor(_Buffer_desc),
        _Array_view_shape<_Rank, _Element_size>(0,_Array_extent,_Section_origin,_Section_extent)
    {
        // Register the view
        _Register();
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Array_view_base ( const Concurrency::extent< _Rank > &  _Array_extent )

inlineprotected

        :
        _Array_view_shape<_Rank, _Element_size>(0,_Array_extent)
    {
        _Ubiquitous_buffer_ptr _PUBuf = _Ubiquitous_buffer::_Create_ubiquitous_buffer(_Array_extent.size(), _Element_size * sizeof(int));
        _M_buffer_descriptor = _Buffer_descriptor(NULL, _PUBuf, _No_access, _No_access);

        // Register the view
        _Register();
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Array_view_base ( _In_ void *  _Data, const Concurrency::extent< _Rank > &  _Array_extent  )

inlineprotected

        :
        _Array_view_shape<_Rank, _Element_size>(0,_Array_extent)
    {
        if (_Data == NULL) {
            throw runtime_exception("Invalid pointer argument (NULL) to array_view constructor", E_INVALIDARG);
        }

        _Buffer_ptr _PBuf = _Buffer::_Create_buffer(_Data, accelerator(accelerator::cpu_accelerator).default_view, _Array_extent.size(), _Element_size * sizeof(int));
        _Ubiquitous_buffer_ptr _PUBuf = _Ubiquitous_buffer::_Create_ubiquitous_buffer(_PBuf);
        _M_buffer_descriptor = _Buffer_descriptor(_Data, _PUBuf, _Read_write_access, _Read_write_access);

        // Register the view
        _Register();
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Array_view_base ( _In_ void *  _Data, const Concurrency::extent< _Rank > &  _Array_extent  )

inlineprotected

        :
        _Array_view_shape<_Rank, _Element_size>(0,_Array_extent), _M_buffer_descriptor(_Data, NULL, _Read_write_access, _Read_write_access)
    {
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Array_view_base ( const void *  _Data, const Concurrency::extent< _Rank > &  _Array_extent  )

inlineprotected

        :
        _Array_view_shape<_Rank, _Element_size>(0,_Array_extent)
    {
        if (_Data == NULL) {
            throw runtime_exception("Invalid pointer argument (NULL) to array_view constructor", E_INVALIDARG);
        }

        _Buffer_ptr _PBuf = _Buffer::_Create_buffer(const_cast<void*>(_Data), accelerator(accelerator::cpu_accelerator).default_view, _Array_extent.size(), _Element_size * sizeof(int));
        _Ubiquitous_buffer_ptr _PUBuf = _Ubiquitous_buffer::_Create_ubiquitous_buffer(_PBuf);
        _M_buffer_descriptor = _Buffer_descriptor(const_cast<void*>(_Data), _PUBuf, _Read_access, _Read_access);

        // Register the view
        _Register();
    }

template<int _Rank, int _Element_size>

Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Array_view_base ( const void *  _Data, const Concurrency::extent< _Rank > &  _Array_extent  )

inlineprotected

        :
#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.
        _Array_view_shape<_Rank, _Element_size>(0,_Array_extent), _M_buffer_descriptor(const_cast<void*>(_Data), NULL, _Read_access, _Read_access)
#pragma warning( pop ) 
    {
    }

Member Function Documentation

template<int _Rank, int _Element_size>

_Ret_ void* Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Access ( const index< _Rank > &  _Index ) const

inlineprotected

    {
        int * _Ptr = reinterpret_cast<int *>(_M_buffer_descriptor._M_data_ptr);
        return &_Ptr[_M_total_linear_offset + (_Element_size * _Flatten_helper::func(_M_array_multiplier._M_base, _Index._M_base))]; 
    }

template<int _Rank, int _Element_size>

_Ret_ void* Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Access ( _Access_mode  _Requested_mode, const index< _Rank > &  _Index  ) const

inlineprotected

    {
        // Refresh the data ptr if we do not have requested access
        if ((_M_buffer_descriptor._M_curr_cpu_access_mode & _Requested_mode) != _Requested_mode) {
            _M_buffer_descriptor._Get_CPU_access(_Requested_mode);
        }

        return _Access(_Index);
    }

template<int _Rank, int _Element_size>

_Ret_ void* Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Access ( _Access_mode  _Requested_mode, const index< _Rank > &  _Index  ) const

inlineprotected

    {
        UNREFERENCED_PARAMETER(_Requested_mode);

        return _Access(_Index);
    }

template<int _Rank, int _Element_size>

_Ret_ _View_shape* Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Create_buffer_view_shape ( ) const

inlineprotected

    {
        unsigned int bufElemSize = static_cast<unsigned int>(_M_buffer_descriptor._Get_buffer_ptr()->_Get_master_buffer_elem_size());
        unsigned int elemSize = _Element_size * sizeof(int);

        size_t linearOffsetInBytes = _Base_linear_offset() * sizeof(int);

        size_t baseLSDExtentInBytes = _M_array_extent[_Rank - 1];
        baseLSDExtentInBytes *= elemSize;

        size_t viewLSDOffsetInBytes = _M_view_offset[_Rank - 1];
        viewLSDOffsetInBytes *= elemSize;

        size_t viewLSDExtentInBytes = _M_view_extent[_Rank - 1];
        viewLSDExtentInBytes *= elemSize;

        // The base array extent, view extent, and view offset must be compatible with the underlying 
        // buffer's element size
        if (((linearOffsetInBytes % bufElemSize) != 0) ||
            ((baseLSDExtentInBytes % bufElemSize) != 0) ||
            ((viewLSDOffsetInBytes % bufElemSize) != 0) ||
            ((viewLSDExtentInBytes % bufElemSize) != 0))
        {
            throw runtime_exception("The array_view base extent, view offset and/or view extent is incompatible with the underlying buffer", E_FAIL);
        }

        // The shape to be passed to the underlying buffer for registration must be in terms of
        // the element size of the buffer
        _ASSERTE((linearOffsetInBytes / bufElemSize) <= UINT_MAX);
        unsigned int linearOffset = static_cast<unsigned int>(linearOffsetInBytes / bufElemSize);

        unsigned int baseExtent[_Rank];
        unsigned int viewOffset[_Rank];
        unsigned int viewExtent[_Rank];
#pragma warning( push )
#pragma warning( disable : 6294 ) 
#pragma warning( disable : 6201 ) //  Index '-1' is out of valid index range '0' to '0' for possibly stack allocated buffer 'baseExtent'.
        for (int i = 0; i < _Rank - 1; ++i) {
            baseExtent[i] = _M_array_extent[i];
            viewOffset[i] = _M_view_offset[i];
            viewExtent[i] = _M_view_extent[i];
        }
#pragma warning( pop )

        // The extent in the least significant dimension needs to be adjusted for 
        // difference in element size between the buffer and ourselves
        _ASSERTE((baseLSDExtentInBytes / bufElemSize) <= UINT_MAX);
        baseExtent[_Rank - 1] = static_cast<unsigned int>(baseLSDExtentInBytes / bufElemSize);

        _ASSERTE((viewLSDOffsetInBytes / bufElemSize) <= UINT_MAX);
        viewOffset[_Rank - 1] = static_cast<unsigned int>(viewLSDOffsetInBytes / bufElemSize);

        _ASSERTE((viewLSDExtentInBytes / bufElemSize) <= UINT_MAX);
        viewExtent[_Rank - 1] = static_cast<unsigned int>(viewLSDExtentInBytes / bufElemSize);

        return _View_shape::_Create_view_shape(_Rank, linearOffset, baseExtent, viewOffset, viewExtent);
    }

template<int _Rank, int _Element_size>

static _Ret_ void* Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Create_projection_buffer_shape ( const _Buffer_descriptor &  _Descriptor, unsigned int  _Dim, int  _Dim_offset  )

inlinestaticprivate

    {
        _View_shape* _Base_shape = _Get_buffer_view_shape(_Descriptor);

        std::vector<unsigned int> _New_view_extent(_Base_shape->_Get_rank());
        std::vector<unsigned int> _New_view_offset(_Base_shape->_Get_rank());
        bool *_New_projection_info = new bool[_Base_shape->_Get_rank()];
        for (unsigned int _I = 0; _I < _Base_shape->_Get_rank(); ++_I)
        {
            _New_view_extent[_I] = _Base_shape->_Get_view_extent()[_I];
            _New_view_offset[_I] = _Base_shape->_Get_view_offset()[_I];
            _New_projection_info[_I] = _Base_shape->_Get_projection_info()[_I];
        }

        // The _Dim'th non-projected dimension needs to be found
        unsigned int _UnProjectedDimCount = 0;
        for (unsigned int _I = 0; _I < _Base_shape->_Get_rank(); ++_I)
        {
            if (_Base_shape->_Get_projection_info()[_I]) {
                continue;
            }

            if (_UnProjectedDimCount == _Dim) {
                _New_view_extent[_I] = 1;
                _New_view_offset[_I] += _Dim_offset;
                _New_projection_info[_I] = true;
                break;
            }
            else {
                _UnProjectedDimCount++;
            }
        }

        auto _PView_shape = _View_shape::_Create_view_shape(_Base_shape->_Get_rank(),
                                                            _Base_shape->_Get_linear_offset(),
                                                            _Base_shape->_Get_base_extent(),
                                                            _New_view_offset.data(),
                                                            _New_view_extent.data(),
                                                            _New_projection_info);

        delete [] _New_projection_info;

        return _PView_shape;
    }

template<int _Rank, int _Element_size>

static _Ret_ void* Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Create_projection_buffer_shape ( const _Buffer_descriptor &  _Descriptor, int  _Dim, int  _I  )

inlinestaticprivate

    {
        UNREFERENCED_PARAMETER(_Descriptor);
        UNREFERENCED_PARAMETER(_Dim);
        UNREFERENCED_PARAMETER(_I);

        return NULL;
    }

template<int _Rank, int _Element_size>

static _Ret_ void* Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Create_section_buffer_shape ( const _Buffer_descriptor &  _Descriptor, const Concurrency::index< _Rank > &  _Section_origin, const Concurrency::extent< _Rank > &  _Section_extent  )

inlinestaticprivate

    {
        _View_shape* _Base_shape = _Get_buffer_view_shape(_Descriptor);
        if (_Base_shape->_Get_rank() == _Rank) {
            return NULL;
        }

        std::vector<unsigned int> _New_view_extent(_Base_shape->_Get_rank());
        std::vector<unsigned int> _New_view_offset(_Base_shape->_Get_rank());
        unsigned int _I = 0, _J = 0;
        while (_I < _Base_shape->_Get_rank())
        {
            if (_Base_shape->_Get_projection_info()[_I]) 
            {
                _New_view_extent[_I] = _Base_shape->_Get_view_extent()[_I];
                _New_view_offset[_I] = _Base_shape->_Get_view_offset()[_I];
            }
            else 
            {
                // If _J is the least significant dimension, then we need to adjust the 
                // offset and extent for the underlying buffer's element size
                if (_J == (_Rank - 1)) 
                {
                    unsigned int bufElemSize = static_cast<unsigned int>(_Descriptor._Get_buffer_ptr()->_Get_master_buffer_elem_size());
                    unsigned int elemSize = _Element_size * sizeof(int);

                    size_t sectionLSDOriginInBytes = _Section_origin[_J];
                    sectionLSDOriginInBytes *= elemSize;

                    size_t sectionLSDExtentInBytes = _Section_extent[_J];
                    sectionLSDExtentInBytes *= elemSize;

                    // The section offset and extent must be compatible with the underlying 
                    // buffer's element size
                    if (((sectionLSDOriginInBytes % bufElemSize) != 0) ||
                        ((sectionLSDExtentInBytes % bufElemSize) != 0))
                    {
                        throw runtime_exception("The array_view section origin and/or extent is incompatible with the underlying buffer", E_FAIL);
                    }

                    // The extent in the least significant dimension needs to be adjusted for 
                    // difference in element size between the buffer and ourselves
                    _ASSERTE((sectionLSDOriginInBytes / bufElemSize) <= UINT_MAX);
                    _New_view_offset[_I] = _Base_shape->_Get_view_offset()[_I] + static_cast<unsigned int>(sectionLSDOriginInBytes / bufElemSize);

                    _ASSERTE((sectionLSDExtentInBytes / bufElemSize) <= UINT_MAX);
                    _New_view_extent[_I] = static_cast<unsigned int>(sectionLSDExtentInBytes / bufElemSize);
                }
                else 
                {
                    _New_view_extent[_I] = _Section_extent[_J];
                    _New_view_offset[_I] = _Base_shape->_Get_view_offset()[_I] + _Section_origin[_J];
                }

                _J++;
            }

            _I++;
        }

        _ASSERTE(_J == _Rank);

        return _View_shape::_Create_view_shape(_Base_shape->_Get_rank(),
                                               _Base_shape->_Get_linear_offset(),
                                               _Base_shape->_Get_base_extent(),
                                               _New_view_offset.data(),
                                               _New_view_extent.data(),
                                               _Base_shape->_Get_projection_info());
    }

template<int _Rank, int _Element_size>

static _Ret_ void* Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Create_section_buffer_shape ( const _Buffer_descriptor &  _Descriptor, const Concurrency::index< _Rank > &  _Section_origin, const Concurrency::extent< _Rank > &  _Section_extent  )

inlinestaticprivate

    {
        UNREFERENCED_PARAMETER(_Descriptor);
        UNREFERENCED_PARAMETER(_Section_origin);
        UNREFERENCED_PARAMETER(_Section_extent);

        return NULL;
    }

template<int _Rank, int _Element_size>

void Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Project0 ( int  _I, _Array_view_base< _Rank-1, _Element_size > &  _Projected_view  ) const

inlineprotected

    {
        _Projected_view._M_buffer_descriptor = this->_M_buffer_descriptor;
        _Array_view_shape<_Rank, _Element_size>::_Project0(_I, _Projected_view);

        // Register the constructed view with the projection buffer view shape
        _Projected_view._Register(_Array_view_base::_Create_projection_buffer_shape(this->_M_buffer_descriptor, 0, _I));
    }

template<int _Rank, int _Element_size>

void Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Register ( )

inlineprivate

    {
        _M_buffer_descriptor._Get_buffer_ptr()->_Register_view(_M_buffer_descriptor._Get_view_key(),
                                                               accelerator(accelerator::cpu_accelerator).default_view,
                                                               _Create_buffer_view_shape());

        if (_M_buffer_descriptor._M_curr_cpu_access_mode != _No_access) 
        {
            _Buffer_ptr _PBuf;
            _Get_access_async(_M_buffer_descriptor._Get_view_key(),
                              accelerator(accelerator::cpu_accelerator).default_view,
                              _M_buffer_descriptor._M_curr_cpu_access_mode,
                              _PBuf)._Get();

            _M_buffer_descriptor._M_data_ptr = _PBuf->_Get_host_ptr();
        }
    }

template<int _Rank, int _Element_size>

void Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Register ( _In_ void *  _Shape )

inlineprivate

    {
        if (_Shape == NULL) {
            return;
        }

        // Unregister and register with the right shape
        _Unregister();

        _M_buffer_descriptor._Get_buffer_ptr()->_Register_view(_M_buffer_descriptor._Get_view_key(),
                                                               accelerator(accelerator::cpu_accelerator).default_view,
                                                               reinterpret_cast<_View_shape*>(_Shape));

        if (_M_buffer_descriptor._M_curr_cpu_access_mode != _No_access) 
        {
            _Buffer_ptr _PBuf;
            _Get_access_async(_M_buffer_descriptor._Get_view_key(),
                              accelerator(accelerator::cpu_accelerator).default_view,
                              _M_buffer_descriptor._M_curr_cpu_access_mode,
                              _PBuf)._Get();

            _M_buffer_descriptor._M_data_ptr = _PBuf->_Get_host_ptr();
        }
    }

template<int _Rank, int _Element_size>

void Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Register ( )

inlineprivate

{}

template<int _Rank, int _Element_size>

void Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Register ( _In_ void *  _Shape )

inlineprivate

    {
        UNREFERENCED_PARAMETER(_Shape);
    }

template<int _Rank, int _Element_size>

void Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Register_copy ( const _Array_view_base< _Rank, _Element_size > &  _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<int _Rank, int _Element_size>

void Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Register_copy ( const _Array_view_base< _Rank, _Element_size > &  _Other )

inlineprivate

    {
        UNREFERENCED_PARAMETER(_Other);
    }

template<int _Rank, int _Element_size>

template<int _New_element_size>

_Array_view_base<_Rank,_New_element_size> Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Reinterpret_as ( ) const

inlineprotected

    {
        static_assert(_Rank==1, "reinterpret_as is only permissible on array views of rank 1");
        int _New_size = _Calculate_reinterpreted_size<_Element_size,_New_element_size>(_M_view_extent.size());
        return _Array_view_base<_Rank,_New_element_size>(this->_M_buffer_descriptor,
                                                         _M_total_linear_offset,
                                                         Concurrency::extent<_Rank>(_New_size));
    }

template<int _Rank, int _Element_size>

_Array_view_base Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Section ( const Concurrency::index< _Rank > &  _Section_origin, const Concurrency::extent< _Rank > &  _Section_extent  ) const

inlineprotected

    {
        auto _View = _Array_view_base(*this, _Section_origin, _Section_extent);

        // Register the constructed view with the section buffer view shape
        _View._Register(_Array_view_base::_Create_section_buffer_shape(this->_M_buffer_descriptor, _Section_origin, _Section_extent));

        return _View;
    }

template<int _Rank, int _Element_size>

_Array_view_base Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Section ( const index< _Rank > &  _Idx ) const

inlineprotected

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

template<int _Rank, int _Element_size>

void Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Unregister ( bool  _Throw_exception = true )

inlineprivate

    {
        if (!_Throw_exception && (std::current_exception() == nullptr)) {
            _Throw_exception = true;
        }

        try
        {
            _M_buffer_descriptor._Get_buffer_ptr()->_Unregister_view(_M_buffer_descriptor._Get_view_key());
        }
        catch(...)
        {
            if (_Throw_exception) {
                throw;
            }
        }
    }

template<int _Rank, int _Element_size>

void Concurrency::details::_Array_view_base< _Rank, _Element_size >::_Unregister ( bool  _Throw_exception = true )

inlineprivate

    {
        UNREFERENCED_PARAMETER(_Throw_exception);
    }

template<int _Rank, int _Element_size>

template<int _New_rank>

_Array_view_base<_New_rank, _Element_size> Concurrency::details::_Array_view_base< _Rank, _Element_size >::_View_as ( const Concurrency::extent< _New_rank > &  _View_extent ) const

inlineprotected

    {
        static_assert(_Rank==1, "view_as is only permissible on array views of rank 1");
        return _Array_view_base<_New_rank, _Element_size>(this->_M_buffer_descriptor,
                                                          _M_total_linear_offset,
                                                          _View_extent,
                                                          index<_New_rank>(),
                                                          _View_extent);
    }

template<int _Rank, int _Element_size>

_Array_view_base& Concurrency::details::_Array_view_base< _Rank, _Element_size >::operator= ( const _Array_view_base< _Rank, _Element_size > &  _Other )

inlineprotected

    {
        if (this != &_Other)
        {
            // Unregister the current view
            _Unregister();

            _M_buffer_descriptor = _Other._M_buffer_descriptor;
            _Array_view_shape<_Rank, _Element_size>::operator=(_Other);

            // Register the new view
            _Register_copy(_Other);
        }

        return *this;
    }

Friends And Related Function Documentation

template<int _Rank, int _Element_size>

template<int _R, int _S>

friend class _Array_view_base

friend

Member Data Documentation

template<int _Rank, int _Element_size>

_Buffer_descriptor Concurrency::details::_Array_view_base< _Rank, _Element_size >::_M_buffer_descriptor

protected

---

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

• VS2013/inc/amp.h