Lange ists her, seit ich den letzten Post verfasst habe. Das hat aber auch guten Grund. Wie einige vielleicht wissen habe ich letztes Jahr mit 3 Mitstudenten eine kleine Firma gegründet. Und unser letztes Projekt war für ein Ortsansässiges Bahnunternehmen, die Thurbo. Die Freizeitapplikation wird Mitte August für das iPhone und für Android Geräte in die jeweiligen Stores gelangen. Weitere Infos zur Applikation finden sich auf der verlinkten Webseite. Das Projekt hat uns alle neben dem Studium recht in Anspruch genommen und daher hatte ich kaum Zeit für andere, private Projekte. Da die arbeiten an der Thurbo App aber mittlerweilen abgeschlossen sind konnte ich mich in den letzten paar Wochen wieder etwas eigenem widmen, was in nächster Zeit wohl dann mal ein Release geben wird.

Dazu sage ich jetzt mal nichts weiteres, sondern lasse mal ein Bild sprechen, dass hoffentlich nicht all zu viel verrät.

Natürlich werde ich zu dem noch einiges mehr sagen, sobald es fertig ist. Das Spiel hat eine interessante Geschichte.



So das wars mal wieder. Zum Abschied noch ein Bild, wo ich mich die nächsten 2 Wochen aufhalte:

Sonderlich schwierig sollte es nicht sein zu erraten welche kleine Insel das ist. Keine Kommentare | Kommentieren

Nach einer Prüfungssessions-bezogenenen Absenz von meinem Blog melde ich mich mal wieder mit einem typisch technischen Beitrag zurück. Dieses mal geht es aber eine Ebene tiefer runter ein und ein gewisses Grundverständis von Maschinencode und Calling Conventions setze ich, neben den grundlegenden Mechanismen von templates, hier voraus.

Kürzlich wurde in einem Forum (vereinfacht) folgender Code gezeigt mit der Frage warum es da einen Laufzeitfehler gibt wonach der Stack beschädigt sein soll:

class foo
{
public:
	template<typename T>
	void bar(T value, T step = T());
};
 
template<typename T>
void foo::bar(T value, T step)
{
	T dummy = step + value;
}
 
int main() 
{ 
	foo f;
	f.bar(2);
	f.bar(2.0);
}

Als ich den Fehler dann im Debug Modus auch mit der aktuellen Version des Visual C++ Compilers reproduzieren konnte und tatsächlich folgenden Fehler bekommen habe:

Run-Time Check Failure #2 - Stack around the variable 'f' was corrupted.

- VC 2010 -

wurde ich Misstrauisch. Der Code ist vollkommen in Ordnung und darum habe ich mir dann den Assembler Code angeschaut um zu sehen was da genau schief läuft. Meine erste Anlaufstelle war natürlich die Implementierung der Funktion(en) selbst. Doch nach einem Weilchen war ich der Meinung, dass diese korrekt implementiert sind. Dann habe ich mir halt mal den Aufruf der Funktionen angeschaut. Und folgende Sequenz vorgefunden:

	f.bar(2);
000910AB  push        0  % zweites Argument
000910AD  push        2  % erstes Argument
000910AF  lea         ecx,[f] % this Pointer
000910B2  call        foo::bar<int> (91037h) % Aufruf  
	f.bar(2.0);
000910B7  push        0  %(1) zweites Argument
000910B9  sub         esp,8  % schaffe Platz
000910BC  fld         qword ptr  [__real@4000000000000000 (96740h)]  % laden
000910C2  fstp        qword ptr [esp]  % speichere double
000910C5  lea         ecx,[f]  % this Pointer
000910C8  call        foo::bar<double> (9102Dh)   %Aufruf

Der Fehler liegt, wie man vermuten könnte bei (1). Doch was ist daran falsch? - Wenn wir anschauen wie der Stack aussieht wird das schnell klar was hier genau verkehrt läuft und warum das mit gleich grossen Datentypen nicht passieren würde.
Zum Zeitpunkt des Aufrufes in Zeile 5 sieht der Stack so aus:

wobei jeder Eintrag natürlich eine Breite von 4 Byte hat (auf einem 32Bit System). Da beide Parameter vom Typ int sind ist das auch in Ordnung so, da so die üblichen Calling Conventions von Funktionen unter x86 eingehalten werden und die Funktion liest dann die Parameter korrekt. Nun schauen wir wie der Stack aussieht für den zweiten Aufruf (Zeile 12). Man bemerke, dass hier die Parameter jeweils vom Typ double sind und somit 8 Byte gross sind. Der Compiler muss also entsprechenden Code erzeugen, der das beachtet. Ausschlaggebend wie der Stack aussieht sind die Zeilen 7,8,9 und 10. In Zeile 7 wird ein einfaches push gemacht, also eine 32 Bit Null auf den Stack gepusht. Dann folgt der erste Parameter (der schon wie beim vorherigen Aufruf als letzer gepusht wird). Der ist aber von der Grösse 8 Byte (da double). Also sieht der Stack so aus:

Und genau hier liegt der Hund begraben. Die aufgerufene Funktion geht hier von 2 Parametern aus, welche jeweils 8 Byte gross sind und liest dementsprechend auch jeweils 8 Byte. Das geht beim ersten Parameter auch noch gut, aber der zweite fängt korrekt bei der gespeicherten 0 an, liest dann aber den zweiten Teil des doubles von dem, was vor dem zweiten Parameter auf den Stack gepusht wurde, was so ziemlich alles sein könnte (je nachdem was man vorher noch so macht). Das so natürlich nichts korrektes bei rauskommen kann ist somit, denke ich klar.

