Anti-Jammer-Thread

[Schrompf]

Wow, cool. Ist vorgemerkt.

[eXile]

Wie immer, so ist es auch auch hier nur schwer möglich die Features zu verstehen, ohne die mal tatsächlich praktisch angewandt zu sehen. Darum gibt es auch auf Channel 9 ein Video vom Herrn STL dazu.

Das hört sich alles sehr nett an. Zwei Dinge hat er etwas übersprungen.

Erstens die magic statics. Da hätte ich sehr, sehr gerne Disassembly gesehen. Dann muss man mal selber ran. Code:

Code: Alles auswählen

#pragma warning(disable : 4350 4514 4710 4711 4820)
#include <iostream>

int MyFunction()
{
	// With VC 2013 RTM: warning C4640: 'i' : construction of local static object is not thread-safe
	static int i = rand();

	i++;

	return i;
}

int main(int /*argc*/, char * /*argv*/[])
{
	std::cout << MyFunction() << std::endl;
	std::cout << MyFunction() << std::endl;
	std::cout << MyFunction() << std::endl;

	return 0;
}

Im Debug wird generiert:

Code: Alles auswählen

int MyFunction()
{
 push        rdi  
 sub         rsp,20h  
 mov         rdi,rsp  
 mov         ecx,8  
 mov         eax,0CCCCCCCCh  
 rep stos    dword ptr [rdi]  
	// With VC 2013 RTM: warning C4640: 'i' : construction of local static object is not thread-safe
	static int i = rand();
 mov         eax,104h  
 mov         eax,eax  
 mov         ecx,dword ptr [_tls_index (07FF797FA0444h)]  
 mov         rdx,qword ptr gs:[58h]  
 mov         rcx,qword ptr [rdx+rcx*8]  
 mov         eax,dword ptr [rax+rcx]  
 cmp         dword ptr [i+4h (07FF797FA03B8h)],eax  
 jle         MyFunction+67h (07FF797F92477h)  
 lea         rcx,[i+4h (07FF797FA03B8h)]  
 call        _Init_thread_header (07FF797F94BB0h)  
 cmp         dword ptr [i+4h (07FF797FA03B8h)],0FFFFFFFFh  
 jne         MyFunction+67h (07FF797F92477h)  
 call        qword ptr [__imp_rand (07FF797FA2378h)]  
 mov         dword ptr [i (07FF797FA03B4h)],eax  
 lea         rcx,[i+4h (07FF797FA03B8h)]  
 call        _Init_thread_footer (07FF797F94B40h)  

	i++;
 mov         eax,dword ptr [i (07FF797FA03B4h)]  
 inc         eax  
 mov         dword ptr [i (07FF797FA03B4h)],eax  

	return i;
 mov         eax,dword ptr [i (07FF797FA03B4h)]  
}
 add         rsp,20h  
 pop         rdi  
 ret  

Die einzig interessante und neue Sache ist, dass der rand-Aufruf mit call _Init_thread_header und call _Init_thread_footer gewrappt wurde. Die beiden Funktionen machen folgendes:

Code: Alles auswählen

	// Control access to the initialization expression.  Only one thread may leave
	// this function before the variable has completed initialization, this thread
	// will perform initialization.  All other threads are blocked until the
	// initialization completes or fails due to an exception.
	void __cdecl _Init_thread_header(int *pOnce)
	{
		_Init_thread_cs.lock();

		if (*pOnce == Uninitialized)
		{
			*pOnce = BeingInitialized;
		}
		else
		{
			while (*pOnce == BeingInitialized)
			{
				_Init_thread_cv.wait(_Init_thread_cs);

				if (*pOnce == Uninitialized)
				{
					*pOnce = BeingInitialized;
					_Init_thread_cs.unlock();
					return;
				}
			}
			_Init_thread_epoch = _Init_global_epoch;
		}
		_Init_thread_cs.unlock();
	}

