7. Aufbau und Arbeitsweise einer mikroprogrammierten CPU

Transkript

1 7. Aufbau und Arbeitsweise einer mikroprogrammierten CPU 245

2 Takte und Phasen Register und Busse ALU Hauptspeicher Mikrobefehle ROM-Speicher Adressberechnung Mikroprogramme Maschinenbefehle Load-Increment-Execute Zyklus Mikroprogrammierte CPU 246

3 Takte und Phasen Durch die interne Uhr werden Takte geliefert. Jeder Takt wird in drei Phasen unterteilt. In jeder der Phasen liegt ein entsprechendes Signal P 1, P 2 oder P 3 auf 1 und alle anderen auf 0. Jeder Schalter ist nur in einer bestimmten Phase aktiv. P1: Phase 1 P2: Phase 2 Phase i Ein/Aus P3: Phase 3 Taktraten :: x MHz MHz = x ** Takte/sec. Taktdauer :: 1/x 1/x ** sec sec Bsp MHz MHz ns ns Ein Schalter, der nur in Phase i aktiv ist In Phase Pi ist Pi =1 und Pk = 0 für i <> k. 247

4 Die Bedeutung der Phasen Die Ausführung eines Mikrobefehls soll jeweils einen Takt erfordern. In jeder Phase wird ein bestimmter Teil eines Mikrobefehls erledigt. P1 Holphase Argumente für für CPU-Operationen werden bereitgestellt P2 Rechenphase CPU rechnet P3 Bringphase Speichere Ergebnis der der Berechnung 248

5 Aufbau einer CPU Eine Gruppe von 32-Bit-Registern ist über Busse mit Registern X, Y und Z verbunden. Den Buszugang regeln Schalter, die nur in bestimmten Phasen aktiv sind. X und Y sind die Operanden-, Z das Ergebnisregister der ALU P1 Holphase s 16 -s 31 aktiv Z-Bus s 32 Mehrzweckregister R0 s 16 X-Bus s 24 Y-Bus P2 Rechenphase ALU aktiv s 39 R1... R7 s 23 s 31 X-Register Y-Register P3 Bringphase s 32 -s 39 aktiv ALU Z-Register 249

6 Mikrobefehle Die Stellung der Schalter für einen bestimmten Takt wird im Maschinenwort zusammengefaßt. Das Maschinenwort bleibt einen Takt lang gültig und steuert in diesem Takt die Arbeitsweise der CPU. Es wird daher als Mikrobefehl bezeichnet. Z-Bus Mehrzweckregister X-Bus Y-Bus s 32 R0 s 16 s 24 Schalter Aktive Phase s s 31 1 s s 39 3 s 39 R1... R7 s 23 s 31 In einem Takt passiert z.b.: Phase 1 : R 1 X, R 7 Y Phase 2 : ALU rechnet Phase 3 : Z R 0, R 1 X-Register ALU Y-Register Maschinenwort s 16 s 24 s 32 s 39 Z-Register X-Bus Y-Bus Z-Bus 250

7 Funktionen der ALU Die ALU unseres CPU-Modells kann 128 Funktionen ausführen. Dafür müssen die Operanden in den X- bzw. Y-Registern liegen. Der Funktionswert kommt in das Z-Register. Meist wird dabei auch das Flag-Register gesetzt. Die Vergleichsoperationen verändern nur das Flag-Register. ALUFC Arithmetische Operationen Logische Operationen Konstante Operationen wie wie mit mit Kopie Kopie der der ALU ALU Flags Flags in in das das CC-Register ALU-FC Flags X-Register Y-Register ALU Z-Register 251

8 Befehlsumfang der ALU (FC 0-63) ALUFC Operation 0 Z := Z (Wait) (Wait) 1 Z := :=--Z 2 Z := X 3 Z := :=--X 4 Z := := Y 5 Z := :=-Y-Y 6 Z := := Y, Y, X <--> <--> Y 7 Z := := X, X, X <--> <--> Y 8 Z := := Y, Y, Y --> --> X 9 Z := := X+1 X Z := := X-1 X Z := := X+Y X+Y Z := := X-Y X-Y Z := := X MUL MUL Y Z := := X DIV DIV Y Z := := X MOD MOD Y Falls Falls < ALUFC < :: Z, Z, X := := ALUFC ALUFC Operation Z := := X SAL SAL Y Z := := X SAR SAR Y Z := := X CMP CMP Y, Y, arith. arith Z := := X AND AND Y Z := := X NAND NAND Y Z := := X OR OR Y Z := := X NOR NOR Y Z := := X XOR XOR Y Z := := X NXOR NXOR Y Z := := X SLL SLL Y Z := := X SLR SLR Y Z := := X CMP CMP Y, Y, log. log X := := X := := FFFFFFFFh Y := := Y := := FFFFFFFFh Falls Falls < ALUFC < :: Z, Z, Y := := ALUFC

