parallel_for_each, fonction (C++ AMP)
Exécute une fonction sur le domaine de calcul. Pour plus d'informations, consultez Présentation de 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
);
Paramètres
_Accl_view
L'objet accelerator_view sur lequel sera exécuter le calcul parallèle._Compute_domain
Un objet extent qui contient les données pour le calcul._Dim0
Dimension de l'objet tiled_extent._Dim1
Dimension de l'objet tiled_extent._Dim2
Dimension de l'objet tiled_extent._Kernel
Un objet lambda ou fonction qui prend un argument de type « index<_Rank> » et exécute le calcul parallèle._Kernel_type
Un lambda ou un objet de fonction (functor)._Rank
Rang de l'extent.
Remarques
La fonction parallel_for_each démarre des calculs de données parallèles sur les périphériques d'accélérateur. Le comportement de base de parallel_for_each est similaire à celui de for_each, qui exécute une fonction sur chaque élément qui se trouve dans un conteneur. Les composants de base dans un appel à parallel_for_each sont un domaine de calcul, un index et une fonction principale. Lorsque parallel_for_each s'exécute, une activité parallèle est gérée pour chaque index dans le domaine de calcul. Vous pouvez utiliser l'activité parallèle pour accéder aux éléments dans les tableaux d'entrée ou de sortie. Un appel à parallel_for_each se comporte comme s'il était synchrone. Dans la pratique, l'appel est asynchrone parce qu'il s'exécute sur un périphérique distinct. Il n'existe aucune garantie concernant la commande et l'accès concurrentiel des activités parallèles exécutées par parallel_for_each qui n'est pas en mosaïque. Les activités communiquent qu'à l'aide des fonctions atomiques.
La version en mosaïque de parallel_for_each organise les activités parallèles en mosaïques qui ont une taille fixe et 1, 2 ou 3 dimensions, comme spécifié dans l'argument tiled_extent. Les threads de la même mosaïque ont accès à toutes les variables déclarées avec le mot clé tile_static. Vous pouvez utiliser la méthode tile_barrier::wait, méthode pour synchroniser l'accès aux variables déclarées avec le mot clé tile_static. Les restrictions suivantes s'appliquent aux mosaïques parallel_for_each :
Le produit des dimensions d'étendue de mosaïque ne peut pas dépasser 1024.
3D: D0 * D1 * D2 ≤ 1024 ; et D0 ≤ 64
2D: D0 * D1 ≤ 1024
1D: D0 ≤ 1024
La grille en mosaïque fournie comme premier paramètre à parallel_for_each doit être divisible, pour chacune de ses dimensions, par l'étendue de mosaïque correspondante.
Pour plus d'informations, consultez Utilisation des mosaïques.
Le code parallel_for_each s'exécute sur un accélérateur, généralement un périphérique GPU. Vous pouvez passer l'accélérateur explicitement à parallel_for_each comme paramètre facultatif accelerator_view. Sinon, l'accélérateur cible est choisi à partir des objets de type array<T,N> capturés dans la fonction noyau principale. Si tous les tableaux ne sont pas liés au même accélérateur, une exception est levée. L'argument tiled_index passé au noyau contient une collection d'index, y compris ceux qui sont relatifs à la mosaïque actuelle.
Le paramètre _Kernel de la fonction parallel_for_each doit être un objet lambda ou fonction. Pour s'exécuter sur un accélérateur, le lambda doit inclure la clause restrict(amp), bien qu'il puisse avoir des restrictions supplémentaires. La clause de restriction garantit plusieurs restrictions de la fonction noyau. Pour plus d'informations, consultez clause de restriction (C++ ampère).
Vous devez pouvoir appeler l'argument _Kernel en utilisant l'un des types d'arguments suivants :
Non organisé en mosaïque : index<N>, où N doit être du même rang que extent<N> utilisé dans parallel_for_each.
En mosaïque : Un objet tiled_index dont les dimensions correspondent à celles de l'objet tiled_extent utilisé dans l'appel à parallel_for_each.
La fonction noyau doit retourner void.
Étant donné que la fonction principale n'accepte aucun argument, toutes autres données opérées dessus par le noyau doivent être capturées dans l'objet lambda ou fonction. Toutes les données capturées doivent être passés par valeur, à l'exception des objets array<T,N>, qui doivent être capturés par référence ou pointeur. Plusieurs restrictions s'appliquent également aux types d'objets qui peuvent être capturés. Pour plus d'informations, consultez clause de restriction (C++ ampère).
Si une erreur se produit lorsque vous essayez de démarrer parallel_for_each, appeler le runtime lève une exception. Les exceptions peuvent être levées pour les raisons suivantes :
Échec de création du nuanceur.
Échec de création des mémoires tampons.
Étendue incorrecte passée.
Accélérateurs incompatibles.
Configuration requise
En-tête : amp.h
Espace de noms d'accès : Concurrency