Befehlszyklus -- Abrufen, Dekodieren, Ausführen, Zurückschreiben
Die CPU folgt für jeden Befehl demselben vierstufigen Prozess, wie ein endloser Pipeline-Takt. Diese Lektion führt Sie tief in die Funktion jeder dieser vier Stufen ein und verwendet Python, um den Befehlsausführungsprozess einer vollständigen CPU zu simulieren.
Analogie aus dem Alltag: Restaurantküche
Stellen Sie sich vor, Sie sind der Chefkoch in einem Restaurant. Nachdem ein Kunde eine Bestellung aufgegeben hat, bereiten Sie das Gericht in den folgenden Schritten zu:
- Abrufen: Nehmen Sie einen neuen Bestellschein von der Rezeption und sehen Sie nach, was der Kunde bestellt hat
- Dekodieren: Analysieren Sie die Speisekarte -- "Geschmorter Schweinebauch" benötigt Schweinebauch, Sojasauce und Kandiszucker; "Gebratenes Gemüse" benötigt Blattgemüse und gehackten Knoblauch
- Kochen (Ausführen): Beginnen Sie tatsächlich zu kochen -- Gemüse hacken, unter Rühren braten und würzen
- Servieren (Zurückschreiben): Richten Sie das fertige Gericht an und übergeben Sie es dem Kellner zum Servieren
Jeder Bestellzettel durchläuft diese vier Schritte. Nachdem ein Gericht fertig ist, hol den nächsten Zettel. Die CPU arbeitet genauso – eine Anweisung holen, eine Anweisung dekodieren, eine Anweisung ausführen und das Ergebnis zurückschreiben, in einem endlosen Zyklus.
Dieser vierstufige Zyklus ist der grundlegende Arbeitsrhythmus der CPU. Vom Einschalten des Computers bis zum Herunterfahren wiederholt die CPU kontinuierlich den Zyklus „Holen-Dekodieren-Ausführen-Zurückschreiben“ milliardenfach pro Sekunde.
Detaillierte Erläuterung der vier Phasen
Phase 1: Holen
Die CPU „holt“ zunächst die nächste auszuführende Anweisung aus dem Speicher.
Es gibt ein spezielles Register namensProgrammzähler (PC, Program Counter), das stets die Speicheradresse der nächsten Anweisung enthält.
Was die Fetch-Phase macht:
- Die CPU legt die Adresse aus dem PC auf den Adressbus.
- Die CPU sendet ein „Lese“-Signal auf den Steuerbus.
- Der Speicher liefert die Anweisungsdaten an dieser Adresse zurück.
- Die Anweisung wird in das Befehlsregister (IR) geladen.
- Der PC wird automatisch um 1 erhöht und zeigt auf die nächste Anweisung.
Hier gibt es ein wichtiges Design:PC inkrementiert automatisch. Das bedeutet, die CPU führt Befehle standardmäßig der Reihe nach aus, es sei denn, sie trifft auf einen Sprungbefehl (wie if-else oder Schleifen), der den PC-Wert ändert.
Stufe 2: Dekodieren
Der abgerufene Befehl ist eine Folge von Binärziffern (zum Beispiel0001 0010 0011), muss die CPU sie "übersetzen".
Die Kernarbeit der Dekodierstufe:
- Opcode identifizieren (Opcode): Die ersten paar Bits des Befehls sagen der CPU, was zu tun ist -- handelt es sich um Addition, Subtraktion, Laden von Daten oder einen Sprung?
- Operanden extrahieren: Die restlichen Bits geben den Operanden an -- welches Register soll verwendet werden? Welche Adresse im Speicher?
- Steuersignal setzen: Basierend auf dem Dekodierungsergebnis gibt die Steuerung entsprechende Steuersignale an Komponenten wie die ALU, die Registerbank und den Bus aus.
Zum Beispiel einen BefehlADD R1, R2, R3, weiß die CPU nach der Dekodierung: Die ALU soll eine Additionsoperation ausführen, mit Eingaben aus den Registern R2 und R3, und das Ergebnis in R1 speichern.
Stufe 3: Ausführen
Dies ist die Stufe, in der der Befehl tatsächlich "die Arbeit erledigt". Je nach Befehlstyp führt die Ausführungsstufe unterschiedliche Dinge aus:
| Befehlstyp | Was macht die Ausführungsphase? | Beteiligte Hardware |
|---|---|---|
| Arithmetische Operationen (ADD, SUB, usw.) | Die ALU führt arithmetische Operationen an den Operanden aus | ALU, Registerbank |
| Logische Operationen (AND, OR, usw.) | Die ALU führt bitweise Operationen an den Operanden aus | ALU, Registerbank |
| Speicherlesen (LOAD) | Über den Adressbus auf den Speicher zugreifen, um Daten zu lesen | Adressbus, Datenbus, Speicher |
| Speicherschreiben (STORE) | Über den Adressbus auf den Speicher zugreifen, um Daten zu schreiben | Adressbus, Datenbus, Speicher |
| Sprung (JUMP, BRANCH) | Den PC-Wert ändern, um den Ausführungsfluss zu verändern | Steuerwerk, PC-Register |
Stufe 4: Rückschreiben
Das in der Ausführungsstufe erzeugte Ergebnis muss an den Zielort "geschrieben" werden.
Die Rückschreibziele können sein:
- Register: Das Operationsergebnis in einem Allzweckregister speichern (am häufigsten)
- Speicher: Das Ergebnis an eine Adresse im Speicher speichern
- Flag-Register: Statusflags aktualisieren (z. B. ob das Ergebnis null ist, ob ein Überlauf auftritt, ob es negativ ist usw.)
Sobald das Rückschreiben abgeschlossen ist, endet der Ausführungszyklus eines Befehls offiziell. Wenn der PC noch auf eine gültige Befehlsadresse zeigt, kehrt die CPU automatisch zur Fetch-Stufe zurück und beginnt mit dem nächsten Befehl.
Zeitleistenansicht des Befehlszyklus
Die folgende Zeitachse zeigt den vollständigen Ablauf von drei nacheinander ausgeführten Befehlen:
时钟周期: 1 2 3 4 5 6 7 8 9 10 11 12
指令1: [取指] [译码] [执行] [写回]
指令2: [取指] [译码] [执行] [写回]
指令3: [取指] [译码] [执行] [写回]
↑ 指令1 完成后才开始指令2,完全串行执行
Beachten Sie, dass jeder Befehl hier 4 Zyklen dauert und die drei Befehle zusammen 12 Zyklen benötigen. Wenn wir später Pipelining behandeln, werden Sie sehen, wie diese Zeit drastisch reduziert werden kann.
Interaktive Demo: SimpleCPU-Simulator
Das folgende Python-Programm simuliert den vollständigen Befehlszyklus einer minimalistischen CPU. Es unterstützt die Befehle LOAD (Wert laden), ADD (Addition), MUL (Multiplikation), CMP (Vergleich + bedingter Sprung) und STORE (Ausgabe drucken) und gibt detaillierte Logs für jede Phase aus.
Beispiel
SimpleCPU-Simulator — Demo für den vollständigen Befehlszyklus
Unterstützte Befehle: LOAD, ADD, MUL, CMP+JGT, STORE, HALT
Jeder Befehl durchläuft: Fetch (IF) → Decode (ID) → Execute (EX) → Write-back (WB)
"""
class SimpleCPU:
"""Ein didaktischer CPU-Simulator, der die vier Phasen des Befehlszyklus demonstriert"""
def __init__(self):
# Allzweckregister: R0~R3, Anfangswerte sind alle 0
self.registers = {'R0': 0, 'R1': 0, 'R2': 0, 'R3': 0}
# Flag-Register: Speichert Vergleichsergebnisse
self.flags = {'ZERO': False, 'GREATER': False}
# Programmzähler: verweist auf die Speicherstelle der nächsten Anweisung
self.pc = 0
# Befehlsregister: speichert die aktuell ausgeführte Anweisung
self.ir = None
# Speicher: speichert die Anweisungsfolge des Programms
self.memory = []
# Zählt die Anzahl der Ausführungen in jeder Phase
self.stats = {'fetch': 0, 'decode': 0, 'execute': 0, 'writeback': 0}
self.total_cycles = 0
# Steuerungsflags
self.running = False
def load_program(self, instructions):
"""Lädt die Anweisungsliste in den Speicher"""
self.memory = instructions
self.pc = 0
self.running = True
print(f"[System] Programm geladen, insgesamt {len(instructions)} Anweisungen")
print(f"[System] Initiale Register: {self.registers}")
print("=" * 60)
def fetch(self):
"""Stufe 1: Befehlsabruf"""
self.total_cycles += 1
if self.pc >= len(self.memory):
self.running = False
return None
# Lese den Befehl, auf den PC zeigt, aus dem Speicher
instruction = self.memory[self.pc]
self.ir = instruction
old_pc = self.pc
self.pc += 1 # PC automatisch erhöhen
self.stats['fetch'] += 1
print(f"[Zyklus {self.total_cycles}] Befehlsabruf (IF)")
print(fPC={old_pc} → Befehl von Speicheradresse {old_pc} lesen)
print(f" Befehlsinhalt:\"{instruction}\"")
print(fPC-Aktualisierung: {old_pc} → {self.pc})
print(f" IR ← \"{instruction}\"")
return instruction
def decode(self, instruction):
"""Stufe 2: Dekodieren (Befehlsdekodierung)"""
self.total_cycles += 1
self.stats['decode'] += 1
# Opcode und Operand parsen
parts = instruction.split()
opcode = parts[0].upper() # opcode
operands = parts[1:] if len(parts) > 1 else [] # Operand
print(f"[Cycle {self.total_cycles}] Dekodieren (ID)")
print(fOpcode: {opcode})
print(f" Operanden: {operands}")
# Erkläre die Bedeutung des Opcodes
opcode_meaning = {
'LOAD': 'Lade unmittelbaren Wert in ein Register',
'ADD': 'Registeraddition',
'MUL': 'Registermultiplikation',
'CMP': 'Vergleiche die Werte zweier Register',
'JGT': 'Bedingter Sprung (Sprung, wenn größer)',
'STORE':'Registerwert ausgeben',
'HALT': 'Ausführung anhalten',
}
if opcode in opcode_meaning:
print(fBedeutung: {opcode_meaning[opcode]})
return opcode, operands
def execute(self, opcode, operands):
"""Phase 3: Ausführen"""
self.total_cycles += 1
self.stats['execute'] += 1
print(f[Zyklus {self.total_cycles}] Ausführen (EX))
if opcode == 'HALT':
print(f" HALT: Programmausführung beenden")
self.running = False
elif opcode == 'LOAD':
# LOAD Rx, value → den Immediate-Wert in Register Rx speichern
reg = operands[0]
value = int(operands[1])
print(f" Operation: Lade den unmittelbaren Wert {value} in Register {reg}")
print(fBeteiligte Komponenten: Datenbus (überträgt den unmittelbaren Wert {value}))
# Ergebnis vorübergehend speichern; Register in der Write-Back-Phase aktualisieren
return ('LOAD', reg, value)
elif opcode == 'ADD':
# ADD Rx, Ry → Rx = Rx + Ry
rx, ry = operands[0], operands[1]
a = self.registers[rx]
b = self.registers[ry]
result = a + b
print(fOperation: ALU führt {rx}({a}) + {ry}({b}) = {result} aus)
print(f" Beteiligte Komponenten: ALU (Recheneinheit), Registerbank")
return ('WRITE_REG', rx, result)
elif opcode == 'MUL':
# MUL Rx, Ry → Rx = Rx * Ry
rx, ry = operands[0], operands[1]
a = self.registers[rx]
b = self.registers[ry]
result = a * b
print(fOperation: ALU führt {rx}({a}) * {ry}({b}) = {result} aus)
print(f" Beteiligte Komponenten: ALU (Recheneinheit), Registerbank")
return ('WRITE_REG', rx, result)
elif opcode == 'CMP':
# CMP Rx, Ry → Zwei Register vergleichen, Flags setzen.
rx, ry = operands[0], operands[1]
a = self.registers[rx]
b = self.registers[ry]
self.flags['ZERO'] = (a == b)
self.flags['GREATER'] = (a > b)
print(fOperation: vergleiche {rx}({a}) und {ry}({b}))
print(f" Ergebnis: ZERO={self.flags['ZERO']}, GREATER={self.flags['GREATER']}")
print(f" Beteiligte Komponenten: ALU (Komparator), Flag-Register")
return ('FLAGS', None, None)
elif opcode == 'JGT':
# JGT address → Wenn das GREATER-Flag wahr ist, zur Adresse springen
target = int(operands[0])
if self.flags['GREATER']:
old_pc = self.pc
self.pc = target
print(fBedingung erfüllt (GREATER=True): PC-Sprung {old_pc} → {target})
print(f" Beteiligte Komponenten: Controller, PC-Register")
else:
print(fBedingung nicht erfüllt (GREATER=False): kein Sprung, PC bleibt {self.pc})
return None
elif opcode == 'STORE':
# STORE Rx → Wert des Registers ausgeben
reg = operands[0]
value = self.registers[reg]
print(fOperation: Wert des Registers {reg} ausgeben)
return ('OUTPUT', reg, value)
return None
def writeback(self, action):
Stufe 4: Rückschreiben
self.total_cycles += 1
self.stats['writeback'] += 1
if action is None:
print(f[Zyklus {self.total_cycles}] Write-Back (WB) - Keine Operation)
return
action_type = action[0]
print(f[Zyklus {self.total_cycles}] Write-back (WB))
if action_type == 'LOAD':
reg, value = action[1], action[2]
old_val = self.registers[reg]
self.registers[reg] = value
print(f" Ziel: Register {reg}")
print(f" Daten: {old_val} → {value}")
print(f" Kanal: Datenbus → Registerbank")
elif action_type == 'WRITE_REG':
reg, result = action[1], action[2]
old_val = self.registers[reg]
self.registers[reg] = result
print(f" Ziel: Register {reg}")
print(fDaten: {old_val} → {result})
print(f" Kanal: ALU-Ausgang → Registerbank (interner Bus)")
elif action_type == 'OUTPUT':
reg, value = action[1], action[2]
print(f" Ausgabe: Register {reg} = {value}")
print(fKanal: Registerbank → Datenbus → E/A-Schnittstelle)
print(fAktueller Registerzustand: {self.registers})
print(fFlags: {self.flags})
print("-" * 60)
def run(self):
"""Führe das gesamte Programm aus, indem die Anweisungen nacheinander ausgeführt werden"""
print("=" * 60)
print(SimpleCPU-Simulatorstart — Befehlszyklus-Demo (Beispiel))
print("=" * 60)
while self.running:
# Vierstufiger Zyklus
instruction = self.fetch() # Stufe 1: Holen
if instruction is None:
break
opcode, operands = self.decode(instruction) # Stufe 2: Decodieren
action = self.execute(opcode, operands) # Stufe 3: Ausführen
self.writeback(action) # Stufe 4: Zurückschreiben
# Ausführung abgeschlossen, Statistiken ausgeben
print("\n" + "=" * 60)
print("Programmausführung abgeschlossen! Statistiken:")
print(fGesamte Taktzyklen: {self.total_cycles})
print(fFetch-Stufe ausgeführt: {self.stats['fetch']} mal)
print(fDecode-Stufen-Ausführung: {self.stats['decode']} mal)
print(fExecute-Phase ausgeführt: {self.stats['execute']} mal)
print(fWrite-back-Stufe ausgeführt: {self.stats['writeback']} mal)
print(f" Endgültige Register: {self.registers}")
print(f" Endgültige Flags: {self.flags}")
print(f" Endgültiger PC: {self.pc}")
print("=" * 60)
# ===== Demo-Programm ausführen =====
# Programmlogik: Berechne das Ergebnis von 1+2, multipliziere dann mit 3 und vergleiche mit 10.
# LOAD R0, 1 → R0 = 1
# LOAD R1, 2 → R1 = 2
# ADD R0, R1 → R0 = R0 + R1 = 1 + 2 = 3
# LOAD R2, 3 → R2 = 3
# MUL R0, R2 → R0 = R0 * R2 = 3 * 3 = 9
# CMP R0, R2 → Vergleiche R0(9) und R2(3), setze GREATER=True
# STORE R0 → gib den Wert von R0 aus
# HALT → anhalten
cpu = SimpleCPU()
Programm = [
"LOAD R0 1", # R0 = 1
"LOAD R1 2", # R1 = 2
"ADD R0 R1", # R0 = R0 + R1 = 3
"LOAD R2 3", # R2 = 3
"MUL R0 R2", # R0 = R0 * R2 = 9
"CMP R0 R2", # Vergleiche 9 und 3, GREATER=True
"JGT 8", # Wenn GREATER, springe zu Anweisung 8
"LOAD R3 0", # (Dies wird nicht ausgeführt, weil JGT es übersprungen hat)
"STORE R0", # Ausgabe R0 = 9
"HALT", # Stopp
]
cpu.load_program(program)
cpu.run()
Der obige Code gibt detaillierte Protokolle für jede Stufe jeder Anweisung aus, sodass du klar sehen kannst, was die CPU intern in jedem Taktzyklus tut. Beachte Folgendes:
- PC inkrementiert automatisch: Bei jeder Ausführung einer Anweisung inkrementiert der PC automatisch um 1 (Fetch-Phase)
- Bedingter Sprung: Die CMP+JGT-Kombination implementiert eine if-Anweisung -- wenn R0 > R2, springt sie zu Anweisung 8 und überspringt Anweisung 7
- Register als Transferstationen: Alle Daten müssen zuerst in Register geladen werden; die ALU liest aus Registern, berechnet und schreibt das Ergebnis zurück in ein Register
Interaktive Demo: Interne CPU-Struktur & Schritt-für-Schritt-Wiedergabe des Anweisungszyklus
Unten ist ein vereinfachtes Diagramm der internen CPU-Struktur, gezeichnet mit vis-network. Klicken Sie auf die Schaltfläche "Next", um zu beobachten, welche Hardwarekomponenten in jeder der vier Instruktionsphasen verwendet werden; aktivierte Komponenten werden in der entsprechenden Phasenfarbe hervorgehoben.