Das Grundgerüst eines Computers
Im Jahr 1945 schlug der Mathematiker John von Neumann einen Entwurf für eine Computerarchitektur vor, der uns noch heute beeinflusst.
Das Kernkonzept dieses Entwurfs ist extrem einfach, doch es legte das Fundament für alle Allzweckcomputer der letzten achtzig Jahre.
Alltagsanalogie: ein automatisiertes Sortiersystem in einer Bibliothek
Stellen Sie sich vor, Sie betreten eine große Bibliothek und möchten schnell ein Buch finden und es einem weit entfernten Freund per Post schicken.
Sie müssen die folgenden Schritte durchlaufen:
Schritt 1: Eingabeanforderungen—Sie geben den Buchtitel am Computerterminal der Bibliothek ein.
Schritt 2: Standort finden—Das System fragt die Datenbank anhand des Titels ab und findet heraus, in welchem Regal das Buch steht.
Schritt 3: Buch abrufen—Ein Roboterarm nimmt das Buch vom Regal.
Schritt 4: Verpacken und Ausgeben—Das Buch wird eingepackt, ein Versandetikett wird angebracht und es wird zur Post geschickt.
Schritt 5: Koordinieren und Steuern—All dies erfordert ein zentrales Leitsystem, um Reihenfolge und Rhythmus zu koordinieren.
Wenn wir dieses System in Computerbegriffe übersetzen, entspricht es den fünf Hauptkomponenten der Von-Neumann-Architektur:
| Bibliotheks-Analogie | Computerkomponenten | Was es tut |
|---|---|---|
| Abfrage-Terminal | Eingabegerät | Externe Informationen in den Computer einspeisen |
| Bücher im Regal | Gedächtnis | Ein Lager zur Speicherung von Programmen und Daten |
| Roboterarm | Arithmetisch-logische Einheit (ALU) | Arithmetische und logische Operationen ausführen |
| Paketzustellung | Ausgabegerät (Ausgabe) | Das Ergebnis aus dem Computer ausgeben |
| Zentrales Dispositionssystem | Steuerwerk | Weist jede Komponente an, koordiniert zusammenzuarbeiten |
Ist Ihnen aufgefallen? Der Schlüssel dafür, dass dieses Bibliothekssystem ordnungsgemäß funktioniert, sind nicht die einzelnen Komponenten selbst, sondern das klare Regelwerk für den Datenfluss zwischen ihnen.
Ebenso liegt das Wesen der von-Neumann-Architektur auch inder Art und Weise, wie die Komponenten sich verbinden und kommunizieren。
Kernprinzip: die Arbeitsteilung und das Zusammenwirken der fünf Komponenten
Überblick über die fünf Hauptkomponenten
Die von-Neumann-Architektur teilt einen Computer in fünf Teile auf, die funktional unabhängig sind und doch eng zusammenarbeiten:
| Komponenten | Englisch | Einfaches Verständnis | Kernfunktionalität |
|---|---|---|---|
| Rechenwerk | ALU (Arithmetisch-logische Einheit) | Der "Abakus" des Computers | Führt arithmetische und logische Operationen wie Addition, Subtraktion, Multiplikation, Division, AND, OR und NOT aus |
| Steuerwerk | Steuerwerk | Die "Kommandozentrale" des Computers | Holt Befehle aus dem Speicher, dekodiert Befehle und sendet Steuersignale, um andere Komponenten zu steuern |
| Gedächtnis | Gedächtnis | Das "Lagerhaus" des Computers | Speichert Programmbefehle und Rechendaten, die über Adressen gelesen und geschrieben werden |
| Eingabegerät | Eingabegeräte | Die "Augen und Ohren" des Computers | Speist externe Informationen (Tastatureingaben, Mausklicks, Sensordaten) in den Computer ein |
| Ausgabegerät | Ausgabegeräte | Der "Mund und die Hände" des Computers | Die Berechnungsergebnisse in einer für Menschen wahrnehmbaren Form ausgeben (Anzeige, Druck, Ton) |
Die ALU und das Steuerwerk zusammen sind das, was wir üblicherweise CPU (Central Processing Unit) nennen. Sie sind das "Gehirn" des Computers, während Speicher und Ein-/Ausgabegeräte das "Nervensystem" und die "Sinne" sind.
Das Architekturdiagramm unten verwendet fünf farbige Rechtecke, um die fünf Hauptkomponenten darzustellen, wobei mit Pfeilen versehene Linien die Richtung des Datenflusses markieren.
Die folgende Abbildung zeigt die klassischste Von-Neumann-Architektur moderner Computer. Das gesamte System besteht aus fünf Teilen: CPU, Speicher, Eingabe, Ausgabe und E/A-Schnittstellen. Im Inneren der CPU befinden sich das Steuerwerk, die ALU und Register.
Die CPU kommuniziert mit dem Speicher und den E/A-Geräten über den Datenbus, den Adressbus und den Steuerbus: Der Adressbus gibt den Zugriffsort an, der Datenbus überträgt Befehle und Daten, und der Steuerbus sendet Steuersignale wie Lesen, Schreiben und Interrupt. Zusammen wickeln die drei den Informationsaustausch im Inneren des Computers ab.
Drei Busse: die Datenautobahn
Die Verbindungen zwischen den fünf Komponenten sind nicht ungeordnet; stattdessen werden Informationen geordnet über drei Gruppen von "Bussen" übertragen:
| Bustyp | Englisch | Was übertragen wird | direction |
|---|---|---|---|
| Datenbus | Datenbus | Tatsächliche Befehle oder Betriebsdaten | Bidirektional (CPU kann lesen und schreiben) |
| Adressbus | Adressbus | Die Speicheradresse, auf die die CPU zugreifen möchte | Unidirektional (die CPU gibt die Adresse an den Speicher aus) |
| Steuerbus | Steuerbus | Lese-/Schreibfreigabe, Interrupt- und andere Steuersignale | Vom Controller ausgegeben, steuern sie jede Komponente |
Die Unterschiede zwischen diesen drei Bussen zu verstehen, ist der Schlüssel zum Verständnis der internen Kommunikation des Computers. Merken Sie es sich so: Der Adressbus sagt „wohin es geht“, der Datenbus ist für das „Transportieren von Dingen“ zuständig, und der Steuerbus entscheidet, „welche Aktion ausgeführt wird“.
Das Konzept des „gespeicherten Programms“: die Seele der von-Neumann-Architektur
Die Aufteilung in fünf Komponenten ist nur das äußere Gerüst. Der wahrhaft revolutionäre Aspekt der von-Neumann-Architektur liegt imKonzept des gespeicherten Programms.
Vor von Neumann musste man, um eine Aufgabe auf einem Computer auszuführen, manuell Kabel ein- und ausstecken, Schalter setzen und sogar Platinen austauschen.
Um Aufgaben zu wechseln, musste man die physischen Verbindungen der Hardware neu einstellen – das ist, als müsste man vor dem Kochen jedes Mal den Herd neu zusammenbauen.
Von Neumanns Durchbruch:
- Programm als Daten—Schreiben Sie die Berechnungsschritte als Befehlsfolge und legen Sie sie im selben Speicher wie die Daten ab.
- Software-modifizierbar—Um ein Programm zu ändern, muss nur der Befehlsinhalt im Speicher geändert werden; die Hardware muss nicht geändert werden.
- Automatische Ausführung—Die CPU holt automatisch und sequenziell Befehle aus dem Speicher, führt sie aus und holt dann den nächsten.
Diese Idee bedeutet, dass sich der Computer von einem „spezialisierten Rechenwerkzeug“ in eine„Allzweck-Computing-Plattform“ verwandelt.。
Interaktive Demo: Fahren Sie mit der Maus darüber, um die fünf Komponenten zu erkunden (Beispiel)
Fahren Sie mit der Maus über eine beliebige Komponente im Architekturdiagramm unten, und die entsprechende detaillierte Beschreibungskarte rechts wird hervorgehoben.Klicken Sie auf die Schaltfläche „Demo ausführen“, und beobachten Sie einen kleinen Punkt, der sich entlang der Datenfluss-Pfeile bewegt – er simuliert den vollständigen Weg der Daten vom Eingabegerät in den Speicher, in die CPU zur Berechnung, zurück in den Speicher und schließlich zum Ausgabegerät.
Das 「Gehirn」 des Computers
Lesen/Schreiben nach Adresse
Daten gelangen in den Computer
Ergebnisse werden aus dem Computer ausgegeben
Interaktive Demo: Simulation eines minimalen Rechners mit gespeichertem Programm
Der folgende Python-Code simuliert einen minimalen Von-Neumann-Rechner – mit einer ALU (für Addition), einem Speicher (zum Speichern von Befehlen und Daten), einem Steuerwerk (das Befehle gemäß dem PC-Zeiger nacheinander abruft und ausführt) und Ein-/Ausgabe.
Bitte lesen Sie die Kommentare sorgfältig und führen Sie es dann aus.
Beispiel
Minimalistischer Von-Neumann-Computer-Simulator (Beispieldemo)
Demonstriert das Zusammenspiel der fünf Hauptkomponenten: Rechenwerk, Steuerwerk, Speicher, Eingabe, Ausgabe
"""
class VonNeumannMachine:
"""Eine komprimierte Version des Computers mit von-Neumann-Architektur"""
def __init__(self):
# --- Speicher ---
# Ein eindimensionales Array, das bei Adresse 0 beginnt und sowohl Befehle als auch Daten enthält
self.memory = [0] * 256
# --- Arithmetisch-logische Einheit (ALU) + Registersatz ---
self.accumulator = 0 # Akkumulator ACC, das Kernregister der ALU
self.temp = 0 # Temporäres Register zum Zwischenspeichern von Operanden
# --- Steuerwerk (Control Unit) ---
self.pc = 0 # Programmzähler PC, speichert die Adresse des nächsten Befehls.
self.running = True # Lauf-Flag
# --- Eingabe / Ausgabe ---
# Simuliere Daten, die vom Eingabegerät gesendet werden
self.input_buffer = []
# Simuliere Daten, die vom Ausgabegerät angezeigt werden
self.output_buffer = []
# ============================================================
# Eingabegerät: schreibt externe Daten an die angegebene Speicheradresse
# ============================================================
def input_to_memory(self, address, value):
print(f[Eingabegerät] Schreibe Daten an die Speicheradresse {address}: {value})
self.memory[address] = value
# ============================================================
# Ausgabegerät: liest Daten von der angegebenen Speicheradresse und zeigt sie an
# ============================================================
def output_from_memory(self, address):
val = self.memory[address]
print(f[Ausgabegerät] Lese Daten von der Speicheradresse {address}: {val})
self.output_buffer.append(val)
# ============================================================
# Speicher: Lese-/Schreiboperationen (CPU greift über den Bus zu)
# ============================================================
def mem_read(self, address):
Speicherinhalt von der angegebenen Adresse lesen
if 0 <= address < len(self.memory):
return self.memory[address]
raise ValueError(f"Ungültige Speicheradresse: {address}")
def mem_write(self, address, value):
"""Schreibe den Wert an die angegebene Speicheradresse"""
if 0 <= address < len(self.memory):
self.memory[address] = value
else:
raise ValueError(f"Ungültige Speicheradresse: {address}")
# ============================================================
# ALU: führt arithmetische Operationen aus
# ============================================================
def alu_add(self, operand):
ALU-Additionsoperation: ACC = ACC + operand
old_acc = self.accumulator
self.accumulator += operand
print(f"[ALU (Arithmetisch-logische Einheit)] Addition: {old_acc} + {operand} = {self.accumulator}")
def alu_load(self, operand):
"""ALU-Ladeoperation: unmittelbaren Wert in ACC laden"""
self.accumulator = operand
print(f[ALU-Einheit] Laden: ACC = {operand})
# ============================================================
# Steuerwerk: holt Befehle, dekodiert, verteilt, aktualisiert PC
# ============================================================
def fetch(self):
"""Befehlsabrufphase: den nächsten Befehl gemäß PC aus dem Speicher holen"""
instruction = self.mem_read(self.pc)
print(f"\n<<<SEP>>> [Steuerwerk FETCH] PC={self.pc}, abgerufener Befehlscode: {instruction})
self.pc += 1 # Nach dem Abruf wird PC automatisch um 1 erhöht, um auf den nächsten Befehl zu zeigen
return instruction
def decode_and_execute(self, instruction):
"""
Dekodier- + Ausführungsphase:
Wir definieren einen minimalen Befehlssatz (gemischte Opcode-Operand-Kodierung):
1 LOAD immediate — Lade den Wert der nächsten Speicherzelle in ACC
2 ADD address — Addiere den Wert an der angegebenen Adresse zu ACC
3 STORE address — Speichere den Wert von ACC an der angegebenen Adresse
255 HALT — Halt
"""
if instruction == 1: # LOAD
operand = self.mem_read(self.pc)
self.pc += 1
print(f[Controller DECODE] Befehl: LOAD, Operand: {operand})
self.alu_load(operand)
elif instruction == 2: # ADD
address = self.mem_read(self.pc)
self.pc += 1
operand = self.mem_read(address)
print(f[Controller DECODE] Befehl: ADD Adresse[{address}] (Wert ist {operand}))
self.alu_add(operand)
elif instruction == 3: # STORE
address = self.mem_read(self.pc)
self.pc += 1
print(f"[Steuereinheit DECODE] Direktive: STORE Adresse[{address}] (Wert = {self.accumulator})")
self.mem_write(address, self.accumulator)
elif instruction == 255: # HALT
print(f"[Controller DECODE] Befehl: HALT (Halt)")
self.running = False
else:
print(f[Controller] Unbekannter Befehl: {instruction}, Halt)
self.running = False
# ============================================================
# Vollständiges Programm ausführen
# ============================================================
def run(self):
Hauptschleife: wiederholt holen -> dekodieren -> ausführen, bis zum Halt
print("=" * 55)
print("Start des minimalen Von-Neumann-Computers")
print("=" * 55)
while self.running:
instr = self.fetch() # Befehl holen
self.decode_and_execute(instr) # Dekodieren + Ausführen
print("\n" + "=" * 55)
print("Programmausführung abgeschlossen, Computer angehalten")
print("=" * 55)
# ================================================================
# Beispielprogramm: 10 + 20 berechnen und das Ergebnis an Adresse 100 speichern
# ================================================================
machine = VonNeumannMachine()
# Das Programm wird in den Speicher geschrieben (Befehle und Daten sind vermischt; dies ist das Konzept des 'gespeicherten Programms')
# Adresse 0: LOAD 10 (Opcode 1, Operand 10)
# Adresse 2: ADD 100 (Opcode 2, Operand 100, bedeutet, den Summanden von Adresse 100 zu holen)
# Adresse 4: STORE 200 (Opcode 3, Operand 200, was angibt, dass das Ergebnis an Adresse 200 gespeichert wird)
# Adresse 6: HALT (Opcode 255)
machine.memory[0] = 1
machine.memory[1] = 10 # LOAD-Operand: unmittelbarer Wert 10
machine.memory[2] = 2
machine.memory[3] = 100 # ADD-Operand: Adresse 100, an der sich die Daten befinden
machine.memory[4] = 3
machine.memory[5] = 200 # STORE-Operand: Adresse 200, an der das Ergebnis gespeichert wird
machine.memory[6] = 255 # HALT
# Den Summanden 20 an Adresse 100 speichern (simuliert das Schreiben von Daten durch das Eingabegerät)
machine.input_to_memory(100, 20)
# Programm ausführen
machine.run()
# Ergebnisse anzeigen
result = machine.mem_read(200)
print(f"\nEndergebnis: Wert an Speicheradresse 200 = {result})
machine.output_from_memory(200)
print(f"Ausgabegerätepuffer: {machine.output_buffer}")
Führen Sie dieses Programm aus, und Sie werden sehen, wie Anweisungen nacheinander abgerufen, dekodiert und ausgeführt werden. Genau das geschieht in Ihrem Computer mehrere hundert Millionen Mal pro Sekunde — nur ist der Befehlssatz einer echten CPU weitaus komplexer als dieser.
Zusammenfassung und Überprüfung
Zusammenfassung in einem Satz
Die Von-Neumann-Architektur teilt den Computer in fünf Teile auf: Rechenwerk, Steuerwerk, Speicher, Eingabegerät und Ausgabegerät, die über drei Busgruppen verbunden sind, und speichert Programm und Daten im selben Speicher; dabei ruft die CPU Befehle automatisch nacheinander ab und führt sie aus.
Selbsttestfragen
Frage 1Unter den fünf Hauptkomponenten der Von-Neumann-Architektur, welche zwei werden zusammen als CPU bezeichnet?
- A. Rechenwerk und Speicher
- B. Rechenwerk und Steuerwerk
- C. Steuerwerk und Speicher
- D. Eingabegeräte und Ausgabegeräte
Richtige Antwort: B
Frage 2Welche Funktion hat der Adressbus? In welche Richtung erfolgt seine Datenübertragung?
- A. Berechnungsergebnisse übertragen; bidirektional
- B. Steuersignale übertragen; vom Steuerwerk ausgegeben
- C. Speicheradressen übertragen; von der CPU zum Speicher (unidirektional)
- D. Befehle und Daten übertragen; bidirektional
Richtige Antwort: C. Der Adressbus gibt Adressinformationen von der CPU an den Speicher aus und ist unidirektional.
Frage 3Was ist die Kernbedeutung des Konzepts des „gespeicherten Programms“?
- A. Von da an benötigten Computer kein Rechenwerk mehr
- B. Das Ändern von Software erfordert nur das Ändern des Speicherinhalts, ohne dass die Hardware geändert werden muss
- C. Die Speicherkapazität ist größer als die CPU
- D. Eingabegeräte und Ausgabegeräte können zusammengeführt werden
Richtige Antwort: B. Das gespeicherte Programm verwandelt den Computer von einem speziellen Gerät in eine universelle Plattform, und Software kann flexibel ausgetauscht werden.
Weitere Erweiterungen