Concurrency::details Namespace Reference

Namespaces
	platform
	std

Classes
class	_Accelerator_view_hasher
class	_Aggregated_operation
	_Aggregated_operation base class More...
class	_Aggregator
	An aggregator for collecting operations coming from multiple sources and executing them serially on a single thread. _Operation_type must be derived from _Aggregated_operation. The parameter _Handler_type is a functor that will be passed the list of operations and is expected to handle each operation appropriately, setting the status of each operation to non-zero. More...
class	_Allocator_base
struct	_AllocBase
class	_Amp_runtime_trace
class	_AnonymousOriginator
struct	_arithmetic_op_helper
struct	_arithmetic_op_helper< _T, opAdd >
struct	_arithmetic_op_helper< _T, opDiv >
struct	_arithmetic_op_helper< _T, opMod >
struct	_arithmetic_op_helper< _T, opMul >
struct	_arithmetic_op_helper< _T, opSub >
struct	_arithmetic_op_loop_helper
struct	_arithmetic_op_loop_helper< _T, _Kind, 1, false >
struct	_arithmetic_op_loop_helper< _T, _Kind, _Rank, false >
struct	_arithmetic_op_loop_helper< _T, _Kind, _Rank, true >
struct	_Array_copy_desc
struct	_Array_flatten_helper
struct	_Array_flatten_helper< 1, _T1, _T2 >
struct	_Array_flatten_helper< 2, _T1, _T2 >
struct	_Array_flatten_helper< 3, _T1, _T2 >
struct	_Array_init_helper
struct	_Array_init_helper< _T1, _T2, 1 >
struct	_Array_init_helper< _T1, _T2, 2 >
struct	_Array_init_helper< _T1, _T2, 3 >
struct	_Array_init_helper< _T1, _T2, 4 >
class	_Array_projection_helper
class	_Array_projection_helper< _T, 1 >
class	_Array_view_base
class	_Array_view_projection_helper
class	_Array_view_projection_helper< _T, 1 >
class	_Array_view_shape
class	_AsyncOriginator
class	_AsyncTaskCollection
	Async Task collections is a thin wrapper over task collection to cater to the execution of asynchronous chores (or tasks defined in ppltasks.h). Specifically, they manage their own lifetime by using reference counts. Scheduling a chore acquires a reference and on completion of its execution the reference is released. More...
struct	_AutoDeleter
struct	_BadArgType
struct	_BadContinuationParamType
struct	_Beacon_reference
	Internal maintainence structure for beacons. More...
class	_Buffer
struct	_Buffer_descriptor
class	_Cancellation_beacon
	A cancellation beacon is a flag which can be polled in an inlinable fashion using the is_signaled method in lieu of polling on the more expensive non inlinable is_current_task_group_canceling method. More...
class	_CancellationTokenCallback
class	_CancellationTokenRegistration
class	_CancellationTokenState
struct	_Chore
struct	_cmp_op_helper
struct	_cmp_op_helper< _T, opEq >
struct	_cmp_op_helper< _T, opNeq >
struct	_cmp_op_loop_helper
struct	_cmp_op_loop_helper< _T, _Kind, 1, false >
struct	_cmp_op_loop_helper< _T, _Kind, _Rank, false >
struct	_cmp_op_loop_helper< _T, _Kind, _Rank, true >
struct	_compound_assign_op_helper
struct	_compound_assign_op_helper< _T, opAddEq >
struct	_compound_assign_op_helper< _T, opAssign >
struct	_compound_assign_op_helper< _T, opDivEq >
struct	_compound_assign_op_helper< _T, opModEq >
struct	_compound_assign_op_helper< _T, opMulEq >
struct	_compound_assign_op_helper< _T, opSubEq >
struct	_compound_assign_op_loop_helper
struct	_compound_assign_op_loop_helper< _T, _Kind, 1, false >
struct	_compound_assign_op_loop_helper< _T, _Kind, _Rank, false >
struct	_compound_assign_op_loop_helper< _T, _Kind, _Rank, true >
struct	_compound_assign_op_loop_helper< _T, opAssign, 1, false >
struct	_compound_assign_op_loop_helper< _T, opAssign, 2, true >
struct	_compound_assign_op_loop_helper< _T, opAssign, 3, true >
struct	_compound_assign_op_loop_helper< _T, opAssign, 4, true >
struct	_CONCRT_TRACE_INFO
class	_Concurrent_hash
class	_Concurrent_queue_base_v4
class	_Concurrent_queue_iterator
class	_Concurrent_queue_iterator_base_v4
class	_Concurrent_queue_rep
class	_Concurrent_unordered_map_traits
class	_Concurrent_unordered_set_traits
class	_Concurrent_vector_base_v4
class	_Condition_variable
	A _Condition_variable which is explicitly aware of the Concurrency Runtime. More...
class	_Const_array_projection_helper
class	_Const_array_projection_helper< _T, 1 >
class	_Const_array_view_projection_helper
class	_Const_array_view_projection_helper< _T, 1 >
struct	_contains
struct	_contains< _EXT, _IDX, 1 >
struct	_contains< _EXT, _IDX, 2 >
struct	_contains< _EXT, _IDX, 3 >
class	_Context
class	_ContextCallback
struct	_ContinuationTaskHandleBase
struct	_ContinuationTypeTraits
class	_CurrentScheduler
class	_D3D_interop
struct	_DPC_call_handle
class	_Dynamic_array
class	_Event
struct	_ExceptionHolder
struct	_Falsifier
struct	_FunctionTypeTraits
struct	_FunctionTypeTraits< _Function, void >
class	_Hash_compare
struct	_Host_Scheduling_info
struct	_index_helper
struct	_InitFunctorTypeTraits
struct	_InitFunctorTypeTraits< T, T >
struct	_Internal_task_options
class	_Interruption_exception
struct	_Is_container
struct	_IsIAsyncInfo
struct	_IsUnwrappedAsyncSelector
struct	_IsUnwrappedAsyncSelector< _TypeSelectorNoAsync >
class	_MallocaArrayHolder
class	_MallocaListHolder
struct	_map_index
struct	_map_index< _T1, 1 >
struct	_map_index< _T1, 2 >
struct	_map_index< _T1, 3 >
struct	_map_index< _T1, 4 >
struct	_Micro_queue
class	_NonReentrantBlockingLock
class	_NonReentrantPPLLock
struct	_NormalizeVoidToUnitType
struct	_NormalizeVoidToUnitType< void >
class	_Originator
struct	_PPLTaskHandle
	The _PPLTaskHandle is the strong-typed task handle base. All user task functions need to be wrapped in this task handler to be executable by PPL. By deriving from a different _BaseTaskHandle, it can be used for both initial tasks and continuation tasks. For initial tasks, _PPLTaskHandle will be derived from _UnrealizedChore_t, and for continuation tasks, it will be derived from _ContinuationTaskHandleBase. The life time of the _PPLTaskHandle object is be managed by runtime if task handle is scheduled. More...
struct	_product_helper
struct	_product_helper< _T, 1, false >
struct	_product_helper< _T, _Rank, false >
struct	_product_helper< _T, _Rank, true >
struct	_project0
struct	_project0< _RES_EXT, _SRC_EXT, _RES_IDX, _SRC_IDX, 2 >
struct	_project0< _RES_EXT, _SRC_EXT, _RES_IDX, _SRC_IDX, 3 >
class	_Projection_result_type
class	_Projection_result_type< _T, 1 >
class	_Queue
class	_ReaderWriterLock
class	_ReentrantBlockingLock
class	_ReentrantLock
class	_ReentrantPPLLock
class	_RefCounter
class	_RefCounterBase
class	_Reference_counted_obj_ptr
class	_Reference_counter
struct	_ResultHolder
class	_Runtime_object
class	_Sampler
struct	_Sampler_descriptor
class	_Scheduler
class	_Solist_const_iterator
class	_Solist_iterator
struct	_SpinCount
class	_SpinLock
class	_SpinWait
	Implements busy wait with no backoff More...
class	_Split_order_list_node
class	_Split_order_list_value
class	_Split_ordered_list
class	_StackGuard
	RAII wrapper used to maintain and limit ppltask maximum inline schedule depth. This class will keep a reference to the depth slot on current context. More...
class	_StructuredTaskCollection
	Structured task collections represent groups of work which follow a strictly LIFO ordered paradigm queueing and waiting respectively. They can only be waited on once and can only be used from a single thread of execution. More...
class	_Subatomic
struct	_Subatomic_impl
struct	_Subatomic_impl< 4 >
class	_SyncOriginator
struct	_Task_completion_event_impl
struct	_Task_generator_oversubscriber
struct	_Task_impl
	The implementation of a first-class task. This structure contains the task group used to execute the task function and handles the scheduling. The _Task_impl is created as a shared_ptr member of the the public task class, so its destruction is handled automatically. More...
struct	_Task_impl_base
	The base implementation of a first-class task. This class contains all the non-type specific implementation details of the task. More...
struct	_Task_ptr
class	_TaskCollection
	Task collections represent groups of work which step outside the strict structuring of the _StructuredTaskCollection definition. Any groups of work which do not follow LIFO ordering, are waited on multiple times, or are passed between arbitrary threads require utilization of this definition of a task collection. It has additional overhead over the _StructuredTaskCollection. More...
class	_TaskCollectionBase
class	_TaskCollectionImpl
class	_TaskCreationCallstack
	Callstack container, which is used to capture and preserve callstacks in ppltasks. Members of this class is examined by vc debugger, thus there will be no public access methods. Please note that names of this class should be kept stable for debugger examining. More...
struct	_TaskEventLogger
struct	_TaskProcHandle
struct	_TaskProcThunk
	Helper object used for LWT invocation. More...
