Concurrency Namespace Reference

The Concurrency namespace provides classes and functions that provide access to the Concurrency Runtime, a concurrent programming framework for C++. For more information, see Concurrency Runtime. More...

Namespaces
	details
	direct3d
	fast_math
	Functions in the fast_math namespace have lower accuracy, and support only single-precision float.
	graphics
	precise_math
	Functions in the precise_math namespace have higher accuracy, but require double-precision support, which not all accelerators do.

Classes
class	_AllocatedBufferHolder
struct	_Binary_transform_impl_helper
struct	_Binary_transform_impl_helper< std::random_access_iterator_tag, std::random_access_iterator_tag, std::random_access_iterator_tag >
class	_Continuation_func_transformer
	A helper class template that transforms a continuation lambda that either takes or returns void, or both, into a lambda that takes and returns a non-void type (details::_Unit_type is used to substitute for void). This is to minimize the special handling required for 'void'. More...
class	_Continuation_func_transformer< _InType, void >
class	_Continuation_func_transformer< void, _OutType >
class	_Continuation_func_transformer< void, void >
class	_Greedy_node
	Helper class used in multi-type greedy join blocks Ordered node is a single-target, single-source ordered propagator block More...
class	_Init_func_transformer
class	_Init_func_transformer< void >
class	_Iterator_helper
class	_Iterator_helper< _Random_iterator, std::random_access_iterator_tag >
class	_Join_node
	Defines a block allowing sources of distinct types to be joined. Join node is a single-target, multi-source ordered propagator block More...
class	_Network_link_iterator
	Const iterator for network link registry. Message blocks should use the link_registry::iterator type for iteration. More...
class	_Non_greedy_node
	Helper class used in multi-type non-greedy join blocks Ordered node is a single-target, single-source ordered propagator block More...
class	_Order_combinable
class	_Order_node_base
	Base class for Helper node used in multi-type join and choice blocks Order node is a single-target, single-source ordered propagator block The main property of an order node is that it accepts a message of _Type and outputs a message of int, with some unique assigned index number. More...
class	_Parallel_chunk_helper
class	_Parallel_chunk_helper_invoke
class	_Parallel_chunk_helper_invoke< _Random_iterator, _Index_type, _Function, false >
class	_Parallel_fixed_chunk_helper
class	_Parallel_for_each_helper
class	_Parallel_localized_chunk_helper
class	_Parallel_reduce_fixed_worker
struct	_Parallel_reduce_forward_executor_helper
class	_Parallel_transform_binary_helper
class	_Parallel_transform_unary_helper
struct	_Radix_sort_default_function
class	_Range
struct	_Reduce_functor_helper
class	_Reserving_node
	Helper class used in multi-type choice blocks Ordered node is a single-target, single-source ordered propagator block More...
class	_Source_link_iterator
	Const Iterator for referenced link manager. More...
class	_Tiled_index_base
	A _Tiled_index_base is the base class of all three kinds of tiled_index to share the common code. More...
struct	_Unary_transform_impl_helper
struct	_Unary_transform_impl_helper< std::random_access_iterator_tag, std::random_access_iterator_tag >
struct	_Unwrap
struct	_Unwrap< std::tuple< _Types...> >
	Template specialization used to unwrap the types from within a tuple. More...
class	_Worker_proxy
class	accelerator
	Class represents a accelerator abstraction for C++ AMP data-parallel devices More...
class	accelerator_view
	Class represents a virtual device abstraction on a C++ AMP data-parallel accelerator More...
class	accelerator_view_removed
	Exception thrown when an underlying DirectX call fails due to the Windows timeout detection and recovery mechanism More...
class	affinity_partitioner
	The affinity_partitioner class is similar to the static_partitioner class, but it improves cache affinity by its choice of mapping subranges to worker threads. It can improve performance significantly when a loop is re-executed over the same data set, and the data fits in cache. Note that the same affinity_partitioner object must be used with subsequent iterations of a parallel loop that is executed over a particular data set, to benefit from data locality. More...
class	agent
	A class intended to be used as a base class for all independent agents. It is used to hide state from other agents and interact using message-passing. More...
class	array
	An array is a multi-dimensional data aggregate on a accelerator_view. More...
class	array_view
	An array_view is an N-dimensional view over data held in another container (such as array<T,N> or other container. It exposes an indexing interface congruent to that of array<T,N>). More...
class	array_view< const _Value_type, _Rank >
class	auto_partitioner
	The auto_partitioner class represents the default method parallel_for, parallel_for_each and parallel_transform use to partition the range they iterates over. This method of partitioning employes range stealing for load balancing as well as per-iterate cancellation. More...
class	await_resume_context
class	bad_target
	This class describes an exception thrown when a messaging block is given a pointer to a target which is invalid for the operation being performed. More...
class	call
	A call messaging block is a multi-source, ordered target_block that invokes a specified function when receiving a message. More...
class	cancellation_token
	The cancellation_token class represents the ability to determine whether some operation has been requested to cancel. A given token can be associated with a task_group, structured_task_group, or task to provide implicit cancellation. It can also be polled for cancellation or have a callback registered for if and when the associated cancellation_token_source is canceled. More...
class	cancellation_token_registration
	The cancellation_token_registration class represents a callback notification from a cancellation_token. When the register method on a cancellation_token is used to receive notification of when cancellation occurs, a cancellation_token_registration object is returned as a handle to the callback so that the caller can request a specific callback no longer be made through use of the deregister method. More...
class	cancellation_token_source
	The cancellation_token_source class represents the ability to cancel some cancelable operation. More...
class	choice
	A choice messaging block is a multi-source, single-target block that represents a control-flow interaction with a set of sources. The choice block will wait for any one of multiple sources to produce a message and will propagate the index of the source that produced the message. More...
class	combinable
	The combinable<T> object is intended to provide thread-private copies of data, to perform lock-free thread-local sub-computations during parallel algorithms. At the end of the parallel operation, the thread-private sub-computations can then be merged into a final result. This class can be used instead of a shared variable, and can result in a performance improvement if there would otherwise be a lot of contention on that shared variable. More...
class	completion_future
	Class represents a future corresponding to a C++ AMP asynchronous operation More...
class	concurrent_priority_queue
	The concurrent_priority_queue class is a container that allows multiple threads to concurrently push and pop items. Items are popped in priority order where priority is determined by a functor supplied as a template argument. More...
class	concurrent_queue
	The concurrent_queue class is a sequence container class that allows first-in, first-out access to its elements. It enables a limited set of concurrency-safe operations, such as push and try_pop. More...
class	concurrent_unordered_map
	The concurrent_unordered_map class is a concurrency-safe container that controls a varying-length sequence of elements of type std::pair<const _Key_type, _Element_type>. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access, and iterator traversal operations. More...
class	concurrent_unordered_multimap
	The concurrent_unordered_multimap class is an concurrency-safe container that controls a varying-length sequence of elements of type std::pair<const _Key_type, _Element_type>. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access and iterator traversal operations. More...
class	concurrent_unordered_multiset
	The concurrent_unordered_multiset class is an concurrency-safe container that controls a varying-length sequence of elements of type _Key_type. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access and iterator traversal operations. More...
class	concurrent_unordered_set
	The concurrent_unordered_set class is an concurrency-safe container that controls a varying-length sequence of elements of type _Key_type. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access and iterator traversal operations. More...
class	concurrent_vector
	The concurrent_vector class is a sequence container class that allows random access to any element. It enables concurrency-safe append, element access, iterator access, and iterator traversal operations. More...
class	context_self_unblock
	This class describes an exception thrown when the Unblock method of a Context object is called from the same context. This would indicate an attempt by a given context to unblock itself. More...
class	context_unblock_unbalanced
	This class describes an exception thrown when calls to the Block and Unblock methods of a Context object are not properly paired. More...
class	critical_section
	A non-reentrant mutex which is explicitly aware of the Concurrency Runtime. More...
class	default_scheduler_exists
	This class describes an exception thrown when the Scheduler::SetDefaultSchedulerPolicy method is called when a default scheduler already exists within the process. More...
class	event
	A manual reset event which is explicitly aware of the Concurrency Runtime. More...
class	extent
	The extent<N> type represents an N-dimensional vector of int which specifies the bounds of an N-dimensional space with an origin of 0. The values in the coordinate vector are ordered from most-significant to least-significant. Thus, in 2-dimensional space, the extent vector (5,3) represents a space with 5 rows and 3 columns. More...
class	improper_lock
	This class describes an exception thrown when a lock is acquired improperly. More...
class	improper_scheduler_attach
	This class describes an exception thrown when the Attach method is called on a Scheduler object which is already attached to the current context. More...
class	improper_scheduler_detach
	This class describes an exception thrown when the CurrentScheduler::Detach method is called on a context which has not been attached to any scheduler using the Attach method of a Scheduler object. More...
class	improper_scheduler_reference
	This class describes an exception thrown when the Reference method is called on a Scheduler object that is shutting down, from a context that is not part of that scheduler. More...
class	index
	Define an N-dimensional index point; which may also be viewed as a vector based at the origin in N-space. More...
class	invalid_compute_domain
	Exception thrown when the runtime fails to launch a kernel using the compute domain specified at the parallel_for_each call site. More...
class	invalid_link_target
	This class describes an exception thrown when the link_target method of a messaging block is called and the messaging block is unable to link to the target. This can be the result of exceeding the number of links the messaging block is allowed or attempting to link a specific target twice to the same source. More...
class	invalid_multiple_scheduling
	This class describes an exception thrown when a task_handle object is scheduled multiple times using the run method of a task_group or structured_task_group object without an intervening call to either the wait or run_and_wait methods. More...
class	invalid_operation
	This class describes an exception thrown when an invalid operation is performed that is not more accurately described by another exception type thrown by the Concurrency Runtime. More...
class	invalid_oversubscribe_operation
	This class describes an exception thrown when the Context::Oversubscribe method is called with the _BeginOversubscription parameter set to false without a prior call to the Context::Oversubscribe method with the _BeginOversubscription parameter set to true. More...
class	invalid_scheduler_policy_key
	This class describes an exception thrown when an invalid or unknown key is passed to a SchedulerPolicy object constructor, or the SetPolicyValue method of a SchedulerPolicy object is passed a key that must be changed using other means such as the SetConcurrencyLimits method. More...
class	invalid_scheduler_policy_thread_specification
	This class describes an exception thrown when an attempt is made to set the concurrency limits of a SchedulerPolicy object such that the value of the MinConcurrency key is less than the value of the MaxConcurrency key. More...
class	invalid_scheduler_policy_value
	This class describes an exception thrown when a policy key of a SchedulerPolicy object is set to an invalid value for that key. More...
class	ISource
	The ISource class is the interface for all source blocks. Source blocks propagate messages to ITarget blocks. More...
class	ITarget
	The ITarget class is the interface for all target blocks. Target blocks consume messages offered to them by ISource blocks. More...
class	join
	A join messaging block is a single-target, multi-source, ordered propagator_block which combines together messages of type _Type from each of its sources. More...
class	location
	An abstraction of a physical location on hardware. More...
class	message
	The basic message envelope containing the data payload being passed between messaging blocks. More...
class	message_not_found
	This class describes an exception thrown when a messaging block is unable to find a requested message. More...
class	message_processor
	The message_processor class is the abstract base class for processing of message objects. There is no guarantee on the ordering of the messages. More...
class	missing_wait
	This class describes an exception thrown when there are tasks still scheduled to a task_group or structured_task_group object at the time that object's destructor executes. This exception will never be thrown if the destructor is reached because of a stack unwinding as the result of an exception. More...
class	multi_link_registry
	The multi_link_registry object is a network_link_registry that manages multiple source blocks or multiple target blocks. More...
class	multitype_join
	A multitype_join messaging block is a multi-source, single-target messaging block that combines together messages of different types from each of its sources and offers a tuple of the combined messages to its targets. More...
class	nested_scheduler_missing_detach
	This class describes an exception thrown when the Concurrency Runtime detects that you neglected to call the CurrentScheduler::Detach method on a context that attached to a second scheduler using the Attach method of the Scheduler object. More...
class	network_link_registry
	The network_link_registry abstract base class manages the links between source and target blocks. More...
class	operation_timed_out
	This class describes an exception thrown when an operation has timed out. More...
class	ordered_message_processor
	An ordered_message_processor is a message_processor that allows message blocks to process messages in the order they were received. More...
class	out_of_memory
	Exception thrown when an underlying OS/DirectX call fails due to lack of system or device memory More...
class	overwrite_buffer
	An overwrite_buffer messaging block is a multi-target, multi-source, ordered propagator_block capable of storing a single message at a time. New messages overwrite previously held ones. More...
class	propagator_block
	The propagator_block class is an abstract base class for message blocks that are both a source and target. It combines the functionality of both the source_block and target_block classes. More...
class	reader_writer_lock
	A writer-preference queue-based reader-writer lock with local only spinning. The lock grants first in - first out (FIFO) access to writers and starves readers under a continuous load of writers. More...
class	runtime_exception
	Exception thrown due to a C++ AMP runtime_exception. This is the base type for all C++ AMP exception types. More...
class	scheduler_not_attached
	This class describes an exception thrown when an operation is performed which requires a scheduler to be attached to the current context and one is not. More...
struct	scheduler_ptr
	Represents a pointer to a scheduler. This class exists to allow the the specification of a shared lifetime by using shared_ptr or just a plain reference by using raw pointer. More...
class	scheduler_resource_allocation_error
	This class describes an exception thrown because of a failure to acquire a critical resource in the Concurrency Runtime. More...
class	scheduler_worker_creation_error
	This class describes an exception thrown because of a failure to create a worker execution context in the Concurrency Runtime. More...
class	simple_partitioner
	The simple_partitioner class represents a static partitioning of the range iterated over by parallel_for. The partitioner divides the range into chunks such that each chunk has at least the number of iterations specified by the chunk size. More...
class	single_assignment
	A single_assignment messaging block is a multi-target, multi-source, ordered propagator_block capable of storing a single, write-once message. More...
class	single_link_registry
	The single_link_registry object is a network_link_registry that manages only a single source or target block. More...
class	source_block
	The source_block class is an abstract base class for source-only blocks. The class provides basic link management functionality as well as common error checks. More...
class	source_link_manager
	The source_link_manager object manages messaging block network links to ISource blocks. More...
class	static_partitioner
	The static_partitioner class represents a static partitioning of the range iterated over by parallel_for. The partitioner divides the range into as many chunks as there are workers available to the underyling scheduler. More...
class	structured_task_group
	The structured_task_group class represents a highly structured collection of parallel work. You can queue individual parallel tasks to a structured_task_group using task_handle objects, and wait for them to complete, or cancel the task group before they have finished executing, which will abort any tasks that have not begun execution. More...
class	target_block
	The target_block class is an abstract base class that provides basic link management functionality and error checking for target only blocks. More...
class	task
	The Parallel Patterns Library (PPL) task class. A task object represents work that can be executed asynchronously, and concurrently with other tasks and parallel work produced by parallel algorithms in the Concurrency Runtime. It produces a result of type _ResultType on successful completion. Tasks of type task<void> produce no result. A task can be waited upon and canceled independently of other tasks. It can also be composed with other tasks using continuations(then), and join(when_all) and choice(when_any) patterns. More...
class	task< void >
	The Parallel Patterns Library (PPL) task class. A task object represents work that can be executed asynchronously, and concurrently with other tasks and parallel work produced by parallel algorithms in the Concurrency Runtime. It produces a result of type _ResultType on successful completion. Tasks of type task<void> produce no result. A task can be waited upon and canceled independently of other tasks. It can also be composed with other tasks using continuations(then), and join(when_all) and choice(when_any) patterns. More...
class	task_canceled
	This class describes an exception thrown by the PPL tasks layer in order to force the current task to cancel. It is also thrown by the get() method on task, for a canceled task. More...
class	task_completion_event
	The task_completion_event class allows you to delay the execution of a task until a condition is satisfied, or start a task in response to an external event. More...
class	task_completion_event< void >
	The task_completion_event class allows you to delay the execution of a task until a condition is satisfied, or start a task in response to an external event. More...
class	task_continuation_context
	The task_continuation_context class allows you to specify where you would like a continuation to be executed. It is only useful to use this class from a Windows Store app. For non-Windows Store apps, the task continuation's execution context is determined by the runtime, and not configurable. More...
class	task_group
	The task_group class represents a collection of parallel work which can be waited on or canceled. More...
class	task_handle
	The task_handle class represents an individual parallel work item. It encapsulates the instructions and the data required to execute a piece of work. More...
class	task_options
	Represents the allowed options for creating a task More...
class	tile_barrier
	The tile_barrier class is a capability class that is only creatable by the system, and passed to a tiled parallel_for_each lambda as part of the tiled_index parameter. It provides wait methods whose purpose is to synchronize execution of threads running within the thread group (tile). More...
class	tiled_extent
	A tiled_extent is an extent of 1 to 3 dimensions which also subdivides the extent space into 1-, 2-, or 3-dimensional tiles. It has three specialized forms: tiled_extent<_Dim0>, tiled_extent<_Dim0,_Dim1>, and tiled_extent<_Dim0,_Dim1,_Dim2>, where _Dim0-2 specify the length of the tile along each dimension, with _Dim0 being the most-significant dimension and _Dim2 being the least-significant. More...
class	tiled_extent< _Dim0, 0, 0 >
class	tiled_extent< _Dim0, _Dim1, 0 >
class	tiled_index
	A tiled_index is a set of indices of 1 to 3 dimensions which have been subdivided into 1-, 2-, or 3-dimensional tiles in a tiled_extent. It has three specialized forms: tiled_index<_Dim0>, tiled_index<_Dim0, _Dim1>, and tiled_index<_Dim0, _Dim1, _Dim2>, where _Dim0-2 specify the length of the tile along the each dimension, with _Dim0 being the most-significant dimension and _Dim2 being the least-significant. More...
class	tiled_index< _Dim0, 0, 0 >
class	tiled_index< _Dim0, _Dim1, 0 >
class	timer
	A timer messaging block is a single-target source_block capable of sending a message to its target after a specified time period has elapsed or at specific intervals. More...
class	transformer
	A transformer messaging block is a single-target, multi-source, ordered propagator_block which can accept messages of one type and is capable of storing an unbounded number of messages of a different type. More...
class	unbounded_buffer
	An unbounded_buffer messaging block is a multi-target, multi-source, ordered propagator_block capable of storing an unbounded number of messages. More...
class	unsupported_feature
	Exception thrown when an unsupported feature is used More...
class	unsupported_os
	This class describes an exception thrown when an unsupported operating system is used. More...

Typedefs
typedef __int32	runtime_object_identity
	Each message instance has an identity that follows it as it is cloned and passed between messaging components. This cannot be the address of the message object. More...
typedef ::Concurrency::details::_NonReentrantPPLLock::_Scoped_lock	_NR_lock
	A lock holder that acquires a non-reentrant lock on instantiation and releases it on destruction. More...
typedef ::Concurrency::details::_ReentrantPPLLock::_Scoped_lock	_R_lock
	A lock holder that acquires a reentrant lock on instantiation and releases it on destruction More...
typedef details::_Reference_counted_obj_ptr< details::_Accelerator_view_impl >	_Accelerator_view_impl_ptr
typedef details::_Reference_counted_obj_ptr< details::_Accelerator_impl >	_Accelerator_impl_ptr
typedef details::_Reference_counted_obj_ptr< details::_Buffer >	_Buffer_ptr
typedef details::_Reference_counted_obj_ptr< details::_Texture >	_Texture_ptr
typedef details::_Reference_counted_obj_ptr< details::_Sampler >	_Sampler_ptr
typedef details::_Reference_counted_obj_ptr< details::_Ubiquitous_buffer >	_Ubiquitous_buffer_ptr
typedef details::_Reference_counted_obj_ptr< details::_Event_impl >	_Event_impl_ptr
typedef details::_Reference_counted_obj_ptr< details::_View_shape >	_View_shape_ptr
typedef void(__cdecl *	TaskProc) (void *)
	Concurrency::details contains definitions of support routines in the public namespaces and one or more macros. Users should not directly interact with this internal namespace. More...
typedef void(__cdecl *	TaskProc_t) (void *)
	An elementary abstraction for a task, defined as void (__cdecl * TaskProc_t)(void *). A TaskProc is called to invoke the body of a task. More...
typedef task_group_status	task_status
	A type that represents the terminal state of a task. Valid values are completed and canceled. More...

Enumerations
enum	message_status { accepted, declined, postponed, missed }
	The valid responses for an offer of a message object to a block. More...
enum	join_type { greedy = 0, non_greedy = 1 }
	The type of a join messaging block. More...
enum	agent_status {   agent_created, agent_runnable, agent_started, agent_done,   agent_canceled }
	The valid states for an agent. More...
enum	access_type {   access_type_none = 0, access_type_read = (1 << 0), access_type_write = (1 << 1), access_type_read_write = access_type_read | access_type_write,   access_type_auto = (1 << 31) }
	Enumeration type used to denote the various types of access to data. More...
enum	queuing_mode { queuing_mode_immediate, queuing_mode_automatic }
	Queuing modes supported for accelerator views More...
enum	ConcRT_EventType {   CONCRT_EVENT_GENERIC = 0, CONCRT_EVENT_START = 1, CONCRT_EVENT_END = 2, CONCRT_EVENT_BLOCK = 3,   CONCRT_EVENT_UNBLOCK = 4, CONCRT_EVENT_YIELD = 5, CONCRT_EVENT_IDLE = 6, CONCRT_EVENT_ATTACH = 7,   CONCRT_EVENT_DETACH = 8 }
	The types of events that can be traced using the tracing functionality offered by the Concurrency Runtime. More...
enum	Concrt_TraceFlags {   SchedulerEventFlag = 0x1, ContextEventFlag = 0x2, VirtualProcessorEventFlag = 0x4, ResourceManagerEventFlag = 0x8,   PPLEventFlag = 0x10, AgentEventFlag = 0x20, AllEventsFlag = 0xFFFFFFFF }
	Trace flags for the event types More...
enum	Agents_EventType {   AGENTS_EVENT_CREATE = 0, AGENTS_EVENT_START = 1, AGENTS_EVENT_END = 2, AGENTS_EVENT_DESTROY = 3,   AGENTS_EVENT_SCHEDULE = 4, AGENTS_EVENT_LINK = 5, AGENTS_EVENT_UNLINK = 6, AGENTS_EVENT_NAME = 7 }
	The types of events that can be traced using the tracing functionality offered by the Agents Library More...
enum	task_group_status { not_complete, completed, canceled }
	Describes the execution status of a task_group or structured_task_group object. A value of this type is returned by numerous methods that wait on tasks scheduled to a task group to complete. More...

Functions
template<class _Type >
_Type	_Receive_impl (ISource< _Type > *_Src, unsigned int _Timeout, typename ITarget< _Type >::filter_method const *_Filter_proc)
	A general receive implementation, allowing a context to wait for data from exactly one source and filter the values that are accepted. If the specified timeout is not COOPERATIVE_TIMEOUT_INFINITE, an exception (operation_timed_out) will be thrown if the specified amount of time expires before a message is received. Note that zero length timeouts should likely use try_receive as opposed to receive with a timeout of zero as it is more efficient and does not throw exceptions on timeouts. More...
template<class _Type >
_Type	receive (_Inout_ ISource< _Type > *_Src, unsigned int _Timeout=COOPERATIVE_TIMEOUT_INFINITE)
	A general receive implementation, allowing a context to wait for data from exactly one source and filter the values that are accepted. More...
template<class _Type >
_Type	receive (_Inout_ ISource< _Type > *_Src, typename ITarget< _Type >::filter_method const &_Filter_proc, unsigned int _Timeout=COOPERATIVE_TIMEOUT_INFINITE)
	A general receive implementation, allowing a context to wait for data from exactly one source and filter the values that are accepted. More...
template<class _Type >
_Type	receive (ISource< _Type > &_Src, unsigned int _Timeout=COOPERATIVE_TIMEOUT_INFINITE)
	A general receive implementation, allowing a context to wait for data from exactly one source and filter the values that are accepted. More...
template<class _Type >
_Type	receive (ISource< _Type > &_Src, typename ITarget< _Type >::filter_method const &_Filter_proc, unsigned int _Timeout=COOPERATIVE_TIMEOUT_INFINITE)
	A general receive implementation, allowing a context to wait for data from exactly one source and filter the values that are accepted. More...
template<class _Type >
bool	_Try_receive_impl (ISource< _Type > *_Src, _Type &_value, typename ITarget< _Type >::filter_method const *_Filter_proc)
	Helper function that implements try_receive A general try-receive implementation, allowing a context to look for data from exactly one source and filter the values that are accepted. If the data is not ready, try_receive will return false. More...
template<class _Type >
bool	try_receive (_Inout_ ISource< _Type > *_Src, _Type &_value)
	A general try-receive implementation, allowing a context to look for data from exactly one source and filter the values that are accepted. If the data is not ready, the method will return false. More...
template<class _Type >
bool	try_receive (_Inout_ ISource< _Type > *_Src, _Type &_value, typename ITarget< _Type >::filter_method const &_Filter_proc)
	A general try-receive implementation, allowing a context to look for data from exactly one source and filter the values that are accepted. If the data is not ready, the method will return false. More...
template<class _Type >
bool	try_receive (ISource< _Type > &_Src, _Type &_value)
	A general try-receive implementation, allowing a context to look for data from exactly one source and filter the values that are accepted. If the data is not ready, the method will return false. More...
template<class _Type >
bool	try_receive (ISource< _Type > &_Src, _Type &_value, typename ITarget< _Type >::filter_method const &_Filter_proc)
	A general try-receive implementation, allowing a context to look for data from exactly one source and filter the values that are accepted. If the data is not ready, the method will return false. More...
template<class _Type >
bool	send (_Inout_ ITarget< _Type > *_Trg, const _Type &_Data)
	A synchronous send operation, which waits until the target either accepts or declines the message. More...
template<class _Type >
bool	send (ITarget< _Type > &_Trg, const _Type &_Data)
	A synchronous send operation, which waits until the target either accepts or declines the message. More...
template<class _Type >
bool	asend (_Inout_ ITarget< _Type > *_Trg, const _Type &_Data)
	An asynchronous send operation, which schedules a task to propagate the data to the target block. More...
template<class _Type >
bool	asend (ITarget< _Type > &_Trg, const _Type &_Data)
	An asynchronous send operation, which schedules a task to propagate the value to the target block. More...
template<typename _Type1 , typename _Type2 , typename... _Types>
choice< std::tuple< _Type1, _Type2, _Types...> >	make_choice (_Type1 _Item1, _Type2 _Item2, _Types..._Items)
	Constructs a choice messaging block from an optional Scheduler or ScheduleGroup and two or more input sources. More...
template<typename _Type1 , typename _Type2 , typename... _Types>
multitype_join< std::tuple< _Type1, _Type2, _Types...> >	make_join (_Type1 _Item1, _Type2 _Item2, _Types..._Items)
	Constructs a non_greedy multitype_join messaging block from an optional Scheduler or ScheduleGroup and two or more input sources. More...
template<typename _Type1 , typename _Type2 , typename... _Types>
multitype_join< std::tuple< _Type1, _Type2, _Types...>, greedy >	make_greedy_join (_Type1 _Item1, _Type2 _Item2, _Types..._Items)
	Constructs a greedy multitype_join messaging block from an optional Scheduler or ScheduleGroup and two or more input sources. More...
