funções de namespace de simultaneidade

Alloc

Aloca um bloco de memória do tamanho especificado do Subalocador de Cache de Tempo de Execução de Simultaneidade.

void* __cdecl Alloc(size_t _NumBytes);

Parâmetros

_NumBytes
O número de bytes de memória a alocar.

Valor de retorno

Um ponteiro para a memória recém-alocada.

Comentários

Para obter mais informações sobre quais cenários em seu aplicativo poderiam se beneficiar do uso do Subalocador de Cache, consulte Agendador de Tarefas.

Asend

Uma operação de envio assíncrona, que agenda uma tarefa para propagar os dados para o bloco de destino.

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

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

Parâmetros

T
O tipo de dados a serem enviados.

_Trg
Um ponteiro ou referência ao destino para o qual os dados são enviados.

_Data
Uma referência aos dados a enviar.

Valor de retorno

true se a mensagem foi aceita antes do método retornar, false de outra forma.

Comentários

Para obter mais informações, consulte Message Passing Functions.

cancel_current_task

Cancela a tarefa em execução no momento. Essa função pode ser chamada de dentro do corpo de uma tarefa para abortar a execução da tarefa e fazer com que ela entre no estado canceled.

Não é um cenário suportado chamar essa função se você não estiver dentro do corpo de um task. Isso resultará em um comportamento indefinido, como uma falha ou falta de resposta em seu aplicativo.

inline __declspec(noreturn) void __cdecl cancel_current_task();

desmarcar

Limpa a fila simultânea, destruindo todos os elementos atualmente enfileirados. Este método não é seguro para simultaneidade.

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

Parâmetros

_Ax

create_async

Cria uma construção assíncrona do Tempo de Execução do Windows com base em um objeto lambda ou de função fornecido pelo usuário. O tipo de retorno de create_async é um dos IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^ou IAsyncOperationWithProgress<TResult, TProgress>^ com base na assinatura do lambda passado para o método.

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

Parâmetros

_Function
Digite.

_Func
O objeto lambda ou função a partir do qual criar uma construção assíncrona do Tempo de Execução do Windows.

Valor de retorno

Uma construção assíncrona representada por um IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^, ou um IAsyncOperationWithProgress<TResult, TProgress>^. A interface retornada depende da assinatura do lambda passado para a função.

Comentários

O tipo de retorno do lambda determina se a construção é uma ação ou uma operação.

Lambdas que retornam vazio causam a criação de ações. Lambdas que retornam um resultado do tipo TResult causam a criação de operações de TResult.

O lambda também pode retornar um task<TResult> que encapsula o trabalho assíncrono dentro de si mesmo ou é a continuação de uma cadeia de tarefas que representam o trabalho assíncrono. Nesse caso, o lambda em si é executado em linha, uma vez que as tarefas são executadas de forma assíncrona, e o tipo de retorno do lambda é desempacotado para produzir a construção assíncrona retornada por create_async. Isso implica que um lambda que retorna uma tarefa<> nulo causará a criação de ações, e um lambda que retorna uma tarefa<> TResult causará a criação de operações de TResult.

A lambda pode ter zero, um ou dois argumentos. Os argumentos válidos são progress_reporter<TProgress> e cancellation_token, nessa ordem, se ambos forem usados. Um lambda sem argumentos causa a criação de uma construção assíncrona sem a capacidade de relatório de progresso. Um lambda que usa um< progress_reporter>TProgress fará com que create_async retorne uma construção assíncrona que relata o progresso do tipo TProgress cada vez que o método report do objeto progress_reporter é chamado. Um lambda que leva 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 cancelamento dessas tarefas.

Se o corpo do objeto lambda ou function retornar um resultado (e não uma tarefa<TResult>), o lambda será executado de forma assíncrona dentro do MTA do processo no contexto de uma tarefa que o Runtime cria implicitamente para ele. O método IAsyncInfo::Cancel causará o cancelamento da tarefa implícita.

Se o corpo do lambda retornar uma tarefa, o lambda será executado embutido e, ao declarar o lambda para usar um argumento do tipo cancellation_token , você poderá acionar o cancelamento de quaisquer tarefas criadas dentro do lambda passando esse token ao criá-las. Você também pode usar o método register_callback no token para fazer com que o Runtime invoque um retorno de chamada quando você chamar IAsyncInfo::Cancel na operação assíncrona ou ação produzida.

Essa função só está disponível para aplicativos do Tempo de Execução do Windows.

CreateResourceManager

Retorna uma interface que representa a instância singleton do Gerenciador de Recursos do Concurrency Runtime. O Resource Manager é responsável por atribuir recursos a programadores que desejam cooperar entre si.

IResourceManager* __cdecl CreateResourceManager();

Valor de retorno

Uma interface IResourceManager.

Comentários

Várias chamadas subsequentes para esse método retornarão a mesma instância do Gerenciador de Recursos. 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.

unsupported_os é lançado se o sistema operacional não for suportado pelo Concurrency Runtime.

create_task

Cria uma tarefa PPL objeto. create_task pode ser usado em qualquer lugar que você teria usado um construtor de tarefas. É fornecido principalmente por conveniência, porque permite o uso da palavra-chave auto durante a criação de tarefas.

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

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