9 Einbindung der ALU Die Operation der ALU wird in ALUFC eingestellt. In Phase 2 berechnet die ALU aus den Inputs in X und Y ein Ergebnis, das dann in Z ausgegeben wird. ALU-FC wird ein Teil des Mikrobefehls ist ALU-Code für Addition (Z:=X+Y) In einem Takt passiert z.b.: Phase 1 : R 1 X, R 7 Y Phase 2 : Z := X+Y Phase 3 : Z R 0, R 1 Maschinenwort Z-Bus s 32 s 39 Mehrzweckregister R0 R1... R7 s 16 s 23 X-Bus Y-Bus s 24 s 31 X-Register Y-Register Flags ALU-FC ALU Z-Register s ALU-FC s 16 s 24 s 32 s X-Bus Y-Bus Z-Bus 253

10 Der Hauptspeicher Schalter Aktive Phase s 43 1 s s 42 3 Z-Bus s 40 s 41 MAR Hauptspeicher MDR s 42 X-Bus 0 1 Mode s Format Y-Bus Der Arbeitsmodus des Hauptspeichers wird in den Mode Schaltern eingestellt: lesen = 01, schreiben = 10, warten sonst. Die Format Schalter geben an, ob auf 1, 2 oder 4 Bytes zugegriffen wird. In MAR (Memory Address Register) wird die Adresse eingestellt. Über MDR (Memory Data Register) gelangen die Daten von bzw. zum Speicher. Eine typische Leseoperation s 40 s 43 s 46 s Speicher Md Ft 254

11 CPU mit RAM Zum Zum Schreiben sind sind zwei zwei Takte Takte notwendig: Phase Phase 3 :: Z MDR MDR Phase Phase 1 :: Phase Phase 2 :: Adresse berechnen Phase Phase 3 :: Z MAR MAR s 39 s 40 MAR R0 R1... R7 Hauptspeicher MDR s Mode s Format X-Register Y-Register s 9 ALU-FC Flags ALU-FC ALU Z-Register s 16 s 24 s 32 s 39 s 40 s 43 s 46 s X-Bus Y-Bus Z-Bus Speicher Md Ft 255

12 Das ROM ROM MCAR MAR Hauptspeicher Mode MCDR MDR Format ROM ROM = Read ReadOnly OnlyMemory Ein Ein Speicher, in in dem dem die die Mikrobefehle stehen. MC MC = micro microcode code R0 R1... MCAR MCAR ist ist Bit Bit breit breit Adressen MCDR MCDR ist ist Bit Bit breit. breit. ROM-Größe ca. ca. 6 KByte KByte Es Es gilt gilt immer immer :: Mode Mode = lesen lesen Format = Bit Bit R7 Flags X-Reg ALU-FC Z-Reg Y-Reg s 1 s 9 s 16 s 24 s 32 s 39 s 40 s 43 s 46 s 49 MC MC-Next ALU-FC X-Bus Y-Bus Z-Bus Speicher Md Ft 256

13 Adressberechnung ROM MCDR Adressberechnungseinheit MCAR Während die die CPU CPU den den gegenwärtigen Befehl Befehl noch noch bearbeitet, berechnet eine eine Adressberechnungseinheit daraus daraus die die Adresse des des nächsten Befehls im im ROM. ROM. Diese Diese Adresse wird wird im im MCAR MCAR abgelegt und und der der gefundene nächste Befehl Befehl liegt liegt danach im im MCDR MCDR vor. vor. Der Der erste erste Teil Teil des des Mikrobefehles (1 (1 Byte) Byte) gibt gibt an, an, wie wieder nächste Befehl Befehl zu zu ermitteln ist. ist :: MCAR MCAR := := 4 ** MC-Next :: MCAR MCAR := := MCAR MCAR *MCNext :: MCAR MCAR := := MCAR MCAR *MCNext s 1 s 9 s 16 s 24 s 32 s 39 s 40 s 43 s 46 s 49 MC MC-Next ALU-FC X-Bus Y-Bus Z-Bus Speicher Md Ft 257