template<class _Type >
void	Trace_agents_register_name (_Inout_ _Type *_PObject, _In_z_ const wchar_t *_Name)
	Associates the given name to the message block or agent in the ETW trace. More...
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, bool >::type	operator== (const _Tuple_type< _Rank > &_Lhs, const _Tuple_type< _Rank > &_Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, bool >::type	operator!= (const _Tuple_type< _Rank > &_Lhs, const _Tuple_type< _Rank > &_Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, _Tuple_type< _Rank > >::type	operator+ (const _Tuple_type< _Rank > &_Lhs, const _Tuple_type< _Rank > &_Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, _Tuple_type< _Rank > >::type	operator- (const _Tuple_type< _Rank > &_Lhs, const _Tuple_type< _Rank > &_Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, _Tuple_type< _Rank > >::type	operator+ (const _Tuple_type< _Rank > &_Lhs, typename _Tuple_type< _Rank >::value_type _Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, _Tuple_type< _Rank > >::type	operator+ (typename _Tuple_type< _Rank >::value_type _Lhs, const _Tuple_type< _Rank > &_Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, _Tuple_type< _Rank > >::type	operator- (const _Tuple_type< _Rank > &_Lhs, typename _Tuple_type< _Rank >::value_type _Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, _Tuple_type< _Rank > >::type	operator- (typename _Tuple_type< _Rank >::value_type _Lhs, const _Tuple_type< _Rank > &_Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, _Tuple_type< _Rank > >::type	operator* (const _Tuple_type< _Rank > &_Lhs, typename _Tuple_type< _Rank >::value_type _Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, _Tuple_type< _Rank > >::type	operator* (typename _Tuple_type< _Rank >::value_type _Lhs, const _Tuple_type< _Rank > &_Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, _Tuple_type< _Rank > >::type	operator/ (const _Tuple_type< _Rank > &_Lhs, typename _Tuple_type< _Rank >::value_type _Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, _Tuple_type< _Rank > >::type	operator/ (typename _Tuple_type< _Rank >::value_type _Lhs, const _Tuple_type< _Rank > &_Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, _Tuple_type< _Rank > >::type	operator% (const _Tuple_type< _Rank > &_Lhs, typename _Tuple_type< _Rank >::value_type _Rhs) __GPU
template<int _Rank, template< int > class _Tuple_type>
std::enable_if< details::_Is_extent_or_index< _Tuple_type< _Rank > >::value, _Tuple_type< _Rank > >::type	operator% (typename _Tuple_type< _Rank >::value_type _Lhs, const _Tuple_type< _Rank > &_Rhs) __GPU
template<typename _Value_type , int _Rank>
concurrency::completion_future	copy_async (const array< _Value_type, _Rank > &_Src, array< _Value_type, _Rank > &_Dest)
	Asynchronously copies the contents of the source array into the destination array. More...
template<typename _Value_type , int _Rank>
void	copy (const array< _Value_type, _Rank > &_Src, array< _Value_type, _Rank > &_Dest)
	Copies the contents of the source array into the destination array. More...
template<typename InputIterator , typename _Value_type , int _Rank>
concurrency::completion_future	copy_async (InputIterator _SrcFirst, InputIterator _SrcLast, array< _Value_type, _Rank > &_Dest)
	Asynchronously copies the elements in the range [_SrcFirst, _SrcLast) into the destination array. More...
template<typename InputIterator , typename _Value_type , int _Rank>
void	copy (InputIterator _SrcFirst, InputIterator _SrcLast, array< _Value_type, _Rank > &_Dest)
	Copies the elements in the range [_SrcFirst, _SrcLast) into the destination array. More...
template<typename InputIterator , typename _Value_type , int _Rank>
concurrency::completion_future	copy_async (InputIterator _SrcFirst, array< _Value_type, _Rank > &_Dest)
	Asynchronously copies the elements beginning at _SrcFirst into the destination array. More...
template<typename InputIterator , typename _Value_type , int _Rank>
void	copy (InputIterator _SrcFirst, array< _Value_type, _Rank > &_Dest)
	Copies the elements beginning at _SrcFirst into the destination array. More...
template<typename OutputIterator , typename _Value_type , int _Rank>
concurrency::completion_future	copy_async (const array< _Value_type, _Rank > &_Src, OutputIterator _DestIter)
	Asynchronously copies the contents of the array into the destination beginning at _DestIter. More...
template<typename OutputIterator , typename _Value_type , int _Rank>
void	copy (const array< _Value_type, _Rank > &_Src, OutputIterator _DestIter)
	Copies the contents of the array into the destination beginning at _DestIter. More...
template<typename _Value_type , int _Rank>
concurrency::completion_future	copy_async (const array< _Value_type, _Rank > &_Src, const array_view< _Value_type, _Rank > &_Dest)
	Asynchronously copies the contents of the source array into the destination array_view. More...
template<typename _Value_type , int _Rank>
void	copy (const array< _Value_type, _Rank > &_Src, const array_view< _Value_type, _Rank > &_Dest)
	Copies the contents of the source array into the destination array_view. More...
template<typename _Value_type , int _Rank>
concurrency::completion_future	copy_async (const array_view< const _Value_type, _Rank > &_Src, array< _Value_type, _Rank > &_Dest)
	Asynchronously copies the contents of the source array_view into the destination array. More...
template<typename _Value_type , int _Rank>
void	copy (const array_view< const _Value_type, _Rank > &_Src, array< _Value_type, _Rank > &_Dest)
	Copies the contents of the source array_view into the destination array. More...
template<typename _Value_type , int _Rank>
concurrency::completion_future	copy_async (const array_view< _Value_type, _Rank > &_Src, array< _Value_type, _Rank > &_Dest)
	Asynchronously copies the contents of the source array_view into the destination array. More...
template<typename _Value_type , int _Rank>
void	copy (const array_view< _Value_type, _Rank > &_Src, array< _Value_type, _Rank > &_Dest)
	Copies the contents of the source array_view into the destination array. More...
template<typename _Value_type , int _Rank>
concurrency::completion_future	copy_async (const array_view< const _Value_type, _Rank > &_Src, const array_view< _Value_type, _Rank > &_Dest)
	Asynchronously copies the contents of the source array_view into the destination array_view. More...
template<typename _Value_type , int _Rank>
void	copy (const array_view< const _Value_type, _Rank > &_Src, const array_view< _Value_type, _Rank > &_Dest)
	Copies the contents of the source array_view into the destination array_view. More...
template<typename _Value_type , int _Rank>
concurrency::completion_future	copy_async (const array_view< _Value_type, _Rank > &_Src, const array_view< _Value_type, _Rank > &_Dest)
	Asynchronously copies the contents of the source array_view into the destination array_view. More...
template<typename _Value_type , int _Rank>
void	copy (const array_view< _Value_type, _Rank > &_Src, const array_view< _Value_type, _Rank > &_Dest)
	Copies the contents of the source array_view into the destination array_view. More...
template<typename InputIterator , typename _Value_type , int _Rank>
concurrency::completion_future	copy_async (InputIterator _SrcFirst, InputIterator _SrcLast, const array_view< _Value_type, _Rank > &_Dest)
	Asynchronously copies the elements in the range [_SrcFirst, _SrcLast) into the destination array_view. More...
template<typename InputIterator , typename _Value_type , int _Rank>
concurrency::completion_future	copy_async (InputIterator _SrcFirst, const array_view< _Value_type, _Rank > &_Dest)
	Asynchronously copies the elements beginning at _SrcFirst into the destination array_view. More...
template<typename InputIterator , typename _Value_type , int _Rank>
void	copy (InputIterator _SrcFirst, InputIterator _SrcLast, const array_view< _Value_type, _Rank > &_Dest)
	Copies the elements in the range [_SrcFirst, _SrcLast) into the destination array_view. More...
template<typename InputIterator , typename _Value_type , int _Rank>
void	copy (InputIterator _SrcFirst, const array_view< _Value_type, _Rank > &_Dest)
	Copies the contents of an STL container into the destination array_view. More...
template<typename OutputIterator , typename _Value_type , int _Rank>
concurrency::completion_future	copy_async (const array_view< _Value_type, _Rank > &_Src, OutputIterator _DestIter)
	Asynchronously copies the contents of the array_view into the destination beginning at _DestIter. More...
template<typename OutputIterator , typename _Value_type , int _Rank>
void	copy (const array_view< _Value_type, _Rank > &_Src, OutputIterator _DestIter)
	Copies the contents of the array_view into the destination beginning at _DestIter. More...
int	atomic_fetch_add (_Inout_ int *_Dest, int _Value) __GPU_ONLY
	Performs an atomic addition of _Value to the memory location pointed to by _Dest More...
unsigned int	atomic_fetch_add (_Inout_ unsigned int *_Dest, unsigned int _Value) __GPU_ONLY
	Performs an atomic addition of _Value to the memory location pointed to by _Dest More...
int	atomic_fetch_sub (_Inout_ int *_Dest, int _Value) __GPU_ONLY
	Performs an atomic subtraction of _Value from the memory location pointed to by _Dest More...
unsigned int	atomic_fetch_sub (_Inout_ unsigned int *_Dest, unsigned int _Value) __GPU_ONLY
	Performs an atomic subtraction of _Value from the memory location pointed to by _Dest More...
int	atomic_fetch_inc (_Inout_ int *_Dest) __GPU_ONLY
	Performs an atomic increment to the memory location pointed to by _Dest More...
unsigned int	atomic_fetch_inc (_Inout_ unsigned int *_Dest) __GPU_ONLY
	Performs an atomic increment to the memory location pointed to by _Dest More...
int	atomic_fetch_dec (_Inout_ int *_Dest) __GPU_ONLY
	Performs an atomic decrement to the memory location pointed to by _Dest More...
unsigned int	atomic_fetch_dec (_Inout_ unsigned int *_Dest) __GPU_ONLY
	Performs an atomic decrement to the memory location pointed to by _Dest More...
int	atomic_exchange (_Inout_ int *_Dest, int _Value) __GPU_ONLY
	Sets the value of location pointed to by _Dest to _Value as an atomic operation More...
unsigned int	atomic_exchange (_Inout_ unsigned int *_Dest, unsigned int _Value) __GPU_ONLY
	Sets the value of location pointed to by _Dest to _Value as an atomic operation More...
float	atomic_exchange (_Inout_ float *_Dest, float _Value) __GPU_ONLY
	Sets the value of location pointed to by _Dest to _Value as an atomic operation More...
bool	atomic_compare_exchange (_Inout_ int *_Dest, _Inout_ int *_Expected_value, int _Value) __GPU_ONLY
	Atomically, compares the value pointed to by _Dest for equality with that pointed to by _Expected_value, and if true, returns true and replaces the value with _Value, and if false, returns false and updates the value pointed to by _Expected_value with the value pointed to by _Dest More...
bool	atomic_compare_exchange (_Inout_ unsigned int *_Dest, _Inout_ unsigned int *_Expected_value, unsigned int _Value) __GPU_ONLY
	Atomically, compares the value pointed to by _Dest for equality with that pointed to by _Expected_value, and if true, returns true and replaces the value with _Value, and if false, returns false and updates the value pointed to by _Expected_value with the value pointed to by _Dest More...
int	atomic_fetch_max (_Inout_ int *_Dest, int _Value) __GPU_ONLY
	Atomically computes the maximum of _Value and the value of the memory location pointed to by _Dest, and stores the maximum value to the memory location More...
unsigned int	atomic_fetch_max (_Inout_ unsigned int *_Dest, unsigned int _Value) __GPU_ONLY
	Atomically computes the maximum of _Value and the value of the memory location pointed to by _Dest, and stores the maximum value to the memory location More...
int	atomic_fetch_min (_Inout_ int *_Dest, int _Value) __GPU_ONLY
	Atomically computes the minimum of _Value and the value of the memory location pointed to by _Dest, and stores the minimum value to the memory location More...
unsigned int	atomic_fetch_min (_Inout_ unsigned int *_Dest, unsigned int _Value) __GPU_ONLY
	Atomically computes the minimum of _Value and the value of the memory location pointed to by _Dest, and stores the minimum value to the memory location More...
int	atomic_fetch_and (_Inout_ int *_Dest, int _Value) __GPU_ONLY
	Performs an atomic bitwise and operation of _Value to the memory location pointed to by _Dest More...
unsigned int	atomic_fetch_and (_Inout_ unsigned int *_Dest, unsigned int _Value) __GPU_ONLY
	Performs an atomic bitwise and operation of _Value to the memory location pointed to by _Dest More...
int	atomic_fetch_or (_Inout_ int *_Dest, int _Value) __GPU_ONLY
	Performs an atomic bitwise or operation of _Value to the memory location pointed to by _Dest More...
unsigned int	atomic_fetch_or (_Inout_ unsigned int *_Dest, unsigned int _Value) __GPU_ONLY
	Performs an atomic bitwise or operation of _Value to the memory location pointed to by _Dest More...
int	atomic_fetch_xor (_Inout_ int *_Dest, int _Value) __GPU_ONLY
	Performs an atomic bitwise xor operation of _Value to the memory location pointed to by _Dest More...
unsigned int	atomic_fetch_xor (_Inout_ unsigned int *_Dest, unsigned int _Value) __GPU_ONLY
	Performs an atomic bitwise xor operation of _Value to the memory location pointed to by _Dest More...
template<int _Rank, typename _Kernel_type >
void	parallel_for_each (const extent< _Rank > &_Compute_domain, const _Kernel_type &_Kernel)
	Invokes a parallel computation of a kernel function over a compute domain on an accelerator_view. The accelerator_view is determined from the arrays and/or array_views captured by the kernel function, or if no accelerator_view can be derived, the default is chosen. More...
template<int _Dim0, int _Dim1, int _Dim2, typename _Kernel_type >
void	parallel_for_each (const tiled_extent< _Dim0, _Dim1, _Dim2 > &_Compute_domain, const _Kernel_type &_Kernel)
	Invokes a parallel computation of a kernel function over a compute domain that has been tiled into 3-dimensional regions. The accelerator is determined from the arrays and/or array_views captured by the kernel function, or if no accelerator can be derived, the default is chosen. More...
template<int _Dim0, int _Dim1, typename _Kernel_type >
void	parallel_for_each (const tiled_extent< _Dim0, _Dim1 > &_Compute_domain, const _Kernel_type &_Kernel)
	Invokes a parallel computation of a kernel function over a compute domain that has been tiled into 2-dimensional regions. The accelerator is determined from the arrays and/or array_views captured by the kernel function, or if no accelerator can be derived, the default is chosen. More...
template<int _Dim0, typename _Kernel_type >
void	parallel_for_each (const tiled_extent< _Dim0 > &_Compute_domain, const _Kernel_type &_Kernel)
	Invokes a parallel computation of a kernel function over a compute domain that has been tiled into 1-dimensional regions. The accelerator is determined from the arrays and/or array_views captured by the kernel function, or if no accelerator can be derived, the default is chosen. More...
template<int _Rank, typename _Kernel_type >
void	parallel_for_each (const accelerator_view &_Accl_view, const extent< _Rank > &_Compute_domain, const _Kernel_type &_Kernel)
	Invokes a parallel computation of a kernel function over a compute domain on an accelerator. More...
template<int _Dim0, int _Dim1, int _Dim2, typename _Kernel_type >
void	parallel_for_each (const accelerator_view &_Accl_view, const tiled_extent< _Dim0, _Dim1, _Dim2 > &_Compute_domain, const _Kernel_type &_Kernel)
	Invokes a parallel computation of a kernel function over a compute domain that has been tiled into 3-dimensional regions. More...
template<int _Dim0, int _Dim1, typename _Kernel_type >
void	parallel_for_each (const accelerator_view &_Accl_view, const tiled_extent< _Dim0, _Dim1 > &_Compute_domain, const _Kernel_type &_Kernel)
	Invokes a parallel computation of a kernel function over a compute domain that has been tiled into 2-dimensional regions. More...
template<int _Dim0, typename _Kernel_type >
void	parallel_for_each (const accelerator_view &_Accl_view, const tiled_extent< _Dim0 > &_Compute_domain, const _Kernel_type &_Kernel)
	Invokes a parallel computation of a kernel function over a compute domain that has been tiled into 1-dimensional regions. More...
void	direct3d_abort () __GPU_ONLY
void	direct3d_errorf (const char *,...) __GPU_ONLY
void	direct3d_printf (const char *,...) __GPU_ONLY
void	all_memory_fence (const tile_barrier &_Barrier) __GPU_ONLY
	Memory fences and tile barriers. More...
void	global_memory_fence (const tile_barrier &_Barrier) __GPU_ONLY
	Ensures that global memory accesses are visible to other threads in the thread tile, and are executed according to program order More...
void	tile_static_memory_fence (const tile_barrier &_Barrier) __GPU_ONLY
	Ensures that tile_static memory accesses are visible to other threads in the thread tile, and are executed according to program order More...
_AMPIMP void __cdecl	amp_uninitialize ()
	Uninitializes the C++ AMP runtime. It is legal to call this function multiple times during an applications lifetime. Calling any C++ AMP API afer calling this function will reinitialize the C++ AMP runtime. Note that it is illegal to use C++ AMP objects across calls to this function and doing so will result in undefined behavior. Also, concurrently calling this function and any other AMP APIs is illegal and would result in undefined behavior. More...
_CONCRTIMP void __cdecl	wait (unsigned int _Milliseconds)
	Pauses the current context for a specified amount of time. More...
_CONCRTIMP void *__cdecl	Alloc (size_t _NumBytes)
	Allocates a block of memory of the size specified from the Concurrency Runtime Caching Suballocator. More...
_CONCRTIMP void __cdecl	Free (_Pre_maybenull_ _Post_invalid_ void *_PAllocation)
	Releases a block of memory previously allocated by the Alloc method to the Concurrency Runtime Caching Suballocator. More...
	__declspec (deprecated("Concurrency::EnableTracing is a deprecated function.")) _CONCRTIMP HRESULT __cdecl EnableTracing()
	Enables tracing in the Concurrency Runtime. This function is deprecated because ETW tracing is now on by default. More...
	__declspec (deprecated("Concurrency::DisableTracing is a deprecated function.")) _CONCRTIMP HRESULT __cdecl DisableTracing()
	Disables tracing in the Concurrency Runtime. This function is deprecated because ETW tracing is unregistered by default. More...
_CONCRTIMP void __cdecl	_Trace_ppl_function (const GUID &_Guid, unsigned char _Level, ConcRT_EventType _Type)
_CONCRTIMP void __cdecl	_Trace_agents (Agents_EventType _Type, __int64 _AgentId,...)
template<typename _Ty , class A1 , class A2 >
bool	operator== (const concurrent_vector< _Ty, A1 > &_A, const concurrent_vector< _Ty, A2 > &_B)
	Tests if the concurrent_vector object on the left side of the operator is equal to the concurrent_vector object on the right side. More...
template<typename _Ty , class A1 , class A2 >
bool	operator!= (const concurrent_vector< _Ty, A1 > &_A, const concurrent_vector< _Ty, A2 > &_B)
	Tests if the concurrent_vector object on the left side of the operator is not equal to the concurrent_vector object on the right side. More...
template<typename _Ty , class A1 , class A2 >
bool	operator< (const concurrent_vector< _Ty, A1 > &_A, const concurrent_vector< _Ty, A2 > &_B)
	Tests if the concurrent_vector object on the left side of the operator is less than the concurrent_vector object on the right side. More...
template<typename _Ty , class A1 , class A2 >
bool	operator> (const concurrent_vector< _Ty, A1 > &_A, const concurrent_vector< _Ty, A2 > &_B)
	Tests if the concurrent_vector object on the left side of the operator is greater than the concurrent_vector object on the right side. More...
template<typename _Ty , class A1 , class A2 >
bool	operator<= (const concurrent_vector< _Ty, A1 > &_A, const concurrent_vector< _Ty, A2 > &_B)
	Tests if the concurrent_vector object on the left side of the operator is less than or equal to the concurrent_vector object on the right side. More...
template<typename _Ty , class A1 , class A2 >
bool	operator>= (const concurrent_vector< _Ty, A1 > &_A, const concurrent_vector< _Ty, A2 > &_B)
	Tests if the concurrent_vector object on the left side of the operator is greater than or equal to the concurrent_vector object on the right side. More...
template<typename _Ty , class _Ax >
void	swap (concurrent_vector< _Ty, _Ax > &_A, concurrent_vector< _Ty, _Ax > &_B)
	Exchanges the elements of two concurrent_vector objects. More...
template<class _Function >
task_handle< _Function >	make_task (const _Function &_Func)
	A factory method for creating a task_handle object. More...
template<typename _Function >
void	run_with_cancellation_token (const _Function &_Func, cancellation_token _Ct)
	Executes a function object immediately and synchronously in the context of a given cancellation token. More...
void	interruption_point ()
	Creates an interruption point for cancellation. If a cancellation is in progress in the context where this function is called, this will throw an internal exception that aborts the execution of the currently executing parallel work. If cancellation is not in progress, the function does nothing. More...
_CONCRTIMP bool __cdecl	is_current_task_group_canceling ()
	Returns an indication of whether the task group which is currently executing inline on the current context is in the midst of an active cancellation (or will be shortly). Note that if there is no task group currently executing inline on the current context, false will be returned. More...
template<typename _Function1 , typename _Function2 >
void	_Parallel_invoke_impl (const _Function1 &_Func1, const _Function2 &_Func2)
template<typename _Function1 , typename _Function2 >
void	parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 >
void	parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 >
void	parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3, const _Function4 &_Func4)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 >
void	parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3, const _Function4 &_Func4, const _Function5 &_Func5)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 >
void	parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3, const _Function4 &_Func4, const _Function5 &_Func5, const _Function6 &_Func6)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 , typename _Function7 >
void	parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3, const _Function4 &_Func4, const _Function5 &_Func5, const _Function6 &_Func6, const _Function7 &_Func7)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 , typename _Function7 , typename _Function8 >
void	parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3, const _Function4 &_Func4, const _Function5 &_Func5, const _Function6 &_Func6, const _Function7 &_Func7, const _Function8 &_Func8)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 , typename _Function7 , typename _Function8 , typename _Function9 >
void	parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3, const _Function4 &_Func4, const _Function5 &_Func5, const _Function6 &_Func6, const _Function7 &_Func7, const _Function8 &_Func8, const _Function9 &_Func9)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()(). More...
template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 , typename _Function7 , typename _Function8 , typename _Function9 , typename _Function10 >
void	parallel_invoke (const _Function1 &_Func1, const _Function2 &_Func2, const _Function3 &_Func3, const _Function4 &_Func4, const _Function5 &_Func5, const _Function6 &_Func6, const _Function7 &_Func7, const _Function8 &_Func8, const _Function9 &_Func9, const _Function10 &_Func10)
	Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()(). More...
template<typename _Worker_class , typename _Index_type , typename Partitioner >
void	_Parallel_chunk_task_group_run (structured_task_group &_Task_group, task_handle< _Worker_class > *_Chunk_helpers, const Partitioner &, _Index_type _I)
template<typename _Worker_class , typename _Index_type >
void	_Parallel_chunk_task_group_run (structured_task_group &_Task_group, task_handle< _Worker_class > *_Chunk_helpers, affinity_partitioner &_Part, _Index_type _I)
template<typename _Worker_class , typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner >
void	_Parallel_chunk_impl (const _Random_iterator &_First, _Index_type _Range_arg, const _Index_type &_Step, const _Function &_Func, _Partitioner &&_Part)
template<typename _Worker_class , typename _Random_iterator , typename _Index_type , typename _Function >
void	_Parallel_chunk_impl (const _Random_iterator &_First, _Index_type _Range_arg, const _Index_type &_Step, const _Function &_Func)
template<typename _Index_type , typename _Diff_type , typename _Function >
void	_Parallel_for_partitioned_impl (_Index_type _First, _Diff_type _Range_arg, _Diff_type _Step, const _Function &_Func, const auto_partitioner &_Part)
template<typename _Index_type , typename _Diff_type , typename _Function >
void	_Parallel_for_partitioned_impl (_Index_type _First, _Diff_type _Range_arg, _Diff_type _Step, const _Function &_Func, const static_partitioner &_Part)
template<typename _Index_type , typename _Diff_type , typename _Function >
void	_Parallel_for_partitioned_impl (_Index_type _First, _Diff_type _Range_arg, _Diff_type _Step, const _Function &_Func, const simple_partitioner &_Part)
template<typename _Index_type , typename _Diff_type , typename _Function >
void	_Parallel_for_partitioned_impl (_Index_type _First, _Diff_type _Range_arg, _Diff_type _Step, const _Function &_Func, affinity_partitioner &_Part)
template<typename _Index_type , typename _Function , typename _Partitioner >
void	_Parallel_for_impl (_Index_type _First, _Index_type _Last, _Index_type _Step, const _Function &_Func, _Partitioner &&_Part)
template<typename _Index_type , typename _Function >
void	_Parallel_for_impl (_Index_type _First, _Index_type _Last, _Index_type _Step, const _Function &_Func)
template<typename _Index_type , typename _Function , typename _Partitioner >
void	parallel_for (_Index_type _First, _Index_type _Last, _Index_type _Step, const _Function &_Func, _Partitioner &&_Part)
	parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel. More...
template<typename _Index_type , typename _Function >
void	parallel_for (_Index_type _First, _Index_type _Last, _Index_type _Step, const _Function &_Func)
	parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel. More...
template<typename _Index_type , typename _Function >
void	parallel_for (_Index_type _First, _Index_type _Last, const _Function &_Func, const auto_partitioner &_Part=auto_partitioner())
	parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel. More...
template<typename _Index_type , typename _Function >
void	parallel_for (_Index_type _First, _Index_type _Last, const _Function &_Func, const static_partitioner &_Part)
	parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel. More...
template<typename _Index_type , typename _Function >
void	parallel_for (_Index_type _First, _Index_type _Last, const _Function &_Func, const simple_partitioner &_Part)
	parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel. More...
template<typename _Index_type , typename _Function >
void	parallel_for (_Index_type _First, _Index_type _Last, const _Function &_Func, affinity_partitioner &_Part)
	parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel. More...
template<typename _Forward_iterator , typename _Function >
void	_Parallel_for_each_chunk (_Forward_iterator &_First, const _Forward_iterator &_Last, const _Function &_Func, task_group &_Task_group)
template<typename _Forward_iterator , typename _Function >
void	_Parallel_for_each_forward_impl (_Forward_iterator &_First, const _Forward_iterator &_Last, const _Function &_Func, task_group &_Task_group)
template<typename _Forward_iterator , typename _Function >
void	_Parallel_for_each_impl (_Forward_iterator _First, const _Forward_iterator &_Last, const _Function &_Func, const auto_partitioner &, std::forward_iterator_tag)
template<typename _Random_iterator , typename _Index_type , typename _Function >
void	_Parallel_for_each_partitioned_impl (const _Random_iterator &_First, _Index_type _Range_arg, _Index_type _Step, const _Function &_Func, const auto_partitioner &_Part)
template<typename _Random_iterator , typename _Index_type , typename _Function >
void	_Parallel_for_each_partitioned_impl (const _Random_iterator &_First, _Index_type _Range_arg, _Index_type _Step, const _Function &_Func, const static_partitioner &_Part)
template<typename _Random_iterator , typename _Index_type , typename _Function >
void	_Parallel_for_each_partitioned_impl (const _Random_iterator &_First, _Index_type _Range_arg, _Index_type _Step, const _Function &_Func, const simple_partitioner &_Part)
template<typename _Random_iterator , typename _Index_type , typename _Function >
void	_Parallel_for_each_partitioned_impl (const _Random_iterator &_First, _Index_type _Range_arg, _Index_type _Step, const _Function &_Func, affinity_partitioner &_Part)
template<typename _Random_iterator , typename _Function , typename _Partitioner >
void	_Parallel_for_each_impl (const _Random_iterator &_First, const _Random_iterator &_Last, const _Function &_Func, _Partitioner &&_Part, std::random_access_iterator_tag)
template<typename _Iterator , typename _Function >
void	parallel_for_each (_Iterator _First, _Iterator _Last, const _Function &_Func)
	parallel_for_each applies a specified function to each element within a range, in parallel. It is semantically equivalent to the for_each function in the std namespace, except that iteration over the elements is performed in parallel, and the order of iteration is unspecified. The argument _Func must support a function call operator of the form operator()(T) where the parameter T is the item type of the container being iterated over. More...
template<typename _Iterator , typename _Function , typename _Partitioner >
void	parallel_for_each (_Iterator _First, _Iterator _Last, const _Function &_Func, _Partitioner &&_Part)
	parallel_for_each applies a specified function to each element within a range, in parallel. It is semantically equivalent to the for_each function in the std namespace, except that iteration over the elements is performed in parallel, and the order of iteration is unspecified. The argument _Func must support a function call operator of the form operator()(T) where the parameter T is the item type of the container being iterated over. More...
template<typename _Reduce_type , typename _Forward_iterator , typename _Range_reduce_fun , typename _Sym_reduce_fun >
_Reduce_type	parallel_reduce (_Forward_iterator _Begin, _Forward_iterator _End, const _Reduce_type &_Identity, const _Range_reduce_fun &_Range_fun, const _Sym_reduce_fun &_Sym_fun)
	Computes the sum of all elements in a specified range by computing successive partial sums, or computes the result of successive partial results similarly obtained from using a specified binary operation other than sum, in parallel. parallel_reduce is semantically similar to std::accumulate, except that it requires the binary operation to be associative, and requires an identity value instead of an initial value. More...
template<typename _Forward_iterator , typename _Sym_reduce_fun >
std::iterator_traits< _Forward_iterator >::value_type	parallel_reduce (_Forward_iterator _Begin, _Forward_iterator _End, const typename std::iterator_traits< _Forward_iterator >::value_type &_Identity, _Sym_reduce_fun _Sym_fun)
	Computes the sum of all elements in a specified range by computing successive partial sums, or computes the result of successive partial results similarly obtained from using a specified binary operation other than sum, in parallel. parallel_reduce is semantically similar to std::accumulate, except that it requires the binary operation to be associative, and requires an identity value instead of an initial value. More...
template<typename _Forward_iterator >
std::iterator_traits< _Forward_iterator >::value_type	parallel_reduce (_Forward_iterator _Begin, _Forward_iterator _End, const typename std::iterator_traits< _Forward_iterator >::value_type &_Identity)
	Computes the sum of all elements in a specified range by computing successive partial sums, or computes the result of successive partial results similarly obtained from using a specified binary operation other than sum, in parallel. parallel_reduce is semantically similar to std::accumulate, except that it requires the binary operation to be associative, and requires an identity value instead of an initial value. More...
template<typename _Forward_iterator , typename _Function >
_Function::_Reduce_type	_Parallel_reduce_impl (_Forward_iterator _First, const _Forward_iterator &_Last, const _Function &_Func, std::forward_iterator_tag)
template<typename _Worker , typename _Random_iterator , typename _Function >
void	_Parallel_reduce_random_executor (_Random_iterator _Begin, _Random_iterator _End, const _Function &_Fun)
template<typename _Random_iterator , typename _Function >
_Function::_Reduce_type	_Parallel_reduce_impl (_Random_iterator _First, _Random_iterator _Last, const _Function &_Func, std::random_access_iterator_tag)
template<typename _Forward_iterator , typename _Function >
void	_Parallel_reduce_forward_executor (_Forward_iterator _First, _Forward_iterator _Last, const _Function &_Func, task_group &_Task_group)
template<typename _Input_iterator1 , typename _Input_iterator2 , typename _Output_iterator , typename _Binary_operator >
void	_Parallel_transform_binary_impl2 (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Input_iterator2 _First2, _Output_iterator &_Result, const _Binary_operator&_Binary_op, task_group &_Tg)
template<typename _Input_iterator , typename _Output_iterator , typename _Unary_operator >
void	_Parallel_transform_unary_impl2 (_Input_iterator _First, _Input_iterator _Last, _Output_iterator &_Result, const _Unary_operator&_Unary_op, task_group &_Tg)
template<typename _Input_iterator , typename _Output_iterator , typename _Unary_operator , typename _Partitioner >
_Output_iterator	_Parallel_transform_unary_impl (_Input_iterator _First, _Input_iterator _Last, _Output_iterator _Result, const _Unary_operator&_Unary_op, _Partitioner &&_Part)
template<typename _Input_iterator1 , typename _Output_iterator , typename _Unary_operator >
_Output_iterator	parallel_transform (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Output_iterator _Result, const _Unary_operator&_Unary_op, const auto_partitioner &_Part=auto_partitioner())
	Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. This functional is semantically equivalent to std::transform. More...
template<typename _Input_iterator1 , typename _Output_iterator , typename _Unary_operator >
_Output_iterator	parallel_transform (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Output_iterator _Result, const _Unary_operator&_Unary_op, const static_partitioner &_Part)
	Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. This functional is semantically equivalent to std::transform. More...
template<typename _Input_iterator1 , typename _Output_iterator , typename _Unary_operator >
_Output_iterator	parallel_transform (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Output_iterator _Result, const _Unary_operator&_Unary_op, const simple_partitioner &_Part)
	Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. This functional is semantically equivalent to std::transform. More...
template<typename _Input_iterator1 , typename _Output_iterator , typename _Unary_operator >
_Output_iterator	parallel_transform (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Output_iterator _Result, const _Unary_operator&_Unary_op, affinity_partitioner &_Part)
	Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. This functional is semantically equivalent to std::transform. More...
template<typename _Input_iterator1 , typename _Input_iterator2 , typename _Output_iterator , typename _Binary_operator , typename _Partitioner >
_Output_iterator	parallel_transform (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Input_iterator2 _First2, _Output_iterator _Result, const _Binary_operator&_Binary_op, _Partitioner &&_Part)
	Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. This functional is semantically equivalent to std::transform. More...
template<typename _Input_iterator1 , typename _Input_iterator2 , typename _Output_iterator , typename _Binary_operator >
_Output_iterator	parallel_transform (_Input_iterator1 _First1, _Input_iterator1 _Last1, _Input_iterator2 _First2, _Output_iterator _Result, const _Binary_operator&_Binary_op)
	Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. This functional is semantically equivalent to std::transform. More...
template<typename _Random_iterator , typename _Function >
size_t	_Median_of_three (const _Random_iterator &_Begin, size_t _A, size_t _B, size_t _C, const _Function &_Func, bool &_Potentially_equal)
template<typename _Random_iterator , typename _Function >
size_t	_Median_of_nine (const _Random_iterator &_Begin, size_t _Size, const _Function &_Func, bool &_Potentially_equal)
template<typename _Random_iterator , typename _Function >
size_t	_Select_median_pivot (const _Random_iterator &_Begin, size_t _Size, const _Function &_Func, const size_t _Chunk_size, bool &_Potentially_equal)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >
size_t	_Search_mid_point (const _Random_iterator &_Begin1, size_t &_Len1, const _Random_buffer_iterator &_Begin2, size_t &_Len2, const _Function &_Func)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Random_output_iterator , typename _Function >
void	_Merge_chunks (_Random_iterator _Begin1, const _Random_iterator &_End1, _Random_buffer_iterator _Begin2, const _Random_buffer_iterator &_End2, _Random_output_iterator _Output, const _Function &_Func)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Random_output_iterator , typename _Function >
void	_Parallel_merge (_Random_iterator _Begin1, size_t _Len1, _Random_buffer_iterator _Begin2, size_t _Len2, _Random_output_iterator _Output, const _Function &_Func, size_t _Div_num)
template<typename _Ty , typename _Function >
size_t	_Radix_key (const _Ty &_Val, size_t _Radix, _Function _Proj_func)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >
void	_Integer_radix_pass (const _Random_iterator &_Begin, size_t _Size, const _Random_buffer_iterator &_Output, size_t _Radix, _Function _Proj_func)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >
void	_Integer_radix_sort (const _Random_iterator &_Begin, size_t _Size, const _Random_buffer_iterator &_Output, size_t _Radix, _Function _Proj_func, size_t _Deep=0)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >
void	_Parallel_integer_radix_sort (const _Random_iterator &_Begin, size_t _Size, const _Random_buffer_iterator &_Output, size_t _Radix, _Function _Proj_func, const size_t _Chunk_size, size_t _Deep=0)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >
void	_Parallel_integer_sort_asc (const _Random_iterator &_Begin, size_t _Size, const _Random_buffer_iterator &_Output, _Function _Proj_func, const size_t _Chunk_size)
template<typename _Random_iterator , typename _Function >
void	_Parallel_quicksort_impl (const _Random_iterator &_Begin, size_t _Size, const _Function &_Func, size_t _Div_num, const size_t _Chunk_size, int _Depth)
template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >
bool	_Parallel_buffered_sort_impl (const _Random_iterator &_Begin, size_t _Size, _Random_buffer_iterator _Output, const _Function &_Func, int _Div_num, const size_t _Chunk_size)
template<typename _Allocator >
_Allocator::pointer	_Construct_buffer (size_t _N, _Allocator &_Alloc)
template<typename _Allocator >
void	_Destroy_buffer (typename _Allocator::pointer _P, size_t _N, _Allocator &_Alloc)
template<typename _Random_iterator , typename _Function >
void	parallel_sort (const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Func, const size_t _Chunk_size=2048)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort. More...
template<typename _Random_iterator >
void	parallel_sort (const _Random_iterator &_Begin, const _Random_iterator &_End)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort. More...
template<typename _Allocator , typename _Random_iterator , typename _Function >
void	parallel_buffered_sort (const _Allocator &_Alloc, const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Func, const size_t _Chunk_size=2048)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted. More...
template<typename _Allocator , typename _Random_iterator , typename _Function >
void	parallel_buffered_sort (const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Func, const size_t _Chunk_size=2048)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted. More...
template<typename _Random_iterator , typename _Function >
void	parallel_buffered_sort (const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Func, const size_t _Chunk_size=2048)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted. More...
template<typename _Random_iterator >
void	parallel_buffered_sort (const _Random_iterator &_Begin, const _Random_iterator &_End)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted. More...
template<typename _Allocator , typename _Random_iterator >
void	parallel_buffered_sort (const _Random_iterator &_Begin, const _Random_iterator &_End)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted. More...
template<typename _Allocator , typename _Random_iterator >
void	parallel_buffered_sort (const _Allocator &_Alloc, const _Random_iterator &_Begin, const _Random_iterator &_End)
	Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted. More...
template<typename _Random_iterator >
void	parallel_radixsort (const _Random_iterator &_Begin, const _Random_iterator &_End)
	Arranges elements in a specified range into an non descending order using a radix sorting algorithm. This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. Default initialization is required for the elements being sorted. More...
template<typename _Allocator , typename _Random_iterator >
void	parallel_radixsort (const _Allocator &_Alloc, const _Random_iterator &_Begin, const _Random_iterator &_End)
	Arranges elements in a specified range into an non descending order using a radix sorting algorithm. This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. Default initialization is required for the elements being sorted. More...
template<typename _Allocator , typename _Random_iterator >
void	parallel_radixsort (const _Random_iterator &_Begin, const _Random_iterator &_End)
	Arranges elements in a specified range into an non descending order using a radix sorting algorithm. This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. Default initialization is required for the elements being sorted. More...
template<typename _Allocator , typename _Random_iterator , typename _Function >
void	parallel_radixsort (const _Allocator &_Alloc, const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Proj_func, const size_t _Chunk_size=256 *256)
	Arranges elements in a specified range into an non descending order using a radix sorting algorithm. This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. Default initialization is required for the elements being sorted. More...
template<typename _Allocator , typename _Random_iterator , typename _Function >
void	parallel_radixsort (const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Proj_func, const size_t _Chunk_size=256 *256)
	Arranges elements in a specified range into an non descending order using a radix sorting algorithm. This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. Default initialization is required for the elements being sorted. More...
template<typename _Random_iterator , typename _Function >
void	parallel_radixsort (const _Random_iterator &_Begin, const _Random_iterator &_End, const _Function &_Proj_func, const size_t _Chunk_size=256 *256)
	Arranges elements in a specified range into an non descending order using a radix sorting algorithm. This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. Default initialization is required for the elements being sorted. More...
template<class _Ty >
bool	await_ready (const task< _Ty > &_Task)
template<class _Ty , typename _Handle >
void	await_suspend (task< _Ty > &_Task, _Handle _ResumeCb)
template<class _Ty >
auto	await_resume (const task< _Ty > &_Task)
struct	__declspec (novtable) scheduler_interface
	Scheduler Interface More...
	__declspec (noreturn) void __cdecl cancel_current_task()
	Cancels the currently executing task. This function can be called from within the body of a task to abort the task's execution and cause it to enter the canceled state. While it may be used in response to a cancellation request through a cancellation_token, you may also use it by itself, to initiate cancellation of the task that is currently executing. More...
template<typename _Ty >
	__declspec (noinline) auto create_task(_Ty _Param
	Creates a PPL task object. create_task can be used anywhere you would have used a task constructor. It is provided mainly for convenience, because it allows use of the auto keyword while creating tasks. More...
const ::std::shared_ptr< scheduler_interface > &	get_ambient_scheduler ()
void	set_ambient_scheduler (const ::std::shared_ptr< scheduler_interface > &_Scheduler)

Variables
const size_t	COOPERATIVE_WAIT_TIMEOUT = SIZE_MAX
	Value indicating that a wait timed out. More...
const unsigned int	COOPERATIVE_TIMEOUT_INFINITE = (unsigned int)-1
	Value indicating that a wait should never time out. More...
_CONCRTIMP const GUID	ConcRT_ProviderGuid
	The ETW provider GUID for the Concurrency Runtime. More...
_CONCRTIMP const GUID	ConcRTEventGuid
	A category GUID describing ETW events fired by the Concurrency Runtime that are not more specifically described by another category. More...
_CONCRTIMP const GUID	SchedulerEventGuid
	A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to scheduler activity. More...
_CONCRTIMP const GUID	ScheduleGroupEventGuid
	A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to schedule groups. More...
_CONCRTIMP const GUID	ContextEventGuid
	A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to contexts. More...
_CONCRTIMP const GUID	ChoreEventGuid
	A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to chores or tasks. More...
_CONCRTIMP const GUID	VirtualProcessorEventGuid
	A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to virtual processors. More...
_CONCRTIMP const GUID	LockEventGuid
	A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to locks. More...
_CONCRTIMP const GUID	ResourceManagerEventGuid
	A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to the resource manager. More...
_CONCRTIMP const GUID	PPLParallelInvokeEventGuid
	A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to usage of the parallel_invoke function. More...
_CONCRTIMP const GUID	PPLParallelForEventGuid
	A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to usage of the parallel_for function. More...
_CONCRTIMP const GUID	PPLParallelForeachEventGuid
	A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to usage of the parallel_for_each function. More...
_CONCRTIMP const GUID	AgentEventGuid
	A category GUID ({B9B5B78C-0713-4898-A21A-C67949DCED07}) describing ETW events fired by the Agents library in the Concurrency Runtime. More...

Detailed Description

The Concurrency namespace provides classes and functions that provide access to the Concurrency Runtime, a concurrent programming framework for C++. For more information, see Concurrency Runtime.

The concurrency namespace provides classes and functions that give you access to the Concurrency Runtime, a concurrent programming framework for C++. For more information, see Concurrency Runtime.

The Concurrency namespace provides classes and functions that give you access to the Concurrency Runtime, a concurrent programming framework for C++. For more information, see Concurrency Runtime.

The Concurrency namespace provides classes and functions that access the Concurrency Runtime, a concurrent programming framework for C++. For more information, see Concurrency Runtime.

Typedef Documentation

typedef details::_Reference_counted_obj_ptr<details::_Accelerator_impl> Concurrency::_Accelerator_impl_ptr

typedef details::_Reference_counted_obj_ptr<details::_Accelerator_view_impl> Concurrency::_Accelerator_view_impl_ptr

typedef details::_Reference_counted_obj_ptr<details::_Buffer> Concurrency::_Buffer_ptr

typedef details::_Reference_counted_obj_ptr<details::_Event_impl> Concurrency::_Event_impl_ptr

typedef ::Concurrency::details::_NonReentrantPPLLock::_Scoped_lock Concurrency::_NR_lock

A lock holder that acquires a non-reentrant lock on instantiation and releases it on destruction.

typedef ::Concurrency::details::_ReentrantPPLLock::_Scoped_lock Concurrency::_R_lock

A lock holder that acquires a reentrant lock on instantiation and releases it on destruction

typedef details::_Reference_counted_obj_ptr<details::_Sampler> Concurrency::_Sampler_ptr

typedef details::_Reference_counted_obj_ptr<details::_Texture> Concurrency::_Texture_ptr

typedef details::_Reference_counted_obj_ptr<details::_Ubiquitous_buffer> Concurrency::_Ubiquitous_buffer_ptr

typedef details::_Reference_counted_obj_ptr<details::_View_shape> Concurrency::_View_shape_ptr

typedef __int32 Concurrency::runtime_object_identity

Each message instance has an identity that follows it as it is cloned and passed between messaging components. This cannot be the address of the message object.

typedef task_group_status Concurrency::task_status

A type that represents the terminal state of a task. Valid values are completed and canceled.

See also

task Class

typedef void(__cdecl * Concurrency::TaskProc) (void *)

Concurrency::details contains definitions of support routines in the public namespaces and one or more macros. Users should not directly interact with this internal namespace.

An elementary abstraction for a task, defined as void (__cdecl * TaskProc)(void *). A TaskProc is called to invoke the body of a task.

typedef void(__cdecl * Concurrency::TaskProc_t) (void *)

An elementary abstraction for a task, defined as void (__cdecl * TaskProc_t)(void *). A TaskProc is called to invoke the body of a task.

Enumeration Type Documentation

enum Concurrency::access_type

Enumeration type used to denote the various types of access to data.

Enumerator
access_type_none
access_type_read
access_type_write
access_type_read_write
access_type_auto

    {
        access_type_none = 0,
        access_type_read = (1 << 0),
        access_type_write = (1 << 1),
        access_type_read_write = access_type_read | access_type_write,
        access_type_auto = (1 << 31),
    };

enum Concurrency::agent_status

The valid states for an agent.

For more information, see Asynchronous Agents.

Enumerator
agent_created	The agent has been created but not started.
agent_runnable	The agent has been started, but not entered its run method.
agent_started	The agent has started.
agent_done	The agent finished without being canceled.
agent_canceled	The agent was canceled.

                  {
    
    agent_created,
    
    agent_runnable,
    
    agent_started,
    
    agent_done,
    
    agent_canceled
};

enum Concurrency::Agents_EventType

The types of events that can be traced using the tracing functionality offered by the Agents Library

Enumerator
AGENTS_EVENT_CREATE	An event type that represents the creation of an object
AGENTS_EVENT_START	An event type that represents the initiation of some processing
AGENTS_EVENT_END	An event type that represents the conclusion of some processing
AGENTS_EVENT_DESTROY	An event type that represents the deletion of an object
AGENTS_EVENT_SCHEDULE	An event type that represents the scheduling of a process
AGENTS_EVENT_LINK	An event type that represents the linking of message blocks
AGENTS_EVENT_UNLINK	An event type that represents the unlinking of message blocks
AGENTS_EVENT_NAME	An event type that represents the name for an object

{
    
    AGENTS_EVENT_CREATE   = 0,

    
    AGENTS_EVENT_START    = 1,

    
    AGENTS_EVENT_END      = 2,

    
    AGENTS_EVENT_DESTROY  = 3,

    
    AGENTS_EVENT_SCHEDULE = 4,

    
    AGENTS_EVENT_LINK     = 5,

    
    AGENTS_EVENT_UNLINK   = 6,

    
    AGENTS_EVENT_NAME     = 7

};

enum Concurrency::ConcRT_EventType

The types of events that can be traced using the tracing functionality offered by the Concurrency Runtime.

Enumerator
CONCRT_EVENT_GENERIC	An event type used for miscellaneous events.
CONCRT_EVENT_START	An event type that marks the beginning of a start/end event pair.
CONCRT_EVENT_END	An event type that marks the beginning of a start/end event pair.
CONCRT_EVENT_BLOCK	An event type that represents the act of a context blocking.
CONCRT_EVENT_UNBLOCK	An event type that represents the act of unblocking a context.
CONCRT_EVENT_YIELD	An event type that represents the act of a context yielding.
CONCRT_EVENT_IDLE	An event type that represents the act of a context becoming idle.
CONCRT_EVENT_ATTACH	An event type that represents the act of a attaching to a scheduler.
CONCRT_EVENT_DETACH	An event type that represents the act of a detaching from a scheduler.

{
    
    CONCRT_EVENT_GENERIC    = 0,
    
    CONCRT_EVENT_START      = 1,
    
    CONCRT_EVENT_END        = 2,
    
    CONCRT_EVENT_BLOCK      = 3,
    
    CONCRT_EVENT_UNBLOCK    = 4,
    
    CONCRT_EVENT_YIELD      = 5,
    
    CONCRT_EVENT_IDLE       = 6,
    
    CONCRT_EVENT_ATTACH     = 7,
    
    CONCRT_EVENT_DETACH     = 8,
};

enum Concurrency::Concrt_TraceFlags

Trace flags for the event types

Enumerator
SchedulerEventFlag
ContextEventFlag
VirtualProcessorEventFlag
ResourceManagerEventFlag
PPLEventFlag
AgentEventFlag
AllEventsFlag

{
    SchedulerEventFlag              = 0x1,
    ContextEventFlag                = 0x2,
    VirtualProcessorEventFlag       = 0x4,
    ResourceManagerEventFlag        = 0x8,
    PPLEventFlag                    = 0x10,
    AgentEventFlag                  = 0x20,

    AllEventsFlag                   = 0xFFFFFFFF
};

enum Concurrency::join_type

The type of a join messaging block.

Enumerator
greedy	Greedy join messaging blocks immediately accept a message upon propagation. This is more efficient, but has the possibility for live-lock, depending on the network configuration.
non_greedy	Non-greedy join messaging blocks postpone messages and try and consume them after all have arrived. These are guaranteed to work, but slower.

               {
    
    greedy = 0,
    
    non_greedy = 1
};

enum Concurrency::message_status

The valid responses for an offer of a message object to a block.

Enumerator
accepted	The target accepted the message.
declined	The target did not accept the message.
postponed	The target postponed the message.
missed	The target tried to accept the message, but it was no longer available.

{
    
    accepted,
    
    declined,
    
    postponed,
    
    missed
};

enum Concurrency::queuing_mode

Queuing modes supported for accelerator views

Enumerator
queuing_mode_immediate
queuing_mode_automatic

                  {
    queuing_mode_immediate,
    queuing_mode_automatic
}; 

enum Concurrency::task_group_status

Describes the execution status of a task_group or structured_task_group object. A value of this type is returned by numerous methods that wait on tasks scheduled to a task group to complete.

See also

task_group Class, task_group::wait Method, task_group::run_and_wait Method, structured_task_group Class, structured_task_group::wait Method, structured_task_group::run_and_wait Method

Enumerator
not_complete	The tasks queued to the task_group object have not completed. Note that this value is not presently returned by the Concurrency Runtime.
completed	The tasks queued to the task_group or structured_task_group object completed successfully.
canceled	The task_group or structured_task_group object was canceled. One or more tasks may not have executed.

{
    
    not_complete,

    
    completed,

    
    canceled
};

Function Documentation

struct Concurrency::__declspec

(

novtable

)

Scheduler Interface

{
    virtual void schedule( TaskProc_t, void* ) = 0;
};

Concurrency::__declspec ( noreturn  )

inline

Cancels the currently executing task. This function can be called from within the body of a task to abort the task's execution and cause it to enter the canceled state. While it may be used in response to a cancellation request through a cancellation_token, you may also use it by itself, to initiate cancellation of the task that is currently executing.

It is not a supported scenario to call this function if you are not within the body of a task. Doing so will result in undefined behavior such as a crash or a hang in your application.

See also

task Class

{
    _THROW_NCEE(task_canceled, _EMPTY_ARGUMENT);
}

template<typename _Ty >

Concurrency::__declspec

(

noinline

)

Creates a PPL task object. create_task can be used anywhere you would have used a task constructor. It is provided mainly for convenience, because it allows use of the auto keyword while creating tasks.

Template Parameters

_Ty	The type of the parameter from which the task is to be constructed.

Parameters

_Param

The parameter from which the task is to be constructed. This could be a lambda or function object, a task_completion_event object, a different task object, or a Windows::Foundation::IAsyncInfo interface if you are using tasks in your Windows Store app.

Returns

A new task of type T, that is inferred from _Param .

The first overload behaves like a task constructor that takes a single parameter.

The second overload associates the cancellation token provided with the newly created task. If you use this overload you are not allowed to pass in a different task object as the first parameter.

The type of the returned task is inferred from the first parameter to the function. If _Param is a task_completion_event<T>, a task<T>, or a functor that returns either type T or task<T>, the type of the created task is task<T>.

In a Windows Store app, if _Param is of type Windows::Foundation::IAsyncOperation<T>^ or Windows::Foundation::IAsyncOperationWithProgress<T,P>^, or a functor that returns either of those types, the created task will be of type task<T>. If _Param is of type Windows::Foundation::IAsyncAction^ or Windows::Foundation::IAsyncActionWithProgress<P>^, or a functor that returns either of those types, the created task will have type task<void>.

See also

task Class, Task Parallelism (Concurrency Runtime)

Concurrency::__declspec

(

deprecated("Concurrency::EnableTracing is a deprecated function.")

)

Enables tracing in the Concurrency Runtime. This function is deprecated because ETW tracing is now on by default.

Returns

If tracing was correctly initiated, S_OK is returned; otherwise, E_NOT_STARTED is returned.

Concurrency::__declspec

(

deprecated("Concurrency::DisableTracing is a deprecated function.")

)

Disables tracing in the Concurrency Runtime. This function is deprecated because ETW tracing is unregistered by default.

Returns

If tracing was correctly disabled, S_OK is returned. If tracing was not previously initiated, E_NOT_STARTED is returned

template<typename _Allocator >

_Allocator::pointer Concurrency::_Construct_buffer ( size_t  _N, _Allocator &  _Alloc  )

inline

{
    typename _Allocator::pointer _P = _Alloc.allocate(_N);

    // If the objects being sorted have trivial default constructors, they do not need to be
    // constructed here. This can benefit performance.
    if (!std::is_trivially_default_constructible<typename _Allocator::value_type>::value)
    {
        for (size_t _I = 0; _I < _N; _I++)
        {
            // Objects being sorted must have a default constructor
            typename _Allocator::value_type _T;
            _Alloc.construct(_P + _I, std::forward<typename _Allocator::value_type>(_T));
        }
    }

    return _P;
}

template<typename _Allocator >

void Concurrency::_Destroy_buffer ( typename _Allocator::pointer  _P, size_t  _N, _Allocator &  _Alloc  )

inline

{
    // If the objects being sorted have trivial destructors, they do not need to be
    // destructed here. This can benefit performance.
    if (!std::is_trivially_destructible<typename _Allocator::value_type>::value)
    {
        for (size_t _I = 0; _I < _N; _I++)
        {
            _Alloc.destroy(_P + _I);
        }
    }

    _Alloc.deallocate(_P, _N);
}

template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >

void Concurrency::_Integer_radix_pass	(	const _Random_iterator &	_Begin,
		size_t	_Size,
		const _Random_buffer_iterator &	_Output,
		size_t	_Radix,
		_Function	_Proj_func
	)

{
    if (!_Size)
    {
        return;
    }

    size_t _Pos[256] = {0};

    for (size_t _I = 0; _I < _Size; _I++)
    {
        ++_Pos[_Radix_key(_Begin[_I], _Radix, _Proj_func)];
    }

    for (size_t _I = 1; _I < 256; _I++)
    {
        _Pos[_I] += _Pos[_I - 1];
    }

    // _Size > 0
    for (size_t _I = _Size - 1; _I != 0; _I--)
    {
        _Output[--_Pos[_Radix_key(_Begin[_I], _Radix, _Proj_func)]] = std::move(_Begin[_I]);
    }

    _Output[--_Pos[_Radix_key(_Begin[0], _Radix, _Proj_func)]] = std::move(_Begin[0]);
}

template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >

void Concurrency::_Integer_radix_sort	(	const _Random_iterator &	_Begin,
		size_t	_Size,
		const _Random_buffer_iterator &	_Output,
		size_t	_Radix,
		_Function	_Proj_func,
		size_t	_Deep = 0
	)

{
    size_t _Cur_radix = 0;
    if (_Size == 0)
    {
        return;
    }

    while (_Cur_radix < _Radix)
    {
        _Integer_radix_pass(_Begin, _Size, _Output, _Cur_radix++, _Proj_func);
        _Integer_radix_pass(_Output, _Size, _Begin, _Cur_radix++, _Proj_func);
    }

    if (_Cur_radix == _Radix)
    {
        _Integer_radix_pass(_Begin, _Size, _Output, _Cur_radix++, _Proj_func);
    }

    // if odd round is passed, then move result back to input buffer
    if (_Deep + _Radix + 1 & 1)
    {
        if (_Radix + 1 & 1)
        {
            std::_Move_no_deprecate(_Output, _Output + _Size, _Begin);
        }
        else
        {
            std::_Move_no_deprecate(_Begin, _Begin + _Size, _Output);
        }
    }
}

template<typename _Random_iterator , typename _Function >

size_t Concurrency::_Median_of_nine ( const _Random_iterator &  _Begin, size_t  _Size, const _Function &  _Func, bool &  _Potentially_equal  )

inline

{
    size_t _Offset = _Size / 8;
    size_t _A = _Median_of_three(_Begin, 0, _Offset, _Offset * 2, _Func, _Potentially_equal),
        _B = _Median_of_three(_Begin, _Offset * 3, _Offset * 4, _Offset * 5, _Func, _Potentially_equal),
        _C = _Median_of_three(_Begin, _Offset * 6, _Offset * 7, _Size - 1, _Func, _Potentially_equal);
    _B = _Median_of_three(_Begin, _A, _B, _C, _Func, _Potentially_equal);

    if (_Potentially_equal)
    {
        _Potentially_equal = !_Func(_Begin[_C], _Begin[_A]);
    }

    return _B;
}

template<typename _Random_iterator , typename _Function >

size_t Concurrency::_Median_of_three ( const _Random_iterator &  _Begin, size_t  _A, size_t  _B, size_t  _C, const _Function &  _Func, bool &  _Potentially_equal  )

inline

{
    _Potentially_equal = false;
    if (_Func(_Begin[_A], _Begin[_B]))
    {
        if (_Func(_Begin[_A], _Begin[_C]))
        {
            return _Func(_Begin[_B], _Begin[_C]) ? _B : _C;
        }
        else
        {
            return _A;
        }
    }
    else
    {
        if (_Func(_Begin[_B], _Begin[_C]))
        {
            return _Func(_Begin[_A], _Begin[_C]) ? _A : _C;
        }
        else
        {
            _Potentially_equal = true;
            return _B;
        }
    }
}

template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Random_output_iterator , typename _Function >

void Concurrency::_Merge_chunks	(	_Random_iterator	_Begin1,
		const _Random_iterator &	_End1,
		_Random_buffer_iterator	_Begin2,
		const _Random_buffer_iterator &	_End2,
		_Random_output_iterator	_Output,
		const _Function &	_Func
	)

{
    while (_Begin1 != _End1 && _Begin2 != _End2)
    {
        if (_Func(*_Begin1, *_Begin2))
        {
            *_Output++ = std::move(*_Begin1++);
        }
        else
        {
            *_Output++ = std::move(*_Begin2++);
        }
    }

    if (_Begin1 != _End1)
    {
        std::_Move_no_deprecate(_Begin1, _End1, _Output);
    }
    else if (_Begin2 != _End2)
    {
        std::_Move_no_deprecate(_Begin2, _End2, _Output);
    }
}

template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >

bool Concurrency::_Parallel_buffered_sort_impl ( const _Random_iterator &  _Begin, size_t  _Size, _Random_buffer_iterator  _Output, const _Function &  _Func, int  _Div_num, const size_t  _Chunk_size  )

inline

{
    static_assert(std::is_same<typename std::iterator_traits<_Random_iterator>::value_type, typename std::iterator_traits<_Random_buffer_iterator>::value_type>::value,
        "same value type expected");

    if (_Div_num <= 1 || _Size <= _Chunk_size)
    {
        _Parallel_quicksort_impl(_Begin, _Size, _Func, _MAX_NUM_TASKS_PER_CORE, _Chunk_size, 0);

        // In case _Size <= _Chunk_size happened BEFORE the planned stop time (when _Div_num == 1) we need to calculate how many turns of
        // binary divisions are left. If there are an odd number of turns left, then the buffer move is necessary to make sure the final
        // merge result will be in the original input array.
        int _Left_div_turns = 0;
        while (_Div_num >>= 1)
        {
            _Left_div_turns++;
        }

        if (_Left_div_turns & 1)
        {
            std::move(_Begin, _Begin + _Size, _Output);
            return true;
        }
        else
        {
            return false;
        }
    }
    else
    {
        size_t _Mid = _Size / 2;
        structured_task_group _Tg;

        auto _Handle = make_task([&, _Chunk_size]
        {
            _Parallel_buffered_sort_impl(_Begin, _Mid, _Output, _Func, _Div_num / 2, _Chunk_size);
        });
        _Tg.run(_Handle);

        bool _Is_buffer_swap = _Parallel_buffered_sort_impl(_Begin + _Mid, _Size - _Mid, _Output + _Mid, _Func, _Div_num / 2, _Chunk_size);

        _Tg.wait();

        if (_Is_buffer_swap)
        {
            _Parallel_merge(_Output, _Mid, _Output + _Mid, _Size - _Mid, _Begin, _Func, _Div_num);
        }
        else
        {
            _Parallel_merge(_Begin, _Mid, _Begin + _Mid, _Size - _Mid, _Output, _Func, _Div_num);
        }

        return !_Is_buffer_swap;
    }
}

template<typename _Worker_class , typename _Random_iterator , typename _Index_type , typename _Function , typename _Partitioner >

void Concurrency::_Parallel_chunk_impl	(	const _Random_iterator &	_First,
		_Index_type	_Range_arg,
		const _Index_type &	_Step,
		const _Function &	_Func,
		_Partitioner &&	_Part
	)

{
    _CONCRT_ASSERT(_Range_arg > 1);
    _CONCRT_ASSERT(_Step > 0);

    _Index_type _Num_iterations = (_Step == 1) ? _Range_arg : (((_Range_arg - 1) / _Step) + 1);
    _CONCRT_ASSERT(_Num_iterations > 1);

    _Index_type _Num_chunks = _Part._Get_num_chunks(_Num_iterations);
    _CONCRT_ASSERT(_Num_chunks > 0);

    // Allocate memory on the stack for task_handles to ensure everything is properly structured.
    ::Concurrency::details::_MallocaArrayHolder<task_handle<_Worker_class>> _Holder;
    task_handle<_Worker_class> * _Chunk_helpers = _Holder._InitOnRawMalloca(_malloca(sizeof(task_handle<_Worker_class>) * static_cast<size_t>(_Num_chunks)));

    structured_task_group _Task_group;

    _Index_type _Iterations_per_chunk = _Num_iterations / _Num_chunks;
    _Index_type _Remaining_iterations = _Num_iterations % _Num_chunks;

    // If there are less iterations than desired chunks, set the chunk number
    // to be the number of iterations.
    if (_Iterations_per_chunk == 0)
    {
        _Num_chunks = _Remaining_iterations;
    }

    _Index_type _Work_size = 0;
    _Index_type _Start_iteration = 0;
    _Index_type _I;

    // Split the available work in chunks
    for (_I = 0; _I < _Num_chunks - 1; _I++)
    {
        if (_Remaining_iterations > 0)
        {
            // Iterations are not divided evenly, so add 1 remainder iteration each time
            _Work_size = _Iterations_per_chunk + 1;
            _Remaining_iterations--;
        }
        else
        {
            _Work_size = _Iterations_per_chunk;
        }

        // New up a task_handle "in-place", in the array preallocated on the stack
        new(&_Chunk_helpers[_I]) task_handle<_Worker_class>(_Worker_class(_I, _First, _Start_iteration, _Start_iteration + _Work_size, _Step, _Func, std::forward<_Partitioner>(_Part)));
        _Holder._IncrementConstructedElemsCount();

        // Run each of the chunk tasks in parallel
        _Parallel_chunk_task_group_run(_Task_group, _Chunk_helpers, std::forward<_Partitioner>(_Part), _I);

        // Prepare for the next iteration
        _Start_iteration += _Work_size;
    }

    // Because this is the last iteration, then work size might be different
    _CONCRT_ASSERT((_Remaining_iterations == 0) || ((_Iterations_per_chunk == 0) && (_Remaining_iterations == 1)));
    _Work_size = _Num_iterations - _Start_iteration;

    // New up a task_handle "in-place", in the array preallocated on the stack
    new(&_Chunk_helpers[_I]) task_handle<_Worker_class>(_Worker_class(_I, _First, _Start_iteration, _Start_iteration + _Work_size, _Step, _Func, std::forward<_Partitioner>(_Part)));
    _Holder._IncrementConstructedElemsCount();

    _Task_group.run_and_wait(_Chunk_helpers[_I]);
}

template<typename _Worker_class , typename _Random_iterator , typename _Index_type , typename _Function >

void Concurrency::_Parallel_chunk_impl	(	const _Random_iterator &	_First,
		_Index_type	_Range_arg,
		const _Index_type &	_Step,
		const _Function &	_Func
	)

{
    _Parallel_chunk_impl<_Worker_class>(_First, _Range_arg, _Step, _Func, auto_partitioner());
}

template<typename _Worker_class , typename _Index_type , typename Partitioner >

void Concurrency::_Parallel_chunk_task_group_run	(	structured_task_group &	_Task_group,
		task_handle< _Worker_class > *	_Chunk_helpers,
		const Partitioner &	,
		_Index_type	_I
	)

{
    _Task_group.run(_Chunk_helpers[_I]);
}

template<typename _Worker_class , typename _Index_type >

void Concurrency::_Parallel_chunk_task_group_run	(	structured_task_group &	_Task_group,
		task_handle< _Worker_class > *	_Chunk_helpers,
		affinity_partitioner &	_Part,
		_Index_type	_I
	)

{
     _Task_group.run(_Chunk_helpers[_I], _Part._Get_chunk_location(static_cast<unsigned int>(_I)));
}

template<typename _Forward_iterator , typename _Function >

void Concurrency::_Parallel_for_each_chunk	(	_Forward_iterator &	_First,
		const _Forward_iterator &	_Last,
		const _Function &	_Func,
		task_group &	_Task_group
	)

{
    // The chunk size selection depends more on the internal implementation of parallel_for than
    // on the actual input. Also, it does not have to be dynamically computed, but it helps
    // parallel_for if it is a power of 2 (easy to divide).
    const unsigned int _Chunk_size = 1024;

    // This functor will be copied on the heap and will execute the chunk in parallel
    _Parallel_for_each_helper<_Forward_iterator, _Function, _Chunk_size> _Functor(_First, _Last, _Func);

    // Because this is an unstructured task group, running the task will make a copy of the necessary data
    // on the heap, ensuring that it is available at the time of execution.
    _Task_group.run(_Functor);
}

template<typename _Forward_iterator , typename _Function >

void Concurrency::_Parallel_for_each_forward_impl	(	_Forward_iterator &	_First,
		const _Forward_iterator &	_Last,
		const _Function &	_Func,
		task_group &	_Task_group
	)

{
    _Parallel_for_each_chunk(_First, _Last, _Func, _Task_group);

    // If there is a tail, push the tail
    if (_First != _Last)
    {
        _Task_group.run(
            [&_First, &_Last, &_Func, &_Task_group]
            {
                ::Concurrency::_Parallel_for_each_forward_impl(_First, _Last, _Func, _Task_group);
            }
        );
    }
}

template<typename _Forward_iterator , typename _Function >

void Concurrency::_Parallel_for_each_impl	(	_Forward_iterator	_First,
		const _Forward_iterator &	_Last,
		const _Function &	_Func,
		const auto_partitioner &	,
		std::forward_iterator_tag
	)

{
    // Because this is a forward iterator, it is difficult to validate that _First comes before _Last, so
    // it is up to the user to provide valid range.
    if (_First != _Last)
    {
        task_group _Task_group;

        _Parallel_for_each_forward_impl(_First, _Last, _Func, _Task_group);

        _Task_group.wait();
    }
}

template<typename _Random_iterator , typename _Function , typename _Partitioner >

void Concurrency::_Parallel_for_each_impl	(	const _Random_iterator &	_First,
		const _Random_iterator &	_Last,
		const _Function &	_Func,
		_Partitioner &&	_Part,
		std::random_access_iterator_tag
	)

{
    typedef typename std::iterator_traits<_Random_iterator>::difference_type _Index_type;

    // Exit early if there is nothing in the collection
    if (_First >= _Last)
    {
        return;
    }

    _Index_type _Range_size = _Last - _First;

    if (_Range_size == 1)
    {
        _Func(*_First);
    }
    else
    {
        _Index_type _Step = 1;

        _Parallel_for_each_partitioned_impl(_First, _Range_size, _Step, _Func, std::forward<_Partitioner>(_Part));
   }
}

template<typename _Random_iterator , typename _Index_type , typename _Function >

void Concurrency::_Parallel_for_each_partitioned_impl	(	const _Random_iterator &	_First,
		_Index_type	_Range_arg,
		_Index_type	_Step,
		const _Function &	_Func,
		const auto_partitioner &	_Part
	)

{
    typedef _Parallel_chunk_helper<_Random_iterator, _Index_type, _Function, auto_partitioner, true> _Worker_class;
        // Use the same function that schedules work for parallel for
    _Parallel_chunk_impl<_Worker_class>(_First, _Range_arg, _Step, _Func, _Part);
}

template<typename _Random_iterator , typename _Index_type , typename _Function >

void Concurrency::_Parallel_for_each_partitioned_impl	(	const _Random_iterator &	_First,
		_Index_type	_Range_arg,
		_Index_type	_Step,
		const _Function &	_Func,
		const static_partitioner &	_Part
	)

{
    typedef _Parallel_fixed_chunk_helper<_Random_iterator, _Index_type, _Function, static_partitioner, true> _Worker_class;
    // Use the same function that schedules work for parallel for
    _Parallel_chunk_impl<_Worker_class>(_First, _Range_arg, _Step, _Func, _Part);
}

template<typename _Random_iterator , typename _Index_type , typename _Function >

void Concurrency::_Parallel_for_each_partitioned_impl	(	const _Random_iterator &	_First,
		_Index_type	_Range_arg,
		_Index_type	_Step,
		const _Function &	_Func,
		const simple_partitioner &	_Part
	)

{
    typedef _Parallel_fixed_chunk_helper<_Random_iterator, _Index_type, _Function, simple_partitioner, true> _Worker_class;
    // Use the same function that schedules work for parallel for
    _Parallel_chunk_impl<_Worker_class>(_First, _Range_arg, _Step, _Func, _Part);
}

template<typename _Random_iterator , typename _Index_type , typename _Function >

void Concurrency::_Parallel_for_each_partitioned_impl	(	const _Random_iterator &	_First,
		_Index_type	_Range_arg,
		_Index_type	_Step,
		const _Function &	_Func,
		affinity_partitioner &	_Part
	)

{
    typedef _Parallel_localized_chunk_helper<_Random_iterator, _Index_type, _Function, true> _Worker_class;
        // Use the same function that schedules work for parallel for
    _Parallel_chunk_impl<_Worker_class>(_First, _Range_arg, _Step, _Func, _Part);
}

template<typename _Index_type , typename _Function , typename _Partitioner >

void Concurrency::_Parallel_for_impl	(	_Index_type	_First,
		_Index_type	_Last,
		_Index_type	_Step,
		const _Function &	_Func,
		_Partitioner &&	_Part
	)

{
    // The step argument must be 1 or greater; otherwise it is an invalid argument
    if (_Step < 1)
    {
        throw std::invalid_argument("_Step");
    }

    // If there are no elements in this range we just return
    if (_First >= _Last)
    {
        return;
    }

    // Compute the difference type based on the arguments and avoid signed overflow for int, long, and long long
    typedef typename std::conditional<std::is_same<_Index_type, int>::value, unsigned int,
        typename std::conditional<std::is_same<_Index_type, long>::value, unsigned long,
            typename std::conditional<std::is_same<_Index_type, long long>::value, unsigned long long, decltype(_Last - _First)
            >::type
        >::type
    >::type _Diff_type;

    _Diff_type _Range_size = _Diff_type(_Last) - _Diff_type(_First);
    _Diff_type _Diff_step = _Step;

    if (_Range_size <= _Diff_step)
    {
        _Func(_First);
    }
    else
    {
        _Parallel_for_partitioned_impl<_Index_type, _Diff_type, _Function>(_First, _Range_size, _Step, _Func, std::forward<_Partitioner>(_Part));
    }
}

template<typename _Index_type , typename _Function >

void Concurrency::_Parallel_for_impl	(	_Index_type	_First,
		_Index_type	_Last,
		_Index_type	_Step,
		const _Function &	_Func
	)

{
    _Parallel_for_impl(_First, _Last, _Step, _Func, auto_partitioner());
}

template<typename _Index_type , typename _Diff_type , typename _Function >

void Concurrency::_Parallel_for_partitioned_impl	(	_Index_type	_First,
		_Diff_type	_Range_arg,
		_Diff_type	_Step,
		const _Function &	_Func,
		const auto_partitioner &	_Part
	)

{
    typedef _Parallel_chunk_helper<_Index_type, _Diff_type, _Function, auto_partitioner, false> _Worker_class;
    _Parallel_chunk_impl<_Worker_class>(_First, _Range_arg, _Step, _Func, _Part);
}

template<typename _Index_type , typename _Diff_type , typename _Function >

void Concurrency::_Parallel_for_partitioned_impl	(	_Index_type	_First,
		_Diff_type	_Range_arg,
		_Diff_type	_Step,
		const _Function &	_Func,
		const static_partitioner &	_Part
	)

{
    typedef _Parallel_fixed_chunk_helper<_Index_type, _Diff_type, _Function, static_partitioner, false> _Worker_class;
    _Parallel_chunk_impl<_Worker_class>(_First, _Range_arg, _Step, _Func, _Part);
}

template<typename _Index_type , typename _Diff_type , typename _Function >

void Concurrency::_Parallel_for_partitioned_impl	(	_Index_type	_First,
		_Diff_type	_Range_arg,
		_Diff_type	_Step,
		const _Function &	_Func,
		const simple_partitioner &	_Part
	)

{
    typedef _Parallel_fixed_chunk_helper<_Index_type, _Diff_type, _Function, simple_partitioner, false> _Worker_class;
    _Parallel_chunk_impl<_Worker_class>(_First, _Range_arg, _Step, _Func, _Part);
}

template<typename _Index_type , typename _Diff_type , typename _Function >

void Concurrency::_Parallel_for_partitioned_impl	(	_Index_type	_First,
		_Diff_type	_Range_arg,
		_Diff_type	_Step,
		const _Function &	_Func,
		affinity_partitioner &	_Part
	)

{
    typedef _Parallel_localized_chunk_helper<_Index_type, _Diff_type, _Function, false> _Worker_class;
    _Parallel_chunk_impl<_Worker_class>(_First, _Range_arg, _Step, _Func, _Part);
}

template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >

void Concurrency::_Parallel_integer_radix_sort	(	const _Random_iterator &	_Begin,
		size_t	_Size,
		const _Random_buffer_iterator &	_Output,
		size_t	_Radix,
		_Function	_Proj_func,
		const size_t	_Chunk_size,
		size_t	_Deep = 0
	)

{
    // If the chunk _Size is too small, then turn to serial least-significant-byte radix sort
    if (_Size <= _Chunk_size || _Radix < 1)
    {
        return _Integer_radix_sort(_Begin, _Size, _Output, _Radix, _Proj_func, _Deep);
    }

    size_t _Threads_num = ::Concurrency::details::_CurrentScheduler::_GetNumberOfVirtualProcessors();
    size_t _Buffer_size = sizeof(size_t) * 256 * _Threads_num;
    size_t _Step = _Size / _Threads_num;
    size_t _Remain = _Size % _Threads_num;

    ::Concurrency::details::_MallocaArrayHolder<size_t [256]> _Holder;
    size_t (*_Chunks)[256] = _Holder._InitOnRawMalloca(_malloca(_Buffer_size));

    memset(_Chunks, 0, _Buffer_size);

    // Our purpose is to map unsorted data in buffer "_Begin" to buffer "_Output" so that all elements who have the same
    // byte value in the "_Radix" position will be grouped together in the buffer "_Output"
    //
    // Serial version:
    // To understand this algorithm, first consider a serial version. In following example, we treat 1 digit as 1 byte, so we have a
    // total of 10 elements for each digit instead of 256 elements in each byte. Let's suppose "_Radix" == 1 (right most is 0), and:
    //
    //      begin:  [ 32 | 62 | 21 | 43 | 55 | 43 | 23 | 44 ]
    //
    // We want to divide the output buffer "_Output" into 10 chunks, and each the element in the "_Begin" buffer should be mapped into
    // the proper destination chunk based on its current digit (byte) indicated by "_Radix"
    //
    // Because "_Radix" == 1, after a pass of this function, the chunks in the "_Output" should look like:
    //
    //      buffer: [   |   | 21 23 | 32 | 43 43 44 | 55 | 62 |   |   |   ]
    //                0   1     2      3      4        5    6   7   8   9
    //
    // The difficulty is determining where to insert values into the "_Output" to get the above result. The way to get the
    // start position of each chunk of the buffer is:
    //      1. Count the number of elements for each chunk (in above example, chunk0 is 0, chunk1 is 0, chunk2 is 2, chunk3 is 1 ...
    //      2. Make a partial sum for these chunks( in above example,  we will get chunk0=chunk0=0, chunk1=chunk0+chunk1=0,
    //         chunk2=chunk0+chunk1+chunk2=2, chunk3=chunk0+chunk1+chunk2+chunk3=3
    //
    // After these steps, we will get the end position of each chunk in the "_Output". The begin position of each chunk will be the end
    // point of last chunk (begin point is close but the end point is open). After that,  we can scan the original array again and directly
    // put elements from original buffer "_Begin" into specified chunk on buffer "_Output".
    // Finally, we invoke _parallel_integer_radix_sort in parallel for each chunk and sort them in parallel based on the next digit (byte).
    // Because this is a STABLE sort algorithm, if two numbers has same key value on this byte (digit), their original order should be kept.
    //
    // Parallel version:
    // Almost the same as the serial version, the differences are:
    //      1. The count for each chunk is executed in parallel, and each thread will count one segment of the input buffer "_Begin".
    //         The count result will be separately stored in their own chunk size counting arrays so we have a total of threads-number
    //         of chunk count arrays.
    //         For example, we may have chunk00, chunk01, ..., chunk09 for first thread, chunk10, chunk11, ..., chunk19 for second thread, ...
    //      2. The partial sum should be executed across these chunk counting arrays that belong to different threads, instead of just
    //         making a partial sum in one counting array.
    //         This is because we need to put values from different segments into one final buffer, and the absolute buffer position for
    //         each chunkXX is needed.
    //      3. Make a parallel scan for original buffer again, and move numbers in parallel into the corresponding chunk on each buffer based
    //         on these threads' chunk size counters.

    // Count in parallel and separately save their local results without reducing
    ::Concurrency::parallel_for(static_cast<size_t>(0), _Threads_num, [=](size_t _Index)
    {
        size_t _Beg_index, _End_index;

        // Calculate the segment position
        if (_Index < _Remain)
        {
            _Beg_index = _Index * (_Step + 1);
            _End_index = _Beg_index + (_Step + 1);
        }
        else
        {
            _Beg_index = _Remain * (_Step + 1) + (_Index - _Remain) * _Step;
            _End_index = _Beg_index + _Step;
        }

        // Do a counting
        while (_Beg_index != _End_index)
        {
            ++_Chunks[_Index][_Radix_key(_Begin[_Beg_index++], _Radix, _Proj_func)];
        }
    });

    int _Index = -1, _Count = 0;

    // Partial sum cross different threads' chunk counters
    for (int _I = 0; _I < 256; _I++)
    {
        size_t _Last = _I ? _Chunks[_Threads_num - 1][_I - 1] : 0;
        _Chunks[0][_I] += _Last;

        for (size_t _J = 1; _J < _Threads_num; _J++)
        {
            _Chunks[_J][_I] += _Chunks[_J - 1][_I];
        }

        // "_Chunks[_Threads_num - 1][_I] - _Last" will get the global _Size for chunk _I(including all threads local _Size for chunk _I)
        // this will chunk whether the chunk _I is empty or not. If it's not empty, it will be recorded.
        if (_Chunks[_Threads_num - 1][_I] - _Last)
        {
            ++_Count;
            _Index = _I;
        }
    }

    // If there is more than 1 chunk that has content, then continue the original algorithm
    if (_Count > 1)
    {
        // Move the elements in parallel into each chunk
        ::Concurrency::parallel_for(static_cast<size_t>(0), _Threads_num, [=](size_t _Index)
        {
            size_t _Beg_index, _End_index;

            // Calculate the segment position
            if (_Index < _Remain)
            {
                _Beg_index = _Index * (_Step + 1);
                _End_index = _Beg_index + (_Step + 1);
            }
            else
            {
                _Beg_index = _Remain * (_Step + 1) + (_Index - _Remain) * _Step;
                _End_index = _Beg_index + _Step;
            }

            // Do a move operation to directly put each value into its destination chunk
            // Chunk pointer is moved after each put operation.
            if (_Beg_index != _End_index--)
            {
                while (_Beg_index != _End_index)
                {
                    _Output[--_Chunks[_Index][_Radix_key(_Begin[_End_index], _Radix, _Proj_func)]] = std::move(_Begin[_End_index]);
                    --_End_index;
                }
                _Output[--_Chunks[_Index][_Radix_key(_Begin[_End_index], _Radix, _Proj_func)]] = std::move(_Begin[_End_index]);
            }
        });

        // Invoke _parallel_integer_radix_sort in parallel for each chunk
        ::Concurrency::parallel_for(static_cast<size_t>(0), static_cast<size_t>(256), [=](size_t _Index)
        {
            if (_Index < 256 - 1)
            {
                _Parallel_integer_radix_sort(_Output + _Chunks[0][_Index], _Chunks[0][_Index + 1] - _Chunks[0][_Index],
                    _Begin + _Chunks[0][_Index], _Radix - 1, _Proj_func, _Chunk_size, _Deep + 1);
            }
            else
            {
                _Parallel_integer_radix_sort(_Output + _Chunks[0][_Index], _Size - _Chunks[0][_Index],
                    _Begin + _Chunks[0][_Index], _Radix - 1, _Proj_func, _Chunk_size, _Deep + 1);
            }
        });
    }
    else
    {
        // Only one chunk has content
        // A special optimization is applied because one chunk means all numbers have a same value on this particular byte (digit).
        // Because we cannot sort them at all (they are all equal at this point), directly call _parallel_integer_radix_sort to
        // sort next byte (digit)
        _Parallel_integer_radix_sort(_Begin, _Size, _Output, _Radix - 1, _Proj_func, _Chunk_size, _Deep);
    }
}

template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >

void Concurrency::_Parallel_integer_sort_asc	(	const _Random_iterator &	_Begin,
		size_t	_Size,
		const _Random_buffer_iterator &	_Output,
		_Function	_Proj_func,
		const size_t	_Chunk_size
	)

{
    typedef typename std::iterator_traits<_Random_iterator>::value_type _Value_type;
    // The key type of the radix sort, this must be an "unsigned integer-like" type, that is, it needs support:
    //     operator>> (int), operator>>= (int), operator& (int), operator <, operator size_t ()
    typedef typename std::remove_const<typename std::remove_reference<decltype(_Proj_func(*_Begin))>::type>::type _Integer_type;

    // Find out the max value, which will be used to determine the highest differing byte (the radix position)
    _Integer_type _Max_val = ::Concurrency::parallel_reduce(_Begin, _Begin + _Size, _Proj_func(*_Begin),
        [=](_Random_iterator _Begin, _Random_iterator _End, _Integer_type _Init) -> _Integer_type
        {
            while (_Begin != _End)
            {
                _Integer_type _Ret = _Proj_func(*_Begin++);
                if (_Init < _Ret)
                {
                    _Init = _Ret;
                }
            }

            return _Init;
        }, [](const _Integer_type &_A, const _Integer_type &_B) -> const _Integer_type& {return (_A < _B)? _B : _A;});
    size_t _Radix = 0;

    // Find out highest differing byte
    while (_Max_val >>= 8)
    {
        ++_Radix;
    }

    _Parallel_integer_radix_sort(_Begin, _Size, _Output, _Radix, _Proj_func, _Chunk_size);
}

template<typename _Function1 , typename _Function2 >

void Concurrency::_Parallel_invoke_impl	(	const _Function1 &	_Func1,
		const _Function2 &	_Func2
	)

{
    structured_task_group _Task_group;

    task_handle<_Function1> _Task_handle1(_Func1);
    _Task_group.run(_Task_handle1);

    // We inline the last item to prevent the unnecessary push/pop on the work queue.
    task_handle<_Function2> _Task_handle2(_Func2);
    _Task_group.run_and_wait(_Task_handle2);
}

template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Random_output_iterator , typename _Function >

void Concurrency::_Parallel_merge	(	_Random_iterator	_Begin1,
		size_t	_Len1,
		_Random_buffer_iterator	_Begin2,
		size_t	_Len2,
		_Random_output_iterator	_Output,
		const _Function &	_Func,
		size_t	_Div_num
	)

{
    // Turn to serial merge or continue splitting chunks base on "_Div_num"
    if (_Div_num <= 1 || (_Len1 <= 1 && _Len2 <= 1))
    {
        _Merge_chunks(_Begin1, _Begin1 + _Len1, _Begin2, _Begin2 + _Len2, _Output, _Func);
    }
    else
    {
        size_t _Mid_len1 = _Len1, _Mid_len2 = _Len2;
        size_t _Mid = _Search_mid_point(_Begin1, _Mid_len1, _Begin2, _Mid_len2, _Func);

        structured_task_group _Tg;
        auto _Handle = make_task([&]
        {
            _Parallel_merge(_Begin1, _Mid_len1, _Begin2, _Mid_len2, _Output, _Func, _Div_num / 2);
        });
        _Tg.run(_Handle);

        _Parallel_merge(_Begin1 + _Mid_len1, _Len1 - _Mid_len1, _Begin2 + _Mid_len2, _Len2 - _Mid_len2, _Output + _Mid, _Func, _Div_num / 2);

        _Tg.wait();
    }
}

template<typename _Random_iterator , typename _Function >

void Concurrency::_Parallel_quicksort_impl	(	const _Random_iterator &	_Begin,
		size_t	_Size,
		const _Function &	_Func,
		size_t	_Div_num,
		const size_t	_Chunk_size,
		int	_Depth
	)

{
    if (_Depth >= _SORT_MAX_RECURSION_DEPTH || _Size <= _Chunk_size || _Size <= static_cast<size_t>(3) || _Chunk_size >= _FINE_GRAIN_CHUNK_SIZE && _Div_num <= 1)
    {
        return std::sort(_Begin, _Begin + _Size, _Func);
    }

    // Determine whether we need to do a three-way quick sort
    // We benefit from three-way merge if there are a lot of elements that are EQUAL to the median value,
    // _Select_median_pivot function will test redundant density by sampling
    bool _Is_three_way_split = false;
    size_t _Mid_index = _Select_median_pivot(_Begin, _Size, _Func, _Chunk_size, _Is_three_way_split);

    // Move the median value to the _Begin position.
    if (_Mid_index)
    {
        std::swap(*_Begin, _Begin[_Mid_index]);
    }
    size_t _I = 1, _J = _Size - 1;

    // Three-way or two-way partition
    // _Div_num < _MAX_NUM_TASKS_PER_CORE is checked to make sure it will never do three-way split before splitting enough tasks
    if (_Is_three_way_split && _Div_num < _MAX_NUM_TASKS_PER_CORE)
    {
        while (_Func(*_Begin, _Begin[_J]))
        {
            --_J;
        }

        while (_Func(_Begin[_I], *_Begin))
        {
            ++_I;
        }

        // Starting from this point, left side of _I will less than median value, right side of _J will be greater than median value,
        // and the middle part will be equal to median. _K is used to scan between _I and _J
        size_t _K = _J;
        while (_I <= _K)
        {
            if (_Func(_Begin[_K], *_Begin))
            {
                std::swap(_Begin[_I++], _Begin[_K]);
            }
            else
            {
                --_K;
            }

            while (_Func(*_Begin, _Begin[_K]))
            {
                std::swap(_Begin[_K--], _Begin[_J--]);
            }
        }

        ++_J;
    }
    else
    {
        while (_I <= _J)
        {
            // Will stop before _Begin
            while (_Func(*_Begin, _Begin[_J]))
            {
                --_J;
            }

            // There must be another element equal or greater than *_Begin
            while (_Func(_Begin[_I], *_Begin))
            {
                ++_I;
            }

            if (_I < _J)
            {
                std::swap(_Begin[_I++], _Begin[_J--]);
            }
            else
            {
                break;
            }
        }

        _I = ++_J;
    }

    std::swap(*_Begin, _Begin[--_I]);

    structured_task_group _Tg;
    volatile size_t _Next_div = _Div_num / 2;
    auto _Handle = make_task([&]
    {
        _Parallel_quicksort_impl(_Begin + _J, _Size - _J, _Func, _Next_div, _Chunk_size, _Depth+1);
    });
    _Tg.run(_Handle);

    _Parallel_quicksort_impl(_Begin, _I, _Func, _Next_div, _Chunk_size, _Depth+1);

    // If at this point, the work hasn't been scheduled, then slow down creating new tasks
    if (_Div_num < _MAX_NUM_TASKS_PER_CORE)
    {
        _Next_div /= 2;
    }

    _Tg.wait();
}

template<typename _Forward_iterator , typename _Function >

void Concurrency::_Parallel_reduce_forward_executor	(	_Forward_iterator	_First,
		_Forward_iterator	_Last,
		const _Function &	_Func,
		task_group &	_Task_group
	)

{
    const static int _Internal_worker_number = 1024, _Default_chunk_size = 512;
    typedef _Parallel_reduce_fixed_worker<_Forward_iterator, _Function> _Worker_class;

    structured_task_group _Worker_group;
    ::Concurrency::details::_MallocaArrayHolder<task_handle<_Worker_class>> _Holder;
    task_handle<_Worker_class>* _Workers = _Holder._InitOnRawMalloca(_malloca(_Internal_worker_number * sizeof(task_handle<_Worker_class>)));

    // Start execution first
    int _Index = 0;
    while (_Index < _Internal_worker_number && _First != _Last)
    {
        // Copy the range _Head
        _Forward_iterator _Head = _First;

        // Read from forward iterator
        for (size_t _I = 0; _I < _Default_chunk_size && _First != _Last; ++_I, ++_First)
        {
            // Body is empty
        };

        // Create a new task, _First is range _End
        new (_Workers + _Index) task_handle<_Worker_class>(_Worker_class(_Head, _First, _Func));
        _Holder._IncrementConstructedElemsCount();
        _Worker_group.run(_Workers[_Index]);
        ++_Index;
    }

    // Divide and append the left
    while (_First != _Last)
    {
        _Task_group.run(_Parallel_reduce_forward_executor_helper<_Forward_iterator, _Function, _Internal_worker_number, _Default_chunk_size>(_First, _Last, _Func));
    }

    _Worker_group.wait();
}

template<typename _Forward_iterator , typename _Function >

_Function::_Reduce_type Concurrency::_Parallel_reduce_impl	(	_Forward_iterator	_First,
		const _Forward_iterator &	_Last,
		const _Function &	_Func,
		std::forward_iterator_tag
	)

{
    // Because this is a forward iterator, it is difficult to validate that _First comes before _Last, so
    // it is up to the user to provide valid range.
    if (_First != _Last)
    {
        task_group _Task_group;
        _Parallel_reduce_forward_executor(_First, _Last, _Func, _Task_group);
        _Task_group.wait();
        return _Func._Combinable._Serial_combine_release();
    }
    else
    {
        return _Func._Identity_value;
    }
}

template<typename _Random_iterator , typename _Function >

_Function::_Reduce_type Concurrency::_Parallel_reduce_impl	(	_Random_iterator	_First,
		_Random_iterator	_Last,
		const _Function &	_Func,
		std::random_access_iterator_tag
	)

{
    typedef _Parallel_reduce_fixed_worker<_Random_iterator, _Function> _Worker_class;

    // Special case for 0, 1 element
    if (_First >= _Last)
    {
        return _Func._Identity_value;
    }
    // Directly compute if size is too small
    else if (_Last - _First <= 1)
    {
        _Worker_class(_First, _Last, _Func)();
        return _Func._Combinable._Serial_combine_release();
    }
    else
    {
        // Use fixed ordered chunk partition to schedule works
        _Parallel_reduce_random_executor<_Worker_class>(_First, _Last, _Func);
        return _Func._Combinable._Serial_combine_release();
    }
}

template<typename _Worker , typename _Random_iterator , typename _Function >

void Concurrency::_Parallel_reduce_random_executor	(	_Random_iterator	_Begin,
		_Random_iterator	_End,
		const _Function &	_Fun
	)

{
    size_t _Cpu_num = static_cast<size_t>(::Concurrency::details::_CurrentScheduler::_GetNumberOfVirtualProcessors()), _Size = _End - _Begin;

    structured_task_group _Tg;
    ::Concurrency::details::_MallocaArrayHolder<task_handle<_Worker>> _Holder;
    task_handle<_Worker> *_Tasks = _Holder._InitOnRawMalloca(_malloca(sizeof(task_handle<_Worker>) * (_Cpu_num - 1)));

    size_t _Begin_index = 0;
    size_t _Step = _Size / _Cpu_num;
    size_t _NumRemaining = _Size - _Step * _Cpu_num;

    for(size_t _I = 0; _I < _Cpu_num - 1; _I++)
    {
        size_t _Next = _Begin_index + _Step;

        // Add remaining to each chunk
        if (_NumRemaining)
        {
            --_NumRemaining;
            ++_Next;
        }

        // New up a task_handle "in-place", in the array preallocated on the stack
        new (_Tasks + _I) task_handle<_Worker>(_Worker(_Begin + _Begin_index, _Begin + _Next, _Fun));
        _Holder._IncrementConstructedElemsCount();

        // Run each of the chunk _Tasks in parallel
        _Tg.run(_Tasks[_I]);
        _Begin_index = _Next;
    }

    task_handle<_Worker> _Tail(_Worker(_Begin + _Begin_index, _End, _Fun));
    _Tg.run_and_wait(_Tail);
}

template<typename _Input_iterator1 , typename _Input_iterator2 , typename _Output_iterator , typename _Binary_operator >

void Concurrency::_Parallel_transform_binary_impl2	(	_Input_iterator1	_First1,
		_Input_iterator1	_Last1,
		_Input_iterator2	_First2,
		_Output_iterator &	_Result,
		const _Binary_operator&	_Binary_op,
		task_group &	_Tg
	)

{
    // This functor will be copied on the heap and will execute the chunk in parallel
    {
        _Parallel_transform_binary_helper<_Input_iterator1, _Input_iterator2, _Output_iterator, _Binary_operator> _Functor(_First1, _Last1, _First2, _Result, _Binary_op);
        _Tg.run(_Functor);
    }

    // If there is a tail, push the tail
    if (_First1 != _Last1)
    {
        _Tg.run(
            [=, &_Result, &_Binary_op, &_Tg]
            {
                _Parallel_transform_binary_impl2(_First1, _Last1, _First2, _Result, _Binary_op, _Tg);
            });
    }
}

template<typename _Input_iterator , typename _Output_iterator , typename _Unary_operator , typename _Partitioner >

_Output_iterator Concurrency::_Parallel_transform_unary_impl	(	_Input_iterator	_First,
		_Input_iterator	_Last,
		_Output_iterator	_Result,
		const _Unary_operator&	_Unary_op,
		_Partitioner &&	_Part
	)

{
    typedef typename std::iterator_traits<_Input_iterator>::iterator_category _Input_iterator_type;
    typedef typename std::iterator_traits<_Output_iterator>::iterator_category _Output_iterator_type;

    if (_First != _Last)
    {
        _Unary_transform_impl_helper<_Input_iterator_type, _Output_iterator_type>
            ::_Parallel_transform_unary_impl(_First, _Last, _Result, _Unary_op, std::forward<_Partitioner>(_Part));
    }

    return _Result;
}

template<typename _Input_iterator , typename _Output_iterator , typename _Unary_operator >

void Concurrency::_Parallel_transform_unary_impl2	(	_Input_iterator	_First,
		_Input_iterator	_Last,
		_Output_iterator &	_Result,
		const _Unary_operator&	_Unary_op,
		task_group &	_Tg
	)

{
    // This functor will be copied on the heap and will execute the chunk in parallel
    {
        _Parallel_transform_unary_helper<_Input_iterator, _Output_iterator, _Unary_operator> _Functor(_First, _Last, _Result, _Unary_op);
        _Tg.run(_Functor);
    }

    // If there is a tail, push the tail
    if (_First != _Last)
    {
        _Tg.run(
            [=, &_Result, &_Unary_op, &_Tg]
            {
                _Parallel_transform_unary_impl2(_First, _Last, _Result, _Unary_op, _Tg);
            });
    }
}

template<typename _Ty , typename _Function >

size_t Concurrency::_Radix_key ( const _Ty &  _Val, size_t  _Radix, _Function  _Proj_func  )

inline

{
    return static_cast<size_t>(_Proj_func(_Val) >> static_cast<int>(8 * _Radix) & 255);
}

template<class _Type >

_Type Concurrency::_Receive_impl	(	ISource< _Type > *	_Src,
		unsigned int	_Timeout,
		typename ITarget< _Type >::filter_method const *	_Filter_proc
	)

A general receive implementation, allowing a context to wait for data from exactly one source and filter the values that are accepted. If the specified timeout is not COOPERATIVE_TIMEOUT_INFINITE, an exception (operation_timed_out) will be thrown if the specified amount of time expires before a message is received. Note that zero length timeouts should likely use try_receive as opposed to receive with a timeout of zero as it is more efficient and does not throw exceptions on timeouts.

Template Parameters

_Type

The payload type

Parameters

_Src	A pointer to the source from which data is expected.
_Timeout	The maximum time for which the method should for the data, in milliseconds.
_Filter_proc	A pointer to a filter which will indicate whether to accept the data or not.

Returns

A value from the source, of the payload type.

{
    // The Blocking Recipient messaging block class is internal to the receive function
    class _Blocking_recipient : public ITarget<_Type>
    {
    public:
        // Create an Blocking Recipient
        _Blocking_recipient(ISource<_Type> * _PSource,
            unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE) :
            _M_pFilter(NULL), _M_pConnectedTo(NULL), _M_pMessage(NULL), _M_fState(_NotInitialized), _M_timeout(_Timeout)
        {
            _Connect(_PSource);
        }

        // Create an Blocking Recipient
        _Blocking_recipient(ISource<_Type> * _PSource,
            filter_method const& _Filter,
            unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE) :
            _M_pFilter(NULL), _M_pConnectedTo(NULL), _M_pMessage(NULL), _M_fState(_NotInitialized), _M_timeout(_Timeout)
        {
            if (_Filter != NULL)
            {
                _M_pFilter = new filter_method(_Filter);
            }

            _Connect(_PSource);
        }

        // Cleans up any resources that may have been created by the BlockingRecipient.
        ~_Blocking_recipient()
        {
            _Disconnect();

            delete _M_pFilter;
            delete _M_pMessage;
        }

        // Gets the value of the message sent to this BlockingRecipient.  Blocks by
        // spinning until a message has arrived.
        _Type _Value()
        {
            _Wait_for_message();

            return _M_pMessage->payload;
        }

        // The main propagation function for ITarget blocks.  Called by a source
        // block, generally within an asynchronous task to send messages to its targets.
        virtual message_status propagate(message<_Type> * _PMessage, ISource<_Type> * _PSource)
        {
            // Throw exception if the message being propagated to this block is NULL
            if (_PMessage == NULL)
            {
                throw std::invalid_argument("_PMessage");
            }

            if (_PSource == NULL)
            {
                throw std::invalid_argument("_PSource");
            }

            // Reject if the recipient has already received a message
            if (_M_fState == _Initialized)
            {
                return declined;
            }

            // Reject if the message does not meet the filter requirements
            if (_M_pFilter != NULL && !(*_M_pFilter)(_PMessage->payload))
            {
                return declined;
            }

            // Accept the message
            _CONCRT_ASSERT(_PSource != NULL);
            _M_pMessage = _PSource->accept(_PMessage->msg_id(), this);

            if (_M_pMessage != NULL)
            {
                // Set the initialized flag on this block
                if (_InterlockedExchange(&_M_fState, _Initialized) == _Blocked)
                {
                    _M_ev.set();
                }

                return accepted;
            }

            return missed;
        }

        // Synchronously sends a message to this block.  When this function completes the message will
        // already have propagated into the block.
        virtual message_status send(message<_Type> * _PMessage, ISource<_Type> * _PSource)
        {
            if (_PMessage == NULL)
            {
                throw std::invalid_argument("_PMessage");
            }

            if (_PSource == NULL)
            {
                throw std::invalid_argument("_PSource");
            }

            // Only the connected source is allowed to send messages
            // to the blocking recipient. Decline messages without
            // a source.

            return declined;
        }

    private:

        // Link a source block
        virtual void link_source(ISource<_Type> * _PSrc)
        {
            _M_pConnectedTo = _PSrc;
            _PSrc->acquire_ref(this);
        }

        // Remove a source messaging block for this BlockingRecipient
        virtual void unlink_source(ISource<_Type> * _PSource)
        {
            if (_InterlockedCompareExchangePointer(reinterpret_cast<void *volatile *>(&_M_pConnectedTo), (void *)NULL, _PSource) == _PSource)
            {
                _PSource->release_ref(this);
            }
        }

        // Remove the source messaging block for this BlockingRecipient
        virtual void unlink_sources()
        {
            ISource<_Type> * _PSource = reinterpret_cast<ISource<_Type> *>(_InterlockedExchangePointer(reinterpret_cast<void *volatile *>(&_M_pConnectedTo), (void *)NULL));
            if (_PSource != NULL)
            {
                _PSource->unlink_target(this);
                _PSource->release_ref(this);
            }
        }


        // Connect the blocking recipient to the source
        void _Connect(ISource<_Type> * _PSource)
        {
            if (_PSource == NULL)
            {
                throw std::invalid_argument("_PSource");
            }

            _PSource->link_target(this);
        }

        // Cleanup the connection to the blocking recipient's source. There is no need
        // to do anything about the associated context.
        void _Disconnect()
        {
            unlink_sources();
        }

        // Internal function used to block while waiting for a message to arrive
        // at this BlockingRecipient
        void _Wait_for_message()
        {
            bool _Timeout = false;

            // If we haven't received a message yet, cooperatively block.
            if (_InterlockedCompareExchange(&_M_fState, _Blocked, _NotInitialized) == _NotInitialized)
            {
                if (_M_ev.wait(_M_timeout) == COOPERATIVE_WAIT_TIMEOUT)
                {
                    _Timeout = true;
                }
            }

            // Unlinking from our source guarantees that there are no threads in propagate
            _Disconnect();

            if (_M_fState != _Initialized)
            {
                // We had to have timed out if we came out of the wait
                // without being initialized.
                _CONCRT_ASSERT(_Timeout);

                throw operation_timed_out();
            }
        }

        // States for this block
        enum
        {
            _NotInitialized,
            _Blocked,
            _Initialized
        };

        volatile long _M_fState;

        // The source messaging block connected to this Recipient
        ISource<_Type> * _M_pConnectedTo;

        // The message that was received
        message<_Type> * volatile _M_pMessage;

        // The timeout.
        unsigned int _M_timeout;

        // The event we wait upon
        event _M_ev;

        // The filter that is called on this block before accepting a message
        filter_method * _M_pFilter;
    };

    if (_Filter_proc != NULL)
    {
        _Blocking_recipient _Recipient(_Src, *_Filter_proc, _Timeout);
        return _Recipient._Value();
    }
    else
    {
        _Blocking_recipient _Recipient(_Src, _Timeout);
        return _Recipient._Value();
    }
}

template<typename _Random_iterator , typename _Random_buffer_iterator , typename _Function >

size_t Concurrency::_Search_mid_point	(	const _Random_iterator &	_Begin1,
		size_t &	_Len1,
		const _Random_buffer_iterator &	_Begin2,
		size_t &	_Len2,
		const _Function &	_Func
	)

{
    size_t _Len = (_Len1 + _Len2) / 2, _Index1 = 0, _Index2 = 0;

    while (_Index1 < _Len1 && _Index2 < _Len2)
    {
        size_t _Mid1 = (_Index1 + _Len1) / 2, _Mid2 = (_Index2 + _Len2) / 2;
        if (_Func(_Begin1[_Mid1], _Begin2[_Mid2]))
        {
            if (_Mid1 + _Mid2 < _Len)
            {
                _Index1 = _Mid1 + 1;
            }
            else
            {
                _Len2 = _Mid2;
            }
        }
        else
        {
            if (_Mid1 + _Mid2 < _Len)
            {
                _Index2 = _Mid2 + 1;
            }
            else
            {
                _Len1 = _Mid1;
            }
        }
    }

    if (_Index1 == _Len1)
    {
        _Len2 = _Len - _Len1;
    }
    else
    {
        _Len1 = _Len - _Len2;
    }

    return _Len;
}

template<typename _Random_iterator , typename _Function >

size_t Concurrency::_Select_median_pivot ( const _Random_iterator &  _Begin, size_t  _Size, const _Function &  _Func, const size_t  _Chunk_size, bool &  _Potentially_equal  )

inline

{
    // Base on different chunk size, apply different sampling optimization
    if (_Chunk_size < _FINE_GRAIN_CHUNK_SIZE && _Size <= std::max<size_t>(_Chunk_size * 4, static_cast<size_t>(15)))
    {
        bool _Never_care_equal;
        return _Median_of_three(_Begin, 0, _Size / 2, _Size - 1, _Func, _Never_care_equal);
    }
    else
    {
        return _Median_of_nine(_Begin, _Size, _Func, _Potentially_equal);
    }
}

_CONCRTIMP void __cdecl Concurrency::_Trace_agents	(	Agents_EventType	_Type,
		__int64	_AgentId,
			...
	)

_CONCRTIMP void __cdecl Concurrency::_Trace_ppl_function	(	const GUID &	_Guid,
		unsigned char	_Level,
		ConcRT_EventType	_Type
	)

template<class _Type >

bool Concurrency::_Try_receive_impl	(	ISource< _Type > *	_Src,
		_Type &	_value,
		typename ITarget< _Type >::filter_method const *	_Filter_proc
	)

Helper function that implements try_receive A general try-receive implementation, allowing a context to look for data from exactly one source and filter the values that are accepted. If the data is not ready, try_receive will return false.

Template Parameters

_Type

The payload type

Parameters

_Src	A pointer to the source from which data is expected.
_value	A reference to a location where the result will be placed.
_Filter_proc	A pointer to a filter which will indicate whether to accept the data or not.

Returns

A bool indicating whether a payload was placed in _value or not.

{
    // The Immediate Recipient messaging block class is internal to the receive function
    class _Immediate_recipient : public ITarget<_Type>
    {
    public:
        // Create an Immediate Recipient
        _Immediate_recipient(ISource<_Type> * _PSource) :
            _M_pFilter(NULL), _M_pConnectedTo(NULL), _M_pMessage(NULL), _M_isInitialized(0)
        {
            _Connect(_PSource);
        }

        // Create an Immediate Recipient
        _Immediate_recipient(ISource<_Type> * _PSource,
            filter_method const& _Filter) :
            _M_pFilter(NULL), _M_pConnectedTo(NULL), _M_pMessage(NULL), _M_isInitialized(0)
        {
            if (_Filter != NULL)
            {
                _M_pFilter = new filter_method(_Filter);
            }

            _Connect(_PSource);
        }

        // Cleans up any resources that may have been created by the ImmediateRecipient.
        ~_Immediate_recipient()
        {
            _Disconnect();

            delete _M_pFilter;
            delete _M_pMessage;
        }

        // Gets the value of the message sent to this ImmediateRecipient.
        bool _Value(_Type & _value)
        {
            // Unlinking from our source guarantees that there are no threads in propagate
            _Disconnect();

            if (_M_pMessage != NULL)
            {
                _value = _M_pMessage->payload;
                return true;
            }

            return false;
        }

        // The main propagation function for ITarget blocks.  Called by a source
        // block, generally within an asynchronous task to send messages to its targets.
        virtual message_status propagate(message<_Type> * _PMessage, ISource<_Type> * _PSource)
        {
            message_status _Result = accepted;

            // Throw exception if the message being propagated to this block is NULL
            if (_PMessage == NULL)
            {
                throw std::invalid_argument("_PMessage");
            }

            if (_PSource == NULL)
            {
                throw std::invalid_argument("_PSource");
            }

            // Reject if the recipient has already received a message
            if (_M_isInitialized == 1)
            {
                return declined;
            }

            // Reject if the message does not meet the filter requirements
            if (_M_pFilter != NULL && !(*_M_pFilter)(_PMessage->payload))
            {
                return declined;
            }

            // Accept the message
            _CONCRT_ASSERT(_PSource != NULL);
            _M_pMessage = _PSource->accept(_PMessage->msg_id(), this);

            // Set the initialized flag on this block

            if (_M_pMessage != NULL)
            {
                // Fence to ensure that the above update to _M_pMessage is visible
                _InterlockedExchange(&_M_isInitialized, 1);
                _Result = accepted;
            }
            else
            {
                _Result = missed;
            }

            return _Result;
        }


        // Synchronously sends a message to this block.  When this function completes the message will
        // already have propagated into the block.
        virtual message_status send(message<_Type> * _PMessage, ISource<_Type> * _PSource)
        {
            if (_PMessage == NULL)
            {
                throw std::invalid_argument("_PMessage");
            }

            if (_PSource == NULL)
            {
                throw std::invalid_argument("_PSource");
            }

            // Only the connected source is allowed to send messages
            // to the blocking recipient. Decline messages without
            // a source.

            return declined;
        }

    private:

        // Add a source messaging block
        virtual void link_source(ISource<_Type> * _PSrc)
        {
            _M_pConnectedTo = _PSrc;
            _PSrc->acquire_ref(this);
        }

        // Remove a source messaging block for this BlockingRecipient
        virtual void unlink_source(ISource<_Type> * _PSource)
        {
            if (_InterlockedCompareExchangePointer(reinterpret_cast<void *volatile *>(&_M_pConnectedTo), (void *)NULL, _PSource) == _PSource)
            {
                _PSource->release_ref(this);
            }
        }

        // Remove the source messaging block for this BlockingRecipient
        virtual void unlink_sources()
        {
            ISource<_Type> * _PSource = reinterpret_cast<ISource<_Type> *>(_InterlockedExchangePointer(reinterpret_cast<void *volatile *>(&_M_pConnectedTo), (void *)NULL));
            if (_PSource != NULL)
            {
                _PSource->unlink_target(this);
                _PSource->release_ref(this);
            }
        }

        // Connect to a source block
        void _Connect(ISource<_Type> * _PSource)
        {
            if (_PSource == NULL)
            {
                throw std::invalid_argument("_PSource");
            }

            _CONCRT_ASSERT(_M_isInitialized == 0);

            _PSource->link_target(this);
        }

        //
        // Cleanup the connection to the trigger's source. There is no need
        // to do anything about the associated context.
        //
        void _Disconnect()
        {
            unlink_sources();
        }

        // The source messaging block connected to this Recipient
        ISource<_Type> * _M_pConnectedTo;

        // The message that was received
        message<_Type> * volatile _M_pMessage;

        // A flag for whether or not this block has been initialized with a value
        volatile long _M_isInitialized;

        // The filter that is called on this block before accepting a message
        filter_method * _M_pFilter;
    };

    if (_Filter_proc != NULL)
    {
        _Immediate_recipient _Recipient(_Src, *_Filter_proc);
        return _Recipient._Value(_value);
    }
    else
    {
        _Immediate_recipient _Recipient(_Src);
        return _Recipient._Value(_value);
    }
}

void Concurrency::all_memory_fence ( const tile_barrier &  _Barrier )

inline

Memory fences and tile barriers.

Ensures that memory accesses are visible to other threads in the thread tile, and are executed according to program order

Parameters

_Barrier

A tile_barrier object

{
    __dp_d3d_all_memory_fence();
}

_CONCRTIMP void* __cdecl Concurrency::Alloc

(

size_t

_NumBytes

)

Allocates a block of memory of the size specified from the Concurrency Runtime Caching Suballocator.

Parameters

_NumBytes

The number of bytes of memory to allocate.

Returns

A pointer to newly allocated memory.

For more information about which scenarios in your application could benefit from using the Caching Suballocator, see Task Scheduler (Concurrency Runtime).

See also

Concurrency::Free Function

_AMPIMP void __cdecl Concurrency::amp_uninitialize

(

)

Uninitializes the C++ AMP runtime. It is legal to call this function multiple times during an applications lifetime. Calling any C++ AMP API afer calling this function will reinitialize the C++ AMP runtime. Note that it is illegal to use C++ AMP objects across calls to this function and doing so will result in undefined behavior. Also, concurrently calling this function and any other AMP APIs is illegal and would result in undefined behavior.

template<class _Type >

bool Concurrency::asend	(	_Inout_ ITarget< _Type > *	_Trg,
		const _Type &	_Data
	)

An asynchronous send operation, which schedules a task to propagate the data to the target block.

Template Parameters

_Type

The type of the data to be sent.

Parameters

_Trg	A pointer or reference to the target to which data is sent.
_Data	A reference to the data to be sent.

Returns

true if the message was accepted before the method returned, false otherwise.

For more information, see Message Passing Functions.

See also

receive Function, try_receive Function, send Function

{
    return details::_Originator::_asend(_Trg, _Data);
}

template<class _Type >

bool Concurrency::asend	(	ITarget< _Type > &	_Trg,
		const _Type &	_Data
	)

An asynchronous send operation, which schedules a task to propagate the value to the target block.

Template Parameters

_Type

The type of the data to be sent.

Parameters

_Trg	A pointer or reference to the target to which data is sent.
_Data	A reference to the data to be sent.

Returns

true if the message was accepted, false otherwise.

For more information, see Message Passing Functions.

See also

receive Function, try_receive Function, send Function

{
    return ::Concurrency::asend(&_Trg, _Data);
}

bool Concurrency::atomic_compare_exchange ( _Inout_ int *  _Dest, _Inout_ int *  _Expected_value, int  _Value  )

inline

Atomically, compares the value pointed to by _Dest for equality with that pointed to by _Expected_value, and if true, returns true and replaces the value with _Value, and if false, returns false and updates the value pointed to by _Expected_value with the value pointed to by _Dest

Parameters

_Dest	Pointer to the destination location
_Expected_value	Pointer to the the value being compared to the value pointed to by _Dest. If the comparison is unsuccessful, the value is updated with the value pointed to by _Dest
_Value	The value to be stored to the location pointed to by _Dest if the comparison is successful

Returns

If the operation is successful, return true. Otherwise, false

{
    int _Old = *_Expected_value;
    unsigned int _Ret = __dp_d3d_interlocked_compare_exchange(AS_UINT_PTR(_Dest), AS_UINT(_Value), AS_UINT(_Old));
    if (_Ret == AS_UINT(_Old)) 
    {
        return true;
    }
    else 
    {
        *_Expected_value = AS_INT(_Ret);
        return false;
    }
}

bool Concurrency::atomic_compare_exchange ( _Inout_ unsigned int *  _Dest, _Inout_ unsigned int *  _Expected_value, unsigned int  _Value  )

inline

Atomically, compares the value pointed to by _Dest for equality with that pointed to by _Expected_value, and if true, returns true and replaces the value with _Value, and if false, returns false and updates the value pointed to by _Expected_value with the value pointed to by _Dest

Parameters

_Dest	Pointer to the destination location
_Expected_value	Pointer to the the value being compared to the value pointed to by _Dest. If the comparison is unsuccessful, the value is updated with the value pointed to by _Dest
_Value	The value to be stored to the location pointed to by _Dest if the comparison is successful

Returns

If the operation is successful, return true. Otherwise, false

{
    unsigned int _Old = *_Expected_value;
    unsigned int _Ret = __dp_d3d_interlocked_compare_exchange(_Dest, _Value, _Old);
    if (_Ret == _Old) 
    {
        return true;
    }
    else 
    {
        *_Expected_value = _Ret;
        return false;
    }
}

int Concurrency::atomic_exchange ( _Inout_ int *  _Dest, int  _Value  )

inline

Sets the value of location pointed to by _Dest to _Value as an atomic operation

Parameters

_Dest	Pointer to the destination location
_Value	The value to be set to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    unsigned int _Ret = __dp_d3d_interlocked_exchange(AS_UINT_PTR(_Dest), AS_UINT(_Value));
    return AS_INT(_Ret);
}

unsigned int Concurrency::atomic_exchange ( _Inout_ unsigned int *  _Dest, unsigned int  _Value  )

inline

Sets the value of location pointed to by _Dest to _Value as an atomic operation

Parameters

_Dest	Pointer to the destination location
_Value	The value to be set to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    return __dp_d3d_interlocked_exchange(_Dest, _Value);
}

float Concurrency::atomic_exchange ( _Inout_ float *  _Dest, float  _Value  )

inline

Sets the value of location pointed to by _Dest to _Value as an atomic operation

Parameters

_Dest	Pointer to the destination location
_Value	The value to be set to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    unsigned int _Ret = __dp_d3d_interlocked_exchange(AS_UINT_PTR(_Dest), AS_UINT(_Value));
    return AS_FLOAT(_Ret);
}

int Concurrency::atomic_fetch_add ( _Inout_ int *  _Dest, int  _Value  )

inline

Performs an atomic addition of _Value to the memory location pointed to by _Dest

Parameters

_Dest	Pointer to the destination location
_Value	The value to be added to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    unsigned int _Ret;
    _Ret = __dp_d3d_interlocked_add(AS_UINT_PTR(_Dest), AS_UINT(_Value));
    return AS_INT(_Ret);
}

unsigned int Concurrency::atomic_fetch_add ( _Inout_ unsigned int *  _Dest, unsigned int  _Value  )

inline

Performs an atomic addition of _Value to the memory location pointed to by _Dest

Parameters

_Dest	Pointer to the destination location
_Value	The value to be added to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    return __dp_d3d_interlocked_add(_Dest, _Value);
}

int Concurrency::atomic_fetch_and ( _Inout_ int *  _Dest, int  _Value  )

inline

Performs an atomic bitwise and operation of _Value to the memory location pointed to by _Dest

Parameters

_Dest	Pointer to the destination location
_Value	The value to bitwise and to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    unsigned int _Ret;
    _Ret = __dp_d3d_interlocked_and(AS_UINT_PTR(_Dest), AS_UINT(_Value));
    return AS_INT(_Ret);
}

unsigned int Concurrency::atomic_fetch_and ( _Inout_ unsigned int *  _Dest, unsigned int  _Value  )

inline

Performs an atomic bitwise and operation of _Value to the memory location pointed to by _Dest

Parameters

_Dest	Pointer to the destination location
_Value	The value to bitwise and to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    return __dp_d3d_interlocked_and(_Dest, _Value);
}

