ZFX + Developia

Spiele Programmierer hat geschrieben:Und mal schnell durchgeschaut: Der "stride"-Parameter von "glVertexAttribPointer" sind definitv falsch.

Ich seh dort auf den ersten Blick keinen Fehler!?

Jonathan hat geschrieben:

Code: Alles auswählen

	glBufferData(GL_ARRAY_BUFFER, 3*m_PositionData.size(), m_PositionData.data(), GL_STATIC_DRAW);

Code: Alles auswählen

	glBufferData(GL_ARRAY_BUFFER, 4 * m_ColorData.size(), m_ColorData.data(), GL_STATIC_DRAW);

Darüber vielleicht nochmal nachdenken (Größe in Byte)... ;)

Ansonsten: Auf jeden Fall einmal vereinfachen; z.B. würd ich niemals gleich mal mit einer Projektionsmatrix usw. anrücken. Lieber zuerst mal einen trivialen VertexShader verwenden, der die Position direkt nach gl_Position schreibt, ein paar Linien direkt in Clipspace Koordinaten angeben und schaun ob überhaupt das funktioniert...

Außerdem seh ich keine Fehlerbehandlung...was sagt denn glGetError()? ;)

Der stride-Parameter sollte passen. Man muss denn nur angeben, wenn man mehrere Attribute in den selben Buffer packt, ich benutze aber für jedes Attribut einen eigenen Buffer. So mache ich es auch beim Mesh-Rendern, dort ist Stride auch überall 0 und es funktioniert.
Ich habe die NDC's ausgerechnet, die Linien liegen so im Camera-Frustum, wie sie sollten, sie müssten also sichtbar sein.
nSight ist aber definitiv ein guter Tipp, nach dem Account-Rumgenerve habe ich es jetzt installiert und mal kurz gestartet. Es ist wirklich komplex und es wird sicherlich ein wenig Zeit beanspruchen, sein volles Potential ausschöpfen zu können, aber ich denke, es könnte mir helfen. Jedenfalls habe ich schon herausgefunden, dass GL_ELEMENT_ARRAY_BUFFER_BINDING 0 ist, was es eigentlich nicht sein sollte (denke ich). Also doch irgendein Fehler beim Buffer Anlegen und Binden. Schaun wir mal. Auf jeden Fall schonmal vielen Dank für die Hilfe bis hier.

Jap, ok hat sich erledigt.
0 ist nicht wirklich 0 sondern es sollte sich den passenden Wert holen. Was es alles für komische Features gibt. ;)

Läuft Nsight bei euch etwa ohne Probleme?

Jup. Habe herausgefunden, dass meine Buffer leer waren. Habe herausgefunden, dass ich nicht bedacht habe, dass glBufferData die Größe in Byte und nicht in Elementen erwartet. Bei 2 Testlinien (wir erinnern uns: Minimale Testdaten) und einem Buffer der nur zu 1/4 (oder 1/sizeof(float)) gefüllt war sieht man dann halt wenig. Jetzt gehts. Und ich habe ein gutes neues Debugging-Tool zur Hand. Ich verbuche das in einer betont optimistischen Weltsicht insgesamt als lohnenswertes Unterfangen und freue mich auf all die Zeit, die ich jetzt dank nSight spare.

[edit]Ah, dot hat es auch direkt gesehen. Vielen dank für den Hinweis. (Vermutlich ist es aber gut, dass ich es nicht gesehen habe, weil ich jetzt zumindest ein bisschen was von nSight kann).
Den Tipp mit ohne Projektionsmatrix werde ich versuchen mir zu merken. Und wegen GetError: Das bau ich grundsätzlich nicht ein, sogar die richtig schlechten OpenGL-Debugger fragen das für mich ab und zeigen Fehler aller Aufrufe an (nicht nur die, die ich checke).

Mein Mini-ITX-Rechner mit AMD E-350 ist exakt 2 Jahre nach Kauf kaputt gegangen. Er geht einfach nicht mehr an. Die Lampe vom Netzteil leuchtet nicht mehr. Das war's dann wohl.
SSD-Festplatte ausgebaut und in die Zotac umgesteckt. Obwohl ich die Zotacs für etwas anderes aufheben wollte. Vielleicht gehen die ja auch in 2 Jahren kaputt.

