Der vollständige Weg einer Instruktion

Von den Binärgrundlagen in Vorlesung 1 bis zum I/O-System in der vorherigen Vorlesung haben wir alle Kerninhalte der Prinzipien der Rechnerorganisation behandelt. Diese Vorlesung wird diese Wissenspunkte zu einer einzigen Linie verbinden und die komplette Reise eines Befehls von der Geburt bis zur Vollendung nachzeichnen.

Wir werden einen vollständigenvon Neumann Computer-Simulator (FullComputer)implementieren, der Folgendes umfasst: vierstufige Speicherstruktur (Festplatte, Arbeitsspeicher, Cache, Register), DMA-Datenübertragung, vierstufige Pipeline von Fetch-Decode-Execute-Writeback, Bus-Interaktion, Cache-Trefferratenstatistik. Abschließend wird ein vollständiger Ausführungsbericht ausgegeben.


Rückblick: Wissenslandkarte der sechs Module

Bevor wir mit der End-to-End-Simulation beginnen, lassen Sie uns schnell die Kernkonzepte jedes der sechs Module in diesem Kurs wiederholen:

ModulThemaKernkonzepteUmsetzung in dieser Vorlesung
Modul 1Binär- und Informationsdarstellung0/1-Kodierung, Basisumrechnung, Zweierkomplement, GleitkommazahlenSowohl Befehle als auch Daten werden in binärer Form im Speicher gespeichert.
Modul 2Logikgatter und digitale SchaltungenAND/OR/NOT-Gatter, Addierer, ALUDie ALU-Operationen in der Ausführungsphase werden durch Gatterschaltungen implementiert.
Modul 3Von-Neumann-ArchitekturFünf Hauptkomponenten, gespeichertes Programm, BefehlszyklusWas diese Vorlesung simuliert, ist eine vollständige Von-Neumann-Maschine.
Modul 4CPU-GrundlagenRegister, PC, IR, Pipeline, vier StufenAlle vier Stufen von Fetch-Decode-Execute-Writeback werden simuliert.
Modul 5SpeichersystemSpeicherhierarchie, Cache, LokalitätsprinzipFestplatte → Speicher → Cache → Register, die vollständige Kette des vierstufigen Speichers.
Modul 6Bus und I/OAdress-, Daten- und Steuerbusse, Polling/Interrupt/DMADMA lädt das Programm, der Bus überträgt Daten, Cacheline-Füllung.

Der vollständige Lebenszyklus eines Befehls

Wir verwenden einen einfachen Pseudo-BefehlADD A, B(addiere die Werte von Register A und B, speichere das Ergebnis zurück in A) als Beispiel, um seine vollständige Reise nachzuvollziehen:

Schritt 1 der Reise: Das Programm wird auf der Festplatte gespeichert

Das Programm wird zunächst als Datei auf der Festplatte gespeichert. Die Festplatte istpersistenter Speicher, Daten gehen nach dem Ausschalten nicht verloren, aber die Lese-/Schreibgeschwindigkeit ist am langsamsten (Millisekundenbereich).

Schritt 2 der Reise: DMA lädt das Programm in den Speicher.

Wenn Sie doppelklicken, um das Programm auszuführen, verschiebt das Betriebssystem das Programm überDMAvon der Festplatte in den Speicher. Der DMA-Controller übernimmt die Datenbewegungsarbeit, und die CPU kann währenddessen andere Dinge erledigen.

Schritt 3 der Reise: Die CPU holt einen Befehl über den Bus.

Die CPU legt den Wert des Programmzählers (PC) auf denAdressbus, auf denSteuerbusund gibt ein "read"-Signal aus. Nach dem Empfang des Signals legt der Speicher den Befehl an der entsprechenden Adresse auf denDatenbus, und die CPU liest ihn in das Befehlsregister (IR).

Schritt 4 der Reise: Decodieren — der Controller analysiert den Befehl.

Das ADD A, B im Befehlsregister wird in drei Teile zerlegt: Opcode ADD, Zieloperand A, Quelloperand B. Der Controller entscheidet anhand des Opcodes über die nächste Operation.

Schritt 5 der Reise: Ausführen — die ALU führt die Operation aus.

Der Controller sendet Steuersignale, wodurch die ALU Werte aus den Registern A und B entnimmt, die Additionsoperation ausführt und das Ergebnis vorübergehend am ALU-Ausgang speichert.

Reise-Schritt 6: Zurückschreiben — das Ergebnis wird über den Datenbus in die Register geschrieben.

Die ALU-Berechnungsergebnisse werden überDatenbusin Register A zurückgeschrieben. Zu diesem Zeitpunkt ist ein Befehl vollständig ausgeführt. Der PC wird automatisch um 1 erhöht, um auf den nächsten Befehl zu zeigen.


Code-Demonstration: Vollständige FullComputer-Simulation.

Die untenstehende FullComputer-Klasse simuliert den gesamten oben beschriebenen Prozess vollständig. Sie enthält über 300 Codezeilen und deckt die Wissenspunkte aller sechs Module dieses Kurses ab. Jeder Schritt gibt detaillierte Logs aus.

Beispiel