int Concurrency::atomic_fetch_dec ( _Inout_ int *  _Dest )

inline

Performs an atomic decrement to the memory location pointed to by _Dest

Parameters

_Dest

Pointer to the destination location

Returns

The original value of the location pointed to by _Dest

{
#pragma warning( push )
#pragma warning( disable : 4146 )
    // Warning 4146: unary minus operator applied to unsigned type, result
    // still unsigned. 
    unsigned int _Ret;
    _Ret = __dp_d3d_interlocked_add(AS_UINT_PTR(_Dest), (-(1U)));
    return AS_INT(_Ret);
#pragma warning( pop )
}

unsigned int Concurrency::atomic_fetch_dec ( _Inout_ unsigned int *  _Dest )

inline

Performs an atomic decrement to the memory location pointed to by _Dest

Parameters

_Dest

Pointer to the destination location

Returns

The original value of the location pointed to by _Dest

{
#pragma warning( push )
#pragma warning( disable : 4146 )
    // Warning 4146: unary minus operator applied to unsigned type, result
    // still unsigned. 
    return __dp_d3d_interlocked_add(_Dest, (-(1U)));
#pragma warning( pop )
}

int Concurrency::atomic_fetch_inc ( _Inout_ int *  _Dest )

inline

Performs an atomic increment to the memory location pointed to by _Dest

