/***
* ==++==
*
* Copyright (c) Microsoft Corporation. All rights reserved.
*
* ==--==
* =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
*
* amprt.h
*
* Define the C++ interfaces exported by the C++ AMP runtime
*
* =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
****/
#pragma once
#if !(defined (_M_X64) || defined (_M_IX86) || defined (_M_ARM) || defined (_M_ARM64) )
#error ERROR: C++ AMP runtime is supported only on X64, X86, ARM, and ARM64 architectures.
#endif
#if defined (_M_CEE)
#error ERROR: C++ AMP runtime is not supported when compiling /clr.
#endif
#ifndef __cplusplus
#error ERROR: C++ AMP runtime is supported only for C++.
#endif
#if !defined(_CXXAMP)
#if defined(_DEBUG)
#pragma comment(lib, "vcampd")
#else // _DEBUG
#pragma comment(lib, "vcamp")
#endif // _DEBUG
#endif // _CXXAMP
#if !defined(_CXXAMP)
#define __GPU restrict(amp,cpu)
#define __GPU_ONLY restrict(amp)
#define __CPU_ONLY
#else
#define __GPU
#define __GPU_ONLY
#define __CPU_ONLY
#endif // _CXXAMP
#include <exception>
#include <unknwn.h>
#include <crtdbg.h>
#include <string>
#include <vector>
#if defined(_CXXAMP)
#include <strsafe.h>
#endif // _CXXAMP
#include <future>
#include <functional>
#include <map>
#include <unordered_map>
#include <set>
#include <unordered_set>
#include <concrt.h>
#include <type_traits>
#if !defined(_AMPIMP)
#define _AMPIMP __declspec(dllimport)
#endif
#pragma pack(push,8)
// Part of runtime-compiler interface
extern "C"
{
// Access mode of fields
enum _Access_mode
{
_No_access = 0,
_Read_access = (1 << 0),
_Write_access = (1 << 1),
_Is_array_mode = (1 << 30),
_Read_write_access = _Read_access | _Write_access,
};
}
namespace Concurrency
{
/// <summary>
/// Enumeration type used to denote the various types of access to data.
/// </summary>
enum access_type
{
access_type_none = 0,
access_type_read = (1 << 0),
access_type_write = (1 << 1),
access_type_read_write = access_type_read | access_type_write,
access_type_auto = (1 << 31),
};
// Forward declarations
class accelerator_view;
class accelerator;
namespace details
{
const size_t ERROR_MSG_BUFFER_SIZE = 1024;
// A reference counter to be used as the base class for all reference counted types.
class _Reference_counter
{
public:
// Constructor.
_Reference_counter() : _M_rc(0) {}
// Destructor.
virtual ~_Reference_counter() {}
// Add a reference.
// Thread-safe.
size_t _Add_reference()
{
return InterlockedIncrement(reinterpret_cast<LONG volatile*>(&_M_rc));
}
// Remove a reference.
// Thread-safe.
size_t _Remove_reference()
{
_ASSERTE(_M_rc > 0);
size_t refCount = InterlockedDecrement(reinterpret_cast<LONG volatile*>(&_M_rc));
if (refCount == 0)
this->_Release();
return refCount;
}
// Release the counter
_AMPIMP void _Release();
// Return the reference count value
size_t _Get_reference_count()
{
return _M_rc;
}
private:
size_t _M_rc;
};
// A smart pointer to a reference counted object
// T must be a type derived from _Reference_counter
template <class T>
class _Reference_counted_obj_ptr
{
public:
// Constructor
_Reference_counted_obj_ptr(T* _Ptr = NULL) : _M_obj_ptr(_Ptr)
{
_Init();
}
// Copy constructor
_Reference_counted_obj_ptr(const _Reference_counted_obj_ptr &_Other) : _M_obj_ptr(_Other._M_obj_ptr)
{
_Init();
}
// Move constructor
_Reference_counted_obj_ptr(_Reference_counted_obj_ptr &&_Other) : _M_obj_ptr(_Other._M_obj_ptr)
{
_Other._M_obj_ptr = nullptr;
// No change to ref-count
}
// Destructor
~_Reference_counted_obj_ptr()
{
if (_M_obj_ptr != NULL) {
_UnInitialize(_M_obj_ptr);
}
}
// Assignment operator
_Reference_counted_obj_ptr& operator=(const _Reference_counted_obj_ptr &_Other)
{
if (_M_obj_ptr != _Other._M_obj_ptr)
{
T *oldPtr = _M_obj_ptr;
_M_obj_ptr = _Other._M_obj_ptr;
_Init();
if (oldPtr != NULL) {
_UnInitialize(oldPtr);
}
}
return *this;
}
// Move-assignment operator
_Reference_counted_obj_ptr& operator=(_Reference_counted_obj_ptr &&_Other)
{
if (_M_obj_ptr != _Other._M_obj_ptr)
{
T *oldPtr = _M_obj_ptr;
_M_obj_ptr = _Other._M_obj_ptr;
_Other._M_obj_ptr = nullptr;
// No change to ref-count of the adopted pointer.
if (oldPtr != nullptr)
{
_UnInitialize(oldPtr);
}
}
return *this;
}
_Ret_ T* operator->() const
{
return _M_obj_ptr;
}
T& operator*() const
{
return *_M_obj_ptr;
}
operator T*() const
{
return _M_obj_ptr;
}
_Ret_ T* _Get_ptr() const
{
return _M_obj_ptr;
}
private:
T *_M_obj_ptr;
void _Init()
{
if (_M_obj_ptr == NULL)
return;
reinterpret_cast<_Reference_counter*>(_M_obj_ptr)->_Add_reference();
}
static void _UnInitialize(_In_ T *_Obj_ptr)
{
reinterpret_cast<_Reference_counter*>(_Obj_ptr)->_Remove_reference();
}
};
// Forward declarations
class _Trace;
class _Amp_runtime_trace;
class _Buffer;
class _Texture;
class _Sampler;
class _Ubiquitous_buffer;
class _D3D_interop;
class _Accelerator_view_impl;
class _CPU_accelerator_view_impl;
class _D3D_accelerator_view_impl;
class _Accelerator_impl;
class _Event_impl;
class _DPC_runtime_factory;
class _View_shape;
struct _Buffer_descriptor;
class _Accelerator_view_hasher;
struct _DPC_shader_blob;
struct _View_info;
// The enum specifies the base type for short vector type.
enum _Short_vector_base_type_id : unsigned int
{
_Uint_type = 0,
_Int_type = 1,
_Float_type = 2,
_Unorm_type = 3,
_Norm_type = 4,
_Double_type = 5,
_Invalid_type = 0xFFFFFFFF
};
typedef enum _Short_vector_base_type_id _Texture_base_type_id;
} // namespace Concurrency::details
typedef details::_Reference_counted_obj_ptr<details::_Accelerator_view_impl> _Accelerator_view_impl_ptr;
typedef details::_Reference_counted_obj_ptr<details::_Accelerator_impl> _Accelerator_impl_ptr;
typedef details::_Reference_counted_obj_ptr<details::_Buffer> _Buffer_ptr;
typedef details::_Reference_counted_obj_ptr<details::_Texture> _Texture_ptr;
typedef details::_Reference_counted_obj_ptr<details::_Sampler> _Sampler_ptr;
typedef details::_Reference_counted_obj_ptr<details::_Ubiquitous_buffer> _Ubiquitous_buffer_ptr;
typedef details::_Reference_counted_obj_ptr<details::_Event_impl> _Event_impl_ptr;
typedef details::_Reference_counted_obj_ptr<details::_View_shape> _View_shape_ptr;
namespace details
{
// The _Event class.
class _Event
{
friend class _Buffer;
friend class _Texture;
friend class accelerator_view;
friend class _D3D_accelerator_view_impl;
public:
/// <summary>
/// Constructor of the _Event.
/// </summary>
_AMPIMP _Event();
/// <summary>
/// Destructor of the _Event.
/// </summary>
_AMPIMP ~_Event();
/// <summary>
/// Copy constructor
/// </summary>
_AMPIMP _Event(const _Event & _Other);
/// <summary>
/// Assignment operator
/// </summary>
_AMPIMP _Event & operator=(const _Event & _Other);
/// <summary>
/// Poll whether the _Event has completed or not. Swallows any exceptions
/// </summary>
/// <returns>
/// true, if the _Event has completed, false otherwise
/// </returns>
_AMPIMP bool _Is_finished_nothrow();
/// <summary>
/// Poll whether the _Event has completed or not and throws any exceptions that occur
/// </summary>
/// <returns>
/// true, if the _Event has completed, false otherwise
/// </returns>
_AMPIMP bool _Is_finished();
/// <summary>
/// Wait until the _Event completes and throw any exceptions that occur.
/// </summary>
_AMPIMP void _Get();
/// <summary>
/// Tells if this is an empty event
/// </summary>
/// <returns>
/// true, if the _Event is empty
/// false, otherwise
/// </returns>
_AMPIMP bool _Is_empty() const;
/// <summary>
/// Creates an event which is an ordered collection of this and _Ev
/// </summary>
/// <returns>
/// The composite event
/// </returns>
_AMPIMP _Event _Add_event(_Event _Ev);
/// <summary>
/// Creates an event which is an ordered collection of this and a continuation task
/// </summary>
/// <returns>
/// The composite event
/// </returns>
_AMPIMP _Event _Add_continuation(const std::function<_Event __cdecl ()> &_Continuation_task);
/// <summary>
/// Return true if the other _Event is same as this _Event; false otherwise
/// </summary>
_AMPIMP bool operator==(const _Event &_Other) const;
/// <summary>
/// Return false if the other _Event is same as this _Event; true otherwise
/// </summary>
_AMPIMP bool operator!=(const _Event &_Other) const;
private:
// Private constructor
_Event(_In_ _Event_impl* _Impl);
_Event_impl_ptr _M_ptr_event_impl;
};
typedef _Buffer_descriptor *_View_key;
_Ret_ _Accelerator_view_impl* _Get_accelerator_view_impl_ptr(const accelerator_view& _Accl_view);
_Ret_ _Accelerator_impl* _Get_accelerator_impl_ptr(const accelerator& _Accl);
_Event _Get_access_async(const _View_key _Key, accelerator_view _Av, _Access_mode _Mode, _Buffer_ptr &_Buf_ptr);
unsigned int _Get_mipmap_levels(const _Texture *_Tex);
inline bool _Is_valid_access_mode(_Access_mode _Mode)
{
if ((_Mode != _Read_access) &&
(_Mode != _Write_access) &&
(_Mode != _Read_write_access))
{
return false;
}
return true;
}
// Caution: Do not change this structure defintion.
// This struct is special and is processed by the FE to identify the buffers
// used in a parallel_for_each and to setup the _M_data_ptr with the appropriate
// buffer ptr value in the device code.
typedef struct _Buffer_descriptor
{
friend _Event _Get_access_async(const _View_key _Key, accelerator_view _Av, _Access_mode _Mode, _Buffer_ptr &_Buf_ptr);
// _M_data_ptr points to the raw data underlying the buffer for accessing on host
mutable void *_M_data_ptr;
private:
// _M_buffer_ptr points to a _Ubiquitous_buffer that holds the data in an 1D array.
// This is private to ensure that all assignments to this data member
// only happen through public functions which properly manage the
// ref count of the underlying buffer
_Ubiquitous_buffer *_M_buffer_ptr;
public:
// _M_curr_cpu_access_mode specifies the current access mode of the data on the
// cpu accelerator_view specified at the time of registration of this view
_Access_mode _M_curr_cpu_access_mode;
// _M_type_acess_mode specifies the access mode of the overlay type
// array_views set it to the appropriate access mode and for arrays it is
// always _Is_array_mode.
_Access_mode _M_type_access_mode;
public:
// Public functions
// Default constructor
_Buffer_descriptor() __GPU
: _M_data_ptr(NULL), _M_buffer_ptr(NULL),
_M_curr_cpu_access_mode(_No_access), _M_type_access_mode(_Is_array_mode)
{
}
_Buffer_descriptor(_In_ void *_Data_ptr, _In_ _Ubiquitous_buffer *_Buffer_ptr,
_Access_mode _Curr_cpu_access_mode, _Access_mode _Type_mode) __GPU
: _M_data_ptr(_Data_ptr), _M_buffer_ptr(NULL),
_M_curr_cpu_access_mode(_Curr_cpu_access_mode), _M_type_access_mode(_Type_mode)
{
_Set_buffer_ptr(_Buffer_ptr);
}
// Destructor
~_Buffer_descriptor() __GPU
{
_Set_buffer_ptr(NULL);
}
// Copy constructor
_Buffer_descriptor(const _Buffer_descriptor &_Other) __GPU
: _M_data_ptr(_Other._M_data_ptr), _M_buffer_ptr(NULL),
_M_curr_cpu_access_mode(_Other._M_curr_cpu_access_mode), _M_type_access_mode(_Other._M_type_access_mode)
{
_Set_buffer_ptr(_Other._M_buffer_ptr);
}
// Assignment operator
_Buffer_descriptor& operator=(const _Buffer_descriptor &_Other) __GPU
{
if (this != &_Other)
{
_M_data_ptr = _Other._M_data_ptr;
_M_curr_cpu_access_mode = _Other._M_curr_cpu_access_mode;
_M_type_access_mode = _Other._M_type_access_mode;
_Set_buffer_ptr(_Other._M_buffer_ptr);
}
return *this;
}
_Ret_ _Ubiquitous_buffer* _Get_buffer_ptr() const __CPU_ONLY
{
return _M_buffer_ptr;
}
void _Set_buffer_ptr(_In_opt_ _Ubiquitous_buffer *_Buffer_ptr) __CPU_ONLY
{
if (_M_buffer_ptr != _Buffer_ptr)
{
if (_M_buffer_ptr != NULL) {
reinterpret_cast<_Reference_counter*>(_M_buffer_ptr)->_Remove_reference();
}
_M_buffer_ptr = _Buffer_ptr;
if (_M_buffer_ptr != NULL) {
reinterpret_cast<_Reference_counter*>(_M_buffer_ptr)->_Add_reference();
}
}
}
#if !defined(_CXXAMP)
void _Set_buffer_ptr(_In_opt_ _Ubiquitous_buffer *_Buffer_ptr) __GPU_ONLY
{
// No need to set the buffer ptr on the GPU
UNREFERENCED_PARAMETER(_Buffer_ptr);
_M_buffer_ptr = NULL;
}
#endif // _CXXAMP
bool _Is_array() const
{
return (_M_type_access_mode == _Is_array_mode);
}
_Ret_ _View_key _Get_view_key()
{
return this;
}
const _View_key _Get_view_key() const
{
return ((const _View_key)(this));
}
_AMPIMP void _Get_CPU_access(_Access_mode _Requested_mode) const;
} _Buffer_descriptor;
// Caution: Do not change this structure defintion.
// This struct is special and is processed by the FE to identify the textures
// used in a parallel_for_each and to setup the _M_data_ptr with the appropriate
// texture ptr value in the device code.
typedef struct _Texture_descriptor
{
// _M_data_ptr points to the raw data underlying the texture
mutable IUnknown *_M_data_ptr;
private:
// _M_texture_ptr points to a _Texture that holds the data
// This is private to ensure that all assignments to this data member
// only happen through public functions which properly manage the
// ref count of the underlying texture
_Texture *_M_texture_ptr;
// The index of the most detailed (largest in size) mipmap level for the texture (or texture view)
// This value is always zero for the texture and might be non-zero for the texture views
unsigned int _M_most_detailed_mipmap_level;
// Number of accessible mipmap levels for the texture (or texture view),
// e.g. if the texture has 3 mipmap levels ([0, 1, 2]),
// then read-only texture view with most detailed mipmap level equal to 1, can have 1 or 2 mipmap levels ([1] or [1, 2]).
// Further texture_views created on top of the texture view defined above can only narrow down the range of accessible mipmap levels.
unsigned int _M_view_mipmap_levels;
public:
// Public functions
// Default constructor
_Texture_descriptor() __GPU
: _M_data_ptr(NULL), _M_texture_ptr(NULL), _M_most_detailed_mipmap_level(0), _M_view_mipmap_levels(0)
{
// Enables move constructor
}
// Constructor for the texture
_Texture_descriptor(unsigned int _Most_detailed_mipmap_level, unsigned int _View_mipmap_levels) __GPU
: _M_data_ptr(NULL), _M_texture_ptr(NULL), _M_most_detailed_mipmap_level(_Most_detailed_mipmap_level), _M_view_mipmap_levels(_View_mipmap_levels)
{
}
// Constructor for the interop texture
_Texture_descriptor(_In_ _Texture * _Texture_ptr) : _M_data_ptr(NULL), _M_texture_ptr(NULL), _M_most_detailed_mipmap_level(0) __CPU_ONLY
{
_Set_texture_ptr(_Texture_ptr);
// Adopt number of mipmap levels from underlying texture object
_M_view_mipmap_levels = _Get_mipmap_levels(_M_texture_ptr);
}
// Destructor
~_Texture_descriptor() __GPU
{
_Set_texture_ptr(NULL);
}
// Copy constructor
_Texture_descriptor(const _Texture_descriptor &_Other) __GPU
: _M_data_ptr(_Other._M_data_ptr), _M_texture_ptr(NULL),
_M_most_detailed_mipmap_level(_Other._M_most_detailed_mipmap_level), _M_view_mipmap_levels(_Other._M_view_mipmap_levels)
{
_Set_texture_ptr(_Other._M_texture_ptr);
}
// Copy constructor with ability to redefine mipmap information
_Texture_descriptor(const _Texture_descriptor &_Other, unsigned int _Most_detailed_mipmap_level, unsigned int _View_mipmap_levels) __GPU
: _M_data_ptr(_Other._M_data_ptr), _M_texture_ptr(NULL),
_M_most_detailed_mipmap_level(_Most_detailed_mipmap_level), _M_view_mipmap_levels(_View_mipmap_levels)
{
_Set_texture_ptr(_Other._M_texture_ptr);
}
// Assignment operator
_Texture_descriptor& operator=(const _Texture_descriptor &_Other) __GPU
{
if (this != &_Other)
{
_M_data_ptr = _Other._M_data_ptr;
_Set_texture_ptr(_Other._M_texture_ptr);
_M_most_detailed_mipmap_level = _Other._M_most_detailed_mipmap_level;
_M_view_mipmap_levels = _Other._M_view_mipmap_levels;
}
return *this;
}
// Move constructor
_Texture_descriptor(_Texture_descriptor &&_Other) __CPU_ONLY
{
*this = std::move(_Other);
}
bool operator==(const _Texture_descriptor &_Other) const __GPU
{
return _M_texture_ptr == _Other._M_texture_ptr
&& _M_data_ptr == _Other._M_data_ptr
&& _M_most_detailed_mipmap_level == _Other._M_most_detailed_mipmap_level
&& _M_view_mipmap_levels == _Other._M_view_mipmap_levels;
}
_Ret_ _Texture* _Get_texture_ptr() const __CPU_ONLY
{
_ASSERTE(_M_texture_ptr);
return _M_texture_ptr;
}
unsigned int _Get_most_detailed_mipmap_level() const __GPU
{
return _M_most_detailed_mipmap_level;
}
unsigned int _Get_view_mipmap_levels() const __GPU
{
return _M_view_mipmap_levels;
}
void _Set_view_mipmap_levels(unsigned int _View_mipmap_levels) __CPU_ONLY
{
_M_view_mipmap_levels = _View_mipmap_levels;
}
void _Set_texture_ptr(_In_opt_ _Texture *_Texture_ptr) __CPU_ONLY
{
if (_M_texture_ptr != _Texture_ptr)
{
if (_M_texture_ptr != NULL) {
reinterpret_cast<_Reference_counter*>(_M_texture_ptr)->_Remove_reference();
}
_M_texture_ptr = _Texture_ptr;
if (_M_texture_ptr != NULL) {
reinterpret_cast<_Reference_counter*>(_M_texture_ptr)->_Add_reference();
}
}
}
#if !defined(_CXXAMP)
void _Set_texture_ptr(_In_opt_ _Texture *_Texture_ptr) __GPU_ONLY
{
// No need to set the texture ptr on the GPU
UNREFERENCED_PARAMETER(_Texture_ptr);
_M_texture_ptr = NULL;
}
#endif // _CXXAMP
// This helper function is used to determine aliasing and copy violations
bool _Are_mipmap_levels_overlapping(const _Texture_descriptor *_Other) const __CPU_ONLY
{
_ASSERTE(_Other);
if (this->_Get_texture_ptr() != _Other->_Get_texture_ptr())
{
return false;
}
return !((_M_most_detailed_mipmap_level < _Other->_M_most_detailed_mipmap_level) ? ((_M_most_detailed_mipmap_level + _M_view_mipmap_levels - 1) < _Other->_M_most_detailed_mipmap_level)
: ((_Other->_M_most_detailed_mipmap_level + _Other->_M_view_mipmap_levels - 1) < _M_most_detailed_mipmap_level));
}
} _Texture_descriptor;
// Caution: Do not change this structure defintion.
// This struct is special and is processed by the FE to identify the samplers
// used in a parallel_for_each.
typedef struct _Sampler_descriptor
{
// _M_data_ptr points to the sampler on accelerator
mutable void *_M_data_ptr;
private:
// _M_sampler_ptr points to a _Sampler that holds the underlying sampler
// representation. This is private to ensure that all assignments to this data member
// only happen through public functions which properly manage the
// ref count of the underlying _Sampler object.
_Sampler *_M_sampler_ptr;
public:
// Public functions
// Default constructor
_Sampler_descriptor() __GPU
: _M_data_ptr(NULL), _M_sampler_ptr(NULL)
{
}
_Sampler_descriptor(_In_ _Sampler * _Sampler_ptr) __GPU
: _M_data_ptr(NULL), _M_sampler_ptr(NULL)
{
_Set_sampler_ptr(_Sampler_ptr);
}
// Destructor
~_Sampler_descriptor() __GPU
{
_Set_sampler_ptr(NULL);
}
// Copy constructor
_Sampler_descriptor(const _Sampler_descriptor &_Other) __GPU
: _M_data_ptr(_Other._M_data_ptr), _M_sampler_ptr(NULL)
{
_Set_sampler_ptr(_Other._M_sampler_ptr);
}
// Assignment operator
_Sampler_descriptor& operator=(const _Sampler_descriptor &_Other) __GPU
{
if (this != &_Other)
{
_M_data_ptr = _Other._M_data_ptr;
_Set_sampler_ptr(_Other._M_sampler_ptr);
}
return *this;
}
// Move constructor
_Sampler_descriptor(_Sampler_descriptor &&_Other) __CPU_ONLY
{
*this = std::move(_Other);
}
bool operator==(const _Sampler_descriptor &_Other) const __GPU
{
return _M_sampler_ptr == _Other._M_sampler_ptr && _M_data_ptr == _Other._M_data_ptr;
}
_Ret_ _Sampler* _Get_sampler_ptr() const __CPU_ONLY
{
return _M_sampler_ptr;
}
void _Set_sampler_ptr(_In_opt_ _Sampler *_Sampler_ptr) __CPU_ONLY
{
if (_M_sampler_ptr != _Sampler_ptr)
{
if (_M_sampler_ptr != NULL) {
reinterpret_cast<_Reference_counter*>(_M_sampler_ptr)->_Remove_reference();
}
_M_sampler_ptr = _Sampler_ptr;
if (_M_sampler_ptr != NULL) {
reinterpret_cast<_Reference_counter*>(_M_sampler_ptr)->_Add_reference();
}
}
}
#if !defined(_CXXAMP)
void _Set_sampler_ptr(_In_opt_ _Sampler *_Sampler_ptr) __GPU_ONLY
{
// No need to set the sampler ptr on the GPU
UNREFERENCED_PARAMETER(_Sampler_ptr);
_M_sampler_ptr = NULL;
}
#endif // _CXXAMP
} _Sampler_descriptor;
} // namespace Concurrency::details
// Forward declaration
class accelerator;
namespace details
{
_AMPIMP size_t __cdecl _Get_num_devices();
_AMPIMP _Ret_ _Accelerator_impl_ptr * __cdecl _Get_devices();
_AMPIMP accelerator __cdecl _Select_default_accelerator();
_AMPIMP bool __cdecl _Set_default_accelerator(_Accelerator_impl_ptr _Accl);
_AMPIMP bool __cdecl _Is_D3D_accelerator_view(const accelerator_view& _Av);
_AMPIMP void __cdecl _Register_async_event(const _Event &_Ev, const std::shared_future<void> &_Shared_future);
_AMPIMP _Access_mode __cdecl _Get_recommended_buffer_host_access_mode(const accelerator_view &_Av);
}
/// <summary>
/// Queuing modes supported for accelerator views
/// </summary>
enum queuing_mode {
queuing_mode_immediate,
queuing_mode_automatic
};
/// <summary>
/// Exception thrown due to a C++ AMP runtime_exception.
/// This is the base type for all C++ AMP exception types.
/// </summary>
class runtime_exception : public std::exception
{
public:
/// <summary>
/// Construct a runtime_exception exception with a message and an error code
/// </summary>
/// <param name="_Message">
/// Descriptive message of error
/// </param>
/// <param name="_Hresult">
/// HRESULT of error that caused this exception
/// </param>
_AMPIMP runtime_exception(const char * _Message, HRESULT _Hresult) throw();
/// <summary>
/// Construct a runtime_exception exception with an error code
/// </summary>
/// <param name="_Hresult">
/// HRESULT of error that caused this exception
/// </param>
_AMPIMP explicit runtime_exception(HRESULT _Hresult) throw();
/// <summary>
/// Copy construct a runtime_exception exception
/// </summary>
/// <param name="_Other">
/// The runtime_exception object to be copied from
/// </param>
_AMPIMP runtime_exception(const runtime_exception &_Other) throw();
/// <summary>
/// Assignment operator
/// </summary>
/// <param name="_Other">
/// The runtime_exception object to be assigned from
/// </param>
_AMPIMP runtime_exception &operator=(const runtime_exception &_Other) throw();
/// <summary>
/// Destruct a runtime_exception exception object instance
/// </summary>
_AMPIMP virtual ~runtime_exception() throw();
/// <summary>
/// Get the error code that caused this exception
/// </summary>
/// <returns>
/// HRESULT of error that caused the exception
/// </returns>
_AMPIMP HRESULT get_error_code() const throw();
private:
HRESULT _M_error_code;
}; // class runtime_exception
/// <summary>
/// Exception thrown when an underlying OS/DirectX call fails
/// due to lack of system or device memory
/// </summary>
class out_of_memory : public runtime_exception
{
public:
/// <summary>
/// Construct an out_of_memory exception with a message
/// </summary>
/// <param name="_Message">
/// Descriptive message of error
/// </param>
_AMPIMP explicit out_of_memory(const char * _Message) throw();
/// <summary>
/// Construct an out_of_memory exception
/// </summary>
_AMPIMP out_of_memory () throw();
}; // class out_of_memory
namespace direct3d
{
/// <summary>
/// Get the D3D device interface underlying a accelerator_view.
/// </summary>
/// <param name="_Av">
/// The D3D accelerator_view for which the underlying D3D device interface is returned.
/// </param>
/// <returns>
/// The IUnknown interface pointer of the D3D device underlying the accelerator_view.
/// </returns>
_AMPIMP _Ret_ IUnknown * __cdecl get_device(const accelerator_view &_Av);
/// <summary>
/// Create a accelerator_view from a D3D device interface pointer.
/// </summary>
/// <param name="_D3D_device">
/// The D3D device interface pointer to create the accelerator_view from.
/// </param>
/// <param name="_Qmode">
/// The queuing_mode to be used for the newly created accelerator_view.
/// This parameter has a default value of queuing_mode_automatic.
/// </param>
/// <returns>
/// The accelerator_view created from the passed D3D device interface.
/// </returns>
_AMPIMP accelerator_view __cdecl create_accelerator_view(_In_ IUnknown *_D3D_device, queuing_mode _Qmode = queuing_mode_automatic);
/// <summary>
/// Create and return a new accelerator view on the specified accelerator.
/// </summary>
/// <param name="_Accelerator">
/// The accelerator on which the new accelerator_view is to be created.
/// </param>
/// <param name="_Disable_timeout">
/// A boolean parameter that specifies whether timeout should be disabled
/// for the newly created accelerator_view. This corresponds to the
/// D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT flag for Direct3D device creation
/// and is used to indicate if the operating system should allow workloads
/// that take more than 2 seconds to execute, without resetting the device
/// per the Windows timeout detection and recovery mechanism. Use of this flag
/// is recommended if you need to perform time consuming tasks on the accelerator_view.
/// </param>
/// <param name="_Qmode">
/// The queuing_mode to be used for the newly created accelerator_view.
/// This parameter has a default value of queuing_mode_automatic.
/// </param>
/// <returns>
/// The newly created accelerator_view.
/// </returns>
_AMPIMP accelerator_view __cdecl create_accelerator_view(accelerator& _Accelerator, bool _Disable_timeout, queuing_mode _Qmode = queuing_mode_automatic);
/// <summary>
/// Returns a boolean flag indicating if timeout is disabled
/// for the specified accelerator_view. This corresponds to the
/// D3D11_CREATE_DEVICE_DISABLE_GPU_TIMEOUT flag for Direct3D device creation.
/// </summary>
/// <param name="_Accelerator_view">
/// The accelerator_view for which the timeout disabled setting is to be queried.
/// </param>
/// <returns>
/// A boolean flag indicating if timeout is disabled for the specified accelerator_view.
/// </returns>
_AMPIMP bool __cdecl is_timeout_disabled(const accelerator_view& _Accelerator_view);
/// <summary>
/// Acquire a lock on an accelerator_view for the purpose of safely performing D3D operations on resources shared
/// with the accelerator_view. The accelerator_view and all C++ AMP resources associated with this accelerator_view
/// internally take this lock when performing operations and will block while another thread holds the D3D access lock.
///
/// This lock is non-recursive: It is undefined behavior to call this function from a thread that already holds the lock.
/// It is undefined behavior to perform operations on the accelerator_view or any data container associated with the
/// accelerator_view from the thread that holds the D3D access lock.
///
/// See also scoped_d3d_access_lock, a RAII-style class for a scope-based D3D access lock.
/// </summary>
/// <param name="_Av">
/// The accelerator_view to lock.
/// </param>
_AMPIMP void __cdecl d3d_access_lock(accelerator_view &_Av);
/// <summary>
/// Attempt to acquire the D3D access lock on an accelerator_view without blocking.
/// </summary>
/// <param name="_Av">
/// The accelerator_view to lock.
/// </param>
/// <returns>
/// true if the lock was acquired, or false if it is currently held by another thread.
/// </returns>
_AMPIMP bool __cdecl d3d_access_try_lock(accelerator_view &_Av);
/// <summary>
/// Release the D3D access lock on the given accelerator_view. If the calling thread does
/// not hold the lock on the accelerator_view the results are undefined.
/// </summary>
/// <param name="_Av">
/// The accelerator_view for which the lock is to be released.
/// </param>
_AMPIMP void __cdecl d3d_access_unlock(accelerator_view &_Av);
/// <summary>
/// Tag type to indicate the D3D access lock should be adopted rather than
/// acquired.
/// </summary>
struct adopt_d3d_access_lock_t {};
/// <summary>
/// RAII wrapper for a D3D access lock on an accelerator_view.
/// </summary>
class scoped_d3d_access_lock
{
public:
/// <summary>
/// Acquire a D3D access lock on the given accelerator_view. The lock is released
/// when this object goes out of scope. Construction will block until the lock
/// is acquired.
/// </summary>
/// <param name="_Av">
/// The accelerator_view to lock.
/// </param>
_AMPIMP explicit scoped_d3d_access_lock(accelerator_view &_Av);
/// <summary>
/// Construct a scoped_d3d_access_lock on an accelerator_view for which the lock
/// is already held (e.g. was acquired by d3d_access_try_lock). The D3D access
/// lock must already be held by the calling thread and not controlled by any other
/// scoped_d3d_access_lock.
/// </summary>
/// <param name="_Av">
/// The accelerator_view for the lock to adopt.
/// </param>
/// <param name="_T">
/// The adopt_d3d_access_lock object.
/// </param>
_AMPIMP explicit scoped_d3d_access_lock(accelerator_view &_Av, adopt_d3d_access_lock_t _T);
/// <summary>
/// Destructor for scoped_d3d_access_lock: unlock the accelerator_view.
/// </summary>
_AMPIMP ~scoped_d3d_access_lock();
/// <summary>
/// Move constructor for scoped_d3d_access_lock: Take ownership of
/// a lock from another scoped_d3d_access_lock.
/// </summary>
/// <param name="_Other">
/// The accelerator_view from which to move.
/// </param>
_AMPIMP scoped_d3d_access_lock(scoped_d3d_access_lock &&_Other);
/// <summary>
/// Move assignment operator for scoped_d3d_access_lock: Take ownership
/// of a lock from another scoped_d3d_access_lock, releasing the previous
/// lock.
/// </summary>
/// <param name="_Other">
/// The accelerator_view from which to move.
/// </param>
/// <returns>
/// A reference to this scoped_accelerator_view_lock.
/// </returns>
_AMPIMP scoped_d3d_access_lock& operator=(scoped_d3d_access_lock &&_Other);
private:
// No copy constructor
scoped_d3d_access_lock(const scoped_d3d_access_lock &_Other);
// No assignment operator
scoped_d3d_access_lock & operator=(const scoped_d3d_access_lock &_Other);
_Accelerator_view_impl_ptr _M_impl;
};
} // namespace direct3d
/// <summary>
/// Class represents a accelerator abstraction for C++ AMP data-parallel devices
/// </summary>
class accelerator
{
friend class accelerator_view;
friend class details::_Ubiquitous_buffer;
friend _AMPIMP accelerator details::_Select_default_accelerator();
_AMPIMP friend accelerator_view __cdecl direct3d::create_accelerator_view(accelerator& _Accelerator, bool _Disable_timeout, queuing_mode _Qmode /* = queuing_mode_automatic */);
friend _Ret_ details::_Accelerator_impl* details::_Get_accelerator_impl_ptr(const accelerator& _Accl);
public:
/// <summary>
/// String constant for default accelerator
/// </summary>
_AMPIMP static const wchar_t default_accelerator[];
/// <summary>
/// String constant for cpu accelerator
/// </summary>
_AMPIMP static const wchar_t cpu_accelerator[];
/// <summary>
/// String constant for direct3d WARP accelerator
/// </summary>
_AMPIMP static const wchar_t direct3d_warp[];
/// <summary>
/// String constant for direct3d reference accelerator
/// </summary>
_AMPIMP static const wchar_t direct3d_ref[];
/// <summary>
/// Construct a accelerator representing the default accelerator
/// </summary>
_AMPIMP accelerator();
/// <summary>
/// Construct a accelerator representing the accelerator with the
/// specified device instance path
/// </summary>
explicit accelerator(const std::wstring &_Device_path) : _M_impl(NULL)
{
_Init(_Device_path.c_str());
}
/// <summary>
/// Destructor
/// </summary>
_AMPIMP ~accelerator();
/// <summary>
/// Copy constructor
/// </summary>
_AMPIMP accelerator(const accelerator &_Other);
/// <summary>
/// Assignment operator
/// </summary>
_AMPIMP accelerator &operator=(const accelerator &_Other);
/// <summary>
/// Returns the vector of accelerator objects representing all available accelerators
/// </summary>
/// <returns>
/// The vector of available accelerators
/// </returns>
static inline std::vector<accelerator> get_all()
{
std::vector<accelerator> _AcceleratorVector;
size_t _NumDevices = details::_Get_num_devices();
for (size_t _I = 0; (_I < _NumDevices); ++_I)
{
_AcceleratorVector.push_back(details::_Get_devices()[_I]);
}
return _AcceleratorVector;
}
/// <summary>
/// Sets the default accelerator to be used for any operation
/// that implicitly uses the default accelerator. This method
/// only succeeds if the runtime selected default accelerator
/// has not already been used in an operation that implicitly
/// uses the default accelerator
/// </summary>
/// <returns>
/// A boolean value indicating if the call succeeds in setting
/// the default accelerator
/// </returns>
static inline bool set_default(const std::wstring& _Path)
{
accelerator _Accl(_Path);
return details::_Set_default_accelerator(_Accl._M_impl);
}
/// <summary>
/// Returns the auto selection accelerator_view which when specified
/// as the parallel_for_each target results in the target accelerator_view
/// for executing the parallel_for_each kernel to be automatically selected
/// by the runtime. For all other purposes, the accelerator_view returned
/// by this method is the same as the default accelerator_view of the default
/// accelerator
/// </summary>
_AMPIMP static accelerator_view __cdecl get_auto_selection_view();
/// <summary>
/// Returns the system-wide unique device instance path as a std::wstring
/// </summary>
std::wstring get_device_path() const
{
return _Get_device_path();
}
__declspec(property(get=get_device_path)) std::wstring device_path;
/// <summary>
/// Get the version for this accelerator
/// </summary>
_AMPIMP unsigned int get_version() const;
__declspec(property(get=get_version)) unsigned int version; // hiword=major, loword=minor
/// <summary>
/// Returns the device description as a std::wstring
/// </summary>
std::wstring get_description() const
{
return _Get_description();
}
__declspec(property(get=get_description)) std::wstring description;
/// <summary>
/// Returns a boolean value indicating whether the accelerator
/// was created with DEBUG layer enabled for extensive error reporting
/// </summary>
_AMPIMP bool get_is_debug() const;
__declspec(property(get=get_is_debug)) bool is_debug;
/// <summary>
/// Returns a boolean value indicating whether the accelerator is emulated.
/// This is true, for example, with the direct3d reference and WARP accelerators.
/// </summary>
_AMPIMP bool get_is_emulated() const;
__declspec(property(get=get_is_emulated)) bool is_emulated;
/// <summary>
/// Returns a boolean value indicating whether the accelerator
/// is attached to a display
/// </summary>
_AMPIMP bool get_has_display() const;
__declspec(property(get=get_has_display)) bool has_display;
/// <summary>
/// Returns a boolean value indicating whether the accelerator
/// supports full double precision (including double division,
/// precise_math functions, int to double, double to int conversions)
/// in a parallel_for_each kernel.
/// </summary>
_AMPIMP bool get_supports_double_precision() const;
__declspec(property(get=get_supports_double_precision)) bool supports_double_precision;
/// <summary>
/// Returns a boolean value indicating whether the accelerator
/// has limited double precision support (excludes double division,
/// precise_math functions, int to double, double to int conversions)
/// for a parallel_for_each kernel.
/// </summary>
_AMPIMP bool get_supports_limited_double_precision() const;
__declspec(property(get=get_supports_limited_double_precision)) bool supports_limited_double_precision;
/// <summary>
/// Returns a boolean value indicating whether the accelerator
/// supports memory accessible both by the accelerator and the CPU.
/// </summary>
_AMPIMP bool get_supports_cpu_shared_memory() const;
__declspec(property(get=get_supports_cpu_shared_memory)) bool supports_cpu_shared_memory;
/// <summary>
/// Return the default accelerator view associated with this accelerator
/// </summary>
_AMPIMP accelerator_view get_default_view() const;
__declspec(property(get=get_default_view)) accelerator_view default_view;
/// <summary>
/// Get the dedicated memory for this accelerator in KB
/// </summary>
_AMPIMP size_t get_dedicated_memory() const;
__declspec(property(get=get_dedicated_memory)) size_t dedicated_memory;
/// <summary>
/// Get the default cpu access_type for buffers created on this accelerator
/// </summary>
_AMPIMP access_type get_default_cpu_access_type() const;
__declspec(property(get=get_default_cpu_access_type)) access_type default_cpu_access_type;
/// <summary>
/// Set the default cpu access_type for arrays created on this accelerator
/// or for implicit memory allocations as part of array_views accessed
/// on this this accelerator. This method only succeeds if the default_cpu_access_type
/// for the accelerator has not already been overriden by a previous call to this method
/// and the runtime selected default_cpu_access_type for this accelerator has not yet
/// been used for allocating an array or for an implicit memory allocation backing an
/// array_view accessed on this accelerator.
/// </summary>
/// <param name="_Default_cpu_access_type">
/// The default cpu access_type to be used for array/array_view memory allocations
/// on this accelerator.
/// </param>
/// <returns>
/// A boolean value indicating if the default cpu access_type for the accelerator
/// was successfully set.
/// </returns>
_AMPIMP bool set_default_cpu_access_type(access_type _Default_cpu_access_type);
/// <summary>
/// Create and return a new accelerator view on this accelerator
/// with the specified queuing mode. When unspecified the accelerator_view
/// is created with queuing_mode_automatic queuing mode.
/// </summary>
_AMPIMP accelerator_view create_view(queuing_mode qmode = queuing_mode_automatic);
/// <summary>
/// Return true if the other accelerator is same as this accelerator; false otherwise
/// </summary>
_AMPIMP bool operator==(const accelerator &_Other) const;
/// <summary>
/// Return false if the other accelerator is same as this accelerator; true otherwise
/// </summary>
_AMPIMP bool operator!=(const accelerator &_Other) const;
private:
// Private constructor
_AMPIMP accelerator(_Accelerator_impl_ptr _Impl);
// Private helper methods
_AMPIMP const wchar_t *_Get_device_path() const;
_AMPIMP const wchar_t *_Get_description() const;
_AMPIMP void _Init(const wchar_t *_Path);
private:
_Accelerator_impl_ptr _M_impl;
};
/// <summary>
/// Class represents a future corresponding to a C++ AMP asynchronous operation
/// </summary>
class completion_future
{
friend class details::_Amp_runtime_trace;
public:
/// <summary>
/// Default constructor
/// </summary>
completion_future()
{
}
/// <summary>
/// Copy constructor
/// </summary>
completion_future(const completion_future& _Other)
: _M_shared_future(_Other._M_shared_future),
_M_task(_Other._M_task)
{
}
/// <summary>
/// Move constructor
/// </summary>
completion_future(completion_future&& _Other)
: _M_shared_future(std::move(_Other._M_shared_future)),
_M_task(std::move(_Other._M_task))
{
}
/// <summary>
/// Destructor
/// </summary>
~completion_future()
{
}
/// <summary>
/// Copy assignment operator
/// </summary>
completion_future& operator=(const completion_future& _Other)
{
if (this != &_Other) {
_M_shared_future = _Other._M_shared_future;
_M_task = _Other._M_task;
}
return (*this);
}
/// <summary>
/// Move assignment operator
/// </summary>
completion_future& operator=(completion_future&& _Other)
{
if (this != &_Other) {
_M_shared_future = std::move(_Other._M_shared_future);
_M_task = std::move(_Other._M_task);
}
return (*this);
}
/// <summary>
/// Waits until the associated asynchronous operation completes
/// Throws the stored exception if one was encountered during the
/// asynchronous operation
/// </summary>
void get() const
{
_M_shared_future.get();
}
/// <summary>
/// Returns true if the object is associated with an asynchronous
/// operation
/// </summary>
/// <returns>
/// true if the object is associated with an asynchronous operation
/// and false otherwise
/// </returns>
bool valid() const
{
return _M_shared_future.valid();
}
/// <summary>
/// Blocks until the associated asynchronous operation completes
/// </summary>
void wait() const
{
_M_shared_future.wait();
}
/// <summary>
/// Blocks until the associated asynchronous operation completes or
/// _Rel_time has elapsed
/// </summary>
/// <returns>
/// - future_status::deferred if the associated asynchronous operation is not running
/// - future_status::ready if the associated asynchronous operation is finished
/// - future_status::timeout if the time period specified has elapsed
/// </returns>
template <class _Rep, class _Period>
std::future_status wait_for(const std::chrono::duration<_Rep, _Period>& _Rel_time) const
{
return _M_shared_future.wait_for(_Rel_time);
}
/// <summary>
/// Blocks until the associated asynchronous operation completes or
/// until the current time exceeds _Abs_time
/// </summary>
/// <returns>
/// - future_status::deferred if the associated asynchronous operation is not running
/// - future_status::ready if the associated asynchronous operation is finished
/// - future_status::timeout if the time point specified has been reached
/// </returns>
template <class _Clock, class _Duration>
std::future_status wait_until(const std::chrono::time_point<_Clock, _Duration>& _Abs_time) const
{
return _M_shared_future.wait_until(_Abs_time);
}
/// <summary>
/// Returns a std::shared_future<void> object corresponding to the
/// associated asynchronous operation
/// </summary>
/// <returns>
/// A std::shared_future<void> object corresponding to the associated
/// asynchronous operation
/// </returns>
operator std::shared_future<void>() const
{
return _M_shared_future;
}
/// <summary>
/// Chains a callback Functor to the completion_future to be executed
/// when the associated asynchronous operation finishes execution
/// </summary>
template <typename _Functor>
void then(const _Functor &_Func) const
{
this->to_task().then(_Func);
}
/// <summary>
/// Returns a concurrency::task<void> object corresponding to the
/// associated asynchronous operation
/// </summary>
/// <returns>
/// A concurrency::task<void> object corresponding to the associated
/// asynchronous operation
/// </returns>
concurrency::task<void> to_task() const
{
return _M_task;
}
private:
// Private constructor
completion_future(const std::shared_future<void> &_Shared_future,
const concurrency::task<void>& _Task)
: _M_shared_future(_Shared_future), _M_task(_Task)
{
}
std::shared_future<void> _M_shared_future;
concurrency::task<void> _M_task;
};
/// <summary>
/// Class represents a virtual device abstraction on a C++ AMP data-parallel accelerator
/// </summary>
class accelerator_view
{
friend class accelerator;
friend class details::_Buffer;
friend class details::_Texture;
friend class details::_Sampler;
friend class details::_Ubiquitous_buffer;
friend class details::_D3D_interop;
friend class details::_D3D_accelerator_view_impl;
friend class details::_CPU_accelerator_view_impl;
friend class details::_Accelerator_view_hasher;
_AMPIMP friend _Ret_ IUnknown * __cdecl direct3d::get_device(const accelerator_view &_Av);
_AMPIMP friend accelerator_view __cdecl direct3d::create_accelerator_view(_In_ IUnknown *_D3D_device, queuing_mode qmode /* = queuing_mode_automatic */);
_AMPIMP friend accelerator_view __cdecl direct3d::create_accelerator_view(accelerator& _Accelerator, bool _Disable_timeout, queuing_mode _Qmode /* = queuing_mode_automatic */);
_AMPIMP friend bool __cdecl direct3d::is_timeout_disabled(const accelerator_view& _Accelerator_view);
friend _Ret_ details::_Accelerator_view_impl* details::_Get_accelerator_view_impl_ptr(const accelerator_view& _Accl_view);
public:
/// <summary>
/// Destructor
/// </summary>
_AMPIMP ~accelerator_view();
/// <summary>
/// Copy constructor
/// </summary>
_AMPIMP accelerator_view(const accelerator_view &_Other);
/// <summary>
/// Assignment operator
/// </summary>
_AMPIMP accelerator_view &operator=(const accelerator_view &_Other);
/// <summary>
/// Get the accelerator for this accelerator view
/// </summary>
_AMPIMP accelerator get_accelerator() const;
__declspec(property(get=get_accelerator)) Concurrency::accelerator accelerator;
/// <summary>
/// Returns a boolean value indicating whether the accelerator view
/// was created with DEBUG layer enabled for extensive error reporting
/// </summary>
_AMPIMP bool get_is_debug() const;
__declspec(property(get=get_is_debug)) bool is_debug;
/// <summary>
/// Get the version for this accelerator view
/// </summary>
_AMPIMP unsigned int get_version() const;
__declspec(property(get=get_version)) unsigned int version; // hiword=major, loword=minor
/// <summary>
/// Get the queuing mode for this accelerator view
/// </summary>
_AMPIMP queuing_mode get_queuing_mode() const;
__declspec(property(get=get_queuing_mode)) Concurrency::queuing_mode queuing_mode;
/// <summary>
/// Returns a boolean value indicating whether the accelerator view
/// when passed to a parallel_for_each would result in automatic
/// selection of an appropriate execution target by the runtime
/// </summary>
_AMPIMP bool get_is_auto_selection() const;
__declspec(property(get=get_is_auto_selection)) bool is_auto_selection;
/// <summary>
/// Return true if the other accelerator view is same as this accelerator view; false otherwise
/// </summary>
_AMPIMP bool operator==(const accelerator_view &_Other) const;
/// <summary>
/// Return false if the other accelerator view is same as this accelerator view; true otherwise
/// </summary>
_AMPIMP bool operator!=(const accelerator_view &_Other) const;
/// <summary>
/// Waits for completion of all commands submitted so far to this accelerator_view
/// </summary>
_AMPIMP void wait();
/// <summary>
/// Submit all pending commands queued to this accelerator_view to the accelerator
/// for execution.
/// </summary>
_AMPIMP void flush();
/// <summary>
/// Return a future to track the completion of all commands submitted so far to this accelerator_view
/// </summary>
_AMPIMP concurrency::completion_future create_marker();
private:
// No default constructor
accelerator_view();
// Private constructor
_AMPIMP accelerator_view(_Accelerator_view_impl_ptr _Impl, bool _Auto_selection = false);
private:
_Accelerator_view_impl_ptr _M_impl;
bool _M_auto_selection;
};
namespace details
{
inline _Ret_ _Accelerator_view_impl* _Get_accelerator_view_impl_ptr(const accelerator_view& _Accl_view)
{
return _Accl_view._M_impl;
}
inline _Ret_ _Accelerator_impl* _Get_accelerator_impl_ptr(const accelerator& _Accl)
{
return _Accl._M_impl;
}
// Type defining a hasher for accelerator_view objects
// for use with std::unordered_set and std::unordered_map
class _Accelerator_view_hasher
{
public:
size_t operator()(const accelerator_view &_Accl_view) const
{
std::hash<_Accelerator_view_impl*> _HashFunctor;
return _HashFunctor(_Accl_view._M_impl._Get_ptr());
}
};
typedef std::unordered_set<accelerator_view, _Accelerator_view_hasher> _Accelerator_view_unordered_set;
// Describes the N dimensional shape of a view in a buffer
class _View_shape : public _Reference_counter
{
public:
_AMPIMP static _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);
_AMPIMP _Ret_ _View_shape* _Get_reduced_shape_for_copy();
inline unsigned int _Get_rank() const
{
return _M_rank;
}
inline unsigned int _Get_linear_offset() const
{
return _M_linear_offset;
}
inline const unsigned int *_Get_base_extent() const
{
return _M_base_extent;
}
inline const unsigned int *_Get_view_offset() const
{
return _M_view_offset;
}
inline const unsigned int *_Get_view_extent() const
{
return _M_view_extent;
}
inline const bool *_Get_projection_info() const
{
return _M_projection_info;
}
inline bool _Is_projection() const
{
return _M_projection_info[0];
}
inline bool _Is_valid(size_t _Buffer_size) const
{
// 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();
}
inline unsigned int _Get_view_size() const
{
return _Get_extent_size(_M_rank, _M_view_extent);
}
inline unsigned int _Get_view_linear_offset() const
{
return _Get_linear_offset(_M_view_offset);
}
static inline 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)
{
_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;
}
static inline bool
_Compare_extent(unsigned int _Rank, const unsigned int *_Extent1, const unsigned int *_Extent2)
{
for (size_t _I = 0; _I < _Rank; ++_I) {
if (_Extent1[_I] != _Extent2[_I]) {
return false;
}
}
return true;
}
inline bool _Is_view_linear(unsigned int &_Linear_offset, unsigned int &_Linear_size) const
{
// 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;
}
inline bool _Overlaps(const _View_shape* _Other) const
{
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);
}
}
inline bool _Subsumes(const _View_shape* _Other) const
{
// 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());
}
private:
// Private constructor to force construction through the _Create_view_shape method
_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();
// No default constructor or copy/assignment
_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);
// Helper methods
static bool _Intervals_overlap(size_t _First_start, size_t _First_end,
size_t _Second_start, size_t _Second_end)
{
// 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);
}
static unsigned int _Get_extent_size(unsigned int _Rank, const unsigned int *_Extent)
{
unsigned int totalExtent = 1;
for (size_t _I = 0; _I < _Rank; ++_I) {
totalExtent *= _Extent[_I];
}
return totalExtent;
}
inline bool _Is_valid() const
{
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;
}
inline bool _Compare_base_shape(const _View_shape* _Other) const
{
return ((_M_rank == _Other->_M_rank) &&
(_M_linear_offset == _Other->_M_linear_offset) &&
_Compare_extent(_M_rank, _M_base_extent, _Other->_M_base_extent));
}
// Checks if the element at the specified index
// is contained within this view shape
// Assumes the rank of the index is same as the
// rank of this view's shape
inline bool _Contains(const unsigned int* _Element_index) const
{
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;
}
inline unsigned int _Get_linear_offset(const unsigned int* _Element_index) const
{
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;
}
private:
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;
};
// This function creates a new _View_shape object from an existing _View_shape object when the data underlying the view
// needs to be reinterpreted to use a different element size than the one used by the original view.
inline
_Ret_ _View_shape *_Create_reinterpreted_shape(const _View_shape* _Source_shape, size_t _Curr_elem_size, size_t _New_elem_size)
{
unsigned int _Rank = _Source_shape->_Get_rank();
size_t _LinearOffsetInBytes = _Source_shape->_Get_linear_offset() * _Curr_elem_size;
size_t _BaseLSDExtentInBytes = (_Source_shape->_Get_base_extent())[_Rank - 1] * _Curr_elem_size;
size_t _ViewLSDOffsetInBytes = (_Source_shape->_Get_view_offset())[_Rank - 1] * _Curr_elem_size;
size_t _ViewLSDExtentInBytes = (_Source_shape->_Get_view_extent())[_Rank - 1] * _Curr_elem_size;
_ASSERTE((_LinearOffsetInBytes % _New_elem_size) == 0);
_ASSERTE((_BaseLSDExtentInBytes % _New_elem_size) == 0);
_ASSERTE((_ViewLSDOffsetInBytes % _New_elem_size) == 0);
_ASSERTE((_ViewLSDExtentInBytes % _New_elem_size) == 0);
size_t _Temp_val = _LinearOffsetInBytes / _New_elem_size;
_ASSERTE(_Temp_val <= UINT_MAX);
unsigned int _New_linear_offset = static_cast<unsigned int>(_Temp_val);
std::vector<unsigned int> _New_base_extent(_Rank);
std::vector<unsigned int> _New_view_offset(_Rank);
std::vector<unsigned int> _New_view_extent(_Rank);
for (unsigned int i = 0; i < _Rank - 1; ++i) {
_New_base_extent[i] = (_Source_shape->_Get_base_extent())[i];
_New_view_offset[i] = (_Source_shape->_Get_view_offset())[i];
_New_view_extent[i] = (_Source_shape->_Get_view_extent())[i];
}
// The extent in the least significant dimension needs to be adjusted
_Temp_val = _BaseLSDExtentInBytes / _New_elem_size;
_ASSERTE(_Temp_val <= UINT_MAX);
_New_base_extent[_Rank - 1] = static_cast<unsigned int>(_Temp_val);
_Temp_val = _ViewLSDOffsetInBytes / _New_elem_size;
_ASSERTE(_Temp_val <= UINT_MAX);
_New_view_offset[_Rank - 1] = static_cast<unsigned int>(_Temp_val);
_Temp_val = _ViewLSDExtentInBytes / _New_elem_size;
_ASSERTE(_Temp_val <= UINT_MAX);
_New_view_extent[_Rank - 1] = static_cast<unsigned int>(_Temp_val);
return _View_shape::_Create_view_shape(_Rank, _New_linear_offset, _New_base_extent.data(), _New_view_offset.data(), _New_view_extent.data());
}
inline _Access_mode _Get_synchronize_access_mode(access_type cpu_access_type)
{
switch(cpu_access_type)
{
case access_type_auto:
case access_type_read:
return _Read_access;
case access_type_write:
return _Write_access;
case access_type_read_write:
return _Read_write_access;
case access_type_none:
default:
_ASSERTE(false);
return _No_access;
}
}
inline access_type _Get_cpu_access_type(_Access_mode _Cpu_access_mode)
{
access_type _Cpu_access_type = access_type_none;
if (_Cpu_access_mode & _Read_access) {
_Cpu_access_type = static_cast<access_type>(_Cpu_access_type | access_type_read);
}
if (_Cpu_access_mode & _Write_access) {
_Cpu_access_type = static_cast<access_type>(_Cpu_access_type | access_type_write);
}
return _Cpu_access_type;
}
// Class manages a raw buffer in a accelerator view
class _Buffer : public _Reference_counter
{
friend class _CPU_accelerator_view_impl;
friend class _D3D_accelerator_view_impl;
friend class _D3D_temp_staging_cache;
public:
// Force construction through these static public method to ensure that _Buffer
// objects are allocated in the runtime
// Allocate a new buffer on the specified accelerator_view
_AMPIMP static _Ret_ _Buffer * __cdecl _Create_buffer(accelerator_view _Accelerator_view, accelerator_view _Access_on_accelerator_view, size_t _Num_elems,
size_t _Elem_size, bool _Is_temp = false, access_type _Cpu_access_type = access_type_auto);
// Create a buffer object from a pre-allocated storage on the specified accelerator_view. This can be thought
// of as the accelerator_view "adopting" the passed data buffer.
_AMPIMP static _Ret_ _Buffer * __cdecl _Create_buffer(_In_ void *_Data_ptr, accelerator_view _Accelerator_view, size_t _Num_elems,
size_t _Elem_size);
// Create a staging buffer on the specified accelerator_view which can be accesed on the cpu upon mapping.
_AMPIMP static _Ret_ _Buffer * __cdecl _Create_stage_buffer(accelerator_view _Accelerator_view, accelerator_view _Access_on_accelerator_view,
size_t _Num_elems, size_t _Elem_size, bool _Is_temp = false);
// Creates a temp staging buffer of the requested size. This function may create
// a staging buffer smaller than the requested size.
_AMPIMP static _Ret_ _Buffer * __cdecl _Get_temp_staging_buffer(accelerator_view _Av, size_t _Requested_num_elems, size_t _Elem_size);
// Map a zero-copy or staging buffer for access on the CPU.
_AMPIMP void _Map_buffer(_Access_mode _Map_type, bool _Wait);
// Asynchronously map a zero-copy or staging buffer for access on the CPU.
_AMPIMP _Event _Map_buffer_async(_Access_mode _Map_type);
// Unmap a zero-copy or staging buffer denying CPU access
_AMPIMP void _Unmap_buffer();
// Copy data to _Dest asynchronously.
_AMPIMP _Event _Copy_to_async(_Out_ _Buffer * _Dest, size_t _Num_elems, size_t _Src_offset = 0, size_t _Dest_offset = 0);
// Copy data to _Dest asynchronously.
_AMPIMP _Event _Copy_to_async(_Out_ _Buffer * _Dest, _View_shape_ptr _Src_shape, _View_shape_ptr _Dest_shape);
_AMPIMP accelerator_view _Get_accelerator_view() const;
_AMPIMP accelerator_view _Get_access_on_accelerator_view() const;
_AMPIMP void _Register_view(_In_ _View_key _Key);
_AMPIMP void _Unregister_view(_In_ _View_key _Key);
// Return the raw data ptr - only a accelerator view implementation can interpret
// this raw pointer. This method should usually not be used in the AMP header files
// The _Get_host_ptr is the right way for accessing the host accesible ptr for a buffer
_Ret_ void * _Get_data_ptr() const
{
return _M_data_ptr;
}
// Returns the host accessible ptr corresponding to the buffer. This would
// return NULL when the buffer is inaccesible on the CPU
_Ret_ void * _Get_host_ptr() const
{
return _M_host_ptr;
}
size_t _Get_elem_size() const
{
return _M_elem_size;
}
size_t _Get_num_elems() const
{
return _M_num_elems;
}
_Ret_ _Accelerator_view_impl* _Get_accelerator_view_impl() const
{
return _M_accelerator_view;
}
_Ret_ _Accelerator_view_impl* _Get_access_on_accelerator_view_impl() const
{
return _M_access_on_accelerator_view;
}
bool _Owns_data() const
{
return _M_owns_data;
}
_AMPIMP bool _Exclusively_owns_data();
bool _Is_staging() const
{
return _M_is_staging;
}
_Access_mode _Get_allowed_host_access_mode() const
{
return _M_allowed_host_access_mode;
}
access_type _Get_allowed_host_access_type() const
{
return _Get_cpu_access_type(_M_allowed_host_access_mode);
}
bool _Is_host_accessible(_Access_mode _Requested_access_mode) const
{
return ((_Get_allowed_host_access_mode() & _Requested_access_mode) == _Requested_access_mode);
}
_Access_mode _Get_current_host_access_mode() const
{
return _M_current_host_access_mode;
}
bool _Is_temp() const
{
return _M_is_temp;
}
bool _Is_adopted() const
{
// Is it adopted from interop?
return _M_is_adopted;
}
bool _Is_buffer() const
{
return _M_is_buffer;
}
_AMPIMP bool _Is_mappable() const;
protected:
// The _Buffer constructor is protected to force construction through the static
// _Create_buffer method to ensure the object is allocated in the runtime
_Buffer(_In_ _Accelerator_view_impl* _Av, _In_ void *_Buffer_data_ptr, _In_ void * _Host_ptr,
_Access_mode _Allowed_host_access_mode, _Access_mode _Current_host_access_mode, size_t _Num_elems,
size_t _Elem_size, bool _Owns_data, bool _Is_staging, bool _Is_temp, bool _Is_adopted);
// protected destructor to force deletion through _Release
virtual ~_Buffer();
// No default consturctor, copy constructor and assignment operator
_Buffer();
_Buffer(const _Buffer &rhs);
_Buffer &operator=(const _Buffer &rhs);
void _Set_host_ptr(_In_ void *_Host_ptr, _Access_mode _Host_access_mode = _No_access)
{
_ASSERTE((_Host_ptr == NULL) || (_Host_access_mode != _No_access));
_M_host_ptr = _Host_ptr;
if (_Host_ptr == NULL) {
_M_current_host_access_mode = _No_access;
}
else {
_M_current_host_access_mode = _Host_access_mode;
}
}
void _Set_data_ptr(_In_ IUnknown *_Data_ptr)
{
_M_data_ptr = _Data_ptr;
}
protected:
_Accelerator_view_impl_ptr _M_accelerator_view;
_Accelerator_view_impl_ptr _M_access_on_accelerator_view;
void * _M_data_ptr;
void * _M_host_ptr;
_Access_mode _M_allowed_host_access_mode;
_Access_mode _M_current_host_access_mode;
size_t _M_elem_size;
size_t _M_num_elems;
bool _M_owns_data;
bool _M_is_staging;
// Used to determine how to map the staging buffer after its involved in a copy
bool _M_is_temp;
bool _M_is_adopted;
bool _M_is_buffer;
private:
// A set of view_keys to invalidate whenever the host ptr of a staging buffer is invalidated
std::unique_ptr<std::unordered_set<_View_key>> _M_view_keys;
Concurrency::critical_section _M_critical_section;
};
// Class manages a texture in a accelerator view
class _Texture : public _Buffer
{
friend class _CPU_accelerator_view_impl;
friend class _D3D_accelerator_view_impl;
friend class _D3D_temp_staging_cache;
public:
// Allocate a new texture on the specified accelerator_view
_AMPIMP static _Ret_ _Texture * __cdecl _Create_texture(accelerator_view _Accelerator_view,
unsigned int _Rank,
size_t _Width, size_t _Height, size_t _Depth,
unsigned int _Mip_levels,
_Short_vector_base_type_id _Type_id,
unsigned int _Num_channels,
unsigned int _Bits_per_channel,
bool _Is_temp = false);
// Create a texture object from a pre-allocated storage on the specified accelerator_view. This can be thought
// of as the accelerator_view "adopting" the passed data buffer.
_AMPIMP static _Ret_ _Texture * __cdecl _Adopt_texture(unsigned int _Rank, _Texture_base_type_id _Id,
_In_ IUnknown *_Data_ptr, accelerator_view _Accelerator_view,
unsigned int _View_format);
// Create a staging texture on the specified accelerator_view which can be accesed on the cpu upon mapping.
_AMPIMP static _Ret_ _Texture * __cdecl _Create_stage_texture(accelerator_view _Accelerator_view, accelerator_view _Access_on_accelerator_view,
unsigned int _Rank,
size_t _Width, size_t _Height, size_t _Depth,
unsigned int _Mip_levels,
unsigned int _Format,
bool _Is_temp = false);
// Create a staging texture on the specified accelerator_view which can be accesed on the cpu upon mapping.
_AMPIMP static _Ret_ _Texture * __cdecl _Create_stage_texture(accelerator_view _Accelerator_view, accelerator_view _Access_on_accelerator_view,
unsigned int _Rank,
size_t _Width, size_t _Height, size_t _Depth,
unsigned int _Mip_levels,
_Short_vector_base_type_id _Type_id,
unsigned int _Num_channels,
unsigned int _Bits_per_channel);
// Creates a temp staging texture. This function may create
// a staging texture smaller than the requested size.
_AMPIMP static _Ret_ _Texture * __cdecl _Get_temp_staging_texture(accelerator_view _Accelerator_view,
unsigned int _Rank,
size_t _Width, size_t _Height, size_t _Depth,
unsigned int _Mip_levels,
unsigned int _Format);
// Constructs a new texture with the same properties as the given texture.
_AMPIMP static _Ret_ _Texture * __cdecl _Clone_texture(const _Texture *_Src, const accelerator_view &_Accelerator_view, const accelerator_view &_Associated_av);
// Copy data to _Dest asynchronously for textures. The two textures must have been created with
// compatible physical formats.
_AMPIMP _Event _Copy_to_async(_Out_ _Texture * _Dest, const size_t *_Copy_extent,
const size_t *_Src_offset, const size_t *_Dst_offset,
unsigned int _Src_mipmap_level, unsigned int _Dst_mipmap_level);
size_t _Get_width(unsigned int _Mip_offset = 0) const
{
return (_M_width >> _Mip_offset) ? (_M_width >> _Mip_offset) : 1U;
}
size_t _Get_height(unsigned int _Mip_offset = 0) const
{
return (_M_height >> _Mip_offset) ? (_M_height >> _Mip_offset) : 1U;
}
size_t _Get_depth(unsigned int _Mip_offset = 0) const
{
return (_M_depth >> _Mip_offset) ? (_M_depth >> _Mip_offset) : 1U;
}
unsigned int _Get_rank() const
{
return _M_rank;
}
unsigned int _Get_texture_format() const
{
return _M_texture_format;
}
unsigned int _Get_view_format() const
{
return _M_view_format;
}
unsigned int _Get_num_channels() const
{
return _M_num_channels;
}
unsigned int _Get_bits_per_channel() const
{
// For texture adopted from interop, return 0.
return _Is_adopted() ? 0 : _M_bits_per_channel;
}
unsigned int _Get_bits_per_element() const
{
return _M_bits_per_channel * _M_num_channels;
}
unsigned int _Get_data_length(unsigned int _Most_detailed_mipmap_level, unsigned int _View_mipmap_levels, const size_t *_Extents = nullptr) const // in bytes
{
_ASSERTE(_View_mipmap_levels);
unsigned long long _Bits_per_byte = 8ULL;
unsigned long long _Total_bytes = 0ULL;
unsigned int _Mip_level = _Most_detailed_mipmap_level;
// Sum up data length (in bytes) of all mipmap levels in the view
for (unsigned int _Mip_offset=0; _Mip_offset < _View_mipmap_levels; ++_Mip_offset)
{
unsigned long long _Width = 1ULL;
unsigned long long _Height = 1ULL;
unsigned long long _Depth = 1ULL;
if (_Extents)
{
switch (_M_rank)
{
case 3:
_Depth = (_Extents[2] >> _Mip_level) ? (_Extents[2] >> _Mip_level) : 1U;
// deliberately fall thru
case 2:
_Height = (_Extents[1] >> _Mip_level) ? (_Extents[1] >> _Mip_level) : 1U;
// deliberately fall thru
case 1:
_Width = (_Extents[0] >> _Mip_level) ? (_Extents[0] >> _Mip_level) : 1U;
break;
default:
_ASSERTE(false); // textures are only rank 1-3
}
}
else
{
_Width = _Get_width(_Mip_level);
_Height = _Get_height(_Mip_level);
_Depth = _Get_depth(_Mip_level);
}
// Note _Get_bits_per_element() can be smaller than 8
// Use unsigned long long to avoid integer overflow
_Total_bytes += ((_Width * _Height * _Depth * static_cast<unsigned long long>(_Get_bits_per_element())) + _Bits_per_byte - 1) / _Bits_per_byte;
_Mip_level++;
}
return static_cast<unsigned int>(_Total_bytes);
}
unsigned int _Get_mip_levels() const
{
return _M_mip_levels;
}
size_t _Get_row_pitch() const
{
return _M_row_pitch;
}
void _Set_row_pitch(size_t _Val)
{
_M_row_pitch = _Val;
}
size_t _Get_depth_pitch() const
{
return _M_depth_pitch;
}
void _Set_depth_pitch(size_t _Val)
{
_M_depth_pitch = _Val;
}
private:
// The _Texture constructor is private to force construction through the static
// _Create_texture method to ensure the object is allocated in the runtime
_Texture(_In_ _Accelerator_view_impl* _Av, _In_ void *_Texture_data_ptr, _In_ void * _Host_ptr,
_Access_mode _Allowed_host_access_mode, _Access_mode _Current_host_access_mode,
unsigned int _Rank,
size_t _Width, size_t _Height, size_t _Depth,
unsigned int _Mip_levels,
unsigned int _Texture_format,
unsigned int _View_format,
unsigned int _Num_channels,
unsigned int _Bits_per_channel,
bool _Owns_data, bool _Is_staging, bool _Is_temp, bool _Is_adopted);
// Private destructor to force deletion through _Release
~_Texture();
// No default consturctor, copy constructor and assignment operator
_Texture();
_Texture(const _Texture &rhs);
_Texture &operator=(const _Texture &rhs);
// Texture only
unsigned int _M_rank;
size_t _M_width;
size_t _M_height;
size_t _M_depth;
unsigned int _M_texture_format;
unsigned int _M_view_format;
unsigned int _M_bits_per_channel;
unsigned int _M_num_channels;
unsigned int _M_mip_levels;
size_t _M_row_pitch;
size_t _M_depth_pitch;
};
class _Sampler : public _Reference_counter
{
public:
// Create a new sampler with configurations exposed by C++ AMP.
_AMPIMP static _Ret_ _Sampler * __cdecl _Create(
unsigned int _Filter_mode,
unsigned int _Address_mode,
float _Border_r,
float _Border_g,
float _Border_b,
float _Border_a);
// Create a sampler object given an adopted opaque data pointer
_AMPIMP static _Ret_ _Sampler * __cdecl _Create(_In_ void *_Data_ptr);
// Return the raw data ptr - only an accelerator view implementation can interpret
// this raw pointer. This method should usually not be used in the AMP header files
_Ret_ void * _Get_data_ptr() const
{
return _M_data_ptr;
}
bool _Is_adopted() const
{
// Is it adopted from interop?
return _M_is_adopted;
}
unsigned int _Get_filter_mode() const
{
return _M_filter_mode;
}
unsigned int _Get_address_mode() const
{
return _M_address_mode;
}
const float* _Get_border_color() const
{
return &_M_border_color[0];
}
private:
// The _Sampler constructor is private to force construction through the static
// _Create method to ensure the object is allocated in the runtime
_Sampler(unsigned int _Filter_mode, unsigned int _Address_mode, float _Border_r, float _Border_g, float _Border_b, float _Border_a);
_Sampler(_In_ void *_Data_ptr);
// Private destructor to force deletion through _Release
~_Sampler();
// No default consturctor, copy constructor and assignment operator
_Sampler();
_Sampler(const _Sampler &rhs);
_Sampler &operator=(const _Sampler &rhs);
void * _M_data_ptr;
bool _M_is_adopted;
unsigned int _M_filter_mode;
unsigned int _M_address_mode;
float _M_border_color[4];
};
// Forward declaration for copy helper functions
_AMPIMP _Event __cdecl _Copy_impl(_In_ _Buffer *_Src, size_t _Src_offset,
_Out_ _Buffer * _Dst, size_t _Dest_offset,
size_t _Num_elems, size_t _Preferred_copy_chunk_num_elems = 0);
_AMPIMP _Event __cdecl _Copy_async_impl(_In_ _Texture *_Src_tex, const size_t *_Src_offset, unsigned int _Src_mipmap_level,
_Out_ _Texture *_Dst_tex, const size_t *_Dst_offset, unsigned int _Dst_mipmap_level,
const size_t *_Copy_extent, const size_t *_Preferred_copy_chunk_extent = NULL);
inline bool _Get_chunked_staging_texture(_In_ _Texture* _Tex, const size_t *_Copy_chunk_extent, _Inout_ size_t *_Remaining_copy_extent, _Out_ size_t *_Curr_copy_extent, _Out_ _Texture_ptr *_Staging_texture)
{
bool _Truncated_copy = false;
size_t _Allocation_extent[3] = { _Copy_chunk_extent[0], _Copy_chunk_extent[1], _Copy_chunk_extent[2] };
unsigned int _Most_sig_idx = _Tex->_Get_rank() - 1;
if (_Allocation_extent[_Most_sig_idx] > _Remaining_copy_extent[_Most_sig_idx]) {
_Allocation_extent[_Most_sig_idx] = _Remaining_copy_extent[_Most_sig_idx];
}
_Texture_ptr _Stage = _Texture::_Get_temp_staging_texture(_Tex->_Get_accelerator_view(), _Tex->_Get_rank(),
_Allocation_extent[0], _Allocation_extent[1], _Allocation_extent[2],
/*_Mip_levels=*/1, _Tex->_Get_texture_format());
std::copy(&_Allocation_extent[0], &_Allocation_extent[3], stdext::make_unchecked_array_iterator(&_Curr_copy_extent[0]));
size_t _Staging_tex_extent[3] = {_Stage->_Get_width(), _Stage->_Get_height(), _Stage->_Get_depth()};
if (_Curr_copy_extent[_Most_sig_idx] > _Staging_tex_extent[_Most_sig_idx]) {
_Curr_copy_extent[_Most_sig_idx] = _Staging_tex_extent[_Most_sig_idx];
}
// The truncation can however happen only in the most significant dimension and lower
// dimensions should not get truncated
if (_Curr_copy_extent[_Most_sig_idx] < _Remaining_copy_extent[_Most_sig_idx])
{
_Remaining_copy_extent[_Most_sig_idx] -= _Curr_copy_extent[_Most_sig_idx];
_Truncated_copy = true;
}
for (unsigned int _I = 0; _I < _Most_sig_idx; _I++)
{
_ASSERTE(_Curr_copy_extent[_I] == _Remaining_copy_extent[_I]);
}
*_Staging_texture = _Stage;
return _Truncated_copy;
}
#pragma warning ( push )
#pragma warning ( disable : 6101 )
// Supress "warning C6101: Returning uninitialized memory '*_Dst'.: A successful"
// "path through the function does not set the named _Out_ parameter."
// The callers to _Copy_data_on_host all have static_assert that _Rank has to be 1, 2, or 3 dimensions for texture
//
template <typename _Input_iterator, typename _Value_type>
inline void _Copy_data_on_host(int _Rank, _Input_iterator _Src, _Out_ _Value_type *_Dst,
size_t _Width, size_t _Height, size_t _Depth,
size_t _Dst_row_pitch_in_bytes, size_t _Dst_depth_pitch_in_bytes,
size_t _Src_row_pitch, size_t _Src_depth_pitch)
{
switch(_Rank)
{
case 1:
{
_Input_iterator _End = _Src;
std::advance(_End, _Width);
std::copy(_Src, _End, stdext::make_unchecked_array_iterator(_Dst));
}
break;
case 2:
{
unsigned char *_Dst_ptr = reinterpret_cast<unsigned char *>(_Dst);
_Input_iterator _Src_start = _Src;
for (size_t _I = 0; _I < _Height; _I++)
{
_Input_iterator _Src_end = _Src_start;
std::advance(_Src_end, _Width);
std::copy(_Src_start, _Src_end, stdext::make_unchecked_array_iterator(reinterpret_cast<_Value_type*>(_Dst_ptr)));
_Dst_ptr += _Dst_row_pitch_in_bytes;
std::advance(_Src_start, _Src_row_pitch);
}
}
break;
case 3:
{
unsigned char *_Dst_ptr_slice_start = reinterpret_cast<unsigned char *>(_Dst);
_Input_iterator _Src_depth_slice_start = _Src;
for (size_t _I = 0; _I < _Depth; _I++)
{
_Input_iterator _Src_start = _Src_depth_slice_start;
unsigned char *_Dst_ptr = _Dst_ptr_slice_start;
for (size_t _J = 0; _J < _Height; _J++)
{
_Input_iterator _Src_end = _Src_start;
std::advance(_Src_end, _Width);
std::copy(_Src_start, _Src_end, stdext::make_unchecked_array_iterator(reinterpret_cast<_Value_type*>(_Dst_ptr)));
_Dst_ptr += _Dst_row_pitch_in_bytes;
std::advance(_Src_start, _Src_row_pitch);
}
_Dst_ptr_slice_start += _Dst_depth_pitch_in_bytes;
std::advance(_Src_depth_slice_start, _Src_depth_pitch);
}
}
break;
default:
_ASSERTE(FALSE);
break;
}
}
#pragma warning ( pop ) // disable : 6101
template <typename _Output_iterator, typename _Value_type>
inline void _Copy_data_on_host(int _Rank, const _Value_type * _Src, _Output_iterator _Dst,
size_t _Width, size_t _Height, size_t _Depth,
size_t _Src_row_pitch_in_bytes, size_t _Src_depth_pitch_in_bytes,
size_t _Dst_row_pitch, size_t _Dst_depth_pitch)
{
switch(_Rank)
{
case 1:
{
const _Value_type * _End = _Src + _Width;
std::copy(stdext::make_unchecked_array_iterator(_Src), stdext::make_unchecked_array_iterator(_End), _Dst);
}
break;
case 2:
{
const unsigned char *_Src_ptr = reinterpret_cast<const unsigned char *>(_Src);
_Output_iterator _Dst_iter = _Dst;
for (size_t _I = 0; _I < _Height; _I++)
{
const _Value_type * _Src_end = reinterpret_cast<const _Value_type*>(_Src_ptr) + _Width;
std::copy(stdext::make_unchecked_array_iterator(reinterpret_cast<const _Value_type*>(_Src_ptr)), stdext::make_unchecked_array_iterator(_Src_end), _Dst_iter);
std::advance(_Dst_iter, _Dst_row_pitch);
_Src_ptr += _Src_row_pitch_in_bytes;
}
}
break;
case 3:
{
const unsigned char *_Src_ptr_slice_start = reinterpret_cast<const unsigned char *>(_Src);
_Output_iterator _Dst_depth_slice_start = _Dst;
for (size_t _I = 0; _I < _Depth; _I++)
{
_Output_iterator _Dst_iter = _Dst_depth_slice_start;
const unsigned char *_Src_ptr = _Src_ptr_slice_start;
for (size_t _J = 0; _J < _Height; _J++)
{
const _Value_type * _Src_end = reinterpret_cast<const _Value_type *>(_Src_ptr) + _Width;
std::copy(stdext::make_unchecked_array_iterator(reinterpret_cast<const _Value_type*>(_Src_ptr)), stdext::make_unchecked_array_iterator(_Src_end), _Dst_iter);
std::advance(_Dst_iter, _Dst_row_pitch);
_Src_ptr += _Src_row_pitch_in_bytes;
}
_Src_ptr_slice_start += _Src_depth_pitch_in_bytes;
std::advance(_Dst_depth_slice_start, _Dst_depth_pitch);
}
}
break;
default:
_ASSERTE(FALSE);
break;
}
}
_AMPIMP size_t __cdecl _Get_preferred_copy_chunk_size(size_t _Total_copy_size_in_bytes);
inline size_t _Get_preferred_copy_chunk_num_elems(size_t _Total_num_elems, size_t _Elem_size)
{
size_t preferredChunkSize = _Get_preferred_copy_chunk_size(_Total_num_elems * _Elem_size);
return (preferredChunkSize / _Elem_size);
}
inline void _Get_preferred_copy_chunk_extent(unsigned int _Rank, size_t _Width, size_t _Height,
size_t _Depth, size_t _Bits_per_element, _Out_writes_(3) size_t *_Preferred_copy_chunk_extent)
{
_ASSERTE(_Preferred_copy_chunk_extent != nullptr);
size_t requestedByteSize = static_cast<size_t>((static_cast<unsigned long long>(_Width) *
static_cast<unsigned long long>(_Height) *
static_cast<unsigned long long>(_Depth) *
static_cast<unsigned long long>(_Bits_per_element)) >> 3);
size_t preferredChunkSize = _Get_preferred_copy_chunk_size(requestedByteSize);
// Lets align the allocation size to the element size of the texture
size_t preferredCopyChunkNumElems = static_cast<size_t>((static_cast<unsigned long long>(preferredChunkSize) * 8U) / _Bits_per_element);
// Lets truncate the dimensions of the requested staging texture.
// We only truncate in the most significant dimension
switch (_Rank)
{
case 1:
_Width = preferredCopyChunkNumElems;
break;
case 2:
_Height = (preferredCopyChunkNumElems + _Width - 1) / _Width;
break;
case 3:
_Depth = (preferredCopyChunkNumElems + (_Height * _Width) - 1) / (_Height * _Width);
break;
default:
_ASSERTE(false);
}
_Preferred_copy_chunk_extent[0] = _Width;
_Preferred_copy_chunk_extent[1] = _Height;
_Preferred_copy_chunk_extent[2] = _Depth;
}
// Finds the greatest common divisor of 2 unsigned integral numbers using Euclid's algorithm
template <typename _T>
inline _T _Greatest_common_divisor(_T _M, _T _N)
{
static_assert(std::is_unsigned<_T>::value, "This GCD function only supports unsigned integral types");
_ASSERTE((_M > 0) && (_N > 0));
if (_N > _M) {
std::swap(_N , _M);
}
_T _Temp;
while (_N > 0)
{
_Temp = _N;
_N = _M % _N;
_M = _Temp;
}
return _M;
}
// Finds the least common multiple of 2 unsigned integral numbers using their greatest_common_divisor
template <typename _T>
inline _T _Least_common_multiple(_T _M, _T _N)
{
static_assert(std::is_unsigned<_T>::value, "This LCM function only supports unsigned integral types");
_ASSERTE((_M > 0) && (_N > 0));
_T _Gcd = _Greatest_common_divisor(_M, _N);
return ((_M / _Gcd) * _N);
}
template <typename InputIterator, typename _Value_type>
inline _Event _Copy_impl(InputIterator _SrcFirst, InputIterator _SrcLast, size_t _NumElemsToCopy,
_Out_ _Buffer * _Dst, size_t _Dest_offset, size_t _Preferred_copy_chunk_num_elems = 0)
{
if (_NumElemsToCopy == 0) {
return _Event();
}
if (_Dst == NULL) {
throw runtime_exception("Failed to copy to buffer.", E_INVALIDARG);
}
#pragma warning ( push )
#pragma warning ( disable : 6001 ) // Using uninitialized memory '*_Dst'
if (((_NumElemsToCopy * sizeof(_Value_type)) + (_Dest_offset * _Dst->_Get_elem_size())) > (_Dst->_Get_num_elems() * _Dst->_Get_elem_size()))
{
throw runtime_exception("Invalid _Src argument(s). _Src size exceeds total size of the _Dest.", E_INVALIDARG);
}
#pragma warning ( pop )
_ASSERTE(_NumElemsToCopy == (size_t)(std::distance(_SrcFirst, _SrcLast)));
// If the dest is host accessible for write then we do the copy on
// accelerator(accelerator::cpu_accelerator).default_view
if (_Dst->_Is_host_accessible(_Write_access))
{
// Lets first map the _Dst buffer
_Event _Ev = _Dst->_Map_buffer_async(_Write_access);
// The _Dest is accessible on host. We just need to do a std::copy using a raw pointer as OutputIterator
_Buffer_ptr _PDestBuf = _Dst;
_Ev = _Ev._Add_continuation(std::function<_Event()>([_PDestBuf,_Dest_offset, _SrcFirst, _SrcLast]() mutable -> _Event
{
_Value_type *_DestPtr = reinterpret_cast<_Value_type*>(reinterpret_cast<char*>(_PDestBuf->_Get_host_ptr()) + (_Dest_offset * _PDestBuf->_Get_elem_size()));
std::copy(_SrcFirst, _SrcLast, stdext::make_unchecked_array_iterator(_DestPtr));
return _Event();
}));
return _Ev;
}
else
{
// _Dest is on a device. Lets create a temp staging buffer on the _Dest accelerator_view and copy the input over
// We may create a staging buffer of size smaller than the copy size and in that case we will perform the copy
// as a series of smaller copies
_Buffer_ptr _PDestBuf = _Dst;
size_t _NumElemsToCopyRemaining = _NumElemsToCopy;
size_t _PreferredNumElemsToCopyPerChunk = _Preferred_copy_chunk_num_elems;
if (_PreferredNumElemsToCopyPerChunk == 0) {
// If a preferred copy chunk size was not specified, lets pick one based on the
// size of the copy
_PreferredNumElemsToCopyPerChunk = _Get_preferred_copy_chunk_num_elems(_NumElemsToCopy, sizeof(_Value_type));
}
size_t _CurrDstOffset = _Dest_offset;
InputIterator _CurrStartIter = _SrcFirst;
_Event _Ev;
size_t _Lcm = _Least_common_multiple(_Dst->_Get_elem_size(), sizeof(_Value_type));
size_t _AdjustmentRatio = _Lcm / sizeof(_Value_type);
do
{
size_t _AllocationNumElems = _PreferredNumElemsToCopyPerChunk;
if (_NumElemsToCopyRemaining < _AllocationNumElems) {
_AllocationNumElems = _NumElemsToCopyRemaining;
}
_Buffer_ptr _PDestStagingBuf = _Buffer::_Get_temp_staging_buffer(_Dst->_Get_accelerator_view(),
_AllocationNumElems, sizeof(_Value_type));
_ASSERTE(_PDestStagingBuf != NULL);
_ASSERTE(_PDestStagingBuf->_Get_elem_size() == sizeof(_Value_type));
InputIterator _CurrEndIter = _CurrStartIter;
size_t _CurrNumElemsToCopy = _AllocationNumElems;
if (_CurrNumElemsToCopy > _PDestStagingBuf->_Get_num_elems()) {
_CurrNumElemsToCopy = _PDestStagingBuf->_Get_num_elems();
}
if (_NumElemsToCopyRemaining <= _CurrNumElemsToCopy) {
_CurrNumElemsToCopy = _NumElemsToCopyRemaining;
_CurrEndIter = _SrcLast;
}
else
{
// We need to adjust the _CurrNumElemsToCopy to be a multiple of the
// least common multiple of the destination buffer's element size and sizeof(_Value_type).
_CurrNumElemsToCopy = (_CurrNumElemsToCopy / _AdjustmentRatio) * _AdjustmentRatio;
std::advance(_CurrEndIter, _CurrNumElemsToCopy);
}
_ASSERTE((_CurrNumElemsToCopy % _AdjustmentRatio) == 0);
// This would not actually never block since we just created this staging buffer or are using
// a cached one that is not in use
_PDestStagingBuf->_Map_buffer(_Write_access, true /* _Wait */);
// Copy from input to the staging using a raw pointer as OutputIterator
std::copy(_CurrStartIter, _CurrEndIter, stdext::make_unchecked_array_iterator(reinterpret_cast<_Value_type*>(_PDestStagingBuf->_Get_host_ptr())));
_Ev = _Ev._Add_event(_PDestStagingBuf->_Copy_to_async(_PDestBuf, _CurrNumElemsToCopy, 0, _CurrDstOffset));
// Adjust the iterators and offsets
_NumElemsToCopyRemaining -= _CurrNumElemsToCopy;
_CurrDstOffset += (_CurrNumElemsToCopy * sizeof(_Value_type)) / _Dst->_Get_elem_size();
_CurrStartIter = _CurrEndIter;
} while (_NumElemsToCopyRemaining != 0);
return _Ev;
}
}
// The std::advance method is only supported for InputIterators and hence we have a custom implementation
// which forwards to the std::advance if the iterator is an input iterator and uses a loop based advance
// implementation otherwise
template<typename _InputIterator, typename _Distance>
typename std::enable_if<std::is_base_of<std::input_iterator_tag, typename std::iterator_traits<_InputIterator>::iterator_category>::value>::type
_Advance_output_iterator(_InputIterator &_Iter, _Distance _N)
{
std::advance(_Iter, _N);
}
template<typename _OutputIterator, typename _Distance>
typename std::enable_if<!std::is_base_of<std::input_iterator_tag, typename std::iterator_traits<_OutputIterator>::iterator_category>::value>::type
_Advance_output_iterator(_OutputIterator &_Iter, size_t _N)
{
for (size_t i = 0; i < _N; ++i)
{
_Iter++;
}
}
template <typename OutputIterator, typename _Value_type>
inline _Event _Copy_impl(_In_ _Buffer *_Src, size_t _Src_offset, size_t _Num_elems,
OutputIterator _DestIter, size_t _Preferred_copy_chunk_num_elems = 0)
{
if ((_Src == NULL) || ((_Src_offset + _Num_elems) > _Src->_Get_num_elems())) {
throw runtime_exception("Failed to copy to buffer.", E_INVALIDARG);
}
if (_Num_elems == 0) {
return _Event();
}
size_t _NumElemsToCopy = (_Num_elems * _Src->_Get_elem_size()) / sizeof(_Value_type);
// If the src is host accessible for readthen we do the copy on
// accelerator(accelerator::cpu_accelerator).default_view
if (_Src->_Is_host_accessible(_Read_access))
{
// Map the _Src buffer
_Event _Ev = _Src->_Map_buffer_async(_Read_access);
// The _Src is accessible on host. We just need to do a std::copy using a raw pointer as OutputIterator
_Buffer_ptr _PSrcBuf = _Src;
_Ev = _Ev._Add_continuation(std::function<_Event()>([_PSrcBuf, _Src_offset, _DestIter, _NumElemsToCopy]() mutable -> _Event
{
// The _Src is accessible on host. We just need to do a std::copy
const _Value_type *_PFirst = reinterpret_cast<const _Value_type*>(reinterpret_cast<char*>(_PSrcBuf->_Get_host_ptr()) + (_Src_offset * _PSrcBuf->_Get_elem_size()));
std::copy(_PFirst, _PFirst + _NumElemsToCopy, _DestIter);
return _Event();
}));
return _Ev;
}
else
{
// The _Src is on the device. We need to copy it out to a temporary staging array
// We may create a staging buffer of size smaller than the copy size and in that case we will
// perform the copy as a series of smaller copies
_Event _Ev;
_Buffer_ptr _PSrcBuf = _Src;
size_t _PreferredNumElemsToCopyPerChunk = _Preferred_copy_chunk_num_elems;
if (_PreferredNumElemsToCopyPerChunk == 0) {
// If a preferred copy chunk size was not specified, lets pick one based on the
// size of the copy
_PreferredNumElemsToCopyPerChunk = _Get_preferred_copy_chunk_num_elems(_NumElemsToCopy, sizeof(_Value_type));
}
size_t _AllocationNumElems = _PreferredNumElemsToCopyPerChunk;
if (_NumElemsToCopy < _AllocationNumElems) {
_AllocationNumElems = _NumElemsToCopy;
}
_Buffer_ptr _PSrcStagingBuf = _Buffer::_Get_temp_staging_buffer(_Src->_Get_accelerator_view(),
_AllocationNumElems, sizeof(_Value_type));
_ASSERTE(_PSrcStagingBuf != NULL);
_ASSERTE(_PSrcStagingBuf->_Get_elem_size() == sizeof(_Value_type));
// The total byte size of a copy chunk must be an integral multiple of both the
// source buffer's element size and sizeof(_Value_type).
size_t _Lcm = _Least_common_multiple(_Src->_Get_elem_size(), sizeof(_Value_type));
size_t _AdjustmentRatio = _Lcm / sizeof(_Value_type);
size_t _CurrNumElemsToCopy = _AllocationNumElems;
if (_CurrNumElemsToCopy > _PSrcStagingBuf->_Get_num_elems()) {
_CurrNumElemsToCopy = _PSrcStagingBuf->_Get_num_elems();
}
if (_NumElemsToCopy <= _CurrNumElemsToCopy)
{
_CurrNumElemsToCopy = _NumElemsToCopy;
}
else
{
// We need to adjust the _StagingBufNumElems to be a multiple of the
// least common multiple of the source buffer's element size and sizeof(_Value_type).
_CurrNumElemsToCopy = (_CurrNumElemsToCopy / _AdjustmentRatio) * _AdjustmentRatio;
}
_ASSERTE((_CurrNumElemsToCopy % _AdjustmentRatio) == 0);
size_t _NumElemsToCopyRemaining = _NumElemsToCopy - _CurrNumElemsToCopy;
_Ev = _PSrcBuf->_Copy_to_async(_PSrcStagingBuf, (_CurrNumElemsToCopy * sizeof(_Value_type)) / _PSrcBuf->_Get_elem_size(), _Src_offset, 0);
if (_NumElemsToCopyRemaining != 0)
{
_Ev = _Ev._Add_continuation(std::function<_Event()>([_DestIter, _PSrcBuf, _PSrcStagingBuf,
_CurrNumElemsToCopy, _NumElemsToCopyRemaining,
_Src_offset, _PreferredNumElemsToCopyPerChunk]() mutable -> _Event
{
// Initiate an asynchronous copy of the remaining part so that this part of the copy
// makes progress while we consummate the copying of the first part
size_t _CurrSrcOffset = _Src_offset + ((_CurrNumElemsToCopy * sizeof(_Value_type)) / _PSrcBuf->_Get_elem_size());
OutputIterator _CurrDestIter = _DestIter;
_Advance_output_iterator<decltype(_CurrDestIter), size_t>(_CurrDestIter, _CurrNumElemsToCopy);
_Event _Ret_ev = _Copy_impl<OutputIterator, _Value_type>(_PSrcBuf._Get_ptr(), _CurrSrcOffset,
(_NumElemsToCopyRemaining * sizeof(_Value_type)) / _PSrcBuf->_Get_elem_size(),
_CurrDestIter, _PreferredNumElemsToCopyPerChunk);
// Now copy the data from staging buffer to the destination
_Value_type *_PFirst = reinterpret_cast<_Value_type*>(_PSrcStagingBuf->_Get_host_ptr());
std::copy(_PFirst, _PFirst + _CurrNumElemsToCopy, _DestIter);
return _Ret_ev;
}));
}
else
{
_Ev = _Ev._Add_continuation(std::function<_Event()>([_DestIter, _PSrcStagingBuf, _CurrNumElemsToCopy]() mutable -> _Event
{
_Value_type *_PFirst = reinterpret_cast<_Value_type*>(_PSrcStagingBuf->_Get_host_ptr());
std::copy(_PFirst, _PFirst + _CurrNumElemsToCopy, _DestIter);
return _Event();
}));
}
return _Ev;
}
}
// Structured copy between buffers across AVs
_AMPIMP _Event __cdecl _Copy_impl(_In_ _Buffer *_Src, _View_shape_ptr _Src_shape, _Out_ _Buffer * _Dst, _View_shape_ptr _Dst_shape);
struct _Array_copy_desc
{
_Array_copy_desc(
const unsigned int _Rank,
const unsigned int _Src_linear_offset,
const unsigned int * _Src_extents,
const unsigned int * _Src_copy_offset,
const unsigned int _Dst_linear_offset,
const unsigned int * _Dst_extents,
const unsigned int * _Dst_copy_offset,
const unsigned int * _Copy_extents)
{
this->_Rank = _Rank;
this->_Src_linear_offset = _Src_linear_offset;
this->_Src_extents.assign( _Src_extents, _Src_extents + _Rank);
this->_Src_copy_offset.assign( _Src_copy_offset, _Src_copy_offset + _Rank);
this->_Dst_linear_offset = _Dst_linear_offset;
this->_Dst_extents.assign( _Dst_extents, _Dst_extents + _Rank);
this->_Dst_copy_offset.assign( _Dst_copy_offset, _Dst_copy_offset + _Rank);
this->_Copy_extents.assign( _Copy_extents, _Copy_extents + _Rank);
}
_Array_copy_desc() {}
unsigned int _Rank;
// Shape of source
unsigned int _Src_linear_offset;
std::vector<unsigned int> _Src_extents;
std::vector<unsigned int> _Src_copy_offset;
// Shape of destination
unsigned int _Dst_linear_offset;
std::vector<unsigned int> _Dst_extents;
std::vector<unsigned int> _Dst_copy_offset;
// Shape of copy region
std::vector<unsigned int> _Copy_extents;
};
// Declaration
_AMPIMP HRESULT __cdecl _Recursive_array_copy(const _Array_copy_desc& _Desc,
unsigned int _Native_copy_rank,
std::function<HRESULT(const _Array_copy_desc &_Reduced)> _Native_copy_func);
_AMPIMP std::pair<accelerator_view, accelerator_view> __cdecl _Get_src_dest_accelerator_view(_In_opt_ const _Buffer_descriptor *_SrcBuffDescPtr,
_In_opt_ const _Buffer_descriptor *_DestBuffDescPtr);
// Iterator based copy function
template<typename _InputInterator, typename _OutputIterator>
inline _Event _Copy_impl_iter(_InputInterator _SrcFirst, _InputInterator _SrcLast, _OutputIterator _DstFirst)
{
std::copy(_SrcFirst, _SrcLast, _DstFirst);
return _Event();
}
// Iterator based copy function
template <typename InputIterator, typename _Value_type>
inline _Event _Copy_impl(InputIterator _SrcFirst, _View_shape_ptr _Src_shape, _Inout_ _Buffer * _Dst, _View_shape_ptr _Dst_shape)
{
_ASSERTE(_Dst != NULL);
_ASSERTE(_Src_shape != NULL);
_ASSERTE(_Dst_shape != NULL);
if (_Src_shape->_Is_projection()) {
_Src_shape = _Src_shape->_Get_reduced_shape_for_copy();
}
if (_Dst_shape->_Is_projection()) {
_Dst_shape = _Dst_shape->_Get_reduced_shape_for_copy();
}
_ASSERTE(_Src_shape->_Get_rank() == _Dst_shape->_Get_rank());
_ASSERTE(_View_shape::_Compare_extent_with_elem_size(_Src_shape->_Get_rank(), _Src_shape->_Get_view_extent(),
sizeof(_Value_type), _Dst_shape->_Get_view_extent(), _Dst->_Get_elem_size()));
if (_Dst->_Is_host_accessible(_Write_access))
{
// The destination buffer is accesible on the host. Map the _Dst buffer
_Event _Ev = _Dst->_Map_buffer_async(_Write_access);
_Buffer_ptr _PDestBuf = _Dst;
return _Ev._Add_continuation(std::function<_Event()>([_SrcFirst, _Src_shape, _PDestBuf, _Dst_shape]() mutable -> _Event {
return _Copy_impl_iter(_SrcFirst, _Src_shape, stdext::make_unchecked_array_iterator(reinterpret_cast<_Value_type*>(_PDestBuf->_Get_host_ptr())),
_Create_reinterpreted_shape(_Dst_shape, _PDestBuf->_Get_elem_size(), sizeof(_Value_type)));
}));
}
else
{
// The dest buffer is not accesible on host. Lets create a temporary
// staging buffer on the destination buffer's accelerator_view
_Buffer_ptr _PTempStagingBuf = _Buffer::_Create_stage_buffer(_Dst->_Get_accelerator_view(), accelerator(accelerator::cpu_accelerator).default_view,
_Src_shape->_Get_view_size(), sizeof(_Value_type), true /* _Is_temp */);
_PTempStagingBuf->_Map_buffer(_Write_access, true /* _Wait */);
_Value_type *_Dst_ptr = reinterpret_cast<_Value_type*>(_PTempStagingBuf->_Get_host_ptr());
_Event _Ev = _Copy_impl_iter(_SrcFirst, _Src_shape, stdext::make_unchecked_array_iterator(_Dst_ptr), _Src_shape);
// Now copy from the staging buffer to the destination buffer
_Buffer_ptr _PDestBuf = _Dst;
return _Ev._Add_continuation(std::function<_Event()>([_PTempStagingBuf, _Src_shape, _PDestBuf, _Dst_shape]() mutable -> _Event {
return _Copy_impl(_PTempStagingBuf, _Src_shape, _PDestBuf, _Dst_shape);
}));
}
}
template <typename OutputIterator, typename _Value_type>
inline _Event _Copy_impl(_In_ _Buffer *_Src, _View_shape_ptr _Src_shape, OutputIterator _DestIter, _View_shape_ptr _Dst_shape)
{
_ASSERTE(_Src != NULL);
_ASSERTE(_Src_shape != NULL);
_ASSERTE(_Dst_shape != NULL);
if (_Src_shape->_Is_projection()) {
_Src_shape = _Src_shape->_Get_reduced_shape_for_copy();
}
if (_Dst_shape->_Is_projection()) {
_Dst_shape = _Dst_shape->_Get_reduced_shape_for_copy();
}
_ASSERTE(_Src_shape->_Get_rank() == _Dst_shape->_Get_rank());
_ASSERTE(_View_shape::_Compare_extent_with_elem_size(_Src_shape->_Get_rank(), _Src_shape->_Get_view_extent(),
_Src->_Get_elem_size(), _Dst_shape->_Get_view_extent(), sizeof(_Value_type)));
if (_Src->_Is_host_accessible(_Read_access))
{
// The source buffer is accessible on the host. Map the _Src buffer
_Event _Ev = _Src->_Map_buffer_async(_Read_access);
_Buffer_ptr _PSrcBuf = _Src;
return _Ev._Add_continuation(std::function<_Event()>([_PSrcBuf, _Src_shape, _DestIter, _Dst_shape]() mutable -> _Event {
return _Copy_impl_iter(reinterpret_cast<_Value_type*>(_PSrcBuf->_Get_host_ptr()),
_Create_reinterpreted_shape(_Src_shape, _PSrcBuf->_Get_elem_size(), sizeof(_Value_type)),
_DestIter, _Dst_shape);
}));
}
else
{
// The source buffer is not accessible on host. Lets create a temporary
// staging buffer on the source buffer's accelerator_view and initiate a copy
// from the source buffer to the temporary staging buffer
_Buffer_ptr _PTempStagingBuf = _Buffer::_Create_stage_buffer(_Src->_Get_accelerator_view(), accelerator(accelerator::cpu_accelerator).default_view,
_Dst_shape->_Get_view_size(), sizeof(_Value_type), true);
_Event _Ev = _Src->_Copy_to_async(_PTempStagingBuf, _Src_shape, _Dst_shape);
return _Ev._Add_continuation(std::function<_Event()>([_PTempStagingBuf, _Dst_shape, _DestIter]() mutable -> _Event {
return _Copy_impl_iter(reinterpret_cast<_Value_type*>(_PTempStagingBuf->_Get_host_ptr()),
_Dst_shape, _DestIter, _Dst_shape);
}));
}
}
// Iterator based structured copy function
template<typename _InputInterator, typename _OutputIterator>
inline _Event _Copy_impl_iter(_InputInterator _SrcIter, _View_shape_ptr _Src_shape,
_OutputIterator _DstIter, _View_shape_ptr _Dst_shape)
{
if (_Src_shape->_Is_projection()) {
_Src_shape = _Src_shape->_Get_reduced_shape_for_copy();
}
if (_Dst_shape->_Is_projection()) {
_Dst_shape = _Dst_shape->_Get_reduced_shape_for_copy();
}
_ASSERTE(_Src_shape->_Get_rank() == _Dst_shape->_Get_rank());
_ASSERTE(_View_shape::_Compare_extent(_Src_shape->_Get_rank(), _Src_shape->_Get_view_extent(), _Dst_shape->_Get_view_extent()));
// If both the _Src_shape and _Dst_shape are linear we can be more efficient
unsigned int _Src_linear_offset, _Src_linear_size, _Dst_linear_offset, _Dst_linear_size;
if (_Src_shape->_Is_view_linear(_Src_linear_offset, _Src_linear_size) &&
_Dst_shape->_Is_view_linear(_Dst_linear_offset, _Dst_linear_size))
{
_ASSERTE(_Src_linear_size == _Dst_linear_size);
// These iterators might be not contiguous, therefore we use std::advance
std::advance(_SrcIter, _Src_linear_offset);
auto _SrcLast = _SrcIter;
std::advance(_SrcLast, _Src_linear_size);
std::advance(_DstIter, _Dst_linear_offset);
return _Copy_impl_iter(_SrcIter, _SrcLast, _DstIter);
}
std::vector<unsigned int> _Src_extent(_Src_shape->_Get_rank());
std::vector<unsigned int> _Src_offset(_Src_shape->_Get_rank());
std::vector<unsigned int> _Dst_extent(_Dst_shape->_Get_rank());
std::vector<unsigned int> _Dst_offset(_Dst_shape->_Get_rank());
std::vector<unsigned int> _Copy_extent(_Src_shape->_Get_rank());
for (size_t i = 0; i < _Src_shape->_Get_rank(); ++i) {
_Src_extent[i] = _Src_shape->_Get_base_extent()[i];
_Src_offset[i] = _Src_shape->_Get_view_offset()[i];
_Dst_extent[i] = _Dst_shape->_Get_base_extent()[i];
_Dst_offset[i] = _Dst_shape->_Get_view_offset()[i];
_Copy_extent[i] = _Src_shape->_Get_view_extent()[i];
}
_Array_copy_desc _Desc(
_Src_shape->_Get_rank(),
_Src_shape->_Get_linear_offset(),
_Src_extent.data(),
_Src_offset.data(),
_Dst_shape->_Get_linear_offset(),
_Dst_extent.data(),
_Dst_offset.data(),
_Copy_extent.data());
// Note: Capturing shape pointers would be incorrect, they are valid for setting up the call.
// They might be deleted right after this call completes.
HRESULT hr = _Recursive_array_copy(_Desc, 1, [_SrcIter, _DstIter](const _Array_copy_desc &_Reduced) -> HRESULT {
auto _SrcFirst = _SrcIter;
auto _DstFirst = _DstIter;
std::advance(_DstFirst, _Reduced._Dst_linear_offset + _Reduced._Dst_copy_offset[0]);
std::advance(_SrcFirst, _Reduced._Src_linear_offset + _Reduced._Src_copy_offset[0]);
auto _SrcLast = _SrcFirst;
std::advance(_SrcLast, _Reduced._Copy_extents[0]);
std::copy(_SrcFirst, _SrcLast, _DstFirst);
return S_OK;
});
if (FAILED(hr)) {
throw Concurrency::runtime_exception("Failed to copy between buffers", E_FAIL);
}
return _Event();
}
// A ubiquitous buffer that provides access to the underlying data
// on any accelerator_view
class _Ubiquitous_buffer : public _Reference_counter
{
friend _Event _Get_access_async(const _View_key _Key, accelerator_view _Av, _Access_mode _Mode, _Buffer_ptr &_Buf_ptr);
friend _AMPIMP accelerator_view __cdecl _Select_copy_src_accelerator_view(_In_ _View_key _Src_view_key, const accelerator_view &_Dest_accelerator_view);
friend struct _DPC_call_handle;
public:
_AMPIMP static _Ret_ _Ubiquitous_buffer * __cdecl _Create_ubiquitous_buffer(size_t _Num_elems, size_t _Elem_size);
_AMPIMP static _Ret_ _Ubiquitous_buffer * __cdecl _Create_ubiquitous_buffer(_Buffer_ptr _Master_buffer);
// Register a new view on top of this _Ubiquitous_buffer
_AMPIMP void _Register_view(_In_ _View_key _Key, accelerator_view _Cpu_av, _View_shape_ptr _Shape);
// Register a copy of an existing view registered with this _Ubiquitous_buffer
_AMPIMP void _Register_view_copy(_In_ _View_key _New_view_key, _In_ _View_key _Existing_view_key);
// Unregister a view currently registered with this _Ubiquitous_buffer
_AMPIMP void _Unregister_view(_In_ _View_key _Key);
// Obtain a specified mode of access to the specified view on the specified target
// accelerator_view. This method also serves the purpose of determining the
// amount of data copy expected to happen as part of this _Get_access request
// without actually performing the copies or state updates in the _Ubiquitous_buffer. This
// is used for reporting the implicit data copies that happen when accessing array_views
// in C++ AMP ETW events
_AMPIMP _Event _Get_access_async(_In_ _View_key _Key, _Accelerator_view_impl_ptr _Av_view_impl_ptr,
_Access_mode _Mode, _Buffer_ptr &_Buf_ptr,
_Inout_opt_ ULONGLONG *_Sync_size = nullptr);
// Discard the content underlying this view
_AMPIMP void _Discard(_In_ _View_key _Key);
// This method does not synchonize the copies. Should not be used for getting
// data access but only to get the underlying buffer's properties
_AMPIMP _Buffer_ptr _Get_master_buffer() const;
_AMPIMP accelerator_view _Get_master_accelerator_view() const;
_AMPIMP _View_shape_ptr _Get_view_shape(_In_ _View_key _Key);
_Ret_ _Accelerator_view_impl* _Get_master_accelerator_view_impl() const
{
return _M_master_av;
}
size_t _Get_master_buffer_elem_size() const
{
return _M_master_buffer_elem_size;
}
size_t _Get_master_buffer_num_elems() const
{
return _M_master_buffer_num_elems;
}
bool _Has_data_source() const
{
return _M_has_data_source;
}
private:
// The _Ubiquitous_buffer constructors are private to force construction through the static
// _Create_ubiquitous_buffer method to ensure the object is allocated in the runtime
_Ubiquitous_buffer(size_t _Num_elems, size_t _Elem_size);
_Ubiquitous_buffer(_In_ _Buffer* _Master_buffer);
// Private destructor to force deletion through _Release
~_Ubiquitous_buffer();
// No default consturctor, copy constructor and assignment operator
_Ubiquitous_buffer();
_Ubiquitous_buffer(const _Ubiquitous_buffer &rhs);
_Ubiquitous_buffer &operator=(const _Ubiquitous_buffer &rhs);
// Helper methods
// Get access to a buffer on a specified accelerator for a specified pre-registered view.
// If _Sync_size parameter is not null, then function calculates number of bytes that we
// need to synchronize to get desired access.
_AMPIMP _Event _Get_access_async(_In_ _View_key _Key, accelerator_view _Av, _Access_mode _Mode,
_Buffer_ptr &_Buf_ptr, _Inout_opt_ ULONGLONG *_Sync_size = NULL);
// Commit a view to the master buffer if needed. When the _Sync_size parameter is non-null
// this method just returns the amount of data to be copied as part of the commit, without
// actually performing the commit
_Event _Commit_view_async(_In_ _View_info *_Info, _Inout_ ULONGLONG *_Sync_size = nullptr);
// Get the _Buffer_ptr corresponding to a specified accelerator_view. When the
// _Create parameter is true, it creates a new _Buffer if one does not already exist
// for that accelerator_view
_Ret_ _Buffer* _Get_buffer(_In_ _Accelerator_view_impl* _Av, bool _Create = true);
// Sets a new access mode for the specified view
void _Set_new_access_mode(_Inout_ _View_info *_Info, _Access_mode _New_mode);
// Unsets the discard flag from the specified view and all other
// overlapping views
void _Unset_discard_flag(_Inout_ _View_info *_Info);
// Determines whether the data underlying the specified view has been discarded
// based on whether a subsuming view has the discard flag set.
bool _Should_discard(const _View_info *_Info) const;
// Does this view have exclusive data which is not discarded,
// not on the master accelerator_view and also there is not other view
// that subsumes this view and is marked dirty
bool _Has_exclusive_data(const _View_info *_Info) const;
// Based on the current state of overlapping views in the _Ubiquitous_buffer
// does the specified view require a data update on the target accelerator_view
// to fulfil an access request
bool _Requires_update_on_target_accelerator_view(const _View_info *_Info,
_Access_mode _Requested_mode,
_In_ _Accelerator_view_impl* _Target_acclerator_view) const;
// This method iterates over all views in the specified commit list
// and flags them as "commit not needed" if that view is subsumed by another view present in the
// commit list
static void _Flag_redundant_commits(std::vector<std::pair<_View_info*, bool>> &_Commit_list);
// This method returns the list of accelerator_views where the specified view already has
// a valid cached copy of the data and getting read access would not incur any data movement.
// The _Can_access_anywhere parameter is an output parameter used to indicate to the
// caller that the specified view can be accessed on any accelerator_view without incurring
// any data movement. This is true when there are no modified overlapping views that require
// synchronization and the specified view has the discard_data flag set.
// This method is used for determining the source accelerator_view for copy and p_f_e operations
// involving array_views
_Accelerator_view_unordered_set _Get_caching_info(_In_ _View_key _Key, _Out_opt_ bool *_Can_access_anywhere = NULL);
_Accelerator_view_unordered_set _Get_caching_info_impl(_In_ _View_key _Key, _Out_opt_ bool *_Can_access_anywhere);
_Ret_ _Accelerator_view_impl* _Determine_alternate_target_accelerator_view(_In_ _View_key _Key,
_In_ _Accelerator_view_impl* _Original_av,
_Access_mode _Mode);
private:
// Private data
// The master accelerator_view for this _Ubiquitous_buffer
// which is specified at construction time
_Accelerator_view_impl_ptr _M_master_av;
// The master _Buffer corresponding to this _Ubiquitous_buffer
// which is specified at construction time
_Buffer* _M_master_buffer;
// The size of each element of the master buffer
size_t _M_master_buffer_elem_size;
// The number of elements in the master buffer
size_t _M_master_buffer_num_elems;
// Indicates if this ubiquitous buffer has an underlying data source
bool _M_has_data_source;
// A map of pre-created _Buffers corresponding to different
// accelerator_views where the _Ubiquitous_buffer has already been
// accessed
std::map<_Accelerator_view_impl_ptr, _Buffer_ptr> _M_buffer_map;
// A mapping between all registered view keys in this _Ubiquitous_buffer
// to their corresponding _View_info
std::unordered_map<_View_key, _View_info*> _M_view_map;
// Set of distinct views of this buffer. As multiple copies of the same
// view may have been registered for this _Ubiquitous_buffer, this set
// maintains the set of distinct views which really matter for the
// caching protocol. Also, note that some view_info may not have any live registered
// and hence does not exist in the _M_view_map but may exist here since
// it has uncomiitted data which needs to be considered as part of the cache
// coherence protocol to prevent modifications underlying this view from being lost
std::unordered_set<_View_info*> _M_view_info_set;
// Critical section object to protect the cache directory
Concurrency::critical_section _M_critical_section;
};
// Class defines functions for interoperability with D3D
class _D3D_interop
{
public:
_AMPIMP static _Ret_ IUnknown * __cdecl _Get_D3D_buffer(_In_ _Buffer *_Buffer_ptr);
_AMPIMP static _Ret_ IUnknown * __cdecl _Get_D3D_texture(_In_ _Texture *_Texture_ptr);
_AMPIMP static _Ret_ void * __cdecl _Get_D3D_sampler_data_ptr(_In_ IUnknown *_D3D_sampler);
_AMPIMP static void __cdecl _Release_D3D_sampler_data_ptr(_In_ void *_Sampler_data_ptr);
_AMPIMP static _Ret_ IUnknown * __cdecl _Get_D3D_sampler(const Concurrency::accelerator_view &_Av, _In_ _Sampler *_Sampler_ptr);
};
inline
_Event _Get_access_async(const _View_key _Key, accelerator_view _Av, _Access_mode _Mode, _Buffer_ptr &_Buf_ptr)
{
return _Key->_Get_buffer_ptr()->_Get_access_async(_Key->_Get_view_key(), _Av, _Mode, _Buf_ptr);
}
inline
_Ret_ _View_shape* _Get_buffer_view_shape(const _Buffer_descriptor& _Descriptor)
{
return _Descriptor._Get_buffer_ptr()->_Get_view_shape(_Descriptor._Get_view_key());
}
inline
bool _Is_cpu_accelerator(const accelerator& _Accl)
{
return (_Accl.device_path == accelerator::cpu_accelerator);
}
} // namespace Concurrency::details
/// <summary>
/// Exception thrown when an underlying DirectX call fails
/// due to the Windows timeout detection and recovery mechanism
/// </summary>
class accelerator_view_removed : public runtime_exception
{
public:
/// <summary>
/// Construct an accelerator_view_removed exception with a message and
/// a view removed reason code
/// </summary>
/// <param name="_Message">
/// Descriptive message of error
/// </param>
/// <param name="_View_removed_reason">
/// HRESULT error code indicating the cause of removal of the accelerator_view
/// </param>
_AMPIMP explicit accelerator_view_removed(const char * _Message, HRESULT _View_removed_reason) throw();
/// <summary>
/// Construct an accelerator_view_removed exception
/// </summary>
/// <param name="_View_removed_reason">
/// HRESULT error code indicating the cause of removal of the accelerator_view
/// </param>
_AMPIMP explicit accelerator_view_removed(HRESULT _View_removed_reason) throw();
/// <summary>
/// Returns an HRESULT error code indicating the cause of the accelerator_view's removal
/// </summary>
/// <returns>
/// The HRESULT error code that indicates the cause of accelerator_view's removal
/// </returns>
_AMPIMP HRESULT get_view_removed_reason() const throw();
private:
HRESULT _M_view_removed_reason_code;
}; // class accelerator_view_removed
/// <summary>
/// Exception thrown when the runtime fails to launch a kernel
/// using the compute domain specified at the parallel_for_each call site.
/// </summary>
class invalid_compute_domain : public runtime_exception
{
public:
/// <summary>
/// Construct an invalid_compute_domain exception with a message
/// </summary>
/// <param name="_Message">
/// Descriptive message of error
/// </param>
_AMPIMP explicit invalid_compute_domain(const char * _Message) throw();
/// <summary>
/// Construct an invalid_compute_domain exception
/// </summary>
_AMPIMP invalid_compute_domain() throw();
}; // class invalid_compute_domain
/// <summary>
/// Exception thrown when an unsupported feature is used
/// </summary>
class unsupported_feature : public runtime_exception
{
public:
/// <summary>
/// Construct an unsupported_feature exception with a message
/// </summary>
/// <param name="_Message">
/// Descriptive message of error
/// </param>
_AMPIMP explicit unsupported_feature(const char * _Message) throw();
/// <summary>
/// Construct an unsupported_feature exception
/// </summary>
_AMPIMP unsupported_feature() throw();
}; // class unsupported_feature
} // namespace Concurrency
// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
//
// Compiler/Runtime Interface
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
#define HELPERAPI __cdecl
using namespace Concurrency::details;
extern "C" {
// This structure is used for storing information about resources required by the kernel.
enum _Resource_kind
{
RESOURCE_BUFFER = 0,
RESOURCE_TEXTURE = 1,
RESOURCE_SAMPLER = 2,
};
struct _Device_resource_info
{
_Resource_kind _M_resource_kind; // buffer, texture, or sampler
void * _M_desc; // Pointer to the _Buffer_descriptor/_Texture_descriptor/_Sampler_descriptor instance
// which underlies all device resource
_Access_mode _M_formal_access_mode; // scalar: read-only
// const scalar ref: read-only
// scalar ref: ReadWrite
// array: ReadWrite
// const array: ReadOnly
size_t _M_actual_arg_num;
BOOL _Is_buffer() const
{
return (_M_resource_kind == RESOURCE_BUFFER);
}
BOOL _Is_texture() const
{
return (_M_resource_kind == RESOURCE_TEXTURE);
}
BOOL _Is_sampler() const
{
return (_M_resource_kind == RESOURCE_SAMPLER);
}
_Ret_ _Buffer_descriptor * _Get_buffer_desc() const
{
_ASSERTE(_Is_buffer());
return reinterpret_cast<_Buffer_descriptor *>(_M_desc);
}
_Ret_ _Texture_descriptor * _Get_texture_desc() const
{
_ASSERTE(_Is_texture());
return reinterpret_cast<_Texture_descriptor *>(_M_desc);
}
_Ret_ _Sampler_descriptor * _Get_sampler_desc() const
{
_ASSERTE(_Is_sampler());
return reinterpret_cast<_Sampler_descriptor *>(_M_desc);
}
_Ret_ void * _Get_resource_ptr() const
{
if (_Is_buffer())
{
_Ubiquitous_buffer * _Tmp = _Get_buffer_desc()->_Get_buffer_ptr();
return reinterpret_cast<void *>(_Tmp);
}
else if (_Is_texture())
{
_Texture * _Tmp = _Get_texture_desc()->_Get_texture_ptr();
return reinterpret_cast<void *>(_Tmp);
}
else
{
_ASSERTE(_Is_sampler());
_Sampler * _Tmp = _Get_sampler_desc()->_Get_sampler_ptr();
return reinterpret_cast<void *>(_Tmp);
}
}
};
// This structure is used for storing information about the const buffers
struct _Device_const_buffer_info
{
void * _M_data; // Pointer to the host data to intialize the
// constant buffer with
size_t _M_const_buf_size; // Size of the const buffer in bytes
unsigned int _M_is_debug_data; // Is this debug data which will be
// intialized by the runtime. 0 (false), 1 (true)
};
}
namespace Concurrency
{
namespace details
{
enum _DPC_kernel_func_kind
{
NON_ALIASED_SHADER = 0, // slot 0
ALIASED_SHADER = 1, // slot 1
NUM_SHADER_VERSIONS = 2
};
struct _DPC_call_handle
{
_Accelerator_view_impl *_M_rv;
bool _M_is_explicit_target_acclview;
// Info about the kernel function arguments
_Device_resource_info * _M_device_resource_info;
size_t _M_num_resources;
size_t _M_num_writable_buffers;
size_t _M_num_samplers;
// Info about the host buffer created corresponding to the const buffer
_Device_const_buffer_info * _M_const_buffer_info;
size_t _M_num_const_buffers;
bool _M_RW_aliasing;
// Kernel funcs
_DPC_shader_blob * _M_shader_blobs[NUM_SHADER_VERSIONS];
// Compute domain info
int _M_is_flat_model;
unsigned int _M_compute_rank;
unsigned int * _M_grid_extents;
// Kernel dispatch info
unsigned int _M_groupCountX;
unsigned int _M_groupCountY;
unsigned int _M_groupCountZ;
// The shape of the group
unsigned int _M_groupExtentX;
unsigned int _M_groupExtentY;
unsigned int _M_groupExtentZ;
_DPC_call_handle(const accelerator_view &_Accelerator_view)
{
if (!_Accelerator_view.is_auto_selection) {
_M_rv = _Get_accelerator_view_impl_ptr(_Accelerator_view);
}
else {
_M_rv = NULL;
}
_M_is_explicit_target_acclview = false;
if (_M_rv != NULL) {
_M_is_explicit_target_acclview = true;
}
_M_device_resource_info = NULL;
_M_num_resources = 0;
_M_num_writable_buffers = 0;
_M_num_samplers = 0;
_M_const_buffer_info = NULL;
_M_num_const_buffers = 0;
_M_RW_aliasing = false;
for (size_t _I = 0; _I < NUM_SHADER_VERSIONS; _I++)
{
_M_shader_blobs[_I] = NULL;
}
_M_is_flat_model = 0;
_M_compute_rank = 0;
_M_grid_extents = NULL;
_M_groupCountX = 0;
_M_groupCountY = 0;
_M_groupCountZ = 0;
_M_groupExtentX = 0;
_M_groupExtentY = 0;
_M_groupExtentZ = 0;
}
~_DPC_call_handle()
{
if (_M_grid_extents) {
delete [] _M_grid_extents;
}
}
bool _Is_buffer_aliased(_In_ void *_Buffer_ptr)
{
return ((_M_aliased_buffer_set != nullptr) && (_M_aliased_buffer_set->find(_Buffer_ptr) != _M_aliased_buffer_set->end()));
}
bool _Is_buffer_unaccessed(size_t _Buffer_idx)
{
return ((_M_is_device_buffer_unaccessed != nullptr) && _M_is_device_buffer_unaccessed->operator[](_Buffer_idx));
}
void _Set_buffer_unaccessed(size_t _Buffer_idx)
{
if (_M_is_device_buffer_unaccessed == nullptr) {
_M_is_device_buffer_unaccessed = std::unique_ptr<std::vector<bool>>(new std::vector<bool>(_M_num_resources, false));
}
_M_is_device_buffer_unaccessed->operator[](_Buffer_idx) = true;
}
const int* _Get_redirect_indices() const
{
if (!_M_RW_aliasing) {
return nullptr;
}
_ASSERTE(_M_Redirect_indices != nullptr);
return _M_Redirect_indices->data();
}
void _Check_buffer_aliasing();
void _Update_buffer_rw_property();
void _Setup_aliasing_redirection_indices();
void _Select_accelerator_view();
void _Verify_buffers_against_accelerator_view();
private:
std::unique_ptr<std::unordered_set<void*>> _M_aliased_buffer_set;
std::unique_ptr<std::vector<bool>> _M_is_device_buffer_unaccessed;
// Info about read-write aliasing
std::unique_ptr<std::vector<int>> _M_Redirect_indices;
};
// This structure is used for passing the scheduling
// info to the parallel_for_each which is handed back
// to the compiler-runtime interface methods by the front-end
struct _Host_Scheduling_info
{
// The accelerator view to invoke a parallel_for_each on
accelerator_view _M_accelerator_view;
};
} // namespace Concurrency::details
/// <summary>
/// Uninitializes the C++ AMP runtime. It is legal to
/// call this function multiple times during an applications
/// lifetime. Calling any C++ AMP API afer calling this function
/// will reinitialize the C++ AMP runtime. Note that it is illegal
/// to use C++ AMP objects across calls to this function and doing
/// so will result in undefined behavior. Also, concurrently calling
/// this function and any other AMP APIs is illegal and would result
/// in undefined behavior.
/// </summary>
_AMPIMP void __cdecl amp_uninitialize();
} // namespace Concurrency
extern "C" {
// Return a compiler helper handle.
_AMPIMP _Ret_ _DPC_call_handle * HELPERAPI __dpc_create_call_handle(_In_ _Host_Scheduling_info *_Sch_info) throw(...);
// Destroy the call handle
_AMPIMP void HELPERAPI __dpc_release_call_handle(_In_ _DPC_call_handle * _Handle) throw(...);
_AMPIMP void HELPERAPI __dpc_set_device_resource_info(_In_ _DPC_call_handle * _Handle, _In_ _Device_resource_info * _DeviceResourceInfo, size_t _NumResources) throw(...);
// Set const buffer info.
_AMPIMP void HELPERAPI __dpc_set_const_buffer_info(_In_ _DPC_call_handle * _Handle, _In_ _Device_const_buffer_info * _DeviceConstBufferInfo, size_t _NumConstBuffers) throw(...);
// Set the kernel shader info
_AMPIMP void HELPERAPI __dpc_set_kernel_shader_info(_In_ _DPC_call_handle * _Handle,
_Inout_ void ** _ShaderBlobs) throw(...);
// Set kernel dispatch info
_AMPIMP void HELPERAPI __dpc_set_kernel_dispatch_info(_In_ _DPC_call_handle * _Handle,
unsigned int _ComputeRank,
_In_ int * _Extents,
unsigned int _GroupRank,
const unsigned int * _GroupExtents,
unsigned int & _GroupCountX,
unsigned int & _GroupCountY,
unsigned int & _GroupCountZ) throw(...);
// Dispatch the kernel
_AMPIMP void HELPERAPI __dpc_dispatch_kernel(_In_ _DPC_call_handle * _Handle) throw(...);
#ifdef _DEBUG
// Dispatch the kernel passed as a HLSL source level shader
// This function is to be used only for testing and debugging purposes
_AMPIMP void HELPERAPI __dpc_dispatch_kernel_test(_In_ _DPC_call_handle * _Handle, _In_ WCHAR* szFileName, LPCSTR szEntryPoint) throw(...);
#endif
}
// =+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+=+
//
// C++ AMP ETW Provider
//
// =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
namespace Concurrency
{
namespace details
{
// Thread-safe factory method for _Amp_runtime_trace object
_AMPIMP _Ret_ _Amp_runtime_trace* __cdecl _Get_amp_trace();
// Class that gathers C++ AMP diagnostic information and triggers events
class _Amp_runtime_trace
{
// Called by factory to create single instance of _Amp_runtime_trace type
friend BOOL CALLBACK _Init_amp_runtime_trace(PINIT_ONCE _Init_once, PVOID _Param, _Inout_ PVOID *_Context);
public:
// Destructor for _Amp_runtime_trace, called at program termination
_AMPIMP ~_Amp_runtime_trace();
// End event is triggered by multiple other events such us StartComputeEvent to show exactly when given activity completed
_AMPIMP void _Write_end_event(ULONG _Span_id);
// Add accelerator configuration information
// Note: This member function does not have to be exported, it is used by C++ AMP runtime factory
void _Add_accelerator_config_event(PVOID _Accelerator_id, LPCWSTR _Device_path, LPCWSTR _Device_description);
// Used by callback function, to write all configuration data when new session is detected
// Note: This member function does not have to be exported, it is used by C++ AMP runtime factory
void _Write_all_accelerator_config_events();
// Started accelerator_view::wait operation
// Note: This member function does not have to be exported, it is used by C++ AMP runtime factory
ULONG _Start_accelerator_view_wait_event(PVOID _Accelerator_id, PVOID _Accelerator_view_id);
// Launched accelerator_view::flush operation
// Note: This member function does not have to be exported, it is used by C++ AMP runtime factory
void _Launch_flush_event(PVOID _Accelerator_id, PVOID _Accelerator_view_id);
// Launched accelerator_view::create_marker operation
// Note: This member function does not have to be exported, it is used by C++ AMP runtime factory
ULONG _Launch_marker(PVOID _Accelerator_id, PVOID _Accelerator_view_id);
// Below are set of helpers that take various types that were available at event injection point and extract all necessary data
_AMPIMP ULONG _Start_parallel_for_each_event_helper(_In_ _DPC_call_handle *_Handle);
// This helper wraps functor with wait start and wait end events
inline concurrency::completion_future _Start_async_op_wait_event_helper(ULONG _Async_op_id, _Event _Ev)
{
std::shared_future<void> retFuture;
concurrency::task_completion_event<void> retTaskCompletionEvent;
// Create a std::shared_future by creating a deferred task through std::async that waits for the
// event _Ev to finish. Wrap functor with start and end events
retFuture = std::async(std::launch::sync, [=]() mutable {
try
{
if (_Async_op_id == _Amp_runtime_trace::_M_event_disabled)
{
_Ev._Get();
}
else
{
auto _Span_id = details::_Get_amp_trace()->_Start_async_op_wait_event(_Async_op_id);
_Ev._Get();
details::_Get_amp_trace()->_Write_end_event(_Span_id);
}
}
catch(...)
{
// If an exception is encountered when executing the asynchronous operation
// we should set the exception on the retTaskCompletionEvent so that it is
// appropriately cancelled and the exception is propagated to continuations
retTaskCompletionEvent.set_exception(std::current_exception());
throw;
}
retTaskCompletionEvent.set();
});
// Register the async event with the runtime asynchronous events manager
_Register_async_event(_Ev, retFuture);
// Lets issue a continuation just to swallow any exceptions that are encountered during the
// async operation and are never observed by the user or are just observed through the
// shared_future and not through the task
concurrency::task<void> retTask(retTaskCompletionEvent);
retTask.then([](concurrency::task<void> _Task) {
try {
_Task.get();
}
catch(...) {
}
});
return Concurrency::completion_future(retFuture, retTask);
}
_AMPIMP ULONG _Start_array_view_synchronize_event_helper(const _Buffer_descriptor &_Buff_desc);
_AMPIMP ULONG _Launch_array_view_synchronize_event_helper(const _Buffer_descriptor &_Buff_desc);
// Helpers for buffers (array, array_view)
_AMPIMP ULONG _Start_copy_event_helper(const _Buffer_descriptor &_Src, const _Buffer_descriptor &_Dest, ULONGLONG _Num_bytes_for_copy);
_AMPIMP ULONG _Start_copy_event_helper(nullptr_t, const _Buffer_descriptor &_Dest, ULONGLONG _Num_bytes_for_copy);
_AMPIMP ULONG _Start_copy_event_helper(const _Buffer_descriptor &_Src, nullptr_t, ULONGLONG _Num_bytes_for_copy);
_AMPIMP ULONG _Launch_async_copy_event_helper(const _Buffer_descriptor &_Src, const _Buffer_descriptor &_Dest, ULONGLONG _Num_bytes_for_copy);
_AMPIMP ULONG _Launch_async_copy_event_helper(nullptr_t, const _Buffer_descriptor &_Dest, ULONGLONG _Num_bytes_for_copy);
_AMPIMP ULONG _Launch_async_copy_event_helper(const _Buffer_descriptor &_Src, nullptr_t, ULONGLONG _Num_bytes_for_copy);
// Helper for textures
_AMPIMP ULONG _Start_copy_event_helper(const _Texture_descriptor &_Src, nullptr_t, ULONGLONG _Num_bytes_for_copy);
_AMPIMP ULONG _Start_copy_event_helper(nullptr_t, const _Texture_descriptor &_Dest, ULONGLONG _Num_bytes_for_copy);
_AMPIMP ULONG _Start_copy_event_helper(const _Texture_descriptor &_Src, const _Texture_descriptor &_Dest, ULONGLONG _Num_bytes_for_copy);
_AMPIMP ULONG _Launch_async_copy_event_helper(const _Texture_descriptor &_Src, nullptr_t, ULONGLONG _Num_bytes_for_copy);
_AMPIMP ULONG _Launch_async_copy_event_helper(nullptr_t, const _Texture_descriptor &_Dest, ULONGLONG _Num_bytes_for_copy);
_AMPIMP ULONG _Launch_async_copy_event_helper(const _Texture_descriptor &_Src, const _Texture_descriptor &_Dest, ULONGLONG _Num_bytes_for_copy);
void _Enable_provider(bool _Enable = true);
private:
// Private constructor. This type is created by factory method
_Amp_runtime_trace(PVOID _Callback_function, _In_ _Trace *_Trace);
// Disallow copy construction
_Amp_runtime_trace(const _Amp_runtime_trace&);
// Disallow assignment operator
_Amp_runtime_trace& operator=(const _Amp_runtime_trace&);
// Used internally to write configuation events
void _Write_accelerator_config_event(const std::tuple<PVOID, LPCWSTR, LPCWSTR> &_ConfigTuple);
// Event triggered when computation is scheduled
ULONG _Start_parallel_for_each_event(
PVOID _Accelerator_id,
PVOID _Accelerator_view_id,
BOOL _Is_tiled_explicitly,
ULONGLONG _Num_of_tiles,
ULONG _Num_of_threads_per_tile,
BOOL _Is_aliased,
ULONG _Num_read_only_resources,
ULONG _Num_read_write_resources,
ULONGLONG _Size_of_all_resouces,
ULONG _Size_of_const_data,
ULONGLONG _Size_of_data_for_copy);
// Synchronous copy operation has started
ULONG _Start_copy_event(
PVOID _Src_accelerator_id,
PVOID _Src_accelerator_view_id,
PVOID _Dst_accelerator_id,
PVOID _Dst_accelerator_view_id,
ULONGLONG _Num_bytes_for_copy,
BOOL _Is_src_staging,
BOOL _Is_dst_staging);
// Asynchronous copy operation has been launched
ULONG _Launch_async_copy_event(
PVOID _Src_accelerator_id,
PVOID _Src_accelerator_view_id,
PVOID _Dst_accelerator_id,
PVOID _Dst_accelerator_view_id,
ULONGLONG _Num_bytes_for_copy,
BOOL _Is_src_staging,
BOOL _Is_dst_staging);
// Started waiting for asynchronous operation to complete
_AMPIMP ULONG _Start_async_op_wait_event(ULONG _Async_op_id);
// Started array_view::synchronize operation
ULONG _Start_array_view_synchronize_event(ULONGLONG _Num_bytes_to_synchronize);
// Async array_view::synchronize operation has been launched
ULONG _Launch_array_view_synchronize_event(ULONGLONG _Num_bytes_to_synchronize);
// Helper function that extracts information from buffer descriptor
std::tuple<PVOID, PVOID, BOOL> _Get_resource_diagnostic_info(const _Buffer_descriptor &_Buff_desc, accelerator_view _Accl_view) const;
// Helper function that extracts information from texture descriptor
std::tuple<PVOID, PVOID, BOOL> _Get_resource_diagnostic_info(const _Texture_descriptor &_Tex_desc) const;
// Generates unique identifiers for span_id and async_op_id
ULONG _Get_unique_identifier();
// Critical section object used by callback function to synchronize following situations:
// a) multiple sessions have started at the same time
// b) C++ AMP Runtime factory adds new accelerator config event to the collection
Concurrency::critical_section _M_critical_section;
// Collection of all configuration events at the time of C++ AMP Runtime initialization
std::vector<std::tuple<PVOID, LPCWSTR, LPCWSTR>> _M_accelerator_configs;
// Unique counter for span id and async operation id
volatile ULONG _M_counter;
// Type that implements ITrace interface and writes events e.g. ETW events
_Trace* _M_trace_ptr;
// Special value that we return to chain events if provider is disabled
static const ULONG _M_event_disabled = 0;
};
// Helper function to query the number of mipmap levels from texture object
inline unsigned int _Get_mipmap_levels(const _Texture *_Tex)
{
_ASSERTE(_Tex);
return _Tex->_Get_mip_levels();
}
} // namespace Concurrency::details
} // namespace Concurrency
namespace concurrency = Concurrency;
#pragma pack(pop)