Funzioni dello spazio dei nomi concurrency

Articolo
10/12/2023

Alloc

Assegna un blocco di memoria dalle dimensioni specificate dal suballocatore di cache del runtime di concorrenza.

void* __cdecl Alloc(size_t _NumBytes);

Parametri

_Numbytes
Numero di byte di memoria da allocare.

Valore restituito

Puntatore alla memoria appena allocata.

Osservazioni:

Per altre informazioni sugli scenari che possono trarre vantaggio dall'uso di Suballocator di memorizzazione nella cache, vedere Utilità di pianificazione.

Asend

Un'operazione di invio asincrona che pianifica un'attività per propagare i dati nel blocco di destinazione.

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

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

Parametri

T
Tipo di dati da inviare.

_Trg
Puntatore o riferimento alla destinazione a cui vengono inviati i dati.

_Dati
Riferimento ai dati da inviare.

Valore restituito

true se il messaggio è stato accettato prima della restituzione del metodo, false in caso contrario.

Osservazioni:

Per altre informazioni, vedere Funzioni di passaggio dei messaggi.

cancel_current_task

Annulla l'attività attualmente in esecuzione. Questa funzione può essere chiamata dal corpo di un'attività per interrompere l'esecuzione dell'attività e forzarne il passaggio allo stato canceled.

Chiamare questa funzione non è uno scenario supportato se non si è all'interno del corpo di un oggetto task. In questo modo si verifica un comportamento non definito, ad esempio un arresto anomalo o una mancata risposta nell'applicazione.

inline __declspec(noreturn) void __cdecl cancel_current_task();

clear

Cancella la coda simultanea, eliminando tutti gli elementi attualmente accodati. Questo metodo non è sicuro per la concorrenza.

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

Parametri

_Ax

Create_async

Crea un costrutto asincrono di Windows Runtime in base a un'espressione lambda o un oggetto funzione fornito dall'utente. Il tipo restituito create_async è uno tra IAsyncAction^, IAsyncActionWithProgress<TProgress>^, IAsyncOperation<TResult>^ o IAsyncOperationWithProgress<TResult, TProgress>^ in base alla firma dell'espressione lambda passata al metodo.

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

Parametri

_Funzione
Tipo.

_Func
Espressione lambda o oggetto funzione da cui si crea un costrutto asincrono di Windows Runtime.

Valore restituito

Costrutto asincrono rappresentato da un IAsyncAction^, IAsyncActionWithProgress<>^, IAsyncOperation<TResult>^o IAsyncOperationWithProgress<TResult, TProgress>^. L'interfaccia restituita dipende dalla firma dell'espressione lambda passata nella funzione.

Osservazioni:

Il tipo restituito dell'espressione lambda determina se il costrutto è un'azione o un'operazione.

Le espressioni lambda tramite cui viene restituito void comportano la creazione di azioni. Le espressioni lambda tramite cui viene restituito un risultato di tipo TResult comportano la creazione di operazioni TResult.

L'espressione lambda può inoltre restituire task<TResult> che incapsula il lavoro asincrono o è la continuazione di una catena di attività che rappresentano il lavoro asincrono. In questo caso, la stessa espressione lambda viene eseguita inline, poiché le attività sono quelle che vengono eseguite in modo asincrono e viene rimosso il wrapping del tipo restituito dell'espressione lambda per generare il costrutto asincrono restituito da create_async. Ciò implica che un'espressione lambda che restituisce un'attività<void> causerà la creazione di azioni e un'espressione lambda che restituisce un'attività<TResult> causerà la creazione di operazioni di TResult.

L'espressione lambda può accettare zero, uno o due argomenti. Gli argomenti validi sono progress_reporter<TProgress> e cancellation_token, in questo ordine se vengono usati entrambi. Un'espressione lambda senza argomenti determina la creazione di un costrutto asincrono senza la funzionalità per la segnalazione dello stato di avanzamento. Un'espressione lambda che accetta un progress_reporter<TProgress> restituirà create_async un costrutto asincrono che segnala lo stato di avanzamento del tipo TProgress ogni volta che viene chiamato il report metodo dell'oggetto progress_reporter. Un'espressione lambda che accetta un cancellation_token può usare tale token per verificare l'annullamento oppure passarlo alle attività create in modo che l'annullamento del costrutto asincrono provochi l'annullamento di tali attività.

Se il corpo dell'oggetto lambda o funzione restituisce un risultato (e non un'attività<TResult>), la lamdba verrà eseguita in modo asincrono all'interno del processo MTA nel contesto di un'attività creata in modo implicito dal runtime. Il metodo IAsyncInfo::Cancel determina l'annullamento dell'attività implicita.

Se tramite il corpo di lambda viene restituita un'attività, lambda viene eseguito inline e, dichiarando che nel lambda viene accettato un argomento di tipo cancellation_token, è possibile attivare l'annullamento delle attività create all'interno di lambda passando il token quando vengono create. È inoltre possibile usare il metodo register_callback sul token per fare in modo che il runtime richiami un callback quando si chiama IAsyncInfo::Cancel sull'operazione async o sull'azione prodotta.

Questa funzione è disponibile solo per le app di Windows Runtime.

CreateResourceManager

Restituisce un'interfaccia che rappresenta l'istanza singleton di Gestione risorse del runtime di concorrenza. Gestione risorse è responsabile dell'assegnazione di risorse a utilità di pianificazione che vogliono cooperare tra loro.

