concurrency (Funciones del espacio de nombres)

Artículo
06/16/2023

Alloc

Asigna un bloque de memoria del tamaño especificado del subasignador de almacenamiento en caché del runtime de simultaneidad.

void* __cdecl Alloc(size_t _NumBytes);

Parámetros

_NumBytes
El número de bytes de memoria a asignar.

Valor devuelto

Puntero a la memoria recién asignada.

Comentarios

Para obtener más información sobre los escenarios que en la aplicación podrían beneficiarse usando el subasignador de almacenamiento en caché, vea Programador de tareas.

asend

Una operación de envío asincrónica, que programa una tarea para propagar los datos al bloque de destino.

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

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

Parámetros

T
El tipo de datos que se van a enviar.

_Trg
Puntero o referencia al destino al que se envían los datos.

_Data
Referencia a los datos que se van a enviar.

Valor devuelto

true si el mensaje se ha aceptado antes de que se devuelva el método; de lo contrario, es false.

Comentarios

Para obtener más información, consulte Funciones de paso de mensajes.

cancel_current_task

Cancela la tarea que se está ejecutando actualmente. Se puede llamar a esta función desde el cuerpo de una tarea para anular la ejecución de la tarea y hacer que obtenga el estado canceled.

No está admitido que llame a esta función si no está dentro del cuerpo de un objeto task. Esto dará lugar a un comportamiento indefinido como, por ejemplo, un bloqueo o falta de respuesta en la aplicación.

inline __declspec(noreturn) void __cdecl cancel_current_task();

clear

Borra la cola simultánea y destruye los elementos que se encuentran en cola. Este método no es seguro para la simultaneidad.

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

Parámetros

_Ax

create_async

Crea una construcción asincrónica de Windows Runtime basada en un objeto o función lambda que se ha proporcionado. El tipo devuelto de create_async es IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^ o IAsyncOperationWithProgress<TResult, TProgress>^ en función de la signatura de la expresión lambda pasada al método.

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

Parámetros

_Function
Tipo.

_Func
Objeto de función o expresión lambda donde se crea una construcción asincrónica de Windows Runtime.

Valor devuelto

Una construcción asincrónica representada por un IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^ o un IAsyncOperationWithProgress<TResult, TProgress>^. La interfaz devuelta depende de la signatura de la expresión lambda pasada a la función.

Comentarios

El tipo devuelto de la expresión lambda determina si la construcción es una acción o una operación.

Las expresiones lambda que devuelven "void" provocan la creación de acciones. Las expresiones lambda que devuelven un resultado de tipo TResult provocan la creación de operaciones TResult.

La expresión lambda también puede devolver un task<TResult> que encapsule el trabajo asincrónico dentro de sí mismo o que sea la continuación de una cadena de tareas que representan el trabajo asincrónico. En este caso, la propia expresión lambda se ejecuta de forma alineada, ya que las tareas son las que se ejecutan de forma asincrónica y el tipo de valor devuelto de una expresión lambda se desempaqueta para generar la construcción asincrónica que devuelve create_async. Esto implica que una expresión lambda que devuelva una tarea<void> producirá la creación de acciones, y una expresión lambda que devuelva una tarea<TResult> producirá la creación de operaciones TResult.

La expresión lambda puede aceptar cero, uno o dos argumentos. Los argumentos válidos son progress_reporter<TProgress> y cancellation_token, en ese orden si se utilizan ambos. Una expresión lambda sin argumentos produce la creación de una construcción asincrónica sin la capacidad de informar del progreso. Una expresión lambda que toma un progress_reporter<TProgress> hará que create_async devuelva una construcción asincrónica que informe del progreso de tipo TProgress cada vez que se llame al método report del objeto progress_reporter. Una expresión lambda que toma un objeto cancellation_token puede utilizar dicho token para comprobar posibles cancelaciones o pasarlo a las tareas que crea para que la cancelación de la construcción asincrónica dé lugar a la cancelación de dichas tareas.

Si el cuerpo del objeto de función o expresión lambda devuelve un resultado (y no una tarea<TResult>), la expresión lamdba se ejecutará de forma asincrónica en el MTA de proceso en el contexto de una tarea que Runtime creará de forma implícita para ella. El método IAsyncInfo::Cancel producirá la cancelación de la tarea implícita.

Si el cuerpo de una expresión lambda devuelve una tarea, la expresión lamba se ejecutará de forma alineada y, al declarar la expresión lambda para que tome un argumento del tipo cancellation_token, podrá desencadenar la cancelación de cualquier tarea que cree en la expresión lambda pasando dicho token en la creación. Puede utilizar el método register_callback del token para hacer que el runtime invoque una devolución de llamada cuando llame a IAsyncInfo::Cancel en la acción u operación asincrónica producida.

Esta función solo está disponible para las aplicaciones de Windows Runtime.

CreateResourceManager

Devuelve una interfaz que representa la instancia singleton del Administrador de recursos del runtime de simultaneidad. El Administrador de recursos es el responsable de asignar recursos a los programadores que desean cooperar entre sí.

IResourceManager* __cdecl CreateResourceManager();