Eine Tortur geht zu Ende, Ubuntu von einem Stick auf eine SSD zu installieren. Ubuntu hat jedes mal versucht, den Bootloader auf den Installer-Stick statt die SSD zu schreiben. Bis ich es per Minimal-Install hinbekommen habe, dieses Verhalten zu ändern und die korrekte Festplatte für die Bootloader-Installation anzugeben.

Animationen debuggen. Ich bin mir echt nicht sicher, was schlimmer ist, falsche Animationen oder "es rendert nicht". Vermutlich ungefähr die selbe Stufe.
Bis jetzt dachte ich, alles wäre super. Bis jetzt gingen alle Modelle und ich war glücklich, dass ich Animationen endlich "am laufen" (haha) habe. Doch jetzt habe ich ein Modell, das überhaupt nicht funktioniert. Und jetzt kann ich eine endlose Kette von Berechnungen durchgehen und gucken wo der Fehler ist. Lauter Formel die kompliziert aussehen, die ich aber schon hundertmal durchgegangen bin und die natürlich im Grunde genommen stimmen. Und als Ausgabe kann sich dann wieder Matrizen anzeigen lassen. Meh.

  48 8D 0D C8 99 00 00 lea rcx,[string "foo.dat not opened; no patche"...]
  4C 8D 05 F6 99 00 00 lea r8,[string "foo.dat not opened; no patche"...+35h]
  44 2B C1             sub r8d,ecx

WAT

Visual C++ 2012 x64 … ist das echt sooo schwer, das so zu machen?!

  48 8D 0D C8 99 00 00 lea rcx,[string "foo.dat not opened; no patche"...]
  B2 35                mov r8a,35h

Meine Fresse, dieser Dilettantismus


Nachtrag: Ooooh Leute, es wird noch schöner:
  48 8D 0D C8 99 00 00       lea  rcx,[string "foo.dat not opened; no patche"...]
  4C 8D 05 F6 99 00 00       lea  r8,[string "foo.dat not opened; no patche"...+35h]
  44 2B C1                   sub  r8d,ecx
  C7 45 70 00 00 00 00       mov  dword ptr [rbp+70h],0
  48 C7 44 24 20 00 00 00 00 mov  qword ptr [rsp+20h],0
  4C 8D 4D 70                lea  r9,[rbp+70h]
  48 8D 15 A3 99 00 00       lea  rdx,[string "foo.dat not opened; no patche"...]
  48 8B 0D 0C E7 00 00       mov  rcx,qword ptr [stdout]
  FF 15 FE 04 00 00          call qword ptr [__imp_WriteFile]

In C++ übersetzt:

  auto begin = "foo";
  auto end   = "foo" + 3;
  auto len   = r8 - rcx;
  auto addr  = "foo";
  WriteFile(addr, len);

Ja, wirklich! Er addiert nicht nur die Länge um sie danach sofort wieder zu subtrahieren, sondern er lädt den String dreifach! Auf höchster Optimierungsstufe!

Nachtrag 2: Funktion von Hand geinlinet, Resultat:

  C7 45 70 00 00 00 00       mov  dword ptr [rbp+70h],0
  48 C7 44 24 20 00 00 00 00 mov  qword ptr [rsp+20h],0
  4C 8D 4D 70                lea  r9,[rbp+70h]
  41 B8 35 00 00 00          mov  r8d,35h
  48 8D 15 2E 9C 00 00       lea  rdx,[string "foo.dat not opened; no patche"...]
  48 8B 0D 97 E9 00 00       mov  rcx,qword ptr [stdout]
  FF 15 89 07 00 00          call qword ptr [__imp_WriteFile]

46 statt 57 B, also 20 % weniger Maschinentext und Befehle. Yay. Mein gesamtes Programm ist 0,5 % kleiner geworden. Fuck my life

LLVM erzeugt manchmal auch solche Dinger. Wenn man allerdings `opt -O3` zwei mal über den Code laufen lässt, kommt wieder der optimale Code heraus. Die haben einfach irgendwo die Thresholds zu niedrig eingestellt und wiederholen nicht so gern aufwendige Passes wie das GVN.

Nein; ich vermute da eher eine verpasste Optimierung statischer Daten:

Es scheint erstmal nicht klar zu sein, dass die Adresse des Strings statisch ist. Sonst hätte er ihn nicht später erneut geladen. So weit das Offensichtliche.