IResourceManager* __cdecl CreateResourceManager();

Valore restituito

Interfaccia IResourceManager.

Osservazioni:

Più chiamate successive a questo metodo restituiranno la stessa istanza di Resource Manager. Ogni chiamata al metodo incrementa un conteggio dei riferimenti in Resource Manager e deve essere associata a una chiamata al metodo IResourceManager::Release quando l'utilità di pianificazione ha terminato la comunicazione con Resource Manager.

unsupported_os viene generata se il sistema operativo non è supportato dal runtime di concorrenza.

create_task

Crea un oggetto attività PPL. create_task può essere usato ovunque si sarebbe usato un costruttore di attività. Viene fornito principalmente per comodità, in quanto consente l'uso della parola chiave auto durante la creazione delle attività.

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

Parametri

T
Tipo del parametro dal quale deve essere costruita l'attività.

_Returntype
Tipo.

_Param
Parametro dal quale deve essere costruita l'attività. Può trattarsi di un oggetto lambda o di funzione, un task_completion_event oggetto, un oggetto diverso task o un'interfaccia Windows::Foundation::IAsyncInfo se usi attività nell'app UWP.

_TaskOptions
Opzioni dell'attività.

_Attività
Attività da creare.

Valore restituito

Nuova attività di tipo T, dedotto da _Param.

Osservazioni:

Il primo overload si comporta come un costruttore di attività che accetta un singolo parametro.

Il secondo overload associa il token di annullamento fornito all'attività appena creata. Se si usa questo overload, non è consentito passare un oggetto diverso task come primo parametro.

Il tipo dell'attività restituita viene dedotto dal primo parametro alla funzione. Se _Param è , task_completion_event<T>o task<T>un funtore che restituisce il tipo T o task<T>, il tipo dell'attività creata è task<T>.

In un'app UWP, se _Param è di tipo Windows::Foundation::IAsyncOperation<T>^ o Windows::Foundation::IAsyncOperationWithProgress<T,P>^o un functor che restituisce uno di questi tipi, l'attività creata sarà di tipo task<T>. Se _Param è di tipo Windows::Foundation::IAsyncAction^ o Windows::Foundation::IAsyncActionWithProgress<P>^o un funtore che restituisce uno di questi tipi, l'attività creata avrà il tipo task<void>.

DisableTracing

Disabilita la tracciatura nel runtime di concorrenza. Questa funzione è deprecata poiché la traccia ETW non viene registrata per impostazione predefinita.

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

Valore restituito

Se la traccia è stata disabilitata correttamente, S_OK viene restituita. Se la traccia non è stata iniziata in precedenza, viene restituito E_NOT_STARTED.

EnableTracing

Abilita la tracciatura nel runtime di concorrenza. Questa funzione è deprecata poiché la traccia ETW è ora attivata per impostazione predefinita.

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

Valore restituito

Se la traccia è stata avviata correttamente, S_OK viene restituita; in caso contrario, E_NOT_STARTED viene restituita.

Disponibile

Rilascia un blocco di memoria precedentemente allocato dal metodo Alloc al suballocatore di cache del runtime di concorrenza.

void __cdecl Free(_Pre_maybenull_ _Post_invalid_ void* _PAllocation);

Parametri

_PAllocation
Puntatore alla memoria allocata in precedenza dal Alloc metodo che deve essere liberato. Se il parametro _PAllocation è impostato sul valore NULL, questo metodo lo ignorerà e restituirà immediatamente.

Osservazioni:

Per altre informazioni sugli scenari che possono trarre vantaggio dall'uso di Suballocator di memorizzazione nella cache, vedere Utilità di pianificazione.

get_ambient_scheduler

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

Valore restituito

GetExecutionContextId

Restituisce un identificatore univoco che può essere assegnato a un contesto di esecuzione che implementa l'interfaccia IExecutionContext.

unsigned int __cdecl GetExecutionContextId();

Valore restituito

Identificatore univoco per un contesto di esecuzione.

Osservazioni:

Usare questo metodo per ottenere un identificatore per il contesto di esecuzione prima di passare un'interfaccia IExecutionContext come parametro a uno dei metodi offerti da Resource Manager.

GetOSVersion

Restituisce la versione del sistema operativo.

IResourceManager::OSVersion __cdecl GetOSVersion();

Valore restituito

Valore enumerato che rappresenta il sistema operativo.

Osservazioni:

unsupported_os viene generata se il sistema operativo non è supportato dal runtime di concorrenza.

GetProcessorCount

Restituisce il numero dei thread hardware sul sistema sottostante.

unsigned int __cdecl GetProcessorCount();

Valore restituito

Numero di thread hardware.

Osservazioni:

unsupported_os viene generata se il sistema operativo non è supportato dal runtime di concorrenza.

GetProcessorNodeCount

Restituisce il numero di nodi NUMA o pacchetti del processore sul sistema sottostante.

unsigned int __cdecl GetProcessorNodeCount();

Valore restituito

Numero di nodi NUMA o pacchetti del processore.

Osservazioni:

Se il sistema contiene più nodi NUMA rispetto ai pacchetti del processore, viene restituito il numero di nodi NUMA. In caso contrario, viene restituito il numero di pacchetti del processore.

unsupported_os viene generata se il sistema operativo non è supportato dal runtime di concorrenza.