Parameters

_Dest

Pointer to the destination location

Returns

The original value of the location pointed to by _Dest

{
    unsigned int _Ret;
    _Ret = __dp_d3d_interlocked_add(AS_UINT_PTR(_Dest), 1U);
    return AS_INT(_Ret);
}

unsigned int Concurrency::atomic_fetch_inc ( _Inout_ unsigned int *  _Dest )

inline

Performs an atomic increment to the memory location pointed to by _Dest

Parameters

_Dest

Pointer to the destination location

Returns

The original value of the location pointed to by _Dest

{
    return __dp_d3d_interlocked_add(_Dest, 1U);
}

int Concurrency::atomic_fetch_max ( _Inout_ int *  _Dest, int  _Value  )

inline

Atomically computes the maximum of _Value and the value of the memory location pointed to by _Dest, and stores the maximum value to the memory location

Parameters

_Dest	Pointer to the destination location
_Value	The value to be compared to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    return __dp_d3d_interlocked_max_int(_Dest, _Value);
}

unsigned int Concurrency::atomic_fetch_max ( _Inout_ unsigned int *  _Dest, unsigned int  _Value  )

inline

Atomically computes the maximum of _Value and the value of the memory location pointed to by _Dest, and stores the maximum value to the memory location

Parameters

_Dest	Pointer to the destination location
_Value	The value to be compared to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    return __dp_d3d_interlocked_max_uint(_Dest, _Value);
}