14 Absolute Adressierung ROM MCAR MAR Hauptspeicher Mode MCDR MDR Format Mit Mit MCNEXT können der der Mikrobefehle im im ROM ROM adressiert werden. Adress- Ist Ist berechnungs- einheit nächste Mikrobefehl 4*MC-Next MC=00, dann dann ist ist der der R0 R1... R7 X-Reg Y-Reg Flags ALU-FC s 1 s Z-Reg s 16 s 24 s 32 s 39 s 40 s 43 s 46 s 49 MC MC-Next ALU-FC X-Bus Y-Bus Z-Bus Speicher Md Ft 258

15 Segmente Je 4 ROM-Adressen werden zu einem Segment zusammengefasst. Absolute Sprünge sind nur an den Segmentanfang möglich. Segment 0: ROM MCAR Segment 1: Segment 2: MCDR 259

16 Einfache Sprünge Für MC <> 11 wird die Adressberechnung folgendermaßen durchgeführt: Segment 0: Segment 1: Segment 2: ROM :: MCAR MCAR := := 4 ** MC-Next :: MCAR MCAR := := MCAR MCAR *MC-Next :: MCAR MCAR := := MCAR MCAR *MC-Next MCAR An den Anfang eines Segmentes Für MC-Next = 0 zum nächsten Befehl. Vom letzten Befehl eines Segmentes immer zum Anfang eines nachfolgenden MCDR Für MC-Next = 0 zum nächsten Befehl. Vom letzten Befehl eines Segmentes immer zum Anfang eines vorhergehenden 260

17 Das Flag-Register Im Flagregister hat jedes einzelne Bit eine eigenständige Bedeutung. Viele Operationen oder Vergleichsoperationen zeigen das Vorliegen besonderer Eigenschaften durch das Setzen bestimmter Bits an. Flags Eine Eine Vergleichsoperation X < Y setzt setzt falls falls X --Y Bit Bit 0 :: =0 =0 Bit Bit 1 :: >0 >0 Bit Bit 2 :: <0 <0 Eine Eine arithmetische Operation Z := X Y setzt setzt falls falls Ergebnis Bit Bit 0 :: = 0 Bit Bit 1 :: > 0 Bit Bit 2 :: < 0 Bit Bit 3 :: Overflow 261

18 Bedingte Sprünge Bedingte Sprungbefehle beziehen sich immer nur auf den Inhalt der Flags. Mikrocode-Sprungbefehle besitzen eine Maske, d.h. ein Bitmuster. Diese Maske wird durch ein AND mit dem Flag-Register verknüpft. Ist das Resultat <> 0000, so wird der Sprung ausgeführt. Ein Ein Sprung mit mit der der Maske Maske wird wird genau genau dann dann ausgeführt, wenn wenn Bit Bit 1 oder oder Bit Bit 2 des des Flag-Registers eine eine 1 enthält, also also wenn wenn das das Ergebnis der der letzten letzten Operation <> <> 0 war, war, oder oder das das Ergebnis des des letzten letzten Vergleiches ungleich ergab. ergab Flags Z > < Of 262

19 Berechnete Sprünge Berechnete Sprünge sind sind solche, deren deren Sprungziel dynamisch berechnet werden kann. kann. Dafür Dafür ist ist der der Modus Modus MC MC = vorgesehen. Ein Ein Register MCOP MCOP kann kann dazu dazu über über den den Z-Bus Z-Bus geladen werden. Der Der Schalter s 44 öffnet 44 öffnet diesen diesen Datenweg. MCNext wird wird aufgespalten in in S-Mode und und Maske. Adressberechnungseinheit Mit Hilfe der Maske kann durch logisches AND festgestellt werden, welches Bit des Flagregisters gesetzt ist. MCOP s 44 IF S-Mode <> 00 and X-Register (Maske AND Flags) Y-Register = 0 THEN MCAR := MCAR+1 ELSE MCAR := 4*MCOP S-Mode Maske Flags ALU s 1 s s 16 s 24 s 32 s 39 MC MC-Next ALU-FC X-Bus Y-Bus Z-Bus Speicher Md Ft s 44 s 40 s 46 s

20 Ein Mikroprogramm Das Das folgende Mikroprogramm berechnet die die Summe aller aller Zahlen Zahlen von von 1 bis bis N, N, wobei wobei N anfangs als als 1 Byte Byte Größe Größe an an der der Adresse 00h 00h liegt. liegt. Das Das Ergebnis soll soll in in 01h 01h gespeichert werden. Initialisieren P 2: Z := 0 P 3: Z --Z-Bus -> R 0 -R 7, MAR MOV MOV R 0, 0,[00h] P 1: Mode = 01 (Read) P 3: MDR --Z-Bus -> R MCOP MCOP := := 1 P 2: Z := 1 P 3: Z --> MDR P 1: MDR --> MCOP MC MC-Next ALU-FC X-Bus Y-Bus Z-Bus Speicher Md Ft 264