"""
FullComputer – Vollständiger von-Neumann-Computer-Simulator (Beispiel-Lehrdemo)

Dieses Programm implementiert einen vollständigen (vereinfachten) von-Neumann-Computer, einschließlich:
- Vierstufiger Speicher: Festplatte → Arbeitsspeicher → Cache → Register
- DMA-Controller: verschiebt Programme automatisch von der Festplatte in den Arbeitsspeicher
- Drei Arten von Bussen: Adressbus, Datenbus, Steuerbus.
- fourPhaseExecute: Befehlsabruf (Fetch) → translatecode (Decode) → Ausführen (Execute) → Rückschreiben (WriteBack)
- Statistiksystem: Cache-Trefferrate, Befehlsanzahl, Busnutzungsanzahl, Ausführungszeit

Unterstützter Befehlssatz:
LOAD reg value - Unmittelbaren Wert in das Register laden
STORE reg addr - Den Registerwert in die Speicheradresse speichern
  ADD dst src - dst = dst + src
  SUB dst src - dst = dst - src
  MUL dst src - dst = dst * src
CMP a b - Zwei Register vergleichen, Flags setzen
JMP addr - Unbedingter Sprung
JZ addr - Sprung, wenn das Zero-Flag wahr ist

Ausführung: python fullcomputer.py
"""


import time


# ============================
# 1. Speichersystem - Vierschichtige Struktur
# ============================

class Disk:
    """
Festplatte - der persistente Speicher auf der untersten Ebene.
Langsamste Geschwindigkeit (Millisekundenbereich), größte Kapazität, Daten gehen bei Stromausfall nicht verloren.
    """

    def __init__(self):
        self.sectors = {}          # Sektorspeicherung, Simulation von Festplattensektoren
        self.read_latency = 5      # Leselatenz (simulierte Zeiteinheit)
        self.write_latency = 8     # Schreiblatenz

    def load_program(self, program_name):
        Lädt das auf der Festplatte gespeicherte Programm. Gibt None zurück, wenn das Programm nicht existiert.
        if program_name in self.sectors:
            print(f" [Festplatte] Kurssequenz '{program_name}' gefunden, Größe: {len(self.sectors[program_name])} Anweisungen")
            return self.sectors[program_name]
        print(f[Festplatte] Programm '{program_name}' nicht gefunden!)
        return None

    def store_program(self, name, program):
        """Speichere das Programm auf der Festplatte"""
        self.sectors[name] = program
        print(f" [Festplatte] Speicherkurssequenz '{name}' ({len(program)} Anweisungen) zu Sektor 0x{hash(name) & 0xFFFF:04X}")


class Memory:
    """
Hauptspeicher - Sekundärspeicher.
Mittlere Geschwindigkeit (Nanosekundenbereich), große Kapazität, Daten gehen bei Stromausfall verloren.
CPU kann nur direkt auf Daten im Speicher zugreifen (kann nicht direkt auf die Festplatte zugreifen).
    """

    def __init__(self, size=65536):
        self.size = size           # Speichergröße (Bytes)
        self.cells = {}            # Speichereinheit: Schlüssel ist Adresse, Wert sind Daten/Anweisung
        self.read_count = 0        # Anzahl Leseoperationen
        self.write_count = 0       # Anzahl der Schreiboperationen

    def read(self, addr):
        Daten von der angegebenen Adresse lesen
        self.read_count += 1
        if addr not in self.cells:
            print(f" Warnung: Adresse {addr} ist nicht initialisiert, es wird 0 zurückgegeben")
            return 0
        return self.cells[addr]

    def write(self, addr, data):
        Daten an die angegebene Adresse schreiben
        self.write_count += 1
        self.cells[addr] = data

    def load(self, start_addr, data_block):
        """
Lädt einen gesamten Datenblock in einen zusammenhängenden Adressbereich des Speichers.
Für Szenarien mit DMA-Batch-Übertragungen.
        """

        for i, item in enumerate(data_block):
            self.cells[start_addr + i] = item
        return len(data_block)


class Cache:
    """
Cache (L1-Cache-Simulation) - Speicher der dritten Ebene.
Extrem schnell (gleiche Frequenz wie die CPU), kleinste Kapazität.

Verwendung eines einfachen Direct-Mapped-Cache-Modells:
- Jede Cache-Zeile speichert: (Speicheradresse, Dateninhalt)
- Cache-Treffer: Daten bereits im Cache, direkt zurückgeben
Cache-Miss: Muss aus dem Speicher geladen werden, eine Cache-Zeile ersetzen.
    """

    def __init__(self, num_lines=8):
        self.num_lines = num_lines
        self.lines = {}            # Cache-Zeile: {cache_line_index: (mem_addr, data)}
        self.hit_count = 0
        self.miss_count = 0

    def read(self, mem_addr, memory):
        """
Aus dem Cache lesen. Bei Treffer direkt zurückgeben; bei Miss aus dem Speicher laden.
Rückgabe: (data, was_hit)
        """

        # Einfache Zuordnung: Cache-Line-Index = Speicheradresse % Anzahl der Cache-Lines
        line_index = mem_addr % self.num_lines

        if line_index in self.lines:
            cached_addr, cached_data = self.lines[line_index]
            if cached_addr == mem_addr:
                # Cache-Treffer
                self.hit_count += 1
                print(f" [Caching] Treffer! Zeile {line_index}, Adresse {mem_addr}, Daten: {cached_data}")
                return cached_data, True

        # Cache-Fehlschlag
        self.miss_count += 1
        data = memory.read(mem_addr)
        self.lines[line_index] = (mem_addr, data)
        print(f" [Caching] Fehlschlag, fromMemory Adresse {mem_addr} addloadData {data} → Cachingline {line_index}")
        return data, False

    @property
    def hit_rate(self):
        total = self.hit_count + self.miss_count
        return self.hit_count / total * 100 if total > 0 else 0.0


