Der Toy Rechner Ein einfacher Mikrorechner

Transkript

1 Der Toy Rechner Ein einfacher Mikrorechner Dr. Gerald Heim Haid-und-Neu-Str Karlsruhe 16. Mai 1995 Allgemeine Informationen 2 Quelle: Phil Kopmann, Microcoded versus Hard-Wired Logic, Byte Jan 87, S. 235 einfacher aber vollständiger Mikrorechner einfacher Aufbau mit Standardbausteinen RISC-Rechner - alle Befehle in einem (2 Phasen ) - sehr einfacher Befehlssatz (12 Befehle)

2 Spezifikation des Toy-Rechners 3 1-Adress-Maschine - Zielregister ist immer der Akkumulator (ACCU) Befehlsformat Komponenten (Speicher CPU) - RAM: 4096 * - ALU: 4 * ALU-Baustein - ACC: Register OP-Code - : Instruktionsregister - PC: Programmzähler - MUX: Multiplexer Speicher-Adresse OP-Code Adresse Bit = 4096 Adressen Blockschaltbild 4 Instructions Register 4 Bit OP-Code Adresse ACCU ALU SET[PC] PC Programmzähler Multiplexer RAM 4K Worte a

3 Befehlssatz 5 0. STO <Adresse> speichere den ACCU ins RAM an die Adresse 1. LDA <Adresse> lade ACCU mit dem Inhalt der Adresse 2. BRZ <Adresse> springe nach Adresse, wenn der ACCU Null ist 3. ADD <Adresse> addiere den Inhalt der Adresse zum ACCU 4. SUB <Adresse> subtrahiere den Inhalt der Adresse vom ACCU 5. OR <Adresse> logisches ODER des ACCUS mit dem Inhalt der Adresse 6. AND <Adresse> logisches UND des ACCUS mit dem Inhalt der Adresse 7. XOR <Adresse> logisches ExODER des ACCUS mit dem Inhalt der Adresse 8. NOT logisches NICHT der Bits im ACCU 9. INC inkrementiere den ACCU 10. DEC dekrementiere den ACCU 11. ZRO setze den ACCU auf NULL 12. NOP nicht benutzt 13. NOP nicht benutzt 14. NOP nicht benutzt 15. NOP nicht benutzt Spezifikation der Befehle OpCode Operation Zyklus Beschreibung 6 0 STO 1 ; ALU=ACC; WRITE(RAM) 2 ADDR=PC; SET(); INC(PC) 1 LDA 1 ; ALU=RAM; SET(ACC) 2 ADDR=PC; SET(); INC(PC) 2 BRZ 1 SET[PC] 2 ADDR=PC; SET(); INC(PC) 3 ADD 1 ; ALU=ACC+RAM; SET(ACC) 2 ADDR=PC; SET(); INC(PC)... 9 INC 1 ALU=ACC+1; SET(ACC) 2 ADDR=PC; SET(); INC(PC) NOP 1 ADDR=PC; SET(); INC(PC) 2

4 Ablaufsteuerung 7 Clock Signal Clock 1 Clock 2 Befehl aus Hauptspeicher holen Befehl ausführen 150 ns 150 ns nächster Befehl 300 ns Komponente 1: Der generator 8 Instructions Register 4 Bit OP-Code Adresse ACCU Quarz - SET[PC] Generator PC Programmzähler Multiplexer ALU RAM 4K Worte a

5 Komponente 2: Die ALU 9 Instructions Register 4 Bit OP-Code Adresse ACCU A(15..12) B(15..12) SET[PC] Y(15..12) A(11..8) B(11.8) PC Programmzähler A(7..4) B(7..4) Y(11..8) Multiplexer Y(7.4) ALU A(3..0) B(3..0) ALU(0..3) RAM Y(3..0) 4K Worte a Komponente 3: Der Befehlszähler 10 OPC(15..12) OPC(11..8) OPC(7..4) 74163Instructions Register Bit OP-Code Adresse SET(PC) & ACCU=0 INC(PC) ADR(11..8) ADR(7..4) ADR(3..0) ALU SET[PC] PC Programmzähler Multiplexer RAM 4K Worte a

