Jammer-Thread

[RazorX]

Da denkt man VS2012 bringt mit den neuen C++11 Features ein bisschen frischen Wind in den Programmieralltag und was ist: VS2012 Crash! Ich hab von CodingCat die StateManager Klasse immitiert, die eine sehr heftige Template-Magie benutzt (@CodingCat: Danke, wirklich! Ich hab was fürs Leben gelernt :D). Aufbau:

Code: Alles auswählen

template<unsigned PartialStateMask, class shaderT,
	void (_stdcall Direct3D::DeviceContext::*SetShaderP)(shaderT*, Direct3D::ClassInstance* const *, UINT),
	void (_stdcall Direct3D::DeviceContext::*GetShaderP)(shaderT**, Direct3D::ClassInstance**, UINT*),
	void (_stdcall Direct3D::DeviceContext::*SetConstantBuffersP)(UINT, UINT, Direct3D::Buffer* const *),
	void (_stdcall Direct3D::DeviceContext::*GetConstantBuffersP)(UINT, UINT, Direct3D::Buffer**),
	void (_stdcall Direct3D::DeviceContext::*SetShaderResourcesP)(UINT, UINT, Direct3D::ShaderResourceView* const *),
	void (_stdcall Direct3D::DeviceContext::*GetShaderResourcesP)(UINT, UINT, Direct3D::ShaderResourceView**),
	void (_stdcall Direct3D::DeviceContext::*SetSamplersP)(UINT, UINT, Direct3D::SamplerState* const *),
	void (_stdcall Direct3D::DeviceContext::*GetSamplersP)(UINT, UINT, Direct3D::SamplerState**)>
class ShaderStageTraits {
// snip
};

typedef ShaderStageTraits<StateMask::VertexShader, Direct3D::VertexShader, &Direct3D::DeviceContext::VSSetShader, &Direct3D::DeviceContext::VSGetShader,
			&Direct3D::DeviceContext::VSSetConstantBuffers, &Direct3D::DeviceContext::VSGetConstantBuffers,
			&Direct3D::DeviceContext::VSSetShaderResources, &Direct3D::DeviceContext::VSGetShaderResources,
			&Direct3D::DeviceContext::VSSetSamplers, &Direct3D::DeviceContext::VSGetSamplers>
VertexShaderStage;

// snip

template<class ShaderStage>
class ShaderStageStateManager {
// snip
};

typedef ShaderStageStateManager<VertexShaderStage>		VertexShaderStageStateManager;
// snip

class StateManager {
	VertexShaderStageStateManager	vsManager;
	PixelShaderStageStateManager	psManager;
	GeometryShaderStageStateManager	gsManager;
	HullShaderStageStateManager	hsManager;
	DomainShaderStageStateManager	dsManager;
	ComputeShaderStageStateManager	csManager;
// snip
};

Die Compilierung und Ausführung von StateManager funktioniert, wenn man debuggt und in eine der Methoden des ShaderStageStateManager geht oder das QuickInfo Fenster der Instanz vom StateManager öffnet schmiert das ganze VS2012 ab. Freude!

Edit: Ich glaub die wollen mir was (Bug Report ist draußen):

Eine Ausnahme (erste Chance) des Typs "System.NotImplementedException" ist in Microsoft.VisualStudio.Debugger.Engine.dll aufgetreten.

[Krishty]

Der VS 2012-Debugger springt keine return-Anweisungen mehr an. WTF wie soll ich jetzt wissen, über welchen Pfad meine Funktionen verlassen werden?!

Hat schon jemand Edit & Continue für natives C++ auf x86-32 zum Laufen gekriegt? Nachdem ich tausend Optionen eingeschaltet habe, wird jeder Versuch immernoch mit "Could not Apply Code Changes \ [Edit] [Stop] [Fuck You]" quittiert …

[Krishty]

Nach einem Tag Rumprobieren habe ich jetzt raus, warum in Visual Studio 2012 immer zufällige Quelldateien aufspringen:

VS 2012 hat einen extrem unangenehmen Bug in der Benutzeroberfläche – immer, wenn man die linke Maustaste drückt, und die Benutzeroberfläche dann kurz hakt, wird das als Doppelklick gewertet(!).


Auf meinem Eee PC bedeutet also bloßes Scrollen durch das Suchergebnisfenster, dass die Datei jedes dritten Ergebnisses geöffnet wird, weil beim Bewegen des Mausrads die Oberfläche hakt und ihre eigene Ladepause als Doppelklick interpretiert.

