Utilizando la GPU con c # [cerrado]

Estoy tratando de obtener más potencia de procesamiento de mi red.

Estoy usando todos los cpus / núcleos, ¿es posible utilizar la GPU con C #?

¿Alguien sabe alguna biblioteca o tiene algún código de muestra?

[ Edite OCT 2017 ya que incluso esta respuesta se vuelve bastante antigua ]

La mayoría de estas respuestas son bastante antiguas, así que pensé en dar un resumen actualizado de dónde creo que está cada proyecto:

• GPU.Net (TidePowerd): probé esto hace 6 meses más o menos y lo puse a funcionar, aunque me llevó un poco de trabajo. Convierte el código del kernel C # a cuda en tiempo de compilación. Lamentablemente, su sitio web no funciona y su github no se ha actualizado durante un par de años, lo que podría indicar que el proyecto está muerto ...

• Cudafy : código abierto y muy fácil de usar. Convierte el código del kernel C # a cuda en tiempo de ejecución (con capacidad para serializar y almacenar en caché). Puede ejecutar fácilmente el mismo código de kernel en la CPU (principalmente para la depuración). Admite múltiples GPU. Más ejemplos disponibles que otros aquí. El código repetitivo al que se refieren otras respuestas es mínimo, y en mi caso al menos me ayudó a comprender cómo funciona el código. Cuda / Nvidia solo sin embargo. Desafortunadamente, parece que tampoco actualizaron sus soluciones durante un par de años (último compromiso en 2015 - soporte de cuda 7.0).

• Hibridizador . Solución comercial compilando C # a CUDA. Proporciona una edición comunitaria gratuita en el mercado visual studio y muestras en github .

• Solución comercial AleaGPU con una edición comunitaria gratuita para GPUS de consumo. Vea los comentarios de Daniel para más detalles.

• Brahma : ejecuta expresiones LINQ a través de OpenCL (por lo que también es compatible con AMD). No mucha documentación / ejemplos. Última actualización en 2011.

• C $ - el último desarrollo fue hace más de 10 años ...

• Microsoft Accelerator : de manera similar, parece que ya no se está desarrollando activamente.

• algunos otros ( C ++ AMP , OpenTK - dead / Cloo ) - muchos de estos son solo enlaces, es decir, le permiten llamar a la GPU desde C #, pero su código de kernel (código que realmente se ejecuta en la GPU) debe escribirse en C o OpenCL, lo que significa que debe usar (y aprender) otro idioma.

Como dije, recomendaría Cudafy sobre todos los demás; si pudiera ejecutarse tanto en OpenCL como en Cuda, sería perfecto.

EDITAR SEP 2013 Cudafy ahora le permite compilar tanto para CUDA como para OpenCL, por lo que ejecutará el mismo código C # en todas las GPU. Esto suena fantástico, aunque todavía no he probado la compilación de OpenCL.

Microsoft Research Accelerator era una biblioteca .NET GP GPU.

Encontré a Brahma ... También tiene un proveedor de GPGPU que permite que los métodos se ejecuten en la GPU ... Gracias por la pregunta ... Aprendí algo nuevo hoy. :)

¿Podría recomendar XNA Game Studio como una posible vía de exploración? Obviamente, está preparado para escribir juegos, pero le brinda acceso administrado a su tarjeta gráfica y un acceso mucho mejor a las funciones de enumeración de capacidades y al desarrollo de sombreadores que anteriormente estaba disponible, por ejemplo, en DirectX administrado. También hay formas de combinar WinForms y XNA en aplicaciones híbridas:

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

Tendrá que esforzarse en aprender la programación del sombreador (XNA admite HLSL), pero este puede ser un enfoque más simple que aprender una solución específica del proveedor, como el CUDA de nVidia. La ventaja es que puede programar en un entorno 100% administrado. Aquí hay algunos enlaces HLSL:

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

El sitio GPGPU también es un destino recomendado para la programación de GPU de propósito general:

http://gpgpu.org/

¡La mejor de las suertes!

¿Qué tal http://www.tidepowerd.com/ GPU.NET?

Aquí hay otro: CUDAfy . Parece GPU.Net, ya que algo tan simple como un atributo de método puede hacer que todo el método se ejecute en la GPU. Pero a diferencia de GPU.Net, CUDAfy es gratuito y de código abierto.

GPU.Net parece no requerir código repetitivo, sin embargo (según sus documentos, es "inyectado automáticamente por la herramienta de compilación") , mientras que CUDAfy sí.

Aquí hay un ejemplo de cómo construir una aplicación con CUDAfy.

Bueno, esta es una pregunta bastante antigua, y desde que se ha hecho, las cosas han cambiado mucho.
Otra opción para usar .Net para escribir código GPU, que nadie ha mencionado en las respuestas en Alea GPU . Cubre C #, F # y VB.

Entorno de desarrollo de software de GPU profesional para .NET y Mono. Verdaderamente multiplataforma

En el sitio oficial de F #, Alea es la primera opción para usar F # en la programación GPGPU.
Para conocer este marco, le sugiero que eche un vistazo a su lista completa de ejemplos .

Además de Brahma, eche un vistazo a C $ (pronunciado "C Bucks"). Desde su sitio CodePlex :

El objetivo de [C $] es crear un lenguaje y un sistema unificados para una programación paralela sin interrupciones en las GPU y CPU modernas.

Se basa en C #, se evalúa perezosamente y se dirige a múltiples modelos de aceleradores:

Actualmente, la lista de arquitecturas previstas incluye GPU, CPU multinúcleo, Multi-GPU (SLI, CrossFire) y Arquitectura híbrida Multi-GPU + Multi-CPU.

Hay una nueva solución de Microsoft en la ciudad: C ++ AMP (introducción aquí ).

El uso desde C # sería a través de P / Invoke, como se muestra aquí para aplicaciones de escritorio, y aquí para aplicaciones de Metro (no llamarlo).

Editar: debo tener en cuenta que C ++ AMP tiene una especificación abierta , lo que significa que no es necesariamente solo para el compilador de MS, o solo para Windows.

Editar: Aparentemente, la tecnología ahora está en "modo de mantenimiento", lo que significa que están reparando errores, pero no se están desarrollando activamente.

DirectX administrado de alguna manera, podría funcionar

Si sus GPU son todas de la misma marca, es posible que pueda obtener soporte GPGPU del proveedor, ya sea a través de CUDA de Nvidia o Stream de ATI. AFAIK, proporcionan archivos DLL, que puede utilizar a través de P / Invoke.

El software CenterSpace tiene computación con GPU en sus bibliotecas NMath que puede agregar al proyecto C #. Es un producto comercial.

Si va a aplicar sus propios algoritmos que necesitan núcleos personalizados:

Recientemente he subido un proyecto de código abierto mío a este repositorio de github que usa OpenCL.

Lo que hace (también puede verificar desde su página wiki) es seleccionar múltiples dispositivos con capacidad OpenCL y una cadena de kernel del usuario y crear envoltorios de matrices C # o C ++ y luego calcular usando todos, con la ayuda de un equilibrador de carga automático y un pipeliner (para ocultar latencias) para obtener una buena eficiencia de la PC.

Aquí hay un ejemplo de su uso (1024 elementos de trabajo particionados en todos los dispositivos, cada uno de los cuales ejecuta el mismo código pero usa diferentes datos e threadId):

// 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

cuando ya no se usan, liberan todos los recursos de C ++ con sus destructores.

Pero no es tan maduro, así que siéntase libre de agregar cualquier "problema" en la pestaña de problemas de github. Las clases relevantes de multi-pc-cluster no funcionan y aún no están traducidas al inglés, pero pueden usar todos los dispositivos en una sola PC al menos.

WPF también usa la GPU y puede agregar sombreadores personalizados usando HLSL.

• Una serie de efectos basados ​​en GPU para WPF (Blog de Greg Schechter)