Funções do namespace de simultaneidadeconcurrency namespace functions

AlocaçãoAlloc

Aloca um bloco de memória do tamanho especificado no subalocador de cache Tempo de Execução de Simultaneidade.Allocates a block of memory of the size specified from the Concurrency Runtime Caching Suballocator.

void* __cdecl Alloc(size_t _NumBytes);

parâmetrosParameters

_NumBytes_NumBytes
O número de bytes de memória a serem alocados.The number of bytes of memory to allocate.

Valor RetornadoReturn Value

Um ponteiro para a memória alocada recentemente.A pointer to newly allocated memory.

ComentáriosRemarks

Para obter mais informações sobre quais cenários em seu aplicativo podem se beneficiar do uso do subalocador de cache, consulte Agendador de tarefas.For more information about which scenarios in your application could benefit from using the Caching Suballocator, see Task Scheduler.

asendasend

Uma operação Send assíncrona, que agenda uma tarefa para propagar os dados para o bloco de destino.An asynchronous send operation, which schedules a task to propagate the data to the target block.

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

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

parâmetrosParameters

TT
O tipo dos dados a serem enviados.The type of the data to be sent.

_Trg_Trg
Um ponteiro ou referência ao destino para o qual os dados são enviados.A pointer or reference to the target to which data is sent.

_Data_Data
Uma referência aos dados a serem enviados.A reference to the data to be sent.

Valor RetornadoReturn Value

true se a mensagem foi aceita antes do retorno do método, false caso contrário.true if the message was accepted before the method returned, false otherwise.

ComentáriosRemarks

Para obter mais informações, consulte funções de passagem de mensagens.For more information, see Message Passing Functions.

cancel_current_taskcancel_current_task

Cancela a tarefa atualmente em execução.Cancels the currently executing task. Essa função pode ser chamada de dentro do corpo de uma tarefa para interromper a execução da tarefa e fazer com que ela entre no estado canceled.This function can be called from within the body of a task to abort the task's execution and cause it to enter the canceled state.

Não é um cenário com suporte para chamar essa função se você não estiver dentro do corpo de uma task.It is not a supported scenario to call this function if you are not within the body of a task. Isso resultará em um comportamento indefinido, como uma falha ou uma falta de resposta em seu aplicativo.Doing so will result in undefined behavior such as a crash or unresponsiveness in your application.

inline __declspec(noreturn) void __cdecl cancel_current_task();

formataçãoclear

Limpa a fila simultânea, destruindo todos os elementos atualmente enfileirados.Clears the concurrent queue, destroying any currently enqueued elements. Esse método não é seguro para simultaneidade.This method is not concurrency-safe.

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

parâmetrosParameters

TT

_Ax_Ax

create_asynccreate_async

Cria uma construção assíncrona de Windows Runtime com base em um objeto de função ou lambda fornecido pelo usuário.Creates a Windows Runtime asynchronous construct based on a user supplied lambda or function object. O tipo de retorno de create_async é IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^ ou IAsyncOperationWithProgress<TResult, TProgress>^ com base na assinatura do lambda passada para o método.The return type of create_async is one of either IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^, or IAsyncOperationWithProgress<TResult, TProgress>^ based on the signature of the lambda passed to the method.

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

parâmetrosParameters

_Function_Function
Digite.Type.

_Func_Func
O objeto de lambda ou função a partir do qual criar uma construção assíncrona de Windows Runtime.The lambda or function object from which to create a Windows Runtime asynchronous construct.

Valor RetornadoReturn Value

Uma construção assíncrona representada por um IAsyncAction ^, IAsyncActionWithProgress <TProgress> ^, IAsyncOperation <TResult> ^ ou IAsyncOperationWithProgress <TResult, TProgress> ^.An asynchronous construct represented by an IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^, or an IAsyncOperationWithProgress<TResult, TProgress>^. A interface retornada depende de assinatura do lambda passada na função.The interface returned depends on the signature of the lambda passed into the function.

ComentáriosRemarks

O tipo de retorno do lambda determina se a construção é uma ação ou uma operação.The return type of the lambda determines whether the construct is an action or an operation.

Lambdas que retornam void causam a criação de ações.Lambdas that return void cause the creation of actions. Lambdas que retornam um resultado do tipo TResult causam a criação de operações de TResult.Lambdas that return a result of type TResult cause the creation of operations of TResult.

Lambda também pode retornar um task<TResult> que encapsula o trabalho assíncrono em si mesmo ou é a continuação de uma cadeia de tarefas que representam o trabalho assíncrono.The lambda may also return a task<TResult> which encapsulates the aysnchronous work within itself or is the continuation of a chain of tasks that represent the asynchronous work. Nesse caso, o próprio lambda é executado em linha, uma vez que as tarefas são aqueles que são executadas de forma assíncrona e o tipo de retorno do lambda é desencapsulado para produzir a construção assíncrona retornada por create_async.In this case, the lambda itself is executed inline, since the tasks are the ones that execute asynchronously, and the return type of the lambda is unwrapped to produce the asynchronous construct returned by create_async. Isso implica que um lambda que retorna uma tarefa causará <void> a criação de ações, e um lambda que retorna uma tarefa causará <TResult> a criação de operações de TResult.This implies that a lambda that returns a task<void> will cause the creation of actions, and a lambda that returns a task<TResult> will cause the creation of operations of TResult.

O lambda pode usar zero, um ou dois argumentos.The lambda may take either zero, one or two arguments. Os argumentos válidos são progress_reporter<TProgress> e cancellation_token, nessa ordem se ambos forem usados.The valid arguments are progress_reporter<TProgress> and cancellation_token, in that order if both are used. Um lambda sem argumentos causará a criação de uma construção assíncrona sem o recurso de relatório de andamento.A lambda without arguments causes the creation of an asynchronous construct without the capability for progress reporting. Um lambda que usa um progress_reporter <TProgress> fará com que create_async o retorne um constructo assíncrono que relate o progresso do tipo TProgress cada vez que o report método do objeto progress_reporter for chamado.A lambda that takes a progress_reporter<TProgress> will cause create_async to return an asynchronous construct which reports progress of type TProgress each time the report method of the progress_reporter object is called. Um lambda que usa um cancellation_token pode usar esse token para verificar se há cancelamento ou passá-lo para tarefas que ele cria para que o cancelamento da construção assíncrona cause o cancelamento dessas tarefas.A lambda that takes a cancellation_token may use that token to check for cancellation, or pass it to tasks that it creates so that cancellation of the asynchronous construct causes cancellation of those tasks.

Se o corpo do objeto lambda ou de função retornar um resultado (e não uma tarefa <TResult> ), o Lamdba será executado de forma assíncrona no MTA do processo no contexto de uma tarefa que o runtime cria implicitamente.If the body of the lambda or function object returns a result (and not a task<TResult>), the lamdba will be executed asynchronously within the process MTA in the context of a task the Runtime implicitly creates for it. O método IAsyncInfo::Cancel causará o cancelamento da tarefa implícita.The IAsyncInfo::Cancel method will cause cancellation of the implicit task.

Se o corpo do lambda retorna uma tarefa, o lambda será executado em linha e declarando-se o lambda para usar um argumento do tipo cancellation_token pode disparar o cancelamento de quaisquer tarefas criadas dentro do lambda passando esse token quando você as cria.If the body of the lambda returns a task, the lamba executes inline, and by declaring the lambda to take an argument of type cancellation_token you can trigger cancellation of any tasks you create within the lambda by passing that token in when you create them. Você também pode usar o método register_callback no token para fazer com que o Runtime invoque um retorno de chamada ao chamar IAsyncInfo::Cancel na operação assíncrona ou na ação produzida.You may also use the register_callback method on the token to cause the Runtime to invoke a callback when you call IAsyncInfo::Cancel on the async operation or action produced..

Essa função só está disponível para Windows Runtime aplicativos.This function is only available to Windows Runtime apps.

CreateResourceManagerCreateResourceManager

Retorna uma interface que representa a instância singleton do Gerenciador de recursos do Tempo de Execução de Simultaneidade.Returns an interface that represents the singleton instance of the Concurrency Runtime's Resource Manager. O Gerenciador de recursos é responsável por atribuir recursos a agendadores que desejam cooperar uns com os outros.The Resource Manager is responsible for assigning resources to schedulers that want to cooperate with each other.

IResourceManager* __cdecl CreateResourceManager();

Valor RetornadoReturn Value

Uma interface IResourceManager.An IResourceManager interface.

ComentáriosRemarks

Várias chamadas subsequentes para esse método retornarão a mesma instância do Gerenciador de recursos.Multiple subsequent calls to this method will return the same instance of the Resource Manager. Cada chamada para o método incrementa uma contagem de referência no Gerenciador de recursos e deve ser correspondida com uma chamada para o método IResourceManager:: Release quando o Agendador terminar de se comunicar com o Gerenciador de recursos.Each call to the method increments a reference count on the Resource Manager, and must be matched with a call to the IResourceManager::Release method when your scheduler is done communicating with the Resource Manager.