W T F

Wenn ich Debuggen starte, beende, oder in Einzelschritten debugge, und der Zeiger dabei zufällig über dem Solution Explorer ist, fliegen mir wie wild automatisch geöffnete Dateien um die Ohren. Dadurch wird natürlich alles noch langsamer und hakeliger.

W T F
W T F
W T F

Und wenn beim Tippen IntelliSense anspringt, wird das Wort unter meinem Zeiger dadurch automatisch markiert und dort weitergetippt.

    W T F
  W T F F
W T F F F
W T F F
W T F

Ich habe schonmal unter extremer Missgunst selber Handling für Einfach-, Doppel-, und Dreifachklicks in einer GUI implementiert, und mir fällt nicht ein, was für Text man produzieren muss, um versehentlich einen einfachen Klick als Doppelklick zu interpretieren. WTF

[Andre]

Da wir gerade am VS2012 und win8 niedermachen sind:

Ein relativ simpler Shader (SM4 level 9.1) mag vom Treiber der Intel HD 3000 nicht geladen werden, aka es crasht im Treiber von Intel. DirectX-Debug-Output möchte auf dem PC natürlich auch nicht funktionieren.

Der Treiber ist allerdings nicht der neueste. Der aktuelle Intel-Treiber für Win8 meldet halt bei der Installation (auf der RTM-Version), dass er das Betriebssystem nicht kennt oder sowas. Super.

Außerdem kann noch sagen: Finger weg von der Deutschen Version von VS2012! Wenn man bei sich selber die Englische drauf hat und dann plötzlich etwas in der Deutschen finden soll... Vorallem haben die echt fast komplett alles übersetzen lassen. Vermutlich auch noch von Leuten die keine große Ahnung der Materie hatten.

Beispiele:
Unmanaged Code -> Systemeigener Code
Managed Code -> Verwalteter Code

Im Grafikdebugger hab ich doch tatsächlich, statt etwas was wohl "Timeline" heißen sollte, "Wanduhrzeit" gefunden.

Wer soll denn da noch durchblicken? :(

[Krishty]

Ja; selbst als geneigter Deutschliebäugler schmunzle ich bei "Stapelrahmen" (Stack Frame). Schade, dass sie nicht auch Thread übersetzt haben.

Was sie bei dem Systemeigenen Code (Text! Text! Text!) geritten hat, weiß ich auch nicht.

[Jonathan]

Ich habe eine cpp Datei die ein paar Hilfsfunktionen bereitstellen soll, um Texturen aus einem Multispektralbild zu erzeugen. Ja, nun brauch ich halt irgendwie die OpenGL Header, also inkludiere ich GL/GL.h. Das reicht aber nicht, weil es darin sowas nettem wie APIENTRY oder WINGDIAPI wimmelt. Die einzige Lösung scheint zu sein, die windows.h zu inkludieren. Oh, und nachdem ich neuliche wiedermal suchen musste, weil LaodImageA nicht definiert war, obwohl es nirgends im Code auftaucht bin ich mir noch sicherer, dass man die windows.h absolut niemals inkludieren will, schon gar nicht in einem Header, der wer weiß was wo benutzt werden könnte. Und von Plattformunabhängigkeit brauch ich wohl gar nicht anfangen.

Einzige Lösung scheint zu sein, auf sowas wie glew zurück zu greifen, weil die das ganze intern irgendwie behandeln, auch ohne, dass die ganzen Windowssymbole überall definiert sind, wo man die glew.h inkludiert. Aber eine andere Bibliothek als Abhängigkeit einzubauen, weil die Windows-Header so absurd dämlich programmiert sind? Das darf doch nicht wahr sein...

[Helmut]

Was sie bei dem Systemeigenen Code (Text! Text! Text!) geritten hat, weiß ich auch nicht.

Seit wann heißt Code auf deutsch Text? Das verwirrt mich schon länger an deinen Posts. :)

[Krishty]

Der Befehlssatz (nicht zu verwechseln mit dem Satz einer Sprache) der CPU formt eine Touring-vollständige Sprache. In dieser Maschinensprache werden Befehlsworte aneinandergehängt; was in der Gesamtheit ein Programm ergibt, sind viele Wörter, also Text.

