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:
| Modul | Thema | Kernkonzepte | Umsetzung in dieser Vorlesung |
|---|---|---|---|
| Modul 1 | Binär- und Informationsdarstellung | 0/1-Kodierung, Basisumrechnung, Zweierkomplement, Gleitkommazahlen | Sowohl Befehle als auch Daten werden in binärer Form im Speicher gespeichert. |
| Modul 2 | Logikgatter und digitale Schaltungen | AND/OR/NOT-Gatter, Addierer, ALU | Die ALU-Operationen in der Ausführungsphase werden durch Gatterschaltungen implementiert. |
| Modul 3 | Von-Neumann-Architektur | Fünf Hauptkomponenten, gespeichertes Programm, Befehlszyklus | Was diese Vorlesung simuliert, ist eine vollständige Von-Neumann-Maschine. |
| Modul 4 | CPU-Grundlagen | Register, PC, IR, Pipeline, vier Stufen | Alle vier Stufen von Fetch-Decode-Execute-Writeback werden simuliert. |
| Modul 5 | Speichersystem | Speicherhierarchie, Cache, Lokalitätsprinzip | Festplatte → Speicher → Cache → Register, die vollständige Kette des vierstufigen Speichers. |
| Modul 6 | Bus und I/O | Adress-, Daten- und Steuerbusse, Polling/Interrupt/DMA | DMA 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:
| Wochennummer | Modul | Zentrale Erkenntnisse |
|---|---|---|
| Woche 1 | Binär- und Informationsdarstellung | Verstanden, 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 2 | Logikgatter und digitale Schaltungen | Die drei grundlegenden Logikgatter beherrscht: AND, OR, NOT; verstanden, wie man damit Addierer und ALUs baut. |
| Woche 3 | Von-Neumann-Architektur | Die Arbeitsteilung zwischen den fünf Hauptkomponenten (Rechenwerk, Steuerwerk, Speicher, Eingabe, Ausgabe) und das Konzept des gespeicherten Programms verstanden. |
| Woche 4 | CPU-Grundlagen | Die vier Phasen des Befehlszyklus beherrscht: Abrufen-Dekodieren-Ausführen-Rückschreiben, und wie Pipelining die Effizienz verbessert. |
| Woche 5 | Speichersystem | Die vierstufige Speicherpyramide von Registern bis zur Festplatte verstanden, und wie Cache das Lokalitätsprinzip nutzt, um Zugriffe zu beschleunigen. |
| Woche 6 | Bus und I/O | Das 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
- Im FullComputer-Simulator: In welchen Schritten werden bei der Ausführung einer LOAD-Anweisung jeweils der Adressbus, der Datenbus und der Steuerbus verwendet?
- 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?
- 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