Utilisation des objets accelerator et accelerator_view

Article
03/04/2013

Vous pouvez utiliser les classes accélérator et accelerator_view pour spécifier le périphérique ou l'émulateur pour exécuter votre code C++ AMP.Un système peut avoir plusieurs appareils ou émulateurs qui varient selon la quantité de mémoire, la prise en charge du débogage, ou la prise en charge en double précision.Le parallélisme massif accéléré par C++ (C++ AMP) fournit des API que vous pouvez utiliser pour examiner les accélérateurs disponibles, en définir un comme valeur par défaut, spécifier plusieurs accélérateurs pour plusieurs appels au parallel_for_each, et effectuer des tâches spéciales de débogage.

À l'aide de l'accélérateur par défaut

Le runtime C++ AMP choisit un accélérateur par défaut, à moins que vous écrivez le code pour en choisir un spécifique.Le runtime sélectionne l'accélérateur par défaut comme suit :

Si l'application s'exécute en mode débogage, un accélérateur qui prend en charge le débogage.
Sinon, l'accélérateur spécifié par la variable d'environnement de CPPAMP_DEFAULT_ACCELERATOR, si elle est définie.
Sinon, un périphérique non émulé.
Sinon, le périphérique qui a la plus grande quantité de mémoire disponible.
Sinon, un périphérique qui n'est pas attaché à l'affichage.

Vous pouvez déterminer les propriétés de l'accélérateur par défaut lorsque vous construisez l'accélérateur par défaut et en examinant ses propriétés.L'exemple de code suivant imprime le chemin d'accès, la mémoire, et la prise en charge en double précision de l'accélérateur par défaut.

void default_properties() {
    accelerator default_acc;
    std::wcout << default_acc.device_path << "\n";
    std::wcout << default_acc.dedicated_memory << "\n";
    std::wcout << (default_acc.supports_double_precision ? 
        "double precision: true" : "double precision: false") << "\n";
}

Variable d'environnement de CPPAMP_DEFAULT_ACCELERATOR

Vous pouvez définir la variable d'environnement de CPPAMP_DEFAULT_ACCELERATOR pour spécifier accelerator::device_path de l'accélérateur par défaut.Le chemin d'accès est dépendant du matériel.Le code suivant utilise la fonction d' accelerator::get_all pour récupérer une liste des accélérateurs disponibles puis pour afficher le chemin d'accès de chaque accélérateur.

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_double_precision ? 
            "double precision: true" : "double precision: false") << "\n";    
    }
}

En sélectionnant un accélérateur

Pour sélectionner un accélérateur, utilisez la méthode accelerator::get_all pour récupérer une liste des accélérateurs disponibles puis pour sélectionner en un en fonction de ses propriétés.Cet exemple montre comment choisir l'accélérateur ayant le plus de mémoire :

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

[!REMARQUE]

L'un des accélérateurs retournés par accelerator::get_all est l'accélérateur du CPU.Vous ne pouvez pas exécuter du code sur l'accélérateur du CPU.Pour filtrer l'accélérateur du CPU, comparez la valeur de la propriété device_path de l'accélérateur retourné par accelerator::get_all avec la valeur accelerator::cpu_accelerator.Pour plus d'informations, consultez la section « d'accélérateurs spéciaux » dans cet article.

En modifiant l'accélérateur par défaut

Vous pouvez modifier l'accélérateur par défaut en appelant la méthode accelerator::set_default .Vous pouvez seulement modifier l'accélérateur par défaut une fois par exécution de l'application et vous devez le modifier avant que tout code soit exécuté sur le GPU.Tous les appels de fonction suivants pour modifier l'accélérateur retourne false.Si vous souhaitez utiliser un accélérateur différent dans un appel à parallel_for_each, lisez la section « utilisation de plusieurs accélérateurs » dans cet article.L'exemple de code suivant définit l'accélérateur par défaut à un non émulé, qui n'est pas connecté à un affichage, et qui prend en charge la double précision.

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

En utilisant plusieurs accélérateurs

Il existe deux façons d'utiliser plusieurs accélérateurs dans votre application :

Vous pouvez passer des objets accelerator_view à des appels à la méthode parallel_for_each .
Vous pouvez construire un objet array à l'aide d'un objet spécifique accelerator .Le runtime de C+AMP prendra l'objet accelerator_view de l'objet capturé array dans l'expression lambda.

Accélérateurs spéciaux

Les chemins d'accès de périphérique de trois accélérateurs spéciaux sont disponibles comme des propriétés de la classe accelerator :

accelerator::direct3d_ref, données membres: Cet accélérateur monothread utilise le logiciel sur le CPU pour émuler une carte graphique générique.Il est utilisé par défaut pour le débogage, mais il n'est pas utile dans la production car il est plus lent que les accélérateurs matériel.En outre, il est uniquement disponible dans le SDK de Direct X et Windows, et il est peu probable qu'il soit installé sur les ordinateurs de vos clients.Pour plus d’informations, consultez Débogage du code GPU.
accelerator::direct3d_warp, données membres: Cet accélérateur fournit une solution de secours pour exécuter le code C++ AMP sur les processeurs multicœurs qui utilisent des extensions Streaming SIMD (SSE).
accelerator::cpu_accelerator, données membres: Vous pouvez utiliser cet accélérateur pour installer des tableaux temporaires.Le code C++ AMP ne peut pas être exécutéPour plus d'informations, consultez Tableaux temporaires dans C++ AMP publié sur la programmation parallèle dans le blog sur le code natif.

Interopérabilité

Le runtime C++ AMP prend en charge l'interopabilité entre la classe accelerator_view et l' interface d'ID3D11DeviceDirect 3D.La méthode create_accelerator_view prend une interface IUnknown et retourne un objet de type accelerator_view .La méthode get_device prend un objet accelerator_view et retourne une interface de type IUknown .