Interessant ist auch noch was passiert, wenn man die beiden Aufrufe vertauscht:

	f.bar(2.0);
00B510AB  sub         esp,8  
00B510AE  fldz  % so geht das ausnullen
00B510B0  fstp        qword ptr [esp]  
00B510B3  sub         esp,8  
00B510B6  fld         qword ptr [__real@4000000000000000 (0B56740h)]  
00B510BC  fstp        qword ptr [esp]  
00B510BF  lea         ecx,[f]  
00B510C2  call        foo::bar<double> (0B5102Dh)  
	f.bar(2);
00B510C7  sub         esp,8  
00B510CA  fldz  % (2) autsch
00B510CC  fstp        qword ptr [esp]  
00B510CF  push        2  
00B510D1  lea         ecx,[f]  
00B510D4  call        foo::bar<int> (0B51037h) 

Hier sieht man, dass der Code eigentlich der gleiche ist bis auf die Stelen bei 3 und 12. Hier passiert eigentlich etwas ähnliches wie bei der ersten Version, aber hier sieht man, dass der Aufruf der double Version der Funktion korrekt läuft aber der zweite Aufruf also der int Version nicht so ganz. Denn da passiert die Ausnullung mit einem Fliesskomma Befehl. Das ergibt dann eine andere Fehlermeldung, aber prinzipiell wird auch hier die Stack discipline nicht eingehalten.

Eine korrekte Implementierung der Aufrufe bekommt man, wenn man die Funktionen als überladene Funktionen implementiert oder aber auch wenn man die template Funktion inline (also in der Klasse) definiert.

Ich hoffe der kurze Einblick, wie man Compiler Bugs aufdecken kann war für einige Interessant.
Mittlerweilen kümmert sich Microsoft um das Problem.Keine Kommentare | Kommentieren

Vor einem Weilchen habe ich ja geschrieben, dass ich an einem Programmierwettbewerb des BASTLIs mitgemacht habe. Nun wurden die Projekte bewertet und es hat nur für den dritten Platz gereicht. Einen Preis gab es trotzdem.

Gewonnen habe ich einen Bastli Bausatz, wobei es sich um einen vom BASTLI entworfenes Board.

Doch bis das Ding so aussieht muss noch ein wenig arbeit reingesteckt werden. Denn im Moment sieht das noch so aus:



Ich hoffe ich werde mal Zeit finden den zusammenzubauen und ein paar Programme dafür zu schreiben.Keine Kommentare | Kommentieren

In der letzten Woche hat sich auf meiner Seite einiges getan. Zumindest Inhaltlich. Zum einen habe ich es endlich einmal geschaft einige meiner Projekte und Programme einen Platz auf meiner Seite zu geben. Zu finden sind diese unter "Projekte." Vollständig ist selbst das bei weitem noch nicht, aber immerhin wirkt es nicht mehr so leer. Ein paar kleinere Sachen werde ich vielleicht noch hinzufügen und die 3-4 Projekte, an denen ich im Moment arbeite werden irgendwann auch da zu finden sein.
Es hat auch einiges dabei, was ich noch nicht veröffentlicht habe.

Ebenfalls neue dazu gekommen ist die Unterseite "Artikel", wo ich einige Blogeinträge, welche zumindest mir wichtig oder interessant erscheinen aufgelistet habe.

Der letzte Abschnitt betrifft die Übungsstunde, die ich leiten werden und diese hat auch ihren eigenen Platz erhalten. Unter "Teaching" ist die Stunde für nächstes Semester eingetragen und weitere werden dann auch dort zu finden sein.

Viel Spass mit dem neuen Inhalt. Vor allem bei den Projekten dürfte sich für einige das einte oder andere interessante befinden.Keine Kommentare | Kommentieren

Ist ein Weilchen her seit ich das letzte mal etwas gepostet habe, aber mich gibt es immer noch.
Meine lange Inaktivität liegt daran, dass ich die letzten 3 Wochen Prüfungen hatte und vorher natürlich jede Menge zu lernen hatte. Für viel anderes hatte ich keine Zeit.
Jetzt sind die Basisprüfungen an der ETH durch und ich habe 3 Wochen bis das Semester wieder beginnt, auf welches ich mich btw. bereits freue.

Im nächsten Semester werde ich dann auch als Hilfsassistent tätig sein und eine Übungsgruppe der Mathematiker/Physiker leiten. Das heisst dann Übungen leiten, Übungen korrigieren und wahrscheinlich sehr viele Fragen beantworten. Ich werde sicher noch meine eigene Seite entsprechend erweitern, um Informationen für meine Tutorlinge (wie nennt man die überhaupt politisch korrekt?!) bereitzustellen. Auch auf diese neue Erfahrung freue ich mich, was auch unter anderem daran liegt, dass man an der ETH für einen solchen Job nicht schlecht bezahlt wird.

Bis es aber soweit ist geniese ich mal noch das nichts-tun-müssen-aber-trotzdem-die-Finger-vom-PC-nicht-lassen-können. (Informatikstudenten werden wissen was ich damit meine. )

So long!Keine Kommentare | Kommentieren