unsupported_os será gerada se o sistema operacional não tiver suporte do tempo de execução de simultaneidade.unsupported_os is thrown if the operating system is not supported by the Concurrency Runtime.

create_taskcreate_task

Cria um objeto de tarefa ppl.Creates a PPL task object. create_task pode ser usado em qualquer lugar em que você tenha usado um construtor de tarefa.create_task can be used anywhere you would have used a task constructor. Ele é fornecido principalmente por conveniência, pois permite o uso da auto palavra-chave durante a criação de tarefas.It is provided mainly for convenience, because it allows use of the auto keyword while creating tasks.

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âmetrosParameters

TT
O tipo do parâmetro do qual a tarefa deve ser construída.The type of the parameter from which the task is to be constructed.

_ReturnType_ReturnType
Digite.Type.

_Param_Param
O parâmetro do qual a tarefa deve ser construída.The parameter from which the task is to be constructed. Isso pode ser um objeto lambda ou de função, um task_completion_event objeto, um task objeto diferente ou uma interface Windows:: Foundation:: IAsyncInfo se você estiver usando tarefas em seu aplicativo UWP.This could be a lambda or function object, a task_completion_event object, a different task object, or a Windows::Foundation::IAsyncInfo interface if you are using tasks in your UWP app.

_TaskOptions_TaskOptions
As opções de tarefa.The task options.

_Task_Task
A tarefa a ser criada.The task to create.

Valor RetornadoReturn Value

Uma nova tarefa do tipo T , que é inferida de _Param .A new task of type T, that is inferred from _Param.

ComentáriosRemarks

A primeira sobrecarga se comporta como um construtor de tarefa que usa um único parâmetro.The first overload behaves like a task constructor that takes a single parameter.

A segunda sobrecarga associa o token de cancelamento fornecido à tarefa recém-criada.The second overload associates the cancellation token provided with the newly created task. Se você usar essa sobrecarga, não poderá passar um task objeto diferente como o primeiro parâmetro.If you use this overload you are not allowed to pass in a different task object as the first parameter.

O tipo da tarefa retornada é inferido do primeiro parâmetro para a função.The type of the returned task is inferred from the first parameter to the function. Se _Param for a task_completion_event<T> , a task<T> ou um functor que retorna um dos tipos T ou task<T> , o tipo da tarefa criada será task<T> .If _Param is a task_completion_event<T>, a task<T>, or a functor that returns either type T or task<T>, the type of the created task is task<T>.

Em um aplicativo UWP, se _Param for do tipo Windows:: Foundation:: IAsyncOperation <T> ^ ou Windows:: Foundation:: IAsyncOperationWithProgress <T,P> ^ ou um functor que retorna um desses tipos, a tarefa criada será do tipo task<T> .In a UWP app, if _Param is of type Windows::Foundation::IAsyncOperation<T>^ or Windows::Foundation::IAsyncOperationWithProgress<T,P>^, or a functor that returns either of those types, the created task will be of type task<T>. Se _Param for do tipo Windows:: Foundation:: IAsyncAction ^ ou Windows:: Foundation:: IAsyncActionWithProgress <P> ^ ou um functor que retorna um desses tipos, a tarefa criada terá o tipo task<void> .If _Param is of type Windows::Foundation::IAsyncAction^ or Windows::Foundation::IAsyncActionWithProgress<P>^, or a functor that returns either of those types, the created task will have type task<void>.

DisableTracingDisableTracing

Desabilita o rastreamento no Tempo de Execução de Simultaneidade.Disables tracing in the Concurrency Runtime. Essa função é preterida porque o rastreamento ETW tem o registro cancelado por padrão.This function is deprecated because ETW tracing is unregistered by default.

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

Valor RetornadoReturn Value

Se o rastreamento foi desabilitado corretamente, S_OK será retornado.If tracing was correctly disabled, S_OK is returned. Se o rastreamento não foi iniciado anteriormente, E_NOT_STARTED será retornadoIf tracing was not previously initiated, E_NOT_STARTED is returned

EnableTracingEnableTracing

Habilita o rastreamento no Tempo de Execução de Simultaneidade.Enables tracing in the Concurrency Runtime. Essa função foi preterida porque o rastreamento ETW agora está ativado por padrão.This function is deprecated because ETW tracing is now on by default.

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

Valor RetornadoReturn Value

Se o rastreamento foi iniciado corretamente, S_OK será retornado; caso contrário, E_NOT_STARTED será retornado.If tracing was correctly initiated, S_OK is returned; otherwise, E_NOT_STARTED is returned.

InformaçõesFree

Libera um bloco de memória alocado anteriormente pelo Alloc método para o subalocador de cache tempo de execução de simultaneidade.Releases a block of memory previously allocated by the Alloc method to the Concurrency Runtime Caching Suballocator.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

parâmetrosParameters

_PAllocation_PAllocation
Um ponteiro para a memória alocada anteriormente pelo Alloc método que deve ser liberado.A pointer to memory previously allocated by the Alloc method which is to be freed. Se o parâmetro _PAllocation for definido como o valor NULL , esse método irá ignorá-lo e retornar imediatamente.If the parameter _PAllocation is set to the value NULL, this method will ignore it and return immediately.

ComentáriosRemarks

Para obter mais informações sobre quais cenários em seu aplicativo podem se beneficiar do uso do subalocador de cache, consulte Agendador de tarefas.For more information about which scenarios in your application could benefit from using the Caching Suballocator, see Task Scheduler.

get_ambient_schedulerget_ambient_scheduler

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

Valor RetornadoReturn Value

GetExecutionContextIdGetExecutionContextId

Retorna um identificador exclusivo que pode ser atribuído a um contexto de execução que implementa a IExecutionContext interface.Returns a unique identifier that can be assigned to an execution context that implements the IExecutionContext interface.

unsigned int __cdecl GetExecutionContextId();

Valor RetornadoReturn Value

Um identificador exclusivo para um contexto de execução.A unique identifier for an execution context.

ComentáriosRemarks

Use este método para obter um identificador para seu contexto de execução antes de passar uma IExecutionContext interface como um parâmetro para qualquer um dos métodos oferecidos pelo Gerenciador de recursos.Use this method to obtain an identifier for your execution context before you pass an IExecutionContext interface as a parameter to any of the methods offered by the Resource Manager.

GetOSVersionGetOSVersion

Retorna a versão do sistema operacional.Returns the operating system version.

IResourceManager::OSVersion __cdecl GetOSVersion();

Valor RetornadoReturn Value

Um valor enumerado que representa o sistema operacional.An enumerated value representing the operating system.

ComentáriosRemarks

unsupported_os será gerada se o sistema operacional não tiver suporte do tempo de execução de simultaneidade.unsupported_os is thrown if the operating system is not supported by the Concurrency Runtime.

GetProcessorCountGetProcessorCount

Retorna o número de threads de hardware no sistema subjacente.Returns the number of hardware threads on the underlying system.

unsigned int __cdecl GetProcessorCount();

Valor RetornadoReturn Value

O número de threads de hardware.The number of hardware threads.

ComentáriosRemarks

unsupported_os será gerada se o sistema operacional não tiver suporte do tempo de execução de simultaneidade.unsupported_os is thrown if the operating system is not supported by the Concurrency Runtime.

GetProcessorNodeCountGetProcessorNodeCount

Retorna o número de nós NUMA ou pacotes de processador no sistema subjacente.Returns the number of NUMA nodes or processor packages on the underlying system.

unsigned int __cdecl GetProcessorNodeCount();

Valor RetornadoReturn Value

O número de nós NUMA ou pacotes de processador.The number of NUMA nodes or processor packages.

ComentáriosRemarks

Se o sistema contiver mais nós NUMA do que pacotes de processador, o número de nós NUMA será retornado, caso contrário, o número de pacotes de processador será retornado.If the system contains more NUMA nodes than processor packages, the number of NUMA nodes is returned, otherwise, the number of processor packages is returned.

unsupported_os será gerada se o sistema operacional não tiver suporte do tempo de execução de simultaneidade.unsupported_os is thrown if the operating system is not supported by the Concurrency Runtime.

GetSchedulerIdGetSchedulerId

Retorna um identificador exclusivo que pode ser atribuído a um Agendador que implementa a IScheduler interface.Returns a unique identifier that can be assigned to a scheduler that implements the IScheduler interface.

unsigned int __cdecl GetSchedulerId();

Valor RetornadoReturn Value

Um identificador exclusivo para um Agendador.A unique identifier for a scheduler.

ComentáriosRemarks

