Usar objetos accelerator y accelerator_viewUsing accelerator and accelerator_view Objects

Puede usar el acelerador y accelerator_view las clases para especificar el dispositivo o emulador para ejecutar el código de C++ AMP.You can use the accelerator and accelerator_view classes to specify the device or emulator to run your C++ AMP code on. Un sistema podría tener varios dispositivos o los emuladores que se distinguen por la cantidad de memoria, la compatibilidad de memoria compartida, la compatibilidad con la depuración ni la compatibilidad de doble precisión.A system might have several devices or emulators that differ by amount of memory, shared memory support, debugging support, or double-precision support. C++ Accelerated Massive Parallelism (C++ AMP) proporciona las API que puede utilizar para examinar los aceleradores disponibles, establezca uno de ellos como el valor predeterminado, especifique varios objetos accelerator_views para varias llamadas a parallel_for_each y realizar tareas de depuración especiales.C++ Accelerated Massive Parallelism (C++ AMP) provides APIs that you can use to examine the available accelerators, set one as the default, specify multiple accelerator_views for multiple calls to parallel_for_each, and perform special debugging tasks.

Usar el Acelerador predeterminadoUsing the Default Accelerator

El tiempo de ejecución de C++ AMP recoge un acelerador predeterminado, a menos que escriba código para seleccionar una en concreto.The C++ AMP runtime picks a default accelerator, unless you write code to pick a specific one. El runtime elige el Acelerador predeterminado como sigue:The runtime chooses the default accelerator as follows:

  1. Si la aplicación se ejecuta en modo de depuración, un acelerador que admite la depuración.If the app is running in debug mode, an accelerator that supports debugging.

  2. En caso contrario, el acelerador especificado por la variable de entorno CPPAMP_DEFAULT_ACCELERATOR, si se establece.Otherwise, the accelerator that's specified by the CPPAMP_DEFAULT_ACCELERATOR environment variable, if it's set.

  3. En caso contrario, un dispositivo no emulados.Otherwise, a non-emulated device.

  4. En caso contrario, el dispositivo que tiene la mayor cantidad de memoria disponible.Otherwise, the device that has the greatest amount of available memory.

  5. En caso contrario, un dispositivo que no esté conectado a la pantalla.Otherwise, a device that's not attached to the display.

    Además, el tiempo de ejecución especifica un access_type de access_type_auto para el Acelerador predeterminado.Additionally, the runtime specifies an access_type of access_type_auto for the default accelerator. Esto significa que el Acelerador predeterminado utiliza memoria compartida si se admite y sus características de rendimiento (ancho de banda y latencia) suelen ser la misma que la memoria dedicada (no compartidos).This means that the default accelerator uses shared memory if it’s supported and if its performance characteristics (bandwidth and latency) are known to be the same as dedicated (non-shared) memory.

    Puede determinar las propiedades del Acelerador predeterminado mediante la construcción el Acelerador predeterminado y examinar sus propiedades.You can determine the properties of the default accelerator by constructing the default accelerator and examining its properties. En el ejemplo de código siguiente se imprime la ruta de acceso, la cantidad de memoria de acelerador, compatibilidad con memoria compartida, compatibilidad de doble precisión y una compatibilidad limitada con precisión doble del Acelerador predeterminado.The following code example prints the path, amount of accelerator memory, shared memory support, double-precision support, and limited double-precision support of the default accelerator.

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

Variable de entorno CPPAMP_DEFAULT_ACCELERATORCPPAMP_DEFAULT_ACCELERATOR Environment Variable

Puede establecer la variable de entorno CPPAMP_DEFAULT_ACCELERATOR para especificar el accelerator::device_path del Acelerador predeterminado.You can set the CPPAMP_DEFAULT_ACCELERATOR environment variable to specify the accelerator::device_path of the default accelerator. La ruta de acceso depende del hardware.The path is hardware-dependent. El siguiente código utiliza el accelerator::get_all función para recuperar una lista de los aceleradores disponibles y, a continuación, muestra la ruta de acceso y las características de cada acelerador.The following code uses the accelerator::get_all function to retrieve a list of the available accelerators and then displays the path and characteristics of each accelerator.

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

Al seleccionar una tecla de aceleraciónSelecting an Accelerator