Parâmetros

T
O tipo do parâmetro a partir do qual a tarefa deve ser construída.

_ReturnType
Digite.

_Param
O parâmetro a partir do qual a tarefa deve ser construída. Pode ser um objeto lambda ou de função, um objeto task_completion_event, um objeto task diferente ou uma interface Windows::Foundation::IAsyncInfo se você estiver usando tarefas em seu aplicativo UWP.

_TaskOptions
As opções de tarefa.

_Task
A tarefa de criar.

Valor de retorno

Uma nova tarefa do tipo T, que é inferida a partir de _Param.

Comentários

A primeira sobrecarga se comporta como um construtor de tarefas que usa um único parâmetro.

A segunda sobrecarga associa o token de cancelamento fornecido com a tarefa recém-criada. Se você usar essa sobrecarga, não terá permissão para passar um objeto task diferente como o primeiro parâmetro.

O tipo da tarefa retornada é inferido do primeiro parâmetro para a função. Se _Param for um task_completion_event<T>, um task<T>ou um functor que retorna o tipo T ou task<T>, o tipo da tarefa criada é 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 retorne qualquer um desses tipos, a tarefa criada será do tipo task<T>. Se _Param for do tipo Windows::Foundation::IAsyncAction^ ou Windows::Foundation::IAsyncActionWithProgress<P>^, ou um functor que retorne qualquer um desses tipos, a tarefa criada terá o tipo task<void>.

DesativaçãoRastreamento

Desabilita o rastreamento no Concurrency Runtime. Esta função foi preterida porque o rastreamento ETW não é registrado por padrão.

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

Valor de retorno

Se o rastreamento foi desativado corretamente, S_OK será retornado. Se o rastreamento não tiver sido iniciado anteriormente, E_NOT_STARTED será retornado

EnableTracing

Permite o rastreamento no Concurrency Runtime. Essa função foi preterida porque o rastreamento ETW agora está ativado por padrão.

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

Valor de retorno

Se o rastreamento foi iniciado corretamente, S_OK é retornado; caso contrário, E_NOT_STARTED será retornado.

Gratuito

Libera um bloco de memória previamente alocado pelo método Alloc para o Subalocador de Cache de Tempo de Execução de Simultaneidade.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

Parâmetros

_PAllocation
Um ponteiro para a memória previamente alocada pelo método Alloc que deve ser liberado. Se o parâmetro _PAllocation estiver definido para o valor NULL, esse método irá ignorá-lo e retornar imediatamente.

Comentários

Para obter mais informações sobre quais cenários em seu aplicativo poderiam se beneficiar do uso do Subalocador de Cache, consulte Agendador de Tarefas.

get_ambient_scheduler

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

Valor de retorno

GetExecutionContextId

Retorna um identificador exclusivo que pode ser atribuído a um contexto de execução que implementa a interface IExecutionContext.

unsigned int __cdecl GetExecutionContextId();

Valor de retorno

Um identificador exclusivo para um contexto de execução.

Comentários

Use esse método para obter um identificador para seu contexto de execução antes de passar uma interface IExecutionContext como parâmetro para qualquer um dos métodos oferecidos pelo Gerenciador de Recursos.

GetOSVersion

Retorna a versão do sistema operacional.

IResourceManager::OSVersion __cdecl GetOSVersion();

Valor de retorno

Um valor enumerado que representa o sistema operacional.

Comentários

unsupported_os é lançado se o sistema operacional não for suportado pelo Concurrency Runtime.

GetProcessorCount

Retorna o número de threads de hardware no sistema subjacente.

unsigned int __cdecl GetProcessorCount();

Valor de retorno

O número de threads de hardware.

Comentários

unsupported_os é lançado se o sistema operacional não for suportado pelo Concurrency Runtime.

GetProcessorNodeCount

Retorna o número de nós NUMA ou pacotes de processador no sistema subjacente.

unsigned int __cdecl GetProcessorNodeCount();

Valor de retorno

O número de nós NUMA ou pacotes de processador.

Comentários

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.

unsupported_os é lançado se o sistema operacional não for suportado pelo Concurrency Runtime.

GetSchedulerId

Retorna um identificador exclusivo que pode ser atribuído a um agendador que implementa a interface IScheduler.

unsigned int __cdecl GetSchedulerId();

Valor de retorno

Um identificador exclusivo para um agendador.

Comentários

Use esse método para obter um identificador para seu agendador antes de passar uma interface IScheduler como um parâmetro para qualquer um dos métodos oferecidos pelo Gerenciador de Recursos.

internal_assign_iterators

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

Parâmetros

_Ax

_Eu

primeira

últimos

interruption_point

Cria um ponto de interrupção para cancelamento. Se um cancelamento estiver em andamento no contexto em que essa função é chamada, isso lançará uma exceção interna que abortará a execução do trabalho paralelo em execução no momento. Se o cancelamento não estiver em andamento, a função não faz nada.

inline void interruption_point();

Comentários

Você não deve pegar a exceção de cancelamento interno lançada pela função interruption_point(). A exceção será capturada e tratada pelo tempo de execução, e capturá-la pode fazer com que seu programa se comporte de forma anormal.

is_current_task_group_canceling