Valor devuelto

Interfaz IResourceManager.

Comentarios

Varias llamadas subsiguientes a este método devolverán la misma instancia del Administrador de recursos. Cada llamada al método incrementa un recuento de referencias en el Administrador de recursos, y debe corresponder con una llamada al método IResourceManager::Release cuando el programador haya terminado de comunicarse con el Administrador de recursos.

Se produce unsupported_os si el Runtime de simultaneidad no es compatible con el sistema operativo.

create_task

Crea un objeto tarea de PPL. create_task se puede usar en cualquier lugar en el que se ha utilizado un constructor de tarea. Se proporciona principalmente por comodidad, porque permite el uso de la palabra clave auto cuando se crean tareas.

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

Parámetros

T
Tipo del parámetro a partir del cual se va a construir la tarea.

_ReturnType
Tipo.

_Param
Parámetro desde el que se va a construir la tarea. Podría ser un objeto lambda o de función, un objeto task_completion_event, un objeto task distinto o una interfaz Windows::Foundation::IAsyncInfo si se usan tareas en la aplicación para UWP.

_TaskOptions
Las opciones de tarea.

_Task
Tarea que se va a crear.

Valor devuelto

Nueva tarea de tipo T, que se deduce de _Param.

Comentarios

La primera sobrecarga se comporta como un constructor de tareas que toma un único parámetro.

La segunda sobrecarga asocia el token de cancelación proporcionado con la tarea recién creada. Si usa esta sobrecarga, no se le permite pasar un objeto task diferente como primer parámetro.

El tipo de la tarea devuelta se deduce del primer parámetro a la función. Si _Param estask_completion_event<T>, task<T> o un functor que devuelve el tipo T o task<T>, el tipo de la tarea creada es task<T>.

En una aplicación para UWP, si _Param es de tipo Windows::Foundation::IAsyncOperation<T>^ o Windows::Foundation::IAsyncOperationWithProgress<T,P>^ o un functor que devuelve cualquiera de esos tipos, la tarea creada será de tipo task<T>. Si _Param es de tipo Windows::Foundation::IAsyncAction^ o Windows::Foundation::IAsyncActionWithProgress<P>^ o un functor que devuelve cualquiera de esos tipos, la tarea creada tendrá el tipo task<void>.

Deshabilitar seguimiento

Deshabilita la traza en el runtime de simultaneidad. Esta función está desusada porque la traza de ETW no está registrada de forma predeterminada.

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

Valor devuelto

Si el seguimiento se ha deshabilitado correctamente, se devuelve S_OK. Si el seguimiento no se inició anteriormente, se devuelve E_NOT_STARTED.

Habilitar seguimiento

Habilita la traza en el runtime de simultaneidad. Esta función está en desuso porque la traza de ETW ahora está registrada de forma predeterminada.

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

Valor devuelto

Si el seguimiento se inició correctamente, se devuelve S_OK; de lo contrario, se devuelve E_NOT_STARTED.

Gratuito

Libera un bloque de memoria asignado previamente mediante el método Alloc al subasignador de almacenamiento en caché del runtime de simultaneidad.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

Parámetros

_PAllocation
Puntero a la memoria previamente asignada por el método Alloc que se liberará. Si el parámetro _PAllocation está establecido en el valor NULL, esté método lo ignorará y volverá inmediatamente.

Comentarios

Para obtener más información sobre los escenarios que en la aplicación podrían beneficiarse usando el subasignador de almacenamiento en caché, vea Programador de tareas.

get_ambient_scheduler

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

Valor devuelto

GetExecutionContextId

Devuelve un identificador único que se puede asignar a un contexto de ejecución que implementa la interfaz IExecutionContext.

unsigned int __cdecl GetExecutionContextId();

Valor devuelto

Identificador único de un contexto de ejecución.

Comentarios

Use este método para obtener un identificador para el contexto de ejecución antes de pasar una interfaz de IExecutionContext como parámetro a cualquiera de los métodos que ofrece el Resource Manager.

GetOSVersion

Devuelve la versión del sistema operativo.

IResourceManager::OSVersion __cdecl GetOSVersion();

Valor devuelto

Valor enumerado que representa el sistema operativo.

Comentarios

Se produce unsupported_os si el Runtime de simultaneidad no es compatible con el sistema operativo.

GetProcessorCount

Devuelve el número de subprocesos de hardware en el sistema subyacente.

unsigned int __cdecl GetProcessorCount();

Valor devuelto

El número de subprocesos de hardware.

Comentarios

Se produce unsupported_os si el Runtime de simultaneidad no es compatible con el sistema operativo.

GetProcessorNodeCount

Devuelve el número de nodos NUMA o paquetes de procesador en el sistema subyacente.

unsigned int __cdecl GetProcessorNodeCount();

Valor devuelto

El número de nodos NUMA o paquetes de procesador.

Comentarios

Si el sistema contiene más nodos NUMA que paquetes de procesador, se devuelve el número de nodos NUMA; de lo contrario, se devuelve el número de paquetes de procesador.

Se produce unsupported_os si el Runtime de simultaneidad no es compatible con el sistema operativo.

