concurrency, fonctions de l’espace de noms

Article
10/12/2023

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

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

Notes

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

cancel_current_task

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.

L'appel de cette fonction en dehors du corps d'un objet task 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();

clear

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écurisée par 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 create_async est IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^ ou IAsyncOperationWithProgress<TResult, TProgress>^ 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 de fonction à partir duquel créer une construction asynchrone Windows Runtime.

Valeur de retour

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

Notes

Le type de retour de l’objet 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 TResult provoquent la création d'opérations TResult.

L’objet lambda peut également retourner un résultat task<TResult> qui encapsule le travail asynchrone en lui-même ou qui est 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 create_async. Cela implique qu’une expression lambda qui retourne une tâche<void> entraîne la création d’actions, et une expression lambda qui retourne une tâche<TResult> entraîne la création d’opérations de TResult.

L’objet lambda peut prendre zéro, un ou deux arguments. Les arguments valides sont progress_reporter<TProgress> et cancellation_token, dans cet ordre si les deux sont utilisés. Un objet lambda sans arguments provoque la création d’une construction asynchrone sans la capacité de créer un rapport de progression. Une expression lambda qui prend un progress_reporter<TProgress> entraîne create_async le retour d’une construction asynchrone qui signale la progression du type TProgress chaque fois que la report méthode de l’objet progress_reporter est appelée. Un objet lambda qui prend un argument cancellation_token peut l’utiliser pour vérifier l’annulation, ou le passer aux tâches qu’il crée afin que l’annulation de la construction 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âche<TResult>), la lamdba 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 IAsyncInfo::Cancel provoquera l’annulation de la tâche implicite.

Si le corps de l'objet lambda retourne une tâche, l'objet lamba s'exécute en ligne, et si vous déclarez que l'objet lambda prend un argument de type cancellation_token, vous pouvez déclencher l'annulation de toutes les tâches que vous créez au sein de l'objet lambda en passant ce jeton lorsque vous créez les tâches. Vous pouvez également utiliser la méthode register_callback sur le jeton pour forcer le runtime à effectuer un rappel lorsque vous appelez IAsyncInfo::Cancel sur l'opération ou l'action asynchrone produite.

Cette fonction est disponible uniquement pour les applications Windows Runtime.

CreateResourceManager

Retourne une interface qui représente l'instance singleton du gestionnaire des ressources du runtime d'accès concurrentiel. Le gestionnaire des ressources est responsable de l'affectation des ressources aux planificateurs qui veulent coopérer.

IResourceManager* __cdecl CreateResourceManager();

Valeur de retour

Interface IResourceManager.

Notes

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

create_task

Crée un objet de tâche PPL. create_task 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é auto 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 task_completion_event objet, d’un objet différent 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 T, déduite de _Param.

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 task objet comme premier paramètre.

Le type de la tâche retournée est déduit du premier paramètre à la fonction. S’il _Param s’agit d’un , d’un task_completion_event<T>task<T>ou d’un fonctor qui retourne le type T ou task<T>le type de la tâche créée est task<T>.

Dans une application UWP, si _Param elle est de type Windows ::Foundation ::IAsyncOperation<T>^ ou Windows ::Foundation ::IAsyncOperationWithProgress<T,P>^, ou un functor 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>.

DisableTracing

Désactive le traçage dans le runtime d'accès concurrentiel. 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é, S_OK est retourné. Si le suivi n’a pas été initié précédemment, E_NOT_STARTED est retourné

EnableTracing

Active le traçage dans le runtime d'accès concurrentiel. 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é, S_OK est retourné ; sinon, E_NOT_STARTED il est retourné.

Gratuit

Libère un bloc de mémoire précédemment alloué par la méthode Alloc 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
Pointeur vers la mémoire précédemment allouée par la Alloc méthode à libérer. Si le paramètre _PAllocation est défini sur la valeur NULL, 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 IExecutionContext.

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 IExecutionContext interface en tant que paramètre à l’une des méthodes offertes par 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.

GetProcessorCount

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 IScheduler.

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 IScheduler interface en tant que paramètre à l’une des méthodes proposées par 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

first

last

interruption_point

Crée un point d'interruption pour l'annulation. Si une annulation est en cours dans le contexte dans lequel cette fonction est appelée, une exception interne est levée et annule l'exécution du travail parallèle 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 interruption_point() fonction. L’exception est interceptée et gérée par le runtime et l’intercepte peut entraîner le comportement anormal de votre programme.

is_current_task_group_canceling