Retorna uma indicação se o grupo de tarefas que está sendo executado atualmente em linha no contexto atual está no meio de um cancelamento ativo (ou estará em breve). Observe que, se não houver nenhum grupo de tarefas atualmente em execução inline no contexto atual, false será retornado.

bool __cdecl is_current_task_group_canceling();

Valor de retorno

true se o grupo de tarefas que está sendo executado no momento estiver cancelando, false caso contrário.

Comentários

Para obter mais informações, consulte Cancelamento.

make_choice

Constrói um bloco de mensagens choice a partir de um Scheduler ou ScheduleGroup opcional e duas ou mais fontes de entrada.

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

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

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

Parâmetros

T1
O tipo de bloco de mensagem da primeira fonte.

T2
O tipo de bloco de mensagem da segunda fonte.

_PScheduler
O Scheduler objeto dentro do qual a tarefa de propagação para o bloco de mensagens choice está agendada.

_Item1
A primeira fonte.

_Item2
A segunda fonte.

_Items
Fontes adicionais.

_PScheduleGroup
O ScheduleGroup objeto dentro do qual a tarefa de propagação para o bloco de mensagens choice está agendada. O objeto Scheduler usado é implícito pelo grupo de agenda.

Valor de retorno

Um bloco de mensagem choice com duas ou mais fontes de entrada.

make_greedy_join

Constrói um bloco de mensagens greedy multitype_join a partir de um Scheduler ou ScheduleGroup opcional e duas ou mais fontes de entrada.

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

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

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

Parâmetros

T1
O tipo de bloco de mensagem da primeira fonte.

T2
O tipo de bloco de mensagem da segunda fonte.

_PScheduler
O Scheduler objeto dentro do qual a tarefa de propagação para o bloco de mensagens multitype_join está agendada.

_Item1
A primeira fonte.

_Item2
A segunda fonte.

_Items
Fontes adicionais.

_PScheduleGroup
O ScheduleGroup objeto dentro do qual a tarefa de propagação para o bloco de mensagens multitype_join está agendada. O objeto Scheduler usado é implícito pelo grupo de agenda.

Valor de retorno

Um bloco de mensagem greedy multitype_join com duas ou mais fontes de entrada.

make_join

Constrói um bloco de mensagens non_greedy multitype_join a partir de um Scheduler ou ScheduleGroup opcional e duas ou mais fontes de entrada.

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

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

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

Parâmetros

T1
O tipo de bloco de mensagem da primeira fonte.

T2
O tipo de bloco de mensagem da segunda fonte.

_PScheduler
O Scheduler objeto dentro do qual a tarefa de propagação para o bloco de mensagens multitype_join está agendada.

_Item1
A primeira fonte.

_Item2
A segunda fonte.

_Items
Fontes adicionais.

Valor de retorno

Um bloco de mensagem non_greedy multitype_join com duas ou mais fontes de entrada.

make_task

Um método de fábrica para criar um objeto task_handle.

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

Parâmetros

_Function
O tipo do objeto de função que será invocado para executar o trabalho representado pelo objeto task_handle.

_Func
A função que será invocada para executar o trabalho representado pelo objeto task_handle. Pode ser um functor lambda, um ponteiro para uma função ou qualquer objeto que suporte uma versão do operador de chamada de função com a assinatura void operator()().

Valor de retorno

Um objeto task_handle.

Comentários

Essa função é útil quando você precisa criar um objeto task_handle com uma expressão lambda, porque permite que você crie o objeto sem saber o tipo verdadeiro do functor lambda.

parallel_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. Esta função é semanticamente semelhante à std::sort na medida em que é uma classificação in-loco baseada em comparação, instável, exceto que precisa de O(n) espaço adicional e requer inicialização padrão para os elementos que estão sendo classificados.

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

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

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

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

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

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

Parâmetros

_Random_iterator
O tipo de iterador do intervalo de entrada.

_Allocator
O tipo de um alocador de memória compatível com C++ Standard Library.

_Function
O tipo do comparador binário.

_Begin
Um iterador de acesso aleatório abordando a posição do primeiro elemento no intervalo a ser classificado.

_End
Um iterador de acesso aleatório abordando a posição um após o elemento final no intervalo a ser classificado.

_Alloc
Uma instância de um alocador de memória compatível com C++ Standard Library.

_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. Um predicado binário usa dois argumentos e retorna true quando satisfeito e false quando não satisfeito. Esta função de comparação deve impor uma ordenação fraca estrita aos pares de elementos da sequência.

_Chunk_size
O tamanho mimimum de um pedaço que será dividido em dois para execução paralela.

Comentários

Todas as sobrecargas requerem n * sizeof(T) espaço adicional, onde n é o número de elementos a serem classificados e T é o tipo de elemento. Na maioria dos casos, parallel_buffered_sort mostrará uma melhoria no desempenho ao longo parallel_sort, e você deve usá-lo ao longo parallel_sort se tiver a memória disponível.

Se você não fornecer um comparador binário, std::less será usado como padrão, o que requer que o tipo de elemento forneça ao operador operator<().

Se você não fornecer um tipo de alocador ou instância, o alocador de memória C++ Standard Library std::allocator<T> é usado para alocar o buffer.

