# Einstieg in Open CL oder Direct Computing



## Pffzzhh! (19. Januar 2010)

Servus,

wie der Titel schon verrät möchte ich die Rechenpower meiner Grafikkarte nutzen.

Falls mir jemand bei folgenden Dingen helfen kann wäre ich sehr dankbar!:

Welche Entwicklungsumgebung / Sprache benötige ich? Ich vermute, dass C# oder C++ genutzt werden kann. Ich könnte dann mit Visual Studio 2008 Prof. (C++) dienen.

Welche(s) SDK(s) benötige ich dafür und wie müssen diese ggf. eingebunden werden? Gibts einfache Beispielprogramme?

Ich erwarte von Open CL und Direct Computing, dass ich einfache C(++) Programme wie immer schreibe, und bestimmen kann, dass bestimmte Funktionen, etc. auf der GPU ausgeführt werden können.

Ich habe mich bereits mehr oder minder erfolgreich mit dem Thema GPU Computing versucht, und mit Atis Stream-SDK auch im Visual Studio das einfachste Programm zum Laufen bekommen.
Was mich damals nur abgeschreckt hat, war die Tatsache, dass dort 10 Seiten Quelltext Voraussetzung stand, um 3 Zeilen eigentlichen Code auszuführen.
Ich erwarte, dass über die neuen Schnittstellen das Thema Initialisierung, etc. nur noch einen kleinen Teil des Codes ausmacht, und man sich auf das eigentliche Programmieren kümmern kann.

Achso: Ich möchte das ganze mit einer Radeon 5770, Catalyst 9.12 unter Windows 7 64 Bit durchführen.

...

Da ich hier im Programmier-Forum noch nie gepostet habe, ein Kurzprofil in dieser Richtung:
Ich habe vor sieben Jahren meine erste Informatik-Ausbildung begonnen. Die ersten drei Jahre habe ich mich intensiv mit verschiedenen Programmiersprachen und Entwicklungswerkzeugen auseinandergesetzt. Ich würde mich als erfahrenen Programmierer sehen, der aber keine super tiefgreifenden Kenntnisse in einem Bereich hat.

Vielen Dank erst einmal im Voraus für eure Hilfe!


----------



## bingo88 (20. Januar 2010)

C/C++ wird da wohl am meisten genutzt. Sowohl ATI als auch Nvidia bieten passende SDKs an. DirectCompute ist Teil von DirectX 11, sollte also im entsprechenden DX SDK enthalten sein.

Beispiele findest du meist auf den Seiten der Hersteller:
Nvidia
Ati/AMD
MSDN DirectX Dev Center

Du kannst dir hier bei Wikipedia mal nen Beispiel zu OpenCL ansehn, ein bisschen umstellen muss man sich schon.

Da ich persönlich damit noch nicht großartig was zu tun hatte, kann ich dir da leider nicht weiterhelfen. Zumindest nicht, sobald es über advanced topics geht


----------



## Pffzzhh! (20. Januar 2010)

Danke für die Antwort!
Also müsste ich eigentlich mit VS 2008 + DX11 SDK bereits per DirectCompute entwickeln können. Und dann schaue ich mal, ob ich bei Ati ggf. noch Beispiele finde. Eine extra SDK von Ati werde ich dann wohl nicht brauchen, da DirectCompute ja universell für alle Karten geschrieben wird, richtig?

Das Beispiel von OpenCL sieht eigentlich noch recht simpel aus, zumindest wenn das alles ist. Meine genannte Erfahrung fand ich viel schlimmer.

Danke erstmal!


----------



## bingo88 (20. Januar 2010)

Ja, sollte dafür reichen!

Hab hier noch was aus der MSDN Code Gallery: Link


----------



## Pffzzhh! (20. Januar 2010)

Vielen Dank für die Hilfe!
Ich installiere jetzt erstmal VS2008 und DX SDK. Mal schauen, wie weit ich komme!


----------



## bingo88 (21. Januar 2010)

Na dann wünsch ich mal viel Erfolg!


----------



## Bauer87 (21. Januar 2010)