GetSchedulerId

Restituisce un identificatore univoco che può essere assegnato a un'utilità di pianificazione che implementa l'interfaccia IScheduler.

unsigned int __cdecl GetSchedulerId();

Valore restituito

Identificatore univoco per un'utilità di pianificazione.

Osservazioni:

Usare questo metodo per ottenere un identificatore per l'utilità di pianificazione prima di passare un'interfaccia IScheduler come parametro a uno dei metodi offerti da 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);

Parametri

_Ax

first

last

interruption_point

Crea un punto di interruzione per l'annullamento. Se un annullamento è in corso nel contesto in cui questa funzione viene chiamata, questa genererà un'eccezione interna che interrompe l'esecuzione del lavoro parallelo in esecuzione. Se l'annullamento non è in corso, la funzione non esegue alcuna operazione.

inline void interruption_point();

Osservazioni:

Non è consigliabile rilevare l'eccezione di annullamento interna generata dalla funzione interruption_point(). L'eccezione viene rilevata e gestita dal runtime, pertanto se viene rilevata potrebbe comportare un'esecuzione anomala del programma.

is_current_task_group_canceling

Restituisce un'informazione che indica se il gruppo di attività attualmente in esecuzione inline sul contesto corrente si trova nel mezzo di un annullamento attivo (o lo sarà a breve). Si noti che se non è presente alcun gruppo di attività in esecuzione inline sul contesto corrente, sarà restituito false.

bool __cdecl is_current_task_group_canceling();

Valore restituito

true se il gruppo di attività attualmente in esecuzione viene annullato; in caso contrario, false .

Osservazioni:

Per altre informazioni, vedere Annullamento.

make_choice

Costruisce un blocco della messaggistica choice da un oggetto Scheduler o ScheduleGroup facoltativo e due o più origini di input.

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

Parametri

T1
Tipo di blocco di messaggi della prima origine.

T2
Tipo di blocco di messaggi della seconda origine.

_PScheduler
Oggetto Scheduler all'interno del quale è pianificata l'attività di propagazione per il blocco della messaggistica choice .

_Item1
Prima origine.

_Item2
Seconda origine.

_Elementi
Origini supplementari.

_PScheduleGroup
Oggetto ScheduleGroup all'interno del quale è pianificata l'attività di propagazione per il blocco della messaggistica choice . L'oggetto Scheduler usato è previsto dal gruppo di pianificazione.

Valore restituito

Blocco di messaggi choice con due o più origini di input.

make_greedy_join

Costruisce un blocco della messaggistica greedy multitype_join da un oggetto Scheduler o ScheduleGroup facoltativo e due o più origini di input.

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

Parametri

T1
Tipo di blocco di messaggi della prima origine.

T2
Tipo di blocco di messaggi della seconda origine.

_PScheduler
Oggetto Scheduler all'interno del quale è pianificata l'attività di propagazione per il blocco della messaggistica multitype_join .

_Item1
Prima origine.

_Item2
Seconda origine.

_Elementi
Origini supplementari.

_PScheduleGroup
Oggetto ScheduleGroup all'interno del quale è pianificata l'attività di propagazione per il blocco della messaggistica multitype_join . L'oggetto Scheduler usato è previsto dal gruppo di pianificazione.

Valore restituito

Blocco di messaggi greedy multitype_join con due o più origini di input.

make_join

Costruisce un blocco della messaggistica non_greedy multitype_join da un oggetto Scheduler o ScheduleGroup facoltativo e due o più origini di input.

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

Parametri

T1
Tipo di blocco di messaggi della prima origine.

T2
Tipo di blocco di messaggi della seconda origine.

_PScheduler
Oggetto Scheduler all'interno del quale è pianificata l'attività di propagazione per il blocco della messaggistica multitype_join .

_Item1
Prima origine.

_Item2
Seconda origine.

_Elementi
Origini supplementari.

Valore restituito

Blocco di messaggi non_greedy multitype_join con due o più origini di input.

make_task

Un metodo factory per la creazione di un oggetto task_handle.

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

Parametri

_Funzione
Tipo dell'oggetto funzione che verrà richiamato per eseguire il lavoro rappresentato dall'oggetto task_handle .

_Func
Funzione che verrà richiamata per eseguire il lavoro rappresentato dall'oggetto task_handle . Può trattarsi di un funtore lambda, di un puntatore a una funzione o di qualsiasi oggetto che supporta una versione dell'operatore di chiamata di funzione con la firma void operator()().

Valore restituito

Oggetto task_handle.

Osservazioni:

Questa funzione è utile quando è necessario creare un task_handle oggetto con un'espressione lambda, perché consente di creare l'oggetto senza conoscere il tipo vero del funtore lambda.

parallel_buffered_sort

Dispone gli elementi in un intervallo specificato in un ordine non decrescente o in base a un criterio di ordinamento specificato da un predicato binario, in parallelo. Questa funzione è semanticamente simile a std::sort in quanto si tratta di un ordinamento basato sul confronto, instabile, sul posto, ma richiede uno spazio aggiuntivo pari O(n) e l'inizializzazione predefinita per gli elementi in fase di ordinamento.

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

Parametri

_Random_iterator
Tipo dell'iteratore dell'intervallo di input.

_Allocatore
Tipo di allocatore di memoria compatibile con la libreria standard C++.