struct	_TaskTypeFromParam
struct	_TaskTypeTraits
struct	_TaskTypeTraits< void >
struct	_TaskWorkItemRAIILogger
class	_Texture
struct	_Texture_descriptor
struct	_Texture_predefined_sample_helper
struct	_Texture_predefined_sample_helper< _T, 1 >
struct	_Texture_predefined_sample_helper< _T, 2 >
struct	_Texture_predefined_sample_helper< _T, 3 >
struct	_Texture_read_helper
struct	_Texture_read_helper< _T, 1 >
struct	_Texture_read_helper< _T, 2 >
struct	_Texture_read_helper< _T, 3 >
struct	_Texture_sample_helper
struct	_Texture_sample_helper< _T, 1 >
struct	_Texture_sample_helper< _T, 2 >
struct	_Texture_sample_helper< _T, 3 >
struct	_Texture_write_helper
struct	_Texture_write_helper< _T, 1 >
struct	_Texture_write_helper< _T, 2 >
struct	_Texture_write_helper< _T, 3 >
class	_Timer
struct	_TypeSelectorAsyncAction
struct	_TypeSelectorAsyncActionWithProgress
struct	_TypeSelectorAsyncOperation
struct	_TypeSelectorAsyncOperationOrTask
struct	_TypeSelectorAsyncOperationWithProgress
struct	_TypeSelectorAsyncTask
struct	_TypeSelectorNoAsync
class	_Ubiquitous_buffer
class	_UnrealizedChore
struct	_UnwrapTaskType
struct	_UnwrapTaskType< task< _Ty > >
class	_Vector_iterator
class	_View_shape
class	CancellationTokenRegistration_TaskProc

Typedefs
typedef enum _Short_vector_base_type_id	_Texture_base_type_id
typedef _Buffer_descriptor *	_View_key
typedef struct Concurrency::details::_Buffer_descriptor	_Buffer_descriptor
typedef struct Concurrency::details::_Texture_descriptor	_Texture_descriptor
typedef struct Concurrency::details::_Sampler_descriptor	_Sampler_descriptor
typedef std::unordered_set< accelerator_view, _Accelerator_view_hasher >	_Accelerator_view_unordered_set
typedef _SpinWait	_SpinWaitBackoffNone
typedef _SpinWait< 0 >	_SpinWaitNoYield
typedef void(__cdecl *	_UnobservedExceptionHandler) (void)
typedef size_t	_Ticket
typedef _Concurrent_queue_base_v4	_Concurrent_queue_base
typedef _Concurrent_queue_iterator_base_v4	concurrent_queue_iterator_base
typedef _Concurrent_vector_base_v4	_Concurrent_vector_base
typedef size_t	_Map_key
typedef _Map_key	_Split_order_key
typedef ::Concurrency::details::_TaskCollectionImpl	_TaskCollection_t
typedef ::Concurrency::details::_TaskInliningMode	_TaskInliningMode_t
typedef ::Concurrency::details::_Task_generator_oversubscriber	_Task_generator_oversubscriber_t
typedef std::atomic< long >	atomic_long
	Atomics More...
typedef std::atomic< size_t >	atomic_size_t
typedef unsigned char	_Unit_type
typedef _TaskCollection_t::_TaskProcHandle_t	_UnrealizedChore_t
typedef std::shared_ptr< _Task_impl_base >	_Task_ptr_base

Enumerations
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 }
enum	_DPC_kernel_func_kind { NON_ALIASED_SHADER = 0, ALIASED_SHADER = 1, NUM_SHADER_VERSIONS = 2 }
enum	_TaskCollectionStatus { _NotComplete, _Completed, _Canceled }
enum	_TaskInliningMode { _NoInline = 0, _DefaultAutoInline = 16, _ForceInline = -1 }
	The enum defines inlining scheduling policy for ppltasks. Scheduling a chore or a functor with _TaskInliningMode will give scheduler a hint on whether apply inline execution or not. More...
enum	_eInitializeState { _do_not_initialize }
enum	_op_kind {   opEq, opNeq, opNot, opAssign,   opAddEq, opSubEq, opMulEq, opDivEq,   opModEq, opAdd, opSub, opMul,   opDiv, opMod }

Functions
template<class _Type >
__int64	_Trace_agents_get_id (_Type *_PObject)
template<int _Old_element_size, int _New_element_size>
int	_Calculate_reinterpreted_size (int _Old_size) __GPU_ONLY
template<typename _Value_type , int _Rank>
_Event	_Copy_async_impl (const array< _Value_type, _Rank > &_Src, array< _Value_type, _Rank > &_Dest)
template<typename InputIterator , typename _Value_type , int _Rank>
_Event	_Copy_async_impl (InputIterator _SrcFirst, InputIterator _SrcLast, array< _Value_type, _Rank > &_Dest)
template<typename OutputIterator , typename _Value_type , int _Rank>
_Event	_Copy_async_impl (const array< _Value_type, _Rank > &_Src, OutputIterator _DestIter)
template<typename _Value_type , int _Rank>
_Event	_Copy_async_impl (const array< _Value_type, _Rank > &_Src, const array_view< _Value_type, _Rank > &_Dest)
template<typename _Value_type , int _Rank>
_Event	_Copy_async_impl (const array_view< const _Value_type, _Rank > &_Src, array< _Value_type, _Rank > &_Dest)
template<typename _Value_type , int _Rank>
_Event	_Copy_async_impl (const array_view< const _Value_type, _Rank > &_Src, const array_view< _Value_type, _Rank > &_Dest)
template<typename InputIterator , typename _Value_type , int _Rank>
_Event	_Copy_async_impl (InputIterator _SrcFirst, InputIterator _SrcLast, const array_view< _Value_type, _Rank > &_Dest)
template<typename OutputIterator , typename _Value_type , int _Rank>
_Event	_Copy_async_impl (const array_view< _Value_type, _Rank > &_Src, OutputIterator _DestIter)
_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)
bool	_Is_valid_access_mode (_Access_mode _Mode)
_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)
_Ret_ _View_shape *	_Create_reinterpreted_shape (const _View_shape *_Source_shape, size_t _Curr_elem_size, size_t _New_elem_size)
_Access_mode	_Get_synchronize_access_mode (access_type cpu_access_type)
access_type	_Get_cpu_access_type (_Access_mode _Cpu_access_mode)
_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)
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)
template<typename _Input_iterator , typename _Value_type >
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)
template<typename _Output_iterator , typename _Value_type >
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)
_AMPIMP size_t __cdecl	_Get_preferred_copy_chunk_size (size_t _Total_copy_size_in_bytes)
size_t	_Get_preferred_copy_chunk_num_elems (size_t _Total_num_elems, size_t _Elem_size)
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)
template<typename _T >
_T	_Greatest_common_divisor (_T _M, _T _N)
template<typename _T >
_T	_Least_common_multiple (_T _M, _T _N)
template<typename InputIterator , typename _Value_type >
_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)
template<typename _InputIterator , typename _Distance >
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)
template<typename _OutputIterator , typename _Distance >
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)
template<typename OutputIterator , typename _Value_type >
_Event	_Copy_impl (_In_ _Buffer *_Src, size_t _Src_offset, size_t _Num_elems, OutputIterator _DestIter, size_t _Preferred_copy_chunk_num_elems=0)
_AMPIMP _Event __cdecl	_Copy_impl (_In_ _Buffer *_Src, _View_shape_ptr _Src_shape, _Out_ _Buffer *_Dst, _View_shape_ptr _Dst_shape)
_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)
template<typename _InputInterator , typename _OutputIterator >
_Event	_Copy_impl_iter (_InputInterator _SrcFirst, _InputInterator _SrcLast, _OutputIterator _DstFirst)
template<typename InputIterator , typename _Value_type >
_Event	_Copy_impl (InputIterator _SrcFirst, _View_shape_ptr _Src_shape, _Inout_ _Buffer *_Dst, _View_shape_ptr _Dst_shape)
template<typename OutputIterator , typename _Value_type >
_Event	_Copy_impl (_In_ _Buffer *_Src, _View_shape_ptr _Src_shape, OutputIterator _DestIter, _View_shape_ptr _Dst_shape)
template<typename _InputInterator , typename _OutputIterator >
_Event	_Copy_impl_iter (_InputInterator _SrcIter, _View_shape_ptr _Src_shape, _OutputIterator _DstIter, _View_shape_ptr _Dst_shape)
_Ret_ _View_shape *	_Get_buffer_view_shape (const _Buffer_descriptor &_Descriptor)
bool	_Is_cpu_accelerator (const accelerator &_Accl)
_AMPIMP _Ret_ _Amp_runtime_trace *__cdecl	_Get_amp_trace ()
template<class _T >
void	_InternalDeleteHelper (_T *_PObject)
void _CRTIMP __cdecl	_UnderlyingYield ()
	Default method for yielding during a spin wait More...
unsigned int _CRTIMP __cdecl	_GetConcurrency ()
	Returns the hardware concurrency available to the Concurrency Runtime, taking into account process affinity, or any restrictions in place because of the set_task_execution_resources method. More...
_CRTIMP void __cdecl	_SetUnobservedExceptionHandler (_UnobservedExceptionHandler)
_CRTIMP void __cdecl	_ReportUnobservedException ()
_CRTIMP const _CONCRT_TRACE_INFO *	_GetConcRTTraceInfo ()
	Retrieves a pointer to the internal trace flags and level information for the Concurrency runtime ETW provider. More...
void	_RegisterConcRTEventTracing ()
	Register ConcRT as an ETW Event Provider. More...
void	_UnregisterConcRTEventTracing ()
	Unregister ConcRT as an ETW Event Provider. More...
