Gyorsító és accelerator_view objektumok használata

A gyorsítóval és accelerator_view osztályokkal megadhatja az eszközt vagy az emulátort a C++ AMP-kód futtatásához. Egy rendszer több olyan eszközzel vagy emulátorsal rendelkezhet, amely a memória mennyisége, a megosztott memória támogatása, a hibakeresési támogatás vagy a dupla pontosságú támogatás alapján különbözik. A C++ gyorsított masszív párhuzamosság (C++ AMP) olyan API-kat biztosít, amelyekkel megvizsgálhatja a rendelkezésre álló gyorsítókat, beállíthatja az egyiket alapértelmezettként, több accelerator_views adhat meg a parallel_for_each több hívásához, és speciális hibakeresési feladatokat hajthat végre.

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.

Az alapértelmezett gyorsító használata

A C++ AMP futtatókörnyezet alapértelmezett gyorsítót választ, hacsak nem ír kódot egy adott elem kiválasztásához. A futtatókörnyezet az alábbi módon választja ki az alapértelmezett gyorsítót:

1. Ha az alkalmazás hibakeresési módban fut, van egy olyan gyorsító, amely támogatja a hibakeresést.

2. Ellenkező esetben, ha be van állítva, a(z) CPPAMP_DEFAULT_ACCELERATOR környezeti változó által megadott gyorsító.

3. Egyébként egy nem emulált eszköz.

4. Ellenkező esetben az eszköz, amely a legnagyobb mennyiségű rendelkezésre álló memóriával rendelkezik.

5. Ellenkező esetben olyan eszköz, amely nincs csatlakoztatva a kijelzőhöz.

Emellett a futtatókörnyezet az alapértelmezett gyorsítóhoz megad egy access_type típusú access_type_auto elemet. Ez azt jelenti, hogy az alapértelmezett gyorsító megosztott memóriát használ, ha támogatott, és ha a teljesítmény jellemzői (sávszélesség és késés) ismerten megegyeznek a dedikált (nem megosztott) memóriával.

Az alapértelmezett gyorsító tulajdonságait az alapértelmezett gyorsító felépítésével és tulajdonságainak vizsgálatával határozhatja meg. Az alábbi példakód az alapértelmezett gyorsító elérési útját, a gyorsító memóriájának mennyiségét, a megosztott memória támogatását, a dupla pontosságú támogatást és az alapértelmezett gyorsító korlátozott dupla pontosságú támogatását nyomtatja ki.

void default_properties() {
    accelerator default_acc;
    std::wcout << default_acc.device_path << "\n";
    std::wcout << default_acc.dedicated_memory << "\n";
    std::wcout << (accs[i].supports_cpu_shared_memory ?
        "CPU shared memory: true" : "CPU shared memory: false") << "\n";
    std::wcout << (accs[i].supports_double_precision ?
        "double precision: true" : "double precision: false") << "\n";
    std::wcout << (accs[i].supports_limited_double_precision ?
        "limited double precision: true" : "limited double precision: false") << "\n";
}

CPPAMP_DEFAULT_ACCELERATOR környezeti változó

A környezeti változót CPPAMP_DEFAULT_ACCELERATOR beállíthatja az accelerator::device_path alapértelmezett gázpedál megadásához. Az elérési út hardverfüggő. Az alábbi kód a függvény használatával accelerator::get_all lekéri az elérhető gyorsítók listáját, majd megjeleníti az egyes gyorsítók elérési útját és jellemzőit.

void list_all_accelerators()
{
    std::vector<accelerator> accs = accelerator::get_all();

    for (int i = 0; i <accs.size(); i++) {
        std::wcout << accs[i].device_path << "\n";
        std::wcout << accs[i].dedicated_memory << "\n";
        std::wcout << (accs[i].supports_cpu_shared_memory ?
            "CPU shared memory: true" : "CPU shared memory: false") << "\n";
        std::wcout << (accs[i].supports_double_precision ?
            "double precision: true" : "double precision: false") << "\n";
        std::wcout << (accs[i].supports_limited_double_precision ?
            "limited double precision: true" : "limited double precision: false") << "\n";
    }
}

Gyorsító kiválasztása

Egy gázgyorsító kiválasztásához a accelerator::get_all metódussal lekérheti az elérhető gyorsítók listáját, majd kiválaszthat egyet a tulajdonságai alapján. Ez a példa bemutatja, hogyan választhatja ki a legtöbb memóriával rendelkező gázpedált:

void pick_with_most_memory()
{
    std::vector<accelerator> accs = accelerator::get_all();
    accelerator acc_chosen = accs[0];

    for (int i = 0; i <accs.size(); i++) {
        if (accs[i].dedicated_memory> acc_chosen.dedicated_memory) {
            acc_chosen = accs[i];
        }
    }

    std::wcout << "The accelerator with the most memory is "
        << acc_chosen.device_path << "\n"
        << acc_chosen.dedicated_memory << ".\n";
}

Megjegyzés:

Az egyik gyorsító, amelyet a accelerator::get_all visszaad, a processzorgyorsító. A processzorgyorsítón nem lehet kódot végrehajtani. A CPU gyorsító szűréséhez hasonlítsa össze a által visszaadott gyorsító accelerator::get_all tulajdonságának értékét a accelerator::cpu_accelerator értékével. További információkért lásd a jelen cikk "Speciális gyorsítók" című szakaszát.

Megosztott memória