_Funzione
Tipo del comparatore binario.

_Iniziare
Iteratore ad accesso casuale che punta alla posizione del primo elemento nell'intervallo da ordinare.

_Fine
Iteratore ad accesso casuale che punta alla prima posizione oltre l'elemento finale nell'intervallo da ordinare.

_Alloc
Istanza di un allocatore di memoria compatibile con la libreria standard C++.

_Func
Oggetto funzione predicato definito dall'utente tramite cui vengono definiti i criteri di confronto che devono essere soddisfatti dagli elementi successivi nell'ordinamento. Un predicato binario accetta due argomenti e viene restituito true se la condizione è soddisfatta e false se non lo è. Tramite questa funzione di confronto deve essere imposto un ordinamento di tipo "strict weak" alle coppie di elementi della sequenza.

_Chunk_size
Dimensione minima di un blocco che verrà suddiviso in due per l'esecuzione parallela.

Osservazioni:

Tutti gli overload richiedono n * sizeof(T) spazio aggiuntivo, dove n è il numero di elementi da ordinare ed T è il tipo di elemento. Nella maggior parte dei casi parallel_buffered_sort mostrerà un miglioramento delle prestazioni rispetto a parallel_sort ed è consigliabile usarlo in parallel_sort se la memoria è disponibile.

Se non si specifica un comparatore std::less binario viene usato come predefinito, che richiede il tipo di elemento per fornire l'operatore operator<().

Se non si specifica un tipo di allocatore o un'istanza, l'allocatore std::allocator<T> di memoria della libreria standard C++ viene usato per allocare il buffer.

Tramite l'algoritmo l'intervallo di input viene diviso in due blocchi e successivamente ogni blocco viene diviso in due blocchi secondari per l'esecuzione in parallelo. L'argomento _Chunk_size facoltativo può essere usato per indicare all'algoritmo che deve gestire in modo seriale blocchi di dimensioni <_Chunk_size .

Parallel_for

parallel_for viene iterato su un intervallo di indici ed esegue una funzione fornita dall'utente a ogni iterazione, in parallelo.

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

Parametri

_Index_type
Tipo dell'indice utilizzato per l'iterazione.

_Funzione
Tipo della funzione che verrà eseguita in ogni iterazione.

_Partitioner
Tipo del partitioner utilizzato per partizionare l'intervallo fornito.

first
Primo indice da includere nell'iterazione.

last
Indice precedente all'ultimo indice da includere nell'iterazione.

_Passo
Valore in base al quale eseguire l'iterazione da first a last. Il passaggio deve essere positivo. invalid_argument viene generata se il passaggio è minore di 1.

_Func
Funzione da eseguire in ogni iterazione. Può trattarsi di un'espressione lambda, di un puntatore di funzione o di qualsiasi oggetto che supporta una versione dell'operatore di chiamata di funzione con la firma void operator()(_Index_type).

_Parte
Riferimento all'oggetto partitioner. L'argomento può essere uno dei constauto_partitioner&,const static_partitioner&,const simple_partitioner o affinity_partitioner&& Se viene utilizzato un oggetto affinity_partitioner, il riferimento deve essere un riferimento non const l-value, in modo che l'algoritmo possa archiviare lo stato per i cicli futuri da riutilizzare.

Osservazioni:

Per altre informazioni, vedere Algoritmi paralleli.

Parallel_for_each

parallel_for_each applica una funzione specificata a ogni elemento all'interno di un intervallo, in parallelo. È semanticamente equivalente alla funzione for_each nello spazio dei nomi std, fatta eccezione per l'iterazione sugli elementi, che viene eseguita in parallelo, e per l'ordine di iterazione, che non è specificato. L'argomento _Func deve supportare un operatore di chiamata della funzione del form operator()(T) laddove il parametro T è il tipo di elemento del contenitore su cui viene eseguita l'iterazione.

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

Parametri

_Iteratore
Tipo dell'iteratore usato per scorrere il contenitore.

_Funzione
Tipo della funzione che verrà applicata a ogni elemento all'interno dell'intervallo.

_Partitioner
first
Iteratore che punta alla posizione del primo elemento da includere nell'iterazione parallela.

last
Iteratore che punta alla posizione successiva all'elemento finale da includere nell'iterazione parallela.

_Func
Oggetto funzione definito dall'utente applicato a ogni elemento dell'intervallo.

Osservazioni:

auto_partitioner verrà usato per l'overload senza un partitioner esplicito.

Per gli iteratori che non supportano l'accesso casuale, è supportato solo auto_partitioner .

Per altre informazioni, vedere Algoritmi paralleli.

Parallel_invoke

Esegue gli oggetti funzione forniti come parametri in parallelo e blocca fino al termine dell'esecuzione. Ogni oggetto funzione potrebbe essere un'espressione lambda, un puntatore a funzione o qualsiasi oggetto che supporta l'operatore della chiamata di funzione con la firma 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);

Parametri

_Function1
Tipo del primo oggetto funzione da eseguire in parallelo.

_Function2
Tipo del secondo oggetto funzione da eseguire in parallelo.

_Function3
Tipo del terzo oggetto funzione da eseguire in parallelo.

_Function4
Tipo del quarto oggetto funzione da eseguire in parallelo.

_Function5
Tipo del quinto oggetto funzione da eseguire in parallelo.

