fonctions de l'espace de noms de concurrence

Les fonctions suivantes sont disponibles dans l’espace de noms :

Alloc

Alloue un bloc de mémoire de la taille spécifiée depuis le sous-allocateur de mise en cache du runtime d'accès concurrentiel.

void* __cdecl Alloc(size_t _NumBytes);

Paramètres

_NumBytes
Nombre d’octets de mémoire à allouer.

Valeur de retour

Pointeur vers la mémoire nouvellement allouée.

Notes

Pour plus d’informations sur les scénarios de votre application qui pourraient tirer parti de l’utilisation du sous-allocator de mise en cache, consultez Le planificateur de tâches.

asend

Opération d’envoi asynchrone qui planifie une tâche pour propager les données vers le bloc cible.

template <class T>
bool asend(
    _Inout_ ITarget<T>* _Trg,
    const T& _Data);

template <class T>
bool asend(
    ITarget<T>& _Trg,
    const T& _Data);

Paramètres

T
Type des données à envoyer.

_Trg
Pointeur ou référence à la cible à laquelle les données sont envoyées.

_Données
Référence aux données à envoyer.

Valeur de retour

si le message a été accepté avant le retour de la méthode, sinon.

Notes

Pour plus d’informations, consultez Fonctions de passage de messages.

annuler_tâche_actuelle

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 .

L'appel de cette fonction en dehors du corps d'un objet n'est pas pris en charge. Cela entraîne un comportement non défini, tel qu’un blocage ou une absence de réponse dans votre application.

inline __declspec(noreturn) void __cdecl cancel_current_task();

clair

Efface la file d’attente simultanée, détruisant tous les éléments actuellement mis en file d’attente. Cette méthode n'est pas sûre pour la concurrence.

template<typename T, class _Ax>
void concurrent_queue<T, _Ax>::clear();

Paramètres

_Ax

create_async

Crée une construction asynchrone Windows Runtime basée sur un objet lambda ou de fonction fourni par l’utilisateur. Le type de retour de est , , ou selon la signature de l’objet lambda passée à la méthode.

template<typename _Function>
__declspec(noinline) auto create_async(const _Function& _Func)
    -> decltype(ref new details::_AsyncTaskGeneratorThunk<_Function>(_Func));

Paramètres

_Fonction
Type.

_Func
Objet lambda ou fonction à partir duquel créer une construction asynchrone Windows Runtime.

Valeur de retour

Construction asynchrone représentée par un IAsyncAction^, IAsyncActionWithProgress^, IAsyncOperation^, ou un IAsyncOperationWithProgress^. L'interface retournée dépend de la signature de l'objet lambda passé dans la fonction.

Notes

Le type de retour du lambda détermine si la construction est une action ou une opération.

Les objets lambda qui retournent void provoquent la création d'actions. Les objets lambda qui retournent un résultat de type provoquent la création d'opérations TResult.

Le lambda peut également retourner un qui encapsule le travail asynchrone en lui-même ou fait partie de la continuation d'une chaîne de tâches représentant le travail asynchrone. Dans ce cas, l'objet lambda lui-même est exécuté en ligne, car les tâches sont celles exécutées de façon asynchrone et le type de retour de l'objet lambda est désencapsulé afin de produire la construction asynchrone retournée par . Cela implique qu’une expression lambda qui retourne une tâchevoid entraîne la création d’actions, et une expression lambda qui retourne une tâcheTResult entraîne la création d’opérations de TResult.

Une lambda peut prendre zéro, un ou deux arguments. Les arguments valides sont et , dans cet ordre si les deux sont utilisés. Une lambda sans arguments entraîne la création d'une structure asynchrone sans possibilité de rapporter la progression. Une expression lambda qui prend un progress_reporterTProgress provoque le retour d'une structure asynchrone qui rapporte une progression de type TProgress chaque fois que la méthode de l’objet progress_reporter est appelée. Une fonction lambda qui prend un argument cancellation_token peut utiliser ce dernier pour vérifier l’annulation, ou le passer aux tâches qu’elle crée afin que l’annulation de la fonctionnalité asynchrone provoque l’annulation de ces tâches.

Si le corps de l’objet lambda ou de fonction retourne un résultat (et non une tâcheTResult), l’expression lambda est exécutée de manière asynchrone dans l’assistant MTA du processus dans le contexte d’une tâche que le runtime crée implicitement pour elle. La méthode provoquera l’annulation de la tâche implicite.

Si le corps de l’expression lambda retourne une tâche, elle s'exécute en ligne, et en déclarant que l’expression lambda prend un argument de type , vous pouvez déclencher l’annulation de toutes les tâches que vous créez dans l’expression lambda en passant ce jeton lors de leur création. Vous pouvez également utiliser la méthode sur le jeton pour que le runtime appelle un rappel lorsque vous appelez sur l’opération asynchrone ou l’action produite.

Cette fonction est disponible uniquement pour les applications Windows Runtime.

CreateResourceManager

Retourne une interface qui représente l'instance singleton du gestionnaire de ressources du Runtime de Concurrency. Le Resource Manager est chargé d’attribuer des ressources aux planificateurs qui souhaitent coopérer entre eux.

IResourceManager* __cdecl CreateResourceManager();

Valeur de retour

Interface .

Notes

Plusieurs appels ultérieurs à cette méthode retournent la même instance du Resource Manager. Chaque appel à la méthode incrémente un nombre de références sur le Resource Manager et doit être mis en correspondance avec un appel à la méthode IResourceManager ::Release lorsque votre planificateur communique avec le Resource Manager.

unsupported_os est levée si le système d’exploitation n’est pas pris en charge par le runtime d’accès concurrentiel.

créer_tâche

Crée un objet de tâche PPL. peut être utilisé partout où vous auriez utilisé un constructeur de tâche. Il est fourni principalement pour des raisons pratiques, car il permet d'utiliser le mot clé pendant la création de tâches.

template<typename T>
__declspec(noinline) auto create_task(T _Param, const task_options& _TaskOptions = task_options())
    -> task<typename details::_TaskTypeFromParam<T>::T>;

