Utilizzo di espressioni lambda, oggetti funzione e funzioni con restrizioni
Il codice C++ AMP che si desidera eseguire sull'acceleratore viene specificato come argomento nella chiamata al metodo parallel_for_each.È possibile fornire una lambda espressione o un oggetto funzione (functor) come tale argomento.Inoltre, la lambda espressione o l'oggetto funzione possono chiamare una funzione C++ AMP limitata.In questo argomento viene utilizzato un algoritmo di somma di matrice per illustrare le funzioni lambda, gli oggetti funzione e le funzioni limitate.Nell'esempio riportato di seguito viene illustrato l'algoritmo senza codice C++ AMP.Vengono create due matrici monodimensionali di uguale lunghezza.Gli elementi integer corrispondenti vengono sommati e memorizzati in una terza matrice monodimensionale.C++ AMP non viene utilizzato.
void CpuMethod() {
int aCPP[] = {1, 2, 3, 4, 5};
int bCPP[] = {6, 7, 8, 9, 10};
int sumCPP[5];
for (int idx = 0; idx < 5; idx++)
{
sumCPP[idx] = aCPP[idx] + bCPP[idx];
}
for (int idx = 0; idx < 5; idx++)
{
std::cout << sumCPP[idx] << "\n";
}
}
Lambda Espressione
Utilizzare una lambda espressione è il modo più diretto per usare C++ AMP per riscrivere il codice.
void AddArraysWithLambda() {
int aCPP[] = {1, 2, 3, 4, 5};
int bCPP[] = {6, 7, 8, 9, 10};
int sumCPP[5];
array_view<const int, 1> a(5, aCPP);
array_view<const int, 1> b(5, bCPP);
array_view<int, 1> sum(5, sumCPP);
sum.discard_data();
parallel_for_each(
sum.extent,
[=](index<1> idx) restrict(amp)
{
sum[idx] = a[idx] + b[idx];
}
);
for (int i = 0; i < 5; i++) {
std::cout << sum[i] << "\n";
}
}
La lambda espressione deve includere un parametro di indicizzazione e deve includere restrict(amp).Nell'esempio, l'oggetto array_viewsum ha rango uguale a 1.Di conseguenza, il parametro verso la lambda espressione è un oggetto indice con rango 1.In fase di esecuzione, la lambda espressione viene eseguita una volta per ogni elemento dell'oggetto array_view.Per ulteriori informazioni, vedere Sintassi delle espressioni lambda.
Oggetto Function
È possibile scomporre il codice dell' acceleratore in un oggetto funzione.
class AdditionFunctionObject
{
public:
AdditionFunctionObject(const array_view<int, 1>& a,
const array_view<int, 1>& b,
const array_view<int, 1>& sum
)
: a(a), b(b), sum(sum)
{
}
void operator()(index<1> idx) restrict(amp)
{
sum[idx] = a[idx] + b[idx];
}
private:
array_view<int, 1> a;
array_view<int, 1> b;
array_view<int, 1> sum;
};
void AddArraysWithFunctionObject() {
int aCPP[] = {1, 2, 3, 4, 5};
int bCPP[] = {6, 7, 8, 9, 10};
int sumCPP[5];
array_view<const int, 1> a(5, aCPP);
array_view<const int, 1> b(5, bCPP);
array_view<int, 1> sum(5, sumCPP);
sum.discard_data();
parallel_for_each(
sum.extent,
AdditionFunctionObject(a, b, sum)
);
for (int i = 0; i < 5; i++) {
std::cout << sum[i] << "\n";
}
}
L'oggetto funzione deve includere un costruttore e deve includere un overload dell'operatore di chiamata a funzione.L'operatore di chiamata a funzione deve includere un parametro indicizzante.Un'istanza dell'oggetto funzione viene passata come secondo argomento al metodo parallel_for_each.In questo esempio, tre oggetti array_view vengono passati al costruttore dell'oggetto funzione.L'oggetto sumarray_view ha rango 1.Di conseguenza, il parametro dell'operatore chiamata a funzione è un oggetto index con rango 1.In fase di esecuzione, la funzione viene eseguita una volta per ogni elemento dell'oggetto array_view.Per ulteriori informazioni, vedere Chiamata di funzione (C++) e Oggetti funzione.
Funzione C++ AMP Limitata
È possibile scomporre ulteriormente il codice dell' acceleratore creando una funzione limitata e chiamandola da una lambda espressione o da un oggetto funzione.Nell'esempio di codice riportato di seguito viene illustrato come chiamare una funzione limitata a partire da una lambda espressione.
void AddElementsWithRestrictedFunction(index<1> idx, array_view<int, 1> sum, array_view<int, 1> a, array_view<int, 1> b) restrict(amp)
{
sum[idx] = a[idx] + b[idx];
}
void AddArraysWithFunction() {
int aCPP[] = {1, 2, 3, 4, 5};
int bCPP[] = {6, 7, 8, 9, 10};
int sumCPP[5];
array_view<int, 1> a(5, aCPP);
array_view<int, 1> b(5, bCPP);
array_view<int, 1> sum(5, sumCPP);
sum.discard_data();
parallel_for_each(
sum.extent,
[=](index<1> idx) restrict(amp)
{
AddElements(idx, sum, a, b);
}
);
for (int i = 0; i < 5; i++) {
std::cout << sum[i] << "\n";
}
}
La funzione limitata deve includere restrict(amp) ed essere conforme alle limitazioni descritte in Clausola di restrizione (AMP C++).
Vedere anche
Riferimenti
Sintassi delle espressioni lambda
Clausola di restrizione (AMP C++)