Code: Alles auswählen

	// Called by the thread that completes initialization of a variable.
	// Increment the global and per thread counters, mark the variable as
	// initialized, and release waiting threads.
	void __cdecl _Init_thread_footer(int *pOnce)
	{
		_Init_thread_cs.lock();
		++_Init_global_epoch;
		*pOnce = _Init_global_epoch;
		_Init_thread_cv.notify_all();
		_Init_thread_epoch = _Init_global_epoch;
		_Init_thread_cs.unlock();
	}

Dieser Code implementiert die „synchronisierte Initialisierung“, welche im Draft N2382 beschrieben wurde. Zur Geschwindigkeit:

The fast-path for the inline function in the header has the following code as generated by gcc 3.2.2 on an x86:

mov %gs:(%esi),%eax # access to thread-local storage
cmp %eax, pthread_once_t_location # accesses the pthread_once_t variable
jg slow_path # decides whether to call the function

This code is one more instruction than a test that is not thread safe. This code touches two cache lines, while an unsafe version would touch only one. However, the additional cache line is thread-specific, and not especially likely to cause misses. As one might expect, repeated calls to the inline version achieve around 1 billion fast-path calls per second on a 2.8GHz processor with a hot cache.

Okay, das hört sich ja schon mal sehr, sehr gut an. Dann schauen wir uns mal diesen „fast-path“ mal an. Visual C++ 2013 RTM (alle mit x gekennzeichneten Zeilen werden ausgeführt):

Code: Alles auswählen

	std::cout << MyFunction() << std::endl;
x mov         eax,dword ptr [_fmode+8h (07FF74C5456E8h)]  
x test        al,1  
x jne         main+67h (07FF74C5412D7h)  
  or          eax,1  
  mov         dword ptr [_fmode+8h (07FF74C5456E8h)],eax  
  call        qword ptr [__imp_rand (07FF74C543190h)]  
  jmp         main+6Dh (07FF74C5412DDh)  
x mov         eax,dword ptr [_fmode+4h (07FF74C5456E4h)]  
x mov         rcx,qword ptr [__imp_std::cout (07FF74C543080h)]  
x inc         eax  
x mov         edx,eax  
x mov         dword ptr [_fmode+4h (07FF74C5456E4h)],eax  
x call        qword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (07FF74C543048h)]  
x lea         rdx,[std::endl<char,std::char_traits<char> > (07FF74C5417A0h)]  
x mov         rcx,rax  
x call        qword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (07FF74C543090h)]  

Visual C++ Compiler November 2013 CTP (wieder, alle mit x gekennzeichneten Zeilen werden ausgeführt):

Code: Alles auswählen

	std::cout << MyFunction() << std::endl;
x mov         eax,dword ptr [rbx]  
x cmp         dword ptr [piecewise_construct+3h (07FF6412E577Ch)],eax  
x jle         main+0B0h (07FF6412E1360h)  
  lea         rcx,[piecewise_construct+3h (07FF6412E577Ch)]  
  call        _Init_thread_header (07FF6412E18F0h)  
  cmp         dword ptr [piecewise_construct+3h (07FF6412E577Ch)],0FFFFFFFFh  
  jne         main+0B0h (07FF6412E1360h)  
  call        qword ptr [__imp_rand (07FF6412E31D0h)]  
  lea         rcx,[piecewise_construct+3h (07FF6412E577Ch)]  
  mov         dword ptr [_fmode+4h (07FF6412E5774h)],eax  
  call        _Init_thread_footer (07FF6412E1880h)  
x mov         edx,dword ptr [_fmode+4h (07FF6412E5774h)]  
x mov         rcx,qword ptr [__imp_std::cout (07FF6412E3080h)]  
x inc         edx  
x mov         dword ptr [_fmode+4h (07FF6412E5774h)],edx  
x call        qword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (07FF6412E3048h)]  
x lea         rdx,[std::endl<char,std::char_traits<char> > (07FF6412E1840h)]  
x mov         rcx,rax  
x call        qword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (07FF6412E3090h)]  

Wie man sieht, sollte das im fast-path ungefähr gleich schnell sein. Zumindest werden fast die gleichen Instruktionen ausgeführt. Natürlich ist der Code etwas größer geworden, aber das sollte alles unproblematisch bei heutigen Code-Cache-Größen sein. Beim slow-path sieht es in meiner extrem unwissenschaftlichen Messung wie folgt aus: Ca. 10- bis 20-mal mehr Prozessorzyklen werden bei der Initialisierung als bei den darauffolgenden fast-paths verbraten (ca. 4000000 Zyklen vs. ca. 230000 Zyklen).