6 Komponente 4: Das 11 Clock Signal Instructions Register OPC 0 4 Bit OP-Code Adresse OPC 1 OPC 2 OPC 3 SET[PC] ; STORE ; ; LOAD ; ; JMPZ ; ; ADD ; ; SUB ; ; OR ; ; AND ; ; XOR ; 8 16 PC ; NOT 17 Programmzähler ; Bit ; INC ; ; DEC ; ; ZERO ; ; NOP Multiplexer ; Bit ; NOP ; ; NOP ; ; NOP ; WRITE(RAM) ACCU INC(PC) SET(PC) ALU SET() SET(ACCU) RAM 4K Worte a Ablauf eines Maschinenbefehls (Ausgangssituation) 12 Ab der Speicherstelle $0007 steht die Befehlssequenz: $3020 ; ADD <$20> $0030; STO <$30> Der Accuinhalt ist $1234. Der Inhalt der Speicherstelle $20 ist $4321 Wie werden die Befehle abgearbeitet?

7 Ablauf eines Maschinenbefehls (Phase 1) ; ALU=ACC+RAM; SET(ACC) 13 $5555 $3020; ADD <$20> Instructions Register 4 Bit OP-Code Adresse $3 $20 $4321 ACCU $1234 ALU SET[PC] PC Programmzähler Multiplexer $20 $7 RAM 4K Worte a Ablauf eines Maschinenbefehls (Phase 2) ADDR=PC; SET(); INC(PC) $0030; STO <$30> 14 $xxxx Instructions Register 4 Bit OP-Code Adresse $0 $30 ACCU $5555 ALU SET[PC] PC Programmzähler Multiplexer $8 $8 RAM 4K Worte a

8 Unterschied zu realen Rechnern 15 Toy Rechner reale Prozessoren Wortlänge bis 100 Bit Mikroinstruktionen 1 Routine pro Maschinenbefehl mehrere Routinen pro Maschinenbefehl Umfang des Mikroprogramms 384 Bit Bit (S/370) Verzweigungsbefehle 1 Verzweigungsbefehl Verzweigungsbefehle Adressierungsmodi 1 Addressierungsmodus 1-21 Addressierungsmodi Befehlssatz 12 Befehle Befehle Registersatz 1 Register (Akku) Register Der Toy-Emulator 16 der Simulator seht unter /usr/local/ra/bin Aufruf durch toyemu <toyfile>

9 Bedienung des Emulators 17 ============================================================================== Accu : $ 0 Address : Contents PC : $ InsnReg : STO $20 $ 0 : $ 20 $200b $1021 $ $ 4 : $ 21 $1020 $a000 $ 20 $ 8 : $200b $b000 $2002 $b000 Steps : 0 $ c : $200c $ 0 $ 0 $ 0 $ 10 : $ 0 $ 0 $ 0 $ $ 14 : $ 0 $ 0 $ 0 $ 0 $ 18 : $ 0 $ 0 $ 0 $ 0 T O Y - EMULATOR $ 1c : $ 0 $ 0 $ 0 $ 0 (c) , gjh $ 20 : $ 0 $ 0 $ 0 $ 0 $ 24 : $ 0 $ 0 $ 0 $ 0 <Space> Single Step $ 28 : $ 0 $ 0 $ 0 $ 0 <S> Enter # of Steps $ 2c : $ 0 $ 0 $ 0 $ 0 <A> Set Accumulator $ 30 : $ 0 $ 0 $ 0 $ 0 <P> Set Program Counter $ 34 : $ 0 $ 0 $ 0 $ 0 <M> Set RAM Cell $ 38 : $ 0 $ 0 $ 0 $ 0 <+>, <-> Scroll RAM-Window $ 3c : $ 0 $ 0 $ 0 $ 0 $ 40 : $ 0 $ 0 $ 0 $ 0 <Q>, <^C> Game Over ============================================================================= Programmfiles für den Emulator 18 ; Variablen: ; Loopcount=$20, Number=$21 (enthaelt zunaechst 0) ; Labels: ; loop=$2, end=$b ; $0020 ; STO Loopcount ; Auswerten des initialen Accuinhalts $200b ; BRZ end ; Schon fertig? # #loop: $1021 ; LDA Number ; nat. Zahl mitzaehlen $9000 ; INC $0021 ; STO Number $1020 ; LDA Loopcount ; Schleifenzaehler aktualisieren $a000 ; DEC $0020 ; STO Loopcount $200b ; BRZ end ; Fertig? $b000 ; ZRO ; Nein, $2002 ; BRZ loop ; dann wieder von vorn # #end: $b000 ; ZRO $200c ; STP ; Endlosschleife

