Aufgabe 7.2: Mikroprogramm-Steuerwerk analysieren

Transkript

1 Fachgebiet Rechnerarchitektur Fachbereich Informatik Lösungsvorschlag 7. Übung Technische Grundlagen der Informatik II Sommersemester 2009 Aufgabe 7.1: Schritt-Steuerwerk in Verilog Das in der Vorlesung (Kapitel 4, Folie 20) angegebene Verilog-Programm ist zu vervollständigen: module stw(clk,, x2, x3, y1, y2); input clk,, x2, x3; output y1, y2; reg [3:0] z; // Zustsregister sync initial z = 4 b0001; assign y1 = z[0] & z[1] z[2] & x2; a) assign y2 = z[1] z[2] & ~x3 z[3]; clk) z[0] <= z[0] & ~ z[3] & (~ ~x3); z[1] <= z[0] & ; b) z[2] <= z[1] & x2 z[3] & & x3; c) z[3] <= z[2] z[1] & ~x2; Aufgabe 7.2: Mikroprogramm-Steuerwerk analysieren Gegeben ist ein MP-Steuerwerk, ähnlich wie das aus der Vorlesung Kapitel 4, Folie 17. module stw(clk,, y1); input, clk; output y1; reg [1:0] s; initial s = 0; // Zustsregister sync reg [2:0] FG [0:7]; // ROM initial FG[0]=3'b001; FG[1]=3'b110; FG[2]=3'b110; FG[3]=3'b001; FG[4]=3'b011; FG[5]=3'b100; FG[6]=3'b111; FG[7]=3'b010; wire [2:0] bef; assign bef = FG[{,s}]; assign y1 = bef[0]; clk) s <= bef[2:1]; Geben Sie die Übergangstabelle und den Zustsgraphen an. Sie können die Zustände dabei zur Vereinfachung auch dezimal darstellen. Seite 1 von 7

2 Übergangstabelle Zustsgraph s s' y y1 = 1 1 y1 = 0 2 y1 = 3 y1 = ~ Aufgabe 7.3: Mikroprogramm-Steuerwerk in Verilog Das in der Vorlesung vorgestellte Fallbeispiel Serien-parallele Multiplikation soll in Verilog beschrieben werden werden. Das folge Bild zeigt das Rechenwerk mit der Schnittstelle zum Steuerwerk. clock start stop X Y load clock addif + P(17:9) P(8:1) shr state iset0 iplus1 i 0 ikleiner7 +1 <7 Rechenwerk a) Das Steuerwerk ist als Mikroprogramm-Steuerwerk in Verilog zu implementieren. Hinweis: Schauen Sie sich dazu auch das vierte Kapitel der Vorlesung an. Für ein Mikroprogramm-Steuerwerk entwickeln wir zunächst eine Übergangstabelle. Seite 2 von 7

3 Wir nen damit, die Eingangssignale des Steuerwerks zu identifizieren (siehe Bild): start, ikleiner7 (1-Bit-Signale) und der aktuelle Zust (clock spielt für die Übergangstabelle keine Rolle). Hierbei muss man sich überlegen, wie viele verschiedene Zustände es gibt (siehe hierzu auch Kapitel 4 der Vorlesungsfolien). Es gibt 4 Zustände (einen Startzust für die Initialisierung (s1), einen für die Addition, falls diese notwig ist (s2), einen für den immer stattfinden Rechtsshift (s3) und einen Endzust (s4)). Der Zust kann also mit 2 Bits kodiert werden (durchnummeriert in der Reihenfolge der Aufzählung). Die Eingangssignale bilden die Adresse der Zustsübergangstabelle, die hier also insgesamt 4 Bit lang ist, das heißt die Tabelle wird 16 Zeilen haben (von 0 bis 15). Wir definieren als Reihenfolge für die Adresse (MSB nach LSB) start, ikleiner7, state. Als nächstes identifizieren wir die Ausgangssignale: stop, load, addif, shr, iset0, iplus1 (1-Bit-Signale), und der Folgezust (wieder 2 Bits). shr und iplus1 kann man hierbei zu einem Signal zusammenfassen, da sie immer die gleichen Werte annehmen. Insgesamt ist jede Zeile des entstehen Speichers also 7 Bit lang. Wir definieren für jede Zeile wieder eine Reihenfolge (MSB nach LSB): state, iset0, load, addif, iplus1/shr, stop. Als nächstes überlegen wir uns, welche Eingangssignale welche Zustsübergänge verursachen und welche Steuersignale jeweils für den aktuellen Zust gesetzt werden müssen. Dabei entsteht folge Übergangstabelle: start ikleiner7 s[1] s[0] s [1] s [0] iset0 load addif iplus1 /shr stop Das Verhalten wurde hier analog zu den Vorlesungsfolien definiert (siehe Kapitel 4, Folien 24, 32 und 35). Wichtig bei Übergangstabellen ist, dass für jede mögliche Adresse ein Verhalten definiert sein muss. (Anmerkung: Es gibt auch ere Möglichkeiten, das Verhalten des Steuerwerks zu definieren. Hier hat beispielsweise das Verändern des Startsignals währ der Berechnung keinen Einfluss (Berechnung wird in jedem Fall zu Ende geführt). Denkbar wäre beispielsweise auch, dass das Startsignal nach dem Laden zurückgesetzt werden muss, damit die Berechnung weitergeführt wird, und dass ein erneutes Setzen von start zu einem Neun führt.) Seite 3 von 7