Use esse método para obter um identificador para o Agendador antes de passar uma IScheduler interface como um parâmetro para qualquer um dos métodos oferecidos pelo Gerenciador de recursos.Use this method to obtain an identifier for your scheduler before you pass an IScheduler interface as a parameter to any of the methods offered by the Resource Manager.

internal_assign_iteratorsinternal_assign_iterators

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

parâmetrosParameters

TT

_Ax_Ax

_I_I

firstfirst

lastlast

interruption_pointinterruption_point

Cria um ponto de interrupção para o cancelamento.Creates an interruption point for cancellation. Se um cancelamento estiver em andamento no contexto em que essa função é chamada, isso gerará uma exceção interna que anula a execução do trabalho paralelo em execução no momento.If a cancellation is in progress in the context where this function is called, this will throw an internal exception that aborts the execution of the currently executing parallel work. Se o cancelamento não estiver em andamento, a função não fará nada.If cancellation is not in progress, the function does nothing.

inline void interruption_point();

ComentáriosRemarks

Você não deve capturar a exceção de cancelamento interna gerada pela interruption_point() função.You should not catch the internal cancellation exception thrown by the interruption_point() function. A exceção será capturada e tratada pelo tempo de execução e a captura poderá fazer com que o seu programa se comporte de forma anormal.The exception will be caught and handled by the runtime, and catching it may cause your program to behave abnormally.

is_current_task_group_cancelingis_current_task_group_canceling

Retorna uma indicação de se o grupo de tarefas que está atualmente em execução embutida no contexto atual está no meio de um cancelamento ativo (ou será em breve).Returns an indication of whether the task group which is currently executing inline on the current context is in the midst of an active cancellation (or will be shortly). Observe que, se não houver nenhum grupo de tarefas atualmente em execução embutido no contexto atual, false será retornado.Note that if there is no task group currently executing inline on the current context, false will be returned.

bool __cdecl is_current_task_group_canceling();

Valor RetornadoReturn Value

true Se o grupo de tarefas que está sendo executado no momento estiver sendo cancelado, false caso contrário.true if the task group which is currently executing is canceling, false otherwise.

ComentáriosRemarks

Para obter mais informações, consulte cancelamento.For more information, see Cancellation.

make_choicemake_choice

Constrói um choice bloco de mensagens de um opcional Scheduler ou ScheduleGroup e duas ou mais fontes de entrada.Constructs a choice messaging block from an optional Scheduler or ScheduleGroup and two or more input sources.

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âmetrosParameters

T1T1
O tipo de bloco de mensagem da primeira origem.The message block type of the first source.

T2T2
O tipo de bloco de mensagens da segunda fonte.The message block type of the second source.

_PScheduler_PScheduler
O Scheduler objeto no qual a tarefa de propagação para o choice bloco de mensagens está agendada.The Scheduler object within which the propagation task for the choice messaging block is scheduled.

_Item1_Item1
A primeira origem.The first source.

_Item2_Item2
A segunda origem.The second source.

_Items_Items
Fontes adicionais.Additional sources.

_PScheduleGroup_PScheduleGroup
O ScheduleGroup objeto no qual a tarefa de propagação para o choice bloco de mensagens está agendada.The ScheduleGroup object within which the propagation task for the choice messaging block is scheduled. O Scheduler objeto usado é implícito pelo grupo de agendamento.The Scheduler object used is implied by the schedule group.

Valor RetornadoReturn Value

Um choice bloco de mensagens com duas ou mais fontes de entrada.A choice message block with two or more input sources.

make_greedy_joinmake_greedy_join

Constrói um greedy multitype_join bloco de mensagens de um opcional Scheduler ou ScheduleGroup e duas ou mais fontes de entrada.Constructs a greedy multitype_join messaging block from an optional Scheduler or ScheduleGroup and two or more input sources.

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âmetrosParameters

T1T1
O tipo de bloco de mensagem da primeira origem.The message block type of the first source.

T2T2
O tipo de bloco de mensagens da segunda fonte.The message block type of the second source.

_PScheduler_PScheduler
O Scheduler objeto no qual a tarefa de propagação para o multitype_join bloco de mensagens está agendada.The Scheduler object within which the propagation task for the multitype_join messaging block is scheduled.

_Item1_Item1
A primeira origem.The first source.

_Item2_Item2
A segunda origem.The second source.

_Items_Items
Fontes adicionais.Additional sources.

_PScheduleGroup_PScheduleGroup
O ScheduleGroup objeto no qual a tarefa de propagação para o multitype_join bloco de mensagens está agendada.The ScheduleGroup object within which the propagation task for the multitype_join messaging block is scheduled. O Scheduler objeto usado é implícito pelo grupo de agendamento.The Scheduler object used is implied by the schedule group.

Valor RetornadoReturn Value

Um greedy multitype_join bloco de mensagens com duas ou mais fontes de entrada.A greedy multitype_join message block with two or more input sources.

make_joinmake_join

Constrói um non_greedy multitype_join bloco de mensagens de um opcional Scheduler ou ScheduleGroup e duas ou mais fontes de entrada.Constructs a non_greedy multitype_join messaging block from an optional Scheduler or ScheduleGroup and two or more input sources.

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âmetrosParameters

T1T1
O tipo de bloco de mensagem da primeira origem.The message block type of the first source.

T2T2
O tipo de bloco de mensagens da segunda fonte.The message block type of the second source.

_PScheduler_PScheduler
O Scheduler objeto no qual a tarefa de propagação para o multitype_join bloco de mensagens está agendada.The Scheduler object within which the propagation task for the multitype_join messaging block is scheduled.

_Item1_Item1
A primeira origem.The first source.

_Item2_Item2
A segunda origem.The second source.

_Items_Items
Fontes adicionais.Additional sources.

_PScheduleGroup_PScheduleGroup
O ScheduleGroup objeto no qual a tarefa de propagação para o multitype_join bloco de mensagens está agendada.The ScheduleGroup object within which the propagation task for the multitype_join messaging block is scheduled. O Scheduler objeto usado é implícito pelo grupo de agendamento.The Scheduler object used is implied by the schedule group.

Valor RetornadoReturn Value

Um non_greedy multitype_join bloco de mensagens com duas ou mais fontes de entrada.A non_greedy multitype_join message block with two or more input sources.

make_taskmake_task

Um método de fábrica para criar um task_handle objeto.A factory method for creating a task_handle object.

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

parâmetrosParameters

_Function_Function
O tipo do objeto de função que será invocado para executar o trabalho representado pelo task_handle objeto.The type of the function object that will be invoked to execute the work represented by the task_handle object.

_Func_Func
A função que será invocada para executar o trabalho representado pelo task_handle objeto.The function that will be invoked to execute the work represented by the task_handle object. Isso pode ser um functor lambda, um ponteiro para uma função ou qualquer objeto que ofereça suporte a uma versão do operador de chamada de função com a assinatura void operator()() .This may be a lambda functor, a pointer to a function, or any object that supports a version of the function call operator with the signature void operator()().

Valor RetornadoReturn Value

Um objeto task_handle.A task_handle object.

ComentáriosRemarks

Essa função é útil quando você precisa criar um task_handle objeto com uma expressão lambda, pois ela permite que você crie o objeto sem saber o tipo true do functor lambda.This function is useful when you need to create a task_handle object with a lambda expression, because it allows you to create the object without knowing the true type of the lambda functor.

parallel_buffered_sortparallel_buffered_sort

Organiza os elementos em um intervalo especificado em uma ordem não decrescente ou de acordo com um critério de ordenação especificado por um predicado binário, em paralelo.Arranges the elements in a specified range into a non-descending order, or according to an ordering criterion specified by a binary predicate, in parallel. Essa função é semanticamente semelhante ao std::sort que é uma classificação baseada em comparação, instável, in-loco, exceto que precisa de O(n) espaço adicional, e requer a inicialização padrão para os elementos que estão sendo classificados.This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place sort except that it needs O(n) additional space, and requires default initialization for the elements being sorted.

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âmetrosParameters

_Random_iterator_Random_iterator
O tipo de iterador do intervalo de entrada.The iterator type of the input range.

_Allocator_Allocator
O tipo de um alocador de memória compatível com biblioteca padrão C++.The type of a C++ Standard Library compatible memory allocator.

_Function_Function
O tipo do comparador de binário.The type of the binary comparator.

_Begin_Begin
Um iterador de acesso aleatório que trata da posição do primeiro elemento no intervalo a ser classificado.A random-access iterator addressing the position of the first element in the range to be sorted.

_End_End
Um iterador de acesso aleatório que trata da posição logo após o elemento final no intervalo a ser classificado.A random-access iterator addressing the position one past the final element in the range to be sorted.

_Alloc_Alloc
Uma instância de um alocador de memória compatível com biblioteca padrão C++.An instance of a C++ Standard Library compatible memory allocator.