template<typename _C , typename _Ty , typename _U >
bool	operator== (const _Concurrent_queue_iterator< _C, _Ty > &_I, const _Concurrent_queue_iterator< _C, _U > &_J)
template<typename _C , typename _Ty , typename _U >
bool	operator!= (const _Concurrent_queue_iterator< _C, _Ty > &_I, const _Concurrent_queue_iterator< _C, _U > &_J)
template<typename _Container , typename _Ty >
_Vector_iterator< _Container, _Ty >	operator+ (ptrdiff_t _Offset, const _Vector_iterator< _Container, _Ty > &_Vec)
template<typename _Container , typename _Ty , typename _U >
bool	operator== (const _Vector_iterator< _Container, _Ty > &_I, const _Vector_iterator< _Container, _U > &_J)
template<typename _Container , typename _Ty , typename _U >
bool	operator!= (const _Vector_iterator< _Container, _Ty > &_I, const _Vector_iterator< _Container, _U > &_J)
template<typename _Container , typename _Ty , typename _U >
bool	operator< (const _Vector_iterator< _Container, _Ty > &_I, const _Vector_iterator< _Container, _U > &_J)
template<typename _Container , typename _Ty , typename _U >
bool	operator> (const _Vector_iterator< _Container, _Ty > &_I, const _Vector_iterator< _Container, _U > &_J)
template<typename _Container , typename _Ty , typename _U >
bool	operator>= (const _Vector_iterator< _Container, _Ty > &_I, const _Vector_iterator< _Container, _U > &_J)
template<typename _Container , typename _Ty , typename _U >
bool	operator<= (const _Vector_iterator< _Container, _Ty > &_I, const _Vector_iterator< _Container, _U > &_J)
template<typename _Container , typename _Ty , typename _U >
ptrdiff_t	operator- (const _Vector_iterator< _Container, _Ty > &_I, const _Vector_iterator< _Container, _U > &_J)
unsigned char	_Reverse_byte (unsigned char _Original_byte)
unsigned char	_Get_msb (size_t _Mask)
template<class _Mylist >
_Solist_const_iterator< _Mylist >::_Unchecked_type	_Unchecked (_Solist_const_iterator< _Mylist > _Iterator)
template<class _Mylist >
_Solist_const_iterator< _Mylist > &	_Rechecked (_Solist_const_iterator< _Mylist > &_Iterator, typename _Solist_const_iterator< _Mylist >::_Unchecked_type _Right)
template<class _Mylist >
_Solist_iterator< _Mylist >::_Unchecked_type	_Unchecked (_Solist_iterator< _Mylist > _Iterator)
template<class _Mylist >
_Solist_iterator< _Mylist > &	_Rechecked (_Solist_iterator< _Mylist > &_Iterator, typename _Solist_iterator< _Mylist >::_Unchecked_type _Right)
_CRTIMP2 size_t __cdecl	_GetCombinableSize ()
template<typename _T >
_T	atomic_compare_exchange (std::atomic< _T > &_Target, _T _Exchange, _T _Comparand)
template<typename _T >
_T	atomic_exchange (std::atomic< _T > &_Target, _T _Value)
template<typename _T >
_T	atomic_increment (std::atomic< _T > &_Target)
template<typename _T >
_T	atomic_decrement (std::atomic< _T > &_Target)
template<typename _T >
_T	atomic_add (std::atomic< _T > &_Target, _T value)
template<typename _T >
_TypeSelectorAsyncTask	_AsyncOperationKindSelector (task< _T >)
_TypeSelectorNoAsync	_AsyncOperationKindSelector (...)
template<typename _Function >
auto	_IsCallable (_Function _Func, int) -> decltype(_Func(), std::true_type())
template<typename _Function >
std::false_type	_IsCallable (_Function,...)
template<typename _Type >
task< _Type >	_To_task (_Type t)
task< void >	_To_task ()
template<typename _Function , typename _Type >
auto	_ReturnTypeHelper (_Type t, _Function _Func, int, int) -> decltype(_Func(_To_task(t)))
template<typename _Function , typename _Type >
auto	_ReturnTypeHelper (_Type t, _Function _Func, int,...) -> decltype(_Func(t))
template<typename _Function , typename _Type >
auto	_ReturnTypeHelper (_Type t, _Function _Func,...) -> _BadContinuationParamType
template<typename _Function , typename _Type >
auto	_IsTaskHelper (_Type t, _Function _Func, int, int) -> decltype(_Func(_To_task(t)), std::true_type())
template<typename _Function , typename _Type >
std::false_type	_IsTaskHelper (_Type t, _Function _Func, int,...)
template<typename _Function >
auto	_VoidReturnTypeHelper (_Function _Func, int, int) -> decltype(_Func(_To_task()))
template<typename _Function >
auto	_VoidReturnTypeHelper (_Function _Func, int,...) -> decltype(_Func())
template<typename _Function >
auto	_VoidIsTaskHelper (_Function _Func, int, int) -> decltype(_Func(_To_task()), std::true_type())
template<typename _Function >
std::false_type	_VoidIsTaskHelper (_Function _Func, int,...)
static void	_ScheduleFuncWithAutoInline (const std::function< void()> &_Func, _TaskInliningMode_t _InliningMode)
	Schedule a functor with automatic inlining. Note that this is "fire and forget" scheduling, which cannot be waited on or canceled after scheduling. This schedule method will perform automatic inlining base on . More...
_Internal_task_options &	_get_internal_task_options (task_options &options)
const _Internal_task_options &	_get_internal_task_options (const task_options &options)
void	_LogCancelTask (_Task_impl_base *)
std::function< _Unit_type(void)>	_MakeVoidToUnitFunc (const std::function< void(void)> &_Func)
template<typename _Type >
std::function< _Type(_Unit_type)>	_MakeUnitToTFunc (const std::function< _Type(void)> &_Func)
template<typename _Type >
std::function< _Unit_type(_Type)>	_MakeTToUnitFunc (const std::function< void(_Type)> &_Func)
std::function< _Unit_type(_Unit_type)>	_MakeUnitToUnitFunc (const std::function< void(void)> &_Func)
template<typename _ReturnType , typename _Ty >
auto	_IsValidTaskCtor (_Ty _Param, int, int, int, int) -> decltype(_Param(), std::true_type())
template<typename _ReturnType , typename _Ty >
auto	_IsValidTaskCtor (_Ty _Param, int, int,...) -> decltype(_Param.set(stdx::declval< _ReturnType >()), std::true_type())
template<typename _ReturnType , typename _Ty >
auto	_IsValidTaskCtor (_Ty _Param, int,...) -> decltype(_Param.set(), std::true_type())
template<typename _ReturnType , typename _Ty >
std::false_type	_IsValidTaskCtor (_Ty _Param,...)
template<typename _ReturnType , typename _Ty >
void	_ValidateTaskConstructorArgs (_Ty _Param)
template<typename _Ty >
_Ty	_GetUnwrappedType (task< _Ty >)
	The following type traits are used for the create_task function. More...
template<typename _Ty >
auto	_GetUnwrappedReturnType (_Ty _Arg, int) -> decltype(_GetUnwrappedType(_Arg))
template<typename _Ty >
_Ty	_GetUnwrappedReturnType (_Ty,...)
template<typename _Ty >
_Ty	_GetTaskType (task_completion_event< _Ty >, std::false_type)
	_GetTaskType functions will retrieve task type T in task[T](Arg), for given constructor argument Arg and its property "callable". It will automatically unwrap argument to get the final return type if necessary. More...
template<typename _Ty >
auto	_GetTaskType (_Ty _NonFunc, std::false_type) -> decltype(_GetUnwrappedType(_NonFunc))
template<typename _Ty >
auto	_GetTaskType (_Ty _Func, std::true_type) -> decltype(_GetUnwrappedReturnType(_Func(), 0))
void	_GetTaskType (std::function< void()>, std::true_type)
template<typename _Ty >
auto	_FilterValidTaskType (_Ty _Param, int) -> decltype(_GetTaskType(_Param, _IsCallable(_Param, 0)))
template<typename _Ty >
_BadArgType	_FilterValidTaskType (_Ty _Param,...)
template<class _Tuple_type >
_Tuple_type	_Create_uninitialized_tuple () __GPU
template<typename _Array_type >
const _Buffer_descriptor &	_Get_buffer_descriptor (const _Array_type &_Array) __GPU
template<typename _Array_type >
_Ret_ _Ubiquitous_buffer *	_Get_buffer (const _Array_type &_Array) __CPU_ONLY
template<typename _Array_type >
_Event	_Get_access_async (const _Array_type &_Array, _Access_mode _Mode, _Buffer_ptr &_Buf_ptr) __CPU_ONLY
template<typename _Array_type >
void *	_Get_datasource_identity (const _Array_type &_Array)
template<typename _Texture_type >
const _Texture_descriptor &	_Get_texture_descriptor (const _Texture_type &_Tex) __GPU
template<typename _Texture_type >
_Ret_ _Texture *	_Get_texture (const _Texture_type &_Tex) __CPU_ONLY
template<int _Rank, template< int > class _T1, template< int > class _T2>
static void	_Is_valid_section (const _T2< _Rank > &_Base_extent, const _T1< _Rank > &_Section_origin, const _T2< _Rank > &_Section_extent) __CPU_ONLY
template<int _Rank, template< int > class _T1>
static void	_Is_valid_projection (int _I, const _T1< _Rank > &_Base_extent) __CPU_ONLY
template<int _Rank, template< int > class _T>
static void	_Is_positive (const _T< _Rank > &_Tuple) __CPU_ONLY
template<int _Rank, template< int > class _T>
static void	_Is_nonnegative (const _T< _Rank > &_Tuple) __CPU_ONLY
template<int _Rank, template< int > class _T>
static void	_Is_valid_extent (const _T< _Rank > &_Tuple) __CPU_ONLY
template<int _Rank>
unsigned int	_Get_max_mipmap_levels (const extent< _Rank > &_Extent)
void	_Are_valid_mipmap_parameters (unsigned int _Most_detailed_mipmap_level, unsigned int _Mipmap_levels=0)
template<int _Rank>
extent< _Rank >	_Get_extent_at_level_unsafe (const extent< _Rank > &_Base_extent, unsigned int _Level) __GPU
template<int _Rank>
extent< _Rank >	_Get_extent_at_level (const extent< _Rank > &_Base_extent, unsigned int _Level)
void	_Is_valid_mipmap_range (unsigned int _Src_view_mipmap_levels, unsigned int _Dst_most_detailed_level, unsigned int _Dst_view_mipmap_levels)
template<int _Rank, typename _Kernel_type >
void	_Parallel_for_each (_In_ _Host_Scheduling_info *_Sch_info, extent< _Rank > _Compute_domain, const _Kernel_type &_F)
template<int _Dim0, int _Dim1, int _Dim2, typename _Kernel_type >
void	_Parallel_for_each (_In_ _Host_Scheduling_info *_Sch_info, tiled_extent< _Dim0, _Dim1, _Dim2 > _Compute_domain, const _Kernel_type &_F)
template<int _Dim0, int _Dim1, typename _Kernel_type >
void	_Parallel_for_each (_In_ _Host_Scheduling_info *_Sch_info, tiled_extent< _Dim0, _Dim1 > _Compute_domain, const _Kernel_type &_F)
template<int _Dim0, typename _Kernel_type >
void	_Parallel_for_each (_In_ _Host_Scheduling_info *_Sch_info, tiled_extent< _Dim0 > _Compute_domain, const _Kernel_type &_F)
void	__dp_no_source_func () __GPU_ONLY
template<>
extent< 1 >	_Get_extent_at_level_unsafe< 1 > (const extent< 1 > &_Base_extent, unsigned int _Level) __GPU
template<>
extent< 2 >	_Get_extent_at_level_unsafe< 2 > (const extent< 2 > &_Base_extent, unsigned int _Level) __GPU
template<>
extent< 3 >	_Get_extent_at_level_unsafe< 3 > (const extent< 3 > &_Base_extent, unsigned int _Level) __GPU