Weiterhin scheint der Compiler String-Konstanten als *beliebige* Zeiger zu behandeln, sobald sie einmal zugewiesen wurden:

• Win32 setzt einen flachen Adressraum von 4 GiB voraus und Überläufe sind als Wrap-Arounds definiert.
• Es scheint nicht klar zu sein, dass sowohl string als auch string + 53 niemals beliebig im Adressraum verstreut sind, sondern mittig geladen werden.
• string und string + 53 werden als 32-Bit-Zeiger geladen und subtrahiert. Das Ergebnis im Falle eines Wrap-Arounds wäre aber ein negativer 64-Bit-Wert und damit ungleich 53.
• Wären die 64-Bit-Versionen der leas genommen worden, wären die Zeiger 64-Bittig geladen und subtrahiert worden. Dann wäre das Ergebnis im Zweierkomplement sogar bei Wrap-Around wieder 53 geworden.

Ich denke, dass die Kombination aus „dieser Zeiger könnte auf alles zeigen“ und „optimieren wir die Adressen schonmal zu 32-Bit“ schuld ist. Eine abstrakte Maschinensprache à la LLVM hätte mehr Information beibehalten, und da wäre nach der Subtraktion beweisbar wieder 53 rausgekommen.

Visual Studio 2013 Express for Windows Desktop (nennen wir es kurz Wolke) ist als ISO 789 MiB groß. Wolke mit ihrem 3. Update zusammen ist als ISO 4,7 GiB groß.

Ich sehe ein, dass zwei Dateien größer als eine sind. Okay. Aber dass ein Update fünf Mal so groß ist wie das Ding, das aktualisiert wird? Das soll ich MS glauben?!

Hat das mal jemand runtergeladen? Was ist da drin? Ist die Bing-Suchleiste schon bei 4 GiB?

Umstieg von Visual C++ 2012 Update 4 auf Visual C++ 2013:

• 1000 B weniger Maschinentext (verbesserte Optimierung? Meine angeprangerten, überflüssigen float-Kopien eliminiert?)
• 500 B mehr konstante Daten (offenbar vor allem umfangreichere Laufzeittypinformation – ich hasse C++-Ausnahmebehandlung)

Visual C++ 2013 zu Visual C++ 2013 Update 3:

• 32 B weniger Maschinentext (irgendwo zwei Befehle weniger und der Rest war Padding)
• 300 B weniger konstante Daten (nicht nachvollziehbar, wo die hin sind)

Aber dieser Addition-Subtraktion-dreifach-Laden-Schmu ist immernoch drin. Und alle anderen Ärgernisse, die ich finden konnte, auch. Pfff.

Quiz: Was für Maschinenbefehle emittiert Visual C++ x64 für diesen Quelltext?

  struct Range {
    void * begin;
    void * end;
  } r;

  auto len = r.end - r.begin;

Mein Tipp wäre gewesen:

  mov    rdi,qword ptr[r]
  mov    r12,qword ptr[r+8]
  sub    rdi,r12

Was tatsächlich passiert:

Wundert mich ehrlich gesagt nicht wirklich. Habe den Maschinencode den da VC++ generiert hat nicht wirklich verstanden aber ich habe auch beim profilen schon mehrmals die leidvolle Erfahrung gemacht, dass VC++ (2008) const Variablen nicht wirklich gut optimiert sondern dass es in einer Schleife auf der es auf jede ms ankommt besser ist direkt mit der Referenz oder den Iterator weiter zu arbeiten auch wenn es den Code nicht lesbarer macht. :?

  movaps xmm2,xmmword ptr [rax]
  movups xmm5,xmmword ptr [rax+20h]
  movups xmm4,xmmword ptr [rax+10h]

Da soll eigentlich eine Matrix geladen werden. Wie Visual C++ 2013 darauf kommt, dass die ersten vier floats 16-Byte-ausgerichtet sind, und die anderen acht nicht? Keine Ahnung. Warum das einen Unterschied machen sollte? Keine Ahnung, denn moderne CPUs können beides gleich schnell. Jedenfalls ist die Matrix nicht ausgerichtet und nun stürzt meine Release-Version ab wenn man auf 3rd Person schaltet.

Dieser Fehler sieht so ähnlich aus und sollte eigentlich schon behoben sein. Aber wie ich Visual C++ kenne, muss man ihn für jeden Datentyp einzeln beheben lassen.