class RegisterFile:
    """
Registerfile - der oberste Speicher.
Schnellster (ein Taktzyklus), kleinste Kapazität.
Allzweckregister + Spezialregister (PC, IR, MAR, MDR, FLAGS)
    """

    def __init__(self):
        # Allzweckregister
        self.gpr = {'A': 0, 'B': 0, 'C': 0, 'D': 0}

        # Spezialregister
        self.PC = 0                # Programmzähler: speichert die Adresse des nächsten Befehls
        self.IR = None             # Befehlsregister: speichert den aktuell ausgeführten Befehl
        self.MAR = 0               # Speicheradressregister: speichert die Speicheradresse, auf die zugegriffen werden soll
        self.MDR = 0               # Speicherdatenregister: speichert Daten, die aus dem Speicher gelesen oder in den Speicher geschrieben werden sollen

        # Flags-Register
        self.FLAGS = {'Z': False}  # Null-Flag: ob das Ergebnis der vorherigen Operation 0 ist

    def __repr__(self):
        gpr_str = ', '.join(f'{k}={v}' for k, v in self.gpr.items())
        return f"GPR[{gpr_str}] PC={self.PC} IR={self.IR} FLAGS={self.FLAGS}"


# ============================
# 2. Bus-System - Drei Busse
# ============================

class SystemBus:
    """
Systembus - umfasst Adressbus, Datenbus, Steuerbus.
Bietet eine einheitliche Schnittstelle für CPU, Speicher und DMA.
    """

    def __init__(self):
        self.address_bus = 0       # Adressbus: aktuell übertragene Adresse
        self.data_bus = 0          # Datenbus: aktuell übertragene Daten
        self.control_bus = 'IDLE'  # Steuerbus: IDLE, READ, WRITE, INTERRUPT, DMA_REQ, DMA_ACK
        self.transfer_count = 0    # Anzahl der Busübertragungen

    def cpu_read(self, address, memory, cache):
        """
Die CPU liest Daten vom Speicher über den Bus (durch den Cache).
Vollständiger Bus-Interaktionsprozess:
1. Die CPU legt die Adresse auf den Adressbus.
2. CPU gibt ein Signal auf dem Steuerbus aus.
3. Der Speicher (über die Cache-Schicht) gibt Daten an den Datenbus zurück.
4. CPU liest Daten vom Datenbus.
5. Den Bus leeren.
        """

        self.address_bus = address
        self.control_bus = 'READ'
        self.transfer_count += 1
        print(f[Bus] Adressbus ← {address}, Steuerbus ← READ)

        # Speicher antwortet über die Cache-Schicht
        data, was_hit = cache.read(address, memory)
        self.data_bus = data
        print(f" [bus] Datenbus ← {data} {'(Cache-Treffer)' if was_hit else '(aus dem Speicher)'}")

        # CPU liest Daten
        result = self.data_bus

        # Bus zurücksetzen
        self.address_bus = 0
        self.data_bus = 0
        self.control_bus = 'IDLE'
        print(f[Bus] Bus zurückgesetzt, Wechsel in den Leerlaufzustand)

        return result

    def cpu_write(self, address, data, memory):
        """
CPU schreibt Daten über den Bus in den Speicher.
        """

        self.address_bus = address
        self.data_bus = data
        self.control_bus = 'WRITE'
        self.transfer_count += 1
        print(f[Bus] Adressbus ← {address}, Datenbus ← {data}, Steuerbus ← WRITE)

        memory.write(address, data)
        print(f[Bus] Daten {data} wurden an Speicheradresse {address} geschrieben)

        # Bus zurücksetzen
        self.address_bus = 0
        self.data_bus = 0
        self.control_bus = 'IDLE'
        print(f[Bus] Bus zurückgesetzt, Wechsel in den Leerlaufzustand)


# ============================
# 3. DMA-Controller
# ============================