Variables
const size_t	ERROR_MSG_BUFFER_SIZE = 1024
_CRTIMP2 const unsigned char	_Byte_reverse_table []
static const int	LOOP_UNROLL_THRESHOLD = 4

Typedef Documentation

typedef std::unordered_set<accelerator_view, _Accelerator_view_hasher> Concurrency::details::_Accelerator_view_unordered_set

typedef struct Concurrency::details::_Buffer_descriptor Concurrency::details::_Buffer_descriptor

typedef _Concurrent_queue_base_v4 Concurrency::details::_Concurrent_queue_base

typedef _Concurrent_vector_base_v4 Concurrency::details::_Concurrent_vector_base

typedef size_t Concurrency::details::_Map_key

typedef struct Concurrency::details::_Sampler_descriptor Concurrency::details::_Sampler_descriptor

typedef _SpinWait Concurrency::details::_SpinWaitBackoffNone

typedef _SpinWait<0> Concurrency::details::_SpinWaitNoYield

typedef _Map_key Concurrency::details::_Split_order_key

typedef ::Concurrency::details::_Task_generator_oversubscriber Concurrency::details::_Task_generator_oversubscriber_t

typedef std::shared_ptr<_Task_impl_base> Concurrency::details::_Task_ptr_base

typedef ::Concurrency::details::_TaskCollectionImpl Concurrency::details::_TaskCollection_t

typedef ::Concurrency::details::_TaskInliningMode Concurrency::details::_TaskInliningMode_t

typedef enum _Short_vector_base_type_id Concurrency::details::_Texture_base_type_id

typedef struct Concurrency::details::_Texture_descriptor Concurrency::details::_Texture_descriptor

typedef size_t Concurrency::details::_Ticket

typedef unsigned char Concurrency::details::_Unit_type

typedef void(__cdecl * Concurrency::details::_UnobservedExceptionHandler) (void)

typedef _TaskCollection_t::_TaskProcHandle_t Concurrency::details::_UnrealizedChore_t

typedef _Buffer_descriptor* Concurrency::details::_View_key

typedef std::atomic<long> Concurrency::details::atomic_long

Atomics

typedef std::atomic<size_t> Concurrency::details::atomic_size_t

typedef _Concurrent_queue_iterator_base_v4 Concurrency::details::concurrent_queue_iterator_base

Enumeration Type Documentation

enum Concurrency::details::_DPC_kernel_func_kind

Enumerator
NON_ALIASED_SHADER
ALIASED_SHADER
NUM_SHADER_VERSIONS

    {
        NON_ALIASED_SHADER  = 0, // slot 0
        ALIASED_SHADER      = 1,  // slot 1
        NUM_SHADER_VERSIONS = 2
    };

enum Concurrency::details::_eInitializeState

Enumerator
_do_not_initialize

                           {
        _do_not_initialize 
    };

enum Concurrency::details::_op_kind

Enumerator
opEq
opNeq
opNot
opAssign
opAddEq
opSubEq
opMulEq
opDivEq
opModEq
opAdd
opSub
opMul
opDiv
opMod

    {
        // cmp op
        opEq,      // a == b
        opNeq,     // a != b
        // not op
        opNot,     // !a
        // compound assignment
        opAssign,  // a = b
        opAddEq,   // a += b;
        opSubEq,   // a -= b;
        opMulEq,   // a *= b
        opDivEq,   // a /= b
        opModEq,   // a %= b
        // arithmetic ops
        opAdd,     // c = a + b
        opSub,     // c = a - b
        opMul,     // c = a * b
        opDiv,     // c = a / b
        opMod,     // c = a % b
    };

enum Concurrency::details::_Short_vector_base_type_id : unsigned int

Enumerator
_Uint_type
_Int_type
_Float_type
_Unorm_type
_Norm_type
_Double_type
_Invalid_type

                                    : unsigned int
    {
        _Uint_type = 0,
        _Int_type = 1,
        _Float_type = 2,
        _Unorm_type = 3,
        _Norm_type = 4,
        _Double_type = 5,
        _Invalid_type = 0xFFFFFFFF
    };

enum Concurrency::details::_TaskCollectionStatus

Enumerator
_NotComplete
_Completed
_Canceled

    {
        _NotComplete,
        _Completed,
        _Canceled
    };

enum Concurrency::details::_TaskInliningMode

The enum defines inlining scheduling policy for ppltasks. Scheduling a chore or a functor with _TaskInliningMode will give scheduler a hint on whether apply inline execution or not.

As an optimization, we assigned an integer number to each option in the enum, which efectively stands for the maximal inlining depth (threshold) for current chore, and the scheduler will compare this threshold with current context's inlining depth to make inline decision. If the current context's inlining depth greater than this threshold, the chore will be scheduled on a new context, otherwise the chore will be scheduled inline. Minimal threshold 0 means do not inline; maximal threshold -1 (0xFFFFFFFF....) means always inline. 16 is a good default inlining threshold we figured out from experiment.

Enumerator
_NoInline
_DefaultAutoInline
_ForceInline

    {
        // Disable inline scheduling
        _NoInline = 0,
        // Let runtime decide whether to do inline scheduling or not
        _DefaultAutoInline = 16,
        // Always do inline scheduling
        _ForceInline = -1,
    };

Function Documentation

void Concurrency::details::__dp_no_source_func ( )

inline

        {
            __dp_no_source_stub();
        }

template<typename _InputIterator , typename _Distance >

std::enable_if<std::is_base_of<std::input_iterator_tag, typename std::iterator_traits<_InputIterator>::iterator_category>::value>::type Concurrency::details::_Advance_output_iterator	(	_InputIterator &	_Iter,
		_Distance	_N
	)

    {
        std::advance(_Iter, _N);
    }

template<typename _OutputIterator , typename _Distance >

std::enable_if<!std::is_base_of<std::input_iterator_tag, typename std::iterator_traits<_OutputIterator>::iterator_category>::value>::type Concurrency::details::_Advance_output_iterator	(	_OutputIterator &	_Iter,
		size_t	_N
	)

    {
        for (size_t i = 0; i < _N; ++i)
        {
            _Iter++;
        }
    }

void Concurrency::details::_Are_valid_mipmap_parameters ( unsigned int  _Most_detailed_mipmap_level, unsigned int  _Mipmap_levels = 0  )

inline

    {
        if (_Most_detailed_mipmap_level >= 32)
        {
            throw runtime_exception("The most detailed mipmap level cannot be greater than or equal to 32", E_INVALIDARG);
        }

        if (_Mipmap_levels > 32)
        {
            throw runtime_exception("The number of mipmap levels cannot be greater than 32", E_INVALIDARG);
        }
    }

template<typename _T >

_TypeSelectorAsyncTask Concurrency::details::_AsyncOperationKindSelector

(

task< _T >

)

_TypeSelectorNoAsync Concurrency::details::_AsyncOperationKindSelector

(

...

)

template<int _Old_element_size, int _New_element_size>

int Concurrency::details::_Calculate_reinterpreted_size

(

int

_Old_size

)

{
    int _Total_size = _Old_element_size * _Old_size;
    int _New_size = (_Total_size + _New_element_size - 1)/ _New_element_size;

    return _New_size; 
}

_AMPIMP _Event __cdecl Concurrency::details::_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
	)

template<typename _Value_type , int _Rank>

_Event Concurrency::details::_Copy_async_impl	(	const array< _Value_type, _Rank > &	_Src,
		array< _Value_type, _Rank > &	_Dest
	)

{
    if (_Src.extent.size() > _Dest.extent.size())
    {
        throw runtime_exception("Invalid _Src argument. _Src size exceeds total size of the _Dest.", E_INVALIDARG);
    }

    // We can obliterate the exisiting content of dest if it is about to be totally overwritten
    _Access_mode _Dest_access_mode = (_Src.extent.size() == _Dest.extent.size()) ? _Write_access : _Read_write_access;

    _Buffer_ptr _PBufSrc, _PBufDest;
    _Event _Ev = _Get_access_async(_Src, _Read_access, _PBufSrc);
    _Ev = _Ev._Add_event(_Get_access_async(_Dest, _Dest_access_mode, _PBufDest));
    size_t _NumElemsToCopy = (_Src.extent.size() * sizeof(_Value_type)) / _PBufSrc->_Get_elem_size();
    return _Ev._Add_continuation(std::function<_Event()>([_PBufSrc, _PBufDest, _NumElemsToCopy]() mutable -> _Event {
        return details::_Copy_impl(_PBufSrc, 0, _PBufDest, 0, _NumElemsToCopy);
    }));
}

template<typename InputIterator , typename _Value_type , int _Rank>

_Event Concurrency::details::_Copy_async_impl	(	InputIterator	_SrcFirst,
		InputIterator	_SrcLast,
		array< _Value_type, _Rank > &	_Dest
	)

{    
    size_t _NumElemsToCopy = std::distance(_SrcFirst, _SrcLast);
    // We can obliterate the exisiting content of dest if it is about to be totally overwritten
    _Access_mode _Dest_access_mode = (_NumElemsToCopy == _Dest.extent.size()) ? _Write_access : _Read_write_access;
    _Buffer_ptr _PDestBuf;
    _Event _Ev = _Get_access_async(_Dest, _Dest_access_mode, _PDestBuf);

    return _Ev._Add_continuation(std::function<_Event()>([_SrcFirst, _SrcLast, _PDestBuf, _NumElemsToCopy]() mutable -> _Event {
        return details::_Copy_impl<InputIterator, _Value_type>(_SrcFirst, _SrcLast, _NumElemsToCopy, _PDestBuf, 0);
    }));
}

template<typename OutputIterator , typename _Value_type , int _Rank>

_Event Concurrency::details::_Copy_async_impl	(	const array< _Value_type, _Rank > &	_Src,
		OutputIterator	_DestIter
	)

{
    _Buffer_ptr _PSrcBuf;
    _Event _Ev = _Get_access_async(_Src, _Read_access, _PSrcBuf);
    size_t _NumElemsToCopy = (_Src.extent.size() * sizeof(_Value_type)) / _PSrcBuf->_Get_elem_size();
    return _Ev._Add_continuation(std::function<_Event()>([_PSrcBuf, _NumElemsToCopy, _DestIter]() mutable -> _Event {
        return details::_Copy_impl<OutputIterator, _Value_type>(_PSrcBuf, 0, _NumElemsToCopy, _DestIter);
    }));
}

template<typename _Value_type , int _Rank>

_Event Concurrency::details::_Copy_async_impl	(	const array< _Value_type, _Rank > &	_Src,
		const array_view< _Value_type, _Rank > &	_Dest
	)