Retourne une indication qui détermine si le groupe de tâches qui s'exécute actuellement inline sur le contexte actuel est au beau milieu d'une annulation active (ou le sera bientôt). Notez que si aucun groupe de tâches ne s'exécute actuellement inline sur le contexte actuel, false est retourné.

bool __cdecl is_current_task_group_canceling();

Valeur de retour

true si le groupe de tâches en cours d’exécution annule, false sinon.

Notes

Pour plus d’informations, consultez Annulation.

make_choice

Construit un bloc de messagerie choice à partir d'un Scheduler ou ScheduleGroup 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 Scheduler dans lequel la tâche de propagation du bloc de messagerie choice est planifiée.

_Item1
Première source.

_Item2
Deuxième source.

_Articles
Sources supplémentaires.

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

Valeur de retour

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

make_greedy_join

Construit un bloc de messagerie greedy multitype_join à partir d'un Scheduler ou ScheduleGroup 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 Scheduler dans lequel la tâche de propagation du bloc de messagerie multitype_join est planifiée.

_Item1
Première source.

_Item2
Deuxième source.

_Articles
Sources supplémentaires.

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

Valeur de retour

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

make_join

Construit un bloc de messagerie non_greedy multitype_join à partir d'un Scheduler ou ScheduleGroup 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 Scheduler dans lequel la tâche de propagation du bloc de messagerie multitype_join est planifiée.

_Item1
Première source.

_Item2
Deuxième source.

_Articles
Sources supplémentaires.

Valeur de retour

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

make_task

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

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 task_handle .

_Func
Fonction qui sera appelée pour exécuter le travail représenté par l’objet task_handle . 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 void operator()().

Valeur de retour

Objet task_handle.

Notes

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

parallel_buffered_sort

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 à std::sort 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 O(n) 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 true quand la condition est satisfaite et false 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
Taille de mimimum d’un bloc qui sera divisé en deux pour l’exécution parallèle.

Notes

Toutes les surcharges nécessitent n * sizeof(T) un espace supplémentaire, où n est le nombre d’éléments à trier et T 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 std::less binaire est utilisé comme valeur par défaut, ce qui nécessite le type d’élément pour fournir l’opérateur operator<().

Si vous ne fournissez pas de type ou d’instance d’allocateur, l’allocateur std::allocator<T> 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 _Chunk_size facultatif peut être utilisé pour indiquer à l’algorithme qu’il doit gérer des blocs de taille <_Chunk_size en série.

Parallel_for

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.

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

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

_Étape
Valeur par laquelle effectuer une itération à lastpartir de first . 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 void operator()(_Index_type).

_Partie
Référence au partitionneur d'objet. L’argument peut être l’un des constauto_partitioner&,const static_partitioner&,const simple_partitioner ou affinity_partitioner&& Si un objet affinity_partitioner est utilisé, la référence doit être une référence non const l-value, afin que l’algorithme puisse stocker l’état des boucles futures à réutiliser.

Notes

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

parallel_for_each

parallel_for_each applique une fonction spécifiée à chaque élément dans une plage, en parallèle. Sémantiquement, elle équivaut à la fonction for_each dans l'espace de noms std, 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 _Func doit prendre en charge un opérateur d’appel de fonction sous la forme de operator()(T) où le paramètre T 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
first
Itérateur qui traite de la position du premier élément à inclure dans l’itération parallèle.

last
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 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 void operator()().

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 inline sur 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 exception de ce type de choix et la propage hors de l’appel parallel_invoke.

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
Taille de mimimum d’un bloc qui sera divisé en deux pour l’exécution parallèle.

Notes

Toutes les surcharges nécessitent n * sizeof(T) un espace supplémentaire, où n est le nombre d’éléments à trier et T est le type d’élément. Un fonctor de projection unaire avec la signature I _Proj_func(T) est nécessaire pour retourner une clé lorsqu’un élément est donné, où T est le type d’élément et I 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 std::allocator<T> 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. parallel_reduce est sémantiquement similaire à std::accumulate, à 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 _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type), 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 _Range_reduce_fun.

_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 _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type), _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 _Identity d’identité est du même type que le type de résultat de la réduction et également de value_type l’itérateur pour les premières et seconde surcharges. 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 value_type de l’itérateur. Elle doit avoir une valeur appropriée de sorte que l’opérateur _Range_funde réduction de plage, lorsqu’il est appliqué à une plage d’un seul élément de type value_type et à la valeur d’identité, se comporte comme un cast de type de la valeur du type value_type au type d’identité.