GetSchedulerId

Devuelve un identificador único que se puede asignar a un programador que implementa la interfaz IScheduler.

unsigned int __cdecl GetSchedulerId();

Valor devuelto

Identificador único para el programador.

Comentarios

Use este método para obtener un identificador para el programador antes de pasar una interfaz de IScheduler como parámetro a cualquiera de los métodos que ofrece el 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);

Parámetros

_Ax

first

last

interruption_point

Crea un punto de interrupción para la cancelación. Si una cancelación está en curso en el contexto donde se llama a esta función, se producirá una excepción interna que anula la ejecución del trabajo paralelo que se está ejecutando actualmente. Si la cancelación no está en curso, la función no hace nada.

inline void interruption_point();

Comentarios

No debe detectar la excepción de cancelación interna que produce la función interruption_point(). El entorno de ejecución detectará y controlará la excepción, lo que puede provocar que el programa se comporte de forma anómala.

is_current_task_group_canceling

Devuelve una indicación de si el grupo de tareas que actualmente se está ejecutando alineado en el contexto actual se encuentra en medio de una cancelación activa (o lo estará pronto). Tenga en cuenta que si no hay ningún grupo de tareas que se ejecuta actualmente alineado en el contexto actual, se devolverá false.

bool __cdecl is_current_task_group_canceling();

Valor devuelto

true si el grupo de tareas que se ejecuta actualmente se cancela, false en caso contrario.

Comentarios

Para obtener más información, consulte Cancelación.

make_choice

Construye un bloque de mensajería choice de un Scheduler opcional o ScheduleGroup y dos o más orígenes de entrada.

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

Parámetros

T1
El tipo de bloque de mensaje del primer origen.

T2
El tipo de bloque de mensaje del segundo origen.

_PScheduler
El objeto Scheduler dentro del que se programa la tarea de propagación para el bloque de mensajería choice .

_Item1
El primer origen.

_Item2
El segundo origen.

_Items
Orígenes adicionales.

_PScheduleGroup
El objeto ScheduleGroup dentro del que se programa la tarea de propagación para el bloque de mensajería choice . El objeto Scheduler utilizado está implícito en el grupo de programación.

Valor devuelto

Bloque de mensajes choice con dos o más orígenes de entrada.

make_greedy_join

Construye un bloque de mensajería greedy multitype_join de un Scheduler opcional o ScheduleGroup y dos o más orígenes de entrada.

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

Parámetros

T1
El tipo de bloque de mensaje del primer origen.

T2
El tipo de bloque de mensaje del segundo origen.

_PScheduler
El objeto Scheduler dentro del que se programa la tarea de propagación para el bloque de mensajería multitype_join .

_Item1
El primer origen.

_Item2
El segundo origen.

_Items
Orígenes adicionales.

_PScheduleGroup
El objeto ScheduleGroup dentro del que se programa la tarea de propagación para el bloque de mensajería multitype_join . El objeto Scheduler utilizado está implícito en el grupo de programación.

Valor devuelto

Bloque de mensajes greedy multitype_join con dos o más orígenes de entrada.

make_join

Construye un bloque de mensajería non_greedy multitype_join de un Scheduler opcional o ScheduleGroup y dos o más orígenes de entrada.

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

Parámetros

T1
El tipo de bloque de mensaje del primer origen.

T2
El tipo de bloque de mensaje del segundo origen.

_PScheduler
El objeto Scheduler dentro del que se programa la tarea de propagación para el bloque de mensajería multitype_join .

_Item1
El primer origen.

_Item2
El segundo origen.

_Items
Orígenes adicionales.

Valor devuelto

Bloque de mensajes non_greedy multitype_join con dos o más orígenes de entrada.

make_task

Un método generador para crear un objeto task_handle.

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

Parámetros

_Function
Tipo del objeto de función que se invocará para ejecutar el trabajo representado por el objeto task_handle.

_Func
Tipo del objeto de función que se invocará para ejecutar el trabajo representado por el objeto task_handle. Esto puede ser un functor lambda, un puntero a una función o cualquier objeto que admita una versión del operador de llamada de función con la signatura void operator()().

Valor devuelto

Un objeto task_handle.

Comentarios

Esta función es útil cuando necesita crear un objeto task_handle con una expresión lambda, ya que permite crear el objeto sin conocer el tipo verdadero del functor lambda.

parallel_buffered_sort

Organiza los elementos en un intervalo especificado en un orden no descendente, o de acuerdo con un criterio de ordenación especificado por un predicado binario, en paralelo. Esta función es semánticamente similar a std::sort que se trata de una ordenación basada en comparación, inestable, en contexto salvo que necesita espacio adicional O(n) y requiere una inicialización predeterminada para los elementos que se ordenan.

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

Parámetros

_Random_iterator
Tipo de iterador del rango de entrada.

_Allocator
Tipo de asignador de memoria compatible con la biblioteca estándar de C++.

_Function
Tipo del comparador binario.

_Begin
Iterador de acceso aleatorio que dirige a la posición del primer elemento del intervalo que se va a ordenar.