{
    const _Buffer_descriptor &_SrcBufDesc = _Get_buffer_descriptor(_Src);
    const _Buffer_descriptor &_DestBufDesc = _Get_buffer_descriptor(_Dest);
    if (_SrcBufDesc._Get_buffer_ptr() == _DestBufDesc._Get_buffer_ptr()) {
        throw runtime_exception("Cannot copy between overlapping regions of the same buffer.", E_INVALIDARG);
    }

    _Buffer_ptr _PSrcBuf, _PDestBuf;
    _Event _Ev = _Get_access_async(_Src, _Read_access, _PSrcBuf);

    // The source accelerator_view is driven by array's master location,
    // therefore we can pass nullptr to avoid unnecessary computation
    auto _AccelInfo = _Get_src_dest_accelerator_view(nullptr, &_DestBufDesc);

    _Ev = _Ev._Add_event(_Get_access_async(_DestBufDesc._Get_view_key(), _AccelInfo.second, _Write_access, _PDestBuf));
    _View_shape_ptr _PSrcShape = _Get_buffer_view_shape(_SrcBufDesc);
    _View_shape_ptr _PDestShape = _Get_buffer_view_shape(_DestBufDesc);
    return _Ev._Add_continuation(std::function<_Event()>([_PSrcBuf, _PSrcShape, _PDestBuf, _PDestShape]() mutable -> _Event {
        return details::_Copy_impl(_PSrcBuf, _PSrcShape, _PDestBuf, _PDestShape);
    }));
}

template<typename _Value_type , int _Rank>

_Event Concurrency::details::_Copy_async_impl	(	const array_view< const _Value_type, _Rank > &	_Src,
		array< _Value_type, _Rank > &	_Dest
	)

{
    const _Buffer_descriptor &_SrcBufDesc = _Get_buffer_descriptor(_Src);
    const _Buffer_descriptor &_DestBufDesc = _Get_buffer_descriptor(_Dest);
    if (_SrcBufDesc._Get_buffer_ptr() == _DestBufDesc._Get_buffer_ptr()) {
        throw runtime_exception("Cannot copy between overlapping regions of the same buffer.", E_INVALIDARG);
    }

    auto _AccelInfo = _Get_src_dest_accelerator_view(&_SrcBufDesc, &_DestBufDesc);

    _Buffer_ptr _PSrcBuf, _PDestBuf;
    _Event _Ev = _Get_access_async(_SrcBufDesc._Get_view_key(), _AccelInfo.first, _Read_access, _PSrcBuf);
    _Ev = _Ev._Add_event(_Get_access_async(_Dest, _Write_access, _PDestBuf));
    _View_shape_ptr _PSrcShape = _Get_buffer_view_shape(_SrcBufDesc);
    _View_shape_ptr _PDestShape = _Get_buffer_view_shape(_DestBufDesc);
    return _Ev._Add_continuation(std::function<_Event()>([_PSrcBuf, _PSrcShape, _PDestBuf, _PDestShape]() mutable -> _Event {
        return details::_Copy_impl(_PSrcBuf, _PSrcShape, _PDestBuf, _PDestShape);
    }));
}

template<typename _Value_type , int _Rank>

_Event Concurrency::details::_Copy_async_impl	(	const array_view< const _Value_type, _Rank > &	_Src,
		const array_view< _Value_type, _Rank > &	_Dest
	)

{
    const _Buffer_descriptor &_SrcBufDesc = _Get_buffer_descriptor(_Src);
    const _Buffer_descriptor &_DestBufDesc = _Get_buffer_descriptor(_Dest);
    _View_shape_ptr _PSrcShape = _Get_buffer_view_shape(_SrcBufDesc);
    _View_shape_ptr _PDestShape = _Get_buffer_view_shape(_DestBufDesc);
    if ((_SrcBufDesc._Get_buffer_ptr() == _DestBufDesc._Get_buffer_ptr()) && _PSrcShape->_Overlaps(_PDestShape)) {
        throw runtime_exception("Cannot copy between overlapping regions of the same buffer.", E_INVALIDARG);
    }
    
    auto _AccelInfo = _Get_src_dest_accelerator_view(&_SrcBufDesc, &_DestBufDesc);

    _Buffer_ptr _PSrcBuf, _PDestBuf;
    _Event _Ev = _Get_access_async(_SrcBufDesc._Get_view_key(), _AccelInfo.first, _Read_access, _PSrcBuf);
    _Ev = _Ev._Add_event(_Get_access_async(_DestBufDesc._Get_view_key(), _AccelInfo.second, _Write_access, _PDestBuf));
    return _Ev._Add_continuation(std::function<_Event()>([_PSrcBuf, _PSrcShape, _PDestBuf, _PDestShape]() mutable -> _Event {
        return details::_Copy_impl(_PSrcBuf, _PSrcShape, _PDestBuf, _PDestShape);
    }));
}

template<typename InputIterator , typename _Value_type , int _Rank>

_Event Concurrency::details::_Copy_async_impl	(	InputIterator	_SrcFirst,
		InputIterator	_SrcLast,
		const array_view< _Value_type, _Rank > &	_Dest
	)

{    
    static_assert(!std::is_const<_Value_type>::value, "Cannot copy to array_view<const _Value_type, _Rank>.");
   
    size_t _Src_size = std::distance(_SrcFirst, _SrcLast);

    // Source cannot be greater than destination
    if (_Src_size > _Dest.extent.size())
    {
        throw runtime_exception("Number of elements in range between [_SrcFirst, _SrcLast) exceeds total size of the _Dest.", E_INVALIDARG);
    }
    
#pragma warning( push )
#pragma warning( disable : 4127 ) // Disable warning about constant conditional expression
    // Higher ranks need to have as many elements as in _Dest array_view
    if ((_Rank > 1) && (_Src_size != _Dest.extent.size()))
    {
        throw runtime_exception("For _Rank > 1 the number of elements in range between [_SrcFirst, _SrcLast) has to be equal to total size of the _Dest.", E_INVALIDARG);
    }
#pragma warning( pop )

    // We can obliterate the exisiting content of dest if it is about to be totally overwritten
    _Access_mode _Dest_access_mode = (_Src_size == _Dest.extent.size()) ? _Write_access : _Read_write_access;

    // Get read-write access for array_view on cpu_accelerator and take underlying pointer to data
    const _Buffer_descriptor &_DestBufDesc = _Get_buffer_descriptor(_Dest);

    auto _AccelInfo = _Get_src_dest_accelerator_view(nullptr, &_DestBufDesc);

    _Buffer_ptr _PDestBuf;
    _Event _Ev = _Get_access_async(_DestBufDesc._Get_view_key(), _AccelInfo.second, _Dest_access_mode, _PDestBuf);

    _View_shape_ptr _Dst_shape = _Get_buffer_view_shape(_DestBufDesc);

    // If the _Dst shape is linear then perform a linear copy
    unsigned int _Dst_linear_offset, _Dst_linear_size;
    if (_Dst_shape->_Is_view_linear(_Dst_linear_offset, _Dst_linear_size))
    {
        _Ev = _Ev._Add_continuation(std::function<_Event()>([_PDestBuf, _SrcFirst, _SrcLast, _Src_size, _Dst_linear_offset]() mutable -> _Event {
            return details::_Copy_impl<InputIterator, _Value_type>(_SrcFirst, _SrcLast, _Src_size, _PDestBuf, _Dst_linear_offset);
        }));
    }
    else
    {
        _View_shape_ptr _Reinterpreted_dst_shape = _Create_reinterpreted_shape(_Dst_shape, _PDestBuf->_Get_elem_size(), sizeof(_Value_type));

        // Source has as many elements as in destination, reshape source to match destination shape
        std::vector<unsigned int> _Src_offset(_Reinterpreted_dst_shape->_Get_rank(), 0);
        _View_shape_ptr _Src_shape = details::_View_shape::_Create_view_shape(_Reinterpreted_dst_shape->_Get_rank(), 0 /* linear offset*/,
                                                                              _Reinterpreted_dst_shape->_Get_view_extent(), _Src_offset.data(),
                                                                              _Reinterpreted_dst_shape->_Get_view_extent());

        _Ev = _Ev._Add_continuation(std::function<_Event()>([_PDestBuf, _SrcFirst, _Src_shape, _Dst_shape]() mutable -> _Event {
            return details::_Copy_impl<InputIterator, _Value_type>(_SrcFirst, _Src_shape, _PDestBuf, _Dst_shape);
        }));
    }

    return _Ev;
}

template<typename OutputIterator , typename _Value_type , int _Rank>

_Event Concurrency::details::_Copy_async_impl	(	const array_view< _Value_type, _Rank > &	_Src,
		OutputIterator	_DestIter
	)

{
    // Caller is responsible for passing valid _DestIter

    // Get read access for array_view on cpu_accelerator and take underlying pointer to data
    const _Buffer_descriptor &_SrcBufDesc = _Get_buffer_descriptor(_Src);

    auto _AccelInfo = _Get_src_dest_accelerator_view(&_SrcBufDesc, nullptr);

    _Buffer_ptr _PSrcBuf;
    _Event _Ev = _Get_access_async(_SrcBufDesc._Get_view_key(), _AccelInfo.first, _Read_access, _PSrcBuf);

    // Get source shape
    _View_shape_ptr _Src_shape = _Get_buffer_view_shape(_SrcBufDesc);

    // If the _Src_shape is linear then perform a linear copy
    unsigned int _Src_linear_offset, _Src_linear_size;
    if (_Src_shape->_Is_view_linear(_Src_linear_offset, _Src_linear_size))
    {
        _Ev = _Ev._Add_continuation(std::function<_Event()>([_PSrcBuf, _Src_linear_offset, _Src_linear_size, _DestIter]() mutable -> _Event {
            return details::_Copy_impl<OutputIterator, _Value_type>(_PSrcBuf, _Src_linear_offset, _Src_linear_size, _DestIter);
        }));
    }
    else
    {
        _View_shape_ptr _Reinterpreted_src_shape = _Create_reinterpreted_shape(_Src_shape, _PSrcBuf->_Get_elem_size(), sizeof(_Value_type));

        // Valid destination should have space for as many elements as in source array_view, reshape to match source view shape
        std::vector<unsigned int> _Dst_offset(_Reinterpreted_src_shape->_Get_rank(), 0);
        _View_shape_ptr _Dst_shape = details::_View_shape::_Create_view_shape(_Reinterpreted_src_shape->_Get_rank(), 0 /* linear offset*/,
                                                                              _Reinterpreted_src_shape->_Get_view_extent(), _Dst_offset.data(),
                                                                              _Reinterpreted_src_shape->_Get_view_extent());

        _Ev = _Ev._Add_continuation(std::function<_Event()>([_PSrcBuf, _Src_shape, _DestIter, _Dst_shape]() mutable -> _Event {
            return details::_Copy_impl<OutputIterator, _Value_type>(_PSrcBuf, _Src_shape, _DestIter, _Dst_shape);
        }));
    }

    return _Ev;
}