_Function6
Tipo del sesto oggetto funzione da eseguire in parallelo.

_Function7
Tipo del settimo oggetto funzione da eseguire in parallelo.

_Function8
Tipo dell'ottavo oggetto funzione da eseguire in parallelo.

_Function9
Tipo del nono oggetto funzione da eseguire in parallelo.

_Function10
Tipo del decimo oggetto funzione da eseguire in parallelo.

_Func1
Primo oggetto funzione da eseguire in parallelo.

_Func2
Secondo oggetto funzione da eseguire in parallelo.

_Func3
Terzo oggetto funzione da eseguire in parallelo.

_Func4
Quarto oggetto funzione da eseguire in parallelo.

_Func5
Quinto oggetto funzione da eseguire in parallelo.

_Func6
Sesto oggetto funzione da eseguire in parallelo.

_Func7
Settimo oggetto funzione da eseguire in parallelo.

_Func8
Ottavo oggetto funzione da eseguire in parallelo.

_Func9
Nono oggetto funzione da eseguire in parallelo.

_Func10
Decimo oggetto funzione da eseguire in parallelo.

Osservazioni:

Si noti che uno o più oggetti funzione forniti come parametri possono essere eseguiti inline nel contesto chiamante.

Se uno o più oggetti funzione passati come parametri a questa funzione generano un'eccezione, il runtime selezionerà un'eccezione di questo tipo dalla scelta e la propaga all'esterno della chiamata a parallel_invoke.

Per altre informazioni, vedere Algoritmi paralleli.

parallel_radixsort

Dispone gli elementi in un intervallo specificato in un ordine non decrescente usando l'algoritmo Radix Sort. Si tratta di una funzione stabile di ordinamento che richiede una funzione di proiezione affinché che consente agli elementi del progetto di essere ordinati nelle chiavi di tipo intero senza segno. L'inizializzazione predefinita è necessaria per gli elementi da ordinare.

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

Parametri

_Random_iterator
Tipo dell'iteratore dell'intervallo di input.

_Allocatore
Tipo di allocatore di memoria compatibile con la libreria standard C++.

_Funzione
Tipo della funzione di proiezione.

_Iniziare
Iteratore ad accesso casuale che punta alla posizione del primo elemento nell'intervallo da ordinare.

_Fine
Iteratore ad accesso casuale che punta alla prima posizione oltre l'elemento finale nell'intervallo da ordinare.

_Alloc
Istanza di un allocatore di memoria compatibile con la libreria standard C++.

_Proj_func
Oggetto funzione di proiezione definito dall'utente che converte un elemento in un valore integrale.

_Chunk_size
Dimensione minima di un blocco che verrà suddiviso in due per l'esecuzione parallela.

Osservazioni:

Tutti gli overload richiedono n * sizeof(T) spazio aggiuntivo, dove n è il numero di elementi da ordinare ed T è il tipo di elemento. Un funtore di proiezione unario con la firma I _Proj_func(T) è necessario per restituire una chiave quando viene assegnato un elemento, dove T è il tipo di elemento e I è un tipo integer senza segno.

Se non si specifica una funzione di proiezione, viene usata una funzione di proiezione predefinita che restituisce semplicemente l'elemento per i tipi integrali. La funzione non verrà compilata se l'elemento non è un tipo integrale in assenza di una funzione di proiezione.

Se non si specifica un tipo di allocatore o un'istanza, l'allocatore std::allocator<T> di memoria della libreria standard C++ viene usato per allocare il buffer.

parallel_reduce

Calcola la somma di tutti gli elementi in un intervallo specificato elaborando le somme parziali successive, o calcola il risultato dei risultati parziali successivi ottenuti analogamente tramite l'uso di un'operazione binaria specificata diversa da quella di somma, in parallelo. parallel_reduce è semanticamente simile a std::accumulate, con la differenza che richiede all'operazione binaria di essere associativa e richiede un valore di identità anziché un valore iniziale.

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

Parametri

_Forward_iterator
Tipo di iteratore dell'intervallo di input.

_Sym_reduce_fun
Tipo della funzione di riduzione simmetrica. Deve essere un tipo di funzione con firma _Reduce_type _Sym_fun(_Reduce_type, _Reduce_type), dove _Reduce_type è uguale al tipo di identità e al tipo di risultato della riduzione. Per il terzo overload, deve essere coerente con il tipo di output di _Range_reduce_fun.

_Reduce_type
Tipo che l'input ridurrà, che può essere diverso dal tipo di elemento di input. Il valore restituito e il valore Identity avranno questo tipo.

_Range_reduce_fun
Tipo della funzione di riduzione dell'intervallo. Deve essere un tipo di funzione con firma _Reduce_type _Range_fun(_Forward_iterator, _Forward_iterator, _Reduce_type), _Reduce_type è uguale al tipo di identità e al tipo di risultato della riduzione.

_Iniziare
Iteratore di input che punta al primo elemento dell'intervallo da ridurre.

_Fine
Iteratore di input che punta all'elemento che è una posizione oltre l'elemento finale nell'intervallo da ridurre.

_Identità
Il valore _Identity Identity è dello stesso tipo del tipo di risultato della riduzione e anche dell'iteratore per il primo e il value_type secondo overload. Per il terzo overload, il valore Identity deve avere lo stesso tipo del tipo di risultato della riduzione, ma può essere diverso da quello value_type dell'iteratore. Deve avere un valore appropriato in modo che l'operatore _Range_fundi riduzione dell'intervallo , se applicato a un intervallo di un singolo elemento di tipo value_type e il valore Identity, si comporti come un cast di tipo del valore dal tipo value_type al tipo identity.