_Func_Func
Um objeto de função de predicado definido pelo usuário que define o critério de comparação a ser satisfeito por elementos sucessivos na ordenação.A user-defined predicate function object that defines the comparison criterion to be satisfied by successive elements in the ordering. Um predicado binário usa dois argumentos e retorna true quando satisfeito e false quando não está satisfeito.A binary predicate takes two arguments and returns true when satisfied and false when not satisfied. Essa função de comparador deve impor uma ordenação fraca estrita aos pares de elementos da sequência.This comparator function must impose a strict weak ordering on pairs of elements from the sequence.

_Chunk_size_Chunk_size
O tamanho de mínimo de uma parte que será dividida em duas para execução paralela.The mimimum size of a chunk that will be split into two for parallel execution.

ComentáriosRemarks

Todas as sobrecargas exigem n * sizeof(T) espaço adicional, em que n é o número de elementos a serem classificados e T é o tipo de elemento.All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. Na maioria dos casos parallel_buffered_sort mostrará uma melhoria no desempenho do parallel_sort, e você deverá usá-lo em parallel_sort se tiver a memória disponível.In most cases parallel_buffered_sort will show an improvement in performance over parallel_sort, and you should use it over parallel_sort if you have the memory available.

Se você não fornecer um comparador de binário std::less é usado como o padrão, o que exige que o tipo de elemento forneça o operador operator<() .If you do not supply a binary comparator std::less is used as the default, which requires the element type to provide the operator operator<().

Se você não fornecer um tipo ou instância de alocador, o alocador de memória da biblioteca padrão C++ std::allocator<T> será usado para alocar o buffer.If you do not supply an allocator type or instance, the C++ Standard Library memory allocator std::allocator<T> is used to allocate the buffer.

O algoritmo divide o intervalo de entrada em duas partes e divide sucessivamente cada parte em duas subpartes para execução em paralelo.The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. O argumento opcional _Chunk_size pode ser usado para indicar ao algoritmo que ele deve manipular partes do tamanho < em _Chunk_size série.The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

parallel_forparallel_for

parallel_for itera em um intervalo de índices e executa uma função fornecida pelo usuário em cada iteração, em paralelo.parallel_for iterates over a range of indices and executes a user-supplied function at each iteration, in parallel.

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âmetrosParameters

_Index_type_Index_type
O tipo do índice que está sendo usado para a iteração.The type of the index being used for the iteration.

_Function_Function
O tipo da função que será executada em cada iteração.The type of the function that will be executed at each iteration.

_Partitioner_Partitioner
O tipo do particionador que é usado para particionar o intervalo fornecido.The type of the partitioner that is used to partition the supplied range.

firstfirst
O primeiro índice a ser incluído na iteração.The first index to be included in the iteration.

lastlast
O índice que ultrapassou o último índice a ser incluído na iteração.The index one past the last index to be included in the iteration.

_Step_Step
O valor pelo qual percorrer ao iterar de first para last .The value by which to step when iterating from first to last. A etapa deve ser positiva.The step must be positive. invalid_argument será gerada se a etapa for menor que 1.invalid_argument is thrown if the step is less than 1.

_Func_Func
A função a ser executada em cada iteração.The function to be executed at each iteration. Isso pode ser uma expressão lambda, um ponteiro de função ou qualquer objeto que ofereça suporte a uma versão do operador de chamada de função com a assinatura void operator()(_Index_type) .This may be a lambda expression, a function pointer, or any object that supports a version of the function call operator with the signature void operator()(_Index_type).

_Part_Part
Uma referência ao objeto do particionador.A reference to the partitioner object. O argumento pode ser um dos const auto_partitioner & , const static_partitioner & , const simple_partitioner & ou affinity_partitioner & se um objeto affinity_partitioner for usado, a referência deverá ser uma referência não const l-Value, para que o algoritmo possa armazenar o estado para loops futuros a serem reutilizados.The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitioner object is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

ComentáriosRemarks

Para obter mais informações, consulte algoritmos paralelos.For more information, see Parallel Algorithms.

parallel_for_eachparallel_for_each

parallel_for_each aplica uma função especificada para cada elemento dentro de um intervalo, em paralelo.parallel_for_each applies a specified function to each element within a range, in parallel. É semanticamente equivalente à for_each função no std namespace, exceto que a iteração sobre os elementos é executada em paralelo e a ordem de iteração não é especificada.It is semantically equivalent to the for_each function in the std namespace, except that iteration over the elements is performed in parallel, and the order of iteration is unspecified. O argumento _Func deve dar suporte a um operador de chamada de função no formato operator()(T) em que o parâmetro T é o tipo de item do contêiner que está sendo iterado.The argument _Func must support a function call operator of the form operator()(T) where the parameter T is the item type of the container being iterated over.

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âmetrosParameters

_Iterator_Iterator
O tipo do iterador que está sendo usado para iterar no contêiner.The type of the iterator being used to iterate over the container.

_Function_Function
O tipo da função que será aplicada a cada elemento dentro do intervalo.The type of the function that will be applied to each element within the range.

_Partitioner_Partitioner
firstfirst
Um iterador que aborda a posição do primeiro elemento a ser incluído na iteração paralela.An iterator addressing the position of the first element to be included in parallel iteration.

lastlast
Um iterador que aborda a posição um passado do elemento final a ser incluído na iteração paralela.An iterator addressing the position one past the final element to be included in parallel iteration.

_Func_Func
Um objeto de função definido pelo usuário que é aplicado a cada elemento no intervalo.A user-defined function object that is applied to each element in the range.

_Part_Part
Uma referência ao objeto do particionador.A reference to the partitioner object. O argumento pode ser um dos const auto_partitioner & , const static_partitioner & , const simple_partitioner & ou affinity_partitioner & se um objeto affinity_partitioner for usado, a referência deverá ser uma referência não const l-Value, para que o algoritmo possa armazenar o estado para loops futuros a serem reutilizados.The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitioner object is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

ComentáriosRemarks

auto_partitioner será usado para a sobrecarga sem um particionador explícito.auto_partitioner will be used for the overload without an explicit partitioner.

Para iteradores que não dão suporte ao acesso aleatório, há suporte apenas para auto_partitioner .For iterators that do not support random access, only auto_partitioner is supported.

Para obter mais informações, consulte algoritmos paralelos.For more information, see Parallel Algorithms.

parallel_invokeparallel_invoke

Executa os objetos de função fornecidos como parâmetros em paralelo e os blocos até que tenham concluído a execução.Executes the function objects supplied as parameters in parallel, and blocks until they have finished executing. Cada objeto de função pode ser uma expressão lambda, um ponteiro para função ou qualquer objeto que dê suporte ao operador de chamada de função com a assinatura void operator()() .Each function object could be a lambda expression, a pointer to function, or any object that supports the function call operator with the 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);

parâmetrosParameters

_Function1_Function1
O tipo do primeiro objeto de função a ser executado em paralelo.The type of the first function object to be executed in parallel.

_Function2_Function2
O tipo do segundo objeto de função a ser executado em paralelo.The type of the second function object to be executed in parallel.

_Function3_Function3
O tipo do terceiro objeto de função a ser executado em paralelo.The type of the third function object to be executed in parallel.

_Function4_Function4
O tipo do quarto objeto de função a ser executado em paralelo.The type of the fourth function object to be executed in parallel.

_Function5_Function5
O tipo do quinto objeto de função a ser executado em paralelo.The type of the fifth function object to be executed in parallel.

_Function6_Function6
O tipo do sexto objeto de função a ser executado em paralelo.The type of the sixth function object to be executed in parallel.

_Function7_Function7
O tipo do sétimo objeto de função a ser executado em paralelo.The type of the seventh function object to be executed in parallel.

_Function8_Function8
O tipo do oitavo objeto de função a ser executado em paralelo.The type of the eighth function object to be executed in parallel.

_Function9_Function9
O tipo do nono objeto de função a ser executado em paralelo.The type of the ninth function object to be executed in parallel.

_Function10_Function10
O tipo do décimo objeto de função a ser executado em paralelo.The type of the tenth function object to be executed in parallel.

_Func1_Func1
O primeiro objeto de função a ser executado em paralelo.The first function object to be executed in parallel.

_Func2_Func2
O segundo objeto de função a ser executado em paralelo.The second function object to be executed in parallel.

_Func3_Func3
O terceiro objeto de função a ser executado em paralelo.The third function object to be executed in parallel.

_Func4_Func4
O quarto objeto de função a ser executado em paralelo.The fourth function object to be executed in parallel.

_Func5_Func5
O quinto objeto de função a ser executado em paralelo.The fifth function object to be executed in parallel.

_Func6_Func6
O sexto objeto de função a ser executado em paralelo.The sixth function object to be executed in parallel.

_Func7_Func7
O sétimo objeto de função a ser executado em paralelo.The seventh function object to be executed in parallel.

