Utilizando a GPU com c # [fechado]

Estou tentando obter mais poder de processamento da minha grade.

Estou usando todos os cpus / núcleos, é possível utilizar a GPU com c #.

Alguém conhece alguma biblioteca ou tem algum código de amostra?

[ Editar OUTUBRO 2017, pois até essa resposta envelhece ]

A maioria dessas respostas é bastante antiga, então pensei em fornecer um resumo atualizado de onde acho que cada projeto é:

• GPU.Net (TidePowerd) - Eu tentei isso há 6 meses ou mais e consegui fazê-lo funcionar, apesar de ter exigido um pouco de trabalho. Converte o código do kernel C # em cuda em tempo de compilação. Infelizmente, o site está inativo e o github não é atualizado há alguns anos, o que pode indicar que o projeto está morto ...

• Cudafy - Código aberto e muito fácil de usar. Converte o código do kernel C # em cuda em tempo de execução (com capacidade de serializar e armazenar em cache). Pode executar facilmente o mesmo código do kernel na CPU (principalmente para depuração). Suporta várias GPUs. Mais exemplos disponíveis do que outros aqui. O código padrão referido por outras respostas é mínimo e, no meu caso, pelo menos ajudou a entender como o código funciona. Cuda / Nvidia apenas embora. Infelizmente, parece que eles não atualizaram suas soluções por alguns anos também (último commit em 2015 - suporte ao cuda 7.0).

• Hibridizador . Solução comercial compilando C # para CUDA. Fornece uma edição gratuita da comunidade no visual studio marketplace e exemplos no github .

• Solução comercial AleaGPU com uma edição comunitária gratuita para GPUS de consumidor. Veja os comentários de Daniel para detalhes.

• Brahma - executa expressões LINQ via OpenCL (também suporta AMD). Não há muita documentação / exemplos. Última atualização em 2011.

• C $ - o último desenvolvimento foi há mais de 10 anos ...

• Microsoft Accelerator - da mesma forma, não parece mais estar sendo desenvolvido ativamente.

• outros ( C ++ AMP , OpenTK - dead / Cloo ) - muitos deles são apenas ligações - ou seja, permitem que você chame a GPU a partir de C #, mas o código do kernel (código que é realmente executado na GPU) precisa ser escrito em C ou OpenCL, o que significa que você deve usar (e aprender) outro idioma.

Como eu disse, eu recomendaria o Cudafy sobre todos os outros - se pudesse rodar no OpenCL e no Cuda, seria perfeito.

EDIT setembro 2013 Cudafy agora permite que você compilar para ambos CUDA e OpenCL, isso irá executar o mesmo código C # no em todas as GPUs. Isso parece fantástico, embora ainda não testei a compilação do OpenCL.

O Microsoft Research Accelerator era uma biblioteca .NET GP GPU.

Encontrei Brahma ... Ele também possui um provedor de GPGPU que permite a execução de métodos na GPU ... Obrigado pela pergunta ... Aprendi algo novo hoje. :)

Posso recomendar o XNA Game Studio como uma possível avenida para exploração? Obviamente, ele é voltado para a criação de jogos, mas oferece acesso gerenciado à sua placa gráfica e um acesso muito melhor às funções de enumeração de recursos e desenvolvimento de sombreadores do que estava disponível anteriormente, por exemplo, no Managed DirectX. Também existem maneiras de combinar o WinForms e o XNA em aplicativos híbridos:

http://www.ziggyware.com/news.php?readmore=866

Você precisará se esforçar para aprender a programação de sombreadores (o XNA suporta HLSL), mas essa pode ser uma abordagem mais simples do que aprender uma solução específica do fornecedor, como o CUDA da nVidia. A vantagem é que você pode programar em um ambiente 100% gerenciado. Aqui estão alguns links HLSL:

http://www.ziggyware.com/weblinks.php?cat_id=9

O site GPGPU também é um destino recomendado para a programação de GPU de uso geral:

http://gpgpu.org/

Boa sorte!

Que tal http://www.tidepowerd.com/ GPU.NET?

Aqui está outro: CUDAfy . Parece GPU.Net, pois algo tão simples quanto um atributo de método pode fazer com que todo o método seja executado na GPU. Mas, diferentemente do GPU.Net, o CUDAfy é gratuito e de código aberto.

O GPU.Net parece não exigir nenhum código padrão (de acordo com os documentos, ele é "injetado automaticamente pela ferramenta de construção") , enquanto o CUDAfy exige.

Aqui está um exemplo de criação de um aplicativo com CUDAfy.

Bem, esta é uma pergunta bastante antiga, e desde que foi perguntado as coisas mudaram muito.
Outra opção para usar o .Net para escrever o código da GPU, que ninguém mencionou nas respostas na Alea GPU . Abrange C #, F # e VB.

Ambiente profissional de desenvolvimento de software de GPU para .NET e Mono. Verdadeiramente multiplataforma

No site oficial do F #, o Alea é a primeira opção para usar o F # na programação GPGPU.
Para conhecer essa estrutura, sugiro dar uma olhada em sua lista abrangente de exemplos .

Além de Brahma, dê uma olhada em C $ (pronunciado "C Bucks"). No site do CodePlex :

O objetivo do [C $] é criar uma linguagem e um sistema unificados para programação paralela contínua em GPUs e CPUs modernas.

É baseado em C #, avaliado preguiçosamente e tem como alvo vários modelos de aceleradores:

Atualmente, a lista de arquiteturas pretendidas inclui GPU, CPU multi-core, Multi-GPU (SLI, CrossFire) e Arquitetura híbrida Multi-GPU + Multi-CPU.

Há uma nova solução da Microsoft na cidade - C ++ AMP (introdução aqui ).

O uso do C # seria via P / Invoke, como demonstrado aqui para aplicativos de desktop e aqui para aplicativos Metro (não chame isso).

Edit: Devo observar que o C ++ AMP tem uma especificação aberta , o que significa que não é necessariamente apenas para o compilador MS ou apenas para o Windows.

Edit: Aparentemente, a tecnologia está agora no "modo de manutenção", o que significa que eles estão corrigindo bugs, mas não desenvolvendo ativamente.

DirectX gerenciado de alguma forma, pode funcionar

Se suas GPUs forem todas da mesma marca, você poderá obter suporte da GPGPU do fornecedor, através do CUDA da Nvidia ou do Stream da ATI. AFAIK, eles fornecem DLLs, que você pode usar através do P / Invoke.

O CenterSpace Software possui computação baseada em GPU em suas bibliotecas NMath que você pode adicionar ao projeto C #. É um produto comercial.

Se você deseja aplicar seus próprios algoritmos que precisam de kernels personalizados:

Recentemente, enviei um projeto meu de código aberto para este repositório do github que usa o OpenCL.

O que ele faz (você também pode verificar na sua página wiki), selecionando vários dispositivos compatíveis com OpenCL e uma sequência de kernel do usuário e criar wrappers de matriz C # ou C ++ e computar usando all, com a ajuda de um balanceador automático de carga e um pipeliner (para ocultar latências) para obter uma boa eficiência do PC.

Aqui está um exemplo de seu uso (1024 itens de trabalho particionados para todos os dispositivos, cada um executando o mesmo código, mas usando dados e threadId diferentes):

// select all GPUs and all CPUs in same pc
ClNumberCruncher gpuCpu = new ClNumberCruncher(AcceleratorType.GPU | AcceleratorType.CPU, @"
    __kernel void distributeTanh(__global float * data,__global int * data2)
    {
         int threadId=get_global_id(0);
         data[threadId]=tanh(data[threadId]);
         data2[threadId]=threadId;
    }    
");

// a wrapper that can hold C# or C++ arrays
ClArray<float> data = new ClArray<float>(1024);
ClArray<int> data2 = new int[1024];

// load-balances "distributeTanh" on all devices more fairly 
// at each repeatation of this line with same compute-id(1 here)
data.nextParam(data2).compute(gpuCpu, 1, "distributeTanh", 1024);
// threadId in kernel receives unique continuous id value for all work
// either it is in cpu or gpu doesn't matter
// compute method also has parameters to enable pipelining to 
// elliminate buffer copy latencies or compute latencies

quando não são mais usados, eles liberam todos os recursos C ++ com seus destruidores.

Mas não é tão maduro, portanto, fique à vontade para adicionar qualquer "problema" na guia de problemas do github. As classes relevantes do cluster com vários computadores não estão funcionando e ainda não estão traduzidas para o inglês, mas podem usar todos os dispositivos em um único computador, pelo menos.

O WPF também usa a GPU e você pode adicionar sombreadores personalizados usando HLSL.

• Uma série de efeitos baseados em GPU para WPF (Blog de Greg Schechter)