|affinity_partitioner Class||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.
|agent Class||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.|
|auto_partitioner Class||The |
auto_partitioner class represents the default method
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.
|bad_target Class||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.|
|call Class||A |
call messaging block is a multi-source, ordered
target_block that invokes a specified function when receiving a message.
|cancellation_token Class||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 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.
|cancellation_token_registration Class||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
|cancellation_token_source Class||The |
cancellation_token_source class represents the ability to cancel some cancelable operation.
|choice Class||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.
|combinable Class||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.
|concurrent_priority_queue Class||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.
|concurrent_queue Class||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
|concurrent_unordered_map Class||The |
concurrent_unordered_map class is a concurrency-safe container that controls a varying-length sequence of elements of type
std::pair<const K, _Element_type>. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access, and iterator traversal operations.
|concurrent_unordered_multimap Class||The |
concurrent_unordered_multimap class is an concurrency-safe container that controls a varying-length sequence of elements of type
std::pair<const K, _Element_type>. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access and iterator traversal operations.
|concurrent_unordered_multiset Class||The |
concurrent_unordered_multiset class is an concurrency-safe container that controls a varying-length sequence of elements of type K. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access and iterator traversal operations.
|concurrent_unordered_set Class||The |
concurrent_unordered_set class is an concurrency-safe container that controls a varying-length sequence of elements of type K. The sequence is represented in a way that enables concurrency-safe append, element access, iterator access and iterator traversal operations.
|concurrent_vector Class||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.
|Context Class||Represents an abstraction for an execution context.|
|context_self_unblock Class||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.
|context_unblock_unbalanced Class||This class describes an exception thrown when calls to the |
Unblock methods of a
Context object are not properly paired.
|critical_section Class||A non-reentrant mutex which is explicitly aware of the Concurrency Runtime.|
|CurrentScheduler Class||Represents an abstraction for the current scheduler associated with the calling context.|
|default_scheduler_exists Class||This class describes an exception thrown when the |
Scheduler::SetDefaultSchedulerPolicy method is called when a default scheduler already exists within the process.
|event Class||A manual reset event which is explicitly aware of the Concurrency Runtime.|
|improper_lock Class||This class describes an exception thrown when a lock is acquired improperly.|
|improper_scheduler_attach Class||This class describes an exception thrown when the |
Attach method is called on a
Scheduler object which is already attached to the current context.
|improper_scheduler_detach Class||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
|improper_scheduler_reference Class||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.
|invalid_link_target Class||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.
|invalid_multiple_scheduling Class||This class describes an exception thrown when a |
task_handle object is scheduled multiple times using the
run method of a
structured_task_group object without an intervening call to either the
|invalid_operation Class||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.|
|invalid_oversubscribe_operation Class||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
|invalid_scheduler_policy_key Class||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
|invalid_scheduler_policy_thread_specification Class||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
|invalid_scheduler_policy_value Class||This class describes an exception thrown when a policy key of a |
SchedulerPolicy object is set to an invalid value for that key.
|ISource Class||The |
ISource class is the interface for all source blocks. Source blocks propagate messages to
|ITarget Class||The |
ITarget class is the interface for all target blocks. Target blocks consume messages offered to them by
|join Class||A |
join messaging block is a single-target, multi-source, ordered
propagator_block which combines together messages of type
T from each of its sources.
|location Class||An abstraction of a physical location on hardware.|
|message Class||The basic message envelope containing the data payload being passed between messaging blocks.|
|message_not_found Class||This class describes an exception thrown when a messaging block is unable to find a requested message.|
|message_processor Class||The |
message_processor class is the abstract base class for processing of
message objects. There is no guarantee on the ordering of the messages.
|missing_wait Class||This class describes an exception thrown when there are tasks still scheduled to a |
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.
|multi_link_registry Class||The |
multi_link_registry object is a
network_link_registry that manages multiple source blocks or multiple target blocks.
|multitype_join Class||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.
|nested_scheduler_missing_detach Class||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
|network_link_registry Class||The |
network_link_registry abstract base class manages the links between source and target blocks.
|operation_timed_out Class||This class describes an exception thrown when an operation has timed out.|
|ordered_message_processor Class||An |
ordered_message_processor is a
message_processor that allows message blocks to process messages in the order they were received.
|overwrite_buffer Class||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.
|progress_reporter Class||The progress reporter class allows reporting progress notifications of a specific type. Each progress_reporter object is bound to a particular asynchronous action or operation.|
|propagator_block Class||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
|reader_writer_lock Class||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.|
|ScheduleGroup Class||Represents an abstraction for a schedule group. Schedule groups organize a set of related work that benefits from being scheduled close together either temporally, by executing another task in the same group before moving to another group, or spatially, by executing multiple items within the same group on the same NUMA node or physical socket.|
|Scheduler Class||Represents an abstraction for a Concurrency Runtime scheduler.|
|scheduler_not_attached Class||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.|
|scheduler_resource_allocation_error Class||This class describes an exception thrown because of a failure to acquire a critical resource in the Concurrency Runtime.|
|scheduler_worker_creation_error Class||This class describes an exception thrown because of a failure to create a worker execution context in the Concurrency Runtime.|
|SchedulerPolicy Class||The |
SchedulerPolicy class contains a set of key/value pairs, one for each policy element, that control the behavior of a scheduler instance.
|simple_partitioner Class||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.
|single_assignment Class||A |
single_assignment messaging block is a multi-target, multi-source, ordered
propagator_block capable of storing a single, write-once
|single_link_registry Class||The |
single_link_registry object is a
network_link_registry that manages only a single source or target block.
|source_block Class||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.
|source_link_manager Class||The |
source_link_manager object manages messaging block network links to
|static_partitioner Class||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.
|structured_task_group Class||The |
structured_task_group class represents a highly structured collection of parallel work. You can queue individual parallel tasks to a
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.
|target_block Class||The |
target_block class is an abstract base class that provides basic link management functionality and error checking for target only blocks.
|task Class (Concurrency Runtime)||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(
|task_canceled Class||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.
|task_completion_event Class||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.
|task_continuation_context Class||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.
|task_group Class||The |
task_group class represents a collection of parallel work which can be waited on or canceled.
|task_handle Class||The |
task_handle class represents an individual parallel work item. It encapsulates the instructions and the data required to execute a piece of work.
|task_options Class (Concurrency Runtime)||Represents the allowed options for creating a task|
|timer Class||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.
|transformer Class||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.
|unbounded_buffer Class||An |
unbounded_buffer messaging block is a multi-target, multi-source, ordered
propagator_block capable of storing an unbounded number of messages.
|unsupported_os Class||This class describes an exception thrown when an unsupported operating system is used.|