template<typename _Input_iterator , typename _Value_type >

void Concurrency::details::_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  )

inline

    {
        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;
        }
    }

template<typename _Output_iterator , typename _Value_type >

void Concurrency::details::_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  )

inline

    {
        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 _Event __cdecl Concurrency::details::_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
	)

template<typename InputIterator , typename _Value_type >

_Event Concurrency::details::_Copy_impl ( InputIterator  _SrcFirst, InputIterator  _SrcLast, size_t  _NumElemsToCopy, _Out_ _Buffer *  _Dst, size_t  _Dest_offset, size_t  _Preferred_copy_chunk_num_elems = 0  )

inline

    {
        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;
        }
    }

template<typename OutputIterator , typename _Value_type >

_Event Concurrency::details::_Copy_impl ( _In_ _Buffer *  _Src, size_t  _Src_offset, size_t  _Num_elems, OutputIterator  _DestIter, size_t  _Preferred_copy_chunk_num_elems = 0  )

inline

    {
        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;
        }
    }

_AMPIMP _Event __cdecl Concurrency::details::_Copy_impl	(	_In_ _Buffer *	_Src,
		_View_shape_ptr	_Src_shape,
		_Out_ _Buffer *	_Dst,
		_View_shape_ptr	_Dst_shape
	)

template<typename InputIterator , typename _Value_type >

_Event Concurrency::details::_Copy_impl ( InputIterator  _SrcFirst, _View_shape_ptr  _Src_shape, _Inout_ _Buffer *  _Dst, _View_shape_ptr  _Dst_shape  )

inline

    {
        _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 >

_Event Concurrency::details::_Copy_impl ( _In_ _Buffer *  _Src, _View_shape_ptr  _Src_shape, OutputIterator  _DestIter, _View_shape_ptr  _Dst_shape  )

inline

    {
        _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);
            }));
        }
    }

template<typename _InputInterator , typename _OutputIterator >

_Event Concurrency::details::_Copy_impl_iter ( _InputInterator  _SrcFirst, _InputInterator  _SrcLast, _OutputIterator  _DstFirst  )

inline

    {
        std::copy(_SrcFirst, _SrcLast, _DstFirst);
        return _Event();
    }

template<typename _InputInterator , typename _OutputIterator >

_Event Concurrency::details::_Copy_impl_iter ( _InputInterator  _SrcIter, _View_shape_ptr  _Src_shape, _OutputIterator  _DstIter, _View_shape_ptr  _Dst_shape  )

inline

    {
        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();
    }

_Ret_ _View_shape* Concurrency::details::_Create_reinterpreted_shape ( const _View_shape *  _Source_shape, size_t  _Curr_elem_size, size_t  _New_elem_size  )

inline

    {
        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());
    }

template<class _Tuple_type >

_Tuple_type Concurrency::details::_Create_uninitialized_tuple

(

)

    {
        return _Tuple_type(details::_do_not_initialize);
    };

template<typename _Ty >

auto Concurrency::details::_FilterValidTaskType	(	_Ty	_Param,
		int
	)		-> decltype(_GetTaskType(_Param, _IsCallable(_Param, 0)))

template<typename _Ty >

_BadArgType Concurrency::details::_FilterValidTaskType	(	_Ty	_Param,
			...
	)

_Ret_ _Accelerator_impl * Concurrency::details::_Get_accelerator_impl_ptr ( const accelerator &  _Accl )

inline

    {
         return _Accl._M_impl;
    }

_Ret_ _Accelerator_view_impl * Concurrency::details::_Get_accelerator_view_impl_ptr ( const accelerator_view &  _Accl_view )

inline

    {
        return _Accl_view._M_impl;
    }

_Event Concurrency::details::_Get_access_async ( const _View_key  _Key, accelerator_view  _Av, _Access_mode  _Mode, _Buffer_ptr &  _Buf_ptr  )

inline

    {
        return _Key->_Get_buffer_ptr()->_Get_access_async(_Key->_Get_view_key(), _Av, _Mode, _Buf_ptr);
    }

template<typename _Array_type >

_Event Concurrency::details::_Get_access_async	(	const _Array_type &	_Array,
		_Access_mode	_Mode,
		_Buffer_ptr &	_Buf_ptr
	)

    { 
        return _Array._Get_access_async(_Mode, _Buf_ptr);
    }

_AMPIMP _Ret_ _Amp_runtime_trace* __cdecl Concurrency::details::_Get_amp_trace

(

)

template<typename _Array_type >

_Ret_ _Ubiquitous_buffer* Concurrency::details::_Get_buffer

(

const _Array_type &

_Array

)

    { 
        return _Array._Get_buffer();
    }

template<typename _Array_type >

const _Buffer_descriptor& Concurrency::details::_Get_buffer_descriptor

(

const _Array_type &

_Array

)

    { 
        return _Array._M_buffer_descriptor; 
    } 

_Ret_ _View_shape* Concurrency::details::_Get_buffer_view_shape ( const _Buffer_descriptor &  _Descriptor )

inline

    {
        return _Descriptor._Get_buffer_ptr()->_Get_view_shape(_Descriptor._Get_view_key());
    }

bool Concurrency::details::_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  )

inline

    {
        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;
    }

access_type Concurrency::details::_Get_cpu_access_type ( _Access_mode  _Cpu_access_mode )

inline

    {
        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;
    }

template<typename _Array_type >

void* Concurrency::details::_Get_datasource_identity

(

const _Array_type &

_Array

)

    {
        return _Get_buffer_descriptor(_Array)._Get_buffer_ptr()._Get_ptr();
    }

_AMPIMP _Ret_ _Accelerator_impl_ptr* __cdecl Concurrency::details::_Get_devices

(

)

template<int _Rank>

extent< _Rank > Concurrency::details::_Get_extent_at_level ( const extent< _Rank > &  _Base_extent, unsigned int  _Level  )

inline

{
    _Are_valid_mipmap_parameters(_Level);
    return _Get_extent_at_level_unsafe(_Base_extent, _Level);
}

template<int _Rank>

extent< _Rank > Concurrency::details::_Get_extent_at_level_unsafe ( const extent< _Rank > &  _Base_extent, unsigned int  _Level  )

inline

{
    static_assert(_Rank >= 3);
}

template<>

extent<1> Concurrency::details::_Get_extent_at_level_unsafe< 1 > ( const extent< 1 > &  _Base_extent, unsigned int  _Level  )

inline

{
    extent<1> _Extent_at_level(_Base_extent);

    _Extent_at_level[0] >>= _Level;
    _Extent_at_level[0] = _Extent_at_level[0] ? _Extent_at_level[0] : 1;

    return _Extent_at_level;
}

template<>

extent<2> Concurrency::details::_Get_extent_at_level_unsafe< 2 > ( const extent< 2 > &  _Base_extent, unsigned int  _Level  )

inline

{
    extent<2> _Extent_at_level(_Base_extent);

    _Extent_at_level[0] >>= _Level;
    _Extent_at_level[1] >>= _Level;
    _Extent_at_level[0] = _Extent_at_level[0] ? _Extent_at_level[0] : 1;
    _Extent_at_level[1] = _Extent_at_level[1] ? _Extent_at_level[1] : 1;

    return _Extent_at_level;
}

template<>

extent<3> Concurrency::details::_Get_extent_at_level_unsafe< 3 > ( const extent< 3 > &  _Base_extent, unsigned int  _Level  )

inline

{
    extent<3> _Extent_at_level(_Base_extent);

    _Extent_at_level[0] >>= _Level;
    _Extent_at_level[1] >>= _Level;
    _Extent_at_level[2] >>= _Level;
    _Extent_at_level[0] = _Extent_at_level[0] ? _Extent_at_level[0] : 1;
    _Extent_at_level[1] = _Extent_at_level[1] ? _Extent_at_level[1] : 1;
    _Extent_at_level[2] = _Extent_at_level[2] ? _Extent_at_level[2] : 1;

    return _Extent_at_level;
}

_Internal_task_options & Concurrency::details::_get_internal_task_options ( task_options &  options )

inline

    {
        return options._M_InternalTaskOptions;
    }

const _Internal_task_options & Concurrency::details::_get_internal_task_options ( const task_options &  options )

inline

    {
        return options._M_InternalTaskOptions;
    }

template<int _Rank>

unsigned int Concurrency::details::_Get_max_mipmap_levels ( const extent< _Rank > &  _Extent )

inline

    {
        unsigned int _Mipmap_levels = 0;

        // Find the largest dimension
        unsigned int _Max_dim = static_cast<unsigned int>(_Extent[0]);
        for(int _I=1; _I<_Rank; ++_I)
        {
            _Max_dim = static_cast<unsigned int>(_Extent[_I]) > _Max_dim ? static_cast<unsigned int>(_Extent[_I]) : _Max_dim;
        }

        // Find out how many times we can divide it by 2
        while(_Max_dim > 0)
        {
            _Mipmap_levels++;
            _Max_dim >>= 1;
        }

        return _Mipmap_levels;
    }

unsigned int Concurrency::details::_Get_mipmap_levels ( const _Texture *  _Tex )

inline

{
    _ASSERTE(_Tex);
    return _Tex->_Get_mip_levels();
}

unsigned char Concurrency::details::_Get_msb ( size_t  _Mask )

inline

{
    unsigned long _Index = 0;

#if (defined (_M_IX86) || defined (_M_ARM))
    _BitScanReverse(&_Index, _Mask);
#else  /* (defined (_M_IX86) || defined (_M_ARM)) */
    _BitScanReverse64(&_Index, _Mask);
#endif  /* (defined (_M_IX86) || defined (_M_ARM)) */

    return (unsigned char) _Index;
}

_AMPIMP size_t __cdecl Concurrency::details::_Get_num_devices

(

)

void Concurrency::details::_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  )

inline

    {
        _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;
    }

size_t Concurrency::details::_Get_preferred_copy_chunk_num_elems ( size_t  _Total_num_elems, size_t  _Elem_size  )