_Sym_fun
Funzione simmetrica che verrà utilizzata nel secondo della riduzione. Per altre informazioni, fare riferimento alle osservazioni.

_Range_fun
Funzione che verrà usata nella prima fase della riduzione. Per altre informazioni, fare riferimento alle osservazioni.

Valore restituito

Risultato della riduzione.

Osservazioni:

Per eseguire una riduzione parallela, la funzione divide l'intervallo in blocchi in base al numero di ruoli di lavoro disponibili per l'utilità di pianificazione sottostante. La riduzione avviene in due fasi, la prima fase esegue una riduzione all'interno di ogni blocco e la seconda fase esegue una riduzione tra i risultati parziali di ogni blocco.

Il primo overload richiede che l'iteratore , value_typeT, sia uguale al tipo di valore identity, nonché al tipo di risultato di riduzione. Il tipo di elemento T deve fornire l'operatore T T::operator + (T) per ridurre gli elementi in ogni blocco. Lo stesso operatore viene usato anche nella seconda fase.

Il secondo overload richiede anche che l'iteratore value_type sia uguale al tipo di valore Identity e al tipo di risultato di riduzione. L'operatore _Sym_fun binario fornito viene usato in entrambe le fasi di riduzione, con il valore Identity come valore iniziale per la prima fase.

Per il terzo overload, il tipo di valore Identity deve essere uguale al tipo di risultato di riduzione, ma l'iteratore value_type può essere diverso da entrambi. La funzione _Range_fun di riduzione dell'intervallo viene usata nella prima fase con il valore Identity come valore iniziale e la funzione _Sym_reduce_fun binaria viene applicata ai risultati secondari nella seconda 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);

Parametri

_Random_iterator
Tipo dell'iteratore dell'intervallo di input.

_Funzione
Tipo del funtore di confronto binario.

_Iniziare
Iteratore ad accesso casuale che punta alla posizione del primo elemento nell'intervallo da ordinare.

_Fine
Iteratore ad accesso casuale che punta alla prima posizione oltre l'elemento finale nell'intervallo da ordinare.

_Chunk_size
Dimensione minima di un blocco che verrà suddiviso in due per l'esecuzione parallela.

Osservazioni:

Il primo overload usa il confronto std::lessbinario .

Nel secondo overload viene utilizzato il confronto binario fornito in cui deve essere presente la firma bool _Func(T, T) dove T è il tipo degli elementi dell'intervallo di input.

parallel_transform

Applica un oggetto funzione specificato ad ogni elemento di un intervallo di origine o a una coppia di elementi di due intervalli di origine e copia i valori restituiti dell'oggetto funzione in un intervallo di destinazione, in parallelo. Questa funzione è 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);

Parametri

_Input_iterator1
Tipo del primo iteratore o di quello solo di input.

_Output_iterator
Tipo dell'iteratore di output.

_Unary_operator
Tipo del funtore unario che deve essere eseguito in ogni elemento nell'intervallo di input.

_Input_iterator2
Tipo del secondo iteratore di input.

_Binary_operator
Tipo del funtore binario eseguito a livello pairwise negli elementi di due intervalli di origine.

_Partitioner
first1
Iteratore di input che punta alla posizione del primo elemento nel primo intervallo o in quello solo origine da utilizzare.

last1
Iteratore di input che punta alla prima posizione dopo l'elemento finale nel primo intervallo o in quello solo di origine da utilizzare.

_Risultato
Iteratore di output che punta alla posizione del primo elemento nell'intervallo di destinazione.

_Unary_op
Oggetto funzione unario definito dall'utente che viene applicato a ogni elemento nell'intervallo di origine.

first2
Iteratore di input che punta alla posizione del primo elemento nel secondo intervallo di origine da utilizzare.

_Binary_op
Oggetto funzione binario definito dall'utente applicato a livello pairwise, in ordine progressivo, ai due intervalli di origine.

Valore restituito

Iteratore di output che punta alla prima posizione dopo l'elemento finale nell'intervallo di destinazione in cui vengono ricevuti gli elementi di output trasformati dall'oggetto funzione.

Osservazioni:

auto_partitioner verranno usati per gli overload senza un argomento partitioner esplicito.

Per gli iteratori che non supportano l'accesso casuale, è supportato solo auto_partitioner .

Tramite gli overload che accettano l'argomento _Unary_op l'intervallo di input viene trasformato in quello di output applicando il funtore unario a ogni elemento nell'intervallo di input. _Unary_op deve supportare l'operatore di chiamata di funzione con la firma operator()(T) dove T è il tipo di valore dell'intervallo che viene scorso.

Tramite gli overload che accettano l'argomento _Binary_op i due intervalli di input vengono trasformati nell'intervallo di output applicando il funtore binario a un elemento del primo intervallo di input e a un elemento dal secondo. _Binary_op deve supportare l'operatore di chiamata di funzione con la firma operator()(T, U) dove T e U sono i tipi di valori dei due iteratori di input.

Per altre informazioni, vedere Algoritmi paralleli.

ricezione

