Funzione parallel_for_each (C++ AMP)
Esegue una funzione tramite il dominio di calcolo. Per ulteriori informazioni, vedere Cenni preliminari su C++ AMP.
template <
int _Rank,
typename _Kernel_type
>
void parallel_for_each(
const extent<_Rank>& _Compute_domain,
const _Kernel_type &_Kernel
);
template <
int _Dim0,
int _Dim1,
int _Dim2,
typename _Kernel_type
>
void parallel_for_each(
const tiled_extent<_Dim0, _Dim1, _Dim2>& _Compute_domain,
const _Kernel_type& _Kernel
);
template <
int _Dim0,
int _Dim1,
typename _Kernel_type
>
void parallel_for_each(
const tiled_extent<_Dim0, _Dim1>& _Compute_domain,
const _Kernel_type& _Kernel
);
template <
int _Dim0,
typename _Kernel_type
>
void parallel_for_each(
const tiled_extent<_Dim0>& _Compute_domain,
const _Kernel_type& _Kernel
);
template <
int _Rank,
typename _Kernel_type
>
void parallel_for_each(
const accelerator_view& _Accl_view,
const extent<_Rank>& _Compute_domain,
const _Kernel_type& _Kernel
);
template <
int _Dim0,
int _Dim1,
int _Dim2,
typename _Kernel_type
>
void parallel_for_each(
const accelerator_view& _Accl_view,
const tiled_extent<_Dim0, _Dim1, _Dim2>& _Compute_domain,
const _Kernel_type& _Kernel
);
template <
int _Dim0,
int _Dim1,
typename _Kernel_type
>
void parallel_for_each(
const accelerator_view& _Accl_view,
const tiled_extent<_Dim0, _Dim1>& _Compute_domain,
const _Kernel_type& _Kernel
);
template <
int _Dim0,
typename _Kernel_type
>
void parallel_for_each(
const accelerator_view& _Accl_view,
const tiled_extent<_Dim0>& _Compute_domain,
const _Kernel_type& _Kernel
);
Parametri
_Accl_view
L'oggetto accelerator_view su cui eseguire il calcolo in parallelo._Compute_domain
Un oggetto extent che contiene i dati per il calcolo._Dim0
La dimensione dell'oggetto tiled_extent._Dim1
La dimensione dell'oggetto tiled_extent._Dim2
La dimensione dell'oggetto tiled_extent._Kernel
Un oggetto lambda o funzione che accetta un argomento di tipo "index<_Rank>" ed esegue il calcolo in parallelo._Kernel_type
Un lambda o un funtore._Rank
Numero di dimensioni dell'extent.
Note
La funzione parallel_for_each inizia i calcoli paralleli sui dispositivi acceleratore. Il comportamento di base di parallel_for_each è simile a quello di for_each, che esegue una funzione su ogni elemento che è in un contenitore. Componenti di base in una chiamata a parallel_for_each sono un dominio di calcolo, un indice e una funzione del kernel. Quando parallel_for_each è in esecuzione, un'attività parallela viene eseguita per ogni indice nel dominio di calcolo. È possibile utilizzare l'attività in parallelo per accedere agli elementi nelle matrici di input o di output. Una chiamata a parallel_for_each si comporta come se fosse sincrona. In pratica, la chiamata è asincrona perché lavora su un dispositivo separato. Non esistono garanzie sull'ordine e sulla concorrenza delle attività parallele eseguite da parallel_for_each non affiancati. Le attività possono comunicare solo utilizzando funzioni atomiche.
La versione parallela di parallel_for_each organizza le attività in parallelo in sezioni che hanno una dimensione fissa e 1, 2, o 3 dimensioni, come specificato nell'argomento tiled_extent. I thread della stessa sezione hanno accesso a tutte le variabili dichiarate con la parola chiave tile_static. È possibile utilizzare il metodo Metodo tile_barrier::wait per sincronizzare l'accesso alle variabili dichiarate con la parola chiave tile_static. Queste restrizioni vengono imposte sull'oggetto parallel_for_each affiancato:
Il prodotto delle dimensioni del tile extent non può superare 1024.
3D: D0 * D1 * D2 ≤ 1024; and D0 ≤ 64
2D: D0 * D1 ≤ 1024
1D: D0 ≤ 1024
La griglia parallela fornita come primo parametro a parallel_for_each deve essere divisibile, lungo ciascuna delle sue dimensioni, in base al corrispondente tile extent.
Per ulteriori informazioni, vedere Utilizzo di sezioni.
Il codice parallel_for_each viene eseguito su un acceleratore, in genere un dispositivo GPU. È possibile passare in modo esplicito questo acceleratore a parallel_for_each come un parametro opzionale accelerator_view. In caso contrario, l'acceleratore viene scelto dagli oggetti di tipo array<T,N>, che sono nella funzione del kernel. Se tutti gli array non sono associati allo stesso acceleratore, viene generata un'eccezione. L'argomento tiled_index passato al kernel, contiene una raccolta di indici, compresi quelli relativi alla sezione corrente.
Il parametro _Kernel della funzione parallel_for_each deve essere un oggetto lambda o un oggetto funzione. Per essere eseguito su un acceleratore, l'oggetto lambda deve includere la clausola restrict(amp) sebbene possa aggiungere restrizioni aggiuntive. La clausola di restrizione comporta diverse restrizioni della funzione del kernel. Per ulteriori informazioni, vedere Clausola di restrizione (AMP C++).
È necessario poter poter essere in grado di richiamare l'argomento _Kernel utilizzando uno dei seguenti tipi di argomento:
Non-tiled: index<N>, dove N deve essere dello stesso grado di extent<N> utilizzato in parallel_for_each.
Tiled: un oggetto tiled_index le cui dimensioni corrispondono a quelli dell'oggetto tiled_extent utilizzato nella chiamata a parallel_for_each.
La funzione del kernel deve restituire void.
Poiché la funzione del kernel non accetta altri argomenti, tutti gli altri dati elaborati dal kernel devono essere acquisiti nell'oggetto lambda o funzione. Tutti i dati acquisiti devono essere passati per valore, ad eccezione degli oggetti array<T,N>, che devono essere acquisiti per riferimento o puntatore. Alcune restrizioni si applicano anche ai tipi di oggetti che possono venire acquisiti. Per ulteriori informazioni, vedere Clausola di restrizione (AMP C++).
Se si verifica un errore quando si tenta di avviare la chiamata parallel_for_each, il runtime genera un'eccezione. Le eccezioni possono essere generate per i seguenti motivi:
Errore nel creare lo shader.
Errore nel creare i buffer.
Extent passato non valido.
Acceleratori non corrispondenti.
Requisiti
Intestazione: amp.h
Spazio dei nomi: Concurrency