inline

    {
        size_t preferredChunkSize = _Get_preferred_copy_chunk_size(_Total_num_elems * _Elem_size);

        return (preferredChunkSize / _Elem_size);
    }

_AMPIMP size_t __cdecl Concurrency::details::_Get_preferred_copy_chunk_size

(

size_t

_Total_copy_size_in_bytes

)

_AMPIMP _Access_mode __cdecl Concurrency::details::_Get_recommended_buffer_host_access_mode

(

const accelerator_view &

_Av

)

_AMPIMP std::pair<accelerator_view, accelerator_view> __cdecl Concurrency::details::_Get_src_dest_accelerator_view	(	_In_opt_ const _Buffer_descriptor *	_SrcBuffDescPtr,
		_In_opt_ const _Buffer_descriptor *	_DestBuffDescPtr
	)

_Access_mode Concurrency::details::_Get_synchronize_access_mode ( access_type  cpu_access_type )

inline

    {
        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;
        }
    }

template<typename _Texture_type >

_Ret_ _Texture* Concurrency::details::_Get_texture

(

const _Texture_type &

_Tex

)

    { 
        return _Tex._Get_texture();
    }

template<typename _Texture_type >

const _Texture_descriptor& Concurrency::details::_Get_texture_descriptor

(

const _Texture_type &

_Tex

)

    { 
        return _Tex._M_texture_descriptor; 
    } 

_CRTIMP2 size_t __cdecl Concurrency::details::_GetCombinableSize

(

)

_CRTIMP const _CONCRT_TRACE_INFO* Concurrency::details::_GetConcRTTraceInfo

(

)

Retrieves a pointer to the internal trace flags and level information for the Concurrency runtime ETW provider.

unsigned int _CRTIMP __cdecl Concurrency::details::_GetConcurrency

(

)

Returns the hardware concurrency available to the Concurrency Runtime, taking into account process affinity, or any restrictions in place because of the set_task_execution_resources method.

template<typename _Ty >

_Ty Concurrency::details::_GetTaskType	(	task_completion_event< _Ty >	,
		std::false_type
	)

_GetTaskType functions will retrieve task type T in task[T](Arg), for given constructor argument Arg and its property "callable". It will automatically unwrap argument to get the final return type if necessary.

template<typename _Ty >

auto Concurrency::details::_GetTaskType	(	_Ty	_NonFunc,
		std::false_type
	)		-> decltype(_GetUnwrappedType(_NonFunc))

template<typename _Ty >

auto Concurrency::details::_GetTaskType	(	_Ty	_Func,
		std::true_type
	)		-> decltype(_GetUnwrappedReturnType(_Func(), 0))

void Concurrency::details::_GetTaskType	(	std::function< void()>	,
		std::true_type
	)

template<typename _Ty >

auto Concurrency::details::_GetUnwrappedReturnType	(	_Ty	_Arg,
		int
	)		-> decltype(_GetUnwrappedType(_Arg))

template<typename _Ty >

_Ty Concurrency::details::_GetUnwrappedReturnType	(	_Ty	,
			...
	)

template<typename _Ty >

_Ty Concurrency::details::_GetUnwrappedType

(

task< _Ty >

)

The following type traits are used for the create_task function.

template<typename _T >

_T Concurrency::details::_Greatest_common_divisor ( _T  _M, _T  _N  )

inline

    {
        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;
    }

template<class _T >

void Concurrency::details::_InternalDeleteHelper

(

_T *

_PObject

)

    {
        delete _PObject;
    }

bool Concurrency::details::_Is_cpu_accelerator ( const accelerator &  _Accl )

inline

    {
        return (_Accl.device_path == accelerator::cpu_accelerator);
    }

_AMPIMP bool __cdecl Concurrency::details::_Is_D3D_accelerator_view

(

const accelerator_view &

_Av

)

template<int _Rank, template< int > class _T>

static void Concurrency::details::_Is_nonnegative ( const _T< _Rank > &  _Tuple )

static

    {
        bool valid = true;
        for (int i = 0; i < _Rank; ++i)
        {
            if (_Tuple[i] < 0) {
                valid = false;
                break;
            }
        }

        if (!valid) {
            throw runtime_exception("Invalid - values for each dimension must be >= 0", E_INVALIDARG);
        }
    }

template<int _Rank, template< int > class _T>

static void Concurrency::details::_Is_positive ( const _T< _Rank > &  _Tuple )

static

    {
        bool valid = true;
        for (int i = 0; i < _Rank; ++i)
        {
            if (_Tuple[i] <= 0) {
                valid = false;
                break;
            }
        }

        if (!valid) {
            throw runtime_exception("Invalid - values for each dimension must be > 0", E_INVALIDARG);
        }
    }

bool Concurrency::details::_Is_valid_access_mode ( _Access_mode  _Mode )

inline

    {
        if ((_Mode != _Read_access) && 
            (_Mode != _Write_access) &&
            (_Mode != _Read_write_access))
        {
            return false;
        }

        return true;
    }

template<int _Rank, template< int > class _T>

static void Concurrency::details::_Is_valid_extent ( const _T< _Rank > &  _Tuple )

static

    {
        _Is_positive(_Tuple);

        bool totalSizeValid = true;
        unsigned long long totalSize = (unsigned long long)_Tuple[0];
#pragma warning( push )
#pragma warning( disable : 6294 ) 
        for (int i = 1; i < _Rank; ++i)
        {
            totalSize *= (unsigned long long)_Tuple[i];
            if (totalSize > UINT_MAX) {
                totalSizeValid = false;
                break;
            }
        }
#pragma warning( pop )

        if (!totalSizeValid) {
            throw runtime_exception("Invalid - extent size exceeds UINT_MAX", E_INVALIDARG);
        }
    }

void Concurrency::details::_Is_valid_mipmap_range ( unsigned int  _Src_view_mipmap_levels, unsigned int  _Dst_most_detailed_level, unsigned int  _Dst_view_mipmap_levels  )

inline

    {
        _Are_valid_mipmap_parameters(_Dst_most_detailed_level, _Dst_view_mipmap_levels);
  
        if (_Dst_view_mipmap_levels == 0 || _Src_view_mipmap_levels < _Dst_most_detailed_level + _Dst_view_mipmap_levels)
        {
            throw runtime_exception("Invalid texture mipmap range", E_INVALIDARG);
        }
    }

template<int _Rank, template< int > class _T1>

static void Concurrency::details::_Is_valid_projection ( int  _I, const _T1< _Rank > &  _Base_extent  )

static

    {
        if ((_I < 0) || (_I >= _Base_extent[0])) {
            throw runtime_exception("the specified projection index is out of bound", E_INVALIDARG);
        }
    }

template<int _Rank, template< int > class _T1, template< int > class _T2>

static void Concurrency::details::_Is_valid_section ( const _T2< _Rank > &  _Base_extent, const _T1< _Rank > &  _Section_origin, const _T2< _Rank > &  _Section_extent  )

static

    {
        _Is_nonnegative(_Section_origin);
        _Is_positive(_Section_extent);

        for (int i = 0; i < _Rank; ++i)
        {
            if ((_Section_origin[i] + _Section_extent[i]) > _Base_extent[i]) {
                throw runtime_exception("the specified section index and extent are out of bound", E_INVALIDARG);
            }
        }
    }

template<typename _Function >

auto Concurrency::details::_IsCallable	(	_Function	_Func,
		int
	)		-> decltype(_Func(), std::true_type())

{ (_Func); return std::true_type(); }

template<typename _Function >

std::false_type Concurrency::details::_IsCallable	(	_Function	,
			...
	)

{ return std::false_type(); }

template<typename _Function , typename _Type >

auto Concurrency::details::_IsTaskHelper	(	_Type	t,
		_Function	_Func,
		int	,
		int
	)		-> decltype(_Func(_To_task(t)), std::true_type())

template<typename _Function , typename _Type >

std::false_type Concurrency::details::_IsTaskHelper	(	_Type	t,
		_Function	_Func,
		int	,
			...
	)

template<typename _ReturnType , typename _Ty >

auto Concurrency::details::_IsValidTaskCtor	(	_Ty	_Param,
		int	,
		int	,
		int	,
		int
	)		-> decltype(_Param(), std::true_type())

template<typename _ReturnType , typename _Ty >

auto Concurrency::details::_IsValidTaskCtor	(	_Ty	_Param,
		int	,
		int	,
			...
	)		-> decltype(_Param.set(stdx::declval< _ReturnType >()), std::true_type())

template<typename _ReturnType , typename _Ty >

auto Concurrency::details::_IsValidTaskCtor	(	_Ty	_Param,
		int	,
			...
	)		-> decltype(_Param.set(), std::true_type())

template<typename _ReturnType , typename _Ty >

std::false_type Concurrency::details::_IsValidTaskCtor	(	_Ty	_Param,
			...
	)

template<typename _T >

_T Concurrency::details::_Least_common_multiple ( _T  _M, _T  _N  )

inline

    {
        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);
    }

void Concurrency::details::_LogCancelTask ( _Task_impl_base *  )

inline

{}

template<typename _Type >

std::function<_Unit_type(_Type)> Concurrency::details::_MakeTToUnitFunc

(

const std::function< void(_Type)> &

_Func

)

    {
        return [=](_Type t) -> _Unit_type { _Func(t); return _Unit_type(); };
    }

template<typename _Type >

std::function<_Type(_Unit_type)> Concurrency::details::_MakeUnitToTFunc

(

const std::function< _Type(void)> &

_Func

)

    {
        return [=](_Unit_type) -> _Type { return _Func(); };
    }

std::function<_Unit_type(_Unit_type)> Concurrency::details::_MakeUnitToUnitFunc ( const std::function< void(void)> &  _Func )

inline

    {
        return [=](_Unit_type) -> _Unit_type { _Func(); return _Unit_type(); };
    }

std::function<_Unit_type(void)> Concurrency::details::_MakeVoidToUnitFunc ( const std::function< void(void)> &  _Func )

inline

    {
        return [=]() -> _Unit_type { _Func(); return _Unit_type(); };
    }

template<int _Rank, typename _Kernel_type >

void Concurrency::details::_Parallel_for_each	(	_In_ _Host_Scheduling_info *	_Sch_info,
		extent< _Rank >	_Compute_domain,
		const _Kernel_type &	_F
	)

template<int _Dim0, int _Dim1, int _Dim2, typename _Kernel_type >