_Func8_Func8
O oitavo objeto de função a ser executado em paralelo.The eighth function object to be executed in parallel.

_Func9_Func9
O nono objeto de função a ser executado em paralelo.The ninth function object to be executed in parallel.

_Func10_Func10
O décimo objeto de função a ser executado em paralelo.The tenth function object to be executed in parallel.

ComentáriosRemarks

Observe que um ou mais dos objetos de função fornecidos como parâmetros podem ser executados embutidos no contexto de chamada.Note that one or more of the function objects supplied as parameters may execute inline on the calling context.

Se um ou mais dos objetos de função passados como parâmetros para essa função lançar uma exceção, o tempo de execução selecionará uma exceção de sua escolha e a propagará da chamada para parallel_invoke .If one or more of the function objects passed as parameters to this function throws an exception, the runtime will select one such exception of its choosing and propagate it out of the call to parallel_invoke.

Para obter mais informações, consulte algoritmos paralelos.For more information, see Parallel Algorithms.

parallel_radixsortparallel_radixsort

Organiza os elementos em um intervalo especificado em uma ordem não decrescente usando um algoritmo de classificação de base.Arranges elements in a specified range into an non descending order using a radix sorting algorithm. Essa é uma função de classificação estável que requer uma função de projeção que pode projetar elementos a serem classificados em chaves semelhantes a inteiros não assinadas.This is a stable sort function which requires a projection function that can project elements to be sorted into unsigned integer-like keys. A inicialização padrão é necessária para os elementos que estão sendo classificados.Default initialization is required for the elements being sorted.

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âmetrosParameters

_Random_iterator_Random_iterator
O tipo de iterador do intervalo de entrada.The iterator type of the input range.

_Allocator_Allocator
O tipo de um alocador de memória compatível com biblioteca padrão C++.The type of a C++ Standard Library compatible memory allocator.

_Function_Function
O tipo da função de projeção.The type of the projection function.

_Begin_Begin
Um iterador de acesso aleatório que trata da posição do primeiro elemento no intervalo a ser classificado.A random-access iterator addressing the position of the first element in the range to be sorted.

_End_End
Um iterador de acesso aleatório que trata da posição logo após o elemento final no intervalo a ser classificado.A random-access iterator addressing the position one past the final element in the range to be sorted.

_Alloc_Alloc
Uma instância de um alocador de memória compatível com biblioteca padrão C++.An instance of a C++ Standard Library compatible memory allocator.

_Proj_func_Proj_func
Um objeto de função de projeção definido pelo usuário que converte um elemento em um valor integral.A user-defined projection function object that converts an element into an integral value.

_Chunk_size_Chunk_size
O tamanho de mínimo de uma parte que será dividida em duas para execução paralela.The mimimum size of a chunk that will be split into two for parallel execution.

ComentáriosRemarks

Todas as sobrecargas exigem n * sizeof(T) espaço adicional, em que n é o número de elementos a serem classificados e T é o tipo de elemento.All overloads require n * sizeof(T) additional space, where n is the number of elements to be sorted, and T is the element type. Uma projeção unário functor com a assinatura I _Proj_func(T) é necessária para retornar uma chave quando um elemento é fornecido, em que T é o tipo de elemento e I é um tipo de inteiro sem sinal.An unary projection functor with the signature I _Proj_func(T) is required to return a key when given an element, where T is the element type and I is an unsigned integer-like type.

Se você não fornecer uma função de projeção, uma função de projeção padrão que simplesmente retorna o elemento é usada para tipos integrais.If you do not supply a projection function, a default projection function which simply returns the element is used for integral types. A função não será compilada se o elemento não for um tipo integral na ausência de uma função de projeção.The function will fail to compile if the element is not an integral type in the absence of a projection function.

Se você não fornecer um tipo ou instância de alocador, o alocador de memória da biblioteca padrão C++ std::allocator<T> será usado para alocar o buffer.If you do not supply an allocator type or instance, the C++ Standard Library memory allocator std::allocator<T> is used to allocate the buffer.

O algoritmo divide o intervalo de entrada em duas partes e divide sucessivamente cada parte em duas subpartes para execução em paralelo.The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. O argumento opcional _Chunk_size pode ser usado para indicar ao algoritmo que ele deve manipular partes do tamanho < em _Chunk_size série.The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

parallel_reduceparallel_reduce

Computa a soma de todos os elementos em um intervalo especificado computando somas parciais sucessivas ou computa o resultado de resultados parciais sucessivos de forma semelhante ao uso de uma operação binária especificada diferente de Sum, em paralelo.Computes the sum of all elements in a specified range by computing successive partial sums, or computes the result of successive partial results similarly obtained from using a specified binary operation other than sum, in parallel. parallel_reduce é semanticamente semelhante a std::accumulate , exceto pelo fato de que ela requer que a operação binária seja associativa e requer um valor de identidade em vez de um valor inicial.parallel_reduce is semantically similar to std::accumulate, except that it requires the binary operation to be associative, and requires an identity value instead of an initial value.

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âmetrosParameters

_Forward_iterator_Forward_iterator
O tipo de iterador do intervalo de entrada.The iterator type of input range.

_Sym_reduce_fun_Sym_reduce_fun
O tipo da função de redução simétrica.The type of the symmetric reduction function. Esse deve ser um tipo de função com assinatura _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type) , em que _Reduce_type é o mesmo que o tipo de identidade e o tipo de resultado da redução.This must be a function type with signature _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type), where _Reduce_type is the same as the identity type and the result type of the reduction. Para a terceira sobrecarga, isso deve ser consistente com o tipo de saída de _Range_reduce_fun .For the third overload, this should be consistent with the output type of _Range_reduce_fun.

_Reduce_type_Reduce_type
O tipo para o qual a entrada será reduzida, que pode ser diferente do tipo de elemento de entrada.The type that the input will reduce to, which can be different from the input element type. O valor de retorno e o valor de identidade terão esse tipo.The return value and identity value will has this type.

_Range_reduce_fun_Range_reduce_fun
O tipo da função de redução de intervalo.The type of the range reduction function. Esse deve ser um tipo de função com assinatura _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type) , _Reduce_type é o mesmo que o tipo de identidade e o tipo de resultado da redução.This must be a function type with signature _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type), _Reduce_type is the same as the identity type and the result type of the reduction.

_Begin_Begin
Um iterador de entrada que aborda o primeiro elemento no intervalo a ser reduzido.An input iterator addressing the first element in the range to be reduced.

_End_End
Um iterador de entrada que aborda o elemento que é uma posição além do elemento final no intervalo a ser reduzido.An input iterator addressing the element that is one position beyond the final element in the range to be reduced.

_Identity_Identity
O valor de identidade _Identity é do mesmo tipo que o tipo de resultado da redução e também o value_type do iterador para a primeira e segunda sobrecargas.The identity value _Identity is of the same type as the result type of the reduction and also the value_type of the iterator for the first and second overloads. Para a terceira sobrecarga, o valor de identidade deve ter o mesmo tipo do tipo de resultado da redução, mas pode ser diferente do value_type do iterador.For the third overload, the identity value must have the same type as the result type of the reduction, but can be different from the value_type of the iterator. Ele deve ter um valor apropriado, de modo que o operador de redução de intervalo _Range_fun , quando aplicado a um intervalo de um único elemento do tipo value_type e o valor de identidade, se comporta como uma conversão de tipo do valor de tipo value_type para o tipo de identidade.It must have an appropriate value such that the range reduction operator _Range_fun, when applied to a range of a single element of type value_type and the identity value, behaves like a type cast of the value from type value_type to the identity type.

_Sym_fun_Sym_fun
A função simétrica que será usada no segundo da redução.The symmetric function that will be used in the second of the reduction. Consulte comentários para obter mais informações.Refer to Remarks for more information.

_Range_fun_Range_fun
A função que será usada na primeira fase da redução.The function that will be used in the first phase of the reduction. Consulte comentários para obter mais informações.Refer to Remarks for more information.

Valor RetornadoReturn Value

O resultado da redução.The result of the reduction.

ComentáriosRemarks

Para executar uma redução paralela, a função divide o intervalo em partes com base no número de trabalhadores disponíveis para o Agendador subjacente.To perform a parallel reduction, the function divides the range into chunks based on the number of workers available to the underlying scheduler. A redução ocorre em duas fases, a primeira fase executa uma redução em cada parte e a segunda fase executa uma redução entre os resultados parciais de cada parte.The reduction takes place in two phases, the first phase performs a reduction within each chunk, and the second phase performs a reduction between the partial results from each chunk.

