====== CPU Entwurf mit VHDL ======

**Prüfer:** Marc Reichenbach\\
**Beisitzer:** Sebastian Rachuj

===== Vorbereitung/Allgemeines =====

War eine super faire und entspannte Prüfung. Marc schubst einen in die richtige Richtung, wenn man gerade mal nicht auf die gewünschte Antwort kommt.

Fragen aus der Vorlesung wiederholen hilft extrem.

===== Prüfungsablauf =====
**Was ist ein FPGA?**
  * Programmierbare Hardware
  * Gut zum Prototyping, da mehrfach programmierbar

**Warum FPGA und nicht Universalprozessor?**
  * Auf individuell programmierbar - kann auf Spezialanwendung ausgelegt werden
  * Geringerer Energieverbrauch

**Was ist VHDL?**
  * Hardwarebeschreibungssprache

**Was ist der Unterschied zu zB. C?**
  * In C werden Anweisungen sequentiell abgearbeitet
  * In VHDL ist alles parallel, außer man bringt mit getakteten Prozessen eine Sequenz rein

**Woraus ist ein VHDL Modul aufgebaut?**
  * library -- Bibliotheken/Packages einbinden
  * entity -- Schnittstelle mit Ports
  * architecture 
    * Strukturbeschreibung -- Modul-/Hierarchiebeschreibung
    * Verhaltensbeschreibung -- Datenfluss <-> Prozesse
  * configuration -- Zuordnung entity -> architecture 

**Bitte die Schnittstelle für einen Multiplizierer für 16 bit Operanden und die architecture aufschreiben.**

<code VHDL>
entity mul is
  port (a: in std_logic_vector(15 downto 0);
          b: in std_logic_vector(15 downto 0);
          o: out std_logic_vector (31 downto 0));
end mul;

architecture behav of mul is
  -- später hier: constant b: integer := 4 bzw. 5;
begin
process(a,b) begin
  0 <= a * b;
end process;
end behav;
</code>

**Braucht man dafür einen Prozess?**
  * Nein, ginge auch mit Datenflussbeschreibung

**Streich mal den zweiten Eingang und ersetz den durch eine Konstante '4'. Wie wird das in Hardware abgebildet?**
  * HW-Multiplizierer
  * Addierer
  * 4 = 2^2 => Shift, also Verkabelung

**Wo finden wir denn solche Shifter noch in der CPU?**
  * im PC
  * bei sign-extend von immediate für Sprünge

**Jetzt ist die Konstante '5', wie sieht das jetzt aus?**
  * keine Zweier-Potenz mehr
  * entweder Multiplizierer

**Geht das nicht ressourcenschonender?**
  * shift um 2 und a nocheinmal addieren

**Skizzier mal eine Single-Cycle CPU.**
  * alle Komponenten hingemalt und jeweils kurz erklärt was es tut, was Ein- und Ausgänge sind etc.

**Schauen wir uns mal das Register-File genauer an. Wie viele Register will man denn?**
  * Es kommt drauf an
  * Wie viel Speicher steht zu Verfügung
  * Viele Register -> wenig lw/sw nötig, aber langer kritischer Pfad im RegFile Multiplexer
  * Wenig Register -> kurzer kritischer Pfad im RegFile, aber öfter Speicheroperationen mit hoher Latenz nötig

**Wie kann die use-Latency mit vielen Registern versteckt werden?** (use latency wurde nochmal erklärt und dann ein Bsp. gegeben)
<code>
  for i in ...
    lw ti, a[i]
    add tx, ti, ti
  end for 
</code>

  * Latenz der lw kann etwas versteckt werden durch etwas loop-unrolling:
<code>
for i in .... i+= 3
  lw ti, a[i]
  lw ti+1, a[i+1]
  lw ti+2, a[i+2]
  
  add tx, ti, ti
  add ty, ti+1, ti+1
  add tz, ti+2, ti+2
end for;
</code>

**Chef sagt so und so viele Register, dadurch ist der kritische Pfad aber nicht mehr akzeptabel. Wie löst du das Problem?**
  * Pipelining
  * Einzelne Ebenen des Multiplexerbaums als Pipelinestufen

**Was gibt es für potentielle Probleme beim Pipelining?**
  * Struktur-Hazards
  * Daten-Hazards
  * Control-Hazards

**Was kann hier auftreten?**
  * es wäre gut gewesen, hier einfach alle 3 Typen einmal kurz zu diskutieren
  * Struktur-Hazards sind nur in Sonderfällen ein Problem (bei gleichzeitigem Rückschreiben und Lesen)
  * Daten-Hazards sind kein Problem
  * Control-Hazards müssen behandelt werden, falls falsche Instruktionen in der Pipeline sind

**Wie viele Takte verliere ich im schlimmsten Fall bei einem Control-Hazard?**
  * So viele, wie Pipelinestufen vor der Sprungentscheidung
  * also viele, wenn RegFile maximale Anzahl an Pipelinestufen beinhaltet

**Kann die Sprung-Entscheidung schon früher getroffen werden?**
  * frühestens nach der letzten Pipelinestufe des RegFiles, da dann erst die richtigen Register ausgewählt und die Inhalten bekannt sind

**Wie könnte durch das Aufgeben von Flexibilität, doch schneller einer Sprung-Entscheidung getroffen werden?**
  * spezielle Register definieren, in denen immer Sprung-Operanden stehen, die dann sofort ausgelesen werden können