O algoritmo divide o intervalo de entrada em dois blocos e divide sucessivamente cada bloco em dois subblocos para execução em paralelo. O argumento opcional _Chunk_size pode ser usado para indicar ao algoritmo que ele deve lidar com pedaços de tamanho <_Chunk_size em série.

parallel_for

parallel_for itera em uma variedade de índices e executa uma função fornecida pelo usuário em cada iteração, em paralelo.

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

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

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

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

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

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

Parâmetros

_Index_type
O tipo de índice que está sendo usado para a iteração.

_Function
O tipo de função que será executada em cada iteração.

_Partitioner
O tipo do particionador que é usado para particionar o intervalo fornecido.

primeira
O primeiro índice a ser incluído na iteração.

últimos
O índice um após o último índice a ser incluído na iteração.

_Step
O valor pelo qual passar ao iterar de first para last. O passo tem de ser positivo. invalid_argument é lançado se o passo for inferior a 1.

_Func
A função a ser executada em cada iteração. 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).

_Part
Uma referência ao objeto particionador. O argumento pode ser um dos constauto_partitioner&, conststatic_partitioner&, constsimple_partitioner& ou affinity_partitioner& Se um objeto affinity_partitioner for usado, a referência deve ser uma referência de valor l não const, para que o algoritmo possa armazenar estado para loops futuros reutilizarem.

Comentários

Para obter mais informações, consulte Parallel Algorithms.

parallel_for_each

parallel_for_each aplica uma função especificada a cada elemento dentro de um intervalo, em paralelo. É semanticamente equivalente à função for_each no namespace std, exceto que a iteração sobre os elementos é executada em paralelo e a ordem de iteração não é especificada. O argumento _Func deve suportar um operador de chamada de função do formulário operator()(T) onde o parâmetro T é o tipo de item do contêiner que está sendo iterado.

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

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

Parâmetros

_Iterator
O tipo do iterador que está sendo usado para iterar sobre o contêiner.

_Function
O tipo de função que será aplicada a cada elemento dentro do intervalo.

_Partitioner
primeira
Um iterador abordando a posição do primeiro elemento a ser incluído na iteração paralela.

últimos
Um iterador abordando a posição um após o elemento final a ser incluído na iteração paralela.

_Func
Um objeto de função definido pelo usuário que é aplicado a cada elemento no intervalo.

Comentários

auto_partitioner serão usados para a sobrecarga sem um particionador explícito.

Para iteradores que não suportam acesso aleatório, apenas auto_partitioner é suportado.

Para obter mais informações, consulte Parallel Algorithms.

parallel_invoke

Executa os objetos de função fornecidos como parâmetros em paralelo e bloqueia até que tenham terminado a execução. Cada objeto de função pode ser uma expressão lambda, um ponteiro para função ou qualquer objeto que suporte o operador de chamada de função com a assinatura void operator()().

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

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

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

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

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

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7,
    typename _Function8>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7,
    const _Function8& _Func8);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7,
    typename _Function8,
    typename _Function9>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7,
    const _Function8& _Func8,
    const _Function9& _Func9);

template <typename _Function1,
    typename _Function2,
    typename _Function3,
    typename _Function4,
    typename _Function5,
    typename _Function6,
    typename _Function7,
    typename _Function8,
    typename _Function9,
    typename _Function10>
void parallel_invoke(
    const _Function1& _Func1,
    const _Function2& _Func2,
    const _Function3& _Func3,
    const _Function4& _Func4,
    const _Function5& _Func5,
    const _Function6& _Func6,
    const _Function7& _Func7,
    const _Function8& _Func8,
    const _Function9& _Func9,
    const _Function10& _Func10);

Parâmetros

_Function1
O tipo do primeiro objeto de função a ser executado em paralelo.

_Function2
O tipo do segundo objeto de função a ser executado em paralelo.

_Function3
O tipo do terceiro objeto de função a ser executado em paralelo.

_Function4
O tipo do quarto objeto de função a ser executado em paralelo.

_Function5
O tipo do quinto objeto de função a ser executado em paralelo.

_Function6
O tipo do sexto objeto de função a ser executado em paralelo.

_Function7
O tipo do sétimo objeto de função a ser executado em paralelo.

_Function8
O tipo do objeto da oitava função a ser executado em paralelo.

_Function9
O tipo do nono objeto de função a ser executado em paralelo.

_Function10
O tipo do décimo objeto de função a ser executado em paralelo.

_Func1
O primeiro objeto de função a ser executado em paralelo.

_Func2
O segundo objeto de função a ser executado em paralelo.

_Func3
O terceiro objeto de função a ser executado em paralelo.

_Func4
O quarto objeto de função a ser executado em paralelo.

_Func5
O quinto objeto de função a ser executado em paralelo.

_Func6
O sexto objeto de função a ser executado em paralelo.

_Func7
O sétimo objeto de função a ser executado em paralelo.

_Func8
O oitavo objeto de função a ser executado em paralelo.

_Func9
O nono objeto de função a ser executado em paralelo.

_Func10
O décimo objeto de função a ser executado em paralelo.

Comentários

Observe que um ou mais dos objetos de função fornecidos como parâmetros podem ser executados em linha no contexto de chamada.