Und der Befehlssatz der CPU ist, genau wie deine Programmiersprache, eine Sprache. Bei deiner Programmiersprache sprichst du auf Gutdeutsch auch von Quelltext. Und wo wir gerade bei den beiden sind: Wer in den 70ern Informatik gelernt hat, wird nicht von kompilieren sprechen, sondern von übersetzen. Damit sollte ich auch mal anfangen.

Letztendlich heißt das Segment von Portable Executables, in denen die Befehlsworte liegen, auch meist .text.

Bei künstlichen Begriffen wie Bytecode bleibe ich aber auch lieber beim englischen Original statt das in portablen Text oder sowas zu verwandeln …

[Schrompf]

Im Grafikdebugger hab ich doch tatsächlich, statt etwas was wohl "Timeline" heißen sollte, "Wanduhrzeit" gefunden.

Das sollte "Wall Clock Time" heißen und ist bei Performance-Messungen ein gängiger Begriff. Ich wüsste nicht, wie man den besser als so übersetzen sollte.

Wer soll denn da noch durchblicken? :(

Jeder, der schon vorher mal mit Deutschem VS gearbeitet hat. Ich sehe da ehrlich gesagt keine Probleme. Es ist, wie so vieles andere, nur Gewöhnung.

[Jonathan]

Und der Befehlssatz der CPU ist, genau wie deine Programmiersprache, eine Sprache. Bei deiner Programmiersprache sprichst du auf Gutdeutsch auch von Quelltext. Und wo wir gerade bei den beiden sind: Wer in den 70ern Informatik gelernt hat, wird nicht von kompilieren sprechen, sondern von übersetzen. Damit sollte ich auch mal anfangen.

Naja, wenn man in der Uni etwas über "Übersetzerbau mit Kellerautomaten" lernt fragt man sich schon, ob nicht ab und zu ein wenig Englisch gar nicht so unalbern wäre. Aber irgendwie gewöhnt man sich dran (und für die armen Engländer muss sich doch alles ähnlich albern anhören, oder?).

[antisteo]

Und der Befehlssatz der CPU ist, genau wie deine Programmiersprache, eine Sprache. Bei deiner Programmiersprache sprichst du auf Gutdeutsch auch von Quelltext. Und wo wir gerade bei den beiden sind: Wer in den 70ern Informatik gelernt hat, wird nicht von kompilieren sprechen, sondern von übersetzen. Damit sollte ich auch mal anfangen.

Naja, wenn man in der Uni etwas über "Übersetzerbau mit Kellerautomaten" lernt fragt man sich schon, ob nicht ab und zu ein wenig Englisch gar nicht so unalbern wäre. Aber irgendwie gewöhnt man sich dran (und für die armen Engländer muss sich doch alles ähnlich albern anhören, oder?).

Du meinst, dass wir wie bei den Popsongs (was man mit Volks-Lieder übersetzen könnte) lieber englische Lieder hören, damit die peinlichen Texte nicht gleich jedem bewusst sind?

[Andre]

Wer soll denn da noch durchblicken? :(

Jeder, der schon vorher mal mit Deutschem VS gearbeitet hat. Ich sehe da ehrlich gesagt keine Probleme. Es ist, wie so vieles andere, nur Gewöhnung.

Wenn man mit einem Deutschen Visualstudio arbeiten möchte setzt das dann aber voraus, dass man zu jedem dieser Begriffe das Englische äquivalent kennt, da die meisten Artikel und Paper eben in Englisch geschrieben sind und sich somit auch auf die Englische Version beziehen.

Bei mir ist das nun kein großes Problem, aber ich sehe es schon kommen, dass so mancher Neuling nicht weiß wovon da geredet wird, nur weil da Callstack steht und bei ihm "Aufrufstliste".

[Krishty]

So lange C++ nicht zulässt, dass in der Bedingung einer do-while-Schleife eine Variable aus dem Innenbereich der Schleife vorkommt, bleibt nur goto.

[Lynxeye]

The PS3 fragment shader hardware is rather esoteric in many ways. The compiler has a really
hard nut to crack trying to optimally map a general shader onto that instruction set. A
consequence of that is that trivial changes sometimes result in wildly different outcome in
terms of shader length and/or register use. However, you can feed the compiler a seed that will
affect the heuristics it will use and whatever paths it takes internally in trying to arrange things.
It is very common that a custom seed exists that will generate a faster shader than the
defaults. The problem is just coming up with the optimal one. We made a tombola compiler
that essentially randomized seeds and tried them, and whenever it found a better seed than
previously encountered it would check that into perforce. So whenever you compiled the
shader you got the currently known best seed. We basically had a machine standing there
continuously just trying random seeds for all our shader LODs and continuously updating the
database with its latest results. After weeks of repeated attempts we would arrive at some sort
of optimum with little new improvements coming in (until someone checked in a change to a
shader that is, which reset the database for that shader). In the end we typically got shaders
that were 10-15% shorter than with default settings, resulting in a pretty decent performance

Aus Creating Vast Game Worlds - Experiences from Avalanche Studios

Meine Fresse, das einzige was an der NV4x fragment shader Hardware "esoterisch" ist, ist das diese auch mit half Präzision rechnen kann und dabei bei richtigem Scheduling zwei Instruktionen gleichzeitig durch die Pipeline drücken kann. Der Registerdruck wird natürlich auch entsprechend verringert. Das ist Kinderkacke verglichen mit VLIW oder ähnlichen Späßen. Und trotzdem wird in 2012 Würfeln noch als valide Methode betrachtet, mit welcher der Compiler Entscheidungen zur Codegenerierung treffen darf?

[Krishty]

Lustig; darüber hatte ich erst gestern mit Cat gesprochen. Ich schreibe mittlerweile von jedem meiner fundamentalen Algorithmen (allerdings auf der CPU; Shader habe ich nicht) zwei oder mehr Versionen, die ich via #define durchschalten kann. Alle paar Monate gehe ich dann wahllos Permutationen durch und wähle für die Auslieferung die, die am schnellsten läuft. Die Unterschiede liegen auch irgendwo in der Hausnummer von zehn Prozent.

[CodingCat]

internal error: compilation aborted unexpectedly (ganz genau, keine Angabe zu Art oder Ort des Fehlers)
alternativ:
xC0000005: Access violation reading location 0x00000008.

Endlich Windows 8 SDK mit neuem HLSL-Compiler. :-/

[CodingCat]

Auflösung: Der neue HLSL-Compiler kommt nicht mehr mit while (true) klar. Noch mehr unnötige Fake-Bedingungen, die nicht rausoptimiert werden dürfen. \o/

[Krishty]

I can't even

Wie geht das denn bitte?!

Rollt der immernoch alle Schleifen per default ab? Aber dann hätte es sich wohl eher als Auffressen des RAMs geäußert …

[CodingCat]

CUDA 5.0 ist da - ohne VC2012-Support. Aber es gibt eine neue Dokumentationsseite.

[Krishty]

    __assume(endOf(renderJobs) > beginningOf(renderJobs)); // immer mindestens einer
    for(auto currJawb = beginningOf(renderJobs); currJawb < endOf(renderJobs); ++currJawb) {
        currJawb->foo();
    }

Glaubt mal ja nicht, dass Visual C++ sich um das __assume() schert. Nein – ich muss die Schleife von Hand zu do { } while(); umschreiben; mitsamt nerviger Scope-Verpestung. Und bevor ihr jetzt rumheult, dass __assume() halt keine komplexen Ausdrücke können muss: beginningOf() und endOf() sind wirkungsfreie Getter; es wäre bei korrektem Compiler-Entwurf null Aufwand, dem Scheißding zu vermitteln, dass sich das Ergebnis der beiden bis zur nächsten Zeile nicht ändert.

Übrigens ist das meine heute bisher wirkungsvollste Optimierung, die in der Schleife sage und schreibe 80 KiB Maschinentext spart.

[Krishty]

    if(1 == beginningOf(stuff) - endOf(stuff)) {

kompiliert auf Assembler-Ebene (die nur Adressen, also zu int konvertierte Zeiger auf char kennt,) zu

    if(1 == ((int)(char *)beginningOf(stuff) - (int)(char *)endOf(stuff)) / sizeof(*stuff)) {

statt zu

    if(sizeof(*stuff) == (int)(char *)beginningOf(stuff) - (int)(char *)endOf(stuff)) {

sizeof(*stuff) ist ungerade; das wird also zu einer Integer-Division, die der Compiler dann wieder durch Multiplikation und Bitschieberei zu optimieren versucht!

    mov  rdx,6666666666666667h
    mov  rcx,qword ptr [rax+8]
    mov  rbx,qword ptr [rax]
    mov  rax,rdx
    mov  qword ptr [rbp],rcx
    sub  rcx,rbx
    mov  qword ptr [rbp+8],rbx
    imul rcx
    sar  rdx,5
    mov  rax,rdx
    shr  rax,3Fh
    add  rdx,rax
    cmp  rdx,1
    jne  rasterize+341h (013F8B7951h)

Vierzehn Befehle wo schlicht

    mov  rcx,qword ptr [rax+8]
    mov  rbx,qword ptr [rax]
    sub  rcx, rbx
    cmp  rcx, 123
    jne

stehen sollte! Ich sollte am besten nur noch Assembler programmieren; echt nicht zu fassen

[j.klugmann]

Wie gesagt, Clang ist Open Source. Dir steht frei diverse Verbesserungen zu implementieren. ;)

[Krishty]

Dafür müssen sie erstmal die Visual C++ x86-ABI implementieren. Atm scheint nur Itanium implementiert zu sein …

[antisteo]

Dafür müssen sie erstmal die Visual C++ x86-ABI implementieren. Atm scheint nur Itanium implementiert zu sein …

Wozu das denn? Hast du Binaries mit objektorientierten Interfaces, die du reinlinken willst?

[Krishty]

Ausnahmebehandlung, K’toren und D’toren sind auch Teil der Chose. Im Augenblick bewirkt z.B. jedes throw ein unaufgelöstes externes Symbol und sechs meiner K’toren und D’toren lassen Clang schlicht abstürzen (offenbar wegen größtenteils nicht implementierter x86-ABI). Dazu kommt, dass ich auch gern die Direct3D-DLLs linken würde; und die liegen nunmal in Microsofts .lib-Format vor.

[Krishty]

Ich habe angefangen, einen alten Algorithmus (Jordan, wo man einen Strahl in ein Polygon schießt und die Schnitte zählt um zu schätzen, ob man drinnen oder draußen ist) von Gleitkomma- auf FestkommaIntegerberechnung umgestellt (weil Gleitkomma stinkt!).

Das Ding ist enorm instabil. Bei gleichen Eingaben war es das vorher auch; aber weil die Gleitkommazahlen immer einen Tick Abweichung drinhatten, hatte sich das so ein Bisschen stabilisiert. Jetzt flackert das Ergebnis wie wild.

Es ist eigentlich genau, wie William Kahan es vorhergesagt hat: Gleitkommaeinheiten sind so günstig geworden, dass niemand von uns überhaupt noch weiß, was Stabilität bedeutet, weil wir dauernd mit einem Epsilon im Kopf rechnen um im Zweifel einfach größere Mantissen auf das Problem schmeißen.

Nachtrag: Unfassbar, wie viel schneller und einfacher man so ein Ding durch Vorberechnung und ordentliche Datenauslegung kriegen kann. Ich könnte wahrscheinlich Tage damit verbringen, das zu optimieren …

[CodingCat]

Ich habe gerade mehrfach versucht, mich zu überwinden und meine bunte objektorientierte Welt zu Gunsten einer funktionaleren Notation aufzugeben:

Code: Alles auswählen

class Foo
{
   void Sth(...);
};
// zu
class Foo;
void Sth(Foo &foo, ...);

Ich schaffe es einfach nicht. Die Angst, damit zu viele Konventionen zu brechen (Auto Completion, implizite Strukturierung des Namensraums und der Dokumentation, Prinzip der kleinsten Überraschung) ist zu groß. Dabei wären die Vorteile immens: Vollständige Unabhängigkeit von Implementierungsdetails, einheitliche Syntax mit freien Funktionen und weniger Rumgeklicke weil Implementierung an einem Ort.

Nun werde ich mich an einem datenorientierten Entity- und Rendering-System versuchen. Dort ist die funktionale Notation unausweichlich, vielleicht gewöhne ich mich so daran.

[Krishty]

Ich suche seit drei Stunden verzweifelt nach einer Möglichkeit, den Pfad meines Windows Driver Kits (7.1!) nicht in Projektdateien hard-coden zu müssen. WhyTF haben Windows SDK und DirectX SDK eigene Makros; das WDK 7.1 aber nicht?! Selbst, wenn ich die Umgebungsvariablen registriere, geht das nur für VS 2012, aber nicht für 2010.

[dot]

Property Sheets to the rescue! ;)

[Krishty]

Werden die mit dem WDK ausgeliefert?