====== Rechnerarchitektur ======
  * "Rechnerarchitektur" WS 2012/2013 (7,5 ECTS, gleiche Prüfung wie fuer 5,0 ECTS) ~ 30 min

**Prüfer:** Prof. Dr.-Ing. Dietmar Fey \\
**Beisitz:** (Name nicht gemerkt)

Papier + Stift bereitgestellt

Prüfer **P**, Student **S**.


==== CISC =====

**P**: Wir haben RISC/CISC kennen gelernt. Beschreiben Sie wie CISC
funktioniert.

**S**:

  * Complex Instruction Set Computing
  * Mikroprogrammierung mit Grafik erklärt (siehe Folien):
    * Instruction Register
    * Control Addreess Register
    * Control Memory
    * Control Buffer Register
    * Sequencing Logik
    * Decoder
    * ALU Flags
  * Makroinstruktion durch Mikroinstruktionen ausgeführt, Sprünge möglich, etc.

**P**: Was sind denn Vorteile der Mikroprogrammierung?

**S:**

  * programmierbar, erlaubt es Fehler auszubessern
  * Kompatibilität zu älteren Instruktionssätzen
  * Unterstützung von anderen Instruktionssätzen

**P**: Warum ging man von CISC weg?

**S**:

  * komplexe Adressierungsarten die keiner mehr Nutzen konnte (VAX)
  * schlechtere Parallelisierbarkeit (Pipelining)
  * Alternative: RISC


==== RISC ====

**P**: Wie funktioniert RISC?

**S**:

  * Reduced Instruction Set Computing

  * Pipelining
  * festverdrahtet
  * viele Register
  * Load/Store Architektur: alle Operanden in Registern
  * spezielle Load/Store Befehle

**P**: Was ist ein Problem bei der Instruktionskodierung?

**S**:

  * länger als vergleichbare CISC-Instruktionen
  * Redundanz da jede Instruktion gleich lang
  * Probleme für Instruktions-Caches

=== Pipelining ===

**P**: Wie funktioniert Pipelining?

**S**:

  * Aufteilung der Ausführung einer Instruktion in Phasen:
    * Befehl holen
    * Befehl dekodieren
    * Operanden holen
    * Befehl ausführen
    * Ergebnis zurückschreiben
  * Skizze von Pipelining gemalt
  * maximaler Speedup erklärt (Formel)
  * nicht erreichbar weil Register zwischen Phasen notwendig sind

**P**: (Zwischenfrage) Sind diese Register wirklich notwendig?

**S**: Nein, wenn man es korrekt timen würde dann, bräuchte man das nicht,
aber das ist schwer zu realisieren (Unterschiedliche Dauer der Instruktionen).

=== Hazards ===

**P**: Was für Hazards gibt es?

**S**:

  * Strukturhazard: nicht genug Einheiten verfügbar
  * Steuerungshazard: Sprünge
  * Datenhazard

  * Steuerungshazard erklärt, falsche Instruktionen in der Pipeline; Flush notwendig
  * Lösung: warten bis Sprungentscheidung (ja/nein) und Sprungziel bekannt

**P**: Wie kann man das besser lösen?

**S**: erstmal Branch-Loop-Buffer erwähnt:

  * zwischen Instruktions-Register und Cache
  * beschleunigt Zugriffe auf Instruktionen
  * z. B. in Schleifen nützlich

(Wollte gleich zu den dynamischen, sollte aber erstmal statische erklären.)

statische Sprungvorhersage:

  * branch-taken
  * branch-not-taken
  * by-opcode (>75%)
  * erklärt

**P**: Welche Sprünge sind wie betroffen?

**S**:

  * unbedingte Sprünge: schon in Dekodierphase erkennbar
  * bedingte Sprünge: erst nach der Operandenholphase
  * indirekte Sprünge: ebenfalls

(Da war ich mir nicht ganz sicher worauf er hinaus wollte.)

**P**: Zweite Möglichkeit?