_End
Iterador de acceso aleatorio que dirige a la posición situada una posición después del último elemento del intervalo que se va a ordenar.

_Alloc
Instancia de asignador de memoria compatible con la biblioteca estándar de C++.

_Func
Objeto de función de predicado definido por el usuario que define el criterio de comparación que deben cumplir los elementos sucesivos de la ordenación. Un predicado binario toma dos argumentos y devuelve true si se cumplen y false si no. Esta función de comparador debe imponer una ordenación débil estricta en los pares de elementos de la secuencia.

_Chunk_size
Tamaño mínimo de un fragmento que se dividirá en dos para la ejecución en paralelo.

Comentarios

Todas las sobrecargas requieren n * sizeof(T) espacio adicional, donde n es el número de elementos que se van a ordenar y T es el tipo de elemento. En la mayoría de los casos, parallel_buffered_sort mostrará una mejora en el rendimiento con respecto a parallel_sort y debe usarlo en parallel_sort si tiene la memoria disponible.

Si no proporciona un comparador binario, std::less se usa como valor predeterminado, lo que requiere que el tipo de elemento proporcione el operador operator<().

Si no proporciona un tipo de asignador o una instancia, el asignador std::allocator<T> de memoria de la biblioteca estándar de C++ se usa para asignar el búfer.

El algoritmo divide el intervalo de entrada en dos fragmentos y divide sucesivamente cada fragmento en dos subárboles para su ejecución en paralelo. El argumento opcional _Chunk_size se puede usar para indicar al algoritmo que debe controlar fragmentos de tamaño <_Chunk_size en serie.

parallel_for

parallel_for itera sobre un intervalo de índices y ejecuta una función proporcionada por el usuario en cada iteración, en paralelo.

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

Parámetros

_Index_type
Tipo del índice que se usa para la iteración.

_Function
Tipo de la función que se ejecutará en cada iteración.

_Partitioner
Tipo del particionador que se usa para particionar el intervalo proporcionado.

first
Primer índice que se va a incluir en la iteración.

last
Índice pasado el último índice que se va a incluir en la iteración.

_Step
Valor por el que se va a recorrer paso a paso al iterar de first a last. El paso debe ser positivo. invalid_argument se produce si el paso es menor que 1.

_Func
Función que se va a ejecutar en cada iteración. Esto puede ser una expresión lambda, un puntero a una función o cualquier objeto que admita una versión del operador de llamada de función con la signatura void operator()(_Index_type).

_Part
Referencia al objeto particionador. El argumento puede ser uno de constauto_partitioner&, conststatic_partitioner&, constsimple_partitioner& o affinity_partitioner& Si se usa un objeto affinity_partitioner, la referencia debe ser una referencia l-value no const para que el algoritmo pueda almacenar el estado de los bucles futuros para volver a usar.

Comentarios

Para obtener más información, consulte Algoritmos paralelos.

parallel_for_each

parallel_for_each aplica una función especificada para cada elemento dentro de un intervalo, en paralelo. Es semánticamente equivalente a la función for_each en el espacio de nombres std, salvo que la iteración sobre los elementos se realiza en paralelo, y el orden de iteración no está especificado. El argumento _Func debe admitir un operador de llamada de función del formulario operator()(T) donde el parámetro T es el tipo de elemento del contenedor que se recorre en iteración.

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

Parámetros

_Iterator
Tipo del iterador que se usa para iterar sobre el contenedor.

_Function
Tipo de la función que se aplicará a cada elemento dentro del rango.

_Partitioner
first
Iterador que dirige la posición del primer elemento que se va a incluir en la iteración paralela.

last
Iterador que dirige la posición, una después del elemento final que se va a incluir en iteración paralela.

_Func
Objeto de función definido por el usuario que se aplica a cada elemento del intervalo.

Comentarios

auto_partitioner se usará para la sobrecarga sin un particionador explícito.

En el caso de los iteradores que no admiten el acceso aleatorio, solo se admite auto_partitioner.

Para obtener más información, consulte Algoritmos paralelos.

parallel_invoke

Ejecuta los objetos de función proporcionados como parámetros en paralelo y se bloquea hasta que han terminado de ejecutarse. Cada objeto de función puede ser una expresión lambda, un puntero a una función o cualquier otro objeto que admite el operador de llamada de función con la signatura 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);

Parámetros

_Function1
Tipo del primer objeto de función que se va a ejecutar en paralelo.

_Function2
Tipo del segundo objeto de función que se va a ejecutar en paralelo.

_Function3
Tipo del tercer objeto de función que se va a ejecutar en paralelo.

_Function4
Tipo del cuarto objeto de función que se va a ejecutar en paralelo.

_Function5
Tipo del quinto objeto de función que se va a ejecutar en paralelo.

_Function6
Tipo del sexto objeto de función que se va a ejecutar en paralelo.

_Function7
Tipo del séptimo objeto de función que se va a ejecutar en paralelo.

_Function8
Tipo del octavo objeto de función que se va a ejecutar en paralelo.

_Function9
Tipo del noveno objeto de función que se va a ejecutar en paralelo.

