#include <amprt.h>

Inheritance diagram for Concurrency::details::_View_shape:

Public Member Functions
_AMPIMP _Ret_ _View_shape *	_Get_reduced_shape_for_copy ()

unsigned int	_Get_rank () const

unsigned int	_Get_linear_offset () const

const unsigned int *	_Get_base_extent () const

const unsigned int *	_Get_view_offset () const

const unsigned int *	_Get_view_extent () const

const bool *	_Get_projection_info () const

bool	_Is_projection () const

bool	_Is_valid (size_t _Buffer_size) const

unsigned int	_Get_view_size () const

unsigned int	_Get_view_linear_offset () const

bool	_Is_view_linear (unsigned int &_Linear_offset, unsigned int &_Linear_size) const

bool	_Overlaps (const _View_shape *_Other) const

bool	_Subsumes (const _View_shape *_Other) const

Public Member Functions inherited from Concurrency::details::_Reference_counter
	_Reference_counter ()

virtual	~_Reference_counter ()

size_t	_Add_reference ()

size_t	_Remove_reference ()

_AMPIMP void	_Release ()

size_t	_Get_reference_count ()

Static Public Member Functions
static _AMPIMP _Ret_ _View_shape *__cdecl	_Create_view_shape (unsigned int _Rank, unsigned int _Linear_offset, const unsigned int _Base_extent, const unsigned int _View_offset, const unsigned int _View_extent, const bool _Projection_info=NULL)

static bool	_Compare_extent_with_elem_size (unsigned int _Rank, const unsigned int _Extent1, size_t _Elem_size1, const unsigned int _Extent2, size_t _Elem_size2)

static bool	_Compare_extent (unsigned int _Rank, const unsigned int _Extent1, const unsigned int _Extent2)

Private Member Functions
	_View_shape (unsigned int _Rank, unsigned int _Linear_offset, const unsigned int _Base_extent, const unsigned int _View_offset, const unsigned int _View_extent, const bool _Projection_info)

virtual	~_View_shape ()

	_View_shape ()

	_View_shape (const _View_shape &_Other)

	_View_shape (_View_shape &&_Other)

_View_shape &	operator= (const _View_shape &_Other)

_View_shape &	operator= (_View_shape &&_Other)

bool	_Is_valid () const

bool	_Compare_base_shape (const _View_shape *_Other) const

bool	_Contains (const unsigned int *_Element_index) const

unsigned int	_Get_linear_offset (const unsigned int *_Element_index) const

Static Private Member Functions
static bool	_Intervals_overlap (size_t _First_start, size_t _First_end, size_t _Second_start, size_t _Second_end)

static unsigned int	_Get_extent_size (unsigned int _Rank, const unsigned int *_Extent)

Private Attributes
unsigned int	_M_rank

unsigned int	_M_linear_offset

unsigned int *	_M_base_extent

unsigned int *	_M_view_offset

unsigned int *	_M_view_extent

bool *	_M_projection_info

Constructor & Destructor Documentation

Concurrency::details::_View_shape::_View_shape	(	unsigned int	_Rank,
		unsigned int	_Linear_offset,
		const unsigned int *	_Base_extent,
		const unsigned int *	_View_offset,
		const unsigned int *	_View_extent,
		const bool *	_Projection_info
	)

private

virtual Concurrency::details::_View_shape::~_View_shape ( )

privatevirtual

Concurrency::details::_View_shape::_View_shape ( )

private

Concurrency::details::_View_shape::_View_shape ( const _View_shape & _Other )

private

Concurrency::details::_View_shape::_View_shape ( _View_shape && _Other )

private

Member Function Documentation

bool Concurrency::details::_View_shape::_Compare_base_shape ( const _View_shape * _Other ) const

inlineprivate

         {
             return ((_M_rank == _Other->_M_rank) &&
                     (_M_linear_offset == _Other->_M_linear_offset) &&
                     _Compare_extent(_M_rank, _M_base_extent, _Other->_M_base_extent));
         }

static bool Concurrency::details::_View_shape::_Compare_extent	(	unsigned int	_Rank,
		const unsigned int *	_Extent1,
		const unsigned int *	_Extent2
	)

inlinestatic

         {
             for (size_t _I = 0; _I < _Rank; ++_I) {
                 if (_Extent1[_I] != _Extent2[_I]) {
                     return false;
                 }
             }
 
             return true;
         }

static bool Concurrency::details::_View_shape::_Compare_extent_with_elem_size	(	unsigned int	_Rank,
		const unsigned int *	_Extent1,
		size_t	_Elem_size1,
		const unsigned int *	_Extent2,
		size_t	_Elem_size2
	)

