====== Allgemeines ======
B: Beisitzer (Kreutzer)

P: Prüfer (Philippsen)

S: Student

Zeit: 30min (Voll ausgenutzt)


====== Stimmung ======
Nervoes. Unter anderem nach dem Kommentar von P, dass ich mich in die Mitte setzen soll, damit B und P mich von beiden Seiten in die Zange nehmen koennen zum zerstoeren..

====== Analyse ======
     int x // <= soll v werden.
     
     float foo(float v) // <= soll baz werden.
     {
         return v + 42.0;
     }
     
     int foo(int n)
     {
         // Code     
     }
     
     int main()
     {
         a[10][4];
         int n;
         int s;
         float k;
         // Wertezuweisung
         
         if((n > 25) || (s < 20 && foo(a[..][..] * ...) < 5)) //[1]
         {
             int x;
             x := 5;
             n := foo(5);
         }
         else
         {
             x := 6;
         }
          
          k := foo(a[..][..] + (13.0 + 11.0));
          s := foo(13);
          
          //...  
     }
B: Wir wollen ein Refactoring Tool schreiben. Hier ist ein Stueck Code mit einer globalen Variable x und mehreren Funktionen. Was machen wir damit?

S: Zuerst lexen und dann AST inklusive Definitionstabelle aufbauen.

B: Und dann? Woher weiss ich, wann ich welche Variable umbenennen muss?

S: Man guckt in der Definitionstabelle nach, worauf das Symbol zeigt.
Symboltabelle hingezeichnet und kurz erklaert...

B: Ok, und jetzt haben wir hier noch die Funktion foo, die wir umbennen wollen.

P: Die ist aber ueberladen. Wie geht das da?

S: Naja, der obere Teil (Funktionsdefinition) ist noch identisch zur Methode. Danach darf man sich die Funktionsaufrufe angucken und anhand der Parameter entscheiden, um welchen Aufruf es sich handelt.


====== Abbildungsphase ======

B: Was macht man in der Abbildungsphase?

S: Transformationen und Optimierungen.

B: Ok, welche Art von Transformationen?

S: Variablenfaltungen. (Zeigt auf 13.0 + 11.0)

P: Ja, ok. Aber was ist der eigentliche Sinn der Abbildungsphase? Was will man danach haben?

S: Oh, man will eine Zwischensprache erzeugen! Weil man so mit ziemlich wenig Aufwand auch Programme fuer andere Architekturen erstellen kann.

B: Gut, und was passiert sonst noch in der Abbildungsphase?

S: (Etwas verunsichert) Erm, naja es werden auch teilweise noch Operationen vertauscht, um so Hardware optimal auszunutzen und weil es manchmal effizienter ist.

B: Ok, wir haben hier einen Baum einer Bedingung. Wie generiere ich hierfuer Code mit Cut-off-Semantik?
(Es handelt sich bei dem Baum um die Condition bei [1])

S: (Kurz durchgefuehrt. Einfach das bekannte Schema angewendet.)

P: Ok, jetzt fehlt da aber noch was..

S: Stimmt, ich hab hier einen Sprung vom Ende des "true"-blocks zum ende des "false"-blocks vergessen.

P: Richtig. Und was passiert, wenn wir zu true bzw. false springen?

S: Naja, es wird halt der entsprechende Codeblock ausgefuehrt. (zeigt auf Programmbeispiel weiter oben)

====== Codierungsphase ======
B: Soo, was passiert denn in der Codierungsphase?

S: Es wird Programmcode aus dem Zwischencode erstellt und dieser wird anschliessend assembliert/gelinkt. Davor findet noch die Registerzuteilung statt.

P: Ok, und was muss man da noch beachten?

S: Erm.. Faellt mir gerade nicht ein..

P: Operationen-Reihenfolge festlegen. Warum?

S: Ach das liegt doch an der Hardware, weil manche Operationen (div, mul) laenger dauern und man so sein Programm noch auf die Hardware optimieren kann.

P: Ja, und was noch?

S: Erm.. Manche Operationen muessen vor anderen ausgefuehrt werden, weil man deren Ergebnis braucht.

B: Gut, Hier hast du n Code, wie bekomme ich da einen Baum?

     t1 <- a * b
     t2 <- 3 * c
     t3 <- t1 * t2
     a <- t3

(Habs erstmal falsch gemacht und n Graph fuers List-Scheduling aufgestellt)

P: Das sieht jetzt aber seeehr nach List-Scheduling aus. Wie geht es denn richtig?

S: Man muss sich den Code von unten nach oben angucken und erstellt dann fuer jede Zeile einen Knoten mit den Kanten als Abhaengigkeiten.

P: Passt.

B: So, kommen wir nochmal zur Operationen-Reihenfolge: Wie funktionieren denn Baumtransformationen? Was braucht man dafuer erstmal?

S: Also man hat ja seine Grammatikregeln (reg <- mem, etc) und braucht jetzt Regeln fuer die Baumtransformationen.

B: Richtig. (legt mir ein Blatt mit ein paar ASM-Befehlen und Grammatikregeln hin.) Wie geht das hier zum Beispiel?

S: (Baumtranformationsregeln kurz angefangen, waren ziemlich trivial)

B: Ok passt, das reicht. Und wie geht die hier? (War eine "minimal schwerere" mit zwei Aesten)

S: (wieder schnell die Loesung hingekritzelt.)

P: Ja, und wie krieg ich jetzt meinen Code??

S: Man hat ja die ASM-Befehle, die man hinschreibt, sobald man eine Baumtransformationsregel durchfuehrt..

P: Ja.

B: So, du hast vorhin Registerzuteilung erwaehnt. Wie funktioniert da die Baumtransformation? (wieder mit kleinem Beispiel)

S: Man hat wieder seine Regeln und nutzt in dem Baum Pattern-matching von unten nach oben (bottom-top) und wandelt dabei seine Knoten je nach Regel um.

P: Dann zeigen sie doch mal, wie das geht.

S: (war unsicher, wo man wie anfangen muss. Hab es schlussendlich anscheinend falsch gemacht und bin wie bei Graham & Glenville vorgegangen.)

P: Ja, und wo ist jetzt der Unterschied zu G&G? Was ist der Vorteil?

Doch dann war die Zeit schon vorbei.. 

====== Besprechung ======

P: Was wuerden Sie sich denn geben?

S: Keine Ahnung, kann ich echt schlecht einschaetzen.

P: Das sagen irgendwie alle...

Zum Schluss wurde ich noch darauf hingewiesen, dass ich die Baumtransformation fuer die Registerzuweisung falsch gemacht hab und P meinte, dass ihm vor allem wichtig ist, dass Stundenten den Stoff anwenden koennen, was ich scheinbar ganz gut konnte.