_Function10
Tipo del décimo objeto de función que se va a ejecutar en paralelo.

_Func1
Primer objeto de función que se va a ejecutar en paralelo.

_Func2
Segundo objeto de función que se va a ejecutar en paralelo.

_Func3
Tercer objeto de función que se va a ejecutar en paralelo.

_Func4
Cuarto objeto de función que se va a ejecutar en paralelo.

_Func5
Quinto objeto de función que se va a ejecutar en paralelo.

_Func6
Sexto objeto de función que se va a ejecutar en paralelo.

_Func7
Séptimo objeto de función que se va a ejecutar en paralelo.

_Func8
Octavo objeto de función que se va a ejecutar en paralelo.

_Func9
Noveno objeto de función que se va a ejecutar en paralelo.

_Func10
Décimo objeto de función que se va a ejecutar en paralelo.

Comentarios

Tenga en cuenta que uno o varios objetos de función proporcionados como parámetros pueden ejecutarse insertados en el contexto de llamada.

Si uno o varios objetos de función pasados como parámetros a esta función inician una excepción, el entorno de ejecución seleccionará una de estas excepciones de su elección y la propagará fuera de la llamada a parallel_invoke.

Para obtener más información, consulte Algoritmos paralelos.

parallel_radixsort

Organiza los elementos en un intervalo especificado en un orden no descendente utilizando un algoritmo de ordenación de base. Esta es una función estable de ordenación que requiere una función de proyección que pueda proyectar elementos que se puedan ordenar en claves como enteros sin signo. Se requiere una inicialización predeterminada para que se ordenen los elementos.

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

Parámetros

_Random_iterator
Tipo de iterador del rango de entrada.

_Allocator
Tipo de asignador de memoria compatible con la biblioteca estándar de C++.

_Function
Tipo de la función de proyección.

_Begin
Iterador de acceso aleatorio que dirige a la posición del primer elemento del intervalo que se va a ordenar.

_End
Iterador de acceso aleatorio que dirige a la posición situada una posición después del último elemento del intervalo que se va a ordenar.

_Alloc
Instancia de asignador de memoria compatible con la biblioteca estándar de C++.

_Proj_func
Objeto de función de proyección definido por el usuario que convierte un elemento en un valor entero.

_Chunk_size
Tamaño mínimo de un fragmento que se dividirá en dos para la ejecución en paralelo.

Comentarios

Todas las sobrecargas requieren n * sizeof(T) espacio adicional, donde n es el número de elementos que se van a ordenar y T es el tipo de elemento. Se requiere un functor de proyección unario con la firma I _Proj_func(T) para devolver una clave cuando se proporciona un elemento, donde T es el tipo de elemento y I es un tipo entero sin signo.

Si no proporciona una función de proyección, se usa una función de proyección predeterminada que simplemente devuelve el elemento de los tipos enteros. La función no se compilará si el elemento no es un tipo entero en ausencia de una función de proyección.

Si no proporciona un tipo de asignador o una instancia, el asignador std::allocator<T> de memoria de la biblioteca estándar de C++ se usa para asignar el búfer.

parallel_reduce

Calcula la suma de todos los elementos en un intervalo especificado mediante el cálculo de sumas parciales sucesivas, o calcula el resultado de los resultados parciales sucesivos obtenidos de manera similar mediante el uso de una operación binaria determinada distinta de la suma, en paralelo. parallel_reduce es semánticamente similar a std::accumulate, salvo que requiere que la operación binaria sea asociativa, y requiere un valor de identidad en lugar de un valor inicial.

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

Parámetros

_Forward_iterator
Tipo de iterador del rango de entrada.

_Sym_reduce_fun
Tipo de la función de reducción simétrica. Debe ser un tipo de función con la firma _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type), donde _Reduce_type es el mismo que el tipo de identidad y el tipo de resultado de la reducción. Para la tercera sobrecarga, debe ser coherente con el tipo de salida de _Range_reduce_fun.

_Reduce_type
Tipo al que se reducirá la entrada, que puede ser diferente del tipo de elemento de entrada. El valor devuelto y el valor de identidad tendrán este tipo.

_Range_reduce_fun
Tipo de la función de reducción de intervalo. Debe ser un tipo de función con la firma _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type), _Reduce_type es el mismo que el tipo de identidad y el tipo de resultado de la reducción.

_Begin
Iterador de entrada que dirige al primer elemento del intervalo que se va a reducir.

_End
Iterador de entrada que dirige el elemento que esta una posición más allá del último elemento del intervalo que se va a reducir.

_Identity
El valor de identidad _Identity es del mismo tipo que el tipo de resultado de la reducción y también del elemento value_type del iterador para la primera y segunda sobrecarga. Para la tercera sobrecarga, el valor de identidad debe tener el mismo tipo que el tipo de resultado de la reducción, pero puede ser diferente del elemento value_type del iterador. Debe tener un valor adecuado para que el operador de reducción de intervalos _Range_fun, cuando se aplique a un intervalo de un solo elemento de tipo value_type y el valor de identidad, se comporte como una conversión de tipo del valor desde el tipo value_type al tipo de identidad.