21 Ein Mikroprogramm (Fortsetzung) Add Add R 2, 2, R 0 0 P 1: R 0 -- X-Bus--> X, R 2 --Y-Bus-> Y P 2: Z := R 0 +R 2 P 3: Z --Z-Bus-> R P 1: R 0 - X-Bus--> X DEC DEC R 0 0 P 2: Z := X-1, CC JNZ JNZ 4 P 3: Z --Z-Bus-> R P 2: Z := 1 MOV MOV [01h], [01h], R 2 2 P 3: Z --> MAR Goto Goto8 P1: R 2 --> X P 2: Z := X P 3: Z --> MDR, Mode = Write MC MC-Next ALU-FC X-Bus Y-Bus Z-Bus Speicher Md Ft 265

22 Maschinensprache Mikrocode-Programmierung ist für praktische Zwecke zu umständlich. Eine abstraktere Sicht der CPU zeigt nur noch Register, Speicher, Operationen, und Sprungbefehle, verbirgt aber Schalter, Takte und Phasen, Sprungmodi und Masken. Ein typischer Maschinenbefehl hat die Form : Op R 1, R 2 dabei ist Op eine Operation, R1 und R2 sind Register. Die Bedeutung ist : R 1 := R 1 Op R2 Beispiele : Add R1, R2 Mov R1, R2 And R1, R2 Bedingte Sprünge bestehen aus einer Vergleichsoperation mit anschließender Sprunganweisung, die auf dem Ergebnis des Vergleiches basiert Op R 1, R 2 CondJmp Ziel Jede Operation, die die Flags der ALU beeinflusst, kann als Vergleichsoperation dienen. Die Sprungbedingung ergibt sich aus den Flags. Beispiel : Sub R1, R2 JLE

23 Aufgaben der Register Die Operanden von Maschinenbefehlen sind Register oder Speicherplätze. Es dürfen aber nie beide Operanden Speicherplätze sein. Die Register werden für bestimmte Zwecke reserviert, etwa als Programmzähler, als Zeiger auf den Stack oder den Datenbereich. Einige Register behält man als Rechenregister. Diese heißen Allzweckregister oder Akkumulatoren. Die Maschinensprache-Befehle sind meist nur mit Allzweckregistern durchführbar. R 0 R 1 R 2 R 3 R 4 R 5 R 6 R 7 Prog. Counter PC Akkumulator A Akkumulator B Loop Index I Hilfsregister Aux I/O Port Data Pointer Stack Pointer Erlaubt : Mov A, B Add A, [021h] AND B,A Nicht erlaubt : Add PC, A Mov I, [0FFh] 267

24 Mikroprogrammierte Maschinenbefehle Jeden Maschinensprachebefehl können wir durch ein kurzes Mikroprogramm implementieren. ADD ADD A, A, B ADD ADD A, A, [[ B ]] Mov MovA, A, MC MC-Next ALU-FC X-Bus Y-Bus Z-Bus Speicher Md Ft 268

25 Sprünge JNZ JNZ 7 Falls das Ergebnis der vorigen Operation = 0, führe den nächsten Maschinenbefehl aus. MCOP sei entsprechend gesetzt. Sonst setze PC (R0) auf 7 (Sprung!) Flags Z > < Of 1000 AND Flags <> 0 <==> Z = 1 SM Maske MC MC-Next ALU-FC X-Bus Y-Bus Z-Bus Speicher Md Ft 269

26 Der Maschinensprache-Interpreter Jeder Maschinensprachebefehl erhält eine Nummer, den OpCode. Er wird als kurze Mikrocoderoutine im ROM abgelegt. Die Routine beginnt immer am Anfang eines Segmentes. Der OpCode ist identisch mit der Segmentnummer. ROM Seg. 0: Seg. 1: Seg. 2: 8 Befehl mit OpCode Seg. 3: 12 Befehl mit OpCode

27 Der Mikrocode im ROM Segment 0 enthält Initialisierungsbefehle. Segment 1 enthält einen Load-Increment-Execute-Zyklus. Dies ist ein Interpreter für Maschinensprache. Jeder Maschinensprachebefehl endet mit einem Sprung an den Anfang von Segment 1. Seg. 0: Seg. 1: ROM Initialisierungsroutine Load-Increment-Execute Zyklus Zyklus Seg. 2: 8 Befehl mit OpCode 2 9 Endet mit Sprung an Seg Seg. 3: 12 Befehl mit OpCode 3. Endet mit Sprung an Seg