template<typename _ReturnType>
__declspec( noinline) task<_ReturnType> create_task(const task<_ReturnType>& _Task);

Paramètres

T
Type du paramètre à partir duquel la tâche doit être construite.

_ReturnType
Type.

_Param
Paramètre à partir duquel la tâche doit être construite. Il peut s’agir d’un objet lambda ou de fonction, d’un objet task_completion_event, d’un autre objet task ou d’une interface Windows ::Foundation ::IAsyncInfo si vous utilisez des tâches dans votre application UWP.

_TaskOptions
Options de tâche.

_Tâche
Tâche à créer.

Valeur de retour

Nouvelle tâche de type , déduite de .

Notes

La première surcharge se comporte comme un constructeur de tâche qui prend un paramètre unique.

La deuxième surcharge associe le jeton d’annulation fourni à la tâche nouvellement créée. Si vous utilisez cette surcharge, vous n’êtes pas autorisé à passer un autre objet comme premier paramètre.

Le type de la tâche retournée est déduit du premier paramètre à la fonction. Si est un , un , ou un fonctor qui retourne soit le type soit , le type de la tâche créée est .

Dans une application UWP, si _Param est de type Windows ::Foundation ::IAsyncOperation<T>^ ou Windows ::Foundation ::IAsyncOperationWithProgress<T,P>^, ou un fonctor qui retourne l’un de ces types, la tâche créée sera de type task<T>. Si _Param est de type Windows ::Foundation ::IAsyncAction^ ou Windows ::Foundation ::IAsyncActionWithProgress<P>^, ou un fonctor qui retourne l’un de ces types, la tâche créée aura le type task<void>.

Désactiver le traçage

Désactive le traçage dans le Concurrency Runtime. Cette fonction est déconseillée car le suivi ETW est désinscrit par défaut.

__declspec(deprecated("Concurrency::DisableTracing is a deprecated function.")) _CRTIMP HRESULT __cdecl DisableTracing();

Valeur de retour

Si le suivi a été correctement désactivé, est retourné. Si le suivi n’a pas été initié précédemment, est retourné

ActiverTraçage

Active le traçage dans le Concurrency Runtime. Cette fonction est déconseillée car le suivi ETW est à présent activé par défaut.

__declspec(deprecated("Concurrency::EnableTracing is a deprecated function.")) _CRTIMP HRESULT __cdecl EnableTracing();

Valeur de retour

Si le suivi a été correctement lancé, est retourné ; sinon, est retourné.

Gratuit

Libère un bloc de mémoire précédemment alloué par la méthode au sous-allocateur de mise en cache du runtime d'accès concurrentiel.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

Paramètres

_PAllocation
Un pointeur vers la mémoire précédemment allouée par la méthode , qui doit être libérée. Si le paramètre est défini sur la valeur , cette méthode l’ignore et retourne immédiatement.

Notes

Pour plus d’informations sur les scénarios de votre application qui pourraient tirer parti de l’utilisation du sous-allocator de mise en cache, consultez Le planificateur de tâches.

get_ambient_scheduler

inline std::shared_ptr<::Concurrency::scheduler_interface> get_ambient_scheduler();

Valeur de retour

GetExecutionContextId

Retourne un identificateur unique qui peut être affecté à un contexte d'exécution qui implémente l'interface .

unsigned int __cdecl GetExecutionContextId();

Valeur de retour

Identificateur unique pour un contexte d’exécution.

Notes

Utilisez cette méthode pour obtenir un identificateur pour votre contexte d’exécution avant de passer une interface IExecutionContext en tant que paramètre à l’une des méthodes offertes par l’Resource Manager.

GetOSVersion

Retourne la version du système d'exploitation.

IResourceManager::OSVersion __cdecl GetOSVersion();

Valeur de retour

Valeur énumérée représentant le système d’exploitation.

Notes

unsupported_os est levée si le système d’exploitation n’est pas pris en charge par le runtime d’accès concurrentiel.

ObtenirNombreProcesseurs

Retourne le nombre de threads matériels sur le système sous-jacent.

unsigned int __cdecl GetProcessorCount();

Valeur de retour

Nombre de threads matériels.

Notes

unsupported_os est levée si le système d’exploitation n’est pas pris en charge par le runtime d’accès concurrentiel.

GetProcessorNodeCount

Retourne le nombre de nœuds NUMA ou de packages de processeurs sur le système sous-jacent.

unsigned int __cdecl GetProcessorNodeCount();

Valeur de retour

Nombre de nœuds ou de packages de processeur NUMA.

Notes

Si le système contient plus de nœuds NUMA que les packages de processeur, le nombre de nœuds NUMA est retourné, sinon, le nombre de packages de processeur est retourné.

unsupported_os est levée si le système d’exploitation n’est pas pris en charge par le runtime d’accès concurrentiel.

GetSchedulerId

Retourne un identificateur unique qui peut être affecté à un planificateur qui implémente l'interface .

unsigned int __cdecl GetSchedulerId();

Valeur de retour

Identificateur unique d’un planificateur.

Notes

Utilisez cette méthode pour obtenir un identificateur pour votre planificateur avant de passer une interface IScheduler en tant que paramètre à l’une des méthodes offertes par l’Resource Manager.

internal_assign_iterators

template<typename T, class _Ax>
template<class _I>
void concurrent_vector<T, _Ax>::internal_assign_iterators(
   _I first,
   _I last);

Paramètres

_Ax

_Je

premier

dernier

point d'interruption

Crée un point d'interruption pour l'annulation. Si une annulation est en cours dans le contexte où cette fonction est appelée, cela lèvera une exception interne qui abandonne l'exécution du travail parallèle actuellement en cours. Si aucune annulation n'est en cours, la fonction ne fait rien.

inline void interruption_point();

Notes

Vous ne devez pas intercepter l'exception d'annulation interne levée par la fonction . L’exception sera interceptée et gérée par l'environnement d'exécution, et l'interception peut entraîner un comportement anormal de votre programme.

est_groupe_tâche_actuel_annule

