GPU computing ohne Compute Shader möglich?

Suchst du nicht eher nach CUDA bzw. OpenCL?

Nein, ich suche einen Ansatz, der auf OpenGL oder WebGL aufbaut, der 
also nicht speziellere Anforderungen an die Hardware stellt.


Cuda setzt Nvidia voraus.
WebCL wird zwar diskutiert, ist aber nicht wirklich marktreif.

Ich würde auch OpenCL für sowas empfehlen, das kann man auch mit OpenGL 
kombinieren, gewisse buffer sharen, etc. Funktioniert zwar noch besser 
mit OpenCL+Vulkan. Das zeugs ist standard bei ernst zunehmenden 
Anwendungen. Ist leider aber etwas kompliziert, viel Aufwand zur 
Initialisierung usw. Auf keinen fall Cuda nutzen, dass ist so eine 
proprietäre nvidia creation. WebCL hat sich leider noch nicht 
durchgesetzt, und ist in Vergessenheit geraten, ich empfehle deshalb, 
sowas einfach nativ zu machen, statt im browser.

Jim M. schrieb:
> Denn schon der Algorithmus selbst
> stellt Anforderungen an die Hardware

Mach dir darüber mal keine Sorgen. Ich kann den Algorithmus mit viel 
oder wenig Resourcen ausführen, brauche nur Integer Arithmetik.

Jim M. schrieb:
> Man rendert in eine Textur und liesst die aus, was oftmals
> recht langsam ist.

Also übergibt man die Inputparameter als Textur und erhält das Ergebnis 
ebenso? Dann ist nur noch die Frage, wie starte ich in OpenGL 3.3 und 
WebGL einen Shader auf, der nicht auf den Bildschirm rendert?

Jim M. schrieb:
> Man rendert in eine Textur und liesst die aus, was oftmals
> recht langsam ist.

@Jim M. (turboj), kannst du bitte noch mal antworten, wie ich das mache? 
Ich kenne nur Vertex und Fragment Shader, um in ein Window zu rendern. 
Welche Shader benutze ich, wenn das Ergebnis nicht dargestellt, sondern 
nur ausgelesen werden soll?

Arno schrieb:
> Welche Shader benutze ich, wenn das Ergebnis nicht dargestellt, sondern
> nur ausgelesen werden soll?

Ob man auf den Bildschirm, eine Textur oder einen render buffer 
zeichnet, ändert nichts an der Pipeline oder den verwendbaren arten von 
Shadern.

Dies ist auch keine Antwort auf meine Frage,

Hat jemand ein Link zu einem Beispiel, wie ich GPU computing mit OpenGL 
3.3 oder WebGL mache? Dann wäre ich euch sehr dankbar.

Wenn ihr mir nur erklären wollt, dass es Probleme gibt, die dafür zu 
komplex sind, weil sie 1000 GB RAM und 128bit Floating Point auf der GPU 
benötigen, kann ich euch versichern, dass mir dies durchaus bewusst ist.

Compute shader wäre ja sowas: 
https://github.com/9ballsyndrome/WebGL_Compute_shader

Ohne die gibt es nur noch folgende möglichkeiten:
  1) Rechnung in Fragment Shader machen, sofern möglich, Ergebnis nach 