Und zweitens ist er am Ende etwas sehr schnell über await/resumable gesprungen. Aus gutem Grunde. Denn das ist ein ganz komisches Teil, wie man hier sieht:

http://www.youtube.com/watch?v=INS1xKWKBQE&t=48m30s

Await
This feature utilizes mechanisms provided by the underlying operating system. It can only be used on machines running Windows 8.1 or later.

Braucht Betriebssystemsupport? Kopiert Stackabschnitte auf den Heap? ... Angst?


Naja ... zumindest erscheint mir await/resumable bis auf weiteres sehr suspekt. ;)

[Krishty]

Wat?! Windows hat doch seit 20 Jahren Unterstützung für Fibers, und sogar Fiber-local Storage … und dann brauchen die Windows 8.1, um drei Windows-95-Funktionen von C++ aus aufzurufen?! I can't even

[Schrompf]

Bin bis Freitag im freiwilligen Exil. Meine Frau hat mich mal wieder zu Wellness überredet, und ich muss sagen, dass ich daran bisher Gefallen fand. Mal so richtig schön dekadent im warmen Wasser lümmeln und auf Liegen liegen und endlich mal wieder zum Lesen kommen.

[antisteo]

So langsam geht's vorwärts mit meiner Firma. Ich glaube, die beste Strategie ist wirklich, eine Reihe von passiven Einkommen aufzubauen.

[Krishty]

Mama Natur will, dass ich wieder mit Sky Rendering anfange

[TDK]

Ich hab das erste mal in einer Founding-Aktion mitgemach und ja, Reset wird es schaffen.

:D

[kaiserludi]

Mama Natur will, dass ich wieder mit Sky Rendering anfange

Und, bist du ein braver Junge und hörst darauf, was Mutti sagt?

[Krishty]

Wenn Mama mich von Schule und Hausaufgaben befreit, bestimmt!

[Krishty]

A systems programmer has seen the terrors of the world and understood the intrinsic horror of existence.

The systems programmer has written drivers for buggy devices whose firmware was implemented by a drunken child or a sober goldfish. The systems programmer has traced a network problem acress eight machines, three time zones, and a brief diversion into Amish country, where the problem was transmitted in the front left hoof of a mule named Deliverance.

The systems programmer has read the kernel source, to better understand the deep ways of the universe, and the systems programmer has seen the comment in the scheduler that says "DOES THIS WORK LOL", and the systems programmer has wept instead of LOLed, and the systems programmer has submitted a kernel patch to restore balance to The Force and fix the priority inversion that was causing MySQL to hang.

A systems programmer will know what to do when society breaks down, because the systems programmer already lives in a world without law.

When you debug a distributed system or an OS kernel, you do it Texas-style. You gather some mean, stoic people, people who have seen things die, and you get some primitive tools, like a compass and a rucksack and a stick that’s pointed on one end, and you walk into the wilderness and you look for trouble, possibly while chewing tobacco.

Indeed, the common discovery mode for an impossibly large buffer error is that your program seems to be working fine, and then it tries to display a string that should say “Hello world,” but instead it prints “#a[5]:3!” or another syntactically correct Perl script, and you’re like WHAT THE HOW THE

(via The Old New Thing — Essays from the funniest man in Microsoft Research)

[Krishty]

[Schrompf]

Spontane Entscheidung: ich portiere jetzt mein altes Crossfire II. Ich vermute mal, es klingelt beim ersten Starten an zehn verschiedenen Out Of Bounds-Zugriffen, weil wir das komplette Spiel damals noch ohne Speicherschutz und sonstige Annehmlichkeiten geschrieben haben und mehr kreativ als verlässlich gearbeitet haben. Aber ich bin gespannt.

