Warum Programme und Daten im selben Speicher abgelegt werden können
In der vorherigen Vorlesung haben wir das Gesamtbild der von-Neumann-Architektur gesehen – fünf Hauptkomponenten und drei Busse.
In dieser Vorlesung konzentrieren wir uns auf ihre revolutionärste Idee:Programmbefehle als eine besondere Art von Daten zu behandeln und sie gemeinsam mit den Daten im selben Speicher abzulegen。
Lebensnahe Analogie: Notenblätter und Musikabspielgeräte
Stellen Sie sich zwei verschiedene Musikgeräte vor:
Gerät A: Spieldose
Eine federgetriebene Spieldose enthält eine mit winzigen Noppen besetzte Metallwalze. Jede Noppe zupft einen Zahn eines Stahlkamms an, um einen Ton zu erzeugen.
Möchten Sie die Melodie ändern? Sie müssen die Spieldose auseinandernehmen und die Walze durch eine andere ersetzen, deren Noppen anders angeordnet sind. Die Walze selbst ist eine physische Verschmelzung von „Programm“ und „Abspieler“.
Gerät B: Musik-App auf dem Smartphone
Ihr Smartphone speichert Hunderte MP3-Dateien. Tippen Sie auf eine, und sie wird abgespielt.
Die MP3-Datei (Programm/Daten) und die Player-App (Ausführer) sind getrennt – um ein Lied zu ändern, müssen Sie nur die Datei ändern, nicht das Smartphone.
Eine Spieldose ist ein Vor-von-Neumann-Computer: Programm und Hardware sind fest aneinander gebunden, und die Aufgabe zu wechseln bedeutet, die Maschine zu wechseln.
Ein Smartphone ist ein Post-von-Neumann-Computer: Programme sind austauschbarer Inhalt im Speicher, und die Hardware ist eine universelle Ausführungsplattform.
| Vergleichsdimension | Spieluhr (externe Programmsteuerung) | Smartphone (gespeichertes Programm) |
|---|---|---|
| Konzept des gespeicherten Programms | In der mechanischen Struktur festgelegt | Im Speicher als Daten abgelegt |
| Titel wechseln | Zerlegen und die Trommel austauschen | Einfach auf den Bildschirm tippen |
| Ist die Hardware universell? | Eine Spieluhr = eine Melodie | Ein Telefon = unbegrenzte Melodien |
| Flexibilität | Nahezu null | extrem hoch |
Was von Neumann tat, war genau dies: Er extrahierte die "Partitur" aus der Hardware und verwandelte sie in eine "Datendatei", die frei ersetzt werden konnte. Von da an war Hardware Hardware und Software Software.
Historischer Hintergrund: von der "externen Programmsteuerung" zum "gespeicherten Programm"
2.1 Computer vor von Neumann
Anfang der 1940er Jahre waren einige elektronische Computer bereits im Einsatz, aber sie alle hatten ein gemeinsames Problem:
ENIAC (1946)—der weltweit erste universell einsetzbare elektronische Computer, erstaunlich schnell, aber jedes Mal, wenn sich die Rechenaufgabe änderte, mussten Ingenieure mehrere Tage darauf verwenden,Hunderte Kabel manuell ein- und auszustecken und Tausende Schalter einzustellenUm zu "reprogrammieren".
Harvard Mark I (1944)—Programme wurden über Lochstreifen eingegeben, aber der Programmspeicher (Lochstreifenleser) und der Datenspeicher waren zwei physisch getrennte Geräte; die CPU konnte nicht auf Programmbefehle auf dieselbe Weise zugreifen wie auf Daten.
Gemeinsame Mängel dieser Maschinen:
- Das Ändern von Programmen war extrem zeitaufwendig—es erforderte manuelles Neuverdrahten der Hardware oder den Austausch physischer Medien.
- Programmbefehle konnten nicht durch das Programm selbst geändert werden—dies schränkte die Entstehung fortgeschrittener Programmiertechniken (wie Compiler und Linker) ein.
- Das Hardware-Design war komplex—verschiedene Aufgaben konnten unterschiedliche Hardware-Konfigurationen erfordern.
2.2 von Neumanns Durchbruch
1945 schlug von Neumann im "First Draft of a Report on the EDVAC" eine kühne Idee vor:
Programmanweisungen in Binärzahlen kodieren und sie zusammen mit Daten im selben adressierbaren Speicher speichern.
Diese Idee brachte drei entscheidende Vorteile:
- Vereinheitlichung der Hardware: Die CPU muss nicht wissen, ob eine gegebene Speicherstelle einen Befehl oder Daten enthält – sie liest und schreibt einfach nach Adresse. Dies vereinfachte das Hardware-Design erheblich.
- Software existiert unabhängig: Programme wurden zu "Dateien", die gespeichert, kopiert und übertragen werden konnten. Dies war die Geburt des Konzepts "Software".
- Programme können sich selbst modifizieren: Ein Programm kann seine eigenen Befehle oder die anderer Programme genauso ändern, wie es mit Daten arbeitet. Dies legte den Grundstein für epochemachende Technologien wie Assembler, Compiler und Betriebssysteme.
Detailliertes Prinzip: die Koexistenz von Befehlen und Daten im Speicher
3.1 Speichermodul-Diagramm: Was ist ein Befehl? Was sind Daten?
Die folgende Abbildung zeigt eine Momentaufnahme eines Speicherbereichs. Jede Zelle ist eine Speichereinheit mit einer eindeutigen Adressnummer.
Bitte beachten Sie—Befehle und Daten sind physisch exakt gleich; sie bestehen alle nur aus 0 und 1.Die einzige Möglichkeit, sie zu unterscheiden, ist, wer darauf zugreift und wann.
3.2 Schlüsselfrage: Wie unterscheidet die CPU Befehle von Daten?
Aus dem obigen Diagramm lässt sich eine zentrale Tatsache erkennen: Befehle und Daten sind auf der Ebene der physischen Speicherung nicht unterscheidbar.Völlig ununterscheidbar—Sie sind alle binäre Bitfolgen.
Woher weiß die CPU also, ob eine Speichereinheit als Befehl oder als Daten behandelt werden soll?
Die Antwort ist einfach:Es hängt vom Zugriffszeitpunkt und vom Zugreifenden ab.
- Befehlsabrufphase: DerProgrammzähler (PC) der CPUstellt die Adresse bereit, und die Steuereinheit sendet ein Steuersignal „Befehl lesen“. Zu diesem Zeitpunkt wird der aus dem Speicher gelesene Inhalt als „Befehl“ behandelt und zum Dekodieren in das Befehlsregister gesendet.
- Ausführungsphase: Die CPU berechnet die Adresse des Operanden anhand des Dekodierungsergebnisses (das aus einem Register oder einem unmittelbaren Wert im Befehl stammen kann), und die Steuerung gibt ein Steuersignal „Daten lesen“ aus. Zu diesem Zeitpunkt wird der aus dem Speicher gelesene Inhalt als „Daten“ an die ALU gesendet, um an der Berechnung teilzunehmen.
In einem Satz: Für dieselbe Speicheradresse gilt: Wenn der PC darauf zeigt, ist sie ein „Befehl“; wenn eine Operandenadresse darauf zeigt, sind es „Daten“. Das ist die Essenz des „gespeicherten Programms“ – Befehle und Daten sind physisch nicht unterscheidbar und werden logisch durch den Zugriffskontext unterschieden.
Interaktive Demonstration: Erkunden Sie selbst Befehle und Daten im Speicher
Der folgende Python-Code erstellt ein Speichersystem, das interaktiv erkundet werden kann – Sie können Befehle oder Daten schreiben, dann den Inhalt einer beliebigen Adresse im Speicher anzeigen und feststellen, ob es sich um einen Befehl oder um Daten handelt.
Beispiel
Demonstration der gemischten Speicherung von Befehlen und Daten im Speicher (Beispiel-Demo)
Demonstration des Konzepts „stored-program“: Befehle und Daten im selben Speicher können anhand ihres Inhalts nicht unterschieden werden.
"""
class MemoryInspector:
Memory Inspector — zeigt intuitiv die Koexistenz von Befehlen und Daten im Speicher.
def __init__(self, size=256):
# Speicher initialisieren: Jede Zelle speichert einen ganzzahligen Wert (simuliert 8-Bit)
self.memory = [0] * size
# Tag-Array: speichert den Typ jeder Adresse — 'instruction' oder 'data'
# Hinweis: Dieser Marker existiert in echter Hardware nicht! Er ist nur zur einfacheren Demonstration hier.
self.type_tags = ['empty'] * size
# Mnemonic-Erklärungen für jede Adresse speichern (auch zur einfacheren Demonstration)
self.annotations = [''] * size
def write_instruction(self, address, opcode, operand, annotation=""):
"""Schreibe einen Befehl in den Speicher (belegt zwei Einheiten: Opcode + Operand)"""
self.memory[address] = opcode
self.type_tags[address] = 'instruction'
self.annotations[address] = annotation
self.memory[address + 1] = operand
self.type_tags[address + 1] = 'instruction'
self.annotations[address + 1] = f" └ Operand: {operand}"
def write_data(self, address, value, annotation=""):
"""Schreibe eine Dateneinheit in den Speicher"""
self.memory[address] = value
self.type_tags[address] = 'data'
self.annotations[address] = annotation
def inspect(self, start=0, end=16):
"""Zeigt den Speicherinhalt in einem angegebenen Bereich an"""
print("=" * 68)
print(f'{Adresse':>6} | {'Gespeicherter Wert':>8} | {'Binär':>10} | {'Typ':>12} | Bedeutung)
print("-" * 68)
for addr in range(start, min(end, len(self.memory))):
val = self.memory[addr]
binary = format(val, '08b') # 8-Bit-Binärdarstellung
tag = self.type_tags[addr]
anno = self.annotations[addr]
# Verwende Marker, um Anzeigefarben zu unterscheiden (keine Farbe im Terminal, verwende stattdessen Symbole)
marker = "[I]" if tag == 'instruction' else \
"[D]" if tag == 'data' else \
"[ ]"
if val != 0 or tag != 'empty':
print(f" {addr:4d} | {marker} {val:5d} | {binary} | {tag:>12} | {anno}")
print("=" * 68)
print([I] = Befehl [D] = Daten [ ] = Frei\n")
def compare_bytes(self, addr1, addr2):
"""
Vergleiche die Rohbytes zweier Adressen — du wirst feststellen, dass sie auf der Binärebene nicht unterscheidbar sind.
"""
v1 = self.memory[addr1]
v2 = self.memory[addr2]
b1 = format(v1, '08b')
b2 = format(v2, '08b')
print(f"\n--- Vergleich von Adresse {addr1} und Adresse {addr2} ---")
print(fAdresse {addr1}: Binär {b1} (Typ: {self.type_tags[addr1]}))
print(fAdresse {addr2}: Binär {b2} (Typ: {self.type_tags[addr2]}))
if b1 == b2 and self.type_tags[addr1] != self.type_tags[addr2]:
print(f>>> Wichtige Erkenntnis: Die binären Inhalte dieser beiden Adressen sind exakt identisch ({b1})!)
print(f>>> Aber ihre Typen sind verschieden: Adresse {addr1} ist {self.type_tags[addr1]},)
print(f>>> Adresse {addr2} ist {self.type_tags[addr2]}.)
print(f>>> Dies zeigt, dass es — mit nur binärem Inhalt — unmöglich ist, Anweisungen von Daten zu unterscheiden!)
else:
print(f"Die Inhalte dieser beiden Adressen sind unterschiedlich.")
def simulate_instruction_data_ambiguity(self, addr):
"""
Zeigen Sie, dass derselbe Binärwert in verschiedenen Kontexten als unterschiedliche Bedeutungen interpretiert wird
"""
val = self.memory[addr]
binary = format(val, '08b')
print(f"\n--- Demonstration der Mehrdeutigkeit der Adresse {addr} ---")
print(fGespeicherter Binärwert: {binary} (Dezimal: {val}))
print(f"")
print(f"Wenn der PC der CPU hierher zeigt (Instruktionsabrufphase):")
print(f" -> dieses Byte wird als 'Instruktionsopcode' interpretiert")
print(f" -> Zum Beispiel könnte {binary} eine 'LOAD'-Instruktion darstellen")
print(f"")
print(f"Wenn die ALU hier über die Operandenadresse darauf zugreift (Ausführungsphase):")
print(f" -> Dieses Byte wird als 'Daten' interpretiert")
print(f-> Zum Beispiel ist die Dezimalzahl {val} einfach ein gewöhnlicher numerischer Wert)
print(f"")
print(f"Dieselbe Bitfolge, von verschiedenen Rollen gelesen, hat völlig unterschiedliche Bedeutungen!")
# ================================================================
# Demo 1: Hybriden In-Memory-Speicher aufbauen
# ================================================================
print(>>> Demo 1: Anweisungen und Daten im Speicher mischen\n")
mem = MemoryInspector()
# Anweisungssequenz schreiben
mem.write_instruction(0, 0xB1, 5, "LOAD A, 5")
mem.write_instruction(2, 0xB2, 3, "LOAD B, 3")
mem.write_instruction(4, 0x20, 1, "ADD A, B")
mem.write_instruction(6, 0x30, 100, "STORE 100")
# Daten schreiben
mem.write_data(100, 8, Berechnungsergebnis: 5 + 3 = 8)
# Speicherübersicht anzeigen
mem.inspect(0, 8)
mem.inspect(100, 102)
# ================================================================
# Demo 2: Befehls-/Daten-Mehrdeutigkeit desselben Werts
# ================================================================
print(>>> Demo 2: Derselbe Binärwert kann eine Anweisung oder Daten darstellen\n")
# Absichtlich einen Wert 5 an der Adresse (Befehlsbereich) schreiben und außerdem 5 an Adresse 200 (Datenbereich) schreiben
mem.write_instruction(10, 5, 0, "Diese 5 ist der Opcode")
mem.write_data(200, 5, "Diese 5 ist der Datenwert")
mem.compare_bytes(10, 200)
# Demonstration der Mehrdeutigkeit
mem.simulate_instruction_data_ambiguity(10)
# ================================================================
# Demo 3: Konzept des selbstmodifizierenden Codes (fortgeschrittenes Thema)
# ================================================================
print(">>> Demo 3: Konzept selbstmodifizierender Programme\n")
print("Weil Anweisungen und Daten im selben Speicher liegen, kann ein Programm seine eigenen Anweisungen ändern!")
print(Genau diese Fähigkeit wird durch die Stored-Program-Architektur ermöglicht.)
print("")
print(Zum Beispiel kann das Programm die Anweisung STORE 100 an Adresse 6 in STORE 200 ändern:)
print(f"Vor der Änderung, Adresse 6: {mem.memory[6]} (Opcode)")
print(f"Vor der Änderung, Adresse 7: {mem.memory[7]} (Operand)")
# Programm modifiziert sich selbst: ändere den Operanden von STORE von 100 zu 200
mem.memory[7] = 200
mem.type_tags[7] = 'data'
mem.annotations[7] = Vom Programm selbst geändert: Operand 100 -> 200
print(fNach der Änderung, Adresse 7: {mem.memory[7]} (Operand hat sich geändert))
print("")
mem.inspect(6, 8)
print(>>> Diese Fähigkeit ist die Grundlage für Technologien wie Compiler, dynamische Linker und virtuelle Maschinen.)
Führen Sie dieses Programm aus, und Sie werden deutlich sehen: Anweisungen und Daten sind nur unterschiedliche "Rollen" im selben Speicherblock. Sie teilen denselben Speicher- und Adressierungsmechanismus—das ist die subtilste Eleganz im Herzen der Von-Neumann-Architektur.
3.3 Interaktive Demonstration: Klicken Sie auf eine Speicherzelle, um ihren Inhalt anzuzeigen (Beispiel)
Nachfolgend eine Simulation eines 64-Byte-Speicherbereichs.Blaue Zellen stellen Anweisungen dar,Orange Zellen stellen Daten dar, graue Bereiche sind frei. Fahren Sie mit der Maus über eine beliebige Zelle, um ihren rohen gespeicherten Wert anzuzeigen,Zelle anklickenDetaillierte Erklärung anzeigen – einschließlich der Frage, ob die Adresse tatsächlich einen "Befehl" oder "Daten" speichert, sowie ihrer tatsächlichen Bedeutung.
Vergleich mit der Harvard-Architektur
Die Von-Neumann-Architektur ist nicht die einzige Computerarchitektur. Ihr wichtigster "Konkurrent" ist die Harvard-Architektur.Harvard-Architektur。
| Vergleichsdimension | Von-Neumann-Architektur | Harvard-Architektur |
|---|---|---|
| Gedächtnis | Ein einzelner Speicher, Befehle und Daten werden gemeinsam genutzt | Zwei unabhängige Speicher, Befehle und Daten sind getrennt |
| Bus | Ein Satz Adress-/Datenbusse; Befehle und Daten teilen sich den Bus im Zeitmultiplex | Zwei unabhängige Bussätze; auf Befehle und Daten kann gleichzeitig zugegriffen werden |
| Vorteile | Einfaches Hardware-Design, hohe Speicherauslastung, flexible Software | Befehlsabruf und Datenabruf können gleichzeitig erfolgen, schneller (pipelinefreundlich) |
| Nachteile | Befehlsabruf und Datenabruf können kollidieren (Von-Neumann-Flaschenhals) | Komplexere Hardware; Befehlsspeicher und Datenspeicher können nicht dynamisch zugewiesen werden |
| Typische Anwendungen | Allzweckcomputer wie PCs, Server usw. | Eingebettete MCUs, DSP-Digitalsignalprozessoren |
Weitere ErweiterungenIn tatsächlichen Implementierungen verschmelzen moderne CPUs häufig die beiden Architekturen: Nach außen präsentieren sie das einheitliche Speichermodell der Von-Neumann-Architektur (aus Gründen der Programmierfreundlichkeit), während sie intern auf der L1-Cache-Ebene getrennte Befehls- und Datencaches verwenden (wodurch sie die Geschwindigkeitsvorteile der Harvard-Architektur nutzen). Dies ist die sogenannte "modifizierte Harvard-Architektur."