inlinestatic

         {
             _ASSERTE((_Rank >= 1) && (_Extent1 != NULL)&& (_Extent2 != NULL));
 
             // The extents should match accounting for the element sizes of the respective buffers
             if ((_Extent1[_Rank - 1] * _Elem_size1) != (_Extent2[_Rank - 1] * _Elem_size2)) 
             {
                 return false;
             }
 
             // Now compare the extent in all but the least significant dimension
             if ((_Rank > 1) && !_Compare_extent(_Rank - 1, _Extent1, _Extent2))
             {
                 return false;
             }
 
             return true;
         }

bool Concurrency::details::_View_shape::_Contains ( const unsigned int * _Element_index ) const

inlineprivate

         {
             for (size_t _I = 0; _I < _M_rank; ++_I)
             {
                 if ((_Element_index[_I] < _M_view_offset[_I]) ||
                     (_Element_index[_I] >= (_M_view_offset[_I] + _M_view_extent[_I]))) 
                 {
                     return false;
                 }
             }
 
             return true;
         }

static _AMPIMP _Ret_ _View_shape* __cdecl Concurrency::details::_View_shape::_Create_view_shape	(	unsigned int	_Rank,
		unsigned int	_Linear_offset,
		const unsigned int *	_Base_extent,
		const unsigned int *	_View_offset,
		const unsigned int *	_View_extent,
		const bool *	_Projection_info = `NULL`
	)

static

const unsigned int* Concurrency::details::_View_shape::_Get_base_extent ( ) const

inline

         {
             return _M_base_extent;
         }

static unsigned int Concurrency::details::_View_shape::_Get_extent_size	(	unsigned int	_Rank,
		const unsigned int *	_Extent
	)

inlinestaticprivate

         {
             unsigned int totalExtent = 1;
             for (size_t _I = 0; _I < _Rank; ++_I) {
                 totalExtent *= _Extent[_I];
             }
 
             return totalExtent;
         }

unsigned int Concurrency::details::_View_shape::_Get_linear_offset ( ) const

inline

         {
             return _M_linear_offset;
         }

unsigned int Concurrency::details::_View_shape::_Get_linear_offset ( const unsigned int * _Element_index ) const

inlineprivate

         {
             unsigned int currMultiplier = 1;
             unsigned int linearOffset = _M_linear_offset;
             for (int _I = static_cast<int>(_M_rank - 1); _I >= 0; _I--)
             {
                 linearOffset += (currMultiplier * _Element_index[_I]);
                 currMultiplier *= _M_base_extent[_I];
             }
 
             return linearOffset;
         }

const bool* Concurrency::details::_View_shape::_Get_projection_info ( ) const

inline

         {
             return _M_projection_info;
         }

unsigned int Concurrency::details::_View_shape::_Get_rank ( ) const

inline

         {
             return _M_rank;
         }

_AMPIMP _Ret_ _View_shape* Concurrency::details::_View_shape::_Get_reduced_shape_for_copy ( )

const unsigned int* Concurrency::details::_View_shape::_Get_view_extent ( ) const

inline

         {
             return _M_view_extent;
         }

unsigned int Concurrency::details::_View_shape::_Get_view_linear_offset ( ) const

inline

         {
             return _Get_linear_offset(_M_view_offset);
         }

const unsigned int* Concurrency::details::_View_shape::_Get_view_offset ( ) const

inline

         {
             return _M_view_offset;
         }

unsigned int Concurrency::details::_View_shape::_Get_view_size ( ) const

inline

         {
             return _Get_extent_size(_M_rank, _M_view_extent);
         }

static bool Concurrency::details::_View_shape::_Intervals_overlap	(	size_t	_First_start,
		size_t	_First_end,
		size_t	_Second_start,
		size_t	_Second_end
	)

inlinestaticprivate

         {
             // Order the intervals by their start points
             if (_First_start > _Second_start) {
                 size_t temp = _First_start;
                 _First_start = _Second_start;
                 _Second_start = temp;
 
                 temp = _First_end;
                 _First_end = _Second_end;
                 _Second_end = temp;
             }
 
             // The start of the second one must be within the bounds of the first one
             return (_Second_start <= _First_end);
         }

bool Concurrency::details::_View_shape::_Is_projection ( ) const

inline

         {
             return _M_projection_info[0];
         }

bool Concurrency::details::_View_shape::_Is_valid ( size_t _Buffer_size ) const

inline

         {
             // The end point of the base shape should not be greater than the size of the buffer
             size_t endLinearOffset = _M_linear_offset + _Get_extent_size(_M_rank, _M_base_extent);
             if (endLinearOffset > _Buffer_size) {
                 return false;
             }
 
             return _Is_valid();
         }

bool Concurrency::details::_View_shape::_Is_valid ( ) const

