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:

  1. Abrufen: Nehmen Sie einen neuen Bestellschein von der Rezeption und sehen Sie nach, was der Kunde bestellt hat
  2. Dekodieren: Analysieren Sie die Speisekarte -- "Geschmorter Schweinebauch" benötigt Schweinebauch, Sojasauce und Kandiszucker; "Gebratenes Gemüse" benötigt Blattgemüse und gehackten Knoblauch
  3. Kochen (Ausführen): Beginnen Sie tatsächlich zu kochen -- Gemüse hacken, unter Rühren braten und würzen
  4. 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:

  1. Die CPU legt die Adresse aus dem PC auf den Adressbus.
  2. Die CPU sendet ein „Lese“-Signal auf den Steuerbus.
  3. Der Speicher liefert die Anweisungsdaten an dieser Adresse zurück.
  4. Die Anweisung wird in das Befehlsregister (IR) geladen.
  5. 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:

BefehlstypWas macht die Ausführungsphase?Beteiligte Hardware
Arithmetische Operationen (ADD, SUB, usw.)Die ALU führt arithmetische Operationen an den Operanden ausALU, Registerbank
Logische Operationen (AND, OR, usw.)Die ALU führt bitweise Operationen an den Operanden ausALU, Registerbank
Speicherlesen (LOAD)Über den Adressbus auf den Speicher zugreifen, um Daten zu lesenAdressbus, Datenbus, Speicher
Speicherschreiben (STORE)Über den Adressbus auf den Speicher zugreifen, um Daten zu schreibenAdressbus, Datenbus, Speicher
Sprung (JUMP, BRANCH)Den PC-Wert ändern, um den Ausführungsfluss zu verändernSteuerwerk, 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.

CPU-Interna & Instruktionszyklus Schritt-für-Schritt-Demo (Beispiel)

Instruktionsabruf IF
Dekodieren ID
Ausführen EX
Zurückschreiben WB
Klicken Sie auf 'Next', um die Demo des Instruktionszyklus zu starten und zu beobachten, welche Komponenten innerhalb der CPU in jeder Phase aktiviert werden.
Weitere Erweiterungen