Para seleccionar un acelerador, use la accelerator::get_all método para recuperar una lista de los aceleradores disponibles y, a continuación, seleccione una en función de sus propiedades.To select an accelerator, use the accelerator::get_all method to retrieve a list of the available accelerators and then select one based on its properties. Este ejemplo muestra cómo seleccionar el acelerador que tiene la mayor cantidad de memoria:This example shows how to pick the accelerator that has the most memory:

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

Nota

Uno de los aceleradores que se devuelven por accelerator::get_all es el Acelerador de CPU.One of the accelerators that are returned by accelerator::get_all is the CPU accelerator. No se puede ejecutar código en el Acelerador de CPU.You cannot execute code on the CPU accelerator. Para filtrar el Acelerador de CPU, compare el valor de la device_path propiedad del acelerador que es devuelto por accelerator::get_all con el valor de la accelerator::cpu_accelerator.To filter out the CPU accelerator, compare the value of the device_path property of the accelerator that's returned by accelerator::get_all with the value of the accelerator::cpu_accelerator. Para obtener más información, vea la sección "Aceleradores especial" en este artículo.For more information, see the "Special Accelerators" section in this article.

Memoria compartidaShared Memory

Memoria compartida es la memoria que puede tener acceso a la CPU y el acelerador.Shared memory is memory that can be accessed by both the CPU and the accelerator. El uso de memoria compartida se elimina o reduce considerablemente la sobrecarga de copiar datos entre la CPU y el acelerador.The use of shared memory eliminates or significantly reduces the overhead of copying data between the CPU and the accelerator. Aunque la memoria se comparte, no se puede tener acceso simultáneamente a la CPU y el acelerador y, al hacerlo provoca un comportamiento indefinido.Although the memory is shared, it cannot be accessed concurrently by both the CPU and the accelerator, and doing so causes undefined behavior. La propiedad de acelerador supports_cpu_shared_memory devuelve true si el acelerador es compatible con memoria compartida y el default_cpu_access_type propiedad obtiene el valor predeterminado access_type para la memoria asignada en el accelerator: por ejemplo, arrayque están asociadas a la accelerator, o array_view objetos obtiene acceso en la accelerator.The accelerator property supports_cpu_shared_memory returns true if the accelerator supports shared memory, and the default_cpu_access_type property gets the default access_type for memory allocated on the accelerator—for example, arrays associated with the accelerator, or array_view objects accessed on the accelerator.

El tiempo de ejecución de C++ AMP elige automáticamente el mejor valor predeterminado access_type para cada accelerator, pero las características de rendimiento (ancho de banda y latencia) de memoria compartida pueden ser peores que los de memoria dedicada acelerador (no compartidos) al leer de la CPU, escribir de la CPU, o ambos.The C++ AMP runtime automatically chooses the best default access_type for each accelerator, but the performance characteristics (bandwidth and latency) of shared memory can be worse than those of dedicated (non-shared) accelerator memory when reading from the CPU, writing from the CPU, or both. Si realiza la memoria compartida, así como memoria dedicada para lectura y escritura de la CPU, el tiempo de ejecución predeterminado access_type_read_write; en caso contrario, el runtime elige el valor predeterminado es más conservador access_typey permite que la aplicación reemplazarlo si tener acceso la memoria patrones de los kernels de su cálculo beneficiarán de otro access_type.If shared memory performs as well as dedicated memory for reading and writing from the CPU, the runtime defaults to access_type_read_write; otherwise, the runtime chooses a more conservative default access_type, and allows the app to override it if the memory access patterns of its computation kernels benefit from a different access_type.

En el ejemplo de código siguiente se muestra cómo determinar si el Acelerador predeterminado es compatible con memoria compartida y, a continuación, reemplaza el tipo de acceso predeterminado y crea un accelerator_view de él.The following code example shows how to determine whether the default accelerator supports shared memory, and then overrides its default access type and creates an accelerator_view from it.

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

Un accelerator_view siempre refleja el default_cpu_access_type de la accelerator que está asociado, y no proporciona ninguna interfaz para invalidar o cambiar su access_type.An accelerator_view always reflects the default_cpu_access_type of the accelerator it’s associated with, and it provides no interface to override or change its access_type.

Cambiar el Acelerador predeterminadoChanging the Default Accelerator