Textur / Renderbuffer rendern 
(https://webglfundamentals.org/webgl/lessons/webgl-render-to-texture.html) 
und dann auslesen 
(https://stackoverflow.com/questions/13626606/read-pixels-from-a-webgl-texture)
     Bei der Methode kann man den fragment shader für jedes Pixel der 
Textur aufrufen lassen, indem man ein vollbild Quadrat rendert. Die 
jeweilige operation kann aber nicht auf andere Pixel zugreifen. Es ist 
oft schwierig bis unmöglich, seine Wunschrechnung auf sowas abzubilden.

  2) Eventuell könnte man 
https://developer.mozilla.org/en-US/docs/Web/API/WebGLTransformFeedback 
misbrauchen, das ist aber noch schlechter supportet als compute shader.

Andere Möglichkeiten gibt es meines Wissens nicht.

Ausser - Falls statt GPU auch CPU Multithreading in ordnung wäre, 
könntest du WebWorkers verwenden: 
https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Using_web_workers 
https://developer.mozilla.org/en-US/docs/Web/API/Transferable

DPA schrieb:
> Bei der Methode kann man den fragment shader für jedes Pixel der
> Textur aufrufen lassen, indem man ein vollbild Quadrat rendert. Die
> jeweilige operation kann aber nicht auf andere Pixel zugreifen. Es ist
> oft schwierig bis unmöglich, seine Wunschrechnung auf sowas abzubilden.

Danke, damit kommen wir der Sache schon näher.

Dass jeder shader nur auf einem Pixel arbeitet, ist tatsächlich so erst 
mal nicht brauchbar. Aber es hilft schon mal, die Anzahl der Prozesse 
festzulegen.

Jeder Prozess wird ja eine bestimmte Menge Inputdaten brauchen. Könnte 
ich dazu weitere Texturen übergeben, von denen sich jeder Prozess einen 
bestimmten Bereich holt, den er dann bearbeitet?

Mit "Prozess" meinte ich den Shader. Habe noch keine tiefere Kenntnis 
der Terminologien.

Unter Windows Direct3D kann man es folgendermassen machen
(per Erweiterungen so direkt auf OpenGL übertragbar, da
kenne ich mich aber kaum aus):

Gerendert wird in eine sogenannte RenderTargets (kann
auch als Textur verwendet werden, aber dann nicht im
aktuellen Renderprozess), die Daten werden entweder
per Variablen/Konstanten gesetzt oder per Texture(n)
zur Verfügung gestellt.


Die Shader sind im Prinzip ausschliesslich PixelShader,
die z.B. (nicht zwingend) von der Texture(n) Daten
entgegennehmen (Texture(n) auslesen), "umrechnet" und dann
im Rendertarget zeichnet. Als Format kann im Prinzip
alles Denkbare gewählt werden: int, float, int2, int3,
int4, etc.

Der Vertexshader projeziert Vertices entlang der z-Achse,
gezeichnet wird nur ein einzelnes Quadrat.

In Direct3D wird dazu ein RenderTarget, Variablen/Konstanten,
Texturen und Rendertargets generiert, die beiden Shader
gesetzt und der Zeichenvorgang gestartet. Soll das
Rendertarget in einem nachfolgenden Rechenprozess als
Quelle verwendet werden, dann muss es als Texture gesetzt
und ein neues Target als Rendertarget gesetzt werden.

Um das genau zu verstehen, liess dir mal das Tutorial
unter Direct3D 9 durch und arbeite dich dann in Shader
und in Texturen, speziell Rendertargets und Formate ein.
Ist nicht sehr kompliziert. Aber sicherlich gibt's für
OpenGL ähnliche Tutorials, so dass du dir Direct3D
sparen kannst. Der Vorgang ist aber der gleiche.

Sigi schrieb:
> Um das genau zu verstehen, liess dir mal das Tutorial
> unter Direct3D 9 durch

Nein Danke! Um meine Frage genau zu verstehen, lies sie dir mal durch.

Warum muss hier eigentlich jeder meine Frage so uminterpretieren, dass 
er meint, seinen Senf dazugeben zu könnnen? Du hast zwar keine Ahnung 
von OpenGL, aber hast schon mal was von Direct3D gehört und musst das 
zum besten geben. Die anderen haben zwar auch nichts beizutragen, können 
aber immerhin eine Reihe zusätzliche Annahmen zu meiner Frage treffen, 
um dann sagen zu können: unter der und der und der Annahme ist OpenGL 
3.3 nicht geeignet.

Könnt ihr nicht einfach GAR NICHTS antworten, wenn ihr die Frage 
versteht oder keine Antwort habt?

Mittlerweile habe ich eine Lösung gefunden, wie ich mittels WebGL oder 
OpenGL 3.3 komplexe Rechnungen auf der GPU durchführen kann.
Danke für nichts!

Rene K. schrieb:
> Für interessierte, wäre es dann net, dies auch zu sagen WAS du gefunden
> hast. ☺️

Dann mach doch deinen eigenen Thread dazu auf und erfahre wie schön man 
hier verarscht wird. Oder such selbst.

Ich bin mit dieser Seite durch. Was man an oberflächlichen und 
unbrauchbaren Antworten von selbstverliebten Möchtegernexperten bekommt 
ist unter aller Sau.

Arno schrieb:
> Dann mach doch deinen eigenen Thread dazu auf und erfahre wie schön man
> hier verarscht wird. Oder such selbst.
>
> Ich bin mit dieser Seite durch. Was man an oberflächlichen und
> unbrauchbaren Antworten von selbstverliebten Möchtegernexperten bekommt
> ist unter aller Sau.

Mimimi, zieh dir doch ein Röckchen an ^^

Arno schrieb:
> Nein Danke! Um meine Frage genau zu verstehen, lies sie dir mal durch.
>
> Warum muss hier eigentlich jeder meine Frage so uminterpretieren, dass
> er meint, seinen Senf dazugeben zu könnnen? Du hast zwar keine Ahnung
> von OpenGL, aber hast schon mal was von Direct3D gehört und musst das
> zum besten geben. Die anderen haben zwar auch nichts beizutragen, können
> aber immerhin eine Reihe zusätzliche Annahmen zu meiner Frage treffen,
> um dann sagen zu können: unter der und der und der Annahme ist OpenGL
> 3.3 nicht geeignet.
>
> Könnt ihr nicht einfach GAR NICHTS antworten, wenn ihr die Frage
> versteht oder keine Antwort habt?

Da gibt man dir eine Hilfestellung zu deiner Frage und deine
Reaktion dazu ist einfach nur unverschähmt, auch zu anderen
Forenteilnehmern, siehe z.B. folgende Bemerkung von dir:

Arno schrieb:
> Ich bin mit dieser Seite durch. Was man an oberflächlichen und
> unbrauchbaren Antworten von selbstverliebten Möchtegernexperten bekommt
> ist unter aller Sau.

Meine Hilfestellung unter Direct3D (war ich seit über 20 Jahren
mache, 100te Simulationen geschrieben, teils durch OpenGL begleitet)
lässt sich so 1:1 in OpenGL umsetzen. Wenn du aber zu dumm bist, dir
ein Tutorial von einer ähnlichen Umgebung/Bibliothek in deine
Umgebung/Bib. zu übersetzen, dann ist dir auch nicht mehr zu helfen.
Und nach deiner unflätigen Art ggÜ den Mitforisten wird DIR auch
keiner mehr unter die Arme greifen.

Dankeschön für deine eindrucksvolle Bestätigung, dass du zu dem Typus 
gehörst, auf dessen Antworten man unbedingt verzichten will.

Nun regt euch noch schon auf und lasst euch das Wochenende versauen. Ich 
werde hier keine Hilfe mehr anbieten oder suchen.

Oh man, bei dem Verhalten des TO hätte ich mir wirklich keine Lösung für 
WebGL 1 ausdenken müssen. Es addiert zahlen aus 2 Arrays. Aber 
vielleicht hilfst ja jemand anderem später mal noch: 
https://jsfiddle.net/yx8fhbtz/5/

Zu beachten ist, dass da vermutlich noch ein paar bugs drin sein 
könnten, und das, da texelFetch in WebGL1 noch nicht verwendet werden 
kann, und texture2D einen float nimmt, ich nicht ausschliessen kann, 
dass das auch mal nen Wert überspringen/verdoppeln könnte.

Arno schrieb:
> Dankeschön für deine eindrucksvolle Bestätigung, dass du zu dem Typus
> gehörst, auf dessen Antworten man unbedingt verzichten will.
>
> Nun regt euch noch schon auf und lasst euch das Wochenende versauen. Ich
> werde hier keine Hilfe mehr anbieten oder suchen.

Oh man, da schütest du ja einen wirklich ekelhaften
Kübel Gülle über deinen Mitmenschen aus, einfach
nur EKELHAFT.

DPA schrieb:
> Zu beachten ist, dass da vermutlich noch ein paar bugs drin sein
> könnten, und das, da texelFetch in WebGL1 noch nicht verwendet werden
> kann, und texture2D einen float nimmt, ich nicht ausschliessen kann,
> dass das auch mal nen Wert überspringen/verdoppeln könnte.

In deiner Lösung lässt sich iE mein Ansatz wiederfinden.
Da ich aber kaum WebGL kenne und vlt. einiges übersehe:
Deine Textur-Sampler müssen im SAMPLE-Modus laufen, sonst
greifst du evtl. bei den Texturdaten leicht daneben und
kriegst leicht verfälschte Ergebnisse.
Ist das Ein- und Auslesen der Datenarrays aufwendig?
Geht das schnell (z.B. bzgl. CPU-Zyklen?

Sigi schrieb:
> Deine Textur-Sampler müssen im SAMPLE-Modus laufen, sonst
> greifst du evtl. bei den Texturdaten leicht daneben und
> kriegst leicht verfälschte Ergebnisse.

Ich wiederum kann mich mit Direct3D nicht aus. Ich nehme an du meinst 
damit dass, was man in WebGL pro Textur setzt?

1

gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);

2

gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);