Se um ou mais dos objetos de função passados como parâmetros para essa função lançarem uma exceção, o tempo de execução selecionará uma dessas exceções de sua escolha e a propagará para fora da chamada para parallel_invoke.

Para obter mais informações, consulte Parallel Algorithms.

parallel_radixsort

Organiza elementos em um intervalo especificado em uma ordem não decrescente usando um algoritmo de classificação radix. Esta é 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 inteiras não assinadas. A inicialização padrão é necessária para os elementos que estão sendo classificados.

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

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

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

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

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

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

Parâmetros

_Random_iterator
O tipo de iterador do intervalo de entrada.

_Allocator
O tipo de um alocador de memória compatível com C++ Standard Library.

_Function
O tipo da função de projeção.

_Begin
Um iterador de acesso aleatório abordando a posição do primeiro elemento no intervalo a ser classificado.

_End
Um iterador de acesso aleatório abordando a posição um após o elemento final no intervalo a ser classificado.

_Alloc
Uma instância de um alocador de memória compatível com C++ Standard Library.

_Proj_func
Um objeto de função de projeção definido pelo usuário que converte um elemento em um valor integral.

_Chunk_size
O tamanho mimimum de um pedaço que será dividido em dois para execução paralela.

Comentários

Todas as sobrecargas requerem n * sizeof(T) espaço adicional, onde n é o número de elementos a serem classificados e T é o tipo de elemento. Um functor de projeção unária com o I _Proj_func(T) de assinatura é necessário para retornar uma chave quando recebe um elemento , onde T é o tipo de elemento e I é um tipo inteiro não assinado.

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. A função falhará ao compilar se o elemento não for um tipo integral na ausência de uma função de projeção.

Se você não fornecer um tipo de alocador ou instância, o alocador de memória C++ Standard Library std::allocator<T> é usado para alocar o buffer.

parallel_reduce

Calcula a soma de todos os elementos em um intervalo especificado calculando somas parciais sucessivas, ou calcula o resultado de resultados parciais sucessivos obtidos de forma semelhante usando uma operação binária especificada diferente da soma, em paralelo. parallel_reduce é semanticamente semelhante a std::accumulate, exceto que requer que a operação binária seja associativa e requer um valor de identidade em vez de um valor inicial.

template<typename _Forward_iterator>
inline typename std::iterator_traits<_Forward_iterator>::value_type parallel_reduce(
    _Forward_iterator _Begin,
    _Forward_iterator _End,
    const typename std::iterator_traits<_Forward_iterator>::value_type& _Identity);

template<typename _Forward_iterator, typename _Sym_reduce_fun>
inline typename std::iterator_traits<_Forward_iterator>::value_type parallel_reduce(
    _Forward_iterator _Begin,
    _Forward_iterator _End,
    const typename std::iterator_traits<_Forward_iterator>::value_type& _Identity,
    _Sym_reduce_fun _Sym_fun);

template<typename _Reduce_type,
    typename _Forward_iterator,
    typename _Range_reduce_fun,
    typename _Sym_reduce_fun>
inline _Reduce_type parallel_reduce(
    _Forward_iterator _Begin,
    _Forward_iterator _End,
    const _Reduce_type& _Identity,
    const _Range_reduce_fun& _Range_fun,
    const _Sym_reduce_fun& _Sym_fun);

Parâmetros

_Forward_iterator
O tipo iterador de intervalo de entrada.

_Sym_reduce_fun
O tipo da função de redução simétrica. Este deve ser um tipo de função com assinatura _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type), onde _Reduce_type é o mesmo que o tipo de identidade e o tipo de resultado da redução. Para a terceira sobrecarga, isso deve ser consistente com o tipo de saída de _Range_reduce_fun.

_Reduce_type
O tipo ao qual a entrada será reduzida, que pode ser diferente do tipo de elemento de entrada. O valor de retorno e o valor de identidade terão esse tipo.

_Range_reduce_fun
O tipo da função de redução de alcance. Este 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.

_Begin
Um iterador de entrada que aborda o primeiro elemento no intervalo a ser reduzido.

_End
Um iterador de entrada que aborda o elemento que está uma posição além do elemento final no intervalo a ser reduzido.

_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. Para a terceira sobrecarga, o valor de identidade deve ter o mesmo tipo que o tipo de resultado da redução, mas pode ser diferente do value_type do iterador. Deve ter um valor adequado de modo a que o operador de redução de intervalo _Range_fun, quando aplicado a um intervalo de um único elemento do tipo value_type e do valor de identidade, se comporte como um tipo do valor do tipo value_type para o tipo de identidade.

_Sym_fun
A função simétrica que será utilizada no segundo da redução. Consulte Comentários para obter mais informações.

_Range_fun
A função que será utilizada na primeira fase da redução. Consulte Comentários para obter mais informações.

Valor de retorno

O resultado da redução.

Comentários

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. A redução ocorre em duas fases, a primeira fase realiza uma redução dentro de cada bloco, e a segunda fase realiza uma redução entre os resultados parciais de cada bloco.

A primeira sobrecarga requer que o value_typedo iterador, T, seja o mesmo que o tipo de valor de identidade, bem como o tipo de resultado de redução. O tipo de elemento T deve fornecer ao operador T T::operator + (T) para reduzir elementos em cada bloco. O mesmo operador também é usado na segunda fase.