Un'implementazione di ricezione generale, che consente a un contesto di attendere i dati esattamente da un'origine e di filtrare i valori accettati.

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

Parametri

T
Tipo di payload.

_Src
Puntatore o riferimento all'origine da cui sono previsti i dati.

_Timeout
Tempo massimo per il quale il metodo deve essere utilizzato per i dati, espresso in millisecondi.

_Filter_proc
Funzione di filtro che determina se i messaggi devono essere accettati.

Valore restituito

Valore dell'origine del tipo di payload.

Osservazioni:

Se il parametro _Timeout ha un valore diverso dalla costante COOPERATIVE_TIMEOUT_INFINITE, l'eccezione operation_timed_out viene generata se la quantità di tempo specificata scade prima della ricezione di un messaggio. Se si desidera un timeout di lunghezza zero, è consigliabile usare la funzione try_receive anziché chiamare receive con un timeout pari 0 a (zero), perché è più efficiente e non genera eccezioni nei timeout.

Per altre informazioni, vedere Funzioni di passaggio dei messaggi.

run_with_cancellation_token

Esegue un oggetto funzione immediatamente e in modo sincrono nel contesto di uno specifico token di annullamento.

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

Parametri

_Funzione
Tipo dell'oggetto funzione che sarà richiamato.

_Func
Oggetto funzione che verrà eseguito. Questo oggetto deve supportare l'operatore di chiamata di funzione con una firma void(void).

_Ct
Token di annullamento tramite cui verrà controllato l'annullamento implicito dell'oggetto funzione. Utilizzare cancellation_token::none() se si desidera che la funzione venga eseguita senza alcuna possibilità di annullamento implicito da un gruppo di attività padre che viene annullato.

Osservazioni:

Quando l'oggetto cancellation_token viene annullato, verranno attivati tutti i punti di interruzione nell'oggetto funzione. Tramite il token esplicito _Ct questo parametro _Func verrà isolato dall'annullamento padre se al padre è associato un token diverso o se non ne dispone.

send

Un'operazione di invio sincrona che attende fino a quando la destinazione accetta o rifiuta il messaggio.

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

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

Parametri

T
Tipo di payload.

_Trg
Puntatore o riferimento alla destinazione a cui vengono inviati i dati.

_Dati
Riferimento ai dati da inviare.

Valore restituito

true se il messaggio è stato accettato, false in caso contrario.

Osservazioni:

Per altre informazioni, vedere Funzioni di passaggio dei messaggi.

set_ambient_scheduler

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

Parametri

_Pianificazione
Utilità di pianificazione ambientale da impostare.

set_task_execution_resources

Limita le risorse di esecuzione usate dai thread di lavoro interni del runtime di concorrenza al set di affinità specificato.

È valido chiamare questo metodo solo prima della creazione di Gestione risorse o tra due cicli di vita di Gestione risorse. Può essere chiamato più volte a condizione che Gestione risorse non esista al momento della chiamata. Dopo aver impostato un limite di affinità, rimane attiva fino alla successiva chiamata al metodo set_task_execution_resources.

La maschera di affinità fornita non deve essere un sottoinsieme della maschera di affinità del processo. L'affinità del processo verrà aggiornata, se necessario.

void __cdecl set_task_execution_resources(
    DWORD_PTR _ProcessAffinityMask);

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

Parametri

_ProcessAffinityMask
Maschera di affinità in base alla quale devono essere limitati i thread di lavoro del runtime di concorrenza. Utilizzare questo metodo in un sistema con più di 64 thread hardware solo se si desidera limitare il runtime di concorrenza a un subset del gruppo di processori correnti. In genere, è necessario utilizzare la versione del metodo che accetta una matrice di affinità di gruppo come parametro, per limitare l'affinità in computer con più di 64 thread hardware.

count
Numero di voci GROUP_AFFINITY nella matrice specificata dal parametro _PGroupAffinity.

_PGroupAffinity
Matrice di voci GROUP_AFFINITY.

Osservazioni:

Il metodo genererà un'eccezione invalid_operation se resource manager è presente al momento della chiamata e un'eccezione invalid_argument se l'affinità specificata restituisce un set vuoto di risorse.

La versione del metodo che accetta una matrice di affinità di gruppo come parametro deve essere utilizzata solo nei sistemi operativi con versione Windows 7 o superiore. In caso contrario, viene generata un'eccezione invalid_operation .

La modifica dell'affinità di processo a livello di codice dopo che questo metodo è stato richiamato non causerà la rivalutazione dell'affinità con cui Resource Manager è limitata. Pertanto, tutte le modifiche all'affinità di processo devono essere realizzate prima di chiamare questo metodo.

scambio

Scambia gli elementi di due oggetti concurrent_vector.

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

Parametri

T
Tipo di dati degli elementi archiviati nei vettori simultanei.

_Ax
Tipo di allocatore dei vettori simultanei.

_Un
Vettore simultaneo i cui elementi devono essere scambiati con quelli del vettore _Bsimultaneo .

_B
Vettore simultaneo che fornisce gli elementi da scambiare o il vettore i cui elementi devono essere scambiati con quelli del vettore _Asimultaneo .

Osservazioni:

La funzione modello è un algoritmo specializzato nella classe concurrent_vector contenitore per eseguire la funzione _Amembro . concurrent_vector::swap( _B). Si tratta di istanze di ordinamento parziale dei modelli di funzione da parte del compilatore. Quando le funzioni modello sono sottoposte a overload in modo tale che la corrispondenza del modello con la chiamata di funzione non è univoca, il compilatore seleziona la versione più specializzata della funzione modello. La versione generale della funzione modello, template <class T> void swap(T&, T&), nella classe dell'algoritmo funziona per assegnazione ed è un'operazione lenta. La versione specializzata presente in ogni contenitore è molto più veloce, dal momento che funziona con la rappresentazione interna della classe contenitore.

Questo metodo non è sicuro per la concorrenza. È necessario assicurarsi che nessun altro thread stia eseguendo operazioni su uno dei vettori simultanei quando si chiama questo metodo.

task_from_exception

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

Parametri

_TaskType

_ExType

_Eccezione

_TaskOptions

Valore restituito

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

Parametri

_Param

_TaskOptions

Valore restituito

Trace_agents_register_name

Associa il nome specificato con il blocco di messaggi o l'agente nella traccia ETW.

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

Parametri

T
Tipo dell'oggetto . Si tratta in genere di un blocco di messaggi o di un agente.

_PObject
Puntatore al blocco di messaggi o all'agente che viene denominato nella traccia.

_Nome
Nome dell'oggetto fornito.

try_receive

Un'implementazione di ricezione try generale, che consente a un contesto di cercare i dati esattamente da un'origine e di filtrare i valori accettati. Se i dati non sono pronti, il metodo restituirà 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);

Parametri

T
Tipo di payload

_Src
Puntatore o riferimento all'origine da cui sono previsti i dati.

_Valore
Riferimento a una posizione in cui verrà inserito il risultato.

_Filter_proc
Funzione di filtro che determina se i messaggi devono essere accettati.

Valore restituito

Valore bool che indica se un payload è stato inserito in _value.

Osservazioni:

Per altre informazioni, vedere Funzioni di passaggio dei messaggi.

wait

Consente di sospendere il contesto corrente per un intervallo di tempo specificato.

void __cdecl wait(unsigned int _Milliseconds);

Parametri

_Millisecondi
Numero di millisecondi durante i quali il contesto corrente deve essere sospeso. Se il parametro _Milliseconds viene impostato sul valore 0, il contesto corrente deve essere eseguito in altri contesti eseguibili prima di continuare.

Osservazioni:

Se questo metodo viene chiamato in un contesto dell'utilità di pianificazione del runtime di concorrenza, l'utilità di pianificazione troverà un contesto diverso da eseguire sulla risorsa sottostante. Poiché l'utilità di pianificazione è cooperativa di natura, non è possibile riprendere il contesto subito dopo il numero di millisecondi specificati. Se tramite l'utilità di pianificazione vengono eseguite altre attività che non vengono passate in modo cooperativo all'utilità, il periodo di attesa potrebbe essere indefinito.

when_all

Crea un'attività che verrà completata correttamente quando tutte le attività fornite come argomenti verranno completate.

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

Parametri

_Iteratore
Tipo di iteratore di input.

_Iniziare
Posizione del primo elemento nell'intervallo di elementi da combinare nell'attività risultante.

_Fine
Posizione del primo elemento oltre l'intervallo di elementi da combinare nell'attività risultante.

_TaskOptions
Oggetto task_options.

Valore restituito

Attività che viene completata correttamente quando tutte le attività di input sono state completate correttamente. Se le attività di input sono di tipo T, l'output di questa funzione sarà task<std::vector<T>>. Se le attività di input sono di tipo void, anche l'attività di output sarà task<void>.

Osservazioni:

when_all è una funzione non bloccante che produce task come risultato. A differenza di task::wait, è possibile chiamare questa funzione in un'app UWP nel thread ASTA (Application STA).

Se una delle attività viene annullata o genera un'eccezione, l'attività restituita verrà completata in anticipo, nello stato annullato e l'eccezione, se si verifica, verrà generata se si chiama task::get o task::wait su tale attività.

Per altre informazioni, vedere Parallelismo delle attività.

when_any

Crea un'attività che verrà completata correttamente quando una qualsiasi delle attività fornite come argomenti verrà completata.

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

Parametri

_Iteratore
Tipo di iteratore di input.

_Iniziare
Posizione del primo elemento nell'intervallo di elementi da combinare nell'attività risultante.

_Fine
Posizione del primo elemento oltre l'intervallo di elementi da combinare nell'attività risultante.

_TaskOptions
_Cancellationtoken
Token di annullamento che controlla l'annullamento dell'attività restituita. Se non si fornisce un token di annullamento, l'attività risultante riceverà il token di annullamento dell'attività che ne causa il completamento.

Valore restituito

Attività che viene completata correttamente quando una delle attività di input è stata completata. Se le attività di input sono di tipo T, l'output di questa funzione sarà un task<std::pair<T, size_t>>>, dove il primo elemento della coppia è il risultato dell'attività in corso di completamento e il secondo elemento è l'indice dell'attività completata. Se le attività di input sono di tipo void l'output è un task<size_t>, dove il risultato è l'indice dell'attività in corso di completamento.

Osservazioni:

when_any è una funzione non bloccante che produce task come risultato. A differenza di task::wait, è possibile chiamare questa funzione in un'app UWP nel thread ASTA (Application STA).

Per altre informazioni, vedere Parallelismo delle attività.

Vedi anche

Spazio dei nomi concurrency