inlineprivate

         {
             if (_M_rank == 0) {
                 return false;
             }
 
             // Ensure the _M_view_offset + _M_view_extent is within the bounds of _M_base_extent
             size_t viewSize = 1;
             
             for (size_t _I = 0; _I < _M_rank; ++_I)
             {
                 viewSize *= _M_view_extent[_I];
                 if ((_M_view_offset[_I] + _M_view_extent[_I]) > _M_base_extent[_I]) {
                     return false;
                 }
             }
 
             if (viewSize == 0) {
                 return false;
             }
 
             return true;
         }

bool Concurrency::details::_View_shape::_Is_view_linear	(	unsigned int &	_Linear_offset,
		unsigned int &	_Linear_size
	)		const

inline

         {
             // The effective rank for the purpose of determining linearity
             // depends on the highest dimension in which the extent is not 1
             unsigned int _First_dim_with_non_unit_extent = 0;
             while ((_First_dim_with_non_unit_extent < _M_rank) && (_M_view_extent[_First_dim_with_non_unit_extent] == 1)) {
                 _First_dim_with_non_unit_extent++;
             }
 
             unsigned int _Effective_rank = (_M_rank - _First_dim_with_non_unit_extent);
 
             // It is linear if the effective rank is <= 1 or the base extent
             // and view extent are same in all but the highest dimension with
             // non-unit extent
             if ((_Effective_rank <= 1) ||
                 (_Compare_extent(_Effective_rank - 1, &_M_base_extent[_First_dim_with_non_unit_extent + 1], &_M_view_extent[_First_dim_with_non_unit_extent + 1]))) 
             {
                 _Linear_offset = _Get_view_linear_offset();
                 _Linear_size = _Get_view_size();
                 return true;
             }
 
             return false;
         }

bool Concurrency::details::_View_shape::_Overlaps ( const _View_shape * _Other ) const

inline

         {
             if (_Compare_base_shape(_Other))
             {
                 // If the base shapes are identical we will do the N-dimensional
                 // bounding box overlap test
                 
                 for (size_t _I = 0; _I < _M_rank; ++_I)
                 {
                     if (!_Intervals_overlap(_M_view_offset[_I], _M_view_offset[_I] + _M_view_extent[_I] - 1,
                                             _Other->_M_view_offset[_I], _Other->_M_view_offset[_I] + _Other->_M_view_extent[_I] - 1)) 
                     {
                         return false;
                     }
                 }
 
                 return true;
             }
             else
             {
                 // The base shapes are different. Check based on linear intervals
                 size_t firstStart = _Get_view_linear_offset();
                 size_t firstEnd = firstStart + _Get_view_size() - 1;
 
                 size_t secondStart = _Other->_Get_view_linear_offset();
                 size_t secondEnd = secondStart + _Other->_Get_view_size() - 1;
 
                 return _Intervals_overlap(firstStart, firstEnd, secondStart, secondEnd);
             }
         }

bool Concurrency::details::_View_shape::_Subsumes ( const _View_shape * _Other ) const

inline

         {
             // Subsumption test can only be done for shapes that have the same base shape or 
             // when both have a rank of 1
             if ((_M_rank == 1) && (_Other->_Get_rank() == 1)) 
             {
                 size_t thisStart = _Get_view_linear_offset();
                 size_t thisEnd = thisStart + _Get_view_size() - 1;
 
                 size_t otherStart = _Other->_Get_view_linear_offset();
                 size_t otherEnd = otherStart + _Other->_Get_view_size() - 1;
 
                 return ((otherStart >= thisStart) && (otherEnd <= thisEnd));
             }
 
             if (!_Compare_base_shape(_Other)) {
                 return false;
             }
 
             if (!_Contains(_Other->_Get_view_offset())) {
                 return false;
             }
 
             std::vector<unsigned int> otherEndPointIndex(_M_rank);
             for (size_t _I = 0; _I < _M_rank; ++_I) {
                 otherEndPointIndex[_I] = _Other->_Get_view_offset()[_I] + _Other->_Get_view_extent()[_I] - 1;
             }
 
             return _Contains(otherEndPointIndex.data());
         }

_View_shape& Concurrency::details::_View_shape::operator= ( const _View_shape & _Other )

private

_View_shape& Concurrency::details::_View_shape::operator= ( _View_shape && _Other )

private

Member Data Documentation

unsigned int* Concurrency::details::_View_shape::_M_base_extent

private

unsigned int Concurrency::details::_View_shape::_M_linear_offset

private

bool* Concurrency::details::_View_shape::_M_projection_info

private

unsigned int Concurrency::details::_View_shape::_M_rank

private

unsigned int* Concurrency::details::_View_shape::_M_view_extent

private

unsigned int* Concurrency::details::_View_shape::_M_view_offset

private

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

VS2013/inc/amprt.h

Public Member Functions

Static Public Member Functions

Private Member Functions

Static Private Member Functions

Private Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation