Utilisation du GPU avec c # [fermé]

J'essaie d'obtenir plus de puissance de traitement de mon réseau.

J'utilise tous les cpus / cœurs, est-il possible d'utiliser le GPU avec C #.

Quelqu'un connaît des bibliothèques ou a un exemple de code?

[ Modifier OCT 2017 car même cette réponse devient assez ancienne ]

La plupart de ces réponses sont assez anciennes, alors j'ai pensé donner un résumé mis à jour de l'endroit où je pense que chaque projet est:

• GPU.Net (TidePowerd) - J'ai essayé cela il y a environ 6 mois, et je l'ai fait fonctionner même si cela a pris un peu de travail. Convertit le code du noyau C # en cuda au moment de la compilation. Malheureusement, leur site Web est en panne et leur github n'a pas été mis à jour depuis quelques années, ce qui pourrait indiquer que le projet est mort ...

• Cudafy - Open source et très facile à utiliser. Convertit le code du noyau C # en cuda au moment de l'exécution (avec possibilité de sérialisation et de cache). Peut facilement exécuter le même code de noyau sur le processeur (principalement pour le débogage). Prend en charge plusieurs GPU. Plus d'exemples disponibles que d'autres ici. Le code standard auquel font référence d'autres réponses est minime et, dans mon cas, m'a au moins aidé à comprendre comment le code fonctionne. Cuda / Nvidia seulement cependant. Malheureusement, il semble qu'ils n'aient pas mis à jour leurs solutions depuis quelques années également (dernier commit en 2015 - support de cuda 7.0).

• Hybridizer . Solution commerciale compilant C # vers CUDA. Fournit une édition communautaire gratuite sur le marché de Visual Studio et des échantillons sur github .

• AleaGPU commerciale avec une édition communautaire gratuite pour les GPUS grand public. Voir les commentaires de Daniel pour plus de détails.

• Brahma - exécute les expressions LINQ via OpenCL (prend donc également en charge AMD). Pas beaucoup de documentation / d'exemples. Dernière mise à jour en 2011.

• C $ - le dernier développement remonte à plus de 10 ans ...

• Microsoft Accelerator - de même, ne semble plus être activement développé.

• d'autres ( C ++ AMP , OpenTK - dead / Cloo ) - beaucoup d'entre eux ne sont que des liaisons - c'est-à-dire vous permettent d'appeler le GPU à partir de C #, mais votre code noyau (code qui est en fait exécuté sur le GPU) doit être écrit en C ou OpenCL, ce qui signifie que vous devez utiliser (et apprendre) une autre langue.

Comme je l'ai dit, je recommanderais Cudafy à tous les autres - s'il pouvait fonctionner aussi bien sur OpenCL que sur Cuda, ce serait parfait.

EDIT septembre 2013 Cudafy vous permet maintenant de compiler pour les deux CUDA et OpenCL, donc va exécuter le même code C # sur tous les processeurs graphiques. Cela semble fantastique, même si je n'ai pas encore testé la compilation OpenCL.

Microsoft Research Accelerator était une bibliothèque GPU .NET.

J'ai trouvé Brahma ... Il a également un fournisseur GPGPU qui permet aux méthodes de fonctionner sur le GPU ... Merci pour la question ... J'ai appris quelque chose de nouveau aujourd'hui. :)

Puis-je recommander XNA Game Studio comme piste d'exploration possible? Il est évidemment conçu pour l'écriture de jeux, mais vous donne un accès géré à votre carte graphique et un accès bien meilleur aux fonctions d'énumération des capacités et au développement de shaders que ce qui était auparavant disponible dans, par exemple, Managed DirectX. Il existe également des moyens de combiner WinForms et XNA dans des applications hybrides:

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

Vous devrez faire des efforts pour apprendre la programmation des shaders (XNA prend en charge HLSL), mais cela peut être une approche plus simple que d'apprendre une solution spécifique au fournisseur telle que CUDA de nVidia. L'avantage est que vous pouvez programmer dans un environnement 100% géré. Voici quelques liens HLSL:

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

Le site GPGPU est également une destination recommandée pour la programmation GPU à usage général:

http://gpgpu.org/

Bonne chance!