class DMAController:
    """
DMA-Controller – zuständig für die direkte Übertragung von Daten zwischen Festplatte und Speicher.
Die CPU muss dem DMA nur Quelladresse, Zieladresse und Übertragungslänge mitteilen.
Nachdem der DMA die Übertragung abgeschlossen hat, benachrichtigt er die CPU über einen Interrupt.
    """

    def __init__(self, bus):
        self.bus = bus
        self.transfer_count = 0    # Anzahl der DMA-Übertragungen
        self.total_bytes = 0       # Insgesamt übertragene Bytes

    def transfer_program(self, disk, program_name, memory, load_addr=0):
        """
Lade das Programm per DMA von der Festplatte in den Speicher.
Dies ist eine praktische Anwendung von Lektion 20 'DMA-Modus' in diesem Kurs.
        """

        print(f"\n  {'='*50}")
        print(fDMA-Transfer startet: Festplatte → Speicher)
        print(f"  {'='*50}")
        print(f[DMA] Quelle: Festplattensektor (Programm '{program_name}'))
        print(f[DMA] Ziel: Start der Speicheradresse 0x{load_addr:04X})
        print(f[DMA] Bussteuerung wird angefordert...)

        # DMA belegt den Bus
        self.bus.control_bus = 'DMA_REQ'
        print(f[DMA] erhält Bussteuerung (Steuerbus ← DMA_REQ))

        program = disk.load_program(program_name)
        if program is None:
            print(f[DMA] Fehler: Programm existiert nicht, Transfer abgebrochen)
            self.bus.control_bus = 'IDLE'
            return 0

        # Befehl-für-Befehl-Übertragung
        for i, instruction in enumerate(program):
            addr = load_addr + i
            memory.write(addr, instruction)
            self.bus.address_bus = addr
            self.bus.data_bus = instruction
            self.total_bytes += 1
            self.transfer_count += 1
            print(f" [DMA] Übertragung #{i}: Direktive '{instruction}' → Speicheradresse {addr} (0x{addr:04X})")

        # DMA gibt den Bus frei und sendet einen Abschluss-Interrupt
        self.bus.control_bus = 'DMA_ACK'
        print(f" [DMA] Übertragung abgeschlossen! Insgesamt {len(program)} Direktiven, {self.total_bytes} Busübertragungen")
        print(f[DMA] Bussteuerung freigeben (Steuerbus ← IDLE))

        # Interrupt benachrichtigt die CPU
        print(f" [DMA] Interruptsignal senden, um die CPU zu benachrichtigen: Programm laden abgeschlossen")
        self.bus.control_bus = 'INTERRUPT'

        # Verarbeitung, nachdem die CPU einen Interrupt empfangen hat
        time.sleep(0.001)
        print(f[CPU-Interrupt-Antwort] DMA-Abschlussinterrupt empfangen, Programm ist bereit)
        self.bus.control_bus = 'IDLE'

        return len(program)

    def cache_prefetch(self, memory, cache, start_addr, count):
        """
DMA-Prefetch: Daten, die bald verwendet werden, aus dem Speicher in den Cache vorladen.
Simuliere den Hardware-Prefetch-Mechanismus einer modernen CPU.
        """

        print(f"\n[DMA-Prefetch] Speicheradressen {start_addr}~{start_addr+count-1} in den Cache vorladen...)
        for i in range(count):
            addr = start_addr + i
            data = memory.read(addr)
            line_index = addr % cache.num_lines
            cache.lines[line_index] = (addr, data)
        print(f[DMA Prefetch] Abgeschlossen, {count} Befehle in den Cache geschrieben)


# ============================
# 4. ALU - Arithmetisch-logische Einheit
# ============================

class ALU:
    """
Arithmetisch-logische Einheit - führt alle arithmetischen und logischen Operationen aus.
Inhalt, der dem zweiten Modul des Kurses entspricht, wie Addierer und Logikgatter.
    """

    @staticmethod
    def add(a, b):
        print(f[ALU] Führe Addition aus: {a} + {b} = {a + b})
        return a + b

    @staticmethod
    def sub(a, b):
        print(f[ALU] Subtraktion wird ausgeführt: {a} - {b} = {a - b})
        return a - b

    @staticmethod
    def mul(a, b):
        print(f[ALU] Multiplikation wird ausgeführt: {a} * {b} = {a * b})
        return a * b

    @staticmethod
    def cmp(a, b):
        result = (a == b)
        print(f" [ALU] ExecuteCompare: {a} == {b} ? {'ja' if result else 'nein'} (Z={1 if result else 0})")
        return result


# ============================
# 5. FullComputer - Vollständiger Computer
# ============================

class FullComputer:
    """
Vollständiger Von-Neumann-Computer-Simulator.

Komponenten:
- disk: Festplatte (persistenter Speicher)
- memory: Hauptspeicher
- cache: L1-Cache
- Register: Registergruppe (einschließlich PC, IR, MAR, MDR, FLAGS)
- ALU: Arithmetisch-logische Einheit
- Bus: Systembus (Adresse + Daten + Steuerung)
- DMA: DMA-Controller

Ausführungsablauf:
1. Laden: DMA überträgt das Programm von der Festplatte in den Speicher.
2. Befehlszyklus: Holen → Dekodieren → Ausführen → Zurückschreiben.
3. Vollständigen Ausführungsbericht generieren
    """


    def __init__(self):
        print("=" * 60)
        print(FullComputer - von-Neumann-Computer wird initialisiert...)
        print("=" * 60)

        # Vierstufiges Speichersystem
        self.disk = Disk()
        self.memory = Memory()
        self.cache = Cache⟦⟧num_lines(num_lines=8)
        self.registers = RegisterFile()

        # Recheneinheit
        self.alu = ALU()

        # Bussystem
        self.bus = SystemBus()

        # DMA-Controller
        self.dma = DMAController(self.bus)

        # Statistiken
        self.instructions_executed = 0
        self.clock_cycles = 0

        print(Komponenten bereit: Festplatte, Speicher (64KB), Cache (8-Zeilen-L1), 4 Allzweckregister)
        print(Komponenten bereit: ALU, Systembus, DMA-Controller)
        print()

    def store_program(self, name, program):
        """Speichere das Programm auf der Festplatte"""
        print(f[Schritt 0] Programm '{name}' auf der Festplatte speichern)
        self.disk.store_program(name, program)
        print()

    def load_program(self, program_name, load_addr=0):
        """
Programm laden: DMA überträgt von der Festplatte in den Speicher.
        """

        print(f[Schritt 1] DMA lädt Programm in den Speicher)
        size = self.dma.transfer_program(
            self.disk, program_name, self.memory, load_addr
        )
        print()

        # Instruktionen in den Cache vorladen
        print(f[Schritt 2] Cache-Aufwärmphase: Lade die ersten {min(4, size)} Instruktionen vor)
        self.dma.cache_prefetch(self.memory, self.cache, load_addr, min(4, size))
        print()

        # PC auf Programmstartadresse setzen
        self.registers.PC = load_addr
        print(f[Schritt 3] PC ← {load_addr} setzen (Startadresse des Programms))
        print()

    def fetch(self):
        """
Phase 1: Holen
- PC-Wert in MAR laden
- Die Adresse über den Adressbus senden
- READ-Signal über den Steuerbus senden
- Befehl vom Datenbus holen (über die Cache-Schicht)
- Befehl in IR speichern
- PC inkrementieren
        """

        print(f"--- Stufe 1: Befehlsabruf (Fetch) ---")
        self.clock_cycles += 1

        # MAR ← PC
        self.registers.MAR = self.registers.PC
        print(f" MAR ← PC = {self.registers.PC}")

        # Speicher über den Bus lesen (über Cache)
        instruction = self.bus.cpu_read(
            self.registers.MAR, self.memory, self.cache
        )

        # MDR ← Datenbus, IR ← MDR
        self.registers.MDR = instruction
        self.registers.IR = instruction
        print(f" MDR ← {instruction}, IR ← MDR")

        # PC inkrementieren
        old_pc = self.registers.PC
        self.registers.PC += 1
        print(f" PC ← {old_pc} + 1 = {self.registers.PC}")

        return instruction

    def decode(self):
        """
Stufe 2: Dekodieren
- Steuereinheit decodiert Befehl in IR
- Opcode und Operand trennen
- Operationen der Ausführungsphase bestimmen
        """

        print(f--- Stufe 2: Dekodieren ---)
        self.clock_cycles += 1

        instruction = self.registers.IR
        parts = instruction.split()
        opcode = parts[0]
        operands = parts[1:] if len(parts) > 1 else []

        print(f" Befehl: '{instruction}'")
        print(fOpcode: {opcode}, Operanden: {operands})

        return opcode, operands

    def execute(self, opcode, operands):
        """
Stufe 3: Ausführen
- Entsprechende Operation basierend auf dem Opcode ausführen
- ALU führt arithmetische/logische Operationen aus
- Kann Register ändern oder Flag-Bits setzen
        """

        print(f--- Phase 3: Ausführen ---)
        self.clock_cycles += 1

        if opcode == 'LOAD':
            # LOAD reg value: Lade den unmittelbaren Wert in das Register
            reg, value = operands[0], int(operands[1])
            self.registers.gpr[reg] = value
            print(fOperation: Lade unmittelbar {value} → Register {reg})
            print(f" ALU ist nicht beteiligt (direktes Laden)")

        elif opcode == 'STORE':
            # STORE reg addr: Speichere den Registerwert in den Speicher
            reg, addr = operands[0], int(operands[1])
            value = self.registers.gpr[reg]
            print(fOperation: Vorbereitung, den Wert {value} von Register {reg} in Speicheradresse {addr} zu speichern)
            # Daten sind bereit; die Write-Back-Phase führt die eigentliche Store-Operation aus.
            return ('STORE', reg, addr, value)

        elif opcode == 'ADD':
            # ADD dst src: dst = dst + src
            dst, src = operands[0], operands[1]
            old_val = self.registers.gpr[dst]
            result = self.alu.add(old_val, self.registers.gpr[src])
            self.registers.gpr[dst] = result
            # Null-Flag setzen
            self.registers.FLAGS['Z'] = (result == 0)
            print(f" Operation: {dst} ← {old_val} + {self.registers.gpr.get(src, src)} = {result}")
            print(fNull-Flag Z ← {self.registers.FLAGS['Z']})

        elif opcode == 'SUB':
            # SUB dst src: dst = dst - src
            dst, src = operands[0], operands[1]
            old_val = self.registers.gpr[dst]
            result = self.alu.sub(old_val, self.registers.gpr[src])
            self.registers.gpr[dst] = result
            self.registers.FLAGS['Z'] = (result == 0)
            print(f" Operation: {dst} ← {old_val} - {self.registers.gpr.get(src, src)} = {result}")

        elif opcode == 'MUL':
            # MUL dst src: dst = dst * src
            dst, src = operands[0], operands[1]
            old_val = self.registers.gpr[dst]
            result = self.alu.mul(old_val, self.registers.gpr[src])
            self.registers.gpr[dst] = result
            self.registers.FLAGS['Z'] = (result == 0)
            print(f" Operation: {dst} ← {old_val} * {self.registers.gpr.get(src, src)} = {result}")

        elif opcode == 'CMP':
            # CMP a b: zwei Registerwerte vergleichen, Null-Flag setzen
            a, b = operands[0], operands[1]
            is_equal = self.alu.cmp(
                self.registers.gpr[a],
                self.registers.gpr[b]
            )
            self.registers.FLAGS['Z'] = is_equal

        elif opcode == 'JMP':
            # JMP addr: Unbedingter Sprung
            target = int(operands[0])
            print(fOperation: unbedingter Sprung zur Adresse {target})
            old_pc = self.registers.PC
            self.registers.PC = target
            print(fPC ← {old_pc} → {target} (Sprung))

        elif opcode == 'JZ':
            # JZ addr: Sprung, wenn das Null-Flag wahr ist
            target = int(operands[0])
            if self.registers.FLAGS['Z']:
                print(fOperation: wenn das Null-Flag wahr ist (Z=1), zur Adresse {target} springen)
                self.registers.PC = target
            else:
                print(fOperation: Null-Flag ist falsch (Z=0), kein Sprung, sequenzielle Ausführung)

        elif opcode == 'HALT':
            # HALT: Anhalten
            print(fOperation: Halt-Befehl, Programm endet)
            return 'HALT'

        else:
            print(f" Unbekannter Opcode: {opcode}")

        return None

    def writeback(self):
        """
Stufe 4: WriteBack
- Wenn es Operationen gibt, die in den Speicher zurückgeschrieben werden müssen (wie STORE), werden sie in dieser Stufe abgeschlossen
- Daten über den Datenbus übertragen
        """

        print(f"--- Stufe 4: WriteBack ---")
        self.clock_cycles += 1

        # Das Ergebnis einer allgemeinen Anweisung wurde bereits während der Ausführungsstufe in das Register geschrieben
        # STORE-Anweisung muss in dieser Stufe in den Speicher schreiben
        print(fRegisterzustand: {self.registers.gpr})
        print(fFlags-Register: {self.registers.FLAGS})

    def writeback_store(self, addr, value):
        """Write-back-Vorgang der STORE-Anweisung — Schreiben in den Speicher über den Bus"""
        self.bus.cpu_write(addr, value, self.memory)
        print(fSTORE abgeschlossen: {value} → Speicheradresse {addr})

    def run(self):
        """
Führe das geladene Programm aus.
Schleife über Abrufen → Dekodieren → Ausführen → Zurückschreiben, bis das Programm endet.
        """

        print("=" * 60)
        print(Programm startet die Ausführung)
        print("=" * 60)

        while self.registers.PC < max(self.memory.cells.keys(), default=0) + 1:
            # Prüfen, ob PC im gültigen Bereich liegt
            if self.registers.PC not in self.memory.cells:
                # PC überschreitet den Programmbereich, möglicherweise aufgrund eines Sprungs an das Ende, beenden
                print(f"\nProgrammzähler PC={self.registers.PC} überschreitet den Programmbereich, Ausführung endet)
                break

            self.instructions_executed += 1

            print(f"\n{'#' * 55}")
            print(f"### Direktive #{self.instructions_executed} | PC = {self.registers.PC}")
            print(f"{'#' * 55}")

            # Befehlsabruf
            instruction = self.fetch()

            # Dekodieren
            opcode, operands = self.decode()

            # Ausführen
            special = self.execute(opcode, operands)

            # HALT-Anweisung behandeln
            if special == 'HALT':
                self.clock_cycles += 1
                break

            # Rückschreiben
            if special and special[0] == 'STORE':
                _, Reg, Adr, Wert = Spezial
                self.writeback_store(int(addr), value)
            else:
                self.writeback()

            # Sicherheitsprüfung: Endlosschleifen verhindern
            if self.instructions_executed > 1000:
                print("\nWarnung: Über 1000 Anweisungen ausgeführt, erzwungener Stopp (mögliche Endlosschleife))
                break

        print(f"\n{'=' * 60}")
        print(f" Programmausführung abgeschlossen")
        print(f"{'=' * 60}")

    def report(self):
        """
Erzeuge einen vollständigen Ausführungsbericht.
Alle Statistiken zusammenfassen: Cache-Trefferrate, Anweisungsanzahl, Taktzyklen,
Bus-Transferanzahl, Speicher-Lese-/Schreibanzahl usw.
        """

        print(f"\n{'=' * 65}")
        print(fFullComputer-Ausführungsbericht —— BEISPIEL)
        print(f"{'=' * 65}")
        print()

        # Basisinformationen
        print(f"  {'─' * 55}")
        print(f" Grundlegende Informationen")
        print(f"  {'─' * 55}")
        print(fAusgeführte Anweisungen insgesamt: {self.instructions_executed:>6d})
        print(fTaktzyklen insgesamt: {self.clock_cycles:>6d} Zyklen)
        if self.instructions_executed > 0:
            cpi = self.clock_cycles / self.instructions_executed
            print(fDurchschnittliche CPI (Zyklen/Anweisung): {cpi:>6.2f})
        print()

        # Cache-Leistung
        print(f"  {'─' * 55}")
        print(f"Cache-Leistung (L1 Cache)")
        print(f"  {'─' * 55}")
        total_access = self.cache.hit_count + self.cache.miss_count
        print(f" Cache-Treffer: {self.cache.hit_count:>6d} Mal")
        print(f" Cache-Fehltreffer: {self.cache.miss_count:>6d} Mal")
        print(fZugriffe insgesamt: {total_access:>6d} Mal)
        print(fTrefferrate: {self.cache.hit_rate:>6.1f}%)
        print(fCache-Zeilen insgesamt: {self.cache.num_lines:>6d} Zeilen)
        print()

        # Speicherzugriff
        print(f"  {'─' * 55}")
        print(f" Speicherzugriffsstatistik")
        print(f"  {'─' * 55}")
        print(fSpeicher-Leseoperationen: {self.memory.read_count:>6d} Mal)
        print(fSpeicher-Schreiboperation: {self.memory.write_count:>6d} Mal)
        print(f" Speicherzugriffe insgesamt: {self.memory.read_count + self.memory.write_count:>6d} Mal")
        print(fAnzahl verwendeter Speicheradressen: {len(self.memory.cells):>6d})
        print()

        # Bus-Statistiken
        print(f"  {'─' * 55}")
        print(f" Bus-Statistiken")
        print(f"  {'─' * 55}")
        print(f" Vom CPU ausgelöste Busübertragungen: {self.bus.transfer_count:>6d} Mal")
        print(f" Vom DMA ausgelöste Busübertragungen: {self.dma.transfer_count:>6d} Mal")
        total_bus = self.bus.transfer_count + self.dma.transfer_count
        print(fGesamtzahl der Bus-Transfers: {total_bus:>6d} Mal)
        print()

        # Endgültiger Registerzustand
        print(f"  {'─' * 55}")
        print(f" Endgültiger Registerzustand")
        print(f"  {'─' * 55}")
        print(fAllzweckregister: {self.registers.gpr})
        print(fProgrammzähler PC: {self.registers.PC})
        print(fBefehlsregister IR: {self.registers.IR})
        print(fFlag-Register FLAGS: {self.registers.FLAGS})
        print()

        # Speicherauszug der Daten (zeigt nur Daten an gültigen Adressen)
        print(f"  {'─' * 55}")
        print(f" Speicherauszug der Daten (zeigt nur den Programmbereich)")
        print(f"  {'─' * 55}")
        if self.memory.cells:
            for addr in sorted(self.memory.cells.keys()):
                val = self.memory.cells[addr]
                print(fAdresse {addr:>4d} (0x{addr:04X}): {val})
        else:
            print(f" (Speicher ist leer)")
        print()

        print(f"{'=' * 65}")
        print(fEnde des Berichts. Vielen Dank für die Nutzung des EXAMPLE FullComputer Simulators!)
        print(f"{'=' * 65}")


# ============================
# 6. Hauptprogramm - End-to-End-Demo
# ============================

if __name__ == "__main__":
    print()
    print("╔" + "═" * 58 + "╗")
    print("║" + Die komplette Reise eines Befehls — EXAMPLE FullComputer Demo.center(52) + "║")
    print("╚" + "═" * 58 + "╝")
    print()

    # Computer erstellen
    computer = FullComputer()

    # Demoprogramm definieren: Berechne (10 + 7) * 2 - 3 = ?
    # Verwende LOAD, um den Anfangswert zu laden, und ADD/MUL/SUB, um die Berechnung auszuführen
    demo_program = [
        "LOAD A 10",    # A = 10
        "LOAD B 7",     # B = 7
        "ADD A B",      # A = A + B = 17
        "LOAD C 2",     # C = 2
        "MUL A C",      # A = A * C = 34
        "LOAD D 3",     # D = 3
        "SUB A D",      # A = A - D = 31
        "STORE A 100",  # Ergebnis in Speicheradresse 100 speichern
        "LOAD B 31",    # B = 31 (erwartetes Ergebnis)
        "CMP A B",      # A und B vergleichen -> sollten gleich sein
        "JZ 12",        # Falls gleich (Z=1), zu HALT springen
        "LOAD D 0",     # (nicht ausgeführt) D = 0
        "HALT",         # Halt
    ]

    # Schritt 1: Das Programm auf der Festplatte speichern
    computer.store_program("EXAMPLE_DEMO", demo_program)

    # Schritt 2: DMA-Laden in den Speicher
    computer.load_program("EXAMPLE_DEMO", load_addr=0)

    # Schritt 3: Das Programm ausführen
    computer.run()

    # Schritt 4: Vollständigen Ausführungsbericht ausgeben
    computer.report()

    print(f"\n")
    print(fÜberblick: Diese Demo behandelt alle sechs Module der Prinzipien der Rechnerorganisation:)
    print(fModul 1 (Binär): Anweisungen und Daten werden im Speicher in binärer Kodierung gespeichert.)
    print(fModul 2 (Logikgatter): Das ADD/SUB/MUL in der Ausführungsstufe wird durch ALU-Gatterschaltungen realisiert)
    print(fModul 3 (von Neumann): Programm und Daten teilen sich den Speicher, fünf Hauptkomponenten arbeiten zusammen)
    print(fModul 4 (CPU-Grundlagen): PC holen → IR dekodieren → ALU ausführen → zurückschreiben, vollständige vierstufige Pipeline.)
    print(fModul 5 (Speichersystem): Festplatte → Hauptspeicher → Cache → Register, vierstufige Speicherhierarchie)
    print(fModul 6 (Bus und E/A): Zusammenspiel der drei Busse, DMA-Programmladen, Interrupt-Benachrichtigung)
    print()

Interpretation des Ausführungsberichts

Nach Ausführung des obigen Codes gibt FullComputer einen detaillierten Ausführungsbericht aus. Interpretieren wir die wichtigsten Kennzahlen:

Cache-Trefferrate

Die im Bericht angezeigte Cache-Trefferrate spiegelt diezeitliche Lokalitätundräumliche Lokalitätdes Programms wider. Da unser Demo-Programm sehr klein ist und DMA die ersten 4 Instruktionen vorab lädt, wird die Trefferrate relativ hoch sein. In tatsächlichen großen Programmen liegt die Cache-Trefferrate normalerweise über 90% — genau das ist der Zweck des Caches.

CPI (Taktzyklen pro Instruktion)

In unserer vereinfachten Simulation benötigt jede Instruktion feste 4 Taktzyklen (Holen-Dekodieren-Ausführen-Rückschreiben), sodass der CPI etwa 4 beträgt. Moderne CPUs verwenden Pipelining, um den CPI auf nahe 1 zu senken — das heißt, eine Instruktion pro Taktzyklus abzuschließen.

Anzahl der Busübertragungen

Bus-Transfer-Anzahl = durch die CPU ausgelöste Transfers + durch die DMA ausgelöste Transfers. Die DMA führt während der Programmladephase eine große Anzahl von Transfers durch, und die CPU löst während der Befehlsabrufphase jedes Befehls mindestens einen Lese-Transfer aus.


Was wir gelernt haben — Rückblick auf den sechswöchigen Kurs.

Vor sechs Wochen begannen wir mit der einfachsten Frage: "Warum verstehen Computer nur 0 und 1?" Jetzt sind wir in der Lage, einen vollständigen Computersimulator von Grund auf zu bauen. Gehen wir diesen Lernpfad noch einmal durch:

WochennummerModulZentrale Erkenntnisse
Woche 1Binär- und InformationsdarstellungVerstanden, warum Computer Binärsysteme verwenden, wie man eine Basisumrechnung durchführt und wie verschiedene Informationen (Zahlen, Text, Bilder) in 0en und 1en kodiert werden.
Woche 2Logikgatter und digitale SchaltungenDie drei grundlegenden Logikgatter beherrscht: AND, OR, NOT; verstanden, wie man damit Addierer und ALUs baut.
Woche 3Von-Neumann-ArchitekturDie Arbeitsteilung zwischen den fünf Hauptkomponenten (Rechenwerk, Steuerwerk, Speicher, Eingabe, Ausgabe) und das Konzept des gespeicherten Programms verstanden.
Woche 4CPU-GrundlagenDie vier Phasen des Befehlszyklus beherrscht: Abrufen-Dekodieren-Ausführen-Rückschreiben, und wie Pipelining die Effizienz verbessert.
Woche 5SpeichersystemDie vierstufige Speicherpyramide von Registern bis zur Festplatte verstanden, und wie Cache das Lokalitätsprinzip nutzt, um Zugriffe zu beschleunigen.
Woche 6Bus und I/ODas Zusammenwirken der drei Busse (Adress-/Daten-/Steuerbus) und die Effizienzunterschiede zwischen den drei E/A-Methoden (Polling/Interrupt/DMA) beherrscht.

Von der Theorie zur Praxis: Wie es weitergeht.

Dieser Kurs hat Ihnen ein solides Fundament in den Grundlagen der Rechnerorganisation gelegt. Wenn Sie tiefer einsteigen möchten, sind hier einige empfohlene Richtungen:

  • Betriebssystem: Lernen Sie, wie Betriebssysteme die CPU, den Speicher, Dateisysteme und E/A-Geräte verwalten. Die in diesem Kurs gelernten „Interrupts“, „DMA“ und „Speicherhierarchie“ sind Kernkonzepte von Betriebssystemen.
  • Assemblersprache: Interagieren Sie direkt mit CPU-Befehlen. Nach Abschluss dieses Kurses ist die Assemblersprache kein „versiegeltes Buch“ mehr – Sie wissen, wie jeder Assemblerbefehl auf Hardwareebene ausgeführt wird.
  • nand2tetris: Ein berühmter Online-Kurs, der Sie von einem einzelnen NAND-Gatter bis zum schrittweisen Aufbau eines vollständigen programmierbaren Computers führt. Die Inhalte dieses Kurses ergänzen ihn hervorragend.
  • Rechnerarchitektur: Tauchen Sie in fortgeschrittene CPU-Entwurfstechniken ein, wie Pipelining, superskalare Ausführung, Out-of-Order-Ausführung und Sprungvorhersage.
  • Eingebettete Systeme: Wenden Sie das Wissen aus diesem Kurs auf Mikrocontroller (wie Arduino, STM32) an und schreiben Sie Programme, die Register und Peripheriegeräte direkt manipulieren.

Zusammenfassung und abschließende Überprüfung

Ein-Satz-Zusammenfassung:Ein Computer ist keine Magie – er ist eine Schicht für Schicht sorgfältig gestaltete Abstraktion, die bei Transistoren beginnt und schrittweise Logikgatter, ALU, CPU, Speichersystem und Bus aufbaut und schließlich ein Gerät bildet, das jede Befehlsfolge ausführen kann. Wenn du diese Ebenen verstehst, verstehst du den Computer wirklich.

Umfassende Selbsttestfragen zum Kurs

  1. Im FullComputer-Simulator: In welchen Schritten werden bei der Ausführung einer LOAD-Anweisung jeweils der Adressbus, der Datenbus und der Steuerbus verwendet?
  2. Wenn der Cache von FullComputer nur 4 Zeilen hätte (statt 8), welche Auswirkungen hätte das auf die Ausführungseffizienz des Programms? Wie nennt man dieses Phänomen in der Computerarchitektur?
  3. In welchen Szenarien verwenden moderne Betriebssysteme Polling, Interrupts und DMA? Bitte gib für jedes ein Beispiel an, das du bei der täglichen Computernutzung beobachten kannst.

Referenzantwort: 1. Fetch-Phase: Der Adressbus überträgt den PC-Wert (die Befehlsadresse), der Steuerbus sendet ein READ-Signal, und der Datenbus liefert den Befehlsinhalt zurück. 2. Mehr Cache-Konflikte, niedrigere Trefferrate (man nennt das Cache-Thrashing oder Konflikt-Misses). 3. Polling: Fortschrittsprüfung während Firmware-Updates bei einigen einfachen eingebetteten Geräten; Interrupt: Jeder Tastendruck löst einen Interrupt aus; DMA: Kopieren großer Dateien, Übertragung des Framebuffers beim Grafikrendering.

Weitere Erweiterungen