Lambdas, functieobjecten en beperkte functies gebruiken

De C++ AMP-code die u op de accelerator wilt uitvoeren, wordt opgegeven als een argument in een aanroep naar de parallel_for_each methode. U kunt een lambda-expressie of een functieobject (functor) opgeven als dat argument. Daarnaast kan de lambda-expressie of het functieobject een C++ AMP-beperkte functie aanroepen. In dit onderwerp wordt een algoritme voor het toevoegen van matrixen gebruikt om lambdas, functieobjecten en beperkte functies te demonstreren. In het volgende voorbeeld ziet u het algoritme zonder C++ AMP-code. Er worden twee 1dimensionale matrices met gelijke lengte gemaakt. De bijbehorende gehele getallen worden toegevoegd en opgeslagen in een derde 1-dimensionale matrix. C++ AMP wordt niet gebruikt.

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-expressie

Het gebruik van een lambda-expressie is de meest directe manier om C++ AMP te gebruiken om de code opnieuw te schrijven.

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

De lambda-expressie moet één indexeringsparameter bevatten en moet bevatten restrict(amp). In het voorbeeld heeft het array_viewsum object een rang van 1. Daarom is de parameter voor de lambda-instructie een indexobject met rang 1. Tijdens runtime wordt de lambda-expressie eenmaal uitgevoerd voor elk element in het array_view-object . Zie De syntaxis van lambda-expressie voor meer informatie.

Functieobject

U kunt de code van de accelerator in een functieobject factoren.

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

Het functieobject moet een constructor bevatten en moet een overbelasting van de operator voor functieaanroepen bevatten. De operator voor functieoproep moet één indexeringsparameter bevatten. Een exemplaar van het functieobject wordt doorgegeven als het tweede argument aan de methode parallel_for_each . In dit voorbeeld worden drie array_view objecten doorgegeven aan de functieobjectconstructor. Het array_view-objectsum heeft een rang van 1. Daarom is de parameter voor de operator voor functieaanroep een indexobject met rang 1. Tijdens runtime wordt de functie eenmaal uitgevoerd voor elk element in het array_view-object . Zie Functieoproep - en functieobjecten in de C++-standaardbibliotheek voor meer informatie.

C++ AMP-Restricted Functie

U kunt de code van de accelerator verder factoreren door een beperkte functie te maken en deze aan te roepen vanuit een lambda-expressie of een functieobject. In het volgende codevoorbeeld ziet u hoe u een beperkte functie aanroept vanuit een lambda-expressie.

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

De beperkte functie moet de beperkingen bevatten restrict(amp) en voldoen aan de beperkingen die worden beschreven in restrict (C++ AMP).

Zie ook

C++ AMP (C++ Versneld massaal parallellisme)
Syntaxis van lambda-expressie
Functieoproep
Functieobjecten in de standaardbibliotheek van C++
beperken (C++ AMP)