10 Hexadezimale Schreibweise 19 Dezimal Hex Befehl 0 0 STO 1 1 LDA 2 2 BRZ 3 3 ADD 4 4 SUB 5 5 OR 6 6 AND 7 7 XOR 8 8 NOT 9 9 INC 10 A DEC 11 B ZRO 12 C NOP 13 D NOP 14 E NOP 15 F NOP Beispiel: 1 LDA <$20> $1020 Assemblieren: 1. Assembler als Kommentar schreiben 2. Adressen der Labels für Sprünge feststellen 3. Adressen für Variablen festlegen 4. Hexcode aus OP-Codetabelle und aus Labels/Variablenadressen berechnen Aufgabe 1: Der Toy-Emulator 20 Installieren Sie den Toy-Emulator und starten Sie ihn mit dem Beispielprogramm count.toy Laden Sie den Accumulator mit $10 und arbeiten Sie das Programm im Einzelschritten ab. 1. Was berechnet das Programm? 2. Wie arbeitet das Programm? 3. Formulieren Sie das Programm in einer höheren Programmiersprache. 4. Wie ist die Endlosschleife programmiert?

11 Aufgabe 2: GGT-Algorithmus 21 Schreiben sie ein Programm, welches den GGT zweier Zahlen berechnet. Die beiden Eingabewerte stehen an den Speicherstellen $30 und $31, das Ergebnis soll an die Stelle $32 geschrieben werden. Der Algorithmus in PASCAL: repeat if m>n then begin tmp := m; m := n; n := tmp; end; n := n - m; until n = 0; write (m); 1. Schreiben Sie das Programm in Toy-Assembler 2. Assemblieren Sie das Programm in ein Programmfile 3. Starten Sie den Emulator mit Ihrem Programm und analysieren Sie das Verhalten Aufgabe 3: Geschwindigkeit des Toy-Emulators 22 Bestimmen Sie die Geschwindigkeit des Toy-Emulators in MIPS (Million Instructions Per Second). Schreiben Sie ein kleines Programm welches eine Speicherzelle 1000 mal beginnend bei decrementiert und bei 0 abbricht. Bestimmen Sie die Anzahl der zyklen Ihres Programms. Starten Sie den Emulator mehrmals und messen Sie die Zeit für einen Programmdurchlauf. 1. Wie hoch ist die MIPS-Rate des Emulators? 2. Welche Aussagekraft hat dieser Wert?

12 Aufgabe 4: Indirekte Adressierung 23 Starten Sie das den Emulator mit dem Programm fibonacci.toy Analysieren Sie das Programm und beobachten Sie wie die Ergebnisse in den Speicher geschrieben werden. 1. Auf welche Weise wird die indirekte Adressierung durchgeführt? 2. Welche Probleme birgt dieses Vorgehen bei realen Systemen?