A segunda sobrecarga também requer que o value_type do iterador seja o mesmo que o tipo de valor de identidade, bem como o tipo de resultado de redução. 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.

Para a terceira sobrecarga, o tipo de valor de identidade deve ser o mesmo que o tipo de resultado de redução, mas o value_type do iterador pode ser diferente de ambos. 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 binária _Sym_reduce_fun é aplicada aos subresultados na segunda fase.

parallel_sort

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

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

Parâmetros

_Random_iterator
O tipo de iterador do intervalo de entrada.

_Function
O tipo do functor de comparação binária.

_Begin
Um iterador de acesso aleatório abordando a posição do primeiro elemento no intervalo a ser classificado.

_End
Um iterador de acesso aleatório abordando a posição um após o elemento final no intervalo a ser classificado.

_Chunk_size
O tamanho mínimo de um bloco que será dividido em dois para execução paralela.

Comentários

A primeira sobrecarga usa o comparador binário 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.

parallel_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. Esta função é semanticamente equivalente a std::transform.

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    const auto_partitioner& _Part = auto_partitioner());

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    const static_partitioner& _Part);

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    const simple_partitioner& _Part);

template <typename _Input_iterator1,
    typename _Output_iterator,
    typename _Unary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Output_iterator _Result,
    const _Unary_operator& _Unary_op,
    affinity_partitioner& _Part);

template <typename _Input_iterator1,
    typename _Input_iterator2,
    typename _Output_iterator,
    typename _Binary_operator,
    typename _Partitioner>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Input_iterator2
first2,
    _Output_iterator _Result,
    const _Binary_operator& _Binary_op,
    _Partitioner&& _Part);

template <typename _Input_iterator1,
    typename _Input_iterator2,
    typename _Output_iterator,
    typename _Binary_operator>
_Output_iterator parallel_transform(
    _Input_iterator1 first1,
    _Input_iterator1 last1,
    _Input_iterator2
first2,
    _Output_iterator _Result,
    const _Binary_operator& _Binary_op);

Parâmetros

_Input_iterator1
O tipo do primeiro ou único iterador de entrada.

_Output_iterator
O tipo do iterador de saída.

_Unary_operator
O tipo de functor unário a ser executado em cada elemento no intervalo de entrada.

_Input_iterator2
O tipo de segundo iterador de entrada.

_Binary_operator
O tipo do functor binário executado em pares em elementos dos dois intervalos de origem.

_Partitioner
primeiro1
Um iterador de entrada que aborda a posição do primeiro elemento no primeiro ou único intervalo de origem a ser operado.

última1
Um iterador de entrada que aborda a posição um após o elemento final no primeiro ou único intervalo de origem a ser operado.

_Result
Um iterador de saída que aborda a posição do primeiro elemento no intervalo de destino.

_Unary_op
Um objeto de função unária definido pelo usuário que é aplicado a cada elemento no intervalo de origem.

primeiro2
Um iterador de entrada que aborda a posição do primeiro elemento no segundo intervalo de fontes a ser operado.

_Binary_op
Um objeto de função binária definido pelo usuário que é aplicado em pares, em uma ordem de encaminhamento, aos dois intervalos de origem.

Valor de retorno

Um iterador de saída que aborda a posição um após o elemento final no intervalo de destino que está recebendo os elementos de saída transformados pelo objeto de função.

Comentários

auto_partitioner serão usados para as sobrecargas sem um argumento de particionador explícito.

Para iteradores que não suportam acesso aleatório, apenas auto_partitioner é suportado.

As sobrecargas que usam o argumento _Unary_op transformar o intervalo de entrada no intervalo de saída aplicando o functor unário a cada elemento no intervalo de entrada. _Unary_op deve suportar o operador de chamada de função com assinatura operator()(T) onde T é o tipo de valor do intervalo que está sendo iterado.

As sobrecargas que usam o argumento _Binary_op transformar dois intervalos de entrada no intervalo de saída aplicando o functor binário a um elemento do primeiro intervalo de entrada e a um elemento do segundo intervalo de entrada. _Binary_op deve suportar o operador de chamada de função com assinatura operator()(T, U) onde T, U são tipos de valor dos dois iteradores de entrada.

Para obter mais informações, consulte Parallel Algorithms.

receber

Uma implementação de recebimento geral, permitindo que um contexto aguarde dados de exatamente uma fonte e filtre os valores que são aceitos.

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

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

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

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

Parâmetros

T
O tipo de carga útil.

_Src
Um ponteiro ou referência à fonte a partir da qual os dados são esperados.

_Timeout
O tempo máximo para o qual o método deve para os dados, em milissegundos.

_Filter_proc
Uma função de filtro que determina se as mensagens devem ser aceites.

Valor de retorno

Um valor da origem, do tipo de carga útil.

Comentários

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 de tempo especificada expirar antes que uma mensagem seja recebida. Se você quiser um tempo limite de comprimento zero, você deve usar a função try_receive, em vez de chamar receive com um tempo limite de 0 (zero), pois é mais eficiente e não lança exceções em tempos limites.

Para obter mais informações, consulte Message Passing Functions.

