Usar C++ AMP en aplicaciones para UWP

Puedes usar C++ AMP (C++ Accelerated Massive Parallelism) en tu aplicación para la Plataforma universal de Windows (UWP) para realizar cálculos en la GPU (Unidad de procesamiento de gráficos) u otros aceleradores computacionales. Sin embargo, C++ AMP no proporciona API para trabajar directamente con tipos de Windows Runtime y Windows Runtime no proporciona un contenedor para C++ AMP. Cuando usas tipos de Windows Runtime en el código (incluidos los que has creado por ti mismo), debes convertirlos a tipos compatibles con C++ AMP.

Nota:

Los encabezados de C++ AMP están en desuso a partir de la versión 17.0 de Visual Studio 2022. Si se incluyen encabezados AMP, se generarán errores de compilación. Defina _SILENCE_AMP_DEPRECATION_WARNINGS antes de incluir encabezados AMP para silenciar las advertencias.

Consideraciones sobre el rendimiento

Si usas extensiones de componentes de Visual C++ C++/CX para crear tu aplicación para la Plataforma universal de Windows (UWP), te recomendamos que uses tipos de datos sin formato antiguos (POD) junto con almacenamiento contiguo (por ejemplo, std::vector o matrices de estilo C) para los datos que se usarán con C++ AMP. Esto puede ayudarle a lograr un mayor rendimiento que al usar tipos no-POD o contenedores de Windows Runtime porque no es necesario realizar marshaling.

En un kernel de C++ AMP, para acceder a los datos almacenados de esta manera, simplemente encapsula std::vector o el almacenamiento de matriz en un concurrency::array_view, y luego usa la vista de matriz en un bucle concurrency::parallel_for_each.

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

Manipulación de tipos de Windows Runtime

Cuando trabajas con las API de Windows Runtime, es posible que quieras usar C++ AMP en los datos almacenados en un contenedor de Windows Runtime, como o Platform::Array<T>^ en tipos de datos complejos, como clases o estructuras que se declaran mediante la palabra clave ref o la palabra clave value . En estas situaciones, debe realizar un trabajo adicional para que los datos estén disponibles para C++ AMP.

Platform::Array<T>^, donde T es un tipo POD

Cuando encuentres un Platform::Array<T>^ y T es un tipo POD, puedes acceder a su almacenamiento subyacente simplemente con la función miembro get.

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

Si T no es un tipo POD, use la técnica que se describe en la sección siguiente para usar los datos con C++ AMP.

Tipos de Windows Runtime: clases ref y clases de valor

C++ AMP no admite tipos de datos complejos. Esto incluye tipos que no son POD y todos los tipos que se declaran mediante la palabra clave ref o la palabra clave value . Si se usa un tipo no admitido en un restrict(amp) contexto, se genera un error en tiempo de compilación.

Cuando encuentre un tipo no admitido, puede copiar partes interesantes de sus datos en un concurrency::array objeto . Además de hacer que los datos estén disponibles para que C++ AMP los consuma, este enfoque de copia manual también puede mejorar el rendimiento maximizando la localidad de los datos y asegurándose de que los datos que no se usarán no se copien en el acelerador. Puede mejorar aún más el rendimiento mediante una matriz de preparación, que es una forma especial de concurrency::array que indica al entorno de ejecución de AMP que se optimice la matriz para la transferencia frecuente entre ella y otras matrices en el acelerador especificado.

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

Consulte también

Creación de tu primera aplicación para UWP con C++
Crear componentes de Windows Runtime en C++