A megosztott memória a processzor és a gyorsító által egyaránt elérhető memória. A megosztott memória használata kiküszöböli vagy jelentősen csökkenti az adatok másolásának többletterhelését a processzor és a gyorsító között. Bár a memória meg van osztva, a processzor és a gyorsító nem tudja egyidejűleg elérni, és ez nem definiált viselkedést okoz. A supports_cpu_shared_memory agyorsító tulajdonság akkor ad visszatrue, ha a gyorsító támogatja a megosztott memóriát, és a default_cpu_access_type tulajdonság megkapja az alapértelmezett access_type a acceleratormemóriához lefoglalt memóriához – például a hozzá társított acceleratorvagy array_view a acceleratorrajta elért objektumokhoz.

A C++ AMP-futtatókörnyezet automatikusan a legjobb alapértelmezett értéket access_type választja mindegyikhez accelerator, de a megosztott memória teljesítményjellemzői (sávszélesség és késés) rosszabbak lehetnek, mint a dedikált (nem megosztott) gyorsítómemória, amikor a PROCESSZORról olvasnak, vagy a processzorról írnak, vagy mindkettő. Ha a megosztott memória olvasás és írás során a processzorból olyan jól teljesít, mint a dedikált memória, akkor a futtatókörnyezet alapértelmezettként a access_type_read_write-t választja; ellenkező esetben egy konzervatívabb alapértelmezést access_type-t választ, és lehetővé teszi az alkalmazás számára, hogy felülírja ezt, ha a számítási kernelek memóriahozzáférési mintái egy eltérő access_type használatát teszik előnyössé.

Az alábbi példakód bemutatja, hogyan állapítható meg, hogy az alapértelmezett gyorsító támogatja-e a megosztott memóriát, majd felülbírálja az alapértelmezett hozzáférési típust, és létrehoz belőle egy accelerator_view értéket.

#include <amp.h>
#include <iostream>

using namespace Concurrency;

int main()
{
    accelerator acc = accelerator(accelerator::default_accelerator);

    // Early out if the default accelerator doesn't support shared memory.
    if (!acc.supports_cpu_shared_memory)
    {
        std::cout << "The default accelerator does not support shared memory" << std::endl;
        return 1;
    }

    // Override the default CPU access type.
    acc.set_default_cpu_access_type(access_type_read_write);

    // Create an accelerator_view from the default accelerator. The
    // accelerator_view reflects the default_cpu_access_type of the
    // accelerator it's associated with.
    accelerator_view acc_v = acc.default_view;
}

An accelerator_view mindig tükrözi az default_cpu_access_typeaccelerator-ját, és nem biztosít felületet a access_type felülbírálásához vagy módosításához.

Az alapértelmezett gyorsító módosítása

Az alapértelmezett gyorsítót a metódus meghívásával módosíthatja accelerator::set_default . Az alapértelmezett gyorsítót alkalmazás-végrehajtásonként csak egyszer módosíthatja, és módosítania kell, mielőtt bármilyen kódot végrehajtanának a GPU-n. Bármely további függvényhívás a gyorsító változtatására false-et ad vissza. Ha másik gázpedált szeretne használni egy hívásban parallel_for_each, olvassa el a jelen cikk "Többgyorsító használata" című szakaszát. Az alábbi példakód úgy állítja be az alapértelmezett gyorsítót, hogy nincs emulált, nincs kijelzőhöz csatlakoztatva, és támogatja a dupla pontosságot.

bool pick_accelerator()
{
    std::vector<accelerator> accs = accelerator::get_all();
    accelerator chosen_one;

    auto result = std::find_if(accs.begin(), accs.end(),
        [] (const accelerator& acc) {
            return !acc.is_emulated &&
                acc.supports_double_precision &&
                !acc.has_display;
        });

    if (result != accs.end()) {
        chosen_one = *(result);
    }

    std::wcout <<chosen_one.description <<std::endl;
    bool success = accelerator::set_default(chosen_one.device_path);
    return success;
}

Többgyorsító használata

Kétféleképpen használhat több gyorsítót az alkalmazásban:

• A accelerator_view objektumokat továbbíthatja a parallel_for_each metódus hívásainak.

• Tömbobjektumot egy adott accelerator_view objektummal hozhat létre. A C++ AMP futtatókörnyezet felveszi a accelerator_view objektumot a lambda kifejezésben rögzített tömbobjektumból.

Speciális gyorsítók

A három speciális gyorsító eszközútvonalai az accelerator osztály tulajdonságaiként érhetők el:

• accelerator::direct3d_ref Data Member: Ez az egyszálas gyorsító szoftvert használ a processzoron egy általános grafikus kártya emulálását. Alapértelmezés szerint hibakeresésre használják, de éles környezetben nem hasznos, mert lassabb, mint a hardvergyorsítók. Emellett csak a DirectX SDK-ban és a Windows SDK-ban érhető el, és nem valószínű, hogy telepítve lesz az ügyfelek számítógépén. További információ: GPU-kód hibakeresése.

• accelerator::direct3d_warp Adattag: Ez a gyorsító alternatív megoldást kínál a C++ AMP-kód streamelési SIMD-bővítményeket (SSE) használó többmagos processzorokon való futtatására.

• gyorsító::cpu_accelerator Adattag: Ezt a gyorsítót használhatja előkészítési tömbök beállításához. Nem tudja végrehajtani a C++ AMP-kódot. További információ: Átmeneti tömbök a C++ AMP-ben bejegyzés a Natív kód párhuzamos programozása blogon.

Interoperabilitás

A C++ AMP futtatókörnyezet támogatja az osztály és a accelerator_view Direct3D ID3D11Device interfész közötti együttműködést. A create_accelerator_view metódus egy IUnknown felületet használ, és visszaad egy objektumot accelerator_view . A get_device metódus egy objektumot accelerator_view vesz fel, és egy IUnknown felületet ad vissza.

Lásd még

C++ AMP (C++ gyorsított masszív párhuzamosság)
GPU-kód hibakeresése
accelerator_view osztály