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.

VergleichsdimensionSpieluhr (externe Programmsteuerung)Smartphone (gespeichertes Programm)
Konzept des gespeicherten ProgrammsIn der mechanischen Struktur festgelegtIm Speicher als Daten abgelegt
Titel wechselnZerlegen und die Trommel austauschenEinfach auf den Bildschirm tippen
Ist die Hardware universell?Eine Spieluhr = eine MelodieEin Telefon = unbegrenzte Melodien
FlexibilitätNahezu nullextrem 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:

  1. 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.
  2. Software existiert unabhängig: Programme wurden zu "Dateien", die gespeichert, kopiert und übertragen werden konnten. Dies war die Geburt des Konzepts "Software".
  3. 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.

Instruction color gradient Data color gradient Memory module background Main memory (RAM)header Address Stored content Type Actual meaningData row Address 0: instruction LOAD A 5 0x0000 10110001 00000101 [ Instruction ] LOAD A, 5Address 2: Data 5 (value of A) 0x0001 00000000 00000101 [ Data ] Immediate value 5Address 3: Instruction LOAD B 3 0x0002 10110010 00000011 [ Instruction ] LOAD B, 3Address 5: Data 3 (value of B) 0x0003 00000000 00000011 [ Data ] Immediate value 3Address 4: Instruction ADD A B 0x0004 00100000 00000001 [ Instruction ] ADD A, BAddress 6: Instruction STORE A 0x0005 00110000 01100100 [ Instruction ] STORE 100Address 100: data storage result 0x0064 00000000 00001000 [ Data ] Calculation result: 8Legend area Legend: Blue highlight = instruction unit (opcode + operand) Orange highlight = data unit (immediate values, variable values, calculation results) Note: Instructions and data are exactly the same in physical storage; they are all binary bits. Only the PC pointer when the CPU fetches an instruction determines whether it is an instruction or data.

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.

Befehl Daten Frei (leer)
Dynamisch von JS generierte Rasterzellen
Klicken Sie auf die Speicherzelle oben, um Typ und Bedeutung des an dieser Adresse gespeicherten Inhalts anzuzeigen

Vergleich mit der Harvard-Architektur

Die Von-Neumann-Architektur ist nicht die einzige Computerarchitektur. Ihr wichtigster "Konkurrent" ist die Harvard-Architektur.Harvard-Architektur。

VergleichsdimensionVon-Neumann-ArchitekturHarvard-Architektur
GedächtnisEin einzelner Speicher, Befehle und Daten werden gemeinsam genutztZwei unabhängige Speicher, Befehle und Daten sind getrennt
BusEin Satz Adress-/Datenbusse; Befehle und Daten teilen sich den Bus im ZeitmultiplexZwei unabhängige Bussätze; auf Befehle und Daten kann gleichzeitig zugegriffen werden
VorteileEinfaches Hardware-Design, hohe Speicherauslastung, flexible SoftwareBefehlsabruf und Datenabruf können gleichzeitig erfolgen, schneller (pipelinefreundlich)
NachteileBefehlsabruf und Datenabruf können kollidieren (Von-Neumann-Flaschenhals)Komplexere Hardware; Befehlsspeicher und Datenspeicher können nicht dynamisch zugewiesen werden
Typische AnwendungenAllzweckcomputer wie PCs, Server usw.Eingebettete MCUs, DSP-Digitalsignalprozessoren

In 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."

Weitere Erweiterungen