28 Load-Increment-Execute-Zyklus Der Load-Increment-Execute-Zyklus besteht aus 2 Mikrobefehlen. ROM Lade den Programmzähler Jump Execute P 1: R 0 ->X P 2: Z:=X, P 3: Z->MAR, P 1: Lies 1Byte, MDR->MCOP P 2: Z:=X+1, MCAR := 4*MCOP P 3: Z->R 0, Z->MAR Jeder Opcode, der Argumente benötigt, kann davon ausgehen, daß MAR auf das erste benötigte Argument zeigt. * Die obigen Befehle dürfen keine Flags verändern. Entweder müssen also die Flags gerettet (PUSHF) und später wiederhergestellt werden (POPF) oder es sind die Varianten der Befehle Z:=X und Z:= X+1 zu benutzen, welche die Flags nicht beeinflussen. 272

29 Maschinencode im RAM Während das Programm im ROM fest vorgegeben und nicht veränderbar ist, kann im RAM ein Programm in Form von Maschinenbefehlen zusammen mit ihren Argumenten liegen. Der Load-Increment-Execute-Zyklus führt dieses Programm aus. RAM Add Arg 1 Arg 2 Inc Arg 1 Jmp Arg 1 Add Arg 1 Clc Add Arg 1 Arg 2... Jeder Opcode, der Argumente benötigt, kann davon ausgehen, dass MAR auf das erste benötigte Argument zeigt. Die Implementierung jedes Opcodes muss garantieren, dass hinterher PC auf dem Opcode des nächsten Befehls steht. 273

30 Entwicklung eines Maschinenspracheprogrammes Pascal-Program { Gauss'sche Summe: Berechne die die Summe aller Zahlen von von 1 bis bis N } VAR VAR N,sum : Integer; BEGIN sum sum := := 0 ; WHILE n > 0 DO DO Begin sum sum := := sum+n ; n := := n-1 n-1 End End END END 274

31 Entwicklung eines Maschinenspracheprogrammes Ersetze Programmstrukturen durch Sprünge (Linearisiere das Programm) VAR VAR n,sum : Integer; LABEL loop,ende; BEGIN sum sum := := 0 ; loop: IF IF n = 0 Goto ende ; sum sum := := sum+n ; n := := n-1 n-1 ; Goto loop ende: END END 275

32 Entwicklung eines Maschinenspracheprogrammes Wähle Register oder Speicherplätze für die Variablen, benutze Assemblerbefehle ; Registerbelegung: ; sum sum --> --> A ; n --> --> B ; MOV MOV A,0 A,0 loop:cmp B,0 B,0 JE JE ende ADD ADD A,B A,B DEC DEC B JMP JMP loop ende:stop 276

33 Entwicklung eines Maschinenspracheprogrammes Implementiere die benötigten Befehle im Simulator. Hier sind es: Befehl Länge OpCode * * ) JMP JMP <adr> 2 02h 02h JE JE <adr> 2 03h 03h DEC DEC B 1 16h 16h ADD ADD A,B A,B 1 17h 17h CMP CMP B,<num> 2 18h 18h MOV MOV A,<num> 2 26h 26h STOP 1 FFh FFh *) Der OpCode kann frei gewählt werden. Die obigen Zahlen sind aus der Beispieldatei Summe.rom. 277

34 Entwicklung eines Maschinenspracheprogrammes 5.a 5.a Übertrage das Programm in das RAM. Im ersten Durchlauf bleiben Sprungadressen noch offen. Position: Inhalt: A 0B... 26h 00h 18h 00h 03h? 17h 16h 02h? FFh.. MOV A CMP B JE ADD A,B DEC B JMP STOP 5.b 5.b Position: Inhalt: Trage die richtigen Sprungadressen nach. Dies nennt man "Backpatching" A 0B... 26h 00h 18h 00h 03h 0Ah 17h 16h 02h 02h FFh.. 278

35 Ausführung des Maschinenspracheprogrammes Lade Datei in in ROM Implementiere "Load-Increment-Execute" Zyklus Implementiere die die benötigten Maschinenbefehle Schreibe Maschinenprogramm in in das das RAM Drücke "Reset" Schreibe das das gewünschte N in in Register B (=R (=R 2 ) 2 ) Führe das das Programm aus, aus, entweder --phasenweise --imim Drei-Phasen-Takt --in in L-I-E Schritten --vollständig (Break-Point-Ablauf) *) *) *) *) Schritte 2.,3.,4. können gespart werden, wenn die fertige Datei "Summe" geladen wird. 279