Retourne une indication qui détermine si le groupe de tâches qui s'exécute actuellement dans le contexte actuel est en cours d'annulation active (ou le sera bientôt). Notez que si aucun groupe de tâches ne s'exécute actuellement en ligne dans le contexte actuel, sera retourné.

bool __cdecl is_current_task_group_canceling();

Valeur de retour

si le groupe de tâches en cours d'exécution est en train d'être annulé, sinon.

Notes

Pour plus d’informations, consultez Annulation.

faire_un_choix

Construit un bloc de messagerie à partir d'un ou facultatif et de deux sources d'entrée ou plus.

template<typename T1, typename T2, typename... Ts>
choice<std::tuple<T1, T2, Ts...>> make_choice(
    Scheduler& _PScheduler,
    T1  _Item1,
    T2  _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
choice<std::tuple<T1, T2, Ts...>> make_choice(
    ScheduleGroup& _PScheduleGroup,
    T1  _Item1,
    T2  _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
choice<std::tuple<T1, T2, Ts...>> make_choice(
    T1  _Item1,
    T2  _Item2,
    Ts... _Items);

Paramètres

T1
Type de bloc de message de la première source.

T2
Type de bloc de message de la deuxième source.

_PScheduler
Objet dans lequel la tâche de propagation du bloc de messagerie est planifiée.

_Item1
Première source.

_Item2
Deuxième source.

_Éléments
Sources supplémentaires.

_PScheduleGroup
Objet dans lequel la tâche de propagation du bloc de messagerie est planifiée. L’objet utilisé est suggéré par le groupe de planification.

Valeur de retour

Bloc de message avec deux sources d’entrée ou plus.

make_greedy_join

Construit un bloc de messagerie à partir d'un ou facultatif et de deux sources d'entrée ou plus.

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>,greedy> make_greedy_join(
    Scheduler& _PScheduler,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>, greedy> make_greedy_join(
    ScheduleGroup& _PScheduleGroup,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>, greedy> make_greedy_join(
    T1 _Item1,
    T2 _Items,
    Ts... _Items);

Paramètres

T1
Type de bloc de message de la première source.

T2
Type de bloc de message de la deuxième source.

_PScheduler
Objet dans lequel la tâche de propagation du bloc de messagerie est planifiée.

_Item1
Première source.

_Item2
Deuxième source.

_Éléments
Sources supplémentaires.

_PScheduleGroup
Objet dans lequel la tâche de propagation du bloc de messagerie est planifiée. L’objet utilisé est suggéré par le groupe de planification.

Valeur de retour

Bloc de message avec deux sources d’entrée ou plus.

make_join

Construit un bloc de messagerie à partir d'un ou facultatif et de deux sources d'entrée ou plus.

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>>
    make_join(
Scheduler& _PScheduler,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>> make_join(
ScheduleGroup& _PScheduleGroup,
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

template<typename T1, typename T2, typename... Ts>
multitype_join<std::tuple<T1, T2, Ts...>> make_join(
    T1 _Item1,
    T2 _Item2,
    Ts... _Items);

Paramètres

T1
Type de bloc de message de la première source.

T2
Type de bloc de message de la deuxième source.

_PScheduler
Objet dans lequel la tâche de propagation du bloc de messagerie est planifiée.

_Item1
Première source.

_Item2
Deuxième source.

_Éléments
Sources supplémentaires.

_PScheduleGroup
Objet dans lequel la tâche de propagation du bloc de messagerie est planifiée. L’objet utilisé est suggéré par le groupe de planification.

Valeur de retour

Bloc de message avec deux sources d’entrée ou plus.

make_task

Méthode de fabrique pour la création d'un objet .

template <class _Function>
task_handle<_Function> make_task(const _Function& _Func);

Paramètres

_Fonction
Type de l’objet de fonction qui sera appelé pour exécuter le travail représenté par l’objet .

_Func
Fonction qui sera appelée pour exécuter le travail représenté par l’objet . Il peut s’agir d’un fonctor lambda, d’un pointeur vers une fonction ou d’un objet qui prend en charge une version de l’opérateur d’appel de fonction avec la signature .

Valeur de retour

Objet .

Notes

Cette fonction est utile lorsque vous devez créer un objet avec une expression lambda, car elle vous permet de créer l’objet sans connaître le type vrai du fonctor lambda.

tri_parallèle_tamponné

Organise les éléments d’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 similaire à en ce sens qu'il s'agit d'un tri sur place, par comparaison et instable, à l'exception près qu'elle a besoin d'un espace supplémentaire et qu'elle requiert une initialisation par défaut pour les éléments triés.

template<typename _Random_iterator>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator,
    typename _Random_iterator>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator,
    typename _Random_iterator>
inline void parallel_buffered_sort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Random_iterator,
    typename _Function>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

template<typename _Allocator,
    typename _Random_iterator,
    typename _Function>
inline void parallel_buffered_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

template<typename _Allocator,
    typename _Random_iterator,
    typename _Function>
inline void parallel_buffered_sort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

Paramètres

_Random_iterator
Type d’itérateur de la plage d’entrée.

_Allocator
Type d’un allocateur de mémoire compatible avec la bibliothèque C++ Standard.

_Fonction
Type du comparateur binaire.

_Commencer
Itérateur d’accès aléatoire ciblant la position du premier élément de la plage à trier.

_Fin
Itérateur d’accès aléatoire ciblant la position juste après le dernier élément de la plage à trier.

_Alloc
Instance d’un allocateur de mémoire compatible avec la bibliothèque C++ Standard.

_Func
Objet de fonction de prédicat défini par l’utilisateur qui définit le critère de comparaison à satisfaire par des éléments successifs dans l’ordre. Un prédicat binaire accepte deux arguments et retourne quand la condition est satisfaite et quand elle ne l’est pas. Cette fonction de comparaison doit imposer un ordre faible strict sur les paires d’éléments de la séquence.

_Chunk_size
La taille minimale d’un bloc qui sera divisé en deux pour l’exécution parallèle.

Notes

Toutes les surcharges nécessitent un espace supplémentaire, où est le nombre d’éléments à trier et est le type d’élément. Dans la plupart des cas, parallel_buffered_sort affiche une amélioration des performances sur parallel_sort, et vous devez l’utiliser sur parallel_sort si la mémoire est disponible.

Si vous ne fournissez pas de comparateur binaire est utilisé comme valeur par défaut, ce qui nécessite le type d’élément pour fournir l’opérateur .

Si vous ne fournissez pas de type ou d’instance d’allocateur, l’allocateur de mémoire de la bibliothèque standard C++ est utilisé pour allouer la mémoire tampon.

L’algorithme divise la plage d’entrée en deux blocs et divise successivement chaque bloc en deux sous-blocs pour l’exécution en parallèle. L’argument facultatif peut être utilisé pour indiquer à l’algorithme qu’il doit gérer des blocs de taille en série.

parallel_for

effectue une itération sur une plage d'index et exécute une fonction fournie par l'utilisateur à chaque itération, en parallèle.

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

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    _Index_type _Step,
    const _Function& _Func);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    const auto_partitioner& _Part = auto_partitioner());

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    const static_partitioner& _Part);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    const simple_partitioner& _Part);

template <typename _Index_type, typename _Function>
void parallel_for(
    _Index_type first,
    _Index_type last,
    const _Function& _Func,
    affinity_partitioner& _Part);

Paramètres

_Index_type
Type de l’index utilisé pour l’itération.

_Fonction
Type de la fonction qui sera exécutée à chaque itération.

_Partitioner
Type du partitionneur utilisé pour partitionner la plage fournie.

premier
Premier index à inclure dans l’itération.

dernier
Index un après le dernier index à inclure dans l’itération.

_Étape
Valeur du pas à utiliser lors de l'itération de à . L’étape doit être positive. invalid_argument est levée si l’étape est inférieure à 1.

_Func
Fonction à exécuter à chaque itération. Il peut s’agir d’une expression lambda, d’un pointeur de fonction ou d’un objet qui prend en charge une version de l’opérateur d’appel de fonction avec la signature .

_Partie
Référence à l'objet partitionneur. L’argument peut être l’un des auto_partitioner, static_partitioner, simple_partitioner ou . Si un objet affinity_partitioner est utilisé, la référence doit être une référence non-constante de type l-value, afin que l’algorithme puisse stocker l’état pour réutiliser dans les boucles futures.

Notes

Pour plus d’informations, consultez Algorithmes parallèles.

parallel_for_each

applique une fonction spécifiée à chaque élément dans une plage, en parallèle. Sémantiquement, elle équivaut à la fonction dans l'espace de noms , si ce n'est que l'itération des éléments est effectuée en parallèle et que l'ordre d'itération n'est pas spécifié. L’argument doit prendre en charge un opérateur d’appel de fonction sous la forme de où le paramètre est le type d’élément du conteneur en cours d’itération.

template <typename _Iterator, typename _Function>
void parallel_for_each(
    _Iterator first,
    _Iterator last,
    const _Function& _Func);

template <typename _Iterator, typename _Function, typename _Partitioner>
void parallel_for_each(
    _Iterator first,
    _Iterator last,
    const _Function& _Func,
    _Partitioner&& _Part);

Paramètres

_Itérateur
Type de l’itérateur utilisé pour itérer sur le conteneur.

_Fonction
Type de la fonction qui sera appliquée à chaque élément de la plage.

_Partitioner
premier
Itérateur qui traite de la position du premier élément à inclure dans l’itération parallèle.

dernier
Itérateur qui traite de la position un après l’élément final à inclure dans l’itération parallèle.

_Func
Objet de fonction défini par l’utilisateur appliqué à chaque élément de la plage.

Notes

auto_partitioner sera utilisé pour la surcharge de fonctions sans partitionneur explicite.

Pour les itérateurs qui ne prennent pas en charge l’accès aléatoire, seul auto_partitioner est pris en charge.

Pour plus d’informations, consultez Algorithmes parallèles.

parallel_invoke

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 .

template <typename _Function1, typename _Function2>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2);

template <typename _Function1, typename _Function2, typename _Function3>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4);

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

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

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

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

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

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