run_with_cancellation_token

Executa um objeto de função de forma imediata e síncrona no contexto de um determinado token de cancelamento.

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

Parâmetros

_Function
O tipo do objeto de função que será invocado.

_Func
O objeto de função que será executado. Este objeto deve suportar o operador de chamada de função com uma assinatura de void(void).

_Ct
O token de cancelamento que controlará o cancelamento implícito do objeto de função. 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 sendo cancelado.

Comentários

Quaisquer pontos de interrupção no objeto de função serão acionados quando o cancellation_token for cancelado. O token explícito _Ct isolará esse _Func do cancelamento pai se o pai tiver um token diferente ou nenhum token.

enviar

Uma operação de envio síncrona, que aguarda até que o destino aceite ou recuse a mensagem.

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

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

Parâmetros

T
O tipo de carga útil.

_Trg
Um ponteiro ou referência ao destino para o qual os dados são enviados.

_Data
Uma referência aos dados a enviar.

Valor de retorno

true se a mensagem foi aceite, false de outra forma.

Comentários

Para obter mais informações, consulte Message Passing Functions.

set_ambient_scheduler

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

Parâmetros

_Scheduler
O agendador de ambiente a definir.

set_task_execution_resources

Restringe os recursos de execução usados pelos threads de trabalho internos do Concurrency Runtime ao conjunto de afinidade especificado.

É válido chamar esse método somente antes que o Resource Manager tenha sido criado ou entre dois tempos de vida do Resource Manager. Ele pode ser invocado várias vezes, desde que o Gerenciador de Recursos não exista no momento da invocação. Depois que um limite de afinidade for definido, ele permanecerá em vigor até a próxima chamada válida para o método set_task_execution_resources.

A máscara de afinidade fornecida não precisa ser um subconjunto da máscara de afinidade do processo. A afinidade do processo será atualizada se necessário.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

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

Parâmetros

_ProcessAffinityMask
A máscara de afinidade à qual os threads de trabalho do Concurrency Runtime devem ser restritos. Use esse método em um sistema com mais de 64 threads de hardware somente se quiser limitar o Concurrency Runtime a um subconjunto do grupo de processadores atual. Em geral, você deve usar a versão do método que aceita uma matriz de afinidades de grupo como parâmetro, para restringir a afinidade em máquinas com mais de 64 threads de hardware.

contagem
O número de entradas de GROUP_AFFINITY na matriz especificada pelo parâmetro _PGroupAffinity.

_PGroupAffinity
Uma matriz de GROUP_AFFINITY entradas.

Comentários

O método lançará uma exceção invalid_operation se um Resource Manager estiver presente no momento em que for invocado e uma exceção invalid_argument se a afinidade especificada resultar em um conjunto vazio de recursos.

A versão do método que usa uma matriz de afinidades de grupo como parâmetro só deve ser usada em sistemas operacionais com versão Windows 7 ou superior. Caso contrário, uma exceção invalid_operation é lançada.

Modificar programaticamente a afinidade do processo depois que esse método tiver sido invocado não fará com que o Gerenciador de Recursos reavalie a afinidade à qual está restrito. Portanto, todas as alterações na afinidade do processo devem ser feitas antes de chamar esse método.

permuta

Troca os elementos de dois objetos concurrent_vector.

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

Parâmetros

T
O tipo de dados dos elementos armazenados nos vetores simultâneos.

_Ax
O tipo de alocador dos vetores simultâneos.

_Um
O vetor concorrente cujos elementos devem ser trocados com os do vetor concorrente _B.

_B
O vetor simultâneo que fornece os elementos a serem trocados, ou o vetor cujos elementos devem ser trocados com os do vetor concorrente _A.

Comentários

A função de modelo é um algoritmo especializado na classe container concurrent_vector executar a função de membro _A. concurrent_vetor::swap(_B). Estas são instâncias da ordenação parcial de modelos de função pelo compilador. Quando as funções de modelo estão sobrecarregadas de tal forma que a correspondência do modelo com a chamada de função não é exclusiva, então o compilador selecionará a versão mais especializada da função de modelo. 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. A versão especializada em cada contêiner é muito mais rápida, pois pode trabalhar com a representação interna da classe de contêiner.

Este método não é seguro para simultaneidade. Você deve garantir que nenhum outro thread esteja executando operações em qualquer um dos vetores simultâneos quando você chamar esse método.

task_from_exception

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

Parâmetros

_TaskType

_ExType

_Exception

_TaskOptions

Valor de retorno

task_from_result

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

inline task<bool> task_from_result(ool _Param);

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

Parâmetros

_Param

_TaskOptions

Valor de retorno

Trace_agents_register_name

Associa o nome dado ao bloco de mensagem ou agente no rastreamento ETW.

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

Parâmetros

T
O tipo do objeto. Normalmente, trata-se de um bloco de mensagens ou de um agente.

_PObject
Um ponteiro para o bloco de mensagem ou agente que está sendo nomeado no rastreamento.

_Name
O nome do objeto fornecido.

try_receive

Uma implementação geral try-receive, permitindo que um contexto procure dados de exatamente uma fonte e filtre os valores que são aceitos. Se os dados não estiverem prontos, o método retornará false.

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

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

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

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