int Concurrency::atomic_fetch_min ( _Inout_ int *  _Dest, int  _Value  )

inline

Atomically computes the minimum of _Value and the value of the memory location pointed to by _Dest, and stores the minimum value to the memory location

Parameters

_Dest	Pointer to the destination location
_Value	The value to be compared to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    return __dp_d3d_interlocked_min_int(_Dest, _Value);
}

unsigned int Concurrency::atomic_fetch_min ( _Inout_ unsigned int *  _Dest, unsigned int  _Value  )

inline

Atomically computes the minimum of _Value and the value of the memory location pointed to by _Dest, and stores the minimum value to the memory location

Parameters

_Dest	Pointer to the destination location
_Value	The value to be compared to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    return __dp_d3d_interlocked_min_uint(_Dest, _Value);
}

int Concurrency::atomic_fetch_or ( _Inout_ int *  _Dest, int  _Value  )

inline

Performs an atomic bitwise or operation of _Value to the memory location pointed to by _Dest

Parameters

_Dest	Pointer to the destination location
_Value	The value to bitwise or to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    unsigned int _Ret;
    _Ret = __dp_d3d_interlocked_or(AS_UINT_PTR(_Dest), AS_UINT(_Value));
    return AS_INT(_Ret);
}

unsigned int Concurrency::atomic_fetch_or ( _Inout_ unsigned int *  _Dest, unsigned int  _Value  )

inline

Performs an atomic bitwise or operation of _Value to the memory location pointed to by _Dest

Parameters

_Dest	Pointer to the destination location
_Value	The value to bitwise or to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    return __dp_d3d_interlocked_or(_Dest, _Value);
}

int Concurrency::atomic_fetch_sub ( _Inout_ int *  _Dest, int  _Value  )

inline

Performs an atomic subtraction of _Value from the memory location pointed to by _Dest

Parameters

_Dest	Pointer to the destination location
_Value	The value to be subtracted from the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    unsigned int _Ret;
    int _Neg = -_Value;
    _Ret = __dp_d3d_interlocked_add(AS_UINT_PTR(_Dest), AS_UINT(_Neg));
    return AS_INT(_Ret);
}

unsigned int Concurrency::atomic_fetch_sub ( _Inout_ unsigned int *  _Dest, unsigned int  _Value  )

inline

Performs an atomic subtraction of _Value from the memory location pointed to by _Dest

Parameters

_Dest	Pointer to the destination location
_Value	The value to be subtracted from the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
#pragma warning( push )
#pragma warning( disable : 4146 )
    // Warning 4146: unary minus operator applied to unsigned type, result
    // still unsigned. 
    // 
    // This is what we want here. The resulted unsigned value have the 
    // right binary representation for achieving subtraction
    return __dp_d3d_interlocked_add(_Dest, (-_Value));
#pragma warning( pop ) 
}

int Concurrency::atomic_fetch_xor ( _Inout_ int *  _Dest, int  _Value  )

inline

Performs an atomic bitwise xor operation of _Value to the memory location pointed to by _Dest

Parameters

_Dest	Pointer to the destination location
_Value	The value to bitwise xor to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    unsigned int _Ret;
    _Ret = __dp_d3d_interlocked_xor(AS_UINT_PTR(_Dest), AS_UINT(_Value));
    return AS_INT(_Ret);
}

unsigned int Concurrency::atomic_fetch_xor ( _Inout_ unsigned int *  _Dest, unsigned int  _Value  )

inline

Performs an atomic bitwise xor operation of _Value to the memory location pointed to by _Dest

Parameters

_Dest	Pointer to the destination location
_Value	The value to bitwise xor to the location pointed to by _Dest

Returns

The original value of the location pointed to by _Dest

{
    return __dp_d3d_interlocked_xor(_Dest, _Value);
}

template<class _Ty >

bool Concurrency::await_ready

(

const task< _Ty > &

_Task

)

    {
        return _Task.is_done();
    }

template<class _Ty >

auto Concurrency::await_resume

(

const task< _Ty > &

_Task

)

    {
        return _Task.get();
    }

template<class _Ty , typename _Handle >

void Concurrency::await_suspend	(	task< _Ty > &	_Task,
		_Handle	_ResumeCb
	)

    {
        _Task.then([_ResumeCb](task<_Ty>&)
        {
            _ResumeCb();
        }, task_continuation_context::get_current_winrt_context());
    }

template<typename _Value_type , int _Rank>

void Concurrency::copy	(	const array< _Value_type, _Rank > &	_Src,
		array< _Value_type, _Rank > &	_Dest
	)

Copies the contents of the source array into the destination array.

Parameters

_Src	The source array.
_Dest	The destination array.