Paramètres

_Function1
Type du premier objet de fonction à exécuter en parallèle.

_Function2
Type du deuxième objet de fonction à exécuter en parallèle.

_Function3
Type du troisième objet de fonction à exécuter en parallèle.

_Function4
Type du quatrième objet de fonction à exécuter en parallèle.

_Function5
Type du cinquième objet de fonction à exécuter en parallèle.

_Function6
Type du sixième objet de fonction à exécuter en parallèle.

_Function7
Type du septième objet de fonction à exécuter en parallèle.

_Function8
Type du huitième objet de fonction à exécuter en parallèle.

_Function9
Type du neuvième objet de fonction à exécuter en parallèle.

_Function10
Type du dixième objet de fonction à exécuter en parallèle.

_Func1
Premier objet de fonction à exécuter en parallèle.

_Func2
Deuxième objet de fonction à exécuter en parallèle.

_Func3
Troisième objet de fonction à exécuter en parallèle.

_Func4
Quatrième objet de fonction à exécuter en parallèle.

_Func5
Cinquième objet de fonction à exécuter en parallèle.

_Func6
Sixième objet de fonction à exécuter en parallèle.

_Func7
Septième objet de fonction à exécuter en parallèle.

_Func8
Huitième objet de fonction à exécuter en parallèle.

_Func9
Neuvième objet de fonction à exécuter en parallèle.

_Func10
Dixième objet de fonction à exécuter en parallèle.

Notes

Notez qu’un ou plusieurs des objets de fonction fournis en tant que paramètres peuvent s’exécuter en ligne dans le contexte appelant.

Si un ou plusieurs objets de fonction passés en tant que paramètres à cette fonction lèvent une exception, le runtime sélectionne une telle exception de son choix et la propage en dehors de l'appel à .

Pour plus d’informations, consultez Algorithmes parallèles.

parallel_radixsort

