Funções do namespace de simultaneidade
Alloc
asend
cancel_current_task
clear
create_async
create_task
CreateResourceManager
DisableTracing
EnableTracing
Free
get_ambient_scheduler
GetExecutionContextId
GetOSVersion
GetProcessorCount
GetProcessorNodeCount
Alloc
Aloca um bloco de memória do tamanho especificado no Subalocador de Cache de Runtime de Simultaneidade.
void* __cdecl Alloc(size_t _NumBytes);
Parâmetros
_NumBytes
O número de bytes da memória a ser alocada.
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 podem se beneficiar do uso do Subalocador de Cache, consulte o 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 dos 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 serem enviados.
Valor de retorno
true se a mensagem foi aceita antes do método retornar, caso contrário, false.
Comentários
Para obter mais informações, consulte Funções de transmissão de mensagem.
cancel_current_task
Cancela a tarefa atualmente em execução. 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.
Não é um cenário com suporte para chamar essa função se você não estiver dentro do corpo de uma task. Isso resultará em um comportamento indefinido, tal como um travamento ou falta de resposta em seu aplicativo.
inline __declspec(noreturn) void __cdecl cancel_current_task();
clear
Limpa a fila simultânea, destruindo todos os elementos enfileirados no momento. Esse método não é seguro para simultaneidade.
template<typename T, class _Ax>
void concurrent_queue<T, _Ax>::clear();
Parâmetros
T
_Ax
create_async
Cria uma construção assíncrona de Windows Runtime com base em um objeto de função ou lambda fornecido pelo usuário. 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.
template<typename _Function>
__declspec(noinline) auto create_async(const _Function& _Func)
-> decltype(ref new details::_AsyncTaskGeneratorThunk<_Function>(_Func));
Parâmetros
_Function
Tipo.
_Func
O objeto de lambda ou função a partir do qual criar uma construção assíncrona de Windows Runtime.
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 de assinatura do lambda passada na 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 void causam a criação de ações. Lambdas que retornam um resultado do tipo TResult causam a criação de operações de 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. 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. Isso significa que um lambda que retorna uma tarefa <void> causará a criação de ações e um lambda que retorna uma tarefa <TResult> causará a criação de operações de TResult.
O lambda pode usar 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 causará a criação de uma construção assíncrona sem o recurso de relatório de andamento. Um lambda que usa um progress_reporter<TProgress> fará com que create_async retorne uma construção assíncrona que relata o andamento do tipo TProgress sempre que o método report do objeto progress_reporter for chamado. 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.
Se o corpo do objeto de lambda ou função retorna um resultado (e não uma tarefa <TResult>), o lamdba será executado de forma assíncrona dentro do MTA do processo no contexto de uma tarefa que o Tempo de execução cria implicitamente para ele. O método IAsyncInfo::Cancel causará o cancelamento da tarefa implícita.
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. 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.
Essa função só está disponível para aplicativos do Windows Runtime.
CreateResourceManager
Retorna uma interface que representa a instância singleton do Resource Manager do Runtime de Simultaneidade. O Resource Manager é responsável por atribuir recursos a agendadores 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 Resource Manager. Cada chamada para o método incrementa uma contagem de referência no Resource Manager e deve ser comparada com uma chamada para o método IResourceManager::Release quando o agendador terminar de se comunicar com o Resource Manager.
unsupported_os será lançado se o sistema operacional não tiver suporte no Runtime de Simultaneidade.
create_task
Cria um objeto de tarefa PPL. create_task pode ser usado em qualquer lugar que você teria usado um construtor de tarefas. Ele é fornecido principalmente para conveniência, pois 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 do qual a tarefa deve ser construída.
_ReturnType
Tipo.
_Param
O parâmetro 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 no aplicativo UWP.
_TaskOptions
As opções de tarefa.
_Task
A tarefa a ser criada.
Valor de retorno
Uma nova tarefa do tipo T, que é inferida 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 à tarefa recém-criada. Se você usar essa sobrecarga, não poderá 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 task_completion_event<T>, task<T> ou um functor que retorna um 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>^, Windows::Foundation::IAsyncOperationWithProgress<T,P>^ ou um functor que retorna qualquer um desses tipos, a tarefa criada será do tipo task<T>. Se _Param for do tipo Windows::Foundation::IAsyncAction^, Windows::Foundation::IAsyncActionWithProgress<P>^ ou um functor que retorna qualquer um desses tipos, a tarefa criada terá o tipo task<void>.
DisableTracing
Desabilita o rastreamento no Runtime de Simultaneidade. Essa 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 tiver sido desabilitado corretamente, S_OK será retornado. Se o rastreamento não tiver sido iniciado anteriormente, E_NOT_STARTED será retornado
EnableTracing
Habilita o rastreamento no Runtime de Simultaneidade. Essa função foi preterida porque o rastreamento ETW agora é 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 é retornado.
Gratuita
Libera um bloco de memória alocado anteriormente pelo método Alloc para o Subalocador de Cache de Runtime de Simultaneidade.
void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);
Parâmetros
_PAllocation
Um ponteiro para a memória alocado anteriormente pelo método Alloc que deve ser liberado. Se o parâmetro _PAllocation for definido como o valor NULL, esse método o ignorará e retornará imediatamente.
Comentários
Para obter mais informações sobre quais cenários em seu aplicativo podem se beneficiar do uso do Subalocador de Cache, consulte o 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 o contexto de execução antes de passar uma interface IExecutionContext como um parâmetro para qualquer um dos métodos oferecidos pelo Resource Manager.
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 será lançado se o sistema operacional não tiver suporte no Runtime de Simultaneidade.
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 será lançado se o sistema operacional não tiver suporte no Runtime de Simultaneidade.
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 será lançado se o sistema operacional não tiver suporte no Runtime de Simultaneidade.
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 o agendador antes de passar uma interface IScheduler como um parâmetro para qualquer um dos métodos oferecidos pelo Resource Manager.
internal_assign_iterators
template<typename T, class _Ax>
template<class _I>
void concurrent_vector<T, _Ax>::internal_assign_iterators(
_I first,
_I last);
Parâmetros
T
_Ax
_I
first
last
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 gerará uma exceção interna que anula 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 capturar a exceção de cancelamento interna gerada pela função interruption_point(). A exceção será capturada e manipulada pelo runtime, e sua captura pode fazer com que o programa se comporte de forma anormal.
is_current_task_group_canceling
Indica se o grupo de tarefas executando de forma embutida no contexto atual está no meio de um cancelamento ativo (ou estará em breve). Observe que, se não houver um grupo de tarefas em execução embutido no contexto atual, false será retornado.
bool __cdecl is_current_task_group_canceling();
Valor de retorno
true se o grupo de tarefas que está em execução estiver sendo cancelado, caso contrário, false.
Comentários
Para obter mais informações, consulte Cancelamento.
make_choice
Constrói um bloco de mensagens choice de Scheduler ou ScheduleGroup opcionais 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 origem.
T2
O tipo de bloco de mensagem da segunda origem.
_PScheduler
O objeto Scheduler no qual a tarefa de propagação do bloco de mensagens choice está agendada.
_Item1
A primeira fonte.
_Item2
A segunda fonte.
_Items
Fontes adicionais.
_PScheduleGroup
O objeto ScheduleGroup no qual a tarefa de propagação do bloco de mensagens choice está agendada. O objeto Scheduler usado é implícito pelo grupo agendado.
Valor de retorno
Um bloco de mensagens choice com duas ou mais fontes de entrada.
make_greedy_join
Constrói um bloco de mensagens greedy multitype_join de Scheduler ou ScheduleGroup opcionais 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 origem.
T2
O tipo de bloco de mensagem da segunda origem.
_PScheduler
O objeto Scheduler no qual a tarefa de propagação do bloco de mensagens multitype_join está agendada.
_Item1
A primeira fonte.
_Item2
A segunda fonte.
_Items
Fontes adicionais.
_PScheduleGroup
O objeto ScheduleGroup no qual a tarefa de propagação do bloco de mensagens multitype_join está agendada. O objeto Scheduler usado é implícito pelo grupo agendado.
Valor de retorno
Um bloco de mensagens greedy multitype_join com duas ou mais fontes de entrada.
make_join
Constrói um bloco de mensagens non_greedy multitype_join de Scheduler ou ScheduleGroup opcionais 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 origem.
T2
O tipo de bloco de mensagem da segunda origem.
_PScheduler
O objeto Scheduler no qual a tarefa de propagação do bloco de mensagens multitype_join está agendada.
_Item1
A primeira fonte.
_Item2
A segunda fonte.
_Items
Fontes adicionais.
_PScheduleGroup
O objeto ScheduleGroup no qual a tarefa de propagação do bloco de mensagens multitype_join está agendada. O objeto Scheduler usado é implícito pelo grupo agendado.
Valor de retorno
Um bloco de mensagens 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 dê suporte a 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, pois permite que você crie o objeto sem saber o tipo verdadeiro do functor lambda.
parallel_buffered_sort
Organiza os elementos de um intervalo especificado em ordem não decrescente ou de acordo com um critério de ordenação especificado por um predicado binário em paralelo. Essa função é semanticamente semelhante a std::sort em que é uma classificação com base em comparação, instável, no local, exceto que precisa de espaço adicional O(n) e requer a 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 a Biblioteca Padrão C++.
_Function
O tipo do comparador binário.
_Begin
Um iterador de acesso aleatório que trata da posição do primeiro elemento no intervalo a ser classificado.
_End
Um iterador de acesso aleatório que trata da posição logo após o elemento final no intervalo a ser classificado.
_Alloc
Uma instância de um alocador de memória compatível com a Biblioteca Padrão C++.
_Func
Objeto de função de predicado definido por um usuário que define os critérios de comparação a serem atendidos pelo sucessivos elementos na ordem. Um predicado binário usa dois argumentos e retorna true quando é atendido e false quando não é atendido. Essa função de comparador deve impor uma ordenação fraca estrita aos pares de elementos da sequência.
_Chunk_size
O tamanho mínimo de uma parte que será dividida em duas para execução paralela.
Comentários
Todas as sobrecargas exigem espaço adicional n * sizeof(T), 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 em parallel_sort e você deverá usá-lo em parallel_sort se tiver a memória disponível.
Se você não fornecer um comparador binário, std::less é usado como o padrão, o que requer o tipo de elemento para fornecer o operador 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.
O algoritmo divide o intervalo de entrada em duas partes e cada parte sucessivamente em duas subpastas para execução em paralelo. O argumento opcional _Chunk_size pode ser usado para indicar ao algoritmo que ele deve manipular partes de tamanho <_Chunk_size serialmente.
parallel_for
parallel_for itera em um intervalo 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 do índice sendo usado para a iteração.
_Function
O tipo da função que será executada em cada iteração.
_Partitioner
O tipo do particionador usado para particionar o intervalo fornecido.
first
O primeiro índice a ser incluído na iteração.
last
O primeiro índice após o último índice a ser incluído na iteração.
_Step
O valor pelo qual a etapa será executada ao iterar de first para last. A etapa deve ser positiva. invalid_argument é lançado se a etapa for menor que 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 dê 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 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 de valor l não const, para que o algoritmo possa armazenar o estado para loops futuros para reutilização.
Comentários
Para obter mais informações, consulte Algoritmos paralelos.
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 dar suporte a um operador de chamada de função do formulário operator()(T) em que 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 sendo usado para iterar no contêiner.
_Function
O tipo da função que será aplicada a cada elemento dentro do intervalo.
_Partitioner
first
Um iterador que trata da posição do primeiro elemento a ser incluído na iteração paralela.
last
Um iterador que trata da primeira posição 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.
_Part
Uma referência ao objeto Particionador. 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 de valor l não const, para que o algoritmo possa armazenar o estado para loops futuros para reutilização.
Comentários
auto_partitioner será usado para a sobrecarga sem um particionador explícito.
Para iteradores que não dão suporte a acesso aleatório, há suporte apenas para auto_partitioner.
Para obter mais informações, consulte Algoritmos paralelos.
parallel_invoke
Executa os objetos de função fornecidos como parâmetros em paralelo e bloqueia até que eles tenham terminado de executar. Cada objeto de função pode ser uma expressão lambda, um ponteiro para a função ou qualquer objeto que dê suporte ao 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 oitavo objeto de 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 de forma embutida no contexto de chamada.
Se um ou mais dos objetos de função passados como parâmetros para essa função gerar uma exceção, o runtime selecionará uma dessas exceções e a propagará da chamada para parallel_invoke.
Para obter mais informações, consulte Algoritmos paralelos.
parallel_radixsort
Organiza elementos em um intervalo especificado em ordem não decrescente usando um algoritmo de classificação de base. 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 sem sinal. 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 a Biblioteca Padrão C++.
_Function
O tipo da função de projeção.
_Begin
Um iterador de acesso aleatório que trata da posição do primeiro elemento no intervalo a ser classificado.
_End
Um iterador de acesso aleatório que trata da posição logo após o elemento final no intervalo a ser classificado.
_Alloc
Uma instância de um alocador de memória compatível com a Biblioteca Padrão C++.
_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 mínimo de uma parte que será dividida em duas para execução paralela.
Comentários
Todas as sobrecargas exigem espaço adicional n * sizeof(T), onde n é o número de elementos a serem classificados e T é o tipo de elemento. Um functor de projeção unário com a assinatura I _Proj_func(T) é necessário para retornar uma chave quando um elemento é dado, onde T é o tipo de elemento e I é um tipo inteiro sem sinal.
Se você não fornecer uma função de projeção, uma função de projeção padrão que simplesmente retorna o elemento será usada para os 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 ou instância de alocador, o alocador de memória da Biblioteca Padrão C++ std::allocator<T> será usado para alocar o buffer.
O algoritmo divide o intervalo de entrada em duas partes e cada parte sucessivamente em duas subpastas para execução em paralelo. O argumento opcional _Chunk_size pode ser usado para indicar ao algoritmo que ele deve manipular partes de tamanho <_Chunk_size serialmente.
parallel_reduce
Calcula a soma de todos os elementos em um intervalo especificado, ao calcular somas parciais sucessivas ou calcula o resultado de resultados parciais sucessivos obtidos 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 de iterador do intervalo de entrada.
_Sym_reduce_fun
O tipo da função de redução simétrica. 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. 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 retornado e o valor de identidade terão esse tipo.
_Range_reduce_fun
O tipo da função de redução de intervalo. 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 trata do primeiro elemento no intervalo a ser reduzido.
_End
Um iterador de entrada que aborda o elemento que está uma posição após o elemento final do intervalo a ser reduzido.
_Identity
O valor de identidade _Identity é do mesmo tipo que o tipo de resultado da redução e também 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 iterador value_type. 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 de tipo value_type e o valor de identidade, se comporte como um tipo de conversão do valor do tipo value_type para o tipo de identidade.
_Sym_fun
A função simétrica que será usada no segundo da redução. Consulte os Comentários para obter mais informações.
_Range_fun
A função que será usada na primeira fase da redução. Consulte os 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 executa uma redução em cada parte e a segunda fase executa uma redução entre os resultados parciais de cada parte.
A primeira sobrecarga requer que o value_type do iterador, T, seja igual ao tipo de valor de identidade, bem como o tipo de resultado de redução. O tipo de elemento T deve fornecer o operador T T::operator + (T) para reduzir elementos em cada parte. O mesmo operador também é usado na segunda fase.
A segunda sobrecarga também requer que o iterador value_type seja igual ao tipo de valor de identidade, bem como o tipo de resultado de redução. O operador binário _Sym_fun fornecido é usado em ambas as fases de redução, com o valor de identidade como o valor inicial da 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 a sub-resultados na segunda fase.
parallel_sort
Organiza os elementos de um intervalo especificado em ordem não decrescente ou de acordo com um critério de ordenação especificado por um predicado binário em paralelo. Essa função é semanticamente semelhante a std::sort que é uma classificação baseada em comparação, instável e local.
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 que trata da posição do primeiro elemento no intervalo a ser classificado.
_End
Um iterador de acesso aleatório que trata da posição logo após o elemento final no intervalo a ser classificado.
_Func
Objeto de função de predicado definido por um usuário que define os critérios de comparação a serem atendidos pelo sucessivos elementos na ordem. Um predicado binário usa dois argumentos e retorna true quando é atendido e false quando não é atendido. Essa função de comparador deve impor uma ordenação fraca estrita aos pares de elementos da sequência.
_Chunk_size
O tamanho mínimo de uma parte que será dividida em duas 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 deveria ter a assinatura bool _Func(T, T) onde T é o tipo dos elementos no intervalo de entrada.
O algoritmo divide o intervalo de entrada em duas partes e cada parte sucessivamente em duas subpastas para execução em paralelo. O argumento opcional _Chunk_size pode ser usado para indicar ao algoritmo que ele deve manipular partes de tamanho <_Chunk_size serialmente.
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. Esse funcional é 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 do functor unário a ser executado em cada elemento no intervalo de entrada.
_Input_iterator2
O tipo do segundo iterador de entrada.
_Binary_operator
O tipo do functor binário executado em pares nos elementos dos dois intervalos de origem.
_Partitioner
first1
Um iterador de entrada que trata da posição do primeiro elemento no primeiro ou único intervalo de origem no qual a operação ocorrerá.
last1
Um iterador de entrada que trata da posição logo após o elemento final no primeiro ou único intervalo de origem no qual a operação ocorrerá.
_Result
Um iterador de saída que trata da 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.
_Part
Uma referência ao objeto Particionador. 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 de valor l não const, para que o algoritmo possa armazenar o estado para loops futuros para reutilização.
first2
Um iterador de entrada que trata da posição do primeiro elemento no segundo intervalo de origem no qual a operação ocorrerá.
_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 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.
Comentários
auto_partitioner será usado para as sobrecargas sem um argumento de particionador explícito.
Para iteradores que não dão suporte a acesso aleatório, há suporte apenas para auto_partitioner.
As sobrecargas com o argumento _Unary_op transformam o intervalo de entrada no intervalo de saída aplicando o functor unário a cada elemento no intervalo de entrada. _Unary_op deve dar suporte ao operador de chamada de função com assinatura operator()(T) onde T é o tipo de valor do intervalo que está sendo iterado.
As sobrecargas com o argumento _Binary_op transformam 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. _Binary_op deve dar suporte ao 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 Algoritmos paralelos.
recebimento
Uma implementação de recebimento geral, permitindo que um contexto aguarde dados de exatamente uma fonte e filtre os valores 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 conteúdo.
_Src
Um ponteiro ou referência à origem da qual os dados são esperados.
_Timeout
O tempo máximo pelo qual o método deve aguardar os dados, em milissegundos.
_Filter_proc
Uma função de filtro que determina se as mensagens devem ser aceitas.
Valor de retorno
Um valor da origem do tipo de conteúdo.
Comentários
Se o parâmetro _Timeout tiver um valor diferente da constante COOPERATIVE_TIMEOUT_INFINITE, a exceção operation_timed_out será gerada se a quantidade de tempo especificada expirar antes de uma mensagem ser recebida. Se você quiser um tempo limite de zero, use a função try_receive em vez de chamar receive com um tempo limite de 0 (zero), pois ela é mais eficiente e não gera exceções em tempos limite.
Para obter mais informações, consulte Funções de transmissão de mensagem.
run_with_cancellation_token
Executa um objeto de função imediatamente e de forma 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. Esse objeto deve dar suporte ao 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 ser cancelado.
Comentários
Todos os pontos de interrupção no objeto de função serão disparados quando cancellation_token for cancelado. O token explícito _Ct isolará _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 conteúdo.
_Trg
Um ponteiro ou referência ao destino para o qual os dados são enviados.
_Data
Uma referência aos dados a serem enviados.
Valor de retorno
true se a mensagem foi aceita, caso contrário, false.
Comentários
Para obter mais informações, consulte Funções de transmissão de mensagem.
set_ambient_scheduler
inline void set_ambient_scheduler(std::shared_ptr<::Concurrency::scheduler_interface> _Scheduler);
Parâmetros
_Scheduler
O agendador de ambiente a ser definido.
set_task_execution_resources
Restringe os recursos de execução usados pelos threads de trabalho internos do Runtime de Simultaneidade ao conjunto de afinidades 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 Resource Manager não exista no momento da invocação. Depois que um limite de afinidade tiver sido 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 Runtime de Simultaneidade devem ser restritos. Use esse método em um sistema com mais de 64 threads de hardware somente se quiser limitar o Runtime de Simultaneidade 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 computadores com mais de 64 threads de hardware.
count
O número de entradas GROUP_AFFINITY na matriz especificada pelo parâmetro _PGroupAffinity.
_PGroupAffinity
Uma matriz de entradas GROUP_AFFINITY.
Comentários
O método lançará uma exceção invalid_operation se um Resource Manager estiver presente quando 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 a versão Windows 7 ou superior. Caso contrário, uma exceção invalid_operation será lançada.
Modificar programaticamente a afinidade do processo depois que esse método for invocado não fará com que o Resource Manager reavalie a afinidade à qual está restrito. Portanto, todas as alterações na afinidade de processo devem ser feitas antes de chamar esse método.
troca
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.
_A
Um vetor simultâneo cujos elementos deverão ser trocados por aqueles do vetor simultâneo _B.
_B
O vetor simultâneo que fornece os elementos a serem trocados ou um vetor cujos elementos deverão ser trocados com aqueles do vetor simultâneo _A.
Comentários
A função de modelo é um algoritmo especializado na classe de contêiner concurrent_vector para executar a função membro _A. concurrent_vector::swap( _B). Essas são instâncias de ordenação parcial de modelos de função pelo compilador. 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. A versão geral da função de modelo, template <class T> void swap(T&, T&), na classe de algoritmo trabalha por atribuição e é uma operação lenta. 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.
Esse método não é seguro para simultaneidade. Você deve garantir que nenhum outro thread esteja executando operações nos vetores simultâneos ao 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
T
_Param
_TaskOptions
Valor de retorno
Trace_agents_register_name
Associa o nome fornecido ao bloco de mensagens ou ao 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, isso é um bloco de mensagens ou um agente.
_PObject
Um ponteiro para o bloco de mensagens ou agente que está sendo nomeado no rastreamento.
_Name
O nome do objeto fornecido.
try_receive
Uma implementação try-receive geral, permitindo que um contexto procure dados de exatamente uma fonte e filtre os valores 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 conteúdo
_Src
Um ponteiro ou referência à origem da qual os dados são esperados.
_value
Uma referência a um local onde o resultado será inserido.
_Filter_proc
Uma função de filtro que determina se as mensagens devem ser aceitas.
Valor de retorno
Um valor bool que indica se um conteúdo foi colocado em _value ou não.
Comentários
Para obter mais informações, consulte Funções de transmissão de mensagem.
wait
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á gerar execução para outros contextos executáveis antes de continuar.
Comentários
Se esse método for chamado em um contexto do agendador do Runtime de Simultaneidade, o agendador encontrará um contexto diferente para ser executado no recurso subjacente. Como o agendador é de natureza cooperativa, ele 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 são suspensas cooperativamente no agendador, o período de espera poderá 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 no intervalo de elementos a ser combinada na tarefa resultante.
_End
A posição do primeiro elemento além do intervalo de elementos a ser combinada na tarefa resultante.
_TaskOptions
O objeto task_options.
Valor de retorno
Uma tarefa que é concluída com êxito quando todas as tarefas de entrada tiverem sido concluídas com êxito. Se as tarefas de entrada forem do tipo T, a saída dessa 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 task como resultado. Ao contrário de task::wait, é seguro chamar essa função em um aplicativo UWP no thread ASTA (Application STA).
Se uma das tarefas for cancelada ou gerar uma exceção, a tarefa retornada será concluída antecipadamente, no estado cancelado, e a exceção, se alguma ocorrer, será gerada se você chamar task::get ou task::wait nessa tarefa.
Para saber mais, confira Paralelismo da tarefa.
when_any
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_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 no intervalo de elementos a ser combinada na tarefa resultante.
_End
A posição do primeiro elemento além do intervalo de elementos a ser combinada 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 fez com que ela fosse concluída.
Valor de retorno
Uma tarefa que foi concluída com êxito quando alguma das tarefas de entrada foi concluída com êxito. 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. Se as tarefas de entrada forem do tipo void, a saída será um task<size_t>, em que o resultado é o índice de conclusão da tarefa.
Comentários
when_any é uma função sem bloqueio que produz task como resultado. Ao contrário de task::wait, é seguro chamar essa função em um aplicativo UWP no thread ASTA (Application STA).
Para saber mais, confira Paralelismo da tarefa.