3

gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);

4

gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);

Zugriff auf einzelne Textur pixel per integer (fetchTexel) stat 
normalisiert per float (texture2D) geht aber erst seit WebGL 2, und bei 
WebGL 1 noch nicht. Ich traue den floats nicht so ganz, auch wenn das 
theoretisch passen müsste. Mit WebGL 2 wäre das alles allgemein viel 
einfacher als mit WebGL 1.

Sigi schrieb:
> Ist das Ein- und Auslesen der Datenarrays aufwendig?
> Geht das schnell (z.B. bzgl. CPU-Zyklen?

Da bin ich auch überfragt. Performanceoptimierungen waren noch nie so 
mein ding, da wäre sicher noch Luft nach oben.

GP-GPU Computing mit Javascript ist mit folgender Bibliothek möglich: 
http://gpu.rocks/

Habe das schon getestet. Funktioniert, hat aber in meiner Anwendung 
nichts gebracht (Speicheroverhead war zu groß).

Kauf' dir eine billige Nvidia Gamer-Card, schnapp dir ein vernuenftiges 
Buch wie dieses..

https://www.wiley.com/en-us/Professional+CUDA+C+Programming-p-9781118739327

..anstatt ein ganzes Forum mit einer Magermilch-Loesung verrueckt zu 
machen.

Ach ja, die Google Cloud bietet Nvidia GPU cores an (warum wohl..).