Du befindest dich hier: FSI Informatik » Prüfungsfragen und Altklausuren » Hauptstudiumsprüfungen » Lehrstuhl 2 » Allgemeines

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Beide Seiten, vorherige ÜberarbeitungVorherige Überarbeitung
Nächste Überarbeitung		Vorherige Überarbeitung
pruefungen:hauptstudium:ls2:ueb1-2017-02-14_2 [14.02.2017 14:57] – preisipruefungen:hauptstudium:ls2:ueb1-2017-02-14_2 [14.02.2017 15:22] (aktuell) – preisi
Zeile 12: Zeile 12:
 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.. 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..
  
-====== Refactoring ======+====== Analyse ======
      int x // <= soll v werden.      int x // <= soll v werden.
            
Zeile 50: Zeile 50:
      }      }
 B: Wir wollen ein Refactoring Tool schreiben. Hier ist ein Stueck Code mit einer globalen Variable x und mehreren Funktionen. Was machen wir damit? 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. S: Zuerst lexen und dann AST inklusive Definitionstabelle aufbauen.
 +
 B: Und dann? Woher weiss ich, wann ich welche Variable umbenennen muss? B: Und dann? Woher weiss ich, wann ich welche Variable umbenennen muss?
 +
 S: Man guckt in der Definitionstabelle nach, worauf das Symbol zeigt. S: Man guckt in der Definitionstabelle nach, worauf das Symbol zeigt.
 Symboltabelle hingezeichnet und kurz erklaert... Symboltabelle hingezeichnet und kurz erklaert...
 +
 B: Ok, und jetzt haben wir hier noch die Funktion foo, die wir umbennen wollen. B: Ok, und jetzt haben wir hier noch die Funktion foo, die wir umbennen wollen.
 +
 P: Die ist aber ueberladen. Wie geht das da? 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. 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.
  
Zeile 62: Zeile 68:
  
 B: Was macht man in der Abbildungsphase? B: Was macht man in der Abbildungsphase?
 +
 S: Transformationen und Optimierungen. S: Transformationen und Optimierungen.
 +
 B: Ok, welche Art von Transformationen? B: Ok, welche Art von Transformationen?
 +
 S: Variablenfaltungen. (Zeigt auf 13.0 + 11.0) S: Variablenfaltungen. (Zeigt auf 13.0 + 11.0)
 +
 P: Ja, ok. Aber was ist der eigentliche Sinn der Abbildungsphase? Was will man danach haben? 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. 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? 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. 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? 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]) (Es handelt sich bei dem Baum um die Condition bei [1])
 +
 S: (Kurz durchgefuehrt. Einfach das bekannte Schema angewendet.) S: (Kurz durchgefuehrt. Einfach das bekannte Schema angewendet.)
 +
 P: Ok, jetzt fehlt da aber noch was.. 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. 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? 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) S: Naja, es wird halt der entsprechende Codeblock ausgefuehrt. (zeigt auf Programmbeispiel weiter oben)
  
 ====== Codierungsphase ====== ====== Codierungsphase ======
-B: +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 ====== ====== Besprechung ======
-TODO+ 
 +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.