Nachtrag: Problematisch ist der folgende Quelltext: Im Speziellen werden die acht identischen(!!!) Aufrufe similarityFrom(planeToView), die Quaternion & Offset in eine 3×4-Matrix umwandeln, nicht wegoptimiert(!!!!!!!!). Einer davon wird dann via movaps geladen obwohl er nicht an 16 B ausgerichtet auf dem Stapel liegt, und … bumm.

Wenn man es wie 1987 macht und eine temporäre Variable anlegt: dann funktioniert es nicht nur, sondern resultiert in weniger als halb so vielen Maschinenbefehlen.

Visual C++ 2013 Update 3 für x64 mit /O2.

Prost.

Ich habe einen vector<string> binär in eine Datei geschrieben (den ganzen Vektor am Stück, wie man es halt mit primitiven Datentypen machen würde). Allerdings an einer Stelle, die nicht so oft benutzt wurde, weswegen ich es auch erst sehr viel später bemerkt habe. Der Absturz kam natürlich erst, als die (relativ lange) Funktion verlassen wurde und hat mich extrem irritiert, da man alles mit dem Debugger schön durchgehen konnte und in den Strings (und in allem, was danach geladen wurde) auch wirklich die richtigen Werte standen. Nur irgendein interner Zeiger oder so war halt falsch.

Ich bereite ein Architektur-Review für SW in medizinischen Produkten vor. Dafür darf ich mich durch Prozess-Dokumentationen ( schwer bis gar nicht zu lesen ), Requirements, verbindliche Regelwerke und wahrscheinlich auch bald noch durch irgeneine Form von heiligen Buch durchquälen, um das dann in irgendeiner verständlichen Weise in eine Präsentation zu questschen, die dann multinational beurteilt wird. Nebst der oben genannten Barrieren also noch English + Konferenz-Call mit Desktop-Sharing on top. Hurra!

Gruß Kimmi

Wenn Menschen die halbe Applikationslogik in SQL queries packen... :(

Achja... das weckt Erinnerungen. Ein Mobiltelefon per Bluetooth mit einem Autoradio verbunden, erlaubt u.A. den Austausch von Kontaktinformationen, damit das Autoradio z.B. den Namen eines Anrufers anzeigen kann. Die Bluetooth-Truppe hatte neben einer Menge ärgerlicher Inkompatibilitäten und Dummheiten auf Seiten der Mobilfunk-Geräte auch einige hausgemachte Probleme. Die banale Abfrage, ob ein Anrufer mit Namen XYZ existiert, spie einen zwanzigzeiligen SQL-Ausdruck in die Debug-Konsole. Sieben Inner Joins, um einen Namen rauszufinden. Da waren Profis am Werk. Und die Profis wunderten sich, warum trotz aller Optimierungen der arme 600MHz-Embedded Prozessor noch 30s für ein Query brauchte.

Genau sowas.

Das Problem (neben den offensichtlichen) ist ja auch das sowas NIEMALS korrigiert wird. Sowas packt ja keiner freiwillig an. Haste dann fuer Jahre in der codebase.

In diesem Zusammenhang gibt's dann auch oft noch Cargo cult programming... Der Begriff war mir recht neu und ich musste ziemlich lachen, als ich ihn das erste mal nachgeschlagen habe.

Bei SQL sieht mir das eher nach if all you have is a hammer, everything looks like a nail aus ;)

kimmi hat geschrieben:Ich bereite ein Architektur-Review für SW in medizinischen Produkten vor. Dafür darf ich mich durch Prozess-Dokumentationen ( schwer bis gar nicht zu lesen ), Requirements, verbindliche Regelwerke und wahrscheinlich auch bald noch durch irgeneine Form von heiligen Buch durchquälen, um das dann in irgendeiner verständlichen Weise in eine Präsentation zu questschen, die dann multinational beurteilt wird. Nebst der oben genannten Barrieren also noch English + Konferenz-Call mit Desktop-Sharing on top. Hurra!

Gruß Kimmi

Dann bemängele das in deinem Review und lass' die Leute das noch mal machen, bis es in Ordnung ist. Reviews sind ja nicht dazu da, dass du Geld bekommst und die Sache abnickst.