**S**: dynamische Sprungvorhersage:

  * Branch Prediction Buffer: Funktionsweise erklärt
    * 1 bit vs. 2 bit Sprungvorhersage - welche Vorteile bei welchen Schleifen?
    * wie viele Fehler macht man mit 1 bit und mit 2 bit in einer geschachtelten Schleife (da war ich mir nicht so sicher)

  * Branch Target Buffer (Branch History Table) als Verbesserung die auch noch das Ziel speichert

**P**: Was gibt es noch als Möglichkeit?

**S**: Delay Slots, Funktionsweise an Hand von Beispiel erklärt.

    A                           A
    B    == durch Compiler ==>  JMP
    JMP                         B

Hat selbe Funktionsweise.

**P**: Was muss für B gelten?

**S**: JMP darf nicht von B abhängen.


==== Caches ====

**P**: Was für Organisationsformen gibt es bei Caches?

**S**:

  * direktabbildend
  * vollassoziativ
  * setassoziativ

jeweils Funktionsweise kurz erklärt

**P**: Was für Konsistenzprobleme gibt es?

**S**: Probleme bei mehreren CPUs, Cache-Kohärenz-Protokolle ..

**P**: (Unterbrechung) Was für Ersetzungsstrategien gibt es?

**S**:

  * Write-Through, Write-Back erklärt (bei Hit)
  * Write-Around, Write-Allocate (bei Miss)

  * Ersetzungsstrategien:
    * LRU
    * LFU
    * FIFO
    * Random
    * jeweils Funktionsweise erklärt

**P**: Was ist die beste Ersetzungsstrategie?

**S**: LRU, aber Random ist auch ganz gut.

**P**: Wann ist Random gut?

**S**: Wusste ich nicht. [Antwort: in größeren Caches]


==== GPU ====

**P**: Wie sieht der Aufbau einer Graphikkarte aus?

  * GPU hingemalt (siehe Folien)
    * globaler Speicher
    * Multiprozessoren aus Streamingprozessoren mit Shared-Memory

**P**: Wo ist der lokale Speicher?

**S**: Ich dachte Teil des Shared-Memory, war aber falsch. [Antwort: Im
globalen Speicher. Deswegen nicht so gut nutzbar, da langsam.]

**P**: Wie ist die Speicherhierarchie?

  * Register
  * Shared-Memory/Level 1 Cache
  * Level 2 Cache
  * Globaler Speicher

**P**: Wie ist das mit den Caches?

**S**: Wusste ich nicht. [Antwort: als Teil vom Shared Memory, dieser dadurch
kleiner.]


==== Flynn ====

**P**: Wie sieht denn die Klassifizierung nach Fynn aus?

**S**:

  * SISD: von Neumann-Rechner
  * SIMD: Vektorrechner/Feldrechner/Graphikkarte
  * MISD: gibt's nicht
  * MIMD: Multikernsystem

**P**: Wo würde ein Multiprozessorsystem reingehören?

**S**: MIMD


==== Eingebettete Systeme ====

**P**: Wir haben eingebettete Systeme besprochen, wie sieht denn da die
Übersicht aus?

**S**: Siehe Folie "Kosten-/Leistungsvergleich verschiedener
Implementierungsarten von Prozessoren".

    CISC/RISC <-> Mikrokontroller/DSP/ASIP <-> FPGA <-> ASIC

  * Geschwindigkeit/Stückzahlen nimmt von links nach rechts zu
  * Energieverbrauch/Flexibilität nimmt von links nach rechts ab

**P**: Was ist denn ein ASIP?

**S**: Wusste ich nicht. [Antwort: DSP ist ein Beispiel für ASIP]

**P**: Wie sieht denn der Unterschied zwischen FPGA und ASIC bei einer Aufgabe
aus?

**S**:

  * ASIC: datenflussorientiert mit den nötigen Gattern, z.B. Addierer und Multiplizierer
  * FPGA: programmierbare Blöcke die passend programmierbar verdrahtet werden, um die gewünschte Funktionalität zu erfüllen


==== Fazit ====

Atmosphäre sehr angenehm, Fragen kamen nur von Prof. Fey. Note: sehr gut