{
    auto _Span_id = details::_Get_amp_trace()->_Start_copy_event_helper(details::_Get_buffer_descriptor(_Src),
                                                                        details::_Get_buffer_descriptor(_Dest),
                                                                        sizeof(_Value_type) * _Src.extent.size());
    
    _Copy_async_impl(_Src, _Dest)._Get();

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

template<typename InputIterator , typename _Value_type , int _Rank>

void Concurrency::copy	(	InputIterator	_SrcFirst,
		InputIterator	_SrcLast,
		array< _Value_type, _Rank > &	_Dest
	)

Copies the elements in the range [_SrcFirst, _SrcLast) into the destination array.

Parameters

_SrcFirst	A beginning iterator into the source container.
_SrcLast	An ending iterator into the source container.
_Dest	The destination array.

{
    auto _Span_id = details::_Get_amp_trace()->_Start_copy_event_helper(nullptr,
                                                                        details::_Get_buffer_descriptor(_Dest),
                                                                        sizeof(_Value_type) * std::distance(_SrcFirst, _SrcLast));

    _Copy_async_impl(_SrcFirst, _SrcLast, _Dest)._Get();
    
    details::_Get_amp_trace()->_Write_end_event(_Span_id);
}

template<typename InputIterator , typename _Value_type , int _Rank>

void Concurrency::copy	(	InputIterator	_SrcFirst,
		array< _Value_type, _Rank > &	_Dest
	)

Copies the elements beginning at _SrcFirst into the destination array.

Parameters

_SrcFirst	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than _Dest.extent.size(), undefined behavior results.
_Dest	The destination array.

{                       
    InputIterator _SrcLast = _SrcFirst;
    std::advance(_SrcLast, _Dest.extent.size());
    copy(_SrcFirst, _SrcLast, _Dest);
}

template<typename OutputIterator , typename _Value_type , int _Rank>

void Concurrency::copy	(	const array< _Value_type, _Rank > &	_Src,
		OutputIterator	_DestIter
	)

Copies the contents of the array into the destination beginning at _DestIter.

Parameters

_Src	The source array.
_DestIter	An output iterator to the beginning position at destination.

{
    _CPP_AMP_VERIFY_MUTABLE_ITERATOR(OutputIterator);

    auto _Span_id = details::_Get_amp_trace()->_Start_copy_event_helper(details::_Get_buffer_descriptor(_Src),
                                                                        nullptr,
                                                                        sizeof(_Value_type) * _Src.extent.size());

    _Copy_async_impl(_Src, _DestIter)._Get();

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

template<typename _Value_type , int _Rank>

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

Copies the contents of the source array into the destination array_view.

Parameters

_Src	The source array.
_Dest	The destination array_view.

{
    auto _Span_id = details::_Get_amp_trace()->_Start_copy_event_helper(details::_Get_buffer_descriptor(_Src),
                                                                        details::_Get_buffer_descriptor(_Dest),
                                                                        sizeof(_Value_type) * _Src.extent.size());

    _Copy_async_impl(_Src, _Dest)._Get();

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

template<typename _Value_type , int _Rank>

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

Copies the contents of the source array_view into the destination array.

Parameters

_Src	The source array_view.
_Dest	The destination array.

{
    auto _Span_id = details::_Get_amp_trace()->_Start_copy_event_helper(details::_Get_buffer_descriptor(_Src),
                                                                        details::_Get_buffer_descriptor(_Dest),
                                                                        sizeof(_Value_type) * _Src.extent.size());

    _Copy_async_impl(_Src, _Dest)._Get();

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

template<typename _Value_type , int _Rank>

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

Copies the contents of the source array_view into the destination array.

Parameters

_Src	The source array_view.
_Dest	The destination array.

{
    copy<_Value_type, _Rank>(array_view<const _Value_type, _Rank>(_Src), _Dest);
}

template<typename _Value_type , int _Rank>

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

Copies the contents of the source array_view into the destination array_view.

Parameters

_Src	The source array_view.
_Dest	The destination array_view.

{
    auto _Span_id = details::_Get_amp_trace()->_Start_copy_event_helper(details::_Get_buffer_descriptor(_Src),
                                                                        details::_Get_buffer_descriptor(_Dest),
                                                                        sizeof(_Value_type) * _Src.extent.size());

    _Copy_async_impl(_Src, _Dest)._Get();
    
    details::_Get_amp_trace()->_Write_end_event(_Span_id);
}

template<typename _Value_type , int _Rank>

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

Copies the contents of the source array_view into the destination array_view.

Parameters

_Src	The source array_view.
_Dest	The destination array_view.

{
    copy<_Value_type, _Rank>(array_view<const _Value_type, _Rank>(_Src), _Dest);
}

template<typename InputIterator , typename _Value_type , int _Rank>

void Concurrency::copy	(	InputIterator	_SrcFirst,
		InputIterator	_SrcLast,
		const array_view< _Value_type, _Rank > &	_Dest
	)

Copies the elements in the range [_SrcFirst, _SrcLast) into the destination array_view.

Parameters

_SrcFirst	A beginning iterator into the source container.
_SrcLast	An ending iterator into the source container.
_Dest	The destination array_view.

{
    auto _Span_id = details::_Get_amp_trace()->_Start_copy_event_helper(nullptr,
                                                                        details::_Get_buffer_descriptor(_Dest),
                                                                        sizeof(_Value_type) * std::distance(_SrcFirst, _SrcLast));

    _Copy_async_impl(_SrcFirst, _SrcLast, _Dest)._Get();

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

template<typename InputIterator , typename _Value_type , int _Rank>

void Concurrency::copy	(	InputIterator	_SrcFirst,
		const array_view< _Value_type, _Rank > &	_Dest
	)

Copies the contents of an STL container into the destination array_view.

Parameters

_SrcFirst	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than _Dest.extent.size(), undefined behavior results.
_Dest	The destination array_view.

{
    InputIterator _SrcLast = _SrcFirst;
    std::advance(_SrcLast, _Dest.extent.size());
    copy(_SrcFirst, _SrcLast, _Dest);
}

template<typename OutputIterator , typename _Value_type , int _Rank>

void Concurrency::copy	(	const array_view< _Value_type, _Rank > &	_Src,
		OutputIterator	_DestIter
	)

Copies the contents of the array_view into the destination beginning at _DestIter.

Parameters

_Src	The source array_view.
_DestIter	An output iterator to the beginning position at destination.

{
    _CPP_AMP_VERIFY_MUTABLE_ITERATOR(OutputIterator);

    auto _Span_id = details::_Get_amp_trace()->_Start_copy_event_helper(details::_Get_buffer_descriptor(_Src),
                                                                        nullptr,
                                                                        sizeof(_Value_type) * _Src.extent.size());

    _Copy_async_impl(_Src, _DestIter)._Get();

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

template<typename _Value_type , int _Rank>

concurrency::completion_future Concurrency::copy_async	(	const array< _Value_type, _Rank > &	_Src,
		array< _Value_type, _Rank > &	_Dest
	)

Asynchronously copies the contents of the source array into the destination array.

Parameters

_Src	The source array.
_Dest	The destination array.

Returns

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

{
    auto _Async_op_id = details::_Get_amp_trace()->_Launch_async_copy_event_helper(details::_Get_buffer_descriptor(_Src),
                                                                                   details::_Get_buffer_descriptor(_Dest),
                                                                                   sizeof(_Value_type) * _Src.extent.size());

    auto _Ev = _Copy_async_impl(_Src, _Dest);

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

template<typename InputIterator , typename _Value_type , int _Rank>

concurrency::completion_future Concurrency::copy_async	(	InputIterator	_SrcFirst,
		InputIterator	_SrcLast,
		array< _Value_type, _Rank > &	_Dest
	)

Asynchronously copies the elements in the range [_SrcFirst, _SrcLast) into the destination array.

Parameters

_SrcFirst	A beginning iterator into the source container.
_SrcLast	An ending iterator into the source container.
_Dest	The destination array.

Returns

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

{   
    auto _Async_op_id = details::_Get_amp_trace()->_Launch_async_copy_event_helper(nullptr,
                                                                                   details::_Get_buffer_descriptor(_Dest),
                                                                                   sizeof(_Value_type) * std::distance(_SrcFirst, _SrcLast));

    _Event _Ev = _Copy_async_impl(_SrcFirst, _SrcLast, _Dest);

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

template<typename InputIterator , typename _Value_type , int _Rank>

concurrency::completion_future Concurrency::copy_async	(	InputIterator	_SrcFirst,
		array< _Value_type, _Rank > &	_Dest
	)

Asynchronously copies the elements beginning at _SrcFirst into the destination array.

Parameters

_SrcFirst	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than _Dest.extent.size(), undefined behavior results.
_Dest	The destination array.

Returns

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

{
    InputIterator _SrcLast = _SrcFirst;
    std::advance(_SrcLast, _Dest.extent.size());
    return copy_async(_SrcFirst, _SrcLast, _Dest);
}

template<typename OutputIterator , typename _Value_type , int _Rank>

concurrency::completion_future Concurrency::copy_async	(	const array< _Value_type, _Rank > &	_Src,
		OutputIterator	_DestIter
	)

Asynchronously copies the contents of the array into the destination beginning at _DestIter.

Parameters

_Src	The source array.
_DestIter	An output iterator to the beginning position at destination.

Returns

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

{
    _CPP_AMP_VERIFY_MUTABLE_ITERATOR(OutputIterator);

    auto _Async_op_id = details::_Get_amp_trace()->_Launch_async_copy_event_helper(details::_Get_buffer_descriptor(_Src), 
                                                                                   nullptr, 
                                                                                   sizeof(_Value_type) * _Src.extent.size());
    _Event _Ev = _Copy_async_impl(_Src, _DestIter);

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

template<typename _Value_type , int _Rank>

concurrency::completion_future Concurrency::copy_async	(	const array< _Value_type, _Rank > &	_Src,
		const array_view< _Value_type, _Rank > &	_Dest
	)

Asynchronously copies the contents of the source array into the destination array_view.

Parameters

_Src	The source array.
_Dest	The destination array_view.

Returns

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

{
    auto _Async_op_id = details::_Get_amp_trace()->_Launch_async_copy_event_helper(details::_Get_buffer_descriptor(_Src),
                                                                                   details::_Get_buffer_descriptor(_Dest),
                                                                                   sizeof(_Value_type) * _Src.extent.size());

    _Event _Ev = _Copy_async_impl(_Src, _Dest);

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

template<typename _Value_type , int _Rank>

concurrency::completion_future Concurrency::copy_async	(	const array_view< const _Value_type, _Rank > &	_Src,
		array< _Value_type, _Rank > &	_Dest
	)

Asynchronously copies the contents of the source array_view into the destination array.

Parameters

_Src	The source array_view.
_Dest	The destination array.

Returns

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

{
    auto _Async_op_id = details::_Get_amp_trace()->_Launch_async_copy_event_helper(details::_Get_buffer_descriptor(_Src), 
                                                                                   details::_Get_buffer_descriptor(_Dest), 
                                                                                   sizeof(_Value_type) * _Src.extent.size());

    _Event _Ev = _Copy_async_impl(_Src, _Dest);

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

template<typename _Value_type , int _Rank>

concurrency::completion_future Concurrency::copy_async	(	const array_view< _Value_type, _Rank > &	_Src,
		array< _Value_type, _Rank > &	_Dest
	)

Asynchronously copies the contents of the source array_view into the destination array.

Parameters

_Src	The source array_view.
_Dest	The destination array.

Returns

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

{
    return copy_async<_Value_type, _Rank>(array_view<const _Value_type, _Rank>(_Src), _Dest);
}

template<typename _Value_type , int _Rank>

concurrency::completion_future Concurrency::copy_async	(	const array_view< const _Value_type, _Rank > &	_Src,
		const array_view< _Value_type, _Rank > &	_Dest
	)

Asynchronously copies the contents of the source array_view into the destination array_view.

Parameters

_Src	The source array_view.
_Dest	The destination array_view.

Returns

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

{
    auto _Async_op_id = details::_Get_amp_trace()->_Launch_async_copy_event_helper(details::_Get_buffer_descriptor(_Src),
                                                                                   details::_Get_buffer_descriptor(_Dest), 
                                                                                   sizeof(_Value_type) * _Src.extent.size());

    _Event _Ev = _Copy_async_impl(_Src, _Dest);

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

template<typename _Value_type , int _Rank>

concurrency::completion_future Concurrency::copy_async	(	const array_view< _Value_type, _Rank > &	_Src,
		const array_view< _Value_type, _Rank > &	_Dest
	)

Asynchronously copies the contents of the source array_view into the destination array_view.

Parameters

_Src	The source array_view.
_Dest	The destination array_view.

Returns

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

{
    return copy_async<_Value_type, _Rank>(array_view<const _Value_type, _Rank>(_Src), _Dest);
}

template<typename InputIterator , typename _Value_type , int _Rank>

concurrency::completion_future Concurrency::copy_async	(	InputIterator	_SrcFirst,
		InputIterator	_SrcLast,
		const array_view< _Value_type, _Rank > &	_Dest
	)

Asynchronously copies the elements in the range [_SrcFirst, _SrcLast) into the destination array_view.

Parameters

_SrcFirst	A beginning iterator into the source container.
_SrcLast	An ending iterator into the source container.
_Dest	The destination array_view.

Returns

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

{    
    auto _Async_op_id = details::_Get_amp_trace()->_Launch_async_copy_event_helper(nullptr, 
                                                                                   details::_Get_buffer_descriptor(_Dest), 
                                                                                   sizeof(_Value_type) * std::distance(_SrcFirst, _SrcLast));

    _Event _Ev = _Copy_async_impl(_SrcFirst, _SrcLast, _Dest);

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

template<typename InputIterator , typename _Value_type , int _Rank>

concurrency::completion_future Concurrency::copy_async	(	InputIterator	_SrcFirst,
		const array_view< _Value_type, _Rank > &	_Dest
	)

Asynchronously copies the elements beginning at _SrcFirst into the destination array_view.

Parameters

_SrcFirst	A beginning iterator into the source container; if the number of available container elements starting at this iterator position is less than _Dest.extent.size(), undefined behavior results.
_Dest	The destination array_view.

Returns

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

{
    InputIterator _SrcLast = _SrcFirst;
    std::advance(_SrcLast, _Dest.extent.size());
    return copy_async(_SrcFirst, _SrcLast, _Dest);
}

template<typename OutputIterator , typename _Value_type , int _Rank>

concurrency::completion_future Concurrency::copy_async	(	const array_view< _Value_type, _Rank > &	_Src,
		OutputIterator	_DestIter
	)

Asynchronously copies the contents of the array_view into the destination beginning at _DestIter.

Parameters

_Src	The source array_view.
_DestIter	An output iterator to the beginning position at destination.

Returns

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

{
    _CPP_AMP_VERIFY_MUTABLE_ITERATOR(OutputIterator);

    // Caller is responsible for passing valid _DestIter
    auto _Async_op_id = details::_Get_amp_trace()->_Launch_async_copy_event_helper(details::_Get_buffer_descriptor(_Src), 
                                                                                   nullptr, 
                                                                                   sizeof(_Value_type) * _Src.extent.size());

    _Event _Ev = _Copy_async_impl(_Src, _DestIter);

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

void Concurrency::direct3d_abort

(

)

void Concurrency::direct3d_errorf	(	const char *	,
			...
	)

void Concurrency::direct3d_printf	(	const char *	,
			...
	)

_CONCRTIMP void __cdecl Concurrency::Free

(

_Pre_maybenull_ _Post_invalid_ void *

_PAllocation

)

Releases a block of memory previously allocated by the Alloc method to the Concurrency Runtime Caching Suballocator.

Parameters

_PAllocation

A pointer to memory previously allocated by the Alloc method which is to be freed. If the parameter _PAllocation is set to the value NULL, this method will ignore it and return immediately.

For more information about which scenarios in your application could benefit from using the Caching Suballocator, see Task Scheduler (Concurrency Runtime).

See also

Concurrency::Alloc Function

const ::std::shared_ptr<scheduler_interface>& Concurrency::get_ambient_scheduler ( )

inline

{
    return details::_GetStaticAmbientSchedulerRef();
}

void Concurrency::global_memory_fence ( const tile_barrier &  _Barrier )

inline

Ensures that global memory accesses are visible to other threads in the thread tile, and are executed according to program order

Parameters

_Barrier

A tile_barrier object

{
    __dp_d3d_device_memory_fence();
}

void Concurrency::interruption_point ( )

inline

Creates an interruption point for cancellation. If a cancellation is in progress in the context where this function is called, this will throw an internal exception that aborts the execution of the currently executing parallel work. If cancellation is not in progress, the function does nothing.

You should not catch the internal cancellation exception thrown by the interruption_point() function. The exception will be caught and handled by the runtime, and catching it may cause your program to behave abnormally.

{
    structured_task_group _Stg;
    _Stg.wait();
}

_CONCRTIMP bool __cdecl Concurrency::is_current_task_group_canceling

(

)

Returns an indication of whether the task group which is currently executing inline on the current context is in the midst of an active cancellation (or will be shortly). Note that if there is no task group currently executing inline on the current context, false will be returned.

Returns

true if the task group which is currently executing is canceling, false otherwise.

For more information, see Cancellation in the PPL.

See also

task_group Class, structured_task_group Class

template<typename _Type1 , typename _Type2 , typename... _Types>

choice<std::tuple<_Type1, _Type2, _Types...> > Concurrency::make_choice	(	_Type1	_Item1,
		_Type2	_Item2,
		_Types...	_Items
	)

Constructs a choice messaging block from an optional Scheduler or ScheduleGroup and two or more input sources.

Template Parameters

_Type1	The message block type of the first source.
_Type2	The message block type of the second source.
_Types	The message block types of additional sources.

Parameters

_Item1	The first source.
_Item2	The second source.
_Items	Additional sources.

Returns

A choice message block with two or more input sources.

See also

choice Class

{
    return choice<std::tuple<_Type1, _Type2, _Types...>>(std::make_tuple(_Item1, _Item2, _Items...));
}

template<typename _Type1 , typename _Type2 , typename... _Types>

multitype_join<std::tuple<_Type1, _Type2, _Types...>, greedy> Concurrency::make_greedy_join	(	_Type1	_Item1,
		_Type2	_Item2,
		_Types...	_Items
	)

Constructs a greedy multitype_join messaging block from an optional Scheduler or ScheduleGroup and two or more input sources.

Template Parameters

_Type1	The message block type of the first source.
_Type2	The message block type of the second source.
_Types	The message block types of additional sources.

Parameters

_Item1	The first source.
_Item2	The second source.
_Items	Additional sources.

Returns

A greedy multitype_join message block with two or more input sources.

See also

multitype_join Class

{
    return multitype_join<std::tuple<_Type1, _Type2, _Types...>, greedy>(std::make_tuple(_Item1, _Item2, _Items...));
}

template<typename _Type1 , typename _Type2 , typename... _Types>

multitype_join<std::tuple<_Type1, _Type2, _Types...> > Concurrency::make_join	(	_Type1	_Item1,
		_Type2	_Item2,
		_Types...	_Items
	)

Constructs a non_greedy multitype_join messaging block from an optional Scheduler or ScheduleGroup and two or more input sources.

Template Parameters

_Type1	The message block type of the first source.
_Type2	The message block type of the second source.
_Types	The message block types of additional sources.

Parameters

_Item1	The first source.
_Item2	The second source.
_Items	Additional sources.

Returns

A non_greedy multitype_join message block with two or more input sources.

See also

multitype_join Class

{
    return multitype_join<std::tuple<_Type1, _Type2, _Types...>>(std::make_tuple(_Item1, _Item2, _Items...));
}

template<class _Function >

task_handle<_Function> Concurrency::make_task

(

const _Function &

_Func

)

A factory method for creating a task_handle object.

Template Parameters

_Function

The type of the function object that will be invoked to execute the work represented by the task_handle object.

Parameters

_Func

The function that will be invoked to execute the work represented by the task_handle object. This may be a lambda functor, a pointer to a function, or any object that supports a version of the function call operator with the signature void operator()().

Returns

A task_handle object.

This function is useful when you need to create a task_handle object with a lambda expression, because it allows you to create the object without knowing the true type of the lambda functor.

See also

task_handle Class, task_group Class, structured_task_group Class

{
    return task_handle<_Function>(_Func);
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, bool>::type Concurrency::operator!=	(	const _Tuple_type< _Rank > &	_Lhs,
		const _Tuple_type< _Rank > &	_Rhs
	)

{
    return !details::_cmp_op_loop_helper<_Tuple_type<_Rank>, details::opEq>::func(_Lhs, _Rhs);
}

template<typename _Ty , class A1 , class A2 >

bool Concurrency::operator!= ( const concurrent_vector< _Ty, A1 > &  _A, const concurrent_vector< _Ty, A2 > &  _B  )

inline

Tests if the concurrent_vector object on the left side of the operator is not equal to the concurrent_vector object on the right side.

Template Parameters

_Ty	The data type of the elements stored in the concurrent vectors.
A1	The allocator type of the first concurrent_vector object.
A2	The allocator type of the second concurrent_vector object.

Parameters

_A	An object of type concurrent_vector.
_B	An object of type concurrent_vector.

Returns

true if the concurrent vectors are not equal; false if the concurrent vectors are equal.

Two concurrent vectors are equal if they have the same number of elements and their respective elements have the same values. Otherwise, they are unequal.

This method is not concurrency-safe with respect to other methods that could modify either of the concurrent vectors _A or _B .

See also

concurrent_vector Class, Parallel Containers and Objects

{
    return !(_A == _B);
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, _Tuple_type<_Rank> >::type Concurrency::operator%	(	const _Tuple_type< _Rank > &	_Lhs,
		typename _Tuple_type< _Rank >::value_type	_Rhs
	)

{
    _Tuple_type<_Rank> new_Tuple = details::_Create_uninitialized_tuple<_Tuple_type<_Rank>>();
    details::_arithmetic_op_loop_helper<_Tuple_type<_Rank>, opMod>::func(new_Tuple, _Lhs, _Rhs);
    return new_Tuple;
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, _Tuple_type<_Rank> >::type Concurrency::operator%	(	typename _Tuple_type< _Rank >::value_type	_Lhs,
		const _Tuple_type< _Rank > &	_Rhs
	)

{
    _Tuple_type<_Rank> new_Tuple = details::_Create_uninitialized_tuple<_Tuple_type<_Rank>>();
    details::_arithmetic_op_loop_helper<_Tuple_type<_Rank>, opMod>::func(new_Tuple, _Lhs, _Rhs);
    return new_Tuple;
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, _Tuple_type<_Rank> >::type Concurrency::operator*	(	const _Tuple_type< _Rank > &	_Lhs,
		typename _Tuple_type< _Rank >::value_type	_Rhs
	)

{
    _Tuple_type<_Rank> new_Tuple = details::_Create_uninitialized_tuple<_Tuple_type<_Rank>>();
    details::_arithmetic_op_loop_helper<_Tuple_type<_Rank>, opMul>::func(new_Tuple, _Lhs, _Rhs);
    return new_Tuple;
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, _Tuple_type<_Rank> >::type Concurrency::operator*	(	typename _Tuple_type< _Rank >::value_type	_Lhs,
		const _Tuple_type< _Rank > &	_Rhs
	)

{
    _Tuple_type<_Rank> new_Tuple = details::_Create_uninitialized_tuple<_Tuple_type<_Rank>>();
    details::_arithmetic_op_loop_helper<_Tuple_type<_Rank>, opMul>::func(new_Tuple, _Lhs, _Rhs);
    return new_Tuple;
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, _Tuple_type<_Rank> >::type Concurrency::operator+	(	const _Tuple_type< _Rank > &	_Lhs,
		const _Tuple_type< _Rank > &	_Rhs
	)

{
    _Tuple_type<_Rank> new_Tuple = details::_Create_uninitialized_tuple<_Tuple_type<_Rank>>();
    details::_arithmetic_op_loop_helper<_Tuple_type<_Rank>, opAdd>::func(new_Tuple, _Lhs, _Rhs);
    return new_Tuple;
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, _Tuple_type<_Rank> >::type Concurrency::operator+	(	const _Tuple_type< _Rank > &	_Lhs,
		typename _Tuple_type< _Rank >::value_type	_Rhs
	)

{
    _Tuple_type<_Rank> new_Tuple = details::_Create_uninitialized_tuple<_Tuple_type<_Rank>>();
    details::_arithmetic_op_loop_helper<_Tuple_type<_Rank>, opAdd>::func(new_Tuple, _Lhs, _Rhs);
    return new_Tuple;
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, _Tuple_type<_Rank> >::type Concurrency::operator+	(	typename _Tuple_type< _Rank >::value_type	_Lhs,
		const _Tuple_type< _Rank > &	_Rhs
	)

{
    _Tuple_type<_Rank> new_Tuple = details::_Create_uninitialized_tuple<_Tuple_type<_Rank>>();
    details::_arithmetic_op_loop_helper<_Tuple_type<_Rank>, opAdd>::func(new_Tuple, _Lhs, _Rhs);
    return new_Tuple;
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, _Tuple_type<_Rank> >::type Concurrency::operator-	(	const _Tuple_type< _Rank > &	_Lhs,
		const _Tuple_type< _Rank > &	_Rhs
	)

{
    _Tuple_type<_Rank> new_Tuple = details::_Create_uninitialized_tuple<_Tuple_type<_Rank>>();
    details::_arithmetic_op_loop_helper<_Tuple_type<_Rank>, opSub>::func(new_Tuple, _Lhs, _Rhs);
    return new_Tuple;
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, _Tuple_type<_Rank> >::type Concurrency::operator-	(	const _Tuple_type< _Rank > &	_Lhs,
		typename _Tuple_type< _Rank >::value_type	_Rhs
	)

{
    _Tuple_type<_Rank> new_Tuple = details::_Create_uninitialized_tuple<_Tuple_type<_Rank>>();
    details::_arithmetic_op_loop_helper<_Tuple_type<_Rank>, opSub>::func(new_Tuple, _Lhs, _Rhs);
    return new_Tuple;
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, _Tuple_type<_Rank> >::type Concurrency::operator-	(	typename _Tuple_type< _Rank >::value_type	_Lhs,
		const _Tuple_type< _Rank > &	_Rhs
	)

{
    _Tuple_type<_Rank> new_Tuple = details::_Create_uninitialized_tuple<_Tuple_type<_Rank>>();
    details::_arithmetic_op_loop_helper<_Tuple_type<_Rank>, opSub>::func(new_Tuple, _Lhs, _Rhs);
    return new_Tuple;
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, _Tuple_type<_Rank> >::type Concurrency::operator/	(	const _Tuple_type< _Rank > &	_Lhs,
		typename _Tuple_type< _Rank >::value_type	_Rhs
	)

{
    _Tuple_type<_Rank> new_Tuple = details::_Create_uninitialized_tuple<_Tuple_type<_Rank>>();
    details::_arithmetic_op_loop_helper<_Tuple_type<_Rank>, opDiv>::func(new_Tuple, _Lhs, _Rhs);
    return new_Tuple;
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, _Tuple_type<_Rank> >::type Concurrency::operator/	(	typename _Tuple_type< _Rank >::value_type	_Lhs,
		const _Tuple_type< _Rank > &	_Rhs
	)

{
    _Tuple_type<_Rank> new_Tuple = details::_Create_uninitialized_tuple<_Tuple_type<_Rank>>();
    details::_arithmetic_op_loop_helper<_Tuple_type<_Rank>, opDiv>::func(new_Tuple, _Lhs, _Rhs);
    return new_Tuple;
}

template<typename _Ty , class A1 , class A2 >

bool Concurrency::operator< ( const concurrent_vector< _Ty, A1 > &  _A, const concurrent_vector< _Ty, A2 > &  _B  )

inline

Tests if the concurrent_vector object on the left side of the operator is less than the concurrent_vector object on the right side.

Template Parameters

_Ty	The data type of the elements stored in the concurrent vectors.
A1	The allocator type of the first concurrent_vector object.
A2	The allocator type of the second concurrent_vector object.

Parameters

_A	An object of type concurrent_vector.
_B	An object of type concurrent_vector.

Returns

true if the concurrent vector on the left side of the operator is less than the concurrent vector on the right side of the operator; otherwise false.

The behavior of this operator is identical to the equivalent operator for the vector class in the std namespace.

This method is not concurrency-safe with respect to other methods that could modify either of the concurrent vectors _A or _B .

See also

concurrent_vector Class, Parallel Containers and Objects

{
    return (std::lexicographical_compare(_A.begin(), _A.end(), _B.begin(), _B.end()));
}

template<typename _Ty , class A1 , class A2 >

bool Concurrency::operator<= ( const concurrent_vector< _Ty, A1 > &  _A, const concurrent_vector< _Ty, A2 > &  _B  )

inline

Tests if the concurrent_vector object on the left side of the operator is less than or equal to the concurrent_vector object on the right side.

Template Parameters

_Ty	The data type of the elements stored in the concurrent vectors.
A1	The allocator type of the first concurrent_vector object.
A2	The allocator type of the second concurrent_vector object.

Parameters

_A	An object of type concurrent_vector.
_B	An object of type concurrent_vector.

Returns

true if the concurrent vector on the left side of the operator is less than or equal to the concurrent vector on the right side of the operator; otherwise false.

The behavior of this operator is identical to the equivalent operator for the vector class in the std namespace.

This method is not concurrency-safe with respect to other methods that could modify either of the concurrent vectors _A or _B .

See also

concurrent_vector Class, Parallel Containers and Objects

{
    return !(_B < _A);
}

template<int _Rank, template< int > class _Tuple_type>

std::enable_if<details::_Is_extent_or_index<_Tuple_type<_Rank> >::value, bool>::type Concurrency::operator==	(	const _Tuple_type< _Rank > &	_Lhs,
		const _Tuple_type< _Rank > &	_Rhs
	)

{
    return details::_cmp_op_loop_helper<_Tuple_type<_Rank>, details::opEq>::func(_Lhs, _Rhs);
}

template<typename _Ty , class A1 , class A2 >

bool Concurrency::operator== ( const concurrent_vector< _Ty, A1 > &  _A, const concurrent_vector< _Ty, A2 > &  _B  )

inline

Tests if the concurrent_vector object on the left side of the operator is equal to the concurrent_vector object on the right side.

Template Parameters

_Ty	The data type of the elements stored in the concurrent vectors.
A1	The allocator type of the first concurrent_vector object.
A2	The allocator type of the second concurrent_vector object.

Parameters

_A	An object of type concurrent_vector.
_B	An object of type concurrent_vector.

Returns

true if the concurrent vector on the left side of the operator is equal to the concurrent vector on the right side of the operator; otherwise false.

Two concurrent vectors are equal if they have the same number of elements and their respective elements have the same values. Otherwise, they are unequal.

This method is not concurrency-safe with respect to other methods that could modify either of the concurrent vectors _A or _B .

See also

concurrent_vector Class, Parallel Containers and Objects

{
    // Simply:    return _A.size() == _B.size() && std::equal(_A.begin(), _A.end(), _B.begin());
    if(_A.size() != _B.size())
        return false;
    typename concurrent_vector<_Ty, A1>::const_iterator _I(_A.begin());
    typename concurrent_vector<_Ty, A2>::const_iterator _J(_B.begin());
    for(; _I != _A.end(); ++_I, ++_J)
    {
        if( !(*_I == *_J) )
            return false;
    }
    return true;
}

template<typename _Ty , class A1 , class A2 >

bool Concurrency::operator> ( const concurrent_vector< _Ty, A1 > &  _A, const concurrent_vector< _Ty, A2 > &  _B  )

inline

Tests if the concurrent_vector object on the left side of the operator is greater than the concurrent_vector object on the right side.

Template Parameters

_Ty	The data type of the elements stored in the concurrent vectors.
A1	The allocator type of the first concurrent_vector object.
A2	The allocator type of the second concurrent_vector object.

Parameters

_A	An object of type concurrent_vector.
_B	An object of type concurrent_vector.

Returns

true if the concurrent vector on the left side of the operator is greater than the concurrent vector on the right side of the operator; otherwise false.

The behavior of this operator is identical to the equivalent operator for the vector class in the std namespace.

This method is not concurrency-safe with respect to other methods that could modify either of the concurrent vectors _A or _B .

See also

concurrent_vector Class, Parallel Containers and Objects

{
    return _B < _A;
}

template<typename _Ty , class A1 , class A2 >

bool Concurrency::operator>= ( const concurrent_vector< _Ty, A1 > &  _A, const concurrent_vector< _Ty, A2 > &  _B  )

inline

Tests if the concurrent_vector object on the left side of the operator is greater than or equal to the concurrent_vector object on the right side.

Template Parameters

_Ty	The data type of the elements stored in the concurrent vectors.
A1	The allocator type of the first concurrent_vector object.
A2	The allocator type of the second concurrent_vector object.

Parameters

_A	An object of type concurrent_vector.
_B	An object of type concurrent_vector.

Returns

true if the concurrent vector on the left side of the operator is greater than or equal to the concurrent vector on the right side of the operator; otherwise false.

The behavior of this operator is identical to the equivalent operator for the vector class in the std namespace.

This method is not concurrency-safe with respect to other methods that could modify either of the concurrent vectors _A or _B .

See also

concurrent_vector Class, Parallel Containers and Objects

{
    return !(_A < _B);
}

template<typename _Allocator , typename _Random_iterator , typename _Function >

void Concurrency::parallel_buffered_sort ( const _Allocator &  _Alloc, const _Random_iterator &  _Begin, const _Random_iterator &  _End, const _Function &  _Func, const size_t  _Chunk_size = 2048  )

inline

Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted.

Template Parameters

_Allocator	The type of an STL compatible memory allocator.
_Random_iterator	The iterator type of the input range.
_Function	The type of the binary comparator.

Parameters

_Alloc	An instance of an STL compatible memory allocator.
_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.
_Func	A user-defined predicate function object that defines the comparison criterion to be satisfied by successive elements in the ordering. A binary predicate takes two arguments and returns true when satisfied and false when not satisfied. This comparator function must impose a strict weak ordering on pairs of elements from the sequence.
_Chunk_size	The minimum size of a chunk that will be split into two for parallel execution.

All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. In most cases parallel_buffered_sort will show an improvement in performance over parallel_sort, and you should use it over parallel_sort if you have the memory available.

If you do not supply a binary comparator std::less is used as the default, which requires the element type to provide the operator operator<().

If you do not supply an allocator type or instance, the STL memory allocator std::allocator<T> is used to allocate the buffer.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    _CONCRT_ASSERT(_Chunk_size > 0);

    // Check cancellation before the algorithm starts.
    interruption_point();

    size_t _Size = _End - _Begin;
    size_t _Core_num = ::Concurrency::details::_CurrentScheduler::_GetNumberOfVirtualProcessors();

    if (_Size <= _Chunk_size || _Core_num < 2)
    {
        return std::sort(_Begin, _End, _Func);
    }
    const static size_t _CORE_NUM_MASK = 0x55555555;

    _AllocatedBufferHolder<_Allocator> _Holder(_Size, _Alloc);

    // Prevent cancellation from happening during the algorithm in case it leaves buffers in unknown state.
    run_with_cancellation_token([&]() {
        // This buffered sort algorithm will divide chunks and apply parallel quicksort on each chunk. In the end, it will
        // apply parallel merge to these sorted chunks.
        //
        // We need to decide on the number of chunks to divide the input buffer into. If we divide it into n chunks, log(n)
        // merges will be needed to get the final sorted result. In this algorithm, we have two buffers for each merge
        // operation, let's say buffer A and B. Buffer A is the original input array, buffer B is the additional allocated
        // buffer. Each turn's merge will put the merge result into the other buffer; for example, if we decided to split
        // into 8 chunks in buffer A at very beginning, after one pass of merging, there will be 4 chunks in buffer B.
        // If we apply one more pass of merging, there will be 2 chunks in buffer A again.
        //
        // The problem is we want to the final merge pass to put the result back in buffer A, so that we don't need
        // one extra copy to put the sorted data back to buffer A.
        // To make sure the final result is in buffer A (original input array), we need an even number of merge passes,
        // which means log(n) must be an even number. Thus n must be a number power(2, even number). For example, when the
        // even number is 2, n is power(2, 2) = 4, when even number is 4, n is power(2, 4) = 16. When we divide chunks
        // into these numbers, the final merge result will be in the original input array. Now we need to decide the chunk(split)
        // number based on this property and the number of cores.
        //
        // We want to get a chunk (split) number close to the core number (or a little more than the number of cores),
        // and it also needs to satisfy above property. For a 8 core machine, the best chunk number should be 16, because it's
        // the smallest number that satisfies the above property and is bigger than the core number (so that we can utilize all
        // cores, a little more than core number is OK, we need to split more tasks anyway).
        //
        // In this algorithm, we will make this alignment by bit operations (it's easy and clear). For a binary representation,
        // all the numbers that satisfy power(2, even number) will be 1, 100, 10000, 1000000, 100000000 ...
        // After OR-ing these numbers together, we will get a mask (... 0101 0101 0101) which is all possible combinations of
        // power(2, even number). We use _Core_num & _CORE_NUM_MASK | _Core_num << 1 & _CORE_NUM_MASK, a bit-wise operation to align
        // _Core_num's highest bit into a power(2, even number).
        //
        // It means if _Core_num = 8, the highest bit in binary is bin(1000) which is not power(2, even number). After this
        // bit-wise operation, it will align to bin(10000) = 16 which is power(2, even number). If the _Core_num = 16, after
        // alignment it still returns 16. The trick is to make sure the highest bit of _Core_num will align to the "1" bit of the
        // mask bin(... 0101 0101 0101) We don't care about the other bits on the aligned result except the highest bit, because they
        // will be ignored in the function.
        _Parallel_buffered_sort_impl(_Begin, _Size, stdext::make_unchecked_array_iterator(_Holder._Get_buffer()),
            _Func, _Core_num & _CORE_NUM_MASK | _Core_num << 1 & _CORE_NUM_MASK, _Chunk_size);
    }, cancellation_token::none());

}

template<typename _Allocator , typename _Random_iterator , typename _Function >

void Concurrency::parallel_buffered_sort ( const _Random_iterator &  _Begin, const _Random_iterator &  _End, const _Function &  _Func, const size_t  _Chunk_size = 2048  )

inline

Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted.

Template Parameters

_Allocator	The type of an STL compatible memory allocator.
_Random_iterator	The iterator type of the input range.
_Function	The type of the binary comparator.

Parameters

_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.
_Func	A user-defined predicate function object that defines the comparison criterion to be satisfied by successive elements in the ordering. A binary predicate takes two arguments and returns true when satisfied and false when not satisfied. This comparator function must impose a strict weak ordering on pairs of elements from the sequence.
_Chunk_size	The minimum size of a chunk that will be split into two for parallel execution.

All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. In most cases parallel_buffered_sort will show an improvement in performance over parallel_sort, and you should use it over parallel_sort if you have the memory available.

If you do not supply a binary comparator std::less is used as the default, which requires the element type to provide the operator operator<().

If you do not supply an allocator type or instance, the STL memory allocator std::allocator<T> is used to allocate the buffer.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    _Allocator _Alloc;
    return parallel_buffered_sort<_Allocator, _Random_iterator, _Function>(_Alloc, _Begin, _End, _Func, _Chunk_size);
}

template<typename _Random_iterator , typename _Function >

void Concurrency::parallel_buffered_sort ( const _Random_iterator &  _Begin, const _Random_iterator &  _End, const _Function &  _Func, const size_t  _Chunk_size = 2048  )

inline

Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted.

Template Parameters

_Random_iterator	The iterator type of the input range.
_Function	The type of the binary comparator.

Parameters

_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.
_Func	A user-defined predicate function object that defines the comparison criterion to be satisfied by successive elements in the ordering. A binary predicate takes two arguments and returns true when satisfied and false when not satisfied. This comparator function must impose a strict weak ordering on pairs of elements from the sequence.
_Chunk_size	The minimum size of a chunk that will be split into two for parallel execution.

All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. In most cases parallel_buffered_sort will show an improvement in performance over parallel_sort, and you should use it over parallel_sort if you have the memory available.

If you do not supply a binary comparator std::less is used as the default, which requires the element type to provide the operator operator<().

If you do not supply an allocator type or instance, the STL memory allocator std::allocator<T> is used to allocate the buffer.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    parallel_buffered_sort<std::allocator<typename std::iterator_traits<_Random_iterator>::value_type>>(_Begin, _End, _Func, _Chunk_size);
}

template<typename _Random_iterator >

void Concurrency::parallel_buffered_sort ( const _Random_iterator &  _Begin, const _Random_iterator &  _End  )

inline

Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted.

Template Parameters

_Random_iterator

The iterator type of the input range.

Parameters

_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.

All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. In most cases parallel_buffered_sort will show an improvement in performance over parallel_sort, and you should use it over parallel_sort if you have the memory available.

If you do not supply a binary comparator std::less is used as the default, which requires the element type to provide the operator operator<().

If you do not supply an allocator type or instance, the STL memory allocator std::allocator<T> is used to allocate the buffer.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    parallel_buffered_sort<std::allocator<typename std::iterator_traits<_Random_iterator>::value_type>>(_Begin, _End,
        std::less<typename std::iterator_traits<_Random_iterator>::value_type>());
}

template<typename _Allocator , typename _Random_iterator >

void Concurrency::parallel_buffered_sort ( const _Random_iterator &  _Begin, const _Random_iterator &  _End  )

inline

Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted.

Template Parameters

_Allocator	The type of an STL compatible memory allocator.
_Random_iterator	The iterator type of the input range.

Parameters

_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.

All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. In most cases parallel_buffered_sort will show an improvement in performance over parallel_sort, and you should use it over parallel_sort if you have the memory available.

If you do not supply a binary comparator std::less is used as the default, which requires the element type to provide the operator operator<().

If you do not supply an allocator type or instance, the STL memory allocator std::allocator<T> is used to allocate the buffer.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    parallel_buffered_sort<_Allocator>(_Begin, _End,
        std::less<typename std::iterator_traits<_Random_iterator>::value_type>());
}

template<typename _Allocator , typename _Random_iterator >

void Concurrency::parallel_buffered_sort ( const _Allocator &  _Alloc, const _Random_iterator &  _Begin, const _Random_iterator &  _End  )

inline

Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted.

Template Parameters

_Allocator	The type of an STL compatible memory allocator.
_Random_iterator	The iterator type of the input range.

Parameters

_Alloc	An instance of an STL compatible memory allocator.
_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.

All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. In most cases parallel_buffered_sort will show an improvement in performance over parallel_sort, and you should use it over parallel_sort if you have the memory available.

If you do not supply a binary comparator std::less is used as the default, which requires the element type to provide the operator operator<().

If you do not supply an allocator type or instance, the STL memory allocator std::allocator<T> is used to allocate the buffer.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    parallel_buffered_sort<_Allocator>(_Alloc, _Begin, _End, std::less<typename std::iterator_traits<_Random_iterator>::value_type>());
}

template<typename _Index_type , typename _Function , typename _Partitioner >

void Concurrency::parallel_for	(	_Index_type	_First,
		_Index_type	_Last,
		_Index_type	_Step,
		const _Function &	_Func,
		_Partitioner &&	_Part
	)

parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel.

Template Parameters

_Index_type	The type of the index being used for the iteration.
_Function	The type of the function that will be executed at each iteration.
_Partitioner	The type of the partitioner that is used to partition the supplied range.

Parameters

_First	The first index to be included in the iteration.
_Last	The index one past the last index to be included in the iteration.
_Step	The value by which to step when iterating from _First to _Last . The step must be positive. invalid_argument is thrown if the step is less than 1.
_Func	The function to be executed at each iteration. This may be a lambda expression, a function pointer, or any object that supports a version of the function call operator with the signature void operator()(_Index_type ).
_Part	A reference to the partitioner object. The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitionerobject is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

For more information, see Parallel Algorithms.

{
    _Trace_ppl_function(PPLParallelForEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_START);
    _Parallel_for_impl(_First, _Last, _Step, _Func, std::forward<_Partitioner>(_Part));
    _Trace_ppl_function(PPLParallelForEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_END);
}

template<typename _Index_type , typename _Function >

void Concurrency::parallel_for	(	_Index_type	_First,
		_Index_type	_Last,
		_Index_type	_Step,
		const _Function &	_Func
	)

parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel.

Template Parameters

_Index_type	The type of the index being used for the iteration. _Index_type must be an integral type.
_Function	The type of the function that will be executed at each iteration.

Parameters

_First	The first index to be included in the iteration.
_Last	The index one past the last index to be included in the iteration.
_Step	The value by which to step when iterating from _First to _Last . The step must be positive. invalid_argument is thrown if the step is less than 1.
_Func	The function to be executed at each iteration. This may be a lambda expression, a function pointer, or any object that supports a version of the function call operator with the signature void operator()(_Index_type ).

For more information, see Parallel Algorithms.

{
    parallel_for(_First, _Last, _Step, _Func, auto_partitioner());
}

template<typename _Index_type , typename _Function >

void Concurrency::parallel_for	(	_Index_type	_First,
		_Index_type	_Last,
		const _Function &	_Func,
		const auto_partitioner &	_Part = auto_partitioner()
	)

parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel.

Template Parameters

_Index_type	The type of the index being used for the iteration.
_Function	The type of the function that will be executed at each iteration.

Parameters

_First	The first index to be included in the iteration.
_Last	The index one past the last index to be included in the iteration.
_Func	The function to be executed at each iteration. This may be a lambda expression, a function pointer, or any object that supports a version of the function call operator with the signature void operator()(_Index_type ).
_Part	A reference to the partitioner object. The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitionerobject is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

For more information, see Parallel Algorithms.

{
    parallel_for(_First, _Last, _Index_type(1), _Func, _Part);
}

template<typename _Index_type , typename _Function >

void Concurrency::parallel_for	(	_Index_type	_First,
		_Index_type	_Last,
		const _Function &	_Func,
		const static_partitioner &	_Part
	)

parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel.

Template Parameters

_Index_type	The type of the index being used for the iteration.
_Function	The type of the function that will be executed at each iteration.

Parameters

_First	The first index to be included in the iteration.
_Last	The index one past the last index to be included in the iteration.
_Func	The function to be executed at each iteration. This may be a lambda expression, a function pointer, or any object that supports a version of the function call operator with the signature void operator()(_Index_type ).
_Part	A reference to the partitioner object. The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitionerobject is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

For more information, see Parallel Algorithms.

{
    parallel_for(_First, _Last, _Index_type(1), _Func, _Part);
}

template<typename _Index_type , typename _Function >

void Concurrency::parallel_for	(	_Index_type	_First,
		_Index_type	_Last,
		const _Function &	_Func,
		const simple_partitioner &	_Part
	)

parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel.

Template Parameters

_Index_type	The type of the index being used for the iteration.
_Function	The type of the function that will be executed at each iteration.

Parameters

_First	The first index to be included in the iteration.
_Last	The index one past the last index to be included in the iteration.
_Func	The function to be executed at each iteration. This may be a lambda expression, a function pointer, or any object that supports a version of the function call operator with the signature void operator()(_Index_type ).
_Part	A reference to the partitioner object. The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitionerobject is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

For more information, see Parallel Algorithms.

{
    parallel_for(_First, _Last, _Index_type(1), _Func, _Part);
}

template<typename _Index_type , typename _Function >

void Concurrency::parallel_for	(	_Index_type	_First,
		_Index_type	_Last,
		const _Function &	_Func,
		affinity_partitioner &	_Part
	)

parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel.

Template Parameters

_Index_type	The type of the index being used for the iteration.
_Function	The type of the function that will be executed at each iteration.

Parameters

_First	The first index to be included in the iteration.
_Last	The index one past the last index to be included in the iteration.
_Func	The function to be executed at each iteration. This may be a lambda expression, a function pointer, or any object that supports a version of the function call operator with the signature void operator()(_Index_type ).
_Part	A reference to the partitioner object. The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitionerobject is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

For more information, see Parallel Algorithms.

{
    parallel_for(_First, _Last, _Index_type(1), _Func, _Part);
}

template<typename _Iterator , typename _Function >

void Concurrency::parallel_for_each	(	_Iterator	_First,
		_Iterator	_Last,
		const _Function &	_Func
	)

parallel_for_each applies a specified function to each element within a range, in parallel. It is semantically equivalent to the for_each function in the std namespace, except that iteration over the elements is performed in parallel, and the order of iteration is unspecified. The argument _Func must support a function call operator of the form operator()(T) where the parameter T is the item type of the container being iterated over.

Template Parameters

_Iterator	The type of the iterator being used to iterate over the container.
_Function	The type of the function that will be applied to each element within the range.

Parameters

_First	An iterator addressing the position of the first element to be included in parallel iteration.
_Last	An iterator addressing the position one past the final element to be included in parallel iteration.
_Func	A user-defined function object that is applied to each element in the range.

auto_partitioner

will be used for the overload without an explicit partitioner.

For iterators that do not support random access, only auto_partitioner

is supported.

For more information, see Parallel Algorithms.

{
    parallel_for_each(_First, _Last, _Func, auto_partitioner());
}

template<typename _Iterator , typename _Function , typename _Partitioner >

void Concurrency::parallel_for_each	(	_Iterator	_First,
		_Iterator	_Last,
		const _Function &	_Func,
		_Partitioner &&	_Part
	)

parallel_for_each applies a specified function to each element within a range, in parallel. It is semantically equivalent to the for_each function in the std namespace, except that iteration over the elements is performed in parallel, and the order of iteration is unspecified. The argument _Func must support a function call operator of the form operator()(T) where the parameter T is the item type of the container being iterated over.

Template Parameters

_Iterator	The type of the iterator being used to iterate over the container.
_Function	The type of the function that will be applied to each element within the range.

Parameters

_First	An iterator addressing the position of the first element to be included in parallel iteration.
_Last	An iterator addressing the position one past the final element to be included in parallel iteration.
_Func	A user-defined function object that is applied to each element in the range.
_Part	A reference to the partitioner object. The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitionerobject is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

auto_partitioner

will be used for the overload without an explicit partitioner.

For iterators that do not support random access, only auto_partitioner

is supported.

For more information, see Parallel Algorithms.

{
    _Trace_ppl_function(PPLParallelForeachEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_START);
    _Parallel_for_each_impl(_First, _Last, _Func, std::forward<_Partitioner>(_Part), typename std::iterator_traits<_Iterator>::iterator_category());
    _Trace_ppl_function(PPLParallelForeachEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_END);
}

template<int _Rank, typename _Kernel_type >

void Concurrency::parallel_for_each	(	const extent< _Rank > &	_Compute_domain,
		const _Kernel_type &	_Kernel
	)

Invokes a parallel computation of a kernel function over a compute domain on an accelerator_view. The accelerator_view is determined from the arrays and/or array_views captured by the kernel function, or if no accelerator_view can be derived, the default is chosen.

Parameters

_Compute_domain	An extent which represents the set of indices that form the compute domain.
_Kernel	A function object that takes an argument of type "index<_Rank>" which performs the parallel computation.

{
    _Host_Scheduling_info _SchedulingInfo = {accelerator::get_auto_selection_view()};
    details::_Parallel_for_each(&_SchedulingInfo, _Compute_domain, _Kernel);
}

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

void Concurrency::parallel_for_each	(	const tiled_extent< _Dim0, _Dim1, _Dim2 > &	_Compute_domain,
		const _Kernel_type &	_Kernel
	)

Invokes a parallel computation of a kernel function over a compute domain that has been tiled into 3-dimensional regions. The accelerator is determined from the arrays and/or array_views captured by the kernel function, or if no accelerator can be derived, the default is chosen.

Parameters

_Compute_domain	A tiled_extent<_Dim0,_Dim1,_Dim2> which represents the tiled set of indices that form the compute domain.
_Kernel	A function object that takes an argument of type "tiled_index&lt;_Dim0,_Dim1,_Dim2&gt;" which performs the parallel computation.

{
    _Host_Scheduling_info _SchedulingInfo = {accelerator::get_auto_selection_view()};
    details::_Parallel_for_each(&_SchedulingInfo, _Compute_domain, _Kernel);
}

template<int _Dim0, int _Dim1, typename _Kernel_type >

void Concurrency::parallel_for_each	(	const tiled_extent< _Dim0, _Dim1 > &	_Compute_domain,
		const _Kernel_type &	_Kernel
	)

Invokes a parallel computation of a kernel function over a compute domain that has been tiled into 2-dimensional regions. The accelerator is determined from the arrays and/or array_views captured by the kernel function, or if no accelerator can be derived, the default is chosen.

Parameters

_Compute_domain	A tiled_extent<_Dim0,_Dim1> which represents the tiled set of indices that form the compute domain.
_Kernel	A function object that takes an argument of type "tiled_index&lt;_Dim0,_Dim1&gt;" which performs the parallel computation.

{
    _Host_Scheduling_info _SchedulingInfo = {accelerator::get_auto_selection_view()};
    details::_Parallel_for_each(&_SchedulingInfo, _Compute_domain, _Kernel);
}

template<int _Dim0, typename _Kernel_type >

void Concurrency::parallel_for_each	(	const tiled_extent< _Dim0 > &	_Compute_domain,
		const _Kernel_type &	_Kernel
	)

Invokes a parallel computation of a kernel function over a compute domain that has been tiled into 1-dimensional regions. The accelerator is determined from the arrays and/or array_views captured by the kernel function, or if no accelerator can be derived, the default is chosen.

Parameters

_Compute_domain	A tiled_extent<_Dim0> which represents the tiled set of indices that form the compute domain.
_Kernel	A function object that takes an argument of type "tiled_index&lt;_Dim0&gt;" which performs the parallel computation.

{
    _Host_Scheduling_info _SchedulingInfo = {accelerator::get_auto_selection_view()};
    details::_Parallel_for_each(&_SchedulingInfo, _Compute_domain, _Kernel);
}

template<int _Rank, typename _Kernel_type >

void Concurrency::parallel_for_each	(	const accelerator_view &	_Accl_view,
		const extent< _Rank > &	_Compute_domain,
		const _Kernel_type &	_Kernel
	)

Invokes a parallel computation of a kernel function over a compute domain on an accelerator.

Parameters

_Accl_view	The accelerator_view upon which to run this parallel computation.
_Compute_domain	An extent which represents the set of indices that form the compute domain.
_Kernel	A function object that takes an argument of type "index<_Rank>" which performs the parallel computation.

{
    _Host_Scheduling_info _SchedulingInfo = {_Accl_view};
    details::_Parallel_for_each(&_SchedulingInfo, _Compute_domain, _Kernel);
}

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

void Concurrency::parallel_for_each	(	const accelerator_view &	_Accl_view,
		const tiled_extent< _Dim0, _Dim1, _Dim2 > &	_Compute_domain,
		const _Kernel_type &	_Kernel
	)

Invokes a parallel computation of a kernel function over a compute domain that has been tiled into 3-dimensional regions.

Parameters

_Accl_view	The accelerator_view upon which to run this parallel computation.
_Compute_domain	A tiled_extent<_Dim0,_Dim1,_Dim2> which represents the tiled set of indices that form the compute domain.
_Kernel	A function object that takes an argument of type "tiled_index&lt;_Dim0,_Dim1,_Dim2&gt;" which performs the parallel computation.

{
    _Host_Scheduling_info _SchedulingInfo = {_Accl_view};
    details::_Parallel_for_each(&_SchedulingInfo, _Compute_domain, _Kernel);
}

template<int _Dim0, int _Dim1, typename _Kernel_type >

void Concurrency::parallel_for_each	(	const accelerator_view &	_Accl_view,
		const tiled_extent< _Dim0, _Dim1 > &	_Compute_domain,
		const _Kernel_type &	_Kernel
	)

Invokes a parallel computation of a kernel function over a compute domain that has been tiled into 2-dimensional regions.

Parameters

_Accl_view	The accelerator_view upon which to run this parallel computation.
_Compute_domain	A tiled_extent<_Dim0,_Dim1> which represents the tiled set of indices that form the compute domain.
_Kernel	A function object that takes an argument of type "tiled_index&lt;_Dim0,_Dim1&gt;" which performs the parallel computation.

{
    _Host_Scheduling_info _SchedulingInfo = {_Accl_view};
    details::_Parallel_for_each(&_SchedulingInfo, _Compute_domain, _Kernel);
}

template<int _Dim0, typename _Kernel_type >

void Concurrency::parallel_for_each	(	const accelerator_view &	_Accl_view,
		const tiled_extent< _Dim0 > &	_Compute_domain,
		const _Kernel_type &	_Kernel
	)

Invokes a parallel computation of a kernel function over a compute domain that has been tiled into 1-dimensional regions.

Parameters

_Accl_view	The accelerator_view upon which to run this parallel computation.
_Compute_domain	A tiled_extent<_Dim0> which represents the tiled set of indices that form the compute domain.
_Kernel	A function object that takes an argument of type "tiled_index&lt;_Dim0&gt;" which performs the parallel computation.

{
    _Host_Scheduling_info _SchedulingInfo = {_Accl_view};
    details::_Parallel_for_each(&_SchedulingInfo, _Compute_domain, _Kernel);
}

template<typename _Function1 , typename _Function2 >

void Concurrency::parallel_invoke	(	const _Function1 &	_Func1,
		const _Function2 &	_Func2
	)

Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()().

Template Parameters

_Function1	The type of the first function object to be executed in parallel.
_Function2	The type of the second function object to be executed in parallel.

Parameters

_Func1	The first function object to be executed in parallel.
_Func2	The second function object to be executed in parallel.

Note that one or more of the function objects supplied as parameters may execute inline on the calling context.

If one or more of the function objects passed as parameters to this function throws an exception, the runtime will select one such exception of its choosing and propagate it out of the call to parallel_invoke.

For more information, see Parallel Algorithms.

{
    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_START);

    _Parallel_invoke_impl(_Func1, _Func2);

    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_END);
}

template<typename _Function1 , typename _Function2 , typename _Function3 >

void Concurrency::parallel_invoke	(	const _Function1 &	_Func1,
		const _Function2 &	_Func2,
		const _Function3 &	_Func3
	)

Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()().

Template Parameters

_Function1	The type of the first function object to be executed in parallel.
_Function2	The type of the second function object to be executed in parallel.
_Function3	The type of the third function object to be executed in parallel.

Parameters

_Func1	The first function object to be executed in parallel.
_Func2	The second function object to be executed in parallel.
_Func3	The third function object to be executed in parallel.

Note that one or more of the function objects supplied as parameters may execute inline on the calling context.

If one or more of the function objects passed as parameters to this function throws an exception, the runtime will select one such exception of its choosing and propagate it out of the call to parallel_invoke.

For more information, see Parallel Algorithms.

{
    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_START);

    structured_task_group _Task_group;

    task_handle<_Function1> _Task_handle1(_Func1);
    _Task_group.run(_Task_handle1);

    task_handle<_Function2> _Task_handle2(_Func2);
    _Task_group.run(_Task_handle2);

    task_handle<_Function3> _Task_handle3(_Func3);
    _Task_group.run_and_wait(_Task_handle3);

    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_END);
}

template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 >

void Concurrency::parallel_invoke	(	const _Function1 &	_Func1,
		const _Function2 &	_Func2,
		const _Function3 &	_Func3,
		const _Function4 &	_Func4
	)

Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()().

Template Parameters

_Function1	The type of the first function object to be executed in parallel.
_Function2	The type of the second function object to be executed in parallel.
_Function3	The type of the third function object to be executed in parallel.
_Function4	The type of the fourth function object to be executed in parallel.

Parameters

_Func1	The first function object to be executed in parallel.
_Func2	The second function object to be executed in parallel.
_Func3	The third function object to be executed in parallel.
_Func4	The fourth function object to be executed in parallel.

Note that one or more of the function objects supplied as parameters may execute inline on the calling context.

If one or more of the function objects passed as parameters to this function throws an exception, the runtime will select one such exception of its choosing and propagate it out of the call to parallel_invoke.

For more information, see Parallel Algorithms.

{
    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_START);

    structured_task_group _Task_group;

    task_handle<_Function1> _Task_handle1(_Func1);
    _Task_group.run(_Task_handle1);

    task_handle<_Function2> _Task_handle2(_Func2);
    _Task_group.run(_Task_handle2);

    task_handle<_Function3> _Task_handle3(_Func3);
    _Task_group.run(_Task_handle3);

    task_handle<_Function4> _Task_handle4(_Func4);
    _Task_group.run_and_wait(_Task_handle4);

    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_END);
}

template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 >

void Concurrency::parallel_invoke	(	const _Function1 &	_Func1,
		const _Function2 &	_Func2,
		const _Function3 &	_Func3,
		const _Function4 &	_Func4,
		const _Function5 &	_Func5
	)

Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()().

Template Parameters

_Function1	The type of the first function object to be executed in parallel.
_Function2	The type of the second function object to be executed in parallel.
_Function3	The type of the third function object to be executed in parallel.
_Function4	The type of the fourth function object to be executed in parallel.
_Function5	The type of the fifth function object to be executed in parallel.

Parameters

_Func1	The first function object to be executed in parallel.
_Func2	The second function object to be executed in parallel.
_Func3	The third function object to be executed in parallel.
_Func4	The fourth function object to be executed in parallel.
_Func5	The fifth function object to be executed in parallel.

Note that one or more of the function objects supplied as parameters may execute inline on the calling context.

If one or more of the function objects passed as parameters to this function throws an exception, the runtime will select one such exception of its choosing and propagate it out of the call to parallel_invoke.

For more information, see Parallel Algorithms.

{
    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_START);

    structured_task_group _Task_group;

    task_handle<_Function1> _Task_handle1(_Func1);
    _Task_group.run(_Task_handle1);

    task_handle<_Function2> _Task_handle2(_Func2);
    _Task_group.run(_Task_handle2);

    task_handle<_Function3> _Task_handle3(_Func3);
    _Task_group.run(_Task_handle3);

    task_handle<_Function4> _Task_handle4(_Func4);
    _Task_group.run(_Task_handle4);

    task_handle<_Function5> _Task_handle5(_Func5);
    _Task_group.run_and_wait(_Task_handle5);

    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_END);
}

template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 >

void Concurrency::parallel_invoke	(	const _Function1 &	_Func1,
		const _Function2 &	_Func2,
		const _Function3 &	_Func3,
		const _Function4 &	_Func4,
		const _Function5 &	_Func5,
		const _Function6 &	_Func6
	)

Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()().

Template Parameters

_Function1	The type of the first function object to be executed in parallel.
_Function2	The type of the second function object to be executed in parallel.
_Function3	The type of the third function object to be executed in parallel.
_Function4	The type of the fourth function object to be executed in parallel.
_Function5	The type of the fifth function object to be executed in parallel.
_Function6	The type of the sixth function object to be executed in parallel.

Parameters

_Func1	The first function object to be executed in parallel.
_Func2	The second function object to be executed in parallel.
_Func3	The third function object to be executed in parallel.
_Func4	The fourth function object to be executed in parallel.
_Func5	The fifth function object to be executed in parallel.
_Func6	The sixth function object to be executed in parallel.

Note that one or more of the function objects supplied as parameters may execute inline on the calling context.

If one or more of the function objects passed as parameters to this function throws an exception, the runtime will select one such exception of its choosing and propagate it out of the call to parallel_invoke.

For more information, see Parallel Algorithms.

{
    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_START);

    structured_task_group _Task_group;

    task_handle<_Function1> _Task_handle1(_Func1);
    _Task_group.run(_Task_handle1);

    task_handle<_Function2> _Task_handle2(_Func2);
    _Task_group.run(_Task_handle2);

    task_handle<_Function3> _Task_handle3(_Func3);
    _Task_group.run(_Task_handle3);

    task_handle<_Function4> _Task_handle4(_Func4);
    _Task_group.run(_Task_handle4);

    task_handle<_Function5> _Task_handle5(_Func5);
    _Task_group.run(_Task_handle5);

    task_handle<_Function6> _Task_handle6(_Func6);
    _Task_group.run_and_wait(_Task_handle6);

    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_END);
}

template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 , typename _Function7 >

void Concurrency::parallel_invoke	(	const _Function1 &	_Func1,
		const _Function2 &	_Func2,
		const _Function3 &	_Func3,
		const _Function4 &	_Func4,
		const _Function5 &	_Func5,
		const _Function6 &	_Func6,
		const _Function7 &	_Func7
	)

Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()().

Template Parameters

_Function1	The type of the first function object to be executed in parallel.
_Function2	The type of the second function object to be executed in parallel.
_Function3	The type of the third function object to be executed in parallel.
_Function4	The type of the fourth function object to be executed in parallel.
_Function5	The type of the fifth function object to be executed in parallel.
_Function6	The type of the sixth function object to be executed in parallel.
_Function7	The type of the seventh function object to be executed in parallel.

Parameters

_Func1	The first function object to be executed in parallel.
_Func2	The second function object to be executed in parallel.
_Func3	The third function object to be executed in parallel.
_Func4	The fourth function object to be executed in parallel.
_Func5	The fifth function object to be executed in parallel.
_Func6	The sixth function object to be executed in parallel.
_Func7	The seventh function object to be executed in parallel.

Note that one or more of the function objects supplied as parameters may execute inline on the calling context.

If one or more of the function objects passed as parameters to this function throws an exception, the runtime will select one such exception of its choosing and propagate it out of the call to parallel_invoke.

For more information, see Parallel Algorithms.

{
    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_START);

    structured_task_group _Task_group;

    task_handle<_Function1> _Task_handle1(_Func1);
    _Task_group.run(_Task_handle1);

    task_handle<_Function2> _Task_handle2(_Func2);
    _Task_group.run(_Task_handle2);

    task_handle<_Function3> _Task_handle3(_Func3);
    _Task_group.run(_Task_handle3);

    task_handle<_Function4> _Task_handle4(_Func4);
    _Task_group.run(_Task_handle4);

    task_handle<_Function5> _Task_handle5(_Func5);
    _Task_group.run(_Task_handle5);

    task_handle<_Function6> _Task_handle6(_Func6);
    _Task_group.run(_Task_handle6);

    task_handle<_Function7> _Task_handle7(_Func7);
    _Task_group.run_and_wait(_Task_handle7);

    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_END);
}

template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 , typename _Function7 , typename _Function8 >

void Concurrency::parallel_invoke	(	const _Function1 &	_Func1,
		const _Function2 &	_Func2,
		const _Function3 &	_Func3,
		const _Function4 &	_Func4,
		const _Function5 &	_Func5,
		const _Function6 &	_Func6,
		const _Function7 &	_Func7,
		const _Function8 &	_Func8
	)

Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()().

Template Parameters

_Function1	The type of the first function object to be executed in parallel.
_Function2	The type of the second function object to be executed in parallel.
_Function3	The type of the third function object to be executed in parallel.
_Function4	The type of the fourth function object to be executed in parallel.
_Function5	The type of the fifth function object to be executed in parallel.
_Function6	The type of the sixth function object to be executed in parallel.
_Function7	The type of the seventh function object to be executed in parallel.
_Function8	The type of the eighth function object to be executed in parallel.

Parameters

_Func1	The first function object to be executed in parallel.
_Func2	The second function object to be executed in parallel.
_Func3	The third function object to be executed in parallel.
_Func4	The fourth function object to be executed in parallel.
_Func5	The fifth function object to be executed in parallel.
_Func6	The sixth function object to be executed in parallel.
_Func7	The seventh function object to be executed in parallel.
_Func8	The eighth function object to be executed in parallel.

Note that one or more of the function objects supplied as parameters may execute inline on the calling context.

If one or more of the function objects passed as parameters to this function throws an exception, the runtime will select one such exception of its choosing and propagate it out of the call to parallel_invoke.

For more information, see Parallel Algorithms.

{
    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_START);

    structured_task_group _Task_group;

    task_handle<_Function1> _Task_handle1(_Func1);
    _Task_group.run(_Task_handle1);

    task_handle<_Function2> _Task_handle2(_Func2);
    _Task_group.run(_Task_handle2);

    task_handle<_Function3> _Task_handle3(_Func3);
    _Task_group.run(_Task_handle3);

    task_handle<_Function4> _Task_handle4(_Func4);
    _Task_group.run(_Task_handle4);

    task_handle<_Function5> _Task_handle5(_Func5);
    _Task_group.run(_Task_handle5);

    task_handle<_Function6> _Task_handle6(_Func6);
    _Task_group.run(_Task_handle6);

    task_handle<_Function7> _Task_handle7(_Func7);
    _Task_group.run(_Task_handle7);

    task_handle<_Function8> _Task_handle8(_Func8);
    _Task_group.run_and_wait(_Task_handle8);

    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_END);
}

template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 , typename _Function7 , typename _Function8 , typename _Function9 >

void Concurrency::parallel_invoke	(	const _Function1 &	_Func1,
		const _Function2 &	_Func2,
		const _Function3 &	_Func3,
		const _Function4 &	_Func4,
		const _Function5 &	_Func5,
		const _Function6 &	_Func6,
		const _Function7 &	_Func7,
		const _Function8 &	_Func8,
		const _Function9 &	_Func9
	)

Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()().

Template Parameters

_Function1	The type of the first function object to be executed in parallel.
_Function2	The type of the second function object to be executed in parallel.
_Function3	The type of the third function object to be executed in parallel.
_Function4	The type of the fourth function object to be executed in parallel.
_Function5	The type of the fifth function object to be executed in parallel.
_Function6	The type of the sixth function object to be executed in parallel.
_Function7	The type of the seventh function object to be executed in parallel.
_Function8	The type of the eighth function object to be executed in parallel.
_Function9	The type of the ninth function object to be executed in parallel.

Parameters

_Func1	The first function object to be executed in parallel.
_Func2	The second function object to be executed in parallel.
_Func3	The third function object to be executed in parallel.
_Func4	The fourth function object to be executed in parallel.
_Func5	The fifth function object to be executed in parallel.
_Func6	The sixth function object to be executed in parallel.
_Func7	The seventh function object to be executed in parallel.
_Func8	The eighth function object to be executed in parallel.
_Func9	The ninth function object to be executed in parallel.

Note that one or more of the function objects supplied as parameters may execute inline on the calling context.

If one or more of the function objects passed as parameters to this function throws an exception, the runtime will select one such exception of its choosing and propagate it out of the call to parallel_invoke.

For more information, see Parallel Algorithms.

{
    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_START);

    structured_task_group _Task_group;

    task_handle<_Function1> _Task_handle1(_Func1);
    _Task_group.run(_Task_handle1);

    task_handle<_Function2> _Task_handle2(_Func2);
    _Task_group.run(_Task_handle2);

    task_handle<_Function3> _Task_handle3(_Func3);
    _Task_group.run(_Task_handle3);

    task_handle<_Function4> _Task_handle4(_Func4);
    _Task_group.run(_Task_handle4);

    task_handle<_Function5> _Task_handle5(_Func5);
    _Task_group.run(_Task_handle5);

    task_handle<_Function6> _Task_handle6(_Func6);
    _Task_group.run(_Task_handle6);

    task_handle<_Function7> _Task_handle7(_Func7);
    _Task_group.run(_Task_handle7);

    task_handle<_Function8> _Task_handle8(_Func8);
    _Task_group.run(_Task_handle8);

    task_handle<_Function9> _Task_handle9(_Func9);
    _Task_group.run_and_wait(_Task_handle9);

    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_END);
}

template<typename _Function1 , typename _Function2 , typename _Function3 , typename _Function4 , typename _Function5 , typename _Function6 , typename _Function7 , typename _Function8 , typename _Function9 , typename _Function10 >

void Concurrency::parallel_invoke	(	const _Function1 &	_Func1,
		const _Function2 &	_Func2,
		const _Function3 &	_Func3,
		const _Function4 &	_Func4,
		const _Function5 &	_Func5,
		const _Function6 &	_Func6,
		const _Function7 &	_Func7,
		const _Function8 &	_Func8,
		const _Function9 &	_Func9,
		const _Function10 &	_Func10
	)

Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the signature void operator()().

Template Parameters

_Function1	The type of the first function object to be executed in parallel.
_Function2	The type of the second function object to be executed in parallel.
_Function3	The type of the third function object to be executed in parallel.
_Function4	The type of the fourth function object to be executed in parallel.
_Function5	The type of the fifth function object to be executed in parallel.
_Function6	The type of the sixth function object to be executed in parallel.
_Function7	The type of the seventh function object to be executed in parallel.
_Function8	The type of the eighth function object to be executed in parallel.
_Function9	The type of the ninth function object to be executed in parallel.
_Function10	The type of the tenth function object to be executed in parallel.

Parameters

_Func1	The first function object to be executed in parallel.
_Func2	The second function object to be executed in parallel.
_Func3	The third function object to be executed in parallel.
_Func4	The fourth function object to be executed in parallel.
_Func5	The fifth function object to be executed in parallel.
_Func6	The sixth function object to be executed in parallel.
_Func7	The seventh function object to be executed in parallel.
_Func8	The eighth function object to be executed in parallel.
_Func9	The ninth function object to be executed in parallel.
_Func10	The tenth function object to be executed in parallel.

Note that one or more of the function objects supplied as parameters may execute inline on the calling context.

If one or more of the function objects passed as parameters to this function throws an exception, the runtime will select one such exception of its choosing and propagate it out of the call to parallel_invoke.

For more information, see Parallel Algorithms.

{
    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_START);

    structured_task_group _Task_group;

    task_handle<_Function1> _Task_handle1(_Func1);
    _Task_group.run(_Task_handle1);

    task_handle<_Function2> _Task_handle2(_Func2);
    _Task_group.run(_Task_handle2);

    task_handle<_Function3> _Task_handle3(_Func3);
    _Task_group.run(_Task_handle3);

    task_handle<_Function4> _Task_handle4(_Func4);
    _Task_group.run(_Task_handle4);

    task_handle<_Function5> _Task_handle5(_Func5);
    _Task_group.run(_Task_handle5);

    task_handle<_Function6> _Task_handle6(_Func6);
    _Task_group.run(_Task_handle6);

    task_handle<_Function7> _Task_handle7(_Func7);
    _Task_group.run(_Task_handle7);

    task_handle<_Function8> _Task_handle8(_Func8);
    _Task_group.run(_Task_handle8);

    task_handle<_Function9> _Task_handle9(_Func9);
    _Task_group.run(_Task_handle9);

    task_handle<_Function10> _Task_handle10(_Func10);
    _Task_group.run_and_wait(_Task_handle10);

    _Trace_ppl_function(PPLParallelInvokeEventGuid, _TRACE_LEVEL_INFORMATION, CONCRT_EVENT_END);
}

template<typename _Random_iterator >

void Concurrency::parallel_radixsort ( const _Random_iterator &  _Begin, const _Random_iterator &  _End  )

inline

Arranges elements in a specified range into an non descending order using a radix sorting algorithm. This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. Default initialization is required for the elements being sorted.

Template Parameters

_Random_iterator

The iterator type of the input range.

Parameters

_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.

All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. A unary projection functor with the signature<c>I _Proj_func(T) is required to return a key when given an element, where T is the element type and I is an unsigned integer-like type.

If you do not supply a projection function, a default projection function which simply returns the element is used for integral types. The function will fail to compile if the element is not an integral type in the absence of a projection function.

If you do not supply an allocator type or instance, the STL memory allocator std::allocator<T> is used to allocate the buffer.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    typedef typename std::iterator_traits<_Random_iterator>::value_type _DataType;

    _Radix_sort_default_function<_DataType> _Proj_func;

    parallel_radixsort<std::allocator<_DataType>>(_Begin, _End, _Proj_func, 256 * 256);
}

template<typename _Allocator , typename _Random_iterator >

void Concurrency::parallel_radixsort ( const _Allocator &  _Alloc, const _Random_iterator &  _Begin, const _Random_iterator &  _End  )

inline

Arranges elements in a specified range into an non descending order using a radix sorting algorithm. This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. Default initialization is required for the elements being sorted.

Template Parameters

_Allocator	The type of an STL compatible memory allocator.
_Random_iterator	The iterator type of the input range.

Parameters

_Alloc	An instance of an STL compatible memory allocator.
_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.

All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. A unary projection functor with the signature<c>I _Proj_func(T) is required to return a key when given an element, where T is the element type and I is an unsigned integer-like type.

If you do not supply a projection function, a default projection function which simply returns the element is used for integral types. The function will fail to compile if the element is not an integral type in the absence of a projection function.

If you do not supply an allocator type or instance, the STL memory allocator std::allocator<T> is used to allocate the buffer.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    typedef typename std::iterator_traits<_Random_iterator>::value_type _DataType;

    _Radix_sort_default_function<_DataType> _Proj_func;

    parallel_radixsort<_Allocator>(_Alloc, _Begin, _End, _Proj_func);
}

template<typename _Allocator , typename _Random_iterator >

void Concurrency::parallel_radixsort ( const _Random_iterator &  _Begin, const _Random_iterator &  _End  )

inline

Arranges elements in a specified range into an non descending order using a radix sorting algorithm. This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. Default initialization is required for the elements being sorted.

Template Parameters

_Allocator	The type of an STL compatible memory allocator.
_Random_iterator	The iterator type of the input range.

Parameters

_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.

All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. A unary projection functor with the signature<c>I _Proj_func(T) is required to return a key when given an element, where T is the element type and I is an unsigned integer-like type.

If you do not supply a projection function, a default projection function which simply returns the element is used for integral types. The function will fail to compile if the element is not an integral type in the absence of a projection function.

If you do not supply an allocator type or instance, the STL memory allocator std::allocator<T> is used to allocate the buffer.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    _Allocator _Alloc;
    return parallel_radixsort<_Allocator, _Random_iterator>(_Alloc, _Begin, _End);
}

template<typename _Allocator , typename _Random_iterator , typename _Function >

void Concurrency::parallel_radixsort ( const _Allocator &  _Alloc, const _Random_iterator &  _Begin, const _Random_iterator &  _End, const _Function &  _Proj_func, const size_t  _Chunk_size = 256 * 256  )

inline

Arranges elements in a specified range into an non descending order using a radix sorting algorithm. This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. Default initialization is required for the elements being sorted.

Template Parameters

_Allocator	The type of an STL compatible memory allocator.
_Random_iterator	The iterator type of the input range.
_Function	The type of the projection function.

Parameters

_Alloc	An instance of an STL compatible memory allocator.
_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.
_Proj_func	A user-defined projection function object that converts an element into an integral value.
_Chunk_size	The minimum size of a chunk that will be split into two for parallel execution.

All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. A unary projection functor with the signature<c>I _Proj_func(T) is required to return a key when given an element, where T is the element type and I is an unsigned integer-like type.

If you do not supply a projection function, a default projection function which simply returns the element is used for integral types. The function will fail to compile if the element is not an integral type in the absence of a projection function.

If you do not supply an allocator type or instance, the STL memory allocator std::allocator<T> is used to allocate the buffer.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    _CONCRT_ASSERT(_Chunk_size > 0);

    // Check for cancellation before the algorithm starts.
    interruption_point();

    size_t _Size = _End - _Begin;

    // If _Size <= 1, no more sorting needs to be done.
    if (_Size <= 1)
    {
        return;
    }

    _AllocatedBufferHolder<_Allocator> _Holder(_Size, _Alloc);

    // Prevent cancellation from happening during the algorithm in case it leaves the buffers in unknown state.
    run_with_cancellation_token([&]() {
        _Parallel_integer_sort_asc(_Begin, _Size, stdext::make_unchecked_array_iterator(_Holder._Get_buffer()), _Proj_func, _Chunk_size);
    }, cancellation_token::none());
}