void Concurrency::details::_Parallel_for_each	(	_In_ _Host_Scheduling_info *	_Sch_info,
		tiled_extent< _Dim0, _Dim1, _Dim2 >	_Compute_domain,
		const _Kernel_type &	_F
	)

template<int _Dim0, int _Dim1, typename _Kernel_type >

void Concurrency::details::_Parallel_for_each	(	_In_ _Host_Scheduling_info *	_Sch_info,
		tiled_extent< _Dim0, _Dim1 >	_Compute_domain,
		const _Kernel_type &	_F
	)

template<int _Dim0, typename _Kernel_type >

void Concurrency::details::_Parallel_for_each	(	_In_ _Host_Scheduling_info *	_Sch_info,
		tiled_extent< _Dim0 >	_Compute_domain,
		const _Kernel_type &	_F
	)

template<class _Mylist >

_Solist_const_iterator<_Mylist>& Concurrency::details::_Rechecked ( _Solist_const_iterator< _Mylist > &  _Iterator, typename _Solist_const_iterator< _Mylist >::_Unchecked_type  _Right  )

inline

{
    return (_Iterator._Rechecked(_Right));
}

template<class _Mylist >

_Solist_iterator<_Mylist>& Concurrency::details::_Rechecked ( _Solist_iterator< _Mylist > &  _Iterator, typename _Solist_iterator< _Mylist >::_Unchecked_type  _Right  )

inline

{
    return (_Iterator._Rechecked(_Right));
}

_AMPIMP HRESULT __cdecl Concurrency::details::_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 void __cdecl Concurrency::details::_Register_async_event	(	const _Event &	_Ev,
		const std::shared_future< void > &	_Shared_future
	)

void Concurrency::details::_RegisterConcRTEventTracing

(

)

Register ConcRT as an ETW Event Provider.

_CRTIMP void __cdecl Concurrency::details::_ReportUnobservedException

(

)

template<typename _Function , typename _Type >

auto Concurrency::details::_ReturnTypeHelper	(	_Type	t,
		_Function	_Func,
		int	,
		int
	)		-> decltype(_Func(_To_task(t)))

template<typename _Function , typename _Type >

auto Concurrency::details::_ReturnTypeHelper	(	_Type	t,
		_Function	_Func,
		int	,
			...
	)		-> decltype(_Func(t))

template<typename _Function , typename _Type >

auto Concurrency::details::_ReturnTypeHelper	(	_Type	t,
		_Function	_Func,
			...
	)		-> _BadContinuationParamType

unsigned char Concurrency::details::_Reverse_byte ( unsigned char  _Original_byte )

inline

{
    // return ((_Original_byte * 0x80200802ULL) & 0x0884422110ULL) * 0x0101010101ULL >> 32;
    return _Byte_reverse_table[_Original_byte];
}

static void Concurrency::details::_ScheduleFuncWithAutoInline ( const std::function< void()> &  _Func, _TaskInliningMode_t  _InliningMode  )

static

Schedule a functor with automatic inlining. Note that this is "fire and forget" scheduling, which cannot be waited on or canceled after scheduling. This schedule method will perform automatic inlining base on .

Parameters

_Func	The user functor need to be scheduled.
_InliningMode	The inlining scheduling policy for current functor.

    {
        _TaskCollection_t::_RunTask(&_TaskProcThunk::_Bridge, new _TaskProcThunk(_Func), _InliningMode);
    }

_AMPIMP accelerator __cdecl Concurrency::details::_Select_default_accelerator

(

)

_AMPIMP bool __cdecl Concurrency::details::_Set_default_accelerator

(

_Accelerator_impl_ptr

_Accl

)

_CRTIMP void __cdecl Concurrency::details::_SetUnobservedExceptionHandler

(

_UnobservedExceptionHandler

)

template<typename _Type >

task<_Type> Concurrency::details::_To_task

(

_Type

t

)

task<void> Concurrency::details::_To_task

(

)

template<class _Type >

__int64 Concurrency::details::_Trace_agents_get_id

(

_Type *

_PObject

)

    {
        return reinterpret_cast<__int64>(_PObject);
    }

template<class _Mylist >

_Solist_const_iterator<_Mylist>::_Unchecked_type Concurrency::details::_Unchecked ( _Solist_const_iterator< _Mylist >  _Iterator )

inline

{
    return (_Iterator._Unchecked());
}

template<class _Mylist >

_Solist_iterator<_Mylist>::_Unchecked_type Concurrency::details::_Unchecked ( _Solist_iterator< _Mylist >  _Iterator )

inline

{
    return (_Iterator._Unchecked());
}

void _CRTIMP __cdecl Concurrency::details::_UnderlyingYield

(

)

Default method for yielding during a spin wait

void Concurrency::details::_UnregisterConcRTEventTracing

(

)

Unregister ConcRT as an ETW Event Provider.

template<typename _ReturnType , typename _Ty >

void Concurrency::details::_ValidateTaskConstructorArgs

(

_Ty

_Param

)

    {
        static_assert(std::is_same<decltype(_IsValidTaskCtor<_ReturnType>(_Param,0,0,0,0)),std::true_type>::value,
#if defined (__cplusplus_winrt)
            "incorrect argument for task constructor; can be a callable object, an asynchronous operation, or a task_completion_event"
#else  /* defined (__cplusplus_winrt) */
            "incorrect argument for task constructor; can be a callable object or a task_completion_event"
#endif  /* defined (__cplusplus_winrt) */
            );
#if defined (__cplusplus_winrt)
        static_assert(!(std::is_same<_Ty,_ReturnType>::value && details::_IsIAsyncInfo<_Ty>::_Value),
            "incorrect template argument for task; consider using the return type of the async operation");
#endif  /* defined (__cplusplus_winrt) */
    }

template<typename _Function >

auto Concurrency::details::_VoidIsTaskHelper	(	_Function	_Func,
		int	,
		int
	)		-> decltype(_Func(_To_task()), std::true_type())

template<typename _Function >

std::false_type Concurrency::details::_VoidIsTaskHelper	(	_Function	_Func,
		int	,
			...
	)

template<typename _Function >

auto Concurrency::details::_VoidReturnTypeHelper	(	_Function	_Func,
		int	,
		int
	)		-> decltype(_Func(_To_task()))

template<typename _Function >

auto Concurrency::details::_VoidReturnTypeHelper	(	_Function	_Func,
		int	,
			...
	)		-> decltype(_Func())

template<typename _T >

_T Concurrency::details::atomic_add	(	std::atomic< _T > &	_Target,
		_T	value
	)

{
    return _Target.fetch_add(value) + value;
}

template<typename _T >

_T Concurrency::details::atomic_compare_exchange	(	std::atomic< _T > &	_Target,
		_T	_Exchange,
		_T	_Comparand
	)

{
    _T _Result = _Comparand;
    _Target.compare_exchange_strong(_Result, _Exchange);
    return _Result;
}

template<typename _T >

_T Concurrency::details::atomic_decrement

(

std::atomic< _T > &

_Target

)

{
    return _Target.fetch_sub(1) - 1;
}

template<typename _T >

_T Concurrency::details::atomic_exchange	(	std::atomic< _T > &	_Target,
		_T	_Value
	)

{
    return _Target.exchange(_Value);
}

template<typename _T >

_T Concurrency::details::atomic_increment

(

std::atomic< _T > &

_Target

)

{
    return _Target.fetch_add(1) + 1;
}

template<typename _C , typename _Ty , typename _U >

bool Concurrency::details::operator!=	(	const _Concurrent_queue_iterator< _C, _Ty > &	_I,
		const _Concurrent_queue_iterator< _C, _U > &	_J
	)

    {
        return _I._My_item!=_J._My_item;
    }

template<typename _Container , typename _Ty , typename _U >

bool Concurrency::details::operator!=	(	const _Vector_iterator< _Container, _Ty > &	_I,
		const _Vector_iterator< _Container, _U > &	_J
	)

    {
        return !(_I==_J);
    }

template<typename _Container , typename _Ty >

_Vector_iterator<_Container,_Ty> Concurrency::details::operator+	(	ptrdiff_t	_Offset,
		const _Vector_iterator< _Container, _Ty > &	_Vec
	)

    {
        return _Vector_iterator<_Container,_Ty>( *_Vec._My_vector, _Vec._My_index+_Offset );
    }

template<typename _Container , typename _Ty , typename _U >

ptrdiff_t Concurrency::details::operator-	(	const _Vector_iterator< _Container, _Ty > &	_I,
		const _Vector_iterator< _Container, _U > &	_J
	)

    {
        return ptrdiff_t(_I._My_index)-ptrdiff_t(_J._My_index);
    }

template<typename _Container , typename _Ty , typename _U >

bool Concurrency::details::operator<	(	const _Vector_iterator< _Container, _Ty > &	_I,
		const _Vector_iterator< _Container, _U > &	_J
	)

    {
        return _I._My_index<_J._My_index && _I._My_vector == _J._My_vector;
    }

template<typename _Container , typename _Ty , typename _U >

bool Concurrency::details::operator<=	(	const _Vector_iterator< _Container, _Ty > &	_I,
		const _Vector_iterator< _Container, _U > &	_J
	)

    {
        return !(_J<_I);
    }

template<typename _C , typename _Ty , typename _U >

bool Concurrency::details::operator==	(	const _Concurrent_queue_iterator< _C, _Ty > &	_I,
		const _Concurrent_queue_iterator< _C, _U > &	_J
	)

    {
        return _I._My_item==_J._My_item;
    }

template<typename _Container , typename _Ty , typename _U >

bool Concurrency::details::operator==	(	const _Vector_iterator< _Container, _Ty > &	_I,
		const _Vector_iterator< _Container, _U > &	_J
	)

    {
        return _I._My_index==_J._My_index && _I._My_vector == _J._My_vector;
    }

template<typename _Container , typename _Ty , typename _U >

bool Concurrency::details::operator>	(	const _Vector_iterator< _Container, _Ty > &	_I,
		const _Vector_iterator< _Container, _U > &	_J
	)

    {
        return _J<_I;
    }

template<typename _Container , typename _Ty , typename _U >

bool Concurrency::details::operator>=	(	const _Vector_iterator< _Container, _Ty > &	_I,
		const _Vector_iterator< _Container, _U > &	_J
	)

    {
        return !(_I<_J);
    }

Variable Documentation

_CRTIMP2 const unsigned char Concurrency::details::_Byte_reverse_table[]

const size_t Concurrency::details::ERROR_MSG_BUFFER_SIZE = 1024

const int Concurrency::details::LOOP_UNROLL_THRESHOLD = 4

static