A C++ AMP használata az UWP-alkalmazásokban

A C++ AMP (C++ gyorsított masszív párhuzamosság) használatával az Univerzális Windows Platform (UWP) alkalmazásban számításokat végezhet a GPU-n (grafikus feldolgozási egységen) vagy más számítási gyorsítókon. A C++ AMP azonban nem biztosít API-kat a Közvetlen Windows-futtatókörnyezet-típusok kezeléséhez, és a Windows futtatókörnyezet nem biztosít burkolót a C++ AMP-hez. Ha windowsos futtatókörnyezet-típusokat használ a kódban – beleértve azokat is, amelyeket ön hozott létre –, a C++ AMP-vel kompatibilis típusokká kell konvertálnia őket.

Megjegyzés:

A C++ AMP fejlécek elavultak a Visual Studio 2022 17.0-s verziójától kezdve. Az AMP-fejlécek beépítése építési hibákat fog okozni. A figyelmeztetések elnémításához a _SILENCE_AMP_DEPRECATION_WARNINGS definiálása előtt az AMP-fejléceket be kell vonni.

Teljesítménnyel kapcsolatos szempontok

Ha a Visual C++ C++/CX összetevőbővítményeket használja az univerzális Windows Platform (UWP) alkalmazás létrehozásához, javasoljuk, hogy a C++ AMP-vel használni kívánt adatokhoz használjon hagyományos adattípusokat (POD) folyamatos tárhellyel, például std::vector vagy C-stílusú tömböket. Ez segíthet a magasabb teljesítmény elérésében, mint a nem-POD típusok vagy a Windows Runtime tárolók használata esetén, mivel nincs szükség marsallálásra.

Egy C++ AMP-kernelben az így tárolt adatok eléréséhez egyszerűen csomagolja be a std::vector vagy a tömbtárolót egy concurrency::array_view-be, majd használja a tömbnézetet egy concurrency::parallel_for_each hurokban.

// 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];
    });

Windows Runtime-típusok kezelésének átvezetése

A Windows Runtime API-k használatakor érdemes lehet a C++ AMP-t használni a Windows Futtatókörnyezet tárolóban tárolt adatokon, például egy Platform::Array<T>^ vagy összetett adattípusokban, például osztályokban vagy szerkezetekben, amelyeket a ref kulcsszóval vagy az érték kulcsszóval deklaráltak. Ezekben az esetekben további munkát kell végeznie, hogy az adatokat elérhetővé tegye a C++ AMP számára.

Platform::Tömb<T>^, ahol T podtípus

Ha egy Platform::Array<T>^ T podtípussal találkozik, a mögöttes tárolót csak a get tagfüggvény használatával érheti el:

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));

Ha a T nem POD típusú, használja a következő szakaszban ismertetett technikát az adatok C++ AMP-vel való használatához.

Windows futtatókörnyezet-típusok: ref osztályok és értékosztályok

A C++ AMP nem támogatja az összetett adattípusokat. Ide tartoznak a nem POD-típusok és a ref kulcsszóval vagy az érték kulcsszóval deklarált típusok. Ha restrict(amp) környezetben nem támogatott típust használ, fordítási hiba keletkezik.

Ha nem támogatott típussal találkozik, az adatok érdekes részeit átmásolhatja egy concurrency::array objektumba. Amellett, hogy a C++ AMP számára elérhetővé teszi az adatokat, ez a manuális másolási módszer az adat helyének maximalizálásával és annak biztosításával is javíthatja a teljesítményt, hogy a nem használt adatok ne legyenek átmásolva a gázpedálba. A teljesítményt tovább javíthatja egy átmeneti tömb használatával, amely a concurrency::array egy speciális formája, és jelzést ad az AMP futtatókörnyezetnek arról, hogy a tömböt optimalizálni kell a megadott gyorsító és más tömbök közötti gyakori átvitelre.

// 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;
    });

Lásd még

Az első UWP-alkalmazás létrehozása a C++ használatával
Windows futtatókörnyezeti összetevők létrehozása a C++ rendszerben

Last updated on 2016-11-04