A primeira sobrecarga requer que o iterador value_type , T , seja o mesmo que o tipo de valor de identidade, bem como o tipo de resultado de redução.The first overload requires that the iterator's value_type, T, be the same as the identity value type as well as the reduction result type. O tipo de elemento T deve fornecer o operador T T::operator + (T) para reduzir os elementos em cada parte.The element type T must provide the operator T T::operator + (T) to reduce elements in each chunk. O mesmo operador também é usado na segunda fase.The same operator is used in the second phase as well.

A segunda sobrecarga também exige que o iterador value_type seja o mesmo que o tipo de valor de identidade, bem como o tipo de resultado de redução.The second overload also requires that the iterator's value_type be the same as the identity value type as well as the reduction result type. O operador binário fornecido _Sym_fun é usado em ambas as fases de redução, com o valor de identidade como o valor inicial para a primeira fase.The supplied binary operator _Sym_fun is used in both reduction phases, with the identity value as the initial value for the first phase.

Para a terceira sobrecarga, o tipo de valor de identidade deve ser o mesmo que o tipo de resultado de redução, mas o iterador value_type pode ser diferente de ambos.For the third overload, the identity value type must be the same as the reduction result type, but the iterator's value_type may be different from both. A função de redução de intervalo _Range_fun é usada na primeira fase com o valor de identidade como o valor inicial e a função Binary _Sym_reduce_fun é aplicada aos subresultados na segunda fase.The range reduction function _Range_fun is used in the first phase with the identity value as the initial value, and the binary function _Sym_reduce_fun is applied to sub results in the second phase.

parallel_sortparallel_sort

Organiza os elementos em um intervalo especificado em uma ordem não decrescente ou de acordo com um critério de ordenação especificado por um predicado binário, em paralelo.Arranges the elements in a specified range into a non-descending order, or according to an ordering criterion specified by a binary predicate, in parallel. Essa função é semanticamente semelhante a que se trata de std::sort uma classificação in-loco, instável e em vigor.This function is semantically similar to std::sort in that it is a compare-based, unstable, in-place 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);

parâmetrosParameters

_Random_iterator_Random_iterator
O tipo de iterador do intervalo de entrada.The iterator type of the input range.

_Function_Function
O tipo de functor de comparação binária.The type of the binary comparison functor.

_Begin_Begin
Um iterador de acesso aleatório que trata da posição do primeiro elemento no intervalo a ser classificado.A random-access iterator addressing the position of the first element in the range to be sorted.

_End_End
Um iterador de acesso aleatório que trata da posição logo após o elemento final no intervalo a ser classificado.A random-access iterator addressing the position one past the final element in the range to be sorted.

_Func_Func
Um objeto de função de predicado definido pelo usuário que define o critério de comparação a ser satisfeito por elementos sucessivos na ordenação.A user-defined predicate function object that defines the comparison criterion to be satisfied by successive elements in the ordering. Um predicado binário usa dois argumentos e retorna true quando satisfeito e false quando não está satisfeito.A binary predicate takes two arguments and returns true when satisfied and false when not satisfied. Essa função de comparador deve impor uma ordenação fraca estrita aos pares de elementos da sequência.This comparator function must impose a strict weak ordering on pairs of elements from the sequence.

_Chunk_size_Chunk_size
O tamanho mínimo de uma parte que será dividida em duas para execução paralela.The minimum size of a chunk that will be split into two for parallel execution.

ComentáriosRemarks

A primeira sobrecarga usa o comparador binário std::less .The first overload uses the binary comparator std::less.

O segundo sobrecarregado usa o comparador binário fornecido que deve ter a assinatura bool _Func(T, T) onde T é o tipo dos elementos no intervalo de entrada.The second overloaded uses the supplied binary comparator that should have the signature bool _Func(T, T) where T is the type of the elements in the input range.

O algoritmo divide o intervalo de entrada em duas partes e divide sucessivamente cada parte em duas subpartes para execução em paralelo.The algorithm divides the input range into two chunks and successively divides each chunk into two sub-chunks for execution in parallel. O argumento opcional _Chunk_size pode ser usado para indicar ao algoritmo que ele deve manipular partes do tamanho < em _Chunk_size série.The optional argument _Chunk_size can be used to indicate to the algorithm that it should handles chunks of size < _Chunk_size serially.

parallel_transformparallel_transform

Aplica um objeto de função especificado a cada elemento em um intervalo de origem, ou a um par de elementos de dois intervalos de origem, e copia os valores de retorno do objeto de função em um intervalo de destino, em paralelo.Applies a specified function object to each element in a source range, or to a pair of elements from two source ranges, and copies the return values of the function object into a destination range, in parallel. Esse funcionamento é semanticamente equivalente a std::transform .This functional is semantically equivalent to 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âmetrosParameters

_Input_iterator1_Input_iterator1
O tipo do primeiro ou somente iterador de entrada.The type of the first or only input iterator.

_Output_iterator_Output_iterator
O tipo do iterador de saída.The type of the output iterator.

_Unary_operator_Unary_operator
O tipo de functor unário a ser executado em cada elemento no intervalo de entrada.The type of the unary functor to be executed on each element in the input range.

_Input_iterator2_Input_iterator2
O tipo do segundo iterador de entrada.The type of second input iterator.

_Binary_operator_Binary_operator
O tipo do functor binário executado emparelha em elementos dos dois intervalos de origem.The type of the binary functor executed pairwise on elements from the two source ranges.

_Partitioner_Partitioner
first1first1
Um iterador de entrada que aborda a posição do primeiro elemento no primeiro ou somente o intervalo de origem a ser operado.An input iterator addressing the position of the first element in the first or only source range to be operated on.

last1last1
Um iterador de entrada que aborda a posição um passado do elemento final no primeiro ou somente o intervalo de origem a ser operado.An input iterator addressing the position one past the final element in the first or only source range to be operated on.

_Result_Result
Um iterador de saída que trata da posição do primeiro elemento no intervalo de destino.An output iterator addressing the position of the first element in the destination range.

_Unary_op_Unary_op
Um objeto de função unário definido pelo usuário que é aplicado a cada elemento no intervalo de origem.A user-defined unary function object that is applied to each element in the source range.

_Part_Part
Uma referência ao objeto do particionador.A reference to the partitioner object. O argumento pode ser um dos const auto_partitioner & , const static_partitioner & , const simple_partitioner & ou affinity_partitioner & se um objeto affinity_partitioner for usado, a referência deverá ser uma referência não const l-Value, para que o algoritmo possa armazenar o estado para loops futuros a serem reutilizados.The argument can be one of const auto_partitioner&, const static_partitioner&, const simple_partitioner& or affinity_partitioner& If an affinity_partitioner object is used, the reference must be a non-const l-value reference, so that the algorithm can store state for future loops to re-use.

first2first2
Um iterador de entrada que trata da posição do primeiro elemento no segundo intervalo de origem no qual a operação ocorrerá.An input iterator addressing the position of the first element in the second source range to be operated on.

_Binary_op_Binary_op
Um objeto de função binária definido pelo usuário que é aplicado emparelhar, em uma ordem de encaminhamento, aos dois intervalos de origem.A user-defined binary function object that is applied pairwise, in a forward order, to the two source ranges.

Valor RetornadoReturn Value

Um iterador de saída que trata da posição logo após o elemento final no intervalo de destino que está recebendo os elementos de saída transformados pelo objeto de função.An output iterator addressing the position one past the final element in the destination range that is receiving the output elements transformed by the function object.

ComentáriosRemarks

auto_partitioner será usado para as sobrecargas sem um argumento de particionador explícito.auto_partitioner will be used for the overloads without an explicit partitioner argument.

Para iteradores que não dão suporte ao acesso aleatório, há suporte apenas para auto_partitioner .For iterators that do not support random access, only auto_partitioner is supported.

As sobrecargas que usam o argumento transformam _Unary_op o intervalo de entrada no intervalo de saída aplicando o functor unário a cada elemento no intervalo de entrada.The overloads that take the argument _Unary_op transform the input range into the output range by applying the unary functor to each element in the input range. _Unary_op deve oferecer suporte ao operador de chamada de função com assinatura, operator()(T) em que T é o tipo de valor do intervalo que está sendo iterado._Unary_op must support the function call operator with signature operator()(T) where T is the value type of the range being iterated over.

As sobrecargas que usam o argumento transformam _Binary_op dois intervalos de entrada no intervalo de saída aplicando o functor binário a um elemento do primeiro intervalo de entrada e um elemento do segundo intervalo de entrada.The overloads that take the argument _Binary_op transform two input ranges into the output range by applying the binary functor to one element from the first input range and one element from the second input range. _Binary_op deve oferecer suporte ao operador de chamada de função com assinatura operator()(T, U) , em que T , U são tipos de valor dos dois iteradores de entrada._Binary_op must support the function call operator with signature operator()(T, U) where T, U are value types of the two input iterators.

Para obter mais informações, consulte algoritmos paralelos.For more information, see Parallel Algorithms.