Puede cambiar el Acelerador predeterminado mediante una llamada a la accelerator::set_default método.You can change the default accelerator by calling the accelerator::set_default method. Puede cambiar el Acelerador predeterminado de una sola vez por cada aplicación de ejecución y debe cambiarla antes de ejecutar cualquier código en la GPU.You can change the default accelerator only once per app execution and you must change it before any code is executed on the GPU. Devolverán las llamadas de función subsiguiente para cambiar el Acelerador false.Any subsequent function calls to change the accelerator return false. Si desea usar un acelerador de diferentes en una llamada a parallel_for_each, lea la sección "Usar los aceleradores varios" en este artículo.If you want to use a different accelerator in a call to parallel_for_each, read the "Using Multiple Accelerators" section in this article. En el ejemplo de código siguiente se establece el Acelerador predeterminado por uno que no se emula, no está conectado a una visualización y admite la precisión doble.The following code example sets the default accelerator to one that is not emulated, is not connected to a display, and supports double-precision.

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

Usar varios aceleradoresUsing Multiple Accelerators

Hay dos maneras de utilizar varias aceleradores de la aplicación:There are two ways to use multiple accelerators in your app:

  • Puede pasar accelerator_view objetos a las llamadas a la parallel_for_each método.You can pass accelerator_view objects to the calls to the parallel_for_each method.

  • Puede construir un array objeto con un determinado accelerator_view objeto.You can construct an array object using a specific accelerator_view object. El tiempo de ejecución de C + AMP recogerá el accelerator_view objeto desde el capturada array objeto en la expresión lambda.The C+AMP runtime will pick up the accelerator_view object from the captured array object in the lambda expression.

Aceleradores especialesSpecial Accelerators

Las rutas de acceso de dispositivo de tres aceleradores especiales están disponibles como propiedades de la accelerator clase:The device paths of three special accelerators are available as properties of the accelerator class:

  • Miembro de datos direct3d_ref: este acelerador de un único subproceso usa el software en la CPU para emular una tarjeta gráfica genérico.accelerator::direct3d_ref Data Member: This single-threaded accelerator uses software on the CPU to emulate a generic graphics card. Se utiliza de forma predeterminada para la depuración, pero no es útil en producción porque es más lento que los aceleradores de hardware.It's used by default for debugging, but it's not useful in production because it's slower than the hardware accelerators. Además, está disponible en el SDK de DirectX y el SDK de Windows, y es probable que estén instalados en equipos de sus clientes.Additionally, it's available only in the DirectX SDK and the Windows SDK, and it's unlikely to be installed on your customers' computers. Para obtener más información, consulte depurar código de GPU.For more information, see Debugging GPU Code.

  • Miembro de datos direct3d_warp: este acelerador proporciona una solución de reserva para la ejecución de código de C++ AMP en las CPU de varios núcleos que utilizan las extensiones SIMD de transmisión por secuencias (SSE).accelerator::direct3d_warp Data Member: This accelerator provides a fallback solution for executing C++ AMP code on multi-core CPUs that use Streaming SIMD Extensions (SSE).

  • Miembro de datos Accelerator::cpu_accelerator: puede usar este acelerador para la configuración de matrices de almacenamiento provisional.accelerator::cpu_accelerator Data Member: You can use this accelerator for setting up staging arrays. No puede ejecutar código de C++ AMP.It cannot execute C++ AMP code. Para obtener más información, consulte el matrices de almacenamiento provisional en C++ AMP post en la programación paralela en código nativo.For more information, see the Staging Arrays in C++ AMP post on the Parallel Programming in Native Code blog.

InteroperabilidadInteroperability

El tiempo de ejecución de C++ AMP admite la interoperabilidad entre el accelerator_view clase y la Direct3D ID3D11Device interfaz.The C++ AMP runtime supports interoperability between the accelerator_view class and the Direct3D ID3D11Device interface. El create_accelerator_view método toma una IUnknown interfaz y devuelve un accelerator_view objeto.The create_accelerator_view method takes an IUnknown interface and returns an accelerator_view object. El get_device método toma una accelerator_view objeto y devuelve una IUknown interfaz.The get_device method takes an accelerator_view object and returns an IUknown interface.

Vea tambiénSee Also

C++ AMP (C++ Accelerated Massive Parallelism) C++ AMP (C++ Accelerated Massive Parallelism)
Depurar código de GPU Debugging GPU Code
accelerator_view (clase)accelerator_view Class