Usando C++ AMP em aplicativos da Windows Store

Artigo
03/12/2013

Você pode usar o AMP C++ (paralelismo maciço acelerado C++) no seu aplicativo de Windows Store para executar cálculos em GPU (unidade de processamento gráfico) ou em outros aceleradores computacionais.No entanto, o AMP C++ não fornece APIs para trabalhar diretamente com tipos de Tempo de Execução do Windows (WinRT), e WinRT não fornece um wrapper para o AMP C++.Quando você usa WinRT em seu arquivo incluindo aqueles que o criá-la você deve converter os mesmos tipos que são compatíveis com AMP C++.

Considerações sobre desempenho

Se você estiver usando Extensões de componentes Visual C++C++/CX() para criar o aplicativo de Windows Store , é recomendável usar tipos de (POD) de liso-antigo- dados juntamente com contígua de armazenamento para o exemplo, o std::vector ou o C de estilo matrizes - para dados que serão usados com AMP C++.Isso pode ajudar a atingir um desempenho melhor do que usar tipos de não VAGEM ou contêiner do Windows RT porque nenhum organização precisa ocorrer.

O núcleo de AMP de c++, para acessar os dados que são armazenados dessa maneira, apenas quebra std::vector ou põe o armazenamento em concurrency::array_view e use o modo de matriz em um loop de 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];
});

Tipos de empacotamento de Tempo de Execução do Windows

Quando você trabalha com APIs de WinRT, convém usar o AMP C++ nos dados que são armazenados em um recipiente de WinRT como Platform::Array<T>^ ou em tipos de dados complexos como classes ou estruturas os que são declarados usando a palavra-chave de ref a palavra-chave ou de value .Nessas situações, você tem que fazer qualquer trabalho adicional para tornar os dados disponíveis para o AMP C++.

^ De Platform::Array<T>T, onde é um tipo de VAGEM

Quando você localiza Platform::Array<T>^ e T é um tipo de VAGEM, você pode acessar o armazenamento subjacente usando apenas a função de membro de get :

Platform::Array<float>^ arr; // Assume that this was returned by a WinRT API
concurrency::array_view<float, 1> av(arr->Length, &arr->get(0));

Se T não é um tipo de VAGEM, use a técnica que é descrito na seção a seguir para usar os dados com AMP C++.

Tipos de Tempo de Execução do Windows: classes de referência e classes de valor

O AMP C++ não da suporte para tipos de dados complexos.Isso inclui os tipos de não VAGEM e os quaisquer tipos que são declarados usando a palavra-chave de ref a palavra-chave ou de value .Se um tipo sem suporte é usado em um contexto de restrict(amp) , um erro de tempo de compilação é gerado.

Quando você encontrar um tipo sem suporte, você pode copiar as partes interessantes dos dados em um objeto de concurrency::array .Além de tornar dados disponíveis para o AMP C++ consome, essa abordagem manual- de impressão também pode melhorar o desempenho maximizando a localidade de dados, e assegurando os dados que não serão usados não são copiados para o acelerador.Você pode melhorar o desempenho mais usando uma matriz de teste, que é um formulário especial de concurrency::array que fornece uma dica para o tempo de execução de AMP que a matriz deve ser otimizada para a transferência frequente entre ele e outras matrizes no 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 também

Outros recursos

Criar seu primeiro aplicativo da Windows Store usando C++

Criando componentes de Tempo de Execução do Windows em C++

Partilhar via