_Sym_fun
Función simétrica que se usará en la segunda de la reducción. Consulte la sección Comentarios para más información.

_Range_fun
Función que se usará en la primera fase de la reducción. Consulte la sección Comentarios para más información.

Valor devuelto

Resultado de la reducción.

Comentarios

Para hacer una reducción paralela, la función divide el intervalo en fragmentos en función del número de trabajos disponibles para el programador subyacente. La reducción tiene lugar en dos fases, la primera fase hace una reducción en cada fragmento y la segunda fase hace una reducción entre los resultados parciales de cada fragmento.

La primera sobrecarga requiere que value_type del iterador, T, sea el mismo que el tipo de valor de identidad, así como el tipo de resultado de reducción. El tipo de elemento T debe proporcionar al operador T T::operator + (T) para reducir los elementos de cada fragmento. El mismo operador también se usa en la segunda fase.

La segunda sobrecarga también requiere que el elemento value_type del iterador sea el mismo que el tipo de valor de identidad, así como el tipo de resultado de reducción. El operador binario proporcionado _Sym_fun se usa en ambas fases de reducción, con el valor de identidad como valor inicial de la primera fase.

Para la tercera sobrecarga, el tipo de valor de identidad debe ser el mismo que el tipo de resultado de reducción, pero el elemento value_type del iterador puede ser diferente de ambos. La función de reducción de intervalo _Range_fun se usa en la primera fase con el valor de identidad como valor inicial y la función binaria _Sym_reduce_fun se aplica a los subresultados en la segunda fase.

parallel_sort

Organiza los elementos en un intervalo especificado en un orden no descendente, o de acuerdo con un criterio de ordenación especificado por un predicado binario, en paralelo. Esta función es semánticamente similar a std::sort que se trata una ordenación basada en comparación, inestable, en contexto.

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

Parámetros

_Random_iterator
Tipo de iterador del rango de entrada.

_Function
Tipo del functor de comparación binario.

_Begin
Iterador de acceso aleatorio que dirige a la posición del primer elemento del intervalo que se va a ordenar.

_End
Iterador de acceso aleatorio que dirige a la posición situada una posición después del último elemento del intervalo que se va a ordenar.

_Chunk_size
Tamaño mínimo de un fragmento que se dividirá en dos para la ejecución en paralelo.

Comentarios

La primera sobrecarga usa el comparador binario std::less.

La segunda sobrecarga usa el comparador binario proporcionado que debe tener la firma bool _Func(T, T) donde T es el tipo de los elementos del intervalo de entrada.

parallel_transform

Aplica un objeto especificado de función a cada elemento de un intervalo de origen, o a un par de elementos de dos intervalos de origen, y copia los valores devueltos del objeto de función en un intervalo de destino, en paralelo. Esta función es semánticamente equivalente a 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);

Parámetros

_Input_iterator1
Tipo del primer o único iterador de entrada.

_Output_iterator
Tipo del iterador de salida.

_Unary_operator
Tipo del functor unario que se va a ejecutar en cada elemento del intervalo de entrada.

_Input_iterator2
Tipo del segundo iterador de entrada.

_Binary_operator
Tipo del functor binario ejecutado en pares en los elementos de los dos intervalos de origen.

_Partitioner
first1
Iterador de entrada que dirige a la posición del primer elemento del primer o único intervalo de origen en el que se va a operar.

last1
Iterador de entrada que dirige a la posición una posición después del último elemento del primer o único intervalo de origen en el que se va a operar.

_Result
Iterador de salida que direcciona la posición del primer elemento del intervalo de destino.

_Unary_op
Objeto de función unaria definido por el usuario que se aplica a cada elemento del intervalo de origen.

first2
Iterador de entrada que dirige a la posición del primer elemento del segundo intervalo de origen en el que se va a operar.

_Binary_op
Objeto de función binaria definido por el usuario que se aplica en pares, en un orden hacía delante, a los dos intervalos de origen.

Valor devuelto

Iterador de salida que dirige a la posición situada una posición después del último elemento del intervalo de destino que va a recibir los elementos de salida transformados por el objeto de función.

Comentarios

auto_partitioner se usará para las sobrecargas sin un argumento de particionador explícito.

En el caso de los iteradores que no admiten el acceso aleatorio, solo se admite auto_partitioner.

Las sobrecargas que toman el argumento _Unary_op transforman el intervalo de entrada en el intervalo de salida al aplicar el functor unario a cada elemento del intervalo de entrada. _Unary_op debe admitir el operador de llamada de función con la firma operator()(T) donde T es el tipo de valor del intervalo en iteración.

Las sobrecargas que toman el argumento _Binary_op transforman dos intervalos de entrada en el intervalo de salida al aplicar el functor binario a un elemento del primer intervalo de entrada y un elemento del segundo intervalo de entrada. _Binary_op debe admitir el operador de llamada de función con la firma operator()(T, U) donde T, U son tipos de valor de los dos iteradores de entrada.

Para obtener más información, consulte Algoritmos paralelos.

receive