template<typename _Allocator , typename _Random_iterator , typename _Function >

void Concurrency::parallel_radixsort ( const _Random_iterator &  _Begin, const _Random_iterator &  _End, const _Function &  _Proj_func, const size_t  _Chunk_size = 256 * 256  )

inline

Arranges elements in a specified range into an non descending order using a radix sorting algorithm. This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. Default initialization is required for the elements being sorted.

Template Parameters

_Allocator	The type of an STL compatible memory allocator.
_Random_iterator	The iterator type of the input range.
_Function	The type of the projection function.

Parameters

_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.
_Proj_func	A user-defined projection function object that converts an element into an integral value.
_Chunk_size	The minimum size of a chunk that will be split into two for parallel execution.

All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. A unary projection functor with the signature<c>I _Proj_func(T) is required to return a key when given an element, where T is the element type and I is an unsigned integer-like type.

If you do not supply a projection function, a default projection function which simply returns the element is used for integral types. The function will fail to compile if the element is not an integral type in the absence of a projection function.

If you do not supply an allocator type or instance, the STL memory allocator std::allocator<T> is used to allocate the buffer.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    _Allocator _Alloc;
    return parallel_radixsort<_Allocator, _Random_iterator, _Function>(_Alloc, _Begin, _End, _Proj_func, _Chunk_size);
}

template<typename _Random_iterator , typename _Function >

void Concurrency::parallel_radixsort ( const _Random_iterator &  _Begin, const _Random_iterator &  _End, const _Function &  _Proj_func, const size_t  _Chunk_size = 256 * 256  )

inline

Arranges elements in a specified range into an non descending order using a radix sorting algorithm. This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. Default initialization is required for the elements being sorted.

Template Parameters

_Random_iterator	The iterator type of the input range.
_Function	The type of the projection function.

Parameters

_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.
_Proj_func	A user-defined projection function object that converts an element into an integral value.
_Chunk_size	The minimum size of a chunk that will be split into two for parallel execution.

All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. A unary projection functor with the signature<c>I _Proj_func(T) is required to return a key when given an element, where T is the element type and I is an unsigned integer-like type.

If you do not supply a projection function, a default projection function which simply returns the element is used for integral types. The function will fail to compile if the element is not an integral type in the absence of a projection function.

If you do not supply an allocator type or instance, the STL memory allocator std::allocator<T> is used to allocate the buffer.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    parallel_radixsort<std::allocator<typename std::iterator_traits<_Random_iterator>::value_type>>(
        _Begin, _End, _Proj_func, _Chunk_size);
}

template<typename _Reduce_type , typename _Forward_iterator , typename _Range_reduce_fun , typename _Sym_reduce_fun >

_Reduce_type Concurrency::parallel_reduce ( _Forward_iterator  _Begin, _Forward_iterator  _End, const _Reduce_type &  _Identity, const _Range_reduce_fun &  _Range_fun, const _Sym_reduce_fun &  _Sym_fun  )

inline

Computes the sum of all elements in a specified range by computing successive partial sums, or computes the result of successive partial results similarly obtained from using a specified binary operation other than sum, in parallel. parallel_reduce is semantically similar to std::accumulate, except that it requires the binary operation to be associative, and requires an identity value instead of an initial value.

Template Parameters

_Reduce_type	The type that the input will reduce to, which can be different from the input element type. The return value and identity value will has this type.
_Forward_iterator	The iterator type of input range.
_Range_reduce_fun	The type of the range reduction function. This must be a function type with signature _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type), _Reduce_type is the same as the identity type and the result type of the reduction.
_Sym_reduce_fun	The type of the symmetric reduction function. This must be a function type with signature _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type), where _Reduce_type is the same as the identity type and the result type of the reduction. For the third overload, this should be consistent with the output type of _Range_reduce_fun.

Parameters

_Begin	An input iterator addressing the first element in the range to be reduced.
_End	An input iterator addressing the element that is one position beyond the final element in the range to be reduced.
_Identity	The identity value _Identity is of the same type as the result type of the reduction and also the value_type of the iterator for the first and second overloads. For the third overload, the identity value must have the same type as the result type of the reduction, but can be different from the value_type of the iterator. It must have an appropriate value such that the range reduction operator _Range_fun , when applied to a range of a single element of type value_type and the identity value, behaves like a type cast of the value from type value_type to the identity type.
_Range_fun	The function that will be used in the first phase of the reduction. Refer to Remarks for more information.
_Sym_fun	The symmetric function that will be used in the second of the reduction. Refer to Remarks for more information.

Returns

The result of the reduction.

To perform a parallel reduction, the function divides the range into chunks based on the number of workers available to the underlying scheduler. The reduction takes place in two phases, the first phase performs a reduction within each chunk, and the second phase performs a reduction between the partial results from each chunk.

The first overload requires that the iterator's value_type, T, be the same as the identity value type as well as the reduction result type. The element type T must provide the operator T T::operator + (T) to reduce elements in each chunk. The same operator is used in the second phase as well.