Réorganise les éléments d'une plage spécifiée dans un ordre non décroissant à l'aide d'un algorithme de tri de base. Il s'agit d'une fonction de tri stable qui requiert une fonction de projection capable de projeter les éléments à trier dans des clés de type entiers non signés. L'initialisation par défaut est requise pour les éléments triés.

template<typename _Random_iterator>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator, typename _Random_iterator>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Allocator, typename _Random_iterator>
inline void parallel_radixsort(
    const _Allocator& _Alloc,
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Random_iterator, typename _Function>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Proj_func,
    const size_t _Chunk_size = 256* 256);

template<typename _Allocator, typename _Random_iterator,
    typename _Function>
inline void parallel_radixsort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Proj_func,
    const size_t _Chunk_size = 256* 256);

template<typename _Allocator,
    typename _Random_iterator,
    typename _Function>
inline 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);

Paramètres

_Random_iterator
Type d’itérateur de la plage d’entrée.

_Allocator
Type d’un allocateur de mémoire compatible avec la bibliothèque C++ Standard.

_Fonction
Type de la fonction de projection.

_Commencer
Itérateur d’accès aléatoire ciblant la position du premier élément de la plage à trier.

_Fin
Itérateur d’accès aléatoire ciblant la position juste après le dernier élément de la plage à trier.

_Alloc
Instance d’un allocateur de mémoire compatible avec la bibliothèque C++ Standard.

_Proj_func
Objet de fonction de projection défini par l’utilisateur qui convertit un élément en valeur intégrale.

_Chunk_size
La taille minimale d’un bloc qui sera divisé en deux pour l’exécution parallèle.

Notes

Toutes les surcharges nécessitent un espace supplémentaire, où est le nombre d’éléments à trier et est le type d’élément. Un fonctor de projection unaire avec la signature est nécessaire pour retourner une clé lorsqu’un élément est donné, où est le type d’élément et est un type entier non signé.

Si vous ne fournissez pas de fonction de projection, une fonction de projection par défaut qui retourne simplement l’élément est utilisée pour les types intégraux. La fonction échoue à compiler si l’élément n’est pas un type intégral en l’absence d’une fonction de projection.

Si vous ne fournissez pas de type ou d’instance d’allocateur, l’allocateur de mémoire de la bibliothèque standard C++ est utilisé pour allouer la mémoire tampon.

parallel_reduce

Calcule la somme de tous les éléments d'une plage spécifiée en calculant des sommes partielles successives, ou calcule le résultat des résultats partiels successifs obtenus de la même façon en utilisant une opération binaire spécifiée autre que la somme, en parallèle. est sémantiquement similaire à , à l'exception près qu'elle a besoin que l'opération binaire soit associative et qu'elle requiert une valeur d'identité au lieu d'une valeur initiale.

template<typename _Forward_iterator>
inline typename 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);

template<typename _Forward_iterator, typename _Sym_reduce_fun>
inline typename 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);

template<typename _Reduce_type,
    typename _Forward_iterator,
    typename _Range_reduce_fun,
    typename _Sym_reduce_fun>
inline _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);

Paramètres

_Forward_iterator
Type d’itérateur de plage d’entrée.

_Sym_reduce_fun
Type de la fonction de réduction symétrique. Il doit s’agir d’un type de fonction avec signature , où _Reduce_type est identique au type d’identité et au type de résultat de la réduction. Pour la troisième surcharge, cela doit être cohérent avec le type de sortie de .

_Reduce_type
Type auquel l’entrée sera réduite, ce qui peut être différent du type d’élément d’entrée. La valeur de retour et la valeur d’identité ont ce type.

_Range_reduce_fun
Type de la fonction de réduction de plage. Il doit s’agir d’un type de fonction avec signature , _Reduce_type est identique au type d’identité et au type de résultat de la réduction.

_Commencer
Itérateur d’entrée ciblant le premier élément de la plage à réduire.

_Fin
Itérateur d’entrée ciblant l’élément qui est une position au-delà de l’élément final de la plage à réduire.

_Identité
La valeur d'identité est du même type que le type de résultat de la réduction et également utilisée comme de l'itérateur pour la première et la seconde surcharge. Pour la troisième surcharge, la valeur d’identité doit avoir le même type que le type de résultat de la réduction, mais peut être différente de celle de l’itérateur. Elle doit avoir une valeur appropriée de sorte que l’opérateur de réduction de plage, lorsqu’il est appliqué à une plage d’un seul élément de type et à la valeur identitaire, se comporte comme une conversion de type de la valeur du type au type identitaire.

_Sym_fun
Fonction symétrique qui sera utilisée durant la deuxième étape de la réduction. Pour plus d’informations, reportez-vous aux remarques.

_Range_fun
Fonction qui sera utilisée dans la première phase de la réduction. Pour plus d’informations, reportez-vous aux remarques.

Valeur de retour

Résultat de la réduction.

Notes

Pour effectuer une réduction parallèle, la fonction divise l'intervalle en segments en fonction du nombre de travailleurs disponibles pour le planificateur sous-jacent. La réduction a lieu en deux phases, la première phase effectue une réduction dans chaque segment, et la deuxième phase effectue une réduction entre les résultats partiels de chaque segment.

La première surcharge nécessite que le type de l’itérateur, , soit le même que le type de valeur d’identité, ainsi que le type de résultat de réduction, . Le type d’élément T doit fournir l’opérateur pour réduire les éléments dans chaque bloc. Le même opérateur est également utilisé dans la deuxième phase.

La deuxième surcharge nécessite également que l'itérateur soit du même type que , c'est-à-dire le type de valeur d'identité ainsi que le type de résultat de réduction. L’opérateur binaire fourni est utilisé dans les deux phases de réduction, avec la valeur d’identité comme valeur initiale pour la première phase.

Pour la troisième surcharge, le type de valeur d’identité doit être identique au type de résultat de réduction, mais l’itérateur peut être différent des deux. La fonction de réduction de plage est utilisée dans la première phase avec la valeur d’identité comme valeur initiale, et la fonction binaire est appliquée aux sous-résultats de la deuxième phase.

parallel_sort

template<typename _Random_iterator>
inline void parallel_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End);