Una implementación receive general, que permite a un contexto esperar datos exactamente de un origen y filtrar los valores que se aceptan.

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

Parámetros

T
Tipo de carga útil.

_Src
Puntero o referencia al origen desde el que se esperan los datos.

_Timeout
Tiempo máximo para el que el método debería para los datos, en milisegundos.

_Filter_proc
Función de filtro que determina si se deben aceptar mensajes.

Valor devuelto

Valor del origen del tipo de carga útil.

Comentarios

Si el parámetro _Timeout tiene un valor distinto de la constante COOPERATIVE_TIMEOUT_INFINITE, se produce la excepción operation_timed_out si la cantidad de tiempo especificada expira antes de recibir un mensaje. Si quiere un tiempo de espera de longitud cero, debe usar la función try_receive, en lugar de llamar a receive con un tiempo de espera de 0 (cero), ya que es más eficaz y no produce excepciones en tiempos de espera.

Para obtener más información, consulte Funciones de paso de mensajes.

run_with_cancellation_token

Ejecuta un objeto de función de forma inmediata y sincrónicamente en el contexto de un token de cancelación dado.

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

Parámetros

_Function
Tipo del objeto de función que se invocará.

_Func
Objeto de función que se ejecutará. Este objeto debe admitir el operador de llamada de función con una firma de void (void).

_Ct
Token de cancelación que controlará la cancelación implícita del objeto de función. Use cancellation_token::none() si quiere que la función se ejecute sin posibilidad de cancelación implícita desde un grupo de tareas primario que se va a cancelar.

Comentarios

Los puntos de interrupción del objeto de función se desencadenarán cuando se cancele cancellation_token. El token explícito _Ct aislará este elemento _Func de la cancelación primaria si el elemento primario tiene un token diferente o ningún token.

Enviar

Una operación de envío sincrónica, que espera hasta que el destino acepte o rechace el mensaje.

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

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

Parámetros

T
Tipo de carga útil.

_Trg
Puntero o referencia al destino al que se envían los datos.

_Data
Referencia a los datos que se van a enviar.

Valor devuelto

true si se aceptó el mensaje, de lo contrario, false.

Comentarios

Para obtener más información, consulte Funciones de paso de mensajes.

set_ambient_scheduler

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

Parámetros

_Scheduler
Programador de ambiente que se va a establecer.

set_task_execution_resources

Limita los recursos de ejecución que usan los subprocesos de trabajo internos del runtime de simultaneidad para el conjunto de afinidad especificado.

Se puede llamar a este método solamente antes de que el Administrador de recursos se haya creado o entre dos duraciones del Administrador de recursos. Se puede invocar varias veces siempre que el Administrador de recursos no exista en el momento de la invocación. Después de que se haya establecido un límite de afinidad, permanece en vigor hasta la siguiente llamada válida al método set_task_execution_resources.

La máscara de afinidad proporcionada no necesita ser un subconjunto de la máscara de afinidad en proceso. La afinidad en proceso se actualizará en caso necesario.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

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

Parámetros

_ProcessAffinityMask
Máscara de afinidad a la que se restringirán los subprocesos de trabajo del Runtime de simultaneidad. Use este método en un sistema con más de 64 subprocesos de hardware solo si quiere limitar el Runtime de simultaneidad a un subconjunto del grupo de procesadores actual. En general, debe usar la versión del método que acepta una matriz de afinidades de grupo como parámetro para restringir la afinidad en las máquinas con más de 64 subprocesos de hardware.

count
Número de entradas GROUP_AFFINITY de la matriz especificada por el parámetro _PGroupAffinity.

_PGroupAffinity
Matriz de entradas GROUP_AFFINITY.

Comentarios

El método producirá una excepción de invalid_operation si hay un administrador de recursos presente en el momento en que se invoca y una excepción de invalid_argument si la afinidad especificada da como resultado un conjunto vacío de recursos.

La versión del método que toma una matriz de afinidades de grupo como parámetro solo debe usarse en sistemas operativos con la versión Windows 7 o superior. De lo contrario, se produce una excepción de invalid_operation.

La modificación mediante programación de la afinidad de proceso después de invocar este método no hará que el administrador de recursos vuelva a evaluar la afinidad a la que está restringida. Por lo tanto, se deben hacer todos los cambios en la afinidad de proceso antes de llamar a este método.

swap

Intercambia los elementos de dos objetos concurrent_vector.

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

Parámetros

T
El tipo de datos de los elementos almacenados en los vectores simultáneos.

_Ax
Tipo de asignador de los vectores simultáneos.

_A
Vector simultáneo cuyos elementos se van a intercambiar con los del vector simultáneo _B.

_B
El vector simultáneo que proporciona los elementos que se van a intercambiar o el vector cuyos elementos se van a intercambiar con los del vector simultáneo _A.

Comentarios

