concurrency, espace de noms

L'espace de noms Concurrency fournit des classes et des fonctions qui vous donnent accès au runtime d'accès concurrentiel, une infrastructure de programmation simultanée pour C++. Pour plus d'informations, consultez Concurrency Runtime.

namespace concurrency;

Membres

Espaces de noms

Nom	Description
concurrency::extensibility Namespace

Typedef

Nom	Description
runtime_object_identity	Chaque instance de message a une identité qui le suit lorsqu'il est cloné et passé entre des composants de messagerie. Ceci ne peut pas être l'adresse de l'objet de message.
task_status	Un type qui représente l'état terminal d'une tâche. Les valeurs valides sont completed et canceled.
TaskProc	Abstraction élémentaire d'une tâche, définie sous la forme void (__cdecl * TaskProc)(void *). Un TaskProc est appelé pour appeler le corps d'une tâche.
TaskProc_t	Abstraction élémentaire d'une tâche, définie sous la forme void (__cdecl * TaskProc_t)(void *). Un TaskProc est appelé pour appeler le corps d'une tâche.

Classes

Nom	Description
affinity_partitioner, classe	La classe affinity_partitioner est semblable à la classe static_partitioner, mais elle améliore l'affinité de cache par son choix de mapper les plages inférieures en threads de travail. Elle peut améliorer considérablement lorsqu'une boucle est exécutée à nouveau sur le même groupe de données, et quand les données tiennent dans le cache. Notez que le même objet affinity_partitioner doit être utilisé avec les itérations suivantes d'une boucle parallèle exécutée sur un groupe de données particulier, pour tirer parti de la localité des données.
agent, classe	Classe prévue pour être utilisée comme une classe de base pour tous les agents indépendants. Cela est utilisé pour masquer l'état d'autres agents et interagir grâce au passage de messages.
auto_partitioner, classe	La classe auto_partitioner représente l'usage des méthodes par défaut parallel_for, parallel_for_each et parallel_transform pour partitionner la plage sur laquelle ils itèrent. Cette méthode de partition utilise le vol de plage pour équilibrer la charge ainsi que l'annulation itérative.
bad_target, classe	Cette classe décrit une exception qui est renvoyée dès qu'un bloc de messagerie reçoit un pointeur vers une cible qui n'est pas valide pour l'opération en cours d'exécution.
call, classe	Un bloc de messagerie call est une source multiple, target_block classé qui appelle une fonction spécifiée lors de la réception d'un message.
cancellation_token, classe	La classe cancellation_token représente la capacité à déterminer si une opération d'annulation a été demandée. Un jeton donné peut être associé à un task_group, structured_task_group, ou à une task pour fournir l'annulation implicite. Il peut également être interrogé pour l'annulation ou avoir un rappel enregistré en cas d'annulation du cancellation_token_source associé.
cancellation_token_registration, classe	La classe cancellation_token_registration représente une notification de rappel de cancellation_token. Lorsque la méthode register sur cancellation_token est utilisée pour recevoir une notification relative à la date d'annulation, un objet cancellation_token_registration est retourné comme handle au rappel afin que l'appelant puisse demander qu'un rappel spécifique ne soit plus effectué via l'utilisation de la méthode deregister.
cancellation_token_source, classe	La classe cancellation_token_source représente la capacité à annuler une opération annulable.
Classe choice	Un bloc de messagerie choice est une source multiple, bloc de cible unique qui représente une interaction de flux de contrôle avec un jeu de sources. Le bloc de choix attendra que l'une des sources multiples produise un message et propagera l'index de la source qui a produit le message.
combinable, classe	L'objet combinable<T> vise à fournir des copies des données spécifiques au thread pour exécuter des sous-calculs locaux de thread sans verrou pendant des algorithmes parallèles. À la fin de l'opération en parallèle, les sous-calculs spécifiques au thread peuvent être fusionnés en un résultat final. Cette classe peut être utilisée à la place d'une variable partagée et peut améliorer les performances si la variable partagée est susceptible de provoquer de nombreux conflits.
concurrent_priority_queue, classe	La classe concurrent_priority_queue est un conteneur qui permet à plusieurs threads de pousser et dépiler simultanément des éléments. Les éléments sont dépilés par ordre de priorité, où la priorité est déterminée par un foncteur fourni comme argument du modèle.
concurrent_queue, classe	La classe concurrent_queue est une classe de conteneur de séquences qui autorise l'accès premier entré, premier sorti à ses éléments. Il permet un ensemble limité d'opérations concurrentiellement sécurisées, telles que push et try_pop.
concurrent_unordered_map, classe	La classe concurrent_unordered_map est un conteneur sécurisé du point de vue de l'accès concurrentiel qui contrôle une séquence de longueur variable d'éléments de type std::pair<const _Key_type, _Element_type>. La séquence est représentée de manière à autoriser les opérations d'ajout, d'accès aux éléments, d'accès aux itérateurs et de parcours d'itérateur sécurisées du point de vue de l'accès concurrentiel.
concurrent_unordered_multimap, classe	La classe concurrent_unordered_multimap est un conteneur sécurisé du point de vue de l'accès concurrentiel qui contrôle une séquence de longueur variable d'éléments de type std::pair<const _Key_type, _Element_type>. La séquence est représentée de manière à autoriser les opérations d'ajout, d'accès aux éléments, d'accès aux itérateurs et de parcours d'itérateur sécurisées du point de vue de l'accès concurrentiel.
concurrent_unordered_multiset, classe	La classe concurrent_unordered_multiset est un conteneur sécurisé du point de vue de l'accès concurrentiel qui contrôle une séquence de longueur variable d'éléments de type _Key_type. La séquence est représentée de manière à autoriser les opérations d'ajout, d'accès aux éléments, d'accès aux itérateurs et de parcours d'itérateur sécurisées du point de vue de l'accès concurrentiel.
concurrent_unordered_set, classe	La classe concurrent_unordered_set est un conteneur sécurisé du point de vue de l'accès concurrentiel qui contrôle une séquence de longueur variable d'éléments de type _Key_type. La séquence est représentée de manière à autoriser les opérations d'ajout, d'accès aux éléments, d'accès aux itérateurs et de parcours d'itérateur sécurisées du point de vue de l'accès concurrentiel.
Classe concurrent_vector	La classe concurrent_vector est une classe de conteneur de séquences qui autorise l'accès aléatoire à tout élément. Elle permet des opérations d'ajout, d'accès d'éléments, d'accès d'itérateur et de parcours d'itérateur sécurisées du point de vue de l'accès concurrentiel.
Context, classe	Représente une abstraction pour un contexte d'exécution.
context_self_unblock, classe	Cette classe décrit une exception qui est renvoyée dès que la méthode Unblock d'un objet Context est appelée à partir du même contexte. Cela indiquerait qu'un contexte donné a tenté de se débloquer.
context_unblock_unbalanced, classe	Cette classe décrit une exception qui est levée dès que les appels aux méthodes Block et Unblock d'un objet Context ne sont pas correctement combinés.
critical_section, classe	Mutex non réentrant qui est explicitement informé du runtime d'accès concurrentiel.
CurrentScheduler, classe	Représente une abstraction pour le planificateur actuel associé au contexte d'appel.
default_scheduler_exists, classe	Cette classe décrit une exception qui est levée dès que la méthode Scheduler::SetDefaultSchedulerPolicy est appelée lorsqu'un planificateur par défaut existe déjà dans le processus.
event, classe	Événement de réinitialisation manuelle qui est explicitement informé du runtime d'accès concurrentiel.
improper_lock, classe	Cette classe décrit une exception qui est levée dès qu'un verrouillage est acquis de façon incorrecte.
improper_scheduler_attach, classe	Cette classe décrit une exception qui est renvoyée dès que la méthode Attach est appelée sur un objet Scheduler qui est déjà attaché au contexte actuel.
improper_scheduler_detach, classe	Cette classe décrit une exception qui est renvoyée dès que la méthode CurrentScheduler::Detach est appelée sur un contexte qui n'a pas été attaché à un planificateur via la méthode Attach d'un objet Scheduler.
improper_scheduler_reference, classe	Cette classe décrit une exception qui est levée dès que la méthode Reference est appelée sur un objet Scheduler en cours de fermeture, à partir d'un contexte qui ne fait pas partie de ce planificateur.
invalid_link_target, classe	Cette classe décrit une exception qui est renvoyée dès que la méthode link_target d'un bloc de messagerie est appelée et que le bloc de messagerie ne peut pas se connecter à la cible. Il peut s'agir du résultat du dépassement du nombre de liens autorisé pour le bloc de messagerie ou de la tentative de lier deux fois une cible spécifique à la même source.
invalid_multiple_scheduling, classe	Cette classe décrit une exception qui est renvoyée lorsqu'un objet task_handle est planifié plusieurs fois via la méthode run d'un objet task_group ou structured_task_group sans appel aux méthodes wait ou run_and_wait.
invalid_operation, classe	Cette classe décrit une exception qui est levée lorsqu'une opération non valide est exécutée qui n'est pas décrite de façon plus précise par un autre type d'exception levé par le runtime d'accès concurrentiel.
invalid_oversubscribe_operation, classe	Cette classe décrit une exception qui est levée lorsque la méthode Context::Oversubscribe est appelée avec le paramètre _BeginOversubscription défini sur false sans appel antérieur à la méthode Context::Oversubscribe avec le paramètre _BeginOversubscription défini comme true.
invalid_scheduler_policy_key, classe	Cette classe décrit une exception qui est levée dès qu'une clé non valide ou inconnue est passée à un constructeur d'objet SchedulerPolicy, ou que la méthode SetPolicyValue d'un objet SchedulerPolicy reçoit une clé qui doit être modifiée via d'autres moyens comme la méthode SetConcurrencyLimits.
invalid_scheduler_policy_thread_specification, classe	Cette classe décrit une exception qui est levée lors de toute tentative de définir les limites d'accès concurrentiel d'un objet SchedulerPolicy de sorte que la valeur de la clé MinConcurrency est inférieure à la valeur de la clé MaxConcurrency.
invalid_scheduler_policy_value, classe	Cette classe décrit une exception qui est renvoyée dès qu'une clé de stratégie d'un objet SchedulerPolicy est définie sur une valeur non valide pour cette clé.
ISource, classe	La classe ISource est l'interface pour tous les blocs source. Les blocs source propagent des messages aux blocs ITarget.
ITarget, classe	La classe ITarget est l'interface pour tous les blocs cibles. Les blocs cible consomment des messages offerts à eux par les blocs ISource.
join, classe	Un bloc de messagerie join est un propagator_block de cible unique, de source multiple et classé qui combine ensemble des messages de type _Type à partir de chacune de ses sources.
location, classe	Une abstraction d'un emplacement physique sur le matériel hardware.
message, classe	Enveloppe de message de base qui contient la charge utile de données qui est passée entre des blocs de messagerie.
message_not_found, classe	Cette classe décrit une exception qui est renvoyée dès qu'un bloc de messagerie ne peut pas trouver un message demandé.
message_processor, classe	La classe message_processor est la classe de base abstraite pour le traitement d'objets message. Il n'y a aucune garantie sur le classement des messages.
missing_wait, classe	Cette classe décrit une exception qui est renvoyée dès que des tâches sont encore planifiées pour un objet task_group ou un objet structured_task_group au moment où le destructeur de cet objet s'exécute. Cette exception ne sera jamais renvoyée si le destructeur est atteint en raison du déroulement de pile suite à une exception.
multi_link_registry, classe	L'objet multi_link_registry est un network_link_registry qui gère plusieurs blocs source ou plusieurs blocs cibles.
multitype_join, classe	Un bloc de messagerie multitype_join est un bloc de messagerie de cible unique et de source multiple qui combine ensemble des messages de types différents à partir de chacune de ses sources et offre un tuple des messages combinés à ses cibles.
nested_scheduler_missing_detach, classe	Cette classe décrit une exception qui est renvoyée lorsque le runtime d'accès concurrentiel détecte que l'on a omis d'appeler la méthode CurrentScheduler::Detach sur un contexte joint à un deuxième planificateur via la méthode Attach de l'objet Scheduler.
network_link_registry, classe	La classe de base abstraite network_link_registry gère les liens entre les blocs source et cibles.
operation_timed_out, classe	Cette classe décrit une exception qui est levée lorsqu'une opération a dépassé son délai.
ordered_message_processor, classe	Un ordered_message_processor est un message_processor qui permet aux blocs de messages de traiter les messages dans l'ordre dans lequel ils ont été reçus.
Classe overwrite_buffer	Un bloc de messagerie overwrite_buffer est un propagator_block ordonné, multi-sources et multi-cibles capable de stocker un seul message la fois. Les nouveaux messages remplacent ceux précédemment maintenus.
progress_reporter, classe	La classe de rapporteur de progression permet de signaler les notifications de progression d'un type spécifique. Chaque objet progress_reporter est lié à une action ou une opération asynchrone particulière.
propagator_block, classe	La classe propagator_block est une classe de base abstraite pour les blocs de messages qui sont à la fois une source et une cible. Il combine les fonctionnalités des classes target_block et source_block.
reader_writer_lock, classe	Verrou de lecteur/writer, basé sur file d'attente, à préférence de writer, à rotation uniquement locale. Le verrou accorde un accès premier entré, premier sorti aux writers et prive les lecteurs sous une charge continue de writers.
ScheduleGroup, classe	Représente une abstraction pour un groupe de planification. Les groupes de planification organisent un ensemble de travaux connexes qui bénéficient d'être planifiés près des uns des autres, au niveau temporel en exécutant une autre tâche du même groupe avant de se déplacer vers un autre groupe, ou au niveau spatial en exécutant plusieurs éléments du même groupe sur le même nœud NUMA ou socket physique.
Scheduler, classe	Représente une abstraction pour un planificateur de runtime d'accès concurrentiel.
scheduler_not_attached, classe	Cette classe décrit une exception qui est levée dès qu'une opération nécessitant qu'un planificateur soit attaché au contexte actuel est réalisée alors qu'aucun planificateur n'est attaché.
scheduler_resource_allocation_error, classe	Cette classe décrit une exception qui est renvoyée en raison de l'échec de l'acquisition d'une ressource critique dans le runtime d'accès concurrentiel.
scheduler_worker_creation_error, classe	Cette classe décrit une exception levée en raison d'un échec dans la création d'un contexte d'exécution de worker du runtime d'accès concurrentiel.
SchedulerPolicy, classe	La classe SchedulerPolicy contient un jeu de paires clé/valeur, un pour chaque élément de stratégie, qui contrôle le comportement d'une instance du planificateur.
simple_partitioner, classe	La classe simple_partitioner représente un partitionnement statique de la plage sur laquelle itère parallel_for. Le partitionneur divise la plage en segments de sorte que chaque segment possède au moins le nombre d'itérations spécifié par la taille du segment.
Classe single_assignment	Un bloc de messagerie single_assignment est un propagator_block de cible multiple, de source multiple et classé capable de stocker un message unique, écrit une seule fois.
single_link_registry, classe	L'objet single_link_registry est un network_link_registry qui gère uniquement un seul bloc source ou cible.
source_block, classe	La classe source_block est une classe de base abstraite pour les blocs source uniquement. La classe fournit une fonctionnalité basique de gestion des liaisons et vérifie les erreurs courantes.
source_link_manager, classe	L'objet source_link_manager gère les liens réseau entre les blocs de messagerie et les blocs ISource.
static_partitioner, classe	La classe static_partitioner représente un partitionnement statique de la plage sur laquelle itère parallel_for. Le partitionneur divise la plage en autant de segments qu'il existe de workers disponibles pour le planificateur sous-jacent.
structured_task_group, classe	La classe structured_task_group représente une collection très structurée de travail parallèle. Vous pouvez mettre en file d'attente des tâches parallèles individuelles dans un structured_task_group à l'aide d'objets task_handle et attendre qu'elles se terminent, ou annuler le groupe de tâches avant la fin de leur exécution, ce qui conduira à l'abandon de toutes les tâches qui n'ont pas commencé.
target_block, classe	La classe target_block est une classe de base abstraite qui fournit des fonctionnalités de gestion des liens de base et vérifie les erreurs pour les blocs cibles uniquement.
task (Concurrency Runtime), classe	Classe task de la bibliothèque de modèles parallèles (PPL). Un objet task représente le travail qui peut être exécuté de façon asynchrone, et simultanément avec d'autres tâches et un travail parallèle généré par des algorithmes parallèles dans le runtime d'accès concurrentiel. Il produit un résultat de type _ResultType une fois l'opération terminée correctement. Les tâches du type task<void> ne produisent aucun résultat. Une tâche peut être mise en attente et annulée indépendamment des autres tâches. Elle peut également être composée d'autres tâches à l'aide des continuations (then) ainsi que de modèles de jointure (when_all) et de choix (when_any).
task_canceled, classe	Cette classe décrit une exception levée par la couche de tâches PPL pour forcer l'annulation de la tâche actuelle. Elle est également levée par la méthode get() sur la tâche, pour une tâche annulée.
task_completion_event, classe	La classe task_completion_event vous permet de différer l'exécution d'une tâche jusqu'à ce qu'une condition soit remplie, ou de démarrer une tâche en réponse à un événement externe.
task_continuation_context, classe	La classe task_continuation_context vous permet de spécifier l'emplacement d'exécution d'une continuation. Il est utile d'utiliser cette classe d'une application du Windows Store. Pour les fenêtres autres que les fenêtres Windows Store, le contexte d'exécution de la continuation de tâche est déterminé par l'exécution, et n'est pas configurable.
task_group, classe	La classe task_group représente une collection de travaux parallèles qui peuvent être mis en attente ou annulés.
task_handle, classe	La classe task_handle représente un élément de travail parallèle individuel. Il encapsule les instructions et les données obligatoires pour exécuter un travail.
task_options, classe (runtime d'accès concurrentiel)	Représente les options autorisées pour créer une tâche
Classe timer	Un bloc de messagerie timer est un source_block à cible unique capable d'envoyer un message à sa cible après qu'une période spécifiée s'est écoulée ou à intervalles spécifiques.
Classe transformer	Un bloc de messagerie transformer est un propagator_block ordonné, multi-sources, à cible unique qui peut accepter des messages d'un type et stocker un nombre illimité de messages d'un type différent.
Classe unbounded_buffer	Un bloc de messagerie unbounded_buffer est un propagator_block ordonné multi-sources et multi-cibles capable de stocker un nombre illimité de messages.
unsupported_os, classe	Cette classe décrit une exception qui est renvoyée dès qu'un système d'exploitation non pris en charge est utilisé.

Structures

Nom	Description
DispatchState, structure	La structure DispatchState est utilisée pour transférer l'état à la méthode IExecutionContext::Dispatch. Il décrit les circonstances sous lesquelles la méthode Dispatch est appelée sur une interface IExecutionContext.
IExecutionContext, structure	Interface à un contexte d'exécution qui peut s'exécuter sur un processeur virtuel donné et dont le contexte peut être modifié de manière coopérative.
IExecutionResource, structure	Abstraction d'un thread matériel.
IResourceManager, structure	Interface au Gestionnaire de ressources du runtime d'accès concurrentiel. C'est l'interface par laquelle les planificateurs communiquent avec le Gestionnaire des ressources.
IScheduler, structure	Interface à une abstraction d'un planificateur de travail. Le Gestionnaire des ressources du runtime d'accès concurrentiel utilise cette interface pour communiquer avec les planificateurs de tâches.
ISchedulerProxy, structure	Interface par laquelle les planificateurs communiquent avec le Gestionnaire des ressources du runtime d'accès concurrentiel pour négocier l'allocation des ressources.
IThreadProxy, structure	Abstraction d'un thread d'exécution. Selon la clé de stratégie SchedulerType du planificateur que vous créez, le Gestionnaire des ressources vous accordera un proxy de thread stocké par un thread Win32 standard ou un thread UMS (User-Mode Schedulable). Les threads UMS sont pris en charge sur les systèmes d'exploitation 64 bits avec la version Windows 7 et supérieure.
ITopologyExecutionResource, structure	Une interface avec une ressource d'exécution comme défini par le gestionnaire de ressources.
ITopologyNode, structure	Une interface avec un nœud de topologie comme défini par le gestionnaire de ressources. Un nœud contient une ou plusieurs ressources d'exécution.
IUMSCompletionList, structure	Représente une liste de saisie semi-automatique UMS. Lorsqu'un thread UMS se bloque, le contexte de planification désigné du planificateur est distribué afin de décider quoi planifier sur la racine de processeur virtuel sous-jacente pendant que le thread d'origine est bloqué. Lorsque le thread d'origine se débloque, le système d'exploitation le met en file d'attente dans la liste de saisie semi-automatique qui est accessible via cette interface. Le planificateur peut interroger la liste de saisie semi-automatique sur le contexte de planification désigné ou tout autre emplacement sur lequel il recherche du travail.
IUMSScheduler, structure	Interface à une abstraction d'un planificateur de travail qui veut que le Gestionnaire de ressources du runtime d'accès concurrentiel lui envoie des threads UMS (user mode schedulable). Le Gestionnaire des ressources utilise cette interface pour communiquer avec les planificateurs de thread UMS. L'interface IUMSScheduler hérite de l'interface IScheduler.
IUMSThreadProxy, structure	Abstraction d'un thread d'exécution. Si vous souhaitez que des threads planifiables en mode utilisateur (UMS) soient accordés à votre planificateur, définissez la valeur de l'élément de stratégie du planificateur SchedulerKind sur UmsThreadDefault et implémentez l'interface IUMSScheduler. Les threads UMS sont pris en charge uniquement sur les systèmes d'exploitation 64 bits avec la version Windows 7 et supérieure.
IUMSUnblockNotification, structure	Représente une notification du Gestionnaire de ressources informant qu'un proxy de thread bloqué ayant déclenché un retour au contexte de planification désigné du planificateur est maintenant débloqué et prêt à être planifié. Cette interface n'est pas valide une fois le contexte d'exécution associé du proxy de thread, retourné par la méthode GetContext, est replanifié.
IVirtualProcessorRoot, structure	Abstraction d'un thread matériel sur laquelle un proxy de thread peut s'exécuter.
scheduler_interface, structure	Interface du planificateur
scheduler_ptr::Structure (runtime d'accès concurrentiel)	Représente un pointeur vers un planificateur. Cette classe existe pour permettre la spécification d'une durée de vie partagée à l'aide de shared_ptr ou d'une référence simple à l'aide d'un pointeur brut.

Énumérations

Nom	Description
agent_status, énumération	États valides pour un agent.
Agents_EventType, énumération	Types d'événements qui peuvent être suivis à l'aide des fonctionnalités de traçage offertes par la Bibliothèque d'Agents.
ConcRT_EventType, énumération	Types d'événements qui peuvent être suivis à l'aide des fonctionnalités de traçage offertes par le runtime d'accès concurrentiel.
Concrt_TraceFlags, énumération	Indicateurs de suivi pour les types d'événement
CriticalRegionType, énumération	Type de région critique dans laquelle se trouve un contexte.
DynamicProgressFeedbackType, énumération	Utilisé par la stratégie DynamicProgressFeedback pour décrire si les ressources du planificateur seront rééquilibrées d'après les statistiques rassemblées à partir du planificateur ou uniquement selon les processeurs virtuels qui entrent ou sortent de l'état d'inactivité via des appels aux méthodes Activate et Deactivate sur l'interface IVirtualProcessorRoot. Pour plus d'informations sur les stratégies de planificateur disponibles, consultez PolicyElementKey, énumération.
join_type, énumération	Type d'un bloc de messagerie join.
message_status, énumération	Réponses valides pour une offre d'un objet message à un bloc.
PolicyElementKey, énumération	Clés de stratégie qui décrivent des aspects de comportement de planificateur. Chaque élément de stratégie est décrit par une paire clé-valeur. Pour plus d'informations sur les stratégies de planificateur et leur impact sur les planificateurs, consultez Planificateur de tâches (runtime d'accès concurrentiel).
SchedulerType, énumération	Utilisé par la stratégie SchedulerKind pour décrire le type des threads que le planificateur doit utiliser pour les contextes d'exécution sous-jacents. Pour plus d'informations sur les stratégies de planificateur disponibles, consultez PolicyElementKey, énumération.
SchedulingProtocolType, énumération	Utilisé par la stratégie SchedulingProtocol pour décrire l'algorithme de planification qui sera utilisé pour le planificateur. Pour plus d'informations sur les stratégies de planificateur disponibles, consultez PolicyElementKey, énumération.
SwitchingProxyState, énumération	Utilisé pour indiquer l'état dans lequel se trouve un proxy de thread, lorsqu'il exécute un basculement de contexte coopératif vers un proxy de thread différent.
task_group_status, énumération	Décrit l'état d'exécution d'un objet task_group ou structured_task_group. Une valeur de ce type est retournée par de nombreuses méthodes qui attendent que les tâches planifiées pour un groupe de tâches se terminent.
WinRTInitializationType, énumération	Utilisé par la stratégie WinRTInitialization pour décrire si et comment les runtimes Windows sont initialisés sur des threads de planificateur pour une application exécutée sur les systèmes d'exploitation avec Windows 8 ou une version ultérieure. Pour plus d'informations sur les stratégies de planificateur disponibles, consultez PolicyElementKey, énumération.

Fonctions

Nom	Description
Alloc, fonction	Alloue un bloc de mémoire de la taille spécifiée depuis le sous-allocateur de cache du runtime d'accès concurrentiel.
asend, fonction	Surchargé. Opération d'envoi asynchrone qui planifie une tâche permettant de propager les données au bloc cible.
cancel_current_task, fonction	Annule la tâche en cours d'exécution. Cette fonction peut être appelée à partir du corps d'une tâche pour annuler l'exécution de la tâche et la faire passer à l'état canceled. Bien qu'elle puisse être utilisée en réponse à la fonction is_task_cancellation_requested, vous pouvez également l'utiliser toute seule, pour initialiser l'annulation de la tâche en cours d'exécution. Ce n'est pas un scénario pris en charge pour appeler cette fonction si vous n'êtes pas dans le corps de task. Cela entraînerait un comportement non défini tel qu'un blocage dans votre application.
create_async, fonction	Crée une construction asynchrone Windows Runtime basé sur un utilisateur lambda ou un objet de fonction fourni. Le type de retour de create_async est IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^ ou IAsyncOperationWithProgress<TResult, TProgress>^ selon la signature de l'expression lambda passée à la méthode.
create_task, fonction	Surchargé. Crée un objet task PPL. create_task peut être utilisé partout où vous auriez utilisé un constructeur de tâche. Il est principalement fourni pour des raisons de commodité, car il permet d'utiliser le mot clé auto tout en créant des tâches.
CreateResourceManager, fonction	Retourne une interface qui représente l'instance de singleton du Gestionnaire de ressources du runtime d'accès concurrentiel. Le Gestionnaire des ressources est chargé d'assigner des ressources aux planificateurs qui souhaitent coopérer les uns avec les autres.
DisableTracing, fonction	Désactive le suivi dans le runtime d'accès concurrentiel. Cette fonction est déconseillée car le traçage ETW est annulé par défaut.
EnableTracing, fonction	Active le suivi dans le runtime d'accès concurrentiel. Cette fonction est déconseillée car le traçage ETW est enclenché par défaut.
Free, fonction	Libère un bloc de mémoire précédemment alloué par la méthode Alloc au sous-allocateur de cache du runtime d'accès concurrentiel.
get_ambient_scheduler, fonction (runtime d'accès concurrentiel)
GetExecutionContextId, fonction	Retourne un identificateur unique qui peut être assigné à un contexte d'exécution qui implémente l'interface IExecutionContext.
GetOSVersion, fonction	Retourne la version du système d'exploitation.
GetProcessorCount, fonction	Retourne le nombre de threads matériels sur le système sous-jacent.
GetProcessorNodeCount, fonction	Retourne le nombre de nœuds NUMA ou packages de processeur sur le système sous-jacent.
GetSchedulerId, fonction	Retourne un identificateur unique qui peut être assigné à un planificateur qui implémente l'interface IScheduler.
interruption_point, fonction	Crée un point d'interruption d'annulation. Si une annulation est en cours dans le contexte où cette fonction est appelée, il renvoie une exception interne qui abandonne l'exécution du travail parallèle en cours de exécution. Si l'annulation n'est pas en cours, la fonction ne fait rien.
is_current_task_group_canceling, fonction	Retourne une indication spécifiant si le groupe de tâches qui s'exécute actuellement inline sur le contexte actuel est en cours d'annulation (ou le sera bientôt). Notez que si aucun groupe de tâches ne s'exécute actuellement inline dans le contexte actuel, false sera retourné.
is_task_cancellation_requested, fonction	Retourne une indication du fait que la tâche en cours d'exécution a reçu une demande d'annulation de son exécution. L'annulation est demandée sur une tâche si la tâche a été créée avec un jeton d'annulation, et que la source de jeton associée à ce jeton est annulée.
make_choice, fonction	Surchargé. Construit un bloc de messagerie choice à partir d'un Scheduler ou d'un ScheduleGroup facultatifs et deux sources d'entrée ou plus.
make_greedy_join, fonction	Surchargé. Construit un bloc de messagerie greedy multitype_join à partir d'un Scheduler ou d'un ScheduleGroup facultatifs et deux sources d'entrée ou plus.
make_join, fonction	Surchargé. Construit un bloc de messagerie non_greedy multitype_join à partir d'un Scheduler ou d'un ScheduleGroup facultatifs et deux sources d'entrée ou plus.
make_task, fonction	Méthode de fabrique pour la création d'un objet task_handle.
parallel_buffered_sort, fonction	Surchargé. Organise les éléments dans une plage spécifiée dans un ordre non décroissant, ou selon un critère de classement spécifié par un prédicat binaire, en parallèle. Cette fonction est sémantiquement semblable à std::sort car c'est un tri sur place, basé sur la comparaison, instable, sauf qu'elle a besoin d'espace supplémentaire pour O(n), et nécessite une initialisation par défaut pour que les éléments soient triés.
parallel_for, fonction	Surchargé. parallel_for itère au sein d'une plage d'index et exécute une fonction fournie par utilisateur à chaque itération, en parallèle.
parallel_for_each, fonction	Surchargé. parallel_for_each applique une fonction spécifiée à chaque élément dans une plage, en parallèle. Elle est sémantiquement équivalente à la fonction for_each dans l'espace de noms std, mais l'itération des éléments est exécutée en parallèle et l'ordre d'itération n'est pas spécifié. L'argument _Func doit prendre en charge un opérateur d'appel de fonction de la forme operator()(T), où le paramètre T est le type d'élément du conteneur sur lequel l'itération est réalisée.
parallel_invoke, fonction	Surchargé. Exécute les objets de fonction fournis comme paramètres en parallèle et se bloque jusqu'à la fin de leur exécution. Chaque objet de fonction peut être une expression lambda, un pointeur vers une fonction ou tout objet qui prend en charge l'opérateur d'appel de fonction avec la signature void operator()().
parallel_radixsort, fonction	Surchargé. Organise les éléments dans une plage spécifiée dans un ordre non décroissant à l'aide d'un algorithme de tri de base. C'est une fonction de tri stable nécessitant une fonction de projection qui peut projeter les éléments à trier en clés similaires à des entiers non signés. L'initialisation par défaut est requise pour les éléments à trier.
parallel_reduce, fonction	Surchargé. Calcule la somme de tous les éléments dans une plage spécifiée en calculant les sommes partielles consécutives, ou calcule le résultat de résultats partiels consécutifs obtenus en utilisant en parallèle une opération binaire spécifiée autre que la somme. parallel_reduce est sémantiquement semblable à std::accumulate, mis à part qu'il requiert que l'opération binaire soit associative, et qu'il requiert une valeur d'identité au lieu d'une valeur initiale.
parallel_sort, fonction	Surchargé. Organise les éléments dans une plage spécifiée dans un ordre non décroissant, ou selon un critère de classement spécifié par un prédicat binaire, en parallèle. Cette fonction est sémantiquement semblable à std::sort car il s'agit d'un tri sur place, instable et basé sur la comparaison.
parallel_transform, fonction	Surchargé. Applique un foncteur (fonction objet) spécifié à chaque élément d'une plage source, ou paire de deux plages sources, et copie les valeurs renvoyées du foncteur (fonction objet) dans une plage de destination, en parallèle. Ce fonctionnel est sémantiquement équivalent à std::transform.
receive, fonction	Surchargé. Implémentation receive générale permettant à un contexte d'attendre des données d'une source exactement et de filtrer les valeurs acceptées.
run_with_cancellation_token, fonction	Exécute un foncteur (fonction objet) immédiatement et synchrone dans le contexte d'un jeton donné d'annulation.
send, fonction	Surchargé. Opération d'envoi synchrone qui attend que la cible accepte ou refuse le message.
set_ambient_scheduler, fonction (runtime d'accès concurrentiel)
set_task_execution_resources, fonction	Surchargé. Restreint les ressources d'exécution utilisées par les threads de travail internes du runtime d'accès concurrentiel à l'affinité spécifiée. Il n'est pas valide d'appeler cette méthode uniquement avant que le gestionnaire de ressources ait été créé, ou entre deux durées de vie du gestionnaire de ressources. On peut l'appeler plusieurs fois à condition que le gestionnaire de ressources n'existe pas au moment de l'appel. Une fois que la limite d'affinité a été définie, elle demeure effective tant que le prchain appel valide appelle la méthode set_task_execution_resources. Le masque d'affinité a fourni n'a pas besoin d'être un sous-ensemble du masque d'affinité de processus. L'affinité de processus sera mise à jour si nécessaire.
swap, fonction	Échange les éléments de deux objets concurrent_vector.
task_from_exception, fonction (runtime d'accès concurrentiel)
task_from_result, fonction (runtime d'accès concurrentiel)
Trace_agents_register_name, fonction	Associe le nom donné au bloc de message ou à l'agent de message dans la trace ETW.
try_receive, fonction	Surchargé. Implémentation try-receive générale permettant à un contexte de rechercher des données d'une source exactement et de filtrer les valeurs acceptées. Si les données ne sont pas prêtes, la méthode retournera la valeur false.
wait, fonction	Suspend le contexte actuel pour une durée spécifiée.
when_all, fonction	Crée une tâche qui s'effectue correctement lorsque toutes les tâches fournies comme arguments s'achèvent correctement.
when_any, fonction	Surchargé. Crée une tâche qui s'effectue correctement lorsque n'importe quelle tâche fournie comme arguments s'achève correctement.

Opérateurs

Nom	Description
operator!=, opérateur	Teste si l'objet concurrent_vector à gauche de l'opérateur n'est pas égal à l'objet concurrent_vector du côté droit.
operator&&, opérateur	Surchargé. Crée une tâche qui s'effectue correctement lorsque les deux tâches fournies comme arguments s'achèvent correctement.
operator||, opérateur	Surchargé. Crée une tâche qui s'effectue correctement lorsque l'une des taches fournies comme arguments s'achève correctement.
operator<, opérateur	Teste si l'objet concurrent_vector à gauche de l'opérateur est inférieur à l'objet concurrent_vector du côté droit.
operator<=, opérateur	Teste si l'objet concurrent_vector à côté gauche de l'opérateur est inférieur ou égal à l'objet concurrent_vector du côté droit.
operator==, opérateur	Teste si l'objet concurrent_vector à gauche de l'opérateur est égal à l'objet concurrent_vector du côté droit.
operator>, opérateur	Teste si l'objet concurrent_vector à gauche de l'opérateur est supérieur à l'objet concurrent_vector du côté droit.
operator>=, opérateur	Teste si l'objet concurrent_vector à gauche de l'opérateur est supérieur ou égal à l'objet concurrent_vector du côté droit.

Constantes

Nom	Description
AgentEventGuid, constante	Un GUID de catégorie ({B9B5B78C - 0713 à 4898 - Les 21 A.C. 67949DCED07}) qui décrit les événements ETW déclenchés par la Bibliothèque d'agents du runtime d'accès concurrentiel.
ChoreEventGuid, constante	Catégorie GUID qui décrit des événements ETW déclenchés par le runtime d'accès concurrentiel directement en rapport avec des tâches.
ConcRT_ProviderGuid, constante	GUID du fournisseur ETW pour le runtime d'accès concurrentiel.
CONCRT_RM_VERSION_1, constante	Indique la prise en charge de l'interface du Gestionnaire de ressources définie dans Visual Studio 2010.
ConcRTEventGuid, constante	Catégorie GUID qui décrit des événements ETW déclenchés par le runtime d'accès concurrentiel qui n'est pas décrit plus spécifiquement par une autre catégorie.
ContextEventGuid, constante	Catégorie GUID qui décrit des événements ETW déclenchés par le runtime d'accès concurrentiel directement en rapport avec des contextes.
COOPERATIVE_TIMEOUT_INFINITE, constante	Valeur qui indique qu'une attente ne doit jamais expirer.
COOPERATIVE_WAIT_TIMEOUT, constante	Valeur qui indique qu'une attente a expiré.
INHERIT_THREAD_PRIORITY, constante	Valeur spéciale pour la clé de stratégie ContextPriority qui indique que la priorité de thread de tous les contextes du planificateur doit être la même que celle du thread ayant créé le planificateur.
LockEventGuid, constante	Catégorie GUID qui décrit des événements ETW déclenchés par le runtime d'accès concurrentiel directement en rapport avec des verrous.
MaxExecutionResources, constante	Valeur spéciale pour les clés de stratégie MinConcurrency et MaxConcurrency. Prend comme valeur par défaut le nombre de threads matériels sur l'ordinateur en l'absence d'autres contraintes.
PPLParallelForeachEventGuid, constante	Catégorie GUID qui décrit des événements ETW déclenchés par le runtime d'accès concurrentiel directement en rapport avec l'utilisation de la fonction parallel_for_each.
PPLParallelForEventGuid, constante	Catégorie GUID qui décrit des événements ETW déclenchés par le runtime d'accès concurrentiel directement en rapport avec l'utilisation de la fonction parallel_for.
PPLParallelInvokeEventGuid, constante	Catégorie GUID qui décrit des événements ETW déclenchés par le runtime d'accès concurrentiel directement en rapport avec l'utilisation de la fonction parallel_invoke.
ResourceManagerEventGuid, constante	Catégorie GUID qui décrit des événements ETW déclenchés par le runtime d'accès concurrentiel directement en rapport avec le gestionnaire des ressources.
ScheduleGroupEventGuid, constante	Catégorie GUID qui décrit des événements ETW déclenchés par le runtime d'accès concurrentiel directement en rapport avec des groupes de planning.
SchedulerEventGuid, constante	Catégorie GUID qui décrit des événements ETW déclenchés par le runtime d'accès concurrentiel directement en rapport avec l'activité du planificateur.
VirtualProcessorEventGuid, constante	Catégorie GUID qui décrit des événements ETW déclenchés par le runtime d'accès concurrentiel directement en rapport avec des processeurs virtuels.

Configuration requise

Header: agents.h, concrt.h, concrtrm.h, concurrent_priority_queue.h, concurrent_queue.h, concurrent_unordered_map.h, concurrent_unordered_set.h, concurrent_vector.h, internal_concurrent_hash.h, internal_split_ordered_list.h, ppl.h, pplcancellation_token.h, pplconcrt.h, pplinterface.h, ppltasks.h

Voir aussi

Autres ressources

Référence (runtime d'accès concurrentiel)