template<typename _Random_iterator,typename _Function>
inline void parallel_sort(
    const _Random_iterator& _Begin,
    const _Random_iterator& _End,
    const _Function& _Func,
    const size_t _Chunk_size = 2048);

Paramètres

_Random_iterator
Type d’itérateur de la plage d’entrée.

_Fonction
Type du fonctor de comparaison binaire.

_Commencer
Itérateur d’accès aléatoire ciblant la position du premier élément de la plage à trier.

_Fin
Itérateur d’accès aléatoire ciblant la position juste après le dernier élément de la plage à trier.

_Chunk_size
Taille minimale d’un bloc qui sera divisé en deux pour l’exécution parallèle.

Notes

La première surcharge utilise le comparateur binaire .

Le deuxième surchargé utilise le comparateur binaire fourni qui doit avoir la signature où est le type des éléments de la plage d’entrée.

parallel_transform

Applique un objet de fonction spécifié à chaque élément d'une plage source ou à une paire d'éléments de deux plages sources, et copie les valeurs de retour de l'objet de fonction dans une plage de destination, en parallèle. Cette fonction équivaut sémantiquement à .

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

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

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

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

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

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

Paramètres

_Input_iterator1
Le type du premier itérateur ou du seul itérateur d'entrée.

_Output_iterator
Type de l’itérateur de sortie.

_Unary_operator
Le type de foncteur unaire à exécuter sur chaque élément de la plage d'entrée.

_Input_iterator2
Le type du second itérateur d'entrée.

_Opérateur_binaire
Le type de foncteur binaire exécuté par paires sur les éléments des deux intervalles sources.

_Partitioner
first1
Itérateur d'entrée qui traite la position du premier élément de la première ou de l'unique plage source à traiter.

last1
Itérateur d'entrée qui traite la position juste après l'élément final dans la première ou l'unique plage source à traiter.

_Résultat
Itérateur de sortie qui traite la position du premier élément dans la plage de destination.

_Unary_op
Objet de fonction unaire défini par l'utilisateur appliqué à chaque élément dans la plage source.

first2
Itérateur d'entrée qui adresse la position du premier élément de la seconde plage source à traiter.

_Binary_op
Objet de fonction binaire défini par l'utilisateur qui est appliqué par couple, progressivement, sur les deux plages sources.

Valeur de retour

Itérateur de sortie qui traite la position située immédiatement après le dernier élément de la plage de destination qui reçoit les éléments de sortie transformés par l'objet de fonction.

Notes

auto_partitioner sera utilisé pour les surcharges sans argument de partitionneur explicite.

Pour les itérateurs qui ne prennent pas en charge l’accès aléatoire, seul auto_partitioner est pris en charge.

Les surcharges prenant l'argument transforment la plage d'entrée en plage de sortie en appliquant le foncteur unaire à chaque élément de la plage d'entrée. doit prendre en charge l'opérateur d'appel de fonction avec la signature où est le type de valeur de la plage à itérer.

Les surcharges prenant l'argument transforment deux plages d'entrée en une plage de sortie en appliquant le foncteur binaire à un élément de la première plage d'entrée et à un élément de la deuxième plage d'entrée. doit prendre en charge l'opérateur d'appel de fonction avec la signature où , sont des types de valeur des deux itérateurs d'entrée.

Pour plus d’informations, consultez Algorithmes parallèles.

recevoir

Implémentation générale de la fonction receive, qui permet à un contexte d'attendre des données en provenance d'une seule source exactement et de filtrer les valeurs qui sont acceptées.