La función de plantilla es un algoritmo especializado en la clase de contenedor concurrent_vector para ejecutar la función miembro _A. concurrent_vector::swap( _B). Se trata de instancias de la ordenación parcial de plantillas de función por el compilador. Cuando las funciones de plantilla se sobrecargan de manera que la coincidencia de la plantilla con la llamada de la función no es única, el compilador selecciona la versión más especializada de la función de plantilla. La versión general de la función de plantilla,template <class T> void swap(T&, T&), en la clase de algoritmo funciona mediante asignación y es una operación lenta. La versión especializada de cada contenedor es mucho más rápida, dado que puede funcionar con la representación interna de la clase contenedora.

Este método no es seguro para la simultaneidad. Debe asegurarse de que ningún otro subproceso realice operaciones en ninguno de los vectores simultáneos al llamar a este método.

task_from_exception

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

Parámetros

_TaskType

_ExType

_Exception

_TaskOptions

Valor devuelto

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

Parámetros

_Param

_TaskOptions

Valor devuelto

Trace_agents_register_name

Asocia el nombre dado al bloque o agente de mensajes en el seguimiento ETW.

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

Parámetros

T
Tipo del objeto. Normalmente, se trata de un bloque de mensajes o un agente.

_PObject
Puntero que apunta al bloque de mensajes o al agente al que se le asigna un nombre en el seguimiento.

_Name
Nombre del objeto determinado.

try_receive

Una implementación try-receive general, que permite a un contexto buscar datos exactamente de un origen y filtrar los valores que se aceptan. Si los datos no están listos, este método devolverá 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);

Parámetros

T
Tipo de carga útil

_Src
Puntero o referencia al origen desde el que se esperan los datos.

_value
Referencia a una ubicación donde se colocará el resultado.

_Filter_proc
Función de filtro que determina si se deben aceptar mensajes.

Valor devuelto

Valor bool que indica si se ha colocado o no una carga útil en _value.

Comentarios

Para obtener más información, consulte Funciones de paso de mensajes.

wait

Hace una pausa en el contexto actual para un periodo de tiempo indicado.

void __cdecl wait(unsigned int _Milliseconds);

Parámetros

_Milliseconds
El número de milisegundos para el que se debe pausar el contexto actual. Si el parámetro _Milliseconds se establece en el valor 0, el contexto actual debe suspender la ejecución en otros contextos ejecutables antes de continuar.

Comentarios

Si se llama a este método en un contexto del programador del Runtime de simultaneidad, el programador encontrará otro contexto para ejecutarse en el recurso subyacente. Dado que el programador es cooperativo por naturaleza, este contexto no se puede reanudar exactamente después del número de milisegundos especificado. Si el programador está ocupado ejecutando otras tareas que no producen cooperativamente al programador, el período de espera podría ser indefinido.

when_all

Crea una tarea que se completará correctamente cuando todas las tareas proporcionadas como argumentos se completen correctamente.

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

Parámetros

_Iterator
El tipo de iterador de entrada.

_Begin
Posición del primer elemento del intervalo de elementos que se va a combinar en la tarea resultante.

_End
Posición del primer elemento que supera el intervalo de elementos que se va a combinar en la tarea resultante.

_TaskOptions
Objeto task_options.

Valor devuelto

Tarea que se completa correctamente cuando todas las tareas de entrada se completan correctamente. Si las tareas de entrada son de tipo T, el resultado de esta función será task<std::vector<T>>. Si las tareas de entrada son del tipo void, la tarea de salida también será task<void>.

Comentarios

when_all es una función sin bloqueo que genera task como resultado. A diferencia de task::wait, resulta seguro llamar a esta función en una aplicación para UWP en el subproceso ASTA (STA de aplicación).

Si una de las tareas se cancela o inicia una excepción, la tarea devuelta finalizará prematuramente con el estado cancelado y la excepción, si se produce una, se iniciará al llamar a task::get o task::wait en dicha tarea.

Para obtener más información, consulte Paralelismo de tareas.

when_any

Crea una tarea que se completará correctamente cuando cualquiera de las tareas proporcionadas como argumentos se complete correctamente.

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

Parámetros

_Iterator
El tipo de iterador de entrada.

_Begin
Posición del primer elemento del intervalo de elementos que se va a combinar en la tarea resultante.

_End
Posición del primer elemento que supera el intervalo de elementos que se va a combinar en la tarea resultante.

_TaskOptions
_CancellationToken
Token de cancelación que controla la cancelación de la tarea devuelta. Si no proporciona un token de cancelación, la tarea resultante recibe el token de cancelación de la tarea que hace que se complete.

Valor devuelto

Tarea que se completa correctamente cuando cualquiera de las tareas de entrada se completa correctamente. Si las tareas de entrada son del tipo T, el resultado de esta función será un task<std::pair<T, size_t>>>, donde el primer elemento del par es el resultado de la tarea que se está completando y el segundo elemento es el índice de la tarea que ha finalizado. Si las tareas de entrada son del tipo void, el resultado es un task<size_t>, donde el resultado es el índice de la tarea que se está completando.

Comentarios

when_any es una función sin bloqueo que genera task como resultado. A diferencia de task::wait, resulta seguro llamar a esta función en una aplicación para UWP en el subproceso ASTA (STA de aplicación).

Para obtener más información, consulte Paralelismo de tareas.

Consulte también

concurrency (espacio de nombres)