Lambdas, függvényobjektumok és korlátozott függvények használata

A gyorsítón futtatni kívánt C++ AMP-kód argumentumként van megadva a parallel_for_each metódus hívásában. Megadhat egy lambda kifejezést vagy egy függvényobjektumot (funktort) az argumentumként. Emellett a lambda kifejezés vagy függvényobjektum C++ AMP-korlátozott függvényt is meghívhat. Ez a témakör tömbfeladási algoritmust használ a lambdák, a függvényobjektumok és a korlátozott függvények bemutatásához. Az alábbi példa c++ AMP-kód nélküli algoritmust mutat be. Két egyenlő hosszúságú egydimenziós tömb jön létre. A megfelelő egész számelemek egy harmadik egydimenziós tömbben lesznek hozzáadva és tárolva. A C++ AMP nem használható.

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 kifejezés

A lambda kifejezés használata a legközvetebb módszer a C++ AMP használatával a kód újraírására.

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";
    }
}

A lambda kifejezésnek tartalmaznia kell egy indexelési paramétert, és tartalmaznia kell.restrict(amp) A példában a array_viewsum objektum rangja 1. Ezért a lambda utasítás paramétere egy 1. rangot tartalmazó indexobjektum . Futásidőben a lambda kifejezést a rendszer egyszer hajtja végre a array_view objektum egyes elemeihez. További információt a Lambda kifejezésszintaxisában talál.

Függvényobjektum

A gyorsító kódot függvényobjektumba is beleszámíthatja.

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";
    }
}

A függvényobjektumnak konstruktort kell tartalmaznia, és tartalmaznia kell a függvényhívási operátor túlterhelését. A függvényhívási operátornak tartalmaznia kell egy indexelési paramétert. A függvényobjektum egy példánya a parallel_for_each metódus második argumentumaként lesz átadva. Ebben a példában három array_view objektum lesz átadva a függvényobjektum-konstruktornak. A array_view objektum sum rangja 1. Ezért a függvényhívási operátor paramétere egy 1. rangot tartalmazó indexobjektum . Futásidőben a függvény végrehajtása egyszer történik a array_view objektum egyes elemeihez. További információ: Függvényhívás és függvényobjektumok a C++ standard kódtárban.

C++ AMP-Restricted függvény

A gyorsítókódot tovább bonthatja szét egy korlátozott függvény létrehozásával, amelyet egy lambda kifejezésből vagy függvényobjektumból hív meg. Az alábbi példakód bemutatja, hogyan hívhat meg korlátozott függvényeket egy lambda kifejezésből.

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)
        {
            AddElementsWithRestrictedFunction(idx, sum, a, b);
        });

    for (int i = 0; i <5; i++) {
        std::cout <<sum[i] <<"\n";
    }
}

A korlátozott függvénynek tartalmaznia restrict(amp) kell és meg kell felelnie a korlátozásban (C++ AMP) leírt korlátozásoknak.

Lásd még

C++ AMP (C++ gyorsított masszív párhuzamosság)
Lambda kifejezés szintaxisa
Függvényhívás
Függvényobjektumok a C++ standard kódtárban
korlátozás (C++ AMP)