4 Aus diese Übergangstabelle kann man nun ganz einfach in Verilog das Mikroprogramm-Steuerwerk schreiben (einen Speicherbereich erstellen, diesen belegen und die einzelnen Bits richtig den Ein- und Ausgangssignale zuweisen): // Mikroprogramm-Steuerwerk - Modul module stw(ikleiner7, clock, start, stop, state, load, addif, shr, iset0, iplus1); input clock; input start, ikleiner7; output [1:0] state; reg [1:0] state; initial state = 0; reg [6:0] mpmem [0:15]; // mp speicher wire [3:0] adr; // adresse assign adr = {start, ikleiner7, state}; wire [6:0] bef = mpmem[adr]; // mikrobefehl, ausgang speicher output stop; output load, addif, shr; output iset0, iplus1; // Steuersignale für p // Steuerssignale für i // Zuweisung der ausgehen Steuersignale assign stop = bef[0]; assign iplus1 = bef[1]; assign shr = iplus1; assign addif = bef[2]; assign load = bef[3]; assign iset0 = bef[4]; // Zuweisung des neuen Zusts (sync) clock) state <= bef[6:5]; // Speicherbelegung initial mpmem[0] = 'h10; // mpmem[1] = 'h44; // mpmem[2] = 'h62; // mpmem[3] = 'h61; // mpmem[4] = 'h10; // mpmem[5] = 'h44; // mpmem[6] = 'h22; // mpmem[7] = 'h61; // mpmem[8] = 'h38; // mpmem[9] = 'h44; // mpmem[10] = 'h62; // mpmem[11] = 'h61; // mpmem[12] = 'h38; // mpmem[13] = 'h44; // mpmem[14] = 'h22; // mpmem[15] = 'h61; // Seite 4 von 7

5 b) Das Steuerwerk ist als Schrittsteuerwerk zu zeichnen, in Verilog zu implementieren und zusammen mit dem Rechenwerk in einer Testumgebung zu simulieren für die Werte 8 und 255. Das Timing-Diagramm ist beizufügen. Hinweis: Ein Beispiel für ein Schrittsteuerwerk finden Sie im vierten Kapitel der Vorlesung. start clock Schritt-Steuerwerk not s1 iset0 load or ikleiner7 s2 addif s3 shr, iplus1 not or s4 stop // Schrittsteuerwerk - Modul module stw(ikleiner7, clock, start, stop, state, load, addif, shr, iset0, iplus1); input ikleiner7, clock, start; output stop; output [0:3] state; reg [0:3] state; initial state = 4'b1000; output load, addif, shr; //Steuersignale für p output iset0, iplus1; // Steuerssignale für i // Zuweisung der neuen Zustände (sync) clock) state[0] <= state[0] & ~start; state[1] <= state[0] & start state[2] & ikleiner7; state[2] <= state[1]; state[3] <= state[2] & ~ikleiner7 state[3]; //Zuweisung der ausgehen Steuersignale assign stop = state[3]; assign load = state[0] & start; assign addif = state[1]; assign shr = state[2]; Seite 5 von 7

6 assign iset0 = state[0]; assign iplus1 = state[2]; // Rechenwerk - Modul (enthält Zähler i), siehe Vorlesung Kapitel 4, Folie 29 module rw(iset0, iplus1, load, addif, shr, clock, x, y, p, i, ikleiner7); input clock; input [8:1] x, y; // von der Test-Umgebung input load, addif, shr; output [17:1] p; reg [17:1] p; // sync clock) if (load) p <= {9'b0, y}; if (addif) if (p[1]) p[17:9] <= p[16:9] + x; if (shr) p <= p >> 1; input iset0, iplus1; output [2:0] i; reg [2:0] i; // sync counter output ikleiner7; assign ikleiner7 = (i < 7); clock) if (iset0) i <= 0; if (iplus1) i <= i + 1; // Testumgebungs Modul // leicht angepasste Version der Testumgebung von Kapitel 4, Folie 30 module testbed(); reg clock; // boole buffered reg [8:1] x, y; // boole, Eingangswerte reg start; // boole, start-signal wire stop; // stop signal vom Multiplizierer wire [17:1] p; // zur Anzeige des Ergebnisses wire [3:0] state; // Anzeige wire [2:0] i; // Anzeige // Einbindung des Steuerwerks stw stw(ikleiner7, clock, start, stop, state, load, addif, shr, iset0, iplus1); // Einbindung des Rechenwerks rw rw(iset0, iplus1, load, addif, shr, clock, x, y, p, i, ikleiner7); Seite 6 von 7

7 // Testen initial x = 8; y = 255; // zu mulitpliziere Werte initial start = 0; #15 start = 1; #10 start = 0; initial clock = 0; #5 repeat (100) #5 clock = ~clock; initial wait (stop) $display("%d * %d = %d %h", x, y, p, p); initial wait clock) $finish; initial $dumpfile("a7-3.vcd"); $dumpvars(1); Seite 7 von 7