[Edit] Boah, ist das Oldschool. Als Datei mitgelieferte Tabellen für Sinus, Cosinus, Wurzel, ArcTan. Inklusive einem Byte WENIGER als notwendig, weil wir damals wohl noch etwas sehr verwirrt mit zero based indices umgingen. Es ist wie ein Blick in eine ferne Welt - ich bin verblüfft und muss die ganze Zeit grinsen.

[Edit2] Ich meine dieses Spiel: http://www.dreamworlds.de/projects/crossfire2_g.html

[Edit3] Und alle Daten in undokumentierten Binärdateien in Big Fucking Endian! Das wird eine Freude.

[CodingCat]

Was vor vielen Monden als waghalsiges Experiment (und Bachelor-Arbeit) begann, findet sich nun bald in GPU Pro 5: Object-order Ray Tracing for Fully Dynamic Scenes.

[Chromanoid]

Supergeil! :) Gratulation!

[Schrompf]

Wow, Glückwunsch! Gibt es auch irgendwo den vollen Text oder soll man dazu das Buch kaufen?

[CodingCat]

Danke! Ja, Volltext findet sich dann im März im Buch. ;) Eventuell wird die Demo nach Erscheinen zugänglicher, dazu weiß aber auch ich erst mehr, wenn es so weit ist.

[gdsWizard]

Auch von mir Glückwunsch ! Ich werde mir das Buch holen. :)

[Schrompf]

Die letzten paar Tage auf Arbeit waren wieder enorm spannend. Ich liebe an diesem Beruf ja vor allem dieses magische Gefühl der Erkenntnis, wenn nach Stunden der Suche plötzlich sonnenklar aus dem Code hervorleuchtet, wo der Fehler liegt. Und in den letzten Tagen gab es gleich drei solche Gelegenheiten, nach denen man gut gelaunt nach Hause geht.

- Track skippen führt zu "SD-Karte nicht lesbar"
Die GUI fasst viele "Nächster Track"-Tastendrücke zu einem Skip-Kommando mit Sprungweite XY zusammen. Und wenn der Nutzer eine SD-Karte mit nur fünf Tracks und einem unspielbaren Track eingelegt hat, dann aber wie ein Irrer auf "Skip Forward" herumhämmert, rennt der TrackChanger x Mal über alle Tracks des Mediums drüberweg und denkt irgendwann, er wäre in einer Endlosschleife. Als ich begriffen hatte, was wir uns da für ein Ei ins Nest gelegt hatten, musste ich erstmal grinsen.

- MP3-Datei mit 1kHz-Sinus hat einen 10mal höheren Klirrfaktor als eine mit einem 1,2kHz-Sinus.
Nach viel diffen und ausprobieren mit Audacity habe ich dann von einem der kompetenten Kollegen einen Auffrischungskurs in digitaler Signalverarbeitung bekommen und weiß jetzt, dass der Hochwandler von 44,1kHz Samplerate zu 48kHz nur linear zwischen den Samples interpoliert und damit Oberwellen erzeugt, die durch das Resampling wieder in den hörbaren Bereich gemappt werden. Bei bestimmten Frequenzen sind diese Oberwellen mit den Harmonischen der Grundwelle zusammengefallen und haben die Klirrfaktor-Messung durch die Decke gehen lassen.

- Ein bestimmter MP3-Player liefert per USB-Kabel nur ~2s von jedem Track und meldet die Datei danach als "nicht lesbar"
... weil dieser Trottel-USB-Player einen Bug im MTP-Protokoll hat, wonach er zwar das GetObject Primitive korrekt implementiert. Das GetPartialObject Primitive dagegen hat ein Offset und eine Länge, welcher Teil der Datei verlangt ist... und der Depp ignoriert das Offset und gibt immer Daten vom Anfang der Datei. Um sowas herauszukriegen, gibt es schicke USB Protocol Analyser, die einem aufs Byte genau anzeigen, was an Datenverkehr über die USB-Schnittstelle geht.

Ich hab wieder unerträglich viel gelernt, was ich eigentlich noch nie wissen wollte, aber ich fühle mich bereichert. Sehr schönes Gefühl.

[antisteo]