TheBenji hat geschrieben:Wenn Menschen die halbe Applikationslogik in SQL queries packen... :(

Finde ich gar nicht so schlimm. Dann kann das DBMS wenigstens ordentlich optimieren. Es gibt ganze Softwareprodukte in der Energiewirtschaft, die nur mit SQL-Produkten (und Oracle Form Builder) gebaut wurden.

Chrome hat mal wieder den Font-Renderer geändert … wenn ich mich recht irre, gehen sie nun den Apple-Weg, der die Linien nicht mehr an Pixeln ausrichtet. Shit.Seht ihr das W? Nein? Ich auch nicht! Nirgends! AAAAAAAAAAH

Eigentlich haben sie auf DirectWrite umgestellt, welches wiederum Pixel-Snapping können sollte. Bei mir scheitert es aber auch bei einem gewaltigen Anteil der Fonts. Aktuell hilft leider nur, unter [url]chrome://flags/[/url] DirectWrite abzuschalten.

Heut' im Möbelmarkt übers EC-Karten-Limit geflucht. Selbes Dilemmat hatte ich schon mit Online-Banking und der Kreditkarte, welche inzwischen beide angehoben sind. Bloß die EC-Karte noch nicht.

Schon mal versucht, ein Haus zu bezahlen per Online-Banking? Je nach Bank muß man sich da das Liimit hochschrauben lassen. Sehr heikel, wenn man das beim Kauf nicht weiß :).

Gruß Kimmi

Das meine Bank erstmal nachfragt bevor es 200k von meinem Konto abbucht find ich jetzt aber nicht so schlimm :D

Kennt ihr Kernel Transactions in NTFS?

Das ist eine sehr gute Idee: Es erlaubt, Operationen wie das Erzeugen und Füllen einer Datei atomar zu machen. Ein Installer legt z.B. die Dateien und Registry-Einträge des zu installierendes Programms in einer Transaktion an. Währenddessen sind die Änderungen, die am System vorgenommen werden, nur für dieses Programm (genau: innerhalb dieser Transaktion) sichtbar. Falls die Installation fehlschlägt, wird die Transaktion als Ganzes rückgängig gemacht. Das geschieht im Kernel – es kann also nicht fehlschlagen. Falls die Installation gelingt, wird die Transaktion committed, und damit wird die gesamte fertige Installation auf einen Schlag für den Rest des Systems sichtbar.

So weit die Theorie. In der Praxis gibt es sowas wie Stromausfälle, und die dürfen den Systemzustand nicht kompromittieren. Außerdem muss sowas tief im System verankert sein. Darum hat NTFS eine Log-Datei, in der alle laufenden Transaktionen vermerkt werden. Nach einem Stromausfall kann so noch vor dem Boot festgestellt werden, ob eine Transaktion unterbrochen wurde, und der Schaden kann aufgeräumt werden, bevor das System drüber stolpern kann.

Dummerweise wurde vergessen, diese Log-Datei neu zu allokieren.

Und Windows Update / MSI funktioniert hauptsächlich mittels Transaktionen.

So belegt diese Log-Datei auf meinem Systemlaufwerk mittlerweile 363 MiB. WTF, Microsoft?! REALLY?! Ihr habt ein Memory Leak ins Dateisystem eingebaut gekriegt?!

Abfragen könnt ihr das mittels Kommandozeile (als Administrator) fsutil resource info c:.

Für den nächsten Neustart könnt ihr die Datei auf 1 MB zurücksetzen via fsutil resource setautoreset true c:\.

(Ich hab’s beim Optimieren meiner virtuellen Maschinen bemerkt.)

Meine Festplatte ist letztes Wochenende abgeraucht. Nach anfänglichen Lesefehlern, DMA-Lesefehlern und sonstigen kaputten Blöcken, verweigerte sie während der Datenmigration ihren Dienst und meldete sich später auch nicht mehr im BIOS. Das bittere ist, dass darauf unwiderbringliche Daten von vor 10 Jahren drauf sind. Letztlich bin ich selbst schuld, weil ich nicht die Symptome nicht früh genug ernst genommen habe und letztlich keine Backup-Strategie eingesetzt habe. Das sollte hoffentlich eine Lehre auch für alle anderen sein, regelmäßig Backups zu machen. Im Nachhinein heißt es ja, wer seine Daten nicht sichert, hält sie auch nicht für erhaltenswert. :-/