Parâmetros

T
O tipo de carga útil

_Src
Um ponteiro ou referência à fonte a partir da qual os dados são esperados.

_value
Uma referência a um local onde o resultado será colocado.

_Filter_proc
Uma função de filtro que determina se as mensagens devem ser aceites.

Valor de retorno

Um valor bool que indica se uma carga útil foi ou não colocada em _value.

Comentários

Para obter mais informações, consulte Message Passing Functions.

aguarde

Pausa o contexto atual por um período de tempo especificado.

void __cdecl wait(unsigned int _Milliseconds);

Parâmetros

_Milliseconds
O número de milissegundos para o qual o contexto atual deve ser pausado. Se o parâmetro _Milliseconds for definido como o valor 0, o contexto atual deverá produzir execução para outros contextos executáveis antes de continuar.

Comentários

Se esse método for chamado em um contexto de agendador de tempo de execução de simultaneidade, o agendador encontrará um contexto diferente para ser executado no recurso subjacente. Como o agendador é cooperativo por natureza, esse contexto não pode ser retomado exatamente após o número de milissegundos especificado. Se o agendador estiver ocupado executando outras tarefas que não cedem cooperativamente ao agendador, o período de espera pode ser indefinido.

when_all

Cria uma tarefa que será concluída com êxito quando todas as tarefas fornecidas como argumentos forem concluídas com êxito.

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

Parâmetros

_Iterator
O tipo do iterador de entrada.

_Begin
A posição do primeiro elemento na gama de elementos a serem combinados na tarefa resultante.

_End
A posição do primeiro elemento além do leque de elementos a serem combinados na tarefa resultante.

_TaskOptions
O objeto task_options.

Valor de retorno

Uma tarefa que é concluída com êxito quando todas as tarefas de entrada foram concluídas com êxito. Se as tarefas de entrada forem do tipo T, a saída desta função será um task<std::vector<T>>. Se as tarefas de entrada forem do tipo void a tarefa de saída também será um task<void>.

Comentários

when_all é uma função sem bloqueio que produz um task como resultado. Ao contrário task::wait, é seguro chamar essa função em um aplicativo UWP no thread ASTA (Application STA).

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á lançada se você chamar tarefa::obter ou task::wait nessa tarefa.

Para obter mais informações, consulte paralelismo de tarefas.

when_any

Cria uma tarefa que será concluída com êxito quando qualquer uma das tarefas fornecidas como argumentos for concluída com êxito.

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

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

Parâmetros

_Iterator
O tipo do iterador de entrada.

_Begin
A posição do primeiro elemento na gama de elementos a serem combinados na tarefa resultante.

_End
A posição do primeiro elemento além do leque de elementos a serem combinados na tarefa resultante.

_TaskOptions
_CancellationToken
O token de cancelamento que controla o cancelamento da tarefa retornada. Se você não fornecer um token de cancelamento, a tarefa resultante receberá o token de cancelamento da tarefa que faz com que ela seja concluída.

Valor de retorno

Uma tarefa que é concluída com êxito quando qualquer uma das tarefas de entrada é concluída com êxito. Se as tarefas de entrada forem do tipo T, a saída desta função será um task<std::pair<T, size_t>>>, onde o primeiro elemento do par é o resultado da tarefa concluída, e o segundo elemento é o índice da tarefa que terminou. Se as tarefas de entrada forem do tipo void a saída será um task<size_t>, onde o resultado é o índice da tarefa concluída.

Comentários

when_any é uma função sem bloqueio que produz um task como resultado. Ao contrário task::wait, é seguro chamar essa função em um aplicativo UWP no thread ASTA (Application STA).

Para obter mais informações, consulte paralelismo de tarefas.

Ver também

simultaneidade Namespace

Comentários

Esta página foi útil?

Last updated on 2025-11-07

Partilhar via

funções de namespace de simultaneidade

Alloc

Parâmetros

Valor de retorno

Comentários

Asend

Parâmetros

Valor de retorno

Comentários

cancel_current_task

desmarcar

Parâmetros

create_async

Parâmetros

Valor de retorno

Comentários

CreateResourceManager

Valor de retorno

Comentários

create_task

Parâmetros

Valor de retorno

Comentários

DesativaçãoRastreamento

Valor de retorno

EnableTracing

Valor de retorno

Gratuito

Parâmetros

Comentários

get_ambient_scheduler

Valor de retorno

GetExecutionContextId

Valor de retorno

Comentários

GetOSVersion

Valor de retorno

Comentários

GetProcessorCount

Valor de retorno

Comentários

GetProcessorNodeCount

Valor de retorno

Comentários

GetSchedulerId

Valor de retorno

Comentários

internal_assign_iterators

Parâmetros

interruption_point

Comentários

is_current_task_group_canceling

Valor de retorno

Comentários

make_choice

Parâmetros

Valor de retorno

make_greedy_join

Parâmetros

Valor de retorno

make_join

Parâmetros

Valor de retorno

make_task

Parâmetros

Valor de retorno

Comentários

parallel_buffered_sort

Parâmetros

Comentários

parallel_for

Parâmetros

Comentários

parallel_for_each

Parâmetros

Comentários

parallel_invoke

Parâmetros

Comentários