The second overload also requires that the iterator's value_type be the same as the identity value type as well as the reduction result type. The supplied binary operator _Sym_fun is used in both reduction phases, with the identity value as the initial value for the first phase.

For the third overload, the identity value type must be the same as the reduction result type, but the iterator's value_type may be different from both. The range reduction function _Range_fun is used in the first phase with the identity value as the initial value, and the binary function _Sym_reduce_fun is applied to sub results in the second phase.

{
    typedef typename std::iterator_traits<_Forward_iterator>::value_type _Value_type;

    static_assert(!std::is_same<typename std::iterator_traits<_Forward_iterator>::iterator_category, std::input_iterator_tag>::value
        && !std::is_same<typename std::iterator_traits<_Forward_iterator>::iterator_category, std::output_iterator_tag>::value,
        "iterator can not be input_iterator or output_iterator.");

    return _Parallel_reduce_impl(_Begin, _End,
        _Reduce_functor_helper<_Reduce_type, _Range_reduce_fun,
            _Order_combinable<_Reduce_type, _Sym_reduce_fun>>(_Identity, _Range_fun, _Order_combinable<_Reduce_type, _Sym_reduce_fun>(_Sym_fun)),
        typename std::iterator_traits<_Forward_iterator>::iterator_category());
}

template<typename _Forward_iterator , typename _Sym_reduce_fun >

std::iterator_traits<_Forward_iterator>::value_type Concurrency::parallel_reduce ( _Forward_iterator  _Begin, _Forward_iterator  _End, const typename std::iterator_traits< _Forward_iterator >::value_type &  _Identity, _Sym_reduce_fun  _Sym_fun  )

inline

Computes the sum of all elements in a specified range by computing successive partial sums, or computes the result of successive partial results similarly obtained from using a specified binary operation other than sum, in parallel. parallel_reduce is semantically similar to std::accumulate, except that it requires the binary operation to be associative, and requires an identity value instead of an initial value.

Template Parameters

_Forward_iterator	The iterator type of input range.
_Sym_reduce_fun	The type of the symmetric reduction function. This must be a function type with signature _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type), where _Reduce_type is the same as the identity type and the result type of the reduction. For the third overload, this should be consistent with the output type of _Range_reduce_fun.

Parameters

_Begin	An input iterator addressing the first element in the range to be reduced.
_End	An input iterator addressing the element that is one position beyond the final element in the range to be reduced.
_Identity	The identity value _Identity is of the same type as the result type of the reduction and also the value_type of the iterator for the first and second overloads. For the third overload, the identity value must have the same type as the result type of the reduction, but can be different from the value_type of the iterator. It must have an appropriate value such that the range reduction operator _Range_fun , when applied to a range of a single element of type value_type and the identity value, behaves like a type cast of the value from type value_type to the identity type.
_Sym_fun	The symmetric function that will be used in the second of the reduction. Refer to Remarks for more information.

Returns

The result of the reduction.

To perform a parallel reduction, the function divides the range into chunks based on the number of workers available to the underlying scheduler. The reduction takes place in two phases, the first phase performs a reduction within each chunk, and the second phase performs a reduction between the partial results from each chunk.

The first overload requires that the iterator's value_type, T, be the same as the identity value type as well as the reduction result type. The element type T must provide the operator T T::operator + (T) to reduce elements in each chunk. The same operator is used in the second phase as well.

The second overload also requires that the iterator's value_type be the same as the identity value type as well as the reduction result type. The supplied binary operator _Sym_fun is used in both reduction phases, with the identity value as the initial value for the first phase.

For the third overload, the identity value type must be the same as the reduction result type, but the iterator's value_type may be different from both. The range reduction function _Range_fun is used in the first phase with the identity value as the initial value, and the binary function _Sym_reduce_fun is applied to sub results in the second phase.

{
    typedef typename std::remove_cv<typename std::iterator_traits<_Forward_iterator>::value_type>::type _Reduce_type;

    return parallel_reduce(_Begin, _End, _Identity,
        [_Sym_fun](_Forward_iterator _Begin, _Forward_iterator _End, _Reduce_type _Init)->_Reduce_type
        {
            while (_Begin != _End)
            {
                _Init = _Sym_fun(_Init, *_Begin++);
            }

            return _Init;
        },
        _Sym_fun);
}

template<typename _Forward_iterator >

std::iterator_traits<_Forward_iterator>::value_type Concurrency::parallel_reduce ( _Forward_iterator  _Begin, _Forward_iterator  _End, const typename std::iterator_traits< _Forward_iterator >::value_type &  _Identity  )

inline

Computes the sum of all elements in a specified range by computing successive partial sums, or computes the result of successive partial results similarly obtained from using a specified binary operation other than sum, in parallel. parallel_reduce is semantically similar to std::accumulate, except that it requires the binary operation to be associative, and requires an identity value instead of an initial value.

Template Parameters

_Forward_iterator

The iterator type of input range.

Parameters

_Begin	An input iterator addressing the first element in the range to be reduced.
_End	An input iterator addressing the element that is one position beyond the final element in the range to be reduced.
_Identity	The identity value _Identity is of the same type as the result type of the reduction and also the value_type of the iterator for the first and second overloads. For the third overload, the identity value must have the same type as the result type of the reduction, but can be different from the value_type of the iterator. It must have an appropriate value such that the range reduction operator _Range_fun , when applied to a range of a single element of type value_type and the identity value, behaves like a type cast of the value from type value_type to the identity type.

Returns

The result of the reduction.

To perform a parallel reduction, the function divides the range into chunks based on the number of workers available to the underlying scheduler. The reduction takes place in two phases, the first phase performs a reduction within each chunk, and the second phase performs a reduction between the partial results from each chunk.

The first overload requires that the iterator's value_type, T, be the same as the identity value type as well as the reduction result type. The element type T must provide the operator T T::operator + (T) to reduce elements in each chunk. The same operator is used in the second phase as well.

The second overload also requires that the iterator's value_type be the same as the identity value type as well as the reduction result type. The supplied binary operator _Sym_fun is used in both reduction phases, with the identity value as the initial value for the first phase.

For the third overload, the identity value type must be the same as the reduction result type, but the iterator's value_type may be different from both. The range reduction function _Range_fun is used in the first phase with the identity value as the initial value, and the binary function _Sym_reduce_fun is applied to sub results in the second phase.

{
    return parallel_reduce(_Begin, _End, _Identity, std::plus<typename std::iterator_traits<_Forward_iterator>::value_type>());
}

template<typename _Random_iterator , typename _Function >

void Concurrency::parallel_sort ( const _Random_iterator &  _Begin, const _Random_iterator &  _End, const _Function &  _Func, const size_t  _Chunk_size = 2048  )

inline

Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort.

Template Parameters

_Random_iterator	The iterator type of the input range.
_Function	The type of the binary comparison functor.

Parameters

_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.
_Func	A user-defined predicate function object that defines the comparison criterion to be satisfied by successive elements in the ordering. A binary predicate takes two arguments and returns true when satisfied and false when not satisfied. This comparator function must impose a strict weak ordering on pairs of elements from the sequence.
_Chunk_size	The minimum size of a chunk that will be split into two for parallel execution.

The first overload uses the binary comparator std::less.

The second overloaded uses the supplied binary comparator that should have the signature bool _Func(T, T) where T is the type of the elements in the input range.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    _CONCRT_ASSERT(_Chunk_size > 0);

    // Check for cancellation before the algorithm starts.
    interruption_point();

    size_t _Size = _End - _Begin;
    size_t _Core_num = ::Concurrency::details::_CurrentScheduler::_GetNumberOfVirtualProcessors();

    if (_Size <= _Chunk_size || _Core_num < 2)
    {
        return std::sort(_Begin, _End, _Func);
    }

    _Parallel_quicksort_impl(_Begin, _Size, _Func, _Core_num * _MAX_NUM_TASKS_PER_CORE, _Chunk_size, 0);
}

template<typename _Random_iterator >

void Concurrency::parallel_sort ( const _Random_iterator &  _Begin, const _Random_iterator &  _End  )

inline

Arranges the elements in a specified range into a nondescending order, or according to an ordering criterion specified by a binary predicate, in parallel. This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort.

Template Parameters

_Random_iterator

The iterator type of the input range.

Parameters

_Begin	A random-access iterator addressing the position of the first element in the range to be sorted.
_End	A random-access iterator addressing the position one past the final element in the range to be sorted.

The first overload uses the binary comparator std::less.

The second overloaded uses the supplied binary comparator that should have the signature bool _Func(T, T) where T is the type of the elements in the input range.

The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

{
    parallel_sort(_Begin, _End, std::less<typename std::iterator_traits<_Random_iterator>::value_type>());
}

template<typename _Input_iterator1 , typename _Output_iterator , typename _Unary_operator >

_Output_iterator Concurrency::parallel_transform	(	_Input_iterator1	_First1,
		_Input_iterator1	_Last1,
		_Output_iterator	_Result,
		const _Unary_operator&	_Unary_op,
		const auto_partitioner &	_Part = auto_partitioner()
	)

Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. This functional is semantically equivalent to std::transform.

Template Parameters

_Input_iterator1	The type of the first or only input iterator.
_Output_iterator	The type of the output iterator.
_Unary_operator	The type of the unary functor to be executed on each element in the input range.

Parameters

_First1	An input iterator addressing the position of the first element in the first or only source range to be operated on.
_Last1	An input iterator addressing the position one past the final element in the first or only source range to be operated on.
_Result	An output iterator addressing the position of the first element in the destination range.
_Unary_op	A user-defined unary function object that is applied to each element in the source range.
_Part	A reference to the partitioner object. The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitionerobject is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

Returns

An output iterator addressing the position one past the final element in the destination range that is receiving the output elements transformed by the function object.

auto_partitioner

will be used for the overloads without an explicit partitioner argument.

For iterators that do not support random access, only auto_partitioner

is supported.

The overloads that take the argument _Unary_op transform the input range into the output range by applying the unary functor to each element in the input range. _Unary_op must support the function call operator with signature operator()(T) where T is the value type of the range being iterated over.

The overloads that take the argument _Binary_op transform two input ranges into the output range by applying the binary functor to one element from the first input range and one element from the second input range. _Binary_op must support the function call operator with signature operator()(T, U) where T, U are value types of the two input iterators.

For more information, see Parallel Algorithms.

{
    return _Parallel_transform_unary_impl(_First1, _Last1, _Result, _Unary_op, _Part);
}

template<typename _Input_iterator1 , typename _Output_iterator , typename _Unary_operator >

_Output_iterator Concurrency::parallel_transform	(	_Input_iterator1	_First1,
		_Input_iterator1	_Last1,
		_Output_iterator	_Result,
		const _Unary_operator&	_Unary_op,
		const static_partitioner &	_Part
	)

Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. This functional is semantically equivalent to std::transform.

Template Parameters

_Input_iterator1	The type of the first or only input iterator.
_Output_iterator	The type of the output iterator.
_Unary_operator	The type of the unary functor to be executed on each element in the input range.

Parameters

_First1	An input iterator addressing the position of the first element in the first or only source range to be operated on.
_Last1	An input iterator addressing the position one past the final element in the first or only source range to be operated on.
_Result	An output iterator addressing the position of the first element in the destination range.
_Unary_op	A user-defined unary function object that is applied to each element in the source range.
_Part	A reference to the partitioner object. The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitionerobject is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

Returns

An output iterator addressing the position one past the final element in the destination range that is receiving the output elements transformed by the function object.

auto_partitioner

will be used for the overloads without an explicit partitioner argument.

For iterators that do not support random access, only auto_partitioner

is supported.

The overloads that take the argument _Unary_op transform the input range into the output range by applying the unary functor to each element in the input range. _Unary_op must support the function call operator with signature operator()(T) where T is the value type of the range being iterated over.

The overloads that take the argument _Binary_op transform two input ranges into the output range by applying the binary functor to one element from the first input range and one element from the second input range. _Binary_op must support the function call operator with signature operator()(T, U) where T, U are value types of the two input iterators.

For more information, see Parallel Algorithms.

{
    return _Parallel_transform_unary_impl(_First1, _Last1, _Result, _Unary_op, _Part);
}

template<typename _Input_iterator1 , typename _Output_iterator , typename _Unary_operator >

_Output_iterator Concurrency::parallel_transform	(	_Input_iterator1	_First1,
		_Input_iterator1	_Last1,
		_Output_iterator	_Result,
		const _Unary_operator&	_Unary_op,
		const simple_partitioner &	_Part
	)

Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. This functional is semantically equivalent to std::transform.

Template Parameters

_Input_iterator1	The type of the first or only input iterator.
_Output_iterator	The type of the output iterator.
_Unary_operator	The type of the unary functor to be executed on each element in the input range.

Parameters

_First1	An input iterator addressing the position of the first element in the first or only source range to be operated on.
_Last1	An input iterator addressing the position one past the final element in the first or only source range to be operated on.
_Result	An output iterator addressing the position of the first element in the destination range.
_Unary_op	A user-defined unary function object that is applied to each element in the source range.
_Part	A reference to the partitioner object. The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitionerobject is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

Returns

An output iterator addressing the position one past the final element in the destination range that is receiving the output elements transformed by the function object.

auto_partitioner

will be used for the overloads without an explicit partitioner argument.

For iterators that do not support random access, only auto_partitioner

is supported.

The overloads that take the argument _Unary_op transform the input range into the output range by applying the unary functor to each element in the input range. _Unary_op must support the function call operator with signature operator()(T) where T is the value type of the range being iterated over.

The overloads that take the argument _Binary_op transform two input ranges into the output range by applying the binary functor to one element from the first input range and one element from the second input range. _Binary_op must support the function call operator with signature operator()(T, U) where T, U are value types of the two input iterators.

For more information, see Parallel Algorithms.

{
    return _Parallel_transform_unary_impl(_First1, _Last1, _Result, _Unary_op, _Part);
}

template<typename _Input_iterator1 , typename _Output_iterator , typename _Unary_operator >

_Output_iterator Concurrency::parallel_transform	(	_Input_iterator1	_First1,
		_Input_iterator1	_Last1,
		_Output_iterator	_Result,
		const _Unary_operator&	_Unary_op,
		affinity_partitioner &	_Part
	)

Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. This functional is semantically equivalent to std::transform.

Template Parameters

_Input_iterator1	The type of the first or only input iterator.
_Output_iterator	The type of the output iterator.
_Unary_operator	The type of the unary functor to be executed on each element in the input range.

Parameters

_First1	An input iterator addressing the position of the first element in the first or only source range to be operated on.
_Last1	An input iterator addressing the position one past the final element in the first or only source range to be operated on.
_Result	An output iterator addressing the position of the first element in the destination range.
_Unary_op	A user-defined unary function object that is applied to each element in the source range.
_Part	A reference to the partitioner object. The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitionerobject is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

Returns

An output iterator addressing the position one past the final element in the destination range that is receiving the output elements transformed by the function object.

auto_partitioner

will be used for the overloads without an explicit partitioner argument.

For iterators that do not support random access, only auto_partitioner

is supported.

The overloads that take the argument _Unary_op transform the input range into the output range by applying the unary functor to each element in the input range. _Unary_op must support the function call operator with signature operator()(T) where T is the value type of the range being iterated over.

The overloads that take the argument _Binary_op transform two input ranges into the output range by applying the binary functor to one element from the first input range and one element from the second input range. _Binary_op must support the function call operator with signature operator()(T, U) where T, U are value types of the two input iterators.

For more information, see Parallel Algorithms.

{
    return _Parallel_transform_unary_impl(_First1, _Last1, _Result, _Unary_op, _Part);
}

template<typename _Input_iterator1 , typename _Input_iterator2 , typename _Output_iterator , typename _Binary_operator , typename _Partitioner >

_Output_iterator Concurrency::parallel_transform	(	_Input_iterator1	_First1,
		_Input_iterator1	_Last1,
		_Input_iterator2	_First2,
		_Output_iterator	_Result,
		const _Binary_operator&	_Binary_op,
		_Partitioner &&	_Part
	)

Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. This functional is semantically equivalent to std::transform.

Template Parameters

_Input_iterator1	The type of the first or only input iterator.
_Input_iterator2	The type of second input iterator.
_Output_iterator	The type of the output iterator.
_Binary_operator	The type of the binary functor executed pairwise on elements from the two source ranges.

Parameters

_First1	An input iterator addressing the position of the first element in the first or only source range to be operated on.
_Last1	An input iterator addressing the position one past the final element in the first or only source range to be operated on.
_First2	An input iterator addressing the position of the first element in the second source range to be operated on.
_Result	An output iterator addressing the position of the first element in the destination range.
_Binary_op	A user-defined binary function object that is applied pairwise, in a forward order, to the two source ranges.
_Part	A reference to the partitioner object. The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitionerobject is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

Returns

An output iterator addressing the position one past the final element in the destination range that is receiving the output elements transformed by the function object.

auto_partitioner

will be used for the overloads without an explicit partitioner argument.

For iterators that do not support random access, only auto_partitioner

is supported.

The overloads that take the argument _Unary_op transform the input range into the output range by applying the unary functor to each element in the input range. _Unary_op must support the function call operator with signature operator()(T) where T is the value type of the range being iterated over.

The overloads that take the argument _Binary_op transform two input ranges into the output range by applying the binary functor to one element from the first input range and one element from the second input range. _Binary_op must support the function call operator with signature operator()(T, U) where T, U are value types of the two input iterators.

For more information, see Parallel Algorithms.

{
    typedef typename std::iterator_traits<_Input_iterator1>::iterator_category _Input_iterator_type1;
    typedef typename std::iterator_traits<_Input_iterator2>::iterator_category _Input_iterator_type2;
    typedef typename std::iterator_traits<_Output_iterator>::iterator_category _Output_iterator_type;

    if (_First1 != _Last1)
    {
        _Binary_transform_impl_helper<_Input_iterator_type1, _Input_iterator_type2, _Output_iterator_type>
            ::_Parallel_transform_binary_impl(_First1, _Last1, _First2, _Result, _Binary_op, std::forward<_Partitioner>(_Part));
    }

    return _Result;
}

template<typename _Input_iterator1 , typename _Input_iterator2 , typename _Output_iterator , typename _Binary_operator >

_Output_iterator Concurrency::parallel_transform	(	_Input_iterator1	_First1,
		_Input_iterator1	_Last1,
		_Input_iterator2	_First2,
		_Output_iterator	_Result,
		const _Binary_operator&	_Binary_op
	)

Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. This functional is semantically equivalent to std::transform.

Template Parameters

_Input_iterator1	The type of the first or only input iterator.
_Input_iterator2	The type of second input iterator.
_Output_iterator	The type of the output iterator.
_Binary_operator	The type of the binary functor executed pairwise on elements from the two source ranges.

Parameters

_First1	An input iterator addressing the position of the first element in the first or only source range to be operated on.
_Last1	An input iterator addressing the position one past the final element in the first or only source range to be operated on.
_First2	An input iterator addressing the position of the first element in the second source range to be operated on.
_Result	An output iterator addressing the position of the first element in the destination range.
_Binary_op	A user-defined binary function object that is applied pairwise, in a forward order, to the two source ranges.

Returns

An output iterator addressing the position one past the final element in the destination range that is receiving the output elements transformed by the function object.

auto_partitioner

will be used for the overloads without an explicit partitioner argument.

For iterators that do not support random access, only auto_partitioner

is supported.

The overloads that take the argument _Unary_op transform the input range into the output range by applying the unary functor to each element in the input range. _Unary_op must support the function call operator with signature operator()(T) where T is the value type of the range being iterated over.

The overloads that take the argument _Binary_op transform two input ranges into the output range by applying the binary functor to one element from the first input range and one element from the second input range. _Binary_op must support the function call operator with signature operator()(T, U) where T, U are value types of the two input iterators.

For more information, see Parallel Algorithms.

{
    return parallel_transform(_First1, _Last1, _First2, _Result, _Binary_op, auto_partitioner());
}

template<class _Type >

_Type Concurrency::receive	(	_Inout_ ISource< _Type > *	_Src,
		unsigned int	_Timeout = COOPERATIVE_TIMEOUT_INFINITE
	)

A general receive implementation, allowing a context to wait for data from exactly one source and filter the values that are accepted.

Template Parameters

_Type

The payload type.

Parameters

_Src	A pointer or reference to the source from which data is expected.
_Timeout	The maximum time for which the method should for the data, in milliseconds.

Returns

A value from the source, of the payload type.

If the parameter _Timeout has a value other than the constant COOPERATIVE_TIMEOUT_INFINITE, the exception operation_timed_out is thrown if the specified amount of time expires before a message is received. If you want a zero length timeout, you should use the try_receive function, as opposed to calling receive with a timeout of 0 (zero), as it is more efficient and does not throw exceptions on timeouts.

For more information, see Message Passing Functions.

See also

try_receive Function, send Function, asend Function

{
    return _Receive_impl(_Src, _Timeout, NULL);
}

template<class _Type >

_Type Concurrency::receive	(	_Inout_ ISource< _Type > *	_Src,
		typename ITarget< _Type >::filter_method const &	_Filter_proc,
		unsigned int	_Timeout = COOPERATIVE_TIMEOUT_INFINITE
	)

A general receive implementation, allowing a context to wait for data from exactly one source and filter the values that are accepted.

Template Parameters

_Type

The payload type.

Parameters

_Src	A pointer or reference to the source from which data is expected.
_Filter_proc	A filter function which determines whether messages should be accepted.
_Timeout	The maximum time for which the method should for the data, in milliseconds.

Returns

A value from the source, of the payload type.

If the parameter _Timeout has a value other than the constant COOPERATIVE_TIMEOUT_INFINITE, the exception operation_timed_out is thrown if the specified amount of time expires before a message is received. If you want a zero length timeout, you should use the try_receive function, as opposed to calling receive with a timeout of 0 (zero), as it is more efficient and does not throw exceptions on timeouts.

For more information, see Message Passing Functions.

See also

try_receive Function, send Function, asend Function

{
    return _Receive_impl(_Src, _Timeout, &_Filter_proc);
}

template<class _Type >

_Type Concurrency::receive	(	ISource< _Type > &	_Src,
		unsigned int	_Timeout = COOPERATIVE_TIMEOUT_INFINITE
	)

A general receive implementation, allowing a context to wait for data from exactly one source and filter the values that are accepted.

Template Parameters

_Type

The payload type.

Parameters

_Src	A pointer or reference to the source from which data is expected.
_Timeout	The maximum time for which the method should for the data, in milliseconds.

Returns

A value from the source, of the payload type.

If the parameter _Timeout has a value other than the constant COOPERATIVE_TIMEOUT_INFINITE, the exception operation_timed_out is thrown if the specified amount of time expires before a message is received. If you want a zero length timeout, you should use the try_receive function, as opposed to calling receive with a timeout of 0 (zero), as it is more efficient and does not throw exceptions on timeouts.

For more information, see Message Passing Functions.

See also

try_receive Function, send Function, asend Function

{
    return _Receive_impl(&_Src, _Timeout, NULL);
}

template<class _Type >

_Type Concurrency::receive	(	ISource< _Type > &	_Src,
		typename ITarget< _Type >::filter_method const &	_Filter_proc,
		unsigned int	_Timeout = COOPERATIVE_TIMEOUT_INFINITE
	)

A general receive implementation, allowing a context to wait for data from exactly one source and filter the values that are accepted.

Template Parameters

_Type

The payload type.

Parameters

_Src	A pointer or reference to the source from which data is expected.
_Filter_proc	A filter function which determines whether messages should be accepted.
_Timeout	The maximum time for which the method should for the data, in milliseconds.

Returns

A value from the source, of the payload type.

If the parameter _Timeout has a value other than the constant COOPERATIVE_TIMEOUT_INFINITE, the exception operation_timed_out is thrown if the specified amount of time expires before a message is received. If you want a zero length timeout, you should use the try_receive function, as opposed to calling receive with a timeout of 0 (zero), as it is more efficient and does not throw exceptions on timeouts.

For more information, see Message Passing Functions.

See also

try_receive Function, send Function, asend Function

{
    return _Receive_impl(&_Src, _Timeout, &_Filter_proc);
}

template<typename _Function >

void Concurrency::run_with_cancellation_token	(	const _Function &	_Func,
		cancellation_token	_Ct
	)

Executes a function object immediately and synchronously in the context of a given cancellation token.

Template Parameters

_Function

The type of the function object that will be invoked.

Parameters

_Func	The function object which will be executed. This object must support the function call operator with a signature of void(void).
_Ct	The cancellation token which will control implicit cancellation of the function object. Use cancellation_token::none() if you want the function execute without any possibility of implicit cancellation from a parent task group being canceled.

Any interruption points in the function object will be triggered when the cancellation_token is canceled. The explicit token _Ct will isolate this _Func from parent cancellation if the parent has a different token or no token.

{
    structured_task_group _Stg(_Ct);
    _Stg.run_and_wait(_Func);
}

template<class _Type >

bool Concurrency::send	(	_Inout_ ITarget< _Type > *	_Trg,
		const _Type &	_Data
	)

A synchronous send operation, which waits until the target either accepts or declines the message.

Template Parameters

_Type

The payload type.

Parameters

_Trg	A pointer or reference to the target to which data is sent.
_Data	A reference to the data to be sent.

Returns

true if the message was accepted, false otherwise.

For more information, see Message Passing Functions.

See also

receive Function, try_receive Function, asend Function

{
    return details::_Originator::_send(_Trg, _Data);
}

template<class _Type >

bool Concurrency::send	(	ITarget< _Type > &	_Trg,
		const _Type &	_Data
	)

A synchronous send operation, which waits until the target either accepts or declines the message.

Template Parameters

_Type

The payload type.

Parameters

_Trg	A pointer or reference to the target to which data is sent.
_Data	A reference to the data to be sent.

Returns

true if the message was accepted, false otherwise.

For more information, see Message Passing Functions.

See also

receive Function, try_receive Function, asend Function

{
    return ::Concurrency::send(&_Trg, _Data);
}

void Concurrency::set_ambient_scheduler ( const ::std::shared_ptr< scheduler_interface > &  _Scheduler )

inline

{
    details::_GetStaticAmbientSchedulerRef() = _Scheduler;
}

template<typename _Ty , class _Ax >

void Concurrency::swap ( concurrent_vector< _Ty, _Ax > &  _A, concurrent_vector< _Ty, _Ax > &  _B  )

inline

Exchanges the elements of two concurrent_vector objects.

Template Parameters

_Ty	The data type of the elements stored in the concurrent vectors.
_Ax	The allocator type of the concurrent vectors.

Parameters

_B	The concurrent vector providing the elements to be swapped, or the vector whose elements are to be exchanged with those of the concurrent vector _A .
_A	The concurrent vector whose elements are to be exchanged with those of the concurrent vector _B .

The template function is an algorithm specialized on the container class concurrent_vector to execute the member function _A .concurrent_vector::swap(_B ). These are instances of the partial ordering of function templates by the compiler. When template functions are overloaded in such a way that the match of the template with the function call is not unique, then the compiler will select the most specialized version of the template function. The general version of the template function, template <class T> void swap(T&, T&), in the algorithm class works by assignment and is a slow operation. The specialized version in each container is much faster as it can work with the internal representation of the container class.

This method is not concurrency-safe. You must ensure that no other threads are performing operations on either of the concurrent vectors when you call this method.

See also

concurrent_vector Class, Parallel Containers and Objects

{
    _A.swap( _B );
}

void Concurrency::tile_static_memory_fence ( const tile_barrier &  _Barrier )

inline

Ensures that tile_static memory accesses are visible to other threads in the thread tile, and are executed according to program order

Parameters

_Barrier

A tile_barrier object

{
    __dp_d3d_tile_static_memory_fence();
}

template<class _Type >

void Concurrency::Trace_agents_register_name	(	_Inout_ _Type *	_PObject,
		_In_z_ const wchar_t *	_Name
	)

Associates the given name to the message block or agent in the ETW trace.

Template Parameters

_Type

The type of the object. This is typically a message block or an agent.

Parameters

_PObject	A pointer to the message block or agent that is being named in the trace.
_Name	The name for the given object.

{
    _Trace_agents(AGENTS_EVENT_NAME, ::Concurrency::details::_Trace_agents_get_id(_PObject), _Name);
}

template<class _Type >

bool Concurrency::try_receive	(	_Inout_ ISource< _Type > *	_Src,
		_Type &	_value
	)

A general try-receive implementation, allowing a context to look for data from exactly one source and filter the values that are accepted. If the data is not ready, the method will return false.

Template Parameters

_Type

The payload type.

Parameters

_Src	A pointer or reference to the source from which data is expected.
_value	A reference to a location where the result will be placed.

Returns

A bool value indicating whether or not a payload was placed in _value .

For more information, see Message Passing Functions.

See also

receive Function, send Function, asend Function

{
    return _Try_receive_impl(_Src, _value, NULL);
}

template<class _Type >

bool Concurrency::try_receive	(	_Inout_ ISource< _Type > *	_Src,
		_Type &	_value,
		typename ITarget< _Type >::filter_method const &	_Filter_proc
	)

A general try-receive implementation, allowing a context to look for data from exactly one source and filter the values that are accepted. If the data is not ready, the method will return false.

Template Parameters

_Type

The payload type.

Parameters

_Src	A pointer or reference to the source from which data is expected.
_value	A reference to a location where the result will be placed.
_Filter_proc	A filter function which determines whether messages should be accepted.

Returns

A bool value indicating whether or not a payload was placed in _value .

For more information, see Message Passing Functions.

See also

receive Function, send Function, asend Function

{
    return _Try_receive_impl(_Src, _value, &_Filter_proc);
}

template<class _Type >

bool Concurrency::try_receive	(	ISource< _Type > &	_Src,
		_Type &	_value
	)

A general try-receive implementation, allowing a context to look for data from exactly one source and filter the values that are accepted. If the data is not ready, the method will return false.

Template Parameters

_Type

The payload type

Parameters

_Src	A pointer or reference to the source from which data is expected.
_value	A reference to a location where the result will be placed.

Returns

A bool value indicating whether or not a payload was placed in _value .

For more information, see Message Passing Functions.

See also

receive Function, send Function, asend Function

{
    return _Try_receive_impl(&_Src, _value, NULL);
}

template<class _Type >

bool Concurrency::try_receive	(	ISource< _Type > &	_Src,
		_Type &	_value,
		typename ITarget< _Type >::filter_method const &	_Filter_proc
	)

A general try-receive implementation, allowing a context to look for data from exactly one source and filter the values that are accepted. If the data is not ready, the method will return false.

Template Parameters

_Type

The payload type

Parameters

_Src	A pointer or reference to the source from which data is expected.
_value	A reference to a location where the result will be placed.
_Filter_proc	A filter function which determines whether messages should be accepted.

Returns

A bool value indicating whether or not a payload was placed in _value .

For more information, see Message Passing Functions.

See also

receive Function, send Function, asend Function

{
    return _Try_receive_impl(&_Src, _value, &_Filter_proc);
}

_CONCRTIMP void __cdecl Concurrency::wait

(

unsigned int

_Milliseconds

)

Pauses the current context for a specified amount of time.

Parameters

_Milliseconds

The number of milliseconds the current context should be paused for. If the _Milliseconds parameter is set to the value 0, the current context should yield execution to other runnable contexts before continuing.

If this method is called on a Concurrency Runtime scheduler context, the scheduler will find a different context to run on the underlying resource. Because the scheduler is cooperative in nature, this context cannot resume exactly after the number of milliseconds specified. If the scheduler is busy executing other tasks that do not cooperatively yield to the scheduler, the wait period could be indefinite.

Variable Documentation

_CONCRTIMP const GUID Concurrency::AgentEventGuid

A category GUID ({B9B5B78C-0713-4898-A21A-C67949DCED07}) describing ETW events fired by the Agents library in the Concurrency Runtime.

_CONCRTIMP const GUID Concurrency::ChoreEventGuid

A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to chores or tasks.

This category of events is not currently fired by the Concurrency Runtime.

See also

task_group Class, structured_task_group Class

_CONCRTIMP const GUID Concurrency::ConcRT_ProviderGuid

The ETW provider GUID for the Concurrency Runtime.

_CONCRTIMP const GUID Concurrency::ConcRTEventGuid

A category GUID describing ETW events fired by the Concurrency Runtime that are not more specifically described by another category.

This category of events is not currently fired by the Concurrency Runtime.

_CONCRTIMP const GUID Concurrency::ContextEventGuid

A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to contexts.

See also

Context Class

const unsigned int Concurrency::COOPERATIVE_TIMEOUT_INFINITE = (unsigned int)-1

Value indicating that a wait should never time out.

See also

event Class, event::wait Method, event::wait_for_multiple Method

const size_t Concurrency::COOPERATIVE_WAIT_TIMEOUT = SIZE_MAX

Value indicating that a wait timed out.

See also

event Class, event::wait Method, event::wait_for_multiple Method

_CONCRTIMP const GUID Concurrency::LockEventGuid

A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to locks.

This category of events is not currently fired by the Concurrency Runtime.

See also

critical_section Class, reader_writer_lock Class

_CONCRTIMP const GUID Concurrency::PPLParallelForeachEventGuid

A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to usage of the parallel_for_each function.

See also

parallel_for_each Function

_CONCRTIMP const GUID Concurrency::PPLParallelForEventGuid

A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to usage of the parallel_for function.

See also

parallel_for Function

_CONCRTIMP const GUID Concurrency::PPLParallelInvokeEventGuid

A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to usage of the parallel_invoke function.

See also

parallel_invoke Function

_CONCRTIMP const GUID Concurrency::ResourceManagerEventGuid

A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to the resource manager.

This category of events is not currently fired by the Concurrency Runtime.

See also

IResourceManager Structure

_CONCRTIMP const GUID Concurrency::ScheduleGroupEventGuid

A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to schedule groups.

This category of events is not currently fired by the Concurrency Runtime.

See also

ScheduleGroup Class

_CONCRTIMP const GUID Concurrency::SchedulerEventGuid

A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to scheduler activity.

See also

CurrentScheduler Class, Scheduler Class

_CONCRTIMP const GUID Concurrency::VirtualProcessorEventGuid

A category GUID describing ETW events fired by the Concurrency Runtime that are directly related to virtual processors.