Bei ATI wirst du nur Beispiele zu OpenCL finden, zumindest habe ich bisher keine anderen gefunden. Allerdings sehe ich (auch mit Stream-SDK) Vorteile bei OpenCL: Das läuft auch ohne DirectX. Also auf dem Mac, mit Linux auf dem Handy, in ner Cloud, etc. Das heißt, dass du mit deinem Wissen deutlich mehr anfangen kannst. Ein OpenCL-Programm kannst du theoretisch „as it is“ in einen Supercomputer jagen und der rechnet dann für dich. DirectCompute kann nur einen Rechner nutzen. Und fordert dort dann auch ne DX11-Karte. Während OpenCL auch über die CPU geht und selbst bei Uralt-Karten ab der GF8 bzw. RadeonX (letztere nur mit angepassten Treibern, Support seitens AMD seit der HD4) von der GPU übernommen werden kann.

PS: Den großen Code-Overhead hast du nicht ständig. Die FFT auf Wikipedia ist z.B. nicht wirklich länger als etwas in reinem C.


----------



## DarkMo (22. Januar 2010)

hmm, klingt ja direkt interessant. ich hab hier vs08 un dx9 sdk wegen studium noch druff. was wären denn so anwendungsfälle für das zeugs? könnte man da, mal extrem gesagt, eigene dx11 engines bauen? wenn mans drauf hätte ^^ oder wozu kann man gerade auch dieses dx11-karten unabhängige OCL nutzen?


----------



## Pffzzhh! (22. Januar 2010)

Also VS08 und OpenCL mit Atis Stream SDK läuft. Vielen Dank erstmal!
Ich finde nur, dass selbst die einfachsten Beispiele unheimlich "Overhead" für Initialisieren, ezc. haben. Vielleicht bin ich auch einfach C++ nicht gewöhnt. Als ich Programmierung mal gelernt habe, hat mir diese Sprache noch gefallen. Aber das Produkt von Microsoft finde ich sehr schlecht zu lesen und syntaktisch schwer nachzuvollziehen. (Beispiel: ein anpassbares Array einer Klasse, grausam!)

@DarkMo: Prinzipiell kann man, wie bereits von Bauer87 geschrieben, OpenCL gut verwenden, um Berechnungen zu parallelisieren.Die von ihm genannten Beispiele bzgl plattformunabhängigkeit gefallen mir.
Anwendungsfälle... Du möchtest etwas berechnen, was sich von der programmierbarkeit halt stark parallelisieren lässt. In diesem Fall kannst du deine Grafikkarte mit ihren hunderten Recheneinheiten verwenden, welche in diesem Fall um ein vielfaches schneller rechnen könnte als eine moderne CPU.
Aber wie gesagt, Voraussetzung ist, dass sich die Aufgabe wirklich gut aufteilen lässt. Vier oder acht Parallelprozesse wären vermutlich auf meiner CPU schneller...


----------



## DarkMo (22. Januar 2010)

Pffzzhh! schrieb:


> Aber wie gesagt, Voraussetzung ist, dass sich die Aufgabe wirklich gut aufteilen lässt.


verstehe, das war auch mein erster gedanke. ertmal bräuchte man sowas ^^ is ja oft genug so, das man sehr schnell wieder seriell arbeiten muss, allein vom ablauffluss her :/


----------



## Bauer87 (23. Januar 2010)

Gut parallelisieren lässt sich z.B. die Berechnung von Wellen. Jeder Punkt der Wellenoberfläche ist in sehr guter Näherung nur von dem vorherigen Aufenthaltsort des selben Punktes sowie von den aktuellen Aufenthaltsorten der benachbarten Punkte abhängig. Wenn man also ein Grid über die Wasseroberfläche legt, kann man jeden Oberflächenpunkt parallel berechnen. Auch der Speicherverwaltung für diese Berechnung ist relativ gering:


```
OrtAlt* GridFürAlteOberfläche[Länge][Breite];
OrtAkt* GridfürAktuelleOberfläche[Länge][Breite]
```

Darin gespeichert sind dann jeweils dreidimensionale Vektoren:


```
struct Ort{
int x;
int y;
int z;
};
```

Wenn die Berechnung für alle Punkte durch ist, kann man einfach die Pointer oben auf das jeweils andere zeigen lassen. Den Wert für die neue Oberfläche schreibt man dabei einfach immer über den für die alte — der wird ja nicht mehr gebraucht.

Damit bekommt man dann eine sehr schöne Oberfläche einer Welle…

PS: Formel für die Bewegung hängt von Dämpfung, etc. ab. Zwischen den Schritten muss das Zeug natürlich auch noch auf die Grafikkarte gegeben werden. Das geht recht einfach mit OpeGL. (Allerdings meines Wissens nach dann tatsächlich nicht mehr Parallel. Wobei das übergeben der Punkte ja eh nicht so besonders aufwändig ist.)


----------

