Delen via

C++ AMP gebruiken in UWP-apps

U kunt C++ AMP (C++ Accelerated Massive Parallelism) in uw UWP-app (Universal Windows Platform) gebruiken om berekeningen uit te voeren op de GPU (Graphics Processing Unit) of andere rekenkundige accelerators. C++ AMP biedt echter geen API's voor het rechtstreeks werken met Windows Runtime-typen en de Windows Runtime biedt geen wrapper voor C++ AMP. Wanneer u Windows Runtime-typen gebruikt in uw code, inclusief de typen die u zelf hebt gemaakt, moet u deze converteren naar typen die compatibel zijn met C++ AMP.

Opmerking

C++ AMP-headers worden afgeschaft vanaf Visual Studio 2022 versie 17.0. Als u AMP-headers opneemt, zullen er buildfouten optreden. Definieer _SILENCE_AMP_DEPRECATION_WARNINGS voordat u AMP-headers opneemt om de waarschuwingen te onderdrukken.

Prestatie-overwegingen

Als u Visual C++-onderdeelextensies C++/CX gebruikt om uw UWP-app (Universal Windows Platform) te maken, raden we u aan om POD-typen (plain-old-data) te gebruiken in combinatie met aaneengesloten opslag, bijvoorbeeld std::vector of C-stijl arrays, voor gegevens die met C++ AMP worden gebruikt. Dit kan u helpen hogere prestaties te bereiken dan door niet-POD-typen of Windows Runtime-containers te gebruiken, omdat er geen marshaling hoeft te gebeuren.

In een C++ AMP-kernel kunt u toegang krijgen tot gegevens die op deze manier zijn opgeslagen, verpakt u de std::vector of matrixopslag in een concurrency::array_view en gebruikt u vervolgens de matrixweergave in een concurrency::parallel_for_each lus:

// simple vector addition example
std::vector<int> data0(1024, 1);
std::vector<int> data1(1024, 2);
std::vector<int> data_out(data0.size(), 0);

concurrency::array_view<int, 1> av0(data0.size(), data0);
concurrency::array_view<int, 1> av1(data1.size(), data1);
concurrency::array_view<int, 1> av2(data_out.size(), data2);

av2.discard_data();

concurrency::parallel_for_each(av0.extent, [=](concurrency::index<1> idx) restrict(amp)
    {
        av2[idx] = av0[idx] + av1[idx];
    });

Marshaling Windows Runtime-typen

Wanneer u met Windows Runtime-API's werkt, wilt u mogelijk C++ AMP gebruiken voor gegevens die zijn opgeslagen in een Windows Runtime-container, zoals een Platform::Array<T>^ of in complexe gegevenstypen, zoals klassen of structs die worden gedeclareerd met behulp van het trefwoord verw of het waardewoord . In deze situaties moet u wat extra werk doen om de gegevens beschikbaar te maken voor C++ AMP.

Platform::Array<T>^, waarbij T een POD-type is

Wanneer u een Platform::Array<T>^ tegenkomt en als T een POD-type is, kunt u de onderliggende opslag benaderen door gebruik te maken van de get lidfunctie.

Platform::Array<float>^ arr; // Assume that this was returned by a Windows Runtime API
concurrency::array_view<float, 1> av(arr->Length, &arr->get(0));

Als T geen POD-type is, gebruikt u de techniek die wordt beschreven in de volgende sectie om de gegevens te gebruiken met C++ AMP.

Typen Windows Runtime: refklassen en waardeklassen

C++ AMP biedt geen ondersteuning voor complexe gegevenstypen. Dit omvat niet-POD-typen en alle typen die worden gedeclareerd door het trefwoord ref of het trefwoord waarde te gebruiken. Als een niet-ondersteund type wordt gebruikt in een restrict(amp) context, wordt er een compilatiefout gegenereerd.

Wanneer u een niet-ondersteund type tegenkomt, kunt u interessante delen van de gegevens naar een concurrency::array object kopiëren. Naast het beschikbaar maken van de gegevens die C++ AMP kan gebruiken, kan deze methode voor handmatig kopiëren ook de prestaties verbeteren door de locatie van gegevens te maximaliseren en ervoor te zorgen dat gegevens die niet worden gebruikt, niet naar de accelerator worden gekopieerd. U kunt de prestaties verder verbeteren met behulp van een staging-array, wat een speciale vorm van concurrency::array is die een hint biedt aan de AMP-runtime dat de array moet worden geoptimaliseerd voor frequente overdracht tussen de array en andere arrays op de opgegeven accelerator.

// pixel_color.h
ref class pixel_color sealed
{
public:
    pixel_color(Platform::String^ color_name, int red, int green, int blue)
    {
        name = color_name;
        r = red;
        g = green;
        b = blue;
    }

    property Platform::String^ name;
    property int r;
    property int g;
    property int b;
};

// Some other file

std::vector<pixel_color^> pixels (256);

for (pixel_color ^pixel : pixels)
{
    pixels.push_back(ref new pixel_color("blue", 0, 0, 255));
}

// Create the accelerators
auto cpuAccelerator = concurrency::accelerator(concurrency::accelerator::cpu_accelerator);
auto devAccelerator = concurrency::accelerator(concurrency::accelerator::default_accelerator);

// Create the staging arrays
concurrency::array<float, 1> red_vec(256, cpuAccelerator.default_view, devAccelerator.default_view);
concurrency::array<float, 1>  blue_vec(256, cpuAccelerator.default_view, devAccelerator.default_view);

// Extract data from the complex array of structs into staging arrays.
concurrency::parallel_for(0, 256, [&](int i)
    {
        red_vec[i] = pixels[i]->r;
        blue_vec[i] = pixels[i]->b;
    });

// Array views are still used to copy data to the accelerator
concurrency::array_view<float, 1> av_red(red_vec);
concurrency::array_view<float, 1> av_blue(blue_vec);

// Change all pixels from blue to red.
concurrency::parallel_for_each(av_red.extent, [=](index<1> idx) restrict(amp)
    {
        av_red[idx] = 255;
        av_blue[idx] = 0;
    });

Zie ook

Uw eerste UWP-app maken met C++
Windows Runtime-onderdelen maken in C++

  • Last updated on