Que diriez-vous de http://www.tidepowerd.com/ GPU.NET?

En voici un autre: CUDAfy . Cela ressemble à GPU.Net, dans la mesure où quelque chose d'aussi simple qu'un attribut de méthode peut entraîner l'exécution de la méthode entière sur le GPU. Mais contrairement à GPU.Net, CUDAfy est gratuit et open source.

GPU.Net semble ne nécessiter aucun code standard, cependant (selon leur documentation, il est "injecté automatiquement par l'outil de construction") , contrairement à CUDAfy.

Voici un exemple de construction d'une application avec CUDAfy.

Eh bien, c'est une question assez ancienne, et depuis qu'elle a été posée, les choses ont beaucoup changé.
Une autre option pour utiliser .Net pour écrire du code GPU, que personne n'a mentionné dans les réponses dans Alea GPU . Il couvre C #, F # et VB.

Environnement de développement de logiciel GPU professionnel pour .NET et Mono. Vraiment multiplateforme

Sur le site officiel F #, Alea est la première option pour utiliser F # dans la programmation GPGPU.
Pour apprendre à connaître ce cadre, je suggère de jeter un coup d'œil à sa liste complète d' exemples .

En plus de Brahma, jetez un œil à C $ (prononcé "C Bucks"). Depuis leur site CodePlex :

Le but de [C $] est de créer un langage et un système unifiés pour une programmation parallèle transparente sur les GPU et CPU modernes.

Il est basé sur C #, évalué paresseusement et cible plusieurs modèles d'accélérateur:

Actuellement, la liste des architectures prévues comprend GPU, CPU multicœur, Multi-GPU (SLI, CrossFire) et Architecture hybride Multi-GPU + Multi-CPU.

Il y a une nouvelle solution Microsoft en ville - C ++ AMP (intro ici ).

L'utilisation à partir de C # se ferait via P / Invoke, comme démontré ici pour les applications de bureau, et ici pour les applications Metro (ne l'appelez pas).

Edit: Je dois noter que C ++ AMP a une spécification ouverte , ce qui signifie que ce n'est pas nécessairement juste pour le compilateur MS, ou juste pour Windows.

Edit: Apparemment, la technologie est maintenant en "mode maintenance", ce qui signifie qu'ils corrigent des bogues, mais ne se développent pas activement.

DirectX géré d'une manière ou d'une autre, pourrait fonctionner

Si vos GPU sont tous de la même marque, vous pourrez peut-être obtenir le support GPGPU du fournisseur, soit via le CUDA de Nvidia ou le Stream d'ATI. AFAIK, ils fournissent des DLL, que vous pouvez utiliser via P / Invoke.

CenterSpace Software a des calculs alimentés par GPU dans leurs bibliothèques NMath que vous pouvez ajouter au projet C #. C'est un produit commercial.

Si vous allez appliquer vos propres algorithmes nécessitant des noyaux personnalisés:

J'ai récemment téléchargé un de mes projets open source dans ce référentiel github qui utilise OpenCL.

Ce qu'il fait (vous pouvez également vérifier à partir de sa page wiki) est de sélectionner plusieurs périphériques compatibles OpenCL et une chaîne de noyau de l'utilisateur et de créer des wrappers de tableau C # ou C ++, puis de calculer en utilisant tous, avec l'aide d'un équilibreur de charge automatique et d'un pipeliner (pour masquer les latences) pour obtenir une bonne efficacité du pc.

Voici un exemple de son utilisation (1024 éléments de travail partitionnés sur tous les périphériques, chacun exécutant le même code mais utilisant des données et un threadId différents):

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

quand tous ne sont plus utilisés, ils libèrent toutes les ressources C ++ avec leurs destructeurs.

Mais ce n'est pas si mature, alors n'hésitez pas à ajouter n'importe quel "problème" sur l'onglet Problèmes de github. Les classes pertinentes multi-pc-cluster ne fonctionnent pas et ne sont pas encore traduites en anglais, mais elles peuvent au moins utiliser tous les périphériques sur un seul PC.

WPF utilise également le GPU et vous pouvez ajouter des shaders personnalisés à l'aide de HLSL.

• Une série d'effets basés sur GPU pour WPF (Blog de Greg Schechter)