template <class T>
T receive(
    _Inout_ ISource<T>* _Src,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

template <class T>
T receive(
    _Inout_ ISource<T>* _Src,
    typename ITarget<T>::filter_method const& _Filter_proc,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

template <class T>
T receive(
    ISource<T>& _Src,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

template <class T>
T receive(
    ISource<T>& _Src,
    typename ITarget<T>::filter_method const& _Filter_proc,
    unsigned int _Timeout = COOPERATIVE_TIMEOUT_INFINITE);

Paramètres

T
Type de charge utile.

_Src
Pointeur ou référence à la source à partir de laquelle les données sont attendues.

_Timeout
Durée maximale pendant laquelle la méthode doit s'appliquer aux données, en millisecondes.

_Filter_proc
Fonction de filtre qui détermine si les messages doivent être acceptés.

Valeur de retour

Valeur de la source, du type de charge utile.

Notes

Si le paramètre a une valeur autre que la constante , l’exception operation_timed_out est levée si la durée spécifiée expire avant la réception d’un message. Si vous souhaitez un délai d’expiration de durée zéro, vous devez utiliser la fonction try_receive , plutôt que d’appeler avec un délai d’attente de (zéro), car il est plus efficace et ne lève pas d’exceptions sur les délais d’attente.

Pour plus d’informations, consultez Fonctions de passage de messages.

exécuter_avec_un_jalon_d'annulation

Exécute un objet de fonction immédiatement et de manière synchrone dans le contexte d’un jeton d’annulation donné.

template<typename _Function>
void run_with_cancellation_token(
    const _Function& _Func,
    cancellation_token _Ct);

Paramètres

_Fonction
Type de l’objet de fonction qui sera appelé.

_Func
Objet de fonction qui sera exécuté. Cet objet doit supporter l'opérateur d'appel de fonction avec une signature void(void).

_Ct
Jeton d’annulation qui contrôle l’annulation implicite de l’objet de fonction. Utilisez si vous souhaitez que la fonction s’exécute sans possibilité d’annulation implicite d’un groupe de tâches parent en cours d’annulation.

Notes

Tous les points d’interruption dans l’objet de fonction seront déclenchés lorsque est annulé. Le jeton explicite isolera de l’annulation du parent si celui-ci possède un jeton différent ou aucun.

Envoyer

Opération d’envoi synchrone qui attend que la cible accepte ou refuse le message.

template <class T>
bool send(_Inout_ ITarget<T>* _Trg, const T& _Data);

template <class T>
bool send(ITarget<T>& _Trg, const T& _Data);

Paramètres

T
Type de charge utile.

_Trg
Pointeur ou référence à la cible à laquelle les données sont envoyées.

_Données
Référence aux données à envoyer.

Valeur de retour

si le message a été accepté, sinon.

Notes

Pour plus d’informations, consultez Fonctions de passage de messages.

définir_planificateur_ambiant

inline void set_ambient_scheduler(std::shared_ptr<::Concurrency::scheduler_interface> _Scheduler);

Paramètres

_Planificateur
Planificateur d'environnement à paramétrer.

définir_ressources_exécution_tâche

Limite les ressources d'exécution utilisées par les threads de travail internes du Runtime de concurrence à l'ensemble d'affinité spécifié.

Il est valide d’appeler cette méthode uniquement avant la création du Resource Manager, ou entre deux cycles de vie du Resource Manager. Il peut être appelé plusieurs fois tant que le Resource Manager n’existe pas au moment de l’appel. Une fois qu'une limite d'affinité a été définie, elle reste en vigueur jusqu'au prochain appel valide à la méthode .

Le masque d'affinité fourni n'a pas besoin de correspondre à un sous-ensemble du masque d'affinité du processus. L'affinité du processus est mise à jour si nécessaire.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

void __cdecl set_task_execution_resources(
    unsigned short count,
    PGROUP_AFFINITY _PGroupAffinity);

Paramètres

_ProcessAffinityMask
Masque d’affinité auquel les threads de travail du runtime d’accès concurrentiel doivent être limités. Utilisez cette méthode sur un système avec plus de 64 threads matériels uniquement si vous souhaitez limiter le runtime d’accès concurrentiel à un sous-ensemble du groupe de processeurs actuel. En général, vous devez utiliser la version de la méthode qui accepte un tableau d’affinités de groupe en tant que paramètre, pour restreindre l’affinité sur les machines avec plus de 64 threads matériels.

compte
Nombre d’entrées dans le tableau spécifié par le paramètre .

_PGroupAffinity
Tableau d’entrées .

Notes

La méthode lève une exception invalid_operation si une Resource Manager est présente au moment où elle est appelée et une exception invalid_argument si l’affinité spécifiée génère un ensemble vide de ressources.

La version de la méthode qui prend un tableau d’affinités de groupe en tant que paramètre ne doit être utilisée que sur les systèmes d’exploitation avec la version Windows 7 ou ultérieure. Sinon, une exception invalid_operation est levée.

La modification par programmation de l’affinité de processus après l’appel de cette méthode n’entraîne pas l’Resource Manager de réévaluer l’affinité à laquelle elle est limitée. Par conséquent, toutes les modifications concernant l'affinité de processus doivent être effectuées avant d'appeler cette méthode.

échanger

Échange les éléments de deux objets .

template<typename T, class _Ax>
inline void swap(
    concurrent_vector<T, _Ax>& _A,
    concurrent_vector<T, _Ax>& _B);

Paramètres

T
Type de données des éléments stockés dans les vecteurs simultanés.

_Ax
Type d’allocateur des vecteurs simultanés.

_A
Vecteur simultané dont les éléments doivent être échangés avec ceux du vecteur simultané .

_B
Vecteur simultané fournissant les éléments à permuter, ou le vecteur dont les éléments doivent être échangés avec ceux du vecteur simultané .

Notes

La fonction template est un algorithme spécialisé dans la classe de conteneur pour exécuter la fonction membre . concurrent_vector ::swap(). Il s’agit d’instances de l’ordonnancement partiel des modèles de fonctions par le compilateur. Quand des fonctions de modèle sont surchargées de sorte que la correspondance du modèle avec l’appel de fonction n’est pas unique, le compilateur sélectionne la version la plus spécialisée de la fonction de modèle. La version générale de la fonction de modèle, dans la classe d’algorithme fonctionne par affectation et est une opération lente. La version spécialisée dans chaque conteneur est beaucoup plus rapide, car elle peut fonctionner avec la représentation interne de la classe de conteneur.

Cette méthode n'est pas sûre pour la concurrence. Vous devez vous assurer qu’aucun autre thread n’effectue d’opérations sur l’un des vecteurs simultanés lorsque vous appelez cette méthode.

task_from_exception (tâche_depuis_exception)

template<typename _TaskType, typename _ExType>
task<_TaskType> task_from_exception(
    _ExType _Exception,
    const task_options& _TaskOptions = task_options());

Paramètres

_TaskType

_ExType

_Exception

_TaskOptions

Valeur de retour

tâche_depuis_résultat

template<typename T>
task<T> task_from_result(
    T _Param,
    const task_options& _TaskOptions = task_options());

inline task<bool> task_from_result(ool _Param);

inline task<void> task_from_result(
    const task_options& _TaskOptions = task_options());

Paramètres

_Param

_TaskOptions

Valeur de retour

Trace_agents_register_name

Associe le nom donné au bloc de message ou à l'agent dans le tracé ETW.

template <class T>
void Trace_agents_register_name(
    _Inout_ T* _PObject,
    _In_z_ const wchar_t* _Name);

Paramètres

T
Type de l’objet. Il s’agit généralement d’un bloc de messages ou d’un agent.

_PObject
Pointeur vers le bloc de message ou l’agent nommé dans la trace.

_Nom
Nom de l’objet donné.

essayer_de_recevoir

Implémentation générale de la fonction try-receive, qui permet à un contexte de rechercher des données en provenance d'une seule source exactement et de filtrer les valeurs qui sont acceptées. Si les données ne sont pas prêtes, la méthode retourne .

template <class T>
bool try_receive(_Inout_ ISource<T>* _Src, T& _value);

template <class T>
bool try_receive(
    _Inout_ ISource<T>* _Src,
    T& _value,
    typename ITarget<T>::filter_method const& _Filter_proc);

template <class T>
bool try_receive(ISource<T>& _Src, T& _value);

template <class T>
bool try_receive(
    ISource<T>& _Src,
    T& _value,
    typename ITarget<T>::filter_method const& _Filter_proc);

Paramètres

T
Type de charge utile

_Src
Pointeur ou référence à la source à partir de laquelle les données sont attendues.

_valeur
Référence à un emplacement où le résultat sera placé.

_Filter_proc
Fonction de filtre qui détermine si les messages doivent être acceptés.

Valeur de retour

Valeur indiquant si une charge utile a été placée ou non dans .

Notes

Pour plus d’informations, consultez Fonctions de passage de messages.

attendre

Suspend le contexte actuel pendant une durée spécifiée.

void __cdecl wait(unsigned int _Milliseconds);

Paramètres

_Millisecondes
Le nombre de millisecondes pour lesquelles le contexte actuel doit être suspendu. Si le paramètre est défini sur la valeur , le contexte actuel doit céder l'exécution à d'autres contextes en cours d'exécution avant de poursuivre.

Notes

Si cette méthode est appelée sur un contexte du planificateur d'exécution du Concurrency Runtime, le planificateur trouve un autre contexte pour s'exécuter sur la ressource sous-jacente. Étant donné que le planificateur est de nature coopérative, ce contexte ne peut pas reprendre exactement après le nombre de millisecondes spécifiées. Si le planificateur est occupé à exécuter d'autres tâches qui ne cèdent pas coopérativement au planificateur, la période d'attente peut être indéfinie.

when_all

Crée une tâche qui s’effectue correctement lorsque toutes les tâches fournies comme arguments s’effectuent correctement.

template <typename _Iterator>
auto when_all(
    _Iterator _Begin,
    _Iterator _End,
    const task_options& _TaskOptions = task_options()) ->
    decltype (details::_WhenAllImpl<typename std::iterator_traits<_Iterator>::value_type::result_type,
    _Iterator>::_Perform(_TaskOptions, _Begin,  _End));

Paramètres

_Itérateur
Type de l'itérateur d'entrée.

_Commencer
Position du premier élément dans la plage d’éléments à combiner dans la tâche obtenue.

_Fin
Position du premier élément au-delà de la plage d’éléments à combiner dans la tâche obtenue.

_TaskOptions
Objet .

Valeur de retour

Une tâche qui se termine avec succès lorsque toutes les tâches d’entrée se sont terminées avec succès. Si les tâches d’entrée sont de type , le résultat de cette fonction sera . Si les tâches d’entrée sont de type , la tâche de sortie sera également .

Notes

est une fonction non bloquante qui produit un en tant que résultat. Contrairement à task ::wait, il est sûr d’appeler cette fonction dans une application UWP sur le thread ASTA (Application STA).

Si l'une des tâches est annulée ou qu'elle soulève une exception, la tâche retournée se terminera rapidement, dans un état annulé, et, si une exception se produit, elle sera levée si vous appelez la tâche::get ou sur cette tâche.

Pour plus d’informations, consultez Parallélisme des tâches.

when_any

Crée une tâche qui se termine avec succès lorsque l'une des tâches fournies en tant qu'arguments se termine avec succès.

template<typename _Iterator>
auto when_any(
    _Iterator _Begin,
    _Iterator _End,
    const task_options& _TaskOptions = task_options())
    -> decltype (
        details::_WhenAnyImpl<
            typename std::iterator_traits<_Iterator>::value_type::result_type,
            _Iterator>::_Perform(_TaskOptions, _Begin, _End));

template<typename _Iterator>
auto when_any(
    _Iterator _Begin,
    _Iterator _End,
    cancellation_token _CancellationToken)
       -> decltype (
           details::_WhenAnyImpl<
               typename std::iterator_traits<_Iterator>::value_type::result_type,
               _Iterator>::_Perform(_CancellationToken._GetImplValue(), _Begin, _End));

Paramètres

_Itérateur
Type de l'itérateur d'entrée.

_Commencer
Position du premier élément dans la plage d’éléments à combiner dans la tâche obtenue.

_Fin
Position du premier élément au-delà de la plage d’éléments à combiner dans la tâche obtenue.

_TaskOptions
_CancellationToken
Le jeton d'annulation qui contrôle l'annulation de la tâche retournée. Si vous ne fournissez pas de jeton d’annulation, la tâche qui en résulte recevra le jeton d’annulation de la tâche entraînant sa fin.

Valeur de retour

Tâche qui s'effectue quand l'une des deux tâches d'entrée s'est correctement déroulée. Si les tâches d’entrée sont de type , la sortie de cette fonction est une , où le premier élément de la paire est le résultat de la fin de la tâche et le deuxième élément est l’index de la tâche terminée. Si les tâches d’entrée sont de type , la sortie est une , où le résultat est l’index de fin de la tâche.

Notes

Pour plus d’informations, consultez Parallélisme des tâches.

Voir aussi

concurrence Namespace

Commentaires

Cette page a-t-elle été utile ?

Last updated on 2026-03-06

Partager via

fonctions de l'espace de noms de concurrence

Alloc

Paramètres

Valeur de retour

Notes

asend

Paramètres

Valeur de retour

Notes

annuler_tâche_actuelle

clair

Paramètres

create_async

Paramètres

Valeur de retour

Notes

CreateResourceManager

Valeur de retour

Notes

créer_tâche

Paramètres

Valeur de retour

Notes

Désactiver le traçage

Valeur de retour

ActiverTraçage

Valeur de retour

Gratuit

Paramètres

Notes

get_ambient_scheduler

Valeur de retour

GetExecutionContextId

Valeur de retour

Notes

GetOSVersion

Valeur de retour

Notes

ObtenirNombreProcesseurs

Valeur de retour

Notes

GetProcessorNodeCount

Valeur de retour

Notes

GetSchedulerId

Valeur de retour

Notes

internal_assign_iterators

Paramètres

point d'interruption

Notes

est_groupe_tâche_actuel_annule

Valeur de retour

Notes

faire_un_choix

Paramètres

Valeur de retour

make_greedy_join

Paramètres

Valeur de retour

make_join

Paramètres

Valeur de retour

make_task

Paramètres

Valeur de retour

Notes

tri_parallèle_tamponné

Paramètres

Notes

parallel_for

Paramètres

Notes

parallel_for_each

Paramètres

Notes

parallel_invoke

Paramètres

Notes