Moin, ich möchte mich ins Thema CPU computing einarbeiten, habe aber nur grundlegende Erfahrung mit dem OpenGL Core Profile sowie Legacy OpenGL. Könnt ihr mir evtl. ein kleines Beispiel oder ein Tutorial nennen, das zeigt, wie man GPU computing betreibt in OpenGL-Versionen, die keine Compute Shader kennen? Ich habe gelesen, dass Vertex und Fragment Shader auch für GPU computing zweckentfremdet werden können, allerdings finde ich nirgendwo beschrieben, wie es geht. Wie rufe ich die Shader auf, ohne etwas zu rendern? Ich habe nur eine alte Grafikkarte, die bis zu OpenGL 3.3 unterstützt, meines Wissens gibt es Compute Shader erst ab OpenGL 4.3, weshalb ich eine Alternative suche. Ebenfalls interessiert mich, wie ich GPU computing in WebGL hinbekomme, was Compute Shader nur in Developmentversionen von Chrome unter Windows unterstützt, aber nicht in der breiten Masse von Browsern. Danke Arno
:
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.
Arno schrieb: > Nein, ich suche einen Ansatz, der auf OpenGL oder WebGL aufbaut, der > also nicht speziellere Anforderungen an die Hardware stellt. Das ist gelinde gesagt Blödsinn. Denn schon der Algorithmus selbst stellt Anforderungen an die Hardware - durch Nutzung bestimmter Shader (= floating point unit in der GPGPU) Features oder alleine durch den benötigten RAM auf der GraKa. Arno schrieb: > Wie rufe ich die Shader auf, > ohne etwas zu rendern? Gar nicht. Man rendert in eine Textur und liesst die aus, was oftmals recht langsam ist. Zwecks Visualisierung kann man sich bei geschickter Programmierung den Auslese Schitt sparen. Die Datenmenge die eine Webseite realistisch mit einem Client im Internet in Echtzeit austauschen kann, sollte sich in JavaScript abhandeln lassen.
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?
Arno schrieb: > 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? Was versteht du unter "Prozess"? Ein Shader wird gestartet, liest bei seiner Ausführung irgendwelche Inputdaten aus Texturen und Uniform-Variablen, erzeugt dann einen Ausgabewert und beendet sich wieder.
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!
Arno schrieb: > 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! Für interessierte, wäre es dann net, dies auch zu sagen WAS du gefunden hast. ☺️
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: > Oder such selbst. Dankeschön, aber eines sollte man dann doch immer bedenken: "Wer im Glashaus sitzt!" Denn so wie du mir gerade entgegen kommst, bist du kein Deut besser als die Leute die du hier beschimpfst. Also: Dankeschön für nix.
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.
Beitrag #6160979 wurde von einem Moderator gelöscht.
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..).
Beitrag #6161099 wurde von einem Moderator gelöscht.
Beitrag #6161110 wurde von einem Moderator gelöscht.
Beitrag #6161127 wurde von einem Moderator gelöscht.
Beitrag #6161155 wurde von einem Moderator gelöscht.
Beitrag #6161194 wurde von einem Moderator gelöscht.
Beitrag #6161258 wurde von einem Moderator gelöscht.
Beitrag #6161336 wurde von einem Moderator gelöscht.
Beitrag #6161365 wurde von einem Moderator gelöscht.
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.