recebereceive

Uma implementação de recebimento geral, permitindo que um contexto aguarde dados de exatamente uma fonte e filtre os valores que são aceitos.A general receive implementation, allowing a context to wait for data from exactly one source and filter the values that are accepted.

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âmetrosParameters

TT
O tipo de carga.The payload type.

_Src_Src
Um ponteiro ou referência à fonte da qual os dados são esperados.A pointer or reference to the source from which data is expected.

_Timeout_Timeout
O tempo máximo para o qual o método deve para os dados, em milissegundos.The maximum time for which the method should for the data, in milliseconds.

_Filter_proc_Filter_proc
Uma função de filtro que determina se as mensagens devem ser aceitas.A filter function which determines whether messages should be accepted.

Valor RetornadoReturn Value

Um valor da origem, do tipo de carga.A value from the source, of the payload type.

ComentáriosRemarks

Se o parâmetro _Timeout tiver um valor diferente da constante COOPERATIVE_TIMEOUT_INFINITE , a exceção operation_timed_out será lançada se a quantidade especificada de tempo expirar antes que uma mensagem seja recebida.If the parameter _Timeout has a value other than the constant COOPERATIVE_TIMEOUT_INFINITE, the exception operation_timed_out is thrown if the specified amount of time expires before a message is received. Se você quiser um tempo limite de comprimento zero, use a função try_receive , em vez de chamar receive com um tempo limite de 0 (zero), pois ele é mais eficiente e não gera exceções em tempos limite.If you want a zero length timeout, you should use the try_receive function, as opposed to calling receive with a timeout of 0 (zero), as it is more efficient and does not throw exceptions on timeouts.

Para obter mais informações, consulte funções de passagem de mensagens.For more information, see Message Passing Functions.

run_with_cancellation_tokenrun_with_cancellation_token

Executa um objeto de função imediatamente e de forma síncrona no contexto de um determinado token de cancelamento.Executes a function object immediately and synchronously in the context of a given cancellation token.

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

parâmetrosParameters

_Function_Function
O tipo do objeto de função que será invocado.The type of the function object that will be invoked.

_Func_Func
O objeto de função que será executado.The function object which will be executed. Este objeto deve dar suporte ao operador de chamada de função com uma assinatura de void (void).This object must support the function call operator with a signature of void(void).

_Ct_Ct
O token de cancelamento que controlará o cancelamento implícito do objeto de função.The cancellation token which will control implicit cancellation of the function object. Use cancellation_token::none() se quiser que a função seja executada sem qualquer possibilidade de cancelamento implícito de um grupo de tarefas pai ser cancelado.Use cancellation_token::none() if you want the function execute without any possibility of implicit cancellation from a parent task group being canceled.

ComentáriosRemarks

Qualquer ponto de interrupção no objeto de função será disparado quando o cancellation_token for cancelado.Any interruption points in the function object will be triggered when the cancellation_token is canceled. O token explícito _Ct isolará isso _Func do cancelamento pai, se o pai tiver um token diferente ou nenhum token.The explicit token _Ct will isolate this _Func from parent cancellation if the parent has a different token or no token.

Enviarsend

Uma operação de envio síncrona, que aguarda até que o destino aceite ou recuse a mensagem.A synchronous send operation, which waits until the target either accepts or declines the message.

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

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

parâmetrosParameters

TT
O tipo de carga.The payload type.

_Trg_Trg
Um ponteiro ou referência ao destino para o qual os dados são enviados.A pointer or reference to the target to which data is sent.

_Data_Data
Uma referência aos dados a serem enviados.A reference to the data to be sent.

Valor RetornadoReturn Value

true se a mensagem foi aceita, false caso contrário.true if the message was accepted, false otherwise.

ComentáriosRemarks

Para obter mais informações, consulte funções de passagem de mensagens.For more information, see Message Passing Functions.

set_ambient_schedulerset_ambient_scheduler

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

parâmetrosParameters

_Scheduler_Scheduler
O Agendador de ambiente a ser definido.The ambient scheduler to set.

set_task_execution_resourcesset_task_execution_resources

Restringe os recursos de execução usados pelo Tempo de Execução de Simultaneidade threads de trabalho internos para o conjunto de afinidade especificado.Restricts the execution resources used by the Concurrency Runtime internal worker threads to the affinity set specified.

É válido chamar esse método somente antes de o Gerenciador de recursos ter sido criado ou entre dois tempos de vida do Gerenciador de recursos.It is valid to call this method only before the Resource Manager has been created, or between two Resource Manager lifetimes. Ele pode ser invocado várias vezes, desde que o Gerenciador de recursos não exista no momento da invocação.It can be invoked multiple times as long as the Resource Manager does not exist at the time of invocation. Depois que um limite de afinidade tiver sido definido, ele permanecerá em vigor até a próxima chamada válida para o set_task_execution_resources método.After an affinity limit has been set, it remains in effect until the next valid call to the set_task_execution_resources method.

A máscara de afinidade fornecida não precisa ser um subconjunto da máscara de afinidade de processo.The affinity mask provided need not be a subset of the process affinity mask. A afinidade de processo será atualizada, se necessário.The process affinity will be updated if necessary.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

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

parâmetrosParameters

_ProcessAffinityMask_ProcessAffinityMask
A máscara de afinidade à qual o Tempo de Execução de Simultaneidade threads de trabalho deve ser restringido.The affinity mask that the Concurrency Runtime worker threads are to be restricted to. Use esse método em um sistema com mais de 64 threads de hardware somente se você quiser limitar o Tempo de Execução de Simultaneidade a um subconjunto do grupo de processadores atual.Use this method on a system with greater than 64 hardware threads only if you want to limit the Concurrency Runtime to a subset of the current processor group. Em geral, você deve usar a versão do método que aceita uma matriz de afinidades de grupo como um parâmetro, para restringir a afinidade em máquinas com mais de 64 threads de hardware.In general, you should use the version of the method that accepts an array of group affinities as a parameter, to restrict affinity on machines with greater than 64 hardware threads.

contagemcount
O número de GROUP_AFFINITY entradas na matriz especificadas pelo parâmetro _PGroupAffinity .The number of GROUP_AFFINITY entries in the array specified by the parameter _PGroupAffinity.

_PGroupAffinity_PGroupAffinity
Uma matriz de GROUP_AFFINITY entradas.An array of GROUP_AFFINITY entries.

ComentáriosRemarks

O método lançará uma exceção de invalid_operation se um Gerenciador de recursos estiver presente no momento em que for invocado, e uma exceção de invalid_argument se a afinidade especificada resultar em um conjunto vazio de recursos.The method will throw an invalid_operation exception if a Resource Manager is present at the time it is invoked, and an invalid_argument exception if the affinity specified results in an empty set of resources.

A versão do método que usa uma matriz de afinidades de grupo como um parâmetro só deve ser usada em sistemas operacionais com a versão Windows 7 ou superior.The version of the method that takes an array of group affinities as a parameter should only be used on operating systems with version Windows 7 or higher. Caso contrário, uma exceção de invalid_operation será lançada.Otherwise, an invalid_operation exception is thrown.

Modificar programaticamente a afinidade do processo após esse método ter sido invocado não fará com que o Gerenciador de recursos reavalie a afinidade à qual ele está restrito.Programmatically modifying the process affinity after this method has been invoked will not cause the Resource Manager to re-evaluate the affinity it is restricted to. Portanto, todas as alterações na afinidade de processo devem ser feitas antes de chamar esse método.Therefore, all changes to process affinity should be made before calling this method.

permutaswap

Troca os elementos de dois objetos concurrent_vector.Exchanges the elements of two concurrent_vector objects.

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

parâmetrosParameters

TT
O tipo de dados dos elementos armazenados nos vetores simultâneos.The data type of the elements stored in the concurrent vectors.

_Ax_Ax
O tipo de alocador dos vetores simultâneos.The allocator type of the concurrent vectors.

_A_A
O vetor simultâneo cujos elementos devem ser trocados por aqueles do vetor simultâneo _B .The concurrent vector whose elements are to be exchanged with those of the concurrent vector _B.

_B_B
O vetor simultâneo que fornece os elementos a serem trocados ou o vetor cujos elementos devem ser trocados com aqueles do vetor simultâneo _A .The concurrent vector providing the elements to be swapped, or the vector whose elements are to be exchanged with those of the concurrent vector _A.

ComentáriosRemarks