Ich habe einen weiteren Baustein zum Aufbau einer künstlichen Intelligenz gefunden - den lernenden Assoziativspeicher. Zu verdanken habe ich das einem total grottigen Artikel (http://www.heute.de/nsa-affaere-hildesh ... 25728.html)

[Chromanoid]

USK: Computerspiele sind Kunst
Ich habe mal den erläuternden Artikel verlinkt über den ich auch davon mitbekommen habe.

[xq]

C# Code "Magic". Inline-Klassen für komische Scriptsprachen:
Freu mich grade echt, dass manche statische Sprachen so tolle Features haben, dass es geht.

Code: Alles auswählen

Main()
{
	var evaluator = new
	{
		evaluate = (Func<string, double>)((expression) =>
			{
				var csc = new Microsoft.CSharp.CSharpCodeProvider();

				var args = new System.CodeDom.Compiler.CompilerParameters(new string[] 
		{ 
			"mscorlib.dll"
		});
				args.GenerateExecutable = false;
				args.GenerateInMemory = true;
				args.OutputAssembly = "Evaluator";

				// Hier wird der Quellcode generiert. Wenn irgendwelche Methoden/Funktionen
				// im Parser gewünscht sind, einfach in die Klasse einfügen und static markieren.
				// Die Methoden sind dann im Parser aufrufbar.
				// {{ wird zu { da string.Format {i} durch den i-ten Parameter ersetzt.
				// Code kann durch {i} beliebig erweitert werden.
				string src = string.Format(
		@"using System;
public class Evaluator
{{
public static double Evaluate(double a, double b)
{{
	return {0};
}}
}}", expression); // Ersetzt {0} durch expression.

				var results = csc.CompileAssemblyFromSource(args, src);

				if (results.Errors.Count > 0)
				{
#if DEBUG
		foreach (var error in results.Errors)
		{
			System.Diagnostics.Debug.WriteLine(error);
		}
#endif
					throw new ArgumentException("The expression is invalid.", "expression");
				}

				var asm = results.CompiledAssembly;
				var type = asm.GetType("Evaluator");
				var method = type.GetMethod("Evaluate", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);

				// In dem Array hier die Parameter von Evaluate angeben
				return (double)method.Invoke(null, new object[] { 10.0, 25.0 });
			})
	};

	Console.WriteLine("a = 10, b = 15");
	do
	{
		Console.Write("=");
		string expr = Console.ReadLine();
		if (expr == "exit")
			return;
		Console.WriteLine("=> {0}", evaluator.evaluate(expr));
	} while (true);
}

[xq]

Viele Dank @Chromanoid. Hab mich schon gefragt, wollte aber auch nicht in die Vollansicht...

[Krishty]

Windows-Nachrichten von Message in Event umbenannt – unzählige KiB gespart. Fuck yeah

[Schrompf]

Splatter ist bei Steam angenommen worden.

[dot]

Herzliche Gratulation! :)

[Tiles]

Glückwunsch :)

[Krishty]

Freut mich sehr und gibt mir vielleicht wieder ein Stückchen Glauben an die Welt zurück :)

[antisteo]

Splatter ist bei Steam angenommen worden.

Und schnellen die Verkaufszahlen schon in die Höhe?

[Schrompf]

Danke! Ich freu mich :-) Und jetzt muss ich noch ne Menge an Splatter machen: das neue Update mit neuem Spielmodus, mehr Multiplayer, evtl. Sprachausgabe, Linux&Mac-Portierung, plus Steam Achievements, Leaderboards, Sammelkarten, evtl. Editor und Steam Workshop. Uff. Aber trotzdem prrrrrrrima!

[Edit] an den Verkaufszahlen passiert erstmal gar nix. Es kommt ja noch ne Menge rechtlicher Kram, die ganzen Materialien für den Shop und die Seiten, usw.

[ponx]

ach cool Schrompf, ich freu mich! Hab heute morgen noch dran gedacht und mich geärgert, dass ich's bis jetzt hab liegen lassen. Jetzt krieg ich doch bestimmt auch endlich meine Rumble-Effekte (tu ich doch?), sauber! Gibt's ne Chance auf Steam-Keys für die Alt-Käufer? (Sammelwahn, und denk an den Werbeeffekt rechts durch "your friends were playing.. X ")