Was wir beim Steuerwerk nicht vergessen dürfen: Funktionsdekodierer für die ALU
Also, Befehlsdekodierer, liefert Steuersignale an alle Einheiten.
Eines an die Funktionsdekodierer. Der Funktionsdekodierer ist aber selber mit den Befehlen verbunden. Er liefert Signale an die ALU
Also, Steuereinheit:
1. Befehlsdekodierer
2. Funktionsdekodierer
Jetzt: Genereller Irrtum!
Einzyklenmikroarchitektur:
(1.) Getaktetes Holen eines Befehls
(2.) Ausführen eines Befehls durch ein Schaltnetz
Jetzt lassen wir (1.) weg. Das ist klar.
Was unlogisch klingt: Wenn ich 5 Zyklen habe - brauche ich 5 Takte. Aber wenn ich einen Zyklus habe - brauche ich einen Takt. Also, muss zweiteres Schneller sein.
Egal. Die Frage, richtet sich nach der technischen Realisierung. Ich dachte: Dass man einen Befehl nur in mehreren Zyklen ausrechnen kann. Das heißt, man nimmt den Befehl, er kommt in den Registersatz.
Dann macht den Registersatz auf (1.) Takt. Dann macht man (2.) Takt die ALU auf (3.) den Datenspeicher (4.) Takt wieder den Registersatz.
Aber warum - also, wenn ich ein Schaltnetz baue,
Dann schließe ich sagen wir 4 ALU's hintereinander. Ich kann die kombinieren. Das heißt, der Datenpfad ist nicht eindeutig. Selbst, wenn nicht eindeutig. Ich kann die alle gleichzeitig öffnen.
Was den Registersatz betrifft, das kenne ich ja von meinen Schaltwerken - die Daten gehen raus - in ein Schaltnetz und das Schaltnetz hat die Daten dann schon und sie gehen wieder ins Register.
Das ist beim Registersatz auch so - die Daten gehen bei Lesedaten raus - durch die ALU und so weiter. Dann führen sie zu Schreibedaten. Das macht aber nichts - weil, das geht gleichzeitig.
Jetzt aber:
Jetzt haben wir so zu sagen auf dem Weg - erst Mal so viel gar nicht - das ist gar nicht mal viel. Das ist ein Registersatz und eine ALU könnte man fast sagen. Eigentlich war das schon das Elementare.
Aber, es gibt einen Registersatz, zwei MUX eine ALU, einen datenspeicher. Das ist fast schon alles.
Aber es wiederspricht nichts, beim Registersatz, die Lesedaten-1, die Lesendaten-2 zu öffnen, diese direkt in die ALU zu schicken, was auch sonst - ich muss keine ALU öffnen, das ist ja quatsch - die muss ich ja nicht öffnen, das ist ein Schaltnetz und hat Eingangssignale - wenn ich die Daten aus dem Registersatz nehme sind sie da und gehen zwangsweise in die ALU.
Jetzt kommt es zum Datenspeicher. Dafür brauche ich keinen Takt. Wenn das offen ist, ist es offen und die MUX machen auch, was sie wollen.
Richtig ist: Dass jede Funktionseinheit Steuersignale braucht. Das geht ja auch nicht anders. Wenn der MUX und die ALU kein Steuersignal hat, geht es nicht. Wie soll das gehen. Aber, diese Signale kann ich alle gleichzeitig erzeugen. Ich muss ja nicht erst das eine Signal und dann das andere erzeugen. Ich kann die auch gleichzeitig erzeugen..
Sicher ist: Der Befehl ist kurz. Der passt in 32 Bit. Oder so. Die ganzen Steuersignale, als ein Pfad und Bus sind groß. Man muss die ALU öffnen. Man muss den Registersatz öffnen und so weiter - deswegen wird das am Ende eine eigene Sache. Aber im Befehl steht kein Steuerbit für die ALU.
Steuereinheit:
1. Befehlsdekodierer
2. Funktionsdekodierer
Befehlsdekodierer:
1. MemtoReg
2. MemWrite
3. Branch
4. ALUSrc
5. RegDst
6. RegWrite
7. ALUOp
Funktionsdekodierer: ALU Operation: 3 Bit
Funktionsdekodierer:
1. Ausgang: ALU Operation: 3 Bit
2. Eingang: Func - vom Befehl - 6 Bit
3. Eingang: ALUOp, 2 Bit vom Befehlsdekodierer
Befehlsdekodierer
Funktionsdekodierer
Registersatz
ALU
Datenspeicher
Befehlsspeicher
Befehlszähler
Vorzeichenerweiterungseinheit
4 x MUX
1 x AND
2 x Addierer
1 x Bit Shifter
Befehlsdekodierer:
1. MemtoReg
2. MemWrite
3. Branch
4. ALUSrc
5. RegDst
6. RegWrite
7. ALUOp
Funktionsdekodierer:
1. Func
2. ALUOp
3. ALU Operation
Registersatz:
- Lese-Register 1
- Lese-Register 2
- Schreiberegister
- Schreibedaten
- WE
- Lese-Daten 1
- Lese-Daten 2
ALU:
- ALU-Ergebnis
- Null
AND:
- PCSrc
Datenspeicher:
- Addresse
- Schreibedaten
- WE
- Lesedaten
Befehlsspeicher:
- Leseaddresse
- Lesedaten
Befehlszähler:
- PC (t+1)
- PC (t)
Alle Datenwege:
1. MemtoReg (Befehlsdekodierer)
2. MemWrite (Befehlsdekodierer)
3. Branch (Befehlsdekodierer)
4. ALUSrc (Befehlsdekodierer)
5. RegDst (Befehlsdekodierer)
6. RegWrite (Befehlsdekodierer)
7. ALUOp (Befehlsdekodierer)
8. Func (Funktionsdekodierer)
9. ALUOp (Funktionsdekodierer)
10. ALU Operation (Funktionsdekodierer)
11. Lese-Register 1 (Registersatz)
12. Lese-Register 2 (Registersatz)
13. Schreiberegister (Registersatz)
14. Schreibedaten (Registersatz)
15. WE (Registersatz)
16. Lese-Daten 1 (Registersatz)
17. Lese-Daten 2 (Registersatz)
18. ALU-Ergebnis (ALU)
19. Null (ALU)
20. PCSrc (AND)
21. Addresse (Datenspeicher)
22. Schreibedaten (Datenspeicher)
23. WE (Datenspeicher)
24. Lesedaten (Datenspeicher)
25. Leseaddresse (Befehlsspeicher)
26. Lesedaten (Befehlsspeicher)
27. PC (t+1) (Befehlszähler)
28. PC (t) (Befehlszähler)
Abgeschrieben, das war aus dem Blockschaltbild - aber allgemeiner Prozessor (OpenSource - und kann jeder verwenden):
ALUOp Func ALU Operanden
00 X 010 - add
X1 X 110 - sub
1X 100000 - add 010 - add
1X 100010 - sub 110 - sub
1X 100100 - and 000 - and
1X 100101 - or 001 - or
1X 101010 - slt 111 - set les than
Op-Code Reg-Write Reg-Dst ALU-Src Branch Mem-Write Mem-toReg ALU-Op
R-Typ 000000 1 1 0 0 0 0 10
lw 100011 1 0 1 0 0 1 00
sw 101011 0 X 1 0 1 X 00
beq 000100 0 X 0 1 0 X 01