_Sym_fun
Fonction symétrique qui sera utilisée dans la seconde 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 la plage en blocs en fonction du nombre de workers 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 l’itérateur soit Tle même que le type de valeur d’identitévalue_type, ainsi que le type de résultat de réduction. Le type d’élément T doit fournir l’opérateur T T::operator + (T) 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 le même que le type de valeur d’identité value_type , ainsi que le type de résultat de réduction. L’opérateur _Sym_fun 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é value_type doit être identique au type de résultat de réduction, mais les itérateurs peuvent être différents des deux. La fonction _Range_fun de réduction de plage est utilisée dans la première phase avec la valeur d’identité comme valeur initiale, et la fonction _Sym_reduce_fun 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 std::lessbinaire .

Le deuxième surchargé utilise le comparateur binaire fourni qui doit avoir la signature bool _Func(T, T) où T 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 à std::transform.

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.

_Binary_operator
Le type de foncteur binaire exécuté par couple sur les éléments des deux plages 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 de l'élément final dans la première ou dans 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 traite 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 _Unary_op transforment la plage d'entrée en plage de sortie en appliquant le foncteur unaire à chaque élément de la plage d'entrée. _Unary_op doit prendre en charge l'opérateur d'appel de fonction avec la signature operator()(T) où T est le type de valeur de la plage à itérer.

Les surcharges prenant l'argument _Binary_op 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. _Binary_op doit prendre en charge l'opérateur d'appel de fonction avec la signature operator()(T, U) où T, U sont des types de valeur des deux itérateurs d'entrée.

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

receive

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 être utilisée pour les 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 _Timeout a une valeur autre que la constante COOPERATIVE_TIMEOUT_INFINITE, 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 receive avec un délai d’attente de 0 (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.

run_with_cancellation_token

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 prendre en charge 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 cancellation_token::none() 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 sont déclenchés lors de l’annulation cancellation_token . Le jeton _Ct explicite l’isolera _Func de l’annulation parente si le parent a un jeton différent ou aucun jeton.

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

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

Notes

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

set_ambient_scheduler

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

Paramètres

_Planificateur
Planificateur ambiant à définir.

set_task_execution_resources

Limite les ressources d'exécution utilisées par les threads de travail interne du runtime d'accès concurrentiel à l'ensemble d'affinités spécifié.

Il est possible d'appeler cette méthode uniquement avant de créer le gestionnaire des ressources, ou entre deux durées de vie de gestionnaires des ressources. Cette méthode peut être appelée plusieurs fois tant que le gestionnaire des ressources 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 set_task_execution_resources.

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 mis à jour si besoin.

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.

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

_PGroupAffinity
Tableau d’entrées GROUP_AFFINITY .

Notes

La méthode lève une exception invalid_operation si un Resource Manager est présent au moment où il est appelé 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 la réévaluation de l’affinité par resource Manager. Par conséquent, toutes les modifications apportées à l’affinité de processus doivent être apportées avant d’appeler cette méthode.

swap

Échange les éléments de deux objets concurrent_vector.

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.

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

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

Notes

La fonction de modèle est un algorithme spécialisé dans la classe concurrent_vector de conteneur pour exécuter la fonction _Amembre. concurrent_vector ::swap( _B). 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, template <class T> void swap(T&, T&)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écurisée par 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

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

task_from_result

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 suivi 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é.

try_receive

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 false.

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 bool indiquant si une charge utile a été placée ou non dans _value.

Notes

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

wait

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 _Milliseconds paramètre est défini sur la valeur 0, le contexte actuel doit générer l’exécution vers d’autres contextes exécutables avant de continuer.

Notes

Si cette méthode est appelée sur un contexte de planificateur d’exécution concurrentiel, le planificateur trouve un autre contexte à 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 donnent pas de manière coopérative 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 task_options.

Valeur de retour

Tâche qui s’exécute correctement lorsque toutes les tâches d’entrée ont réussi. Si les tâches d’entrée sont de type T, le résultat de cette fonction sera task<std::vector<T>>. Si les tâches d’entrée sont de type void, la tâche de sortie sera également task<void>.

Notes

when_all est une fonction non bloquante qui produit un task 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 lève une exception, la tâche retournée se termine tôt, dans l’état annulé et l’exception, si elle se produit, est levée si vous appelez la tâche ::get ou task::wait sur cette tâche.

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

when_any

Crée une tâche qui s'effectue quand l'une des tâches fournies en tant qu'arguments s'effectue.

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
Jeton d'annulation contrôlant 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 T, la sortie de cette fonction est une task<std::pair<T, size_t>>>, 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 void, la sortie est une task<size_t>, où le résultat est l’index de fin de la tâche.

Notes

when_any est une fonction non bloquante qui produit un task 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).

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

Voir aussi

accès concurrentiel Namespace