A função de modelo é um algoritmo especializado na classe de contêiner concurrent_vector para executar a função de membro _A .The template function is an algorithm specialized on the container class concurrent_vector to execute the member function _A. concurrent_vector:: swap( _B ).concurrent_vector::swap( _B). Essas são instâncias de ordenação parcial de modelos de função pelo compilador.These are instances of the partial ordering of function templates by the compiler. Quando as funções de modelo são sobrecarregadas de forma que a correspondência do modelo com a chamada de função não é exclusiva, o compilador seleciona a versão mais especializada do modelo de função.When template functions are overloaded in such a way that the match of the template with the function call is not unique, then the compiler will select the most specialized version of the template function. A versão geral da função de modelo, template <class T> void swap(T&, T&) , na classe de algoritmo, funciona por atribuição e é uma operação lenta.The general version of the template function, template <class T> void swap(T&, T&), in the algorithm class works by assignment and is a slow operation. A versão especializada em cada contêiner é muito mais rápida, uma vez que ela pode funcionar com a representação interna da classe de contêiner.The specialized version in each container is much faster as it can work with the internal representation of the container class.

Esse método não é seguro para simultaneidade.This method is not concurrency-safe. Você deve garantir que nenhum outro thread esteja executando operações em qualquer um dos vetores simultâneos ao chamar esse método.You must ensure that no other threads are performing operations on either of the concurrent vectors when you call this method.

task_from_exceptiontask_from_exception

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

parâmetrosParameters

_TaskType_TaskType

_ExType_ExType

_Exception_Exception

_TaskOptions_TaskOptions

Valor RetornadoReturn Value

task_from_resulttask_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âmetrosParameters

TT

_Param_Param

_TaskOptions_TaskOptions

Valor RetornadoReturn Value

Trace_agents_register_nameTrace_agents_register_name

Associa o nome fornecido ao bloco de mensagens ou ao agente no rastreamento ETW.Associates the given name to the message block or agent in the ETW trace.

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

parâmetrosParameters

TT
O tipo do objeto.The type of the object. Normalmente, esse é um bloco de mensagem ou um agente.This is typically a message block or an agent.

_PObject_PObject
Um ponteiro para o bloco de mensagens ou agente que está sendo nomeado no rastreamento.A pointer to the message block or agent that is being named in the trace.

_Name_Name
O nome do objeto fornecido.The name for the given object.

try_receivetry_receive

Uma implementação geral de teste de recebimento, permitindo que um contexto Procure dados de exatamente uma fonte e filtre os valores que são aceitos.A general try-receive implementation, allowing a context to look for data from exactly one source and filter the values that are accepted. Se os dados não estiverem prontos, o método retornará false .If the data is not ready, the method will return 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âmetrosParameters

TT
O tipo de cargaThe payload type

_Src_Src
Um ponteiro ou referência à fonte da qual os dados são esperados.A pointer or reference to the source from which data is expected.

_value_value
Uma referência a um local onde o resultado será colocado.A reference to a location where the result will be placed.

_Filter_proc_Filter_proc
Uma função de filtro que determina se as mensagens devem ser aceitas.A filter function which determines whether messages should be accepted.

Valor RetornadoReturn Value

Um bool valor que indica se uma carga foi colocada ou não _value .A bool value indicating whether or not a payload was placed in _value.

ComentáriosRemarks

Para obter mais informações, consulte funções de passagem de mensagens.For more information, see Message Passing Functions.

esperadowait

Pausa o contexto atual por um período de tempo especificado.Pauses the current context for a specified amount of time.

void __cdecl wait(unsigned int _Milliseconds);

parâmetrosParameters

_Milliseconds_Milliseconds
O número de milissegundos para o qual o contexto atual deve ser pausado.The number of milliseconds the current context should be paused for. Se o _Milliseconds parâmetro for definido como o valor 0 , o contexto atual deverá gerar a execução para outros contextos executáveis antes de continuar.If the _Milliseconds parameter is set to the value 0, the current context should yield execution to other runnable contexts before continuing.

ComentáriosRemarks

Se esse método for chamado em um Tempo de Execução de Simultaneidade contexto do Agendador, o Agendador encontrará um contexto diferente para ser executado no recurso subjacente.If this method is called on a Concurrency Runtime scheduler context, the scheduler will find a different context to run on the underlying resource. Como o Agendador é cooperativo por natureza, esse contexto não pode continuar exatamente após o número de milissegundos especificado.Because the scheduler is cooperative in nature, this context cannot resume exactly after the number of milliseconds specified. Se o Agendador estiver ocupado executando outras tarefas que não geram um rendimento cooperativo para o Agendador, o período de espera poderá ser indefinido.If the scheduler is busy executing other tasks that do not cooperatively yield to the scheduler, the wait period could be indefinite.

when_allwhen_all

Cria uma tarefa que será concluída com êxito quando todas as tarefas fornecidas como argumentos forem concluídas com êxito.Creates a task that will complete successfully when all of the tasks supplied as arguments complete successfully.

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âmetrosParameters

_Iterator_Iterator
O tipo do iterador de entrada.The type of the input iterator.

_Begin_Begin
A posição do primeiro elemento no intervalo de elementos a ser combinada na tarefa resultante.The position of the first element in the range of elements to be combined into the resulting task.

_End_End
A posição do primeiro elemento além do intervalo de elementos a ser combinada na tarefa resultante.The position of the first element beyond the range of elements to be combined into the resulting task.

_TaskOptions_TaskOptions
O objeto task_options.The task_options object.

Valor RetornadoReturn Value

Uma tarefa que é concluída com êxito quando todas as tarefas de entrada foram concluídas com êxito.A task that completes successfully when all of the input tasks have completed successfully. Se as tarefas de entrada forem do tipo T, a saída dessa função será um task<std::vector<T>>.If the input tasks are of type T, the output of this function will be a task<std::vector<T>>. Se as tarefas de entrada forem do tipo void , a tarefa de saída também será um task<void> .If the input tasks are of type void the output task will also be a task<void>.

ComentáriosRemarks

when_all é uma função sem bloqueio que produz a task como resultado.when_all is a non-blocking function that produces a task as its result. Ao contrário da tarefa:: Wait, é seguro chamar essa função em um aplicativo UWP no thread Asta (Application STA).Unlike task::wait, it is safe to call this function in a UWP app on the ASTA (Application STA) thread.

Se uma das tarefas for cancelada ou lançar uma exceção, a tarefa retornada será concluída antecipadamente, no estado cancelado, e a exceção, se ocorrer, será gerada se você chamar Task:: Get ou task::wait nessa tarefa.If one of the tasks is canceled or throws an exception, the returned task will complete early, in the canceled state, and the exception, if one occurs, will be thrown if you call task::get or task::wait on that task.

Para obter mais informações, consulte paralelismo de tarefas.For more information, see Task Parallelism.

when_anywhen_any

Cria uma tarefa que será concluída com êxito quando todas as tarefas fornecidas como argumentos forem concluídas com êxito.Creates a task that will complete successfully when any of the tasks supplied as arguments completes successfully.

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âmetrosParameters

_Iterator_Iterator
O tipo do iterador de entrada.The type of the input iterator.

_Begin_Begin
A posição do primeiro elemento no intervalo de elementos a ser combinada na tarefa resultante.The position of the first element in the range of elements to be combined into the resulting task.

_End_End
A posição do primeiro elemento além do intervalo de elementos a ser combinada na tarefa resultante.The position of the first element beyond the range of elements to be combined into the resulting task.

_TaskOptions_TaskOptions
_CancellationToken_CancellationToken
O token de cancelamento que controla o cancelamento da tarefa retornada.The cancellation token which controls cancellation of the returned task. Se você não fornecer um token de cancelamento, a tarefa resultante receberá o token de cancelamento da tarefa que fez com que ela fosse concluída.If you do not provide a cancellation token, the resulting task will receive the cancellation token of the task that causes it to complete.

Valor RetornadoReturn Value

Uma tarefa que foi concluída com êxito quando alguma das tarefas de entrada foi concluída com êxito.A task that completes successfully when any one of the input tasks has completed successfully. Se as tarefas de entrada forem do tipo T, a saída dessa função será um task<std::pair<T, size_t>>>, em que o primeiro elemento do par é o resultado da conclusão da tarefa e o segundo elemento é o índice da tarefa que foi concluída.If the input tasks are of type T, the output of this function will be a task<std::pair<T, size_t>>>, where the first element of the pair is the result of the completing task, and the second element is the index of the task that finished. Se as tarefas de entrada forem do tipo void , a saída será a task<size_t> , em que o resultado é o índice da tarefa de conclusão.If the input tasks are of type void the output is a task<size_t>, where the result is the index of the completing task.

ComentáriosRemarks

when_any é uma função sem bloqueio que produz a task como resultado.when_any is a non-blocking function that produces a task as its result. Ao contrário da tarefa:: Wait, é seguro chamar essa função em um aplicativo UWP no thread Asta (Application STA).Unlike task::wait, it is safe to call this function in a UWP app on the ASTA (Application STA) thread.

Para obter mais informações, consulte paralelismo de tarefas.For more information, see Task Parallelism.

Confira tambémSee also

Namespace de simultaneidadeconcurrency Namespace