cleared cache because workspace.json is abnoxious
This commit is contained in:
@@ -1,4 +0,0 @@
|
||||
# Was ist das Amdahlsche Gesetz
|
||||
Das Amdahlsche Gesetz bezieht sich auf die maximale Prozessbeschleunigung, die man anhand X Prozessoren im Multi-Threading erreichen kann.
|
||||
|
||||
$µs = \frac{1}{1-p+\frac{p}{s}}$
|
||||
@@ -1,11 +0,0 @@
|
||||
# Falsch beantwortete Fragen:
|
||||
1. Harvard Architektur
|
||||
2. Adressraum
|
||||
3. TLB
|
||||
4. Multithreading
|
||||
5. Ausnahmebehandlung
|
||||
6. Adressierung
|
||||
7. Pipelinestufen
|
||||
8. Vorteile Verzweigter Adressierung relativ zum Programmzähler
|
||||
9. Branch Delay Slot
|
||||
10. Warum kann eine CPU mit höherem MIPS-Wert langsamer sein, als eien CPU mit niedrigem MIPS-Wert?
|
||||
@@ -1,8 +0,0 @@
|
||||
|
||||
# Hazards
|
||||
## DATA Hazard
|
||||
![[Pasted image 20250709205101.png]]
|
||||
Durch 'optimierungen' (verlagern des 2. LOAD WORD lw Befehls) wird Stalling verhindert und man spart sich 2 Takte. --> 11 Takte
|
||||
## CONTROL Hazard
|
||||
## STRUCT Hazard
|
||||
Es dürfen Fetch und Memory nicht gleichzeitig geschehen, Fetch müsste anhand eines NOPs delayed werden.
|
||||
@@ -1,10 +0,0 @@
|
||||
a = 2 min
|
||||
b = 8 min
|
||||
|
||||
a) $\frac{2}{8}\ \frac{0.25 min}{15 sec}$
|
||||
= 8 min 15 sek
|
||||
|
||||
b) 8 min * 0.8 + 2 min = 8,4 minuten
|
||||
|
||||
(a+b)/ 8,25 = 1,21111
|
||||
(a+b)/ 8,4 = 1,19
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 61 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 65 KiB |
@@ -1,14 +0,0 @@
|
||||
# Übung 1
|
||||
- Beim von-Neumann-Rechner lassen sich Programme im Speicher genauso ändern wie Daten. Wo könnte das sinnvoll sein?
|
||||
- Beim der Rechner der Harvard-Rechner sind Programme und Daten strikt getrennt. Wo könnte das sinnvoll sein?
|
||||
- Welche Gatter kennen Sie?
|
||||
- Welche Darstellungen (graphisch) von Gattern kennen Sie?
|
||||
- Wie viele unterschiedliche Gatter gibt es, sind möglich?
|
||||
- Was für Komponenten kennen Sie eine Abstraktionsebene über den Gattern?
|
||||
- Noch eine Ebene höher?
|
||||
- Beim der Rechner der Harvard-Rechner sind Programme und Daten strikt getrennt. Wo könnte das sinnvoll sein?
|
||||
- Was beschreibt das Moore’sche Gesetz?
|
||||
|
||||
- Auf einem Datenpfad benötigt das Laden der Eingaberegister 5 ns, die ALU-Verarbeitung 10 ns und das Rückspeichern 5 ns. Wie viel MIPS hat dieser Rechner?
|
||||
$\frac{1}{20^{-9}s} = 0.05 * 10^9 = 50 \text{ MIPS}$
|
||||
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 18 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 71 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 33 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 19 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 233 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 122 KiB |
@@ -1,96 +0,0 @@
|
||||
## 📘 **Zusammenfassung: V1 Einführung – Computerarchitektur**
|
||||
|
||||
### 🏛️ Was ist Computerarchitektur?
|
||||
|
||||
- **Definition:** Untersuchung, wie alle Teile eines Computersystems entworfen werden müssen, um eine optimale Programmierung zu ermöglichen.
|
||||
- **Enthält:** Datentypen, Operationen, Merkmale, Komponenten auf unterschiedlichen Ebenen.
|
||||
- **Begriffspaare:**
|
||||
- **Computerarchitektur** = was der Programmierer „sieht“ (Befehlssatz, Speicher, IO)
|
||||
- **Computerorganisation** = wie es technisch umgesetzt ist (Mikroarchitektur, Logikgatter)
|
||||
|
||||
---
|
||||
|
||||
### 🔄 Wichtige Kundenfragen
|
||||
|
||||
- Ist der neue Rechner **kompatibel**?
|
||||
- Betriebssystem, Programme, Peripherie => **Abwärtskompatibilität**
|
||||
- Unterschiedliche Bedürfnisse von Mensch & Maschine → **Abstraktion nötig**
|
||||
|
||||
---
|
||||
|
||||
### 🪜 Ebenen der Abstraktion (Virtuelle Maschinen)
|
||||
|
||||
1. **Ebene 0 – Digitale Logik:** Gatter, Flipflops
|
||||
2. **Ebene 1 – Mikroarchitektur:** ALU, Register, Datenpfade
|
||||
3. **Ebene 2 – Befehlssatzachritektur (ISA):** Maschinensprache
|
||||
4. **Ebene 3 – Betriebssystem:** Multiprogramming, IO-Abstraktion
|
||||
5. **Ebene 4 – Assemblersprache:** maschinennahe Programmierung
|
||||
6. **Ebene 5 – Problemorientierte Sprachen:** unabhängige Algorithmen, Compiler oder Interpreter
|
||||
|
||||
---
|
||||
|
||||
### 📜 Historie der Computer
|
||||
|
||||
#### Nullte Generation (vor 1945)
|
||||
|
||||
- Mechanische Rechenmaschinen (Pascal, Leibniz, Babbage)
|
||||
- Zuse Z3 (1941) – erster programmgesteuerter Computer
|
||||
|
||||
#### Erste Generation (1945–1955)
|
||||
|
||||
- Relais, Vakuumröhren
|
||||
- **ENIAC**, **COLOSSUS**, **IAS-Maschine**
|
||||
- Einführung der Mikroprogrammierung (Wilkes, 1951)
|
||||
- Von-Neumann-Architektur:
|
||||
- Gemeinsamer Speicher für Daten & Programme
|
||||
- Vorteil: Programme können sich selbst ändern
|
||||
- Harvard-Architektur:
|
||||
- Trennung von Daten- & Programmspeicher
|
||||
- Vorteil: schneller & sicherer
|
||||
|
||||
#### Zweite Generation (1955–1965)
|
||||
|
||||
- **Transistoren** ersetzen Röhren
|
||||
- Minicomputer (DEC PDP)
|
||||
|
||||
#### Dritte Generation (1965–1980)
|
||||
|
||||
- **Integrierte Schaltungen**
|
||||
- IBM System/360 → Abwärtskompatibilität
|
||||
|
||||
#### Vierte Generation (ab 1980)
|
||||
|
||||
- **VLSI (Very Large Scale Integration)**
|
||||
- Personal Computer (IBM PC, Commodore, Apple)
|
||||
- RISC vs. CISC Architekturen
|
||||
|
||||
#### Fünfte Generation (heute)
|
||||
|
||||
- Cloud Computing, Mobile Geräte, Embedded Systems
|
||||
|
||||
---
|
||||
|
||||
### 🚀 Meilensteine
|
||||
|
||||
- **Intel 4004 (1971):** erster Mikroprozessor (4-bit)
|
||||
- **Intel 8080, 8086:** Vorläufer moderner x86-Architektur
|
||||
- **Cray-1 (1977):** erster Vektorrechner/Supercomputer
|
||||
- **PDP-11 (1970):** Unix & Programmiersprache C entstanden darauf
|
||||
|
||||
---
|
||||
|
||||
### 📚 Literatur (Hauptquelle für Klausurvorbereitung)
|
||||
|
||||
- Patterson & Hennessy:
|
||||
- _Rechnerorganisation und Rechnerentwurf_
|
||||
- _Computer Organization and Design_ (RISC-V Edition)
|
||||
|
||||
---
|
||||
|
||||
### 🧠 Für die Klausur merken
|
||||
|
||||
✅ Unterschiede Von-Neumann vs. Harvard-Architektur
|
||||
✅ Abstraktionsebenen (0–5) und ihre Funktionen
|
||||
✅ Historische Entwicklung + wichtige Computer/Prozessoren
|
||||
✅ Begriffe wie ISA, Mikroarchitektur, VLSI, Abwärtskompatibilität
|
||||
✅ Beispielfragen: „Warum war der Intel 4004 revolutionär?“ oder „Worin liegt der Vorteil der Harvard-Architektur?“
|
||||
@@ -1,121 +0,0 @@
|
||||
## 📘 **Zusammenfassung: VA Compiler – Computerarchitektur**
|
||||
|
||||
---
|
||||
|
||||
### 🔄 Vom Quellcode zum ausführbaren Programm
|
||||
|
||||
- **Compiler-Toolchain**:
|
||||
|
||||
- Übersetzt Hochsprache in Maschinencode
|
||||
|
||||
- Tools: GCC, Clang, MSVC, Intel Compiler
|
||||
|
||||
- Ergebnis: ausführbare Datei (PE, ELF, Mach-O)
|
||||
|
||||
- **Loader (Betriebssystem):**
|
||||
|
||||
- Lädt die Datei in den Speicher & startet die Ausführung
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🧱 Phasen des Compilers
|
||||
|
||||
|Phase|Aufgabe|
|
||||
|---|---|
|
||||
|**Lexikalische Analyse**|Zerlegt Quelltext in Tokens: `<Tokenname, Attributwert>`|
|
||||
|**Syntaktische Analyse**|Erzeugt Syntaxbaum (AST) aus Tokens|
|
||||
|**Semantische Analyse**|Prüft Typen, ergänzt Typkonvertierungen, Symboltabelle wird erweitert|
|
||||
|**Zwischencode-Gen.**|Erzeugt maschinenunabhängigen Zwischencode (z. B. 3-Adress-Code)|
|
||||
|**Optimierung**|Vereinfachung & Effizienzsteigerung (lokal/global, konstante Faltung, tote Code-Elimination)|
|
||||
|**Codegenerator**|Übersetzt in Zielmaschinencode, Register- und Speicherzuweisung|
|
||||
|
||||
---
|
||||
|
||||
### 🔥 Optimierungstechniken
|
||||
|
||||
#### 🏃 Lokale Optimierungen (Basisblock)
|
||||
|
||||
- Gemeinsame Teilausdrücke eliminieren
|
||||
|
||||
- Toten Code entfernen
|
||||
|
||||
- Registernutzung reduzieren (Operandenumordnung)
|
||||
|
||||
- Kostenreduktion: Multiplikation → Addition ersetzen
|
||||
|
||||
|
||||
#### 🌎 Globale Optimierungen
|
||||
|
||||
- Registerzuteilung über mehrere Basisblöcke hinweg
|
||||
|
||||
- Schleifeninvariante Codebewegung
|
||||
|
||||
- Induktionsvariablen optimieren (i++ statt i = i+1)
|
||||
|
||||
|
||||
#### 📝 Beispiel (3-Adress-Code)
|
||||
|
||||
```c
|
||||
t1 = id3 * 60.0
|
||||
id1 = id2 + t1
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
### 🌳 Flussgraph & DAG
|
||||
|
||||
- **Grundblöcke:** Sequenzen ohne Sprünge
|
||||
|
||||
- **Flussgraph:** zeigt Steuerfluss zwischen Grundblöcken
|
||||
|
||||
- **DAG (Directed Acyclic Graph):** erkennt gemeinsame Teilausdrücke
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🔗 Binden & Laden
|
||||
|
||||
- **Relokation:** Anpassung der Adressen bei Modulzusammenführung
|
||||
|
||||
- **Dynamisches Binden:**
|
||||
|
||||
- Windows: DLLs (Dynamic Link Libraries)
|
||||
|
||||
- Unix: Shared Objects (.so)
|
||||
|
||||
- MULTICS: Prozeduradresse erst beim ersten Aufruf zugewiesen
|
||||
|
||||
|
||||
---
|
||||
|
||||
### ⚙️ Compiler Tools
|
||||
|
||||
|Tool|Aufgabe|
|
||||
|---|---|
|
||||
|`cc -E`|Preprocessing (Makros expandieren)|
|
||||
|`cc -S`|Erzeugt Assembler-Code|
|
||||
|`cc -c`|Erzeugt Objektcode|
|
||||
|`cc -o`|Linkt Objektcode zu ausführbarer Datei|
|
||||
|
||||
---
|
||||
|
||||
### 📚 Literatur
|
||||
|
||||
- **Dragon Book:** _Compilers: Principles, Techniques, and Tools_ (Aho, Sethi, Ullman, Lam)
|
||||
|
||||
- **Wirth:** _Compilerbau_
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📝 Für die Klausur merken
|
||||
|
||||
✅ Compiler-Phasen & deren Aufgaben
|
||||
✅ Unterschied Inline Assembler ↔ Compiler
|
||||
✅ Optimierungen: lokal (Basisblock), global (Flussgraph)
|
||||
✅ DAG & Flussgraph: Aufbau und Nutzen
|
||||
✅ Dynamisches Binden unter Windows/Unix
|
||||
✅ Tools & Compiler-Optionen (z. B. `cc -S`, `cc -c`)
|
||||
|
||||
---
|
||||
@@ -1,152 +0,0 @@
|
||||
## 📘 **Zusammenfassung: VB Zuverlässigkeit und Virtualität – Computerarchitektur**
|
||||
|
||||
---
|
||||
|
||||
### 🔒 **Zuverlässigkeit (Dependability)**
|
||||
|
||||
#### 🛑 Begriffe
|
||||
|
||||
- **Fault:** Fehler in einem Bauteil (temporär oder permanent)
|
||||
|
||||
- **Failure:** System liefert nicht die spezifizierte Leistung
|
||||
|
||||
- **MTTF (Mean Time To Failure):** mittlere Betriebsdauer bis zum Ausfall
|
||||
|
||||
- **MTTR (Mean Time To Repair):** mittlere Reparaturzeit
|
||||
|
||||
- **MTBF (Mean Time Between Failures):** MTTF+MTTRMTTF + MTTR
|
||||
|
||||
- **Verfügbarkeit (Availability):**
|
||||
|
||||
Availability=MTTFMTTF+MTTRAvailability = \frac{MTTF}{MTTF + MTTR}
|
||||
- Verbesserungen:
|
||||
|
||||
- **MTTF erhöhen:** Fehlervermeidung, Fehlertoleranz
|
||||
|
||||
- **MTTR verringern:** bessere Diagnose & Reparaturprozesse
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🧮 Fehlererkennung & Korrektur
|
||||
|
||||
#### ✅ Hamming-Codes
|
||||
|
||||
- **Hamming-Distanz 3:** Single Error Correction (SEC), Double Error Detection (DED)
|
||||
|
||||
- SEC/DED:
|
||||
|
||||
- Erkennt bis zu 2 Fehler
|
||||
|
||||
- Korrigiert einen Fehler
|
||||
|
||||
- ECC DRAM: Schützt 64 Bit mit zusätzlichen 8 Bit (insg. 72 Bit)
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🖥 Virtualisierung
|
||||
|
||||
#### 📦 Virtuelle Maschinen (VMs)
|
||||
|
||||
- Host-System emuliert Gastbetriebssystem & Hardware
|
||||
|
||||
- Vorteile:
|
||||
|
||||
- Isolation mehrerer Gäste
|
||||
|
||||
- Bessere Ressourcennutzung
|
||||
|
||||
- Sicherheit & Zuverlässigkeit
|
||||
|
||||
- Beispiele:
|
||||
|
||||
- **System-VMs:** VMware, VirtualBox
|
||||
|
||||
- **Language-VMs:** JavaVM
|
||||
|
||||
- **Container (lightweight):** Docker
|
||||
|
||||
|
||||
#### ⚙ Virtual Machine Monitor (VMM)
|
||||
|
||||
- Verwaltet die Zuordnung von virtuellen zu physischen Ressourcen
|
||||
|
||||
- Traps bei privilegierten Instruktionen
|
||||
|
||||
- Emuliert Timer & I/O-Geräte für Gäste
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🗺 Virtueller Speicher (Virtual Memory)
|
||||
|
||||
#### 🧱 Grundlagen
|
||||
|
||||
- Nutzt Hauptspeicher als Cache für Festplatte
|
||||
|
||||
- Programme erhalten eigenen **virtuellen Adressraum**
|
||||
|
||||
- **Page Table:** Zuordnung virtueller zu physischer Adressen
|
||||
|
||||
- **Page Fault:** Seite nicht im Speicher → OS lädt sie nach
|
||||
|
||||
|
||||
#### 🚀 Optimierungen
|
||||
|
||||
- **Translation Lookaside Buffer (TLB):** Cache für Seitentabelleneinträge
|
||||
|
||||
- **LRU (Least Recently Used):** Ersetzt selten genutzte Seiten
|
||||
|
||||
- **Write-Back Cache:** Schreibt geänderte Seiten nur bei Ersetzung zurück
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🔥 Speicherhierarchie & Multiprozessoren
|
||||
|
||||
#### 🏎 Cache-Kohärenz
|
||||
|
||||
- Problem: mehrere Caches → inkonsistente Daten
|
||||
|
||||
- Lösungen:
|
||||
|
||||
- **Snooping-Protokolle:** Caches überwachen Busaktivitäten
|
||||
|
||||
- **Directory-based Protokolle:** zentrale Verzeichnisse verwalten Status
|
||||
|
||||
- **Memory Consistency:** Sicherstellen, dass alle Prozessoren Änderungen sehen
|
||||
|
||||
|
||||
---
|
||||
|
||||
### ⚠️ Fallacies & Pitfalls
|
||||
|
||||
- Schlechte Speicherlokalität (z. B. Spaltenweise Iteration)
|
||||
|
||||
- Geringe Assoziativität bei vielen Kernen → Konfliktmisses
|
||||
|
||||
- VM-Implementierung auf ISAs ohne Virtualisierungs-Support erschwert
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📜 Fazit
|
||||
|
||||
✅ **Fast memories are small, large memories are slow → Memory Hierarchy mit Caching notwendig**
|
||||
✅ Zuverlässigkeit durch Fehlertoleranz & Fehlerkorrektur verbessern
|
||||
✅ Virtualisierung & Virtual Memory: Schlüsseltechnologien moderner Systeme
|
||||
✅ Multiprozessorsysteme benötigen Kohärenzprotokolle
|
||||
|
||||
---
|
||||
|
||||
### 📝 Für die Klausur merken
|
||||
|
||||
✅ Unterschied Fault ↔ Failure ↔ Error
|
||||
✅ Hamming-Codes: SEC/DED, ECC
|
||||
✅ Vorteile/Nachteile von Virtualisierung
|
||||
✅ Virtual Memory: Page Table, TLB, Page Fault Handling
|
||||
✅ Cache-Kohärenz: Snooping vs. Directory-Protokolle
|
||||
✅ Bedeutung von LRU & Write-Back Caches
|
||||
|
||||
---
|
||||
@@ -1,169 +0,0 @@
|
||||
## 📘 **Zusammenfassung: V2 Architekturen – Computerarchitektur**
|
||||
|
||||
### 🔄 Wiederholung Computergenerationen
|
||||
|
||||
- **0. Generation (bis 1945):** Mechanische Rechenmaschinen (Pascal, Leibniz, Babbage, Zuse)
|
||||
- **1. Generation (1945–1955):** Relais & Vakuumröhren – ENIAC, COLOSSUS, MANIAC
|
||||
- **2. Generation (1955–1965):** Transistoren – Minicomputer (PDP), Supercomputer (CDC 6600)
|
||||
- **3. Generation (1965–1980):** Integrierte Schaltungen – IBM System/360, PDP-11
|
||||
- **4. Generation (ab 1980):** VLSI – PCs, x86-Architektur
|
||||
- **5. Generation (heute):** Smartphones, Cloud, Embedded Systems
|
||||
|
||||
---
|
||||
|
||||
### 🚀 Moore’s Law (Moor’sches Gesetz)
|
||||
|
||||
- **Kerngedanke:** Verdopplung der Anzahl Transistoren pro IC alle 12–24 Monate.
|
||||
- Auswirkungen:
|
||||
- Kleinere Strukturen → geringere Kosten
|
||||
- Mehr Komponenten → höhere Leistung
|
||||
- > Resultierend: Geringerer Stromverbrauch
|
||||
- Aber: Miniaturisierung wird zunehmend teurer und schwieriger.
|
||||
|
||||
---
|
||||
|
||||
### 📊 Leistungsmessung von Computern
|
||||
|
||||
- **System-Benchmarks:** Cinebench, 3DMark, HPC Challenge
|
||||
- **Kenngrößen:**
|
||||
- Instruktionen/Sekunde (IPS), FLOPS (Floating point operations/second)
|
||||
- Taktzyklen pro Instruktion (CPI), Instruktionen pro Takt (IPC)
|
||||
- Speicherzugriffszeit, Durchsatz
|
||||
- Netzwerk- & Grafikleistung (FPS, TPS)
|
||||
- Kritik an MIPS: „Misleading Information to Promote Sales“ – nicht immer aussagekräftig. (MIPS => Million instructions per second)
|
||||
|
||||
---
|
||||
|
||||
### 🤖 Computer als endlicher Automat (Finite State Machine)
|
||||
|
||||
- **Zustände:** durch Bitmuster repräsentiert
|
||||
- **Operation:** Boolesche Funktion auf Teilzuständen
|
||||
- Vergleichbare Modelle:
|
||||
- Schaltnetz: keine Schleifen, keine Rückkopplung)
|
||||
- Endlicher Automat (Deterministisch und Nichtdeterministisch)
|
||||
- Kellerautomat (unendlich, aber Zugriff nur auf oberstes Element)(Hardwarelimitierungen?)
|
||||
- Turing-Maschine (endliche Zustände des Automaten, unendliches Band zum Lesen und Schreiben)
|
||||
![[Pasted image 20250708185128.png]]
|
||||
![[Pasted image 20250708185152.png]]
|
||||
![[Pasted image 20250708185618.png]]
|
||||
|
||||
---
|
||||
|
||||
### 🚌 Speicheranbindung & Endianness
|
||||
|
||||
- Speicheradressierung:
|
||||
- **big-endian:** höchstwertiges Byte an kleinster Adresse
|
||||
- **little-endian:** niedrigstwertiges Byte zuerst
|
||||
- Bus-System:
|
||||
- Bus-Takt meist langsamer als CPU-Takt
|
||||
- Cache als schneller Zwischenspeicher
|
||||
|
||||
---
|
||||
|
||||
### ⚙️ Aufbau von Computersystemen
|
||||
|
||||
#### Rechenwerk (ALU)
|
||||
|
||||
- Operationen: +, −, *, /, logische Operationen
|
||||
- Moderne CPUs: mehrere Register → direkte Register-Register-Operationen
|
||||
- Ältere CPUs: Akkumulator-Register für ALU-Operationen
|
||||
![[Pasted image 20250708185932.png]]****
|
||||
#### Steuerwerk
|
||||
- Verantwortlich für:
|
||||
- Ausführung der Befehle
|
||||
- Datenflusskontrolle
|
||||
- Ausnahmebehandlung & Interrupts
|
||||
|
||||
#### Register
|
||||
- Program Counter PC
|
||||
- Befehlsregister (Instruction Registers IR)
|
||||
- **optional**: Stackpointer SP
|
||||
- **Statusregister**: Zustandsregister, Flags usw.
|
||||
- Einfache CPUs haben einen speziellen Akkumulator-Register (Accu)
|
||||
- Aus diesem wird ein Wert gelesen
|
||||
- Ergebnis einer Operation wird hier gelagert
|
||||
- Moderne CPUs können nicht direkt Daten aus dem Hauptspeicher in das Rechenwerk lesen (Sicherheit oder warum?)
|
||||
|
||||
#### Bottleneck Datentransfer
|
||||
| Speichertyp | Geschwindigkeit |
|
||||
| -------------------- | -------------------- |
|
||||
| CPU Register | < Nanosekunde |
|
||||
| CPU Cache | ~wenige Nanosekunden |
|
||||
| Arbeitsspeicher | 60-70 Nanosekunden |
|
||||
| Sekundärspeicher SSD | 0,4 ms |
|
||||
| Sekundärspeicher HDD | 8-10 ms |
|
||||
|
||||
---
|
||||
|
||||
### 🧵 Befehlssatzarchitekturen (ISA)
|
||||
|
||||
**Befehle bestimmen die Architektur und umgekehrt**
|
||||
|
||||
#### 1️⃣ Stack-Architektur
|
||||
|
||||
- Operanden und Ergebnisse liegen auf Stack.
|
||||
- Benötigt Stack Pointer **SP Register**
|
||||
- Ergebnis wird final auf den Stack gelegt
|
||||
- Vorteile: kompakter Code, minimaler Prozessorzustand, sog. Null-Address Machine
|
||||
- Nachteil: viele Speicherzugriffe
|
||||
- Heute: nur noch in virtuellen Maschinen (JVM, p-Machine)
|
||||
|
||||
#### 2️⃣ Akkumulator-Architektur
|
||||
|
||||
- Ein Register (Akkumulator) für Operanden & Ergebnis
|
||||
- Speicherzugriff für zweiten Operand nötig
|
||||
- Kompakt, aber teuer durch Speicherzugriffe
|
||||
- **Ein-Adress-Maschine**
|
||||
|
||||
#### 3️⃣ Register-Memory-Architektur
|
||||
|
||||
- Mehrere Register, 2. Operand aus Speicher
|
||||
- Zwei-Adress-Befehle
|
||||
- Vorteil: direkt mit Speicher arbeiten
|
||||
- Nachteil: Speicherzugriffe kosten Zeit
|
||||
|
||||
#### 4️⃣ Register-Register (Load/Store)-Architektur
|
||||
|
||||
- Arithmetik nur auf Registern
|
||||
- Speicherzugriff explizit mit Load/Store
|
||||
- Drei-Adress-Befehle
|
||||
- Vorteil: keine unnötigen Speicherzugriffe
|
||||
- Nachteil: mehr Befehle nötig → größerer Code
|
||||
- Typisch für **RISC-Architekturen**
|
||||
|
||||
---
|
||||
|
||||
### 🔥 RISC vs CISC
|
||||
|
||||
| **Merkmal** | **RISC** | **CISC** |
|
||||
| --------------- | ----------------------------------- | ------------------------------- |
|
||||
| **Befehlssatz** | Einfach, einheitlich, kurze Befehle | Komplex, unterschiedliche Länge |
|
||||
| **Hardware** | Einfach, energieeffizient | Komplex oder Mikroprogramme |
|
||||
| **Codegröße** | Größer | Kompakter |
|
||||
| **Beispiele** | ARM, MIPS, SPARC, PowerPC | x86 (Intel, AMD), Zilog Z80 |
|
||||
| **Vorteile** | Schneller bei genügend Registern | Speichereffizient |
|
||||
| **Nachteile** | Mehr Programmspeicher nötig | Langsame komplexe Befehle |
|
||||
|
||||
Unterschied zwischen CISC und RISC CPUs – Gibt es Mischformen?
|
||||
|
||||
| ==Merkmal== | ==CISC (Complex Instruction Set Computer)== | ==RISC (Reduced Instruction Set Computer)== |
|
||||
| :--------------- | :------------------------------------------ | :------------------------------------------ |
|
||||
| Befehlssatz | Viele, komplexe Befehle | Wenige, einfache Befehle |
|
||||
| Hardwareaufbau | Komplexe Steuerlogik oder Mikroprogramme | Einfache, schnelle Hardware |
|
||||
| Befehlslänge | Unterschiedlich lang (z. B. 1–15 Byte) | Gleich lang (z. B. 4 Byte) |
|
||||
| Operationen | Direkt mit Speicher möglich | Nur mit Registern (Load/Store-Prinzip) |
|
||||
| Speicherbedarf | Geringer, da kompakter Code | Höher, da mehr Befehle nötig |
|
||||
| Energieeffizienz | Weniger effizient | Höher, da keine ungenutzten Logikblöcke |
|
||||
| Fokus | Effizienz bei Assembler-Programmierung | Optimierung für Compiler und Pipeline |
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📝 Für die Klausur merken
|
||||
|
||||
✅ Unterschiede der Architekturen (Stack, Akkumulator, Register-Memory, Load/Store)
|
||||
✅ RISC vs. CISC: Vor- und Nachteile + Beispiele
|
||||
✅ Endianness und Bedeutung bei Datentransfer
|
||||
✅ Moore’s Law und dessen Grenzen
|
||||
✅ Flaschenhals Speicherzugriff: Register > Cache > RAM > SSD > HDD
|
||||
|
||||
@@ -1,78 +0,0 @@
|
||||
## 📘 **Zusammenfassung: V3 Prozessor (Teil 1) – Computerarchitektur**
|
||||
|
||||
### 🧠 Einführung: CPU-Leistungsfaktoren
|
||||
|
||||
- **Instruction Count (IC):** Anzahl der Befehle → bestimmt durch ISA & Compiler\
|
||||
- **Cycles Per Instruction (CPI):** Anzahl der Takte pro Befehl → bestimmt durch Hardware\
|
||||
- **Cycle Time (CT):** Dauer eines Takts → bestimmt durch Hardware\
|
||||
- **CPU-Zeit Formel:**\
|
||||
CPU-Zeit=IC×CPI×CTCPU\text{-Zeit} = IC \times CPI \times CT
|
||||
|
||||
---
|
||||
|
||||
### 🔁 Ablauf der Instruktionsausführung
|
||||
|
||||
1. **Fetch:** Befehl aus Speicher laden (PC → Instruction Memory)\
|
||||
2. **Decode:** Register lesen, Operanden bestimmen\
|
||||
3. **Execute:** ALU berechnet Ergebnis oder Adresse\
|
||||
4. **Memory Access:** Speicherzugriff bei Load/Store\
|
||||
5. **Write Back:** Ergebnis ins Register zurückschreiben\
|
||||
6. **PC Update:** PC + 4 oder Sprungadresse\
|
||||
|
||||
---
|
||||
|
||||
### 🗂️ MIPS-Befehlssatz (Überblick)
|
||||
|
||||
#### 📦 Register
|
||||
|
||||
- 32 Register: z. B. `$s0-$s7`, `$t0-$t9`, `$zero` (immer 0), `$sp`, `$ra`\
|
||||
- Daten müssen in Register geladen werden, bevor ALU-Operationen möglich sind.\
|
||||
|
||||
#### 🛠️ Befehle
|
||||
![[Pasted image 20250708193917.png]]
|
||||
![[Pasted image 20250708193937.png]]
|
||||
---
|
||||
|
||||
### 🧮 Aufbau der CPU: Datenpfad (Datapath)
|
||||
|
||||
#### 🛠️ Bausteine
|
||||
|
||||
- **Register:** Speicherung von Zwischenwerten\
|
||||
- **ALU (Arithmetic Logic Unit):** führt Berechnungen durch\
|
||||
- **Multiplexer (MUX):** entscheidet zwischen Eingangsquellen\
|
||||
- **Memory:** Instruktions- & Datenspeicher\
|
||||
- **Control Unit:** steuert Datenfluss und Operationen\
|
||||
|
||||
#### 📐 Schrittweise Entwicklung
|
||||
|
||||
- **R-Typ Befehle:** nur Registeroperationen\
|
||||
- **Load/Store:** ALU berechnet Adresse, Speicherzugriff\
|
||||
- **Branch:** ALU-Vergleich → PC-Update bei Bedingung\
|
||||
|
||||
---
|
||||
|
||||
### 🔄 Taktgesteuerte Logik
|
||||
|
||||
- **Kombinatorische Elemente:** berechnen Ausgaben ohne Zustände\
|
||||
- **Sequenzielle Elemente (Register):** speichern Zustände, aktualisieren mit **Taktflanke**\
|
||||
- **Clocking Methodology:** Längste Verzögerung bestimmt Taktperiode.\
|
||||
|
||||
---
|
||||
|
||||
### 🔥 Besonderheiten MIPS
|
||||
|
||||
- **Load/Store Architektur:** Nur Load/Store greifen auf Speicher zu; alle anderen Befehle arbeiten mit Registern.\
|
||||
- **Einheitliche Befehlslänge (32 Bit):** vereinfacht Dekodierung.\
|
||||
- **Pipelining-Fähigkeit:** parallele Bearbeitung mehrerer Instruktionen möglich (kommt in Teil 2).\
|
||||
|
||||
---
|
||||
|
||||
### 📝 Für die Klausur merken
|
||||
|
||||
✅ CPU-Leistungsfaktoren & Formel
|
||||
✅ MIPS-Befehle (insbesondere `lw`, `sw`, `add`, `beq`, `j`)
|
||||
✅ Unterschied komb. Logik ↔ sequenzielle Logik
|
||||
✅ Aufbau des Datenpfades & Rolle der einzelnen Elemente
|
||||
✅ Load/Store-Prinzip (Register-Register-Arithmetik)
|
||||
|
||||
---
|
||||
@@ -1,66 +0,0 @@
|
||||
## 📘 **Zusammenfassung: V3a Von Schaltnetzen zu Endlichen Automaten**
|
||||
|
||||
### 🔌 Schaltnetze (Combinatorial Logic)
|
||||
|
||||
- **Merkmale:**
|
||||
- Keine Schleifen
|
||||
- Keine Rückkopplung
|
||||
- Keine Zustände (stateless)
|
||||
- Gleiche Eingabe → gleiche Ausgabe
|
||||
- Benötigt Zeit zur Ausgabeerzeugung (aber keinen Takt)
|
||||
- **Praxisbezug:** Einfache Logik wie Addierer, Multiplexer, Decoder sind Schaltnetze.
|
||||
|
||||
---
|
||||
|
||||
### 🔁 Endliche Automaten (Finite State Machines, FSM)
|
||||
|
||||
- **Merkmale:**
|
||||
- Schleifen und Rückkopplungen möglich
|
||||
- Zustände vorhanden (stateful)
|
||||
- Gleiche Eingabe kann unterschiedliche Ausgaben erzeugen – abhängig vom aktuellen Zustand
|
||||
- Braucht Zeit zur Ausgabeerzeugung
|
||||
- **Meist getaktet**, um Design und Analyse zu vereinfachen
|
||||
- **Praxisbezug:** Steuerwerke in Prozessoren sind typischerweise FSMs.
|
||||
|
||||
---
|
||||
|
||||
### 🕒 Vom Schaltnetz zum Endlichen Automaten
|
||||
|
||||
- Erweiterung von Schaltnetzen durch:
|
||||
1. **Flip-Flops** → Speichern von Zuständen
|
||||
2. **Getaktete Flip-Flops** → Synchronisation der Zustandsänderung
|
||||
3. **Flankengesteuerte Flip-Flops** → Reagieren nur auf steigende oder fallende Taktflanken
|
||||
- Ergebnis: **Deterministischer Endlicher Automat (DEA)** mit Taktsteuerung.
|
||||
|
||||
---
|
||||
|
||||
### 🔄 Struktur eines DEAs
|
||||
|
||||
- **Bestandteile:**
|
||||
- Zustandspeicher (z. B. Flip-Flops)
|
||||
- Kombinatorische Logik
|
||||
- Takt
|
||||
- **Ablauf:**
|
||||
- Kombinatorische Logik berechnet den nächsten Zustand aus aktuellem Zustand + Eingabe
|
||||
- Zustandspeicher aktualisiert sich bei Taktflanke
|
||||
- Ausgabe wird aus Zustand/Eingabe erzeugt
|
||||
|
||||
---
|
||||
|
||||
### ⏱️ Zeitliche Aspekte
|
||||
|
||||
- Jeder Schritt im Automaten braucht Zeit für:
|
||||
- Propagation durch die Logik
|
||||
- Synchronisation mit dem Takt
|
||||
- **Ohne Takt:** Asynchrone Schaltungen
|
||||
- **Mit Takt:** Syntaktische FSM → bevorzugt in modernen Prozessoren
|
||||
|
||||
---
|
||||
|
||||
### 📝 Für die Klausur merken
|
||||
|
||||
✅ Unterschied Schaltnetz ↔ Endlicher Automat
|
||||
✅ Rolle von Flip-Flops beim Speichern von Zuständen
|
||||
✅ DEA Aufbau: Zustandspeicher + Kombinatorische Logik + Takt
|
||||
✅ Flankengesteuerte Flip-Flops: warum wichtig?
|
||||
✅ Warum getaktete Automaten Analyse und Design erleichtern
|
||||
@@ -1,72 +0,0 @@
|
||||
## 📘 **Zusammenfassung: V4 Prozessor (Teil 2) – Computerarchitektur**
|
||||
|
||||
### 🔁 Wiederholung aus Teil 1
|
||||
|
||||
- **Instruktionstypen (MIPS):**
|
||||
- **R-Format:** arithmetische/logische Operationen (z. B. `add $s1,$s2,$s3`)
|
||||
- **Load/Store:** Speicherzugriff (z. B. `lw`, `sw`)
|
||||
- **Branch:** bedingte Sprünge (`beq`, `bne`)
|
||||
- **Datenpfad (Full Datapath):**
|
||||
- Register → ALU → Speicher → Register
|
||||
- Separate Instruktions- und Datenspeicher nötig, da ein Zugriff pro Zyklus
|
||||
|
||||
---
|
||||
|
||||
### ⚙️ Steuerungseinheit (Control Unit)
|
||||
|
||||
- **Erzeugt Steuersignale aus dem Opcode:**
|
||||
- **MemtoReg:** bestimmt Datenquelle für Register-Schreiben
|
||||
- **ALUSrc:** wählt ALU-Operand (Register vs. unmittelbarer Wert)
|
||||
- **RegWrite:** aktiviert Schreibzugriff auf Register
|
||||
- **MemRead/MemWrite:** steuern Speicherzugriffe
|
||||
- **Branch:** aktiviert bei bedingten Sprüngen
|
||||
- **ALU Control:**
|
||||
- Basierend auf Opcode und Funct-Feld
|
||||
- Beispiel Mapping:
|
||||
|
||||
| ALUOp | Funct | ALU-Funktion |
|
||||
| ----- | ------ | ------------ |
|
||||
| 00 | XXXXXX | `add` |
|
||||
| 01 | XXXXXX | `sub` |
|
||||
| 10 | 100000 | `add` |
|
||||
| 10 | 100010 | `sub` |
|
||||
| 10 | 100100 | `and` |
|
||||
| 10 | 100101 | `or` |
|
||||
| 10 | 101010 | `slt` |
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📦 Erweiterter Datenpfad
|
||||
|
||||
- Unterstützung für:
|
||||
- **Jumps (`j`, `jal`):**
|
||||
- PC-Update mit 26-Bit Zieladresse + oberen 4 Bit des alten PCs
|
||||
- Steuerleitung „Jump“ wird aus Opcode dekodiert
|
||||
- **Branches (`beq`, `bne`):**
|
||||
- Zieladresse berechnen (PC+4 + Offset << 2)
|
||||
- ALU prüft, ob Bedingung erfüllt (Zero-Flag)
|
||||
|
||||
---
|
||||
|
||||
### 🚨 Performance-Betrachtung
|
||||
|
||||
- **Ein-Zyklus-Datenpfad Problem:**
|
||||
- Längster Pfad (Critical Path) bestimmt Taktfrequenz
|
||||
- Beispiel: Load-Befehl → Instruktionsspeicher → Registerfile → ALU → Datenspeicher → Registerfile
|
||||
- Unterschiedliche Instruktionen hätten unterschiedliche Latenzen → nicht praktikabel
|
||||
- **Lösung:** **Pipelining**
|
||||
- Aufteilung des Datenpfads in Stufen
|
||||
- Überlappende Bearbeitung mehrerer Instruktionen
|
||||
|
||||
---
|
||||
|
||||
### 📝 Für die Klausur merken
|
||||
|
||||
✅ Steuersignale (MemtoReg, ALUSrc, RegWrite, Branch, Jump)
|
||||
✅ ALU Control Mapping (wie wird aus Opcode+Funct ALU-Funktion bestimmt?)
|
||||
✅ Erweiterung des Datenpfads für Jump/Branch
|
||||
✅ Problem des Ein-Zyklus-Datenpfads (Critical Path) → Motivation für Pipelining
|
||||
✅ Unterschied: Jump vs. Branch
|
||||
|
||||
---
|
||||
@@ -1,82 +0,0 @@
|
||||
## 📘 **Zusammenfassung: V5 Pipelining – Computerarchitektur**
|
||||
|
||||
### 🚀 Was ist Pipelining?
|
||||
|
||||
- **Prinzip:** Überlappende Ausführung mehrerer Instruktionen
|
||||
- **Analogie:** Waschstraße – mehrere Autos gleichzeitig in unterschiedlichen Phasen
|
||||
- **Ziel:** Erhöhung des Durchsatzes (mehr Befehle pro Zeiteinheit)
|
||||
- **Wichtig:** Latenz einzelner Instruktionen bleibt gleich
|
||||
|
||||
---
|
||||
|
||||
### 🔁 MIPS-Pipeline (5 Stufen)
|
||||
|
||||
|**Stufe**|**Name**|**Funktion**|
|
||||
|---|---|---|
|
||||
|1|IF (Instruction Fetch)|Befehl aus Speicher laden|
|
||||
|2|ID (Instruction Decode)|Dekodieren, Register lesen|
|
||||
|3|EX (Execute)|ALU-Berechnung, Adresse kalkulieren|
|
||||
|4|MEM (Memory Access)|Speicher lesen/schreiben|
|
||||
|5|WB (Write Back)|Ergebnis ins Register zurückschreiben|
|
||||
|
||||
---
|
||||
|
||||
### 📈 Performance-Vorteile
|
||||
|
||||
- **Single-Cycle Datapath:** 800 ps pro Befehl
|
||||
- **Pipelined Datapath:** 200 ps pro Befehl
|
||||
- **Theoretisches Speedup:** Anzahl Stufen = 5x schneller
|
||||
- **Realität:** Speedup < 5 wegen Hazard-Stalls und unbalancierter Stufen
|
||||
|
||||
---
|
||||
|
||||
### ⚠️ Hazards (Gefahren)
|
||||
|
||||
#### 🏗 Struktur-Hazards
|
||||
|
||||
- Konflikt um Ressource (z. B. Instruktions- und Datenspeicher gleichzeitig benötigt)
|
||||
- **Lösung:** Getrennte Instruktions-/Datenspeicher oder Caches
|
||||
|
||||
#### 📦 Daten-Hazards
|
||||
|
||||
- Instruktion benötigt Ergebnis der vorherigen Instruktion
|
||||
- Beispiel:
|
||||
```asm
|
||||
add $s0, $t0, $t1
|
||||
sub $t2, $s0, $t3
|
||||
```
|
||||
|
||||
- **Lösungen:**
|
||||
- **Forwarding (Bypassing):** Ergebnis direkt weiterleiten
|
||||
- **Stalls:** Pipeline anhalten
|
||||
- **Code Scheduling:** Befehle umsortieren, um Abhängigkeiten zu vermeiden
|
||||
|
||||
#### 🔁 Kontroll-Hazards
|
||||
|
||||
- Sprünge (`beq`, `bne`) → Ziel erst spät bekannt
|
||||
- **Lösungen:**
|
||||
- Warten bis Branch-Entscheidung (Stalls)
|
||||
- **Branch Prediction:**
|
||||
- **Static:** Vorwärts nicht nehmen, Rückwärts nehmen
|
||||
- **Dynamic:** Verlauf der Branches aufzeichnen und vorhersagen
|
||||
|
||||
---
|
||||
|
||||
### 📦 Optimierungen
|
||||
|
||||
- **Forwarding:** Verhindert unnötige Stalls
|
||||
- **Branch Prediction:** Reduziert Control Hazards
|
||||
- **Separate Speicher:** Löst Struktur-Hazards
|
||||
- **Code Scheduling:** Compiler verschiebt Befehle zur Vermeidung von Stalls
|
||||
|
||||
---
|
||||
|
||||
### 📝 Für die Klausur merken
|
||||
|
||||
✅ Pipeline-Stufen & ihre Aufgaben
|
||||
✅ Arten von Hazards + Lösungsstrategien (Forwarding, Prediction)
|
||||
✅ Unterschied Durchsatz ↔ Latenz
|
||||
✅ Warum MIPS-ISA besonders pipelining-freundlich ist
|
||||
✅ Unterschied Static ↔ Dynamic Branch Prediction
|
||||
|
||||
---
|
||||
@@ -1,161 +0,0 @@
|
||||
## 📘 **Zusammenfassung: V6 Pipelining Datapath and Control – Computerarchitektur**
|
||||
|
||||
### 🔁 Wiederholung: Pipelined Datapath
|
||||
|
||||
- **Pipeline-Register** zwischen Stufen speichern Zwischenergebnisse:
|
||||
|
||||
- IF/ID, ID/EX, EX/MEM, MEM/WB
|
||||
|
||||
- **Ziel:** jede Stufe arbeitet gleichzeitig an unterschiedlichen Instruktionen
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📦 Pipeline-Steuerung
|
||||
|
||||
- **Steuersignale** werden wie im Single-Cycle-Design aus dem Opcode abgeleitet.
|
||||
|
||||
- Vereinfachte & detaillierte Steuerung für jede Pipeline-Stufe:
|
||||
|
||||
- IF → ID → EX → MEM → WB
|
||||
|
||||
- Fehlerbehandlung und Hazard-Erkennung notwendig.
|
||||
|
||||
|
||||
---
|
||||
|
||||
### ⚠️ Data Hazards & Forwarding
|
||||
|
||||
#### 📦 Beispiel-Hazard
|
||||
|
||||
```asm
|
||||
sub $2, $1, $3 # Ergebnis wird in $2 geschrieben
|
||||
and $12, $2, $5 # liest $2 → Hazard
|
||||
or $13, $6, $2 # liest $2 → Hazard
|
||||
```
|
||||
|
||||
#### 🛠 Lösungen
|
||||
|
||||
- **Forwarding (Bypassing):**
|
||||
|
||||
- Ergebnis wird direkt aus EX/MEM oder MEM/WB weitergeleitet.
|
||||
|
||||
- **Forwarding-Bedingungen:**
|
||||
|
||||
- EX-Hazard (vorherige Instruktion schreibt):
|
||||
|
||||
```
|
||||
if EX/MEM.RegWrite && EX/MEM.RegisterRd ≠ 0
|
||||
&& EX/MEM.RegisterRd == ID/EX.RegisterRs
|
||||
→ ForwardA = 10
|
||||
```
|
||||
|
||||
- MEM-Hazard (vor-vorherige Instruktion schreibt):
|
||||
|
||||
```
|
||||
if MEM/WB.RegWrite && MEM/WB.RegisterRd ≠ 0
|
||||
&& MEM/WB.RegisterRd == ID/EX.RegisterRs
|
||||
→ ForwardA = 01
|
||||
```
|
||||
|
||||
- **Revised Forwarding:** MEM-Forwarding nur, wenn kein EX-Hazard.
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🔁 Load-Use Hazard
|
||||
|
||||
- Auftritt, wenn Instruktion direkt nach einem Load das geladene Register benötigt.
|
||||
|
||||
- **Lösung:** 1-Stall-Cycle (Bubble) einfügen.
|
||||
|
||||
- Erkennung:
|
||||
|
||||
```
|
||||
if ID/EX.MemRead &&
|
||||
(ID/EX.RegisterRt == IF/ID.RegisterRs ||
|
||||
ID/EX.RegisterRt == IF/ID.RegisterRt)
|
||||
→ Stall
|
||||
```
|
||||
|
||||
|
||||
---
|
||||
|
||||
### ⏱ Stalls & Bubbles
|
||||
|
||||
- **Bubble:** NOP wird in die Pipeline eingefügt
|
||||
|
||||
- PC und IF/ID-Register werden nicht aktualisiert (Pipeline pausiert)
|
||||
|
||||
- Compiler kann Code oft umsortieren, um Stalls zu vermeiden.
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🔥 Branch Hazards & Lösungen
|
||||
|
||||
#### ⏳ Problem:
|
||||
|
||||
- Branch-Entscheidung erst in MEM-Stufe bekannt → falsche Befehle im IF
|
||||
|
||||
|
||||
#### 🛠 Lösungen:
|
||||
|
||||
1. **Early Branch Resolution:**
|
||||
|
||||
- Zieladresse & Vergleich schon in ID berechnen
|
||||
|
||||
2. **Flush Pipeline:**
|
||||
|
||||
- Falls Branch genommen → falsche Instruktionen entfernen
|
||||
|
||||
3. **Branch Prediction:**
|
||||
|
||||
- **Static Prediction:**
|
||||
|
||||
- Rückwärts: taken (Schleifen)
|
||||
|
||||
- Vorwärts: not taken
|
||||
|
||||
- **Dynamic Prediction:**
|
||||
|
||||
- **1-Bit Predictor:** einfache Historie
|
||||
|
||||
- **2-Bit Predictor:** robuster gegen wiederholte Fehleinschätzungen
|
||||
|
||||
- **Branch Target Buffer (BTB):**
|
||||
|
||||
- Cache für Zieladressen
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📐 Visualisierung
|
||||
|
||||
- **Multi-Cycle-Diagramme:** Ressourcen-Nutzung über Zeit
|
||||
|
||||
- **Single-Cycle-Diagramme:** Pipeline-Zustand zu einem Takt
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📊 Performance-Effekte
|
||||
|
||||
- Forwarding & Prediction minimieren Stalls
|
||||
|
||||
- Dennoch: Stalls notwendig für Korrektheit
|
||||
|
||||
- Compiler kann helfen: **Instruction Scheduling**
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📝 Für die Klausur merken
|
||||
|
||||
✅ Pipeline-Register & ihre Funktion
|
||||
✅ Forwarding vs. Stalling: Bedingungen & Hardwarelogik
|
||||
✅ Load-Use Hazard: Erkennung & Behebung
|
||||
✅ Branch Hazards: Static & Dynamic Prediction, BTB
|
||||
✅ Unterschied Multi- und Single-Cycle-Diagramme
|
||||
|
||||
---
|
||||
@@ -1,139 +0,0 @@
|
||||
## 📘 **Zusammenfassung: V7 Pipelining – Exceptions, Interrupts & Instruction-Level Parallelism (ILP)**
|
||||
|
||||
---
|
||||
|
||||
### ⚡ Exceptions & Interrupts
|
||||
|
||||
#### 🛑 Was sind Exceptions?
|
||||
|
||||
- Unerwartete Ereignisse **innerhalb der CPU**
|
||||
|
||||
- Beispiele: undefined opcode, overflow, syscall
|
||||
|
||||
- **MIPS:** Verwaltet durch Coprozessor (CP0)
|
||||
|
||||
- Speichert PC der verursachenden Instruktion in **EPC (Exception Program Counter)**
|
||||
|
||||
- Speichert Ursache im **Cause Register**
|
||||
|
||||
- Springt zu Exception Handler (z. B. Adresse `0x8000 0180`)
|
||||
|
||||
|
||||
#### 📡 Was sind Interrupts?
|
||||
|
||||
- Unerwartete Ereignisse **von außen** (z. B. I/O-Geräte)
|
||||
|
||||
- Unterschiedliche ISAs verwenden „Exception“ & „Interrupt“ teilweise synonym.
|
||||
|
||||
|
||||
#### 🚦 Exception-Handling im Pipeline-Design
|
||||
|
||||
- Ähnlich wie ein Branch-Misprediction:
|
||||
|
||||
- Vorherige Instruktionen abschließen
|
||||
|
||||
- Verursachende & folgende Instruktionen flushen
|
||||
|
||||
- Kontrolle an den Handler übergeben
|
||||
|
||||
|
||||
#### 🔄 Restartable vs. Imprecise Exceptions
|
||||
|
||||
- **Restartable:** Handler beendet und springt zurück zur Instruktion (EPC)
|
||||
|
||||
- **Imprecise:** Pipeline stoppt, mehrere Exceptions gespeichert → Handler entscheidet, was zu tun ist
|
||||
|
||||
- Schwieriger bei Out-of-Order-Pipelines
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🚀 Instruction-Level Parallelism (ILP)
|
||||
|
||||
#### 📊 Ziel: Mehrere Instruktionen gleichzeitig ausführen
|
||||
|
||||
- **Pipelining:** 1 Instruktion pro Stufe, mehrere gleichzeitig aktiv
|
||||
|
||||
- **Deeper Pipeline:** kürzere Takte, aber mehr Stalls möglich
|
||||
|
||||
- **Multiple Issue:** mehrere Instruktionen pro Takt starten
|
||||
|
||||
- **Static Multiple Issue (VLIW):**
|
||||
|
||||
- Compiler bildet „issue packets“ (mehrere Instruktionen pro Takt)
|
||||
|
||||
- Beispiel: Dual-Issue MIPS (1 ALU/Branch + 1 Load/Store)
|
||||
|
||||
- Compiler-Scheduling nötig
|
||||
|
||||
- **Dynamic Multiple Issue (Superscalar):**
|
||||
|
||||
- CPU entscheidet zur Laufzeit, wie viele Instruktionen pro Takt gestartet werden
|
||||
|
||||
- Vorteil: weniger Compiler-Arbeit
|
||||
|
||||
- Herausforderung: Hazards und Ressourcen-Konflikte vermeiden
|
||||
|
||||
|
||||
#### 🧠 Speculation
|
||||
|
||||
- **Prinzip:** Vermuten, welche Instruktionen ausgeführt werden können
|
||||
|
||||
- **Branch Speculation:** Vorhersage der Sprungrichtung
|
||||
|
||||
- **Load Speculation:** vorzeitiges Laden von Speicherwerten
|
||||
|
||||
- Bei falscher Vermutung: Rollback & korrekt ausführen
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🔄 Dynamisches Scheduling
|
||||
|
||||
- CPU führt Instruktionen **out of order** aus, um Stalls zu vermeiden
|
||||
|
||||
- Ergebnisse werden **in order committed** (Reorder Buffer)
|
||||
|
||||
- **Register Renaming:**
|
||||
|
||||
- Verhindert falsche Abhängigkeiten (WAW & WAR)
|
||||
|
||||
- Ermöglicht parallele Nutzung derselben logischen Register
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📈 Herausforderungen für ILP
|
||||
|
||||
- **Abhängigkeiten:**
|
||||
|
||||
- Datenabhängigkeit (true dependency)
|
||||
|
||||
- Kontrollabhängigkeit (branches)
|
||||
|
||||
- Ressourcenabhängigkeit (strukturelle Konflikte)
|
||||
|
||||
- **Compiler-Limitationen:**
|
||||
|
||||
- Pointer-Aliasing erschwert statische Analyse
|
||||
|
||||
- **Hardware-Limitationen:**
|
||||
|
||||
- Fenstergröße für dynamisches Scheduling begrenzt
|
||||
|
||||
- Cache-Misses & Speicherbandbreite begrenzen Parallelität
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📝 Für die Klausur merken
|
||||
|
||||
✅ Unterschied Exception ↔ Interrupt
|
||||
✅ EPC & Cause-Register im MIPS-Handling
|
||||
✅ Restartable vs. Imprecise Exceptions
|
||||
✅ VLIW vs. Superscalar (Static vs. Dynamic Multiple Issue)
|
||||
✅ Speculation: was passiert bei falscher Vorhersage?
|
||||
✅ Register Renaming: warum wichtig?
|
||||
✅ Warum ILP in der Praxis nicht beliebig steigerbar ist
|
||||
|
||||
---
|
||||
@@ -1,110 +0,0 @@
|
||||
## 📘 **Zusammenfassung: V8a Intel und Arm – Computerarchitektur**
|
||||
|
||||
---
|
||||
|
||||
### ⚡ Power Efficiency: ARM vs. Intel
|
||||
|
||||
||**ARM Cortex-A8**|**Intel Core i7-920**|
|
||||
|---|---|---|
|
||||
|Markt|Mobile Devices|Server, Desktop|
|
||||
|TDP (Thermal Power)|2 W|130 W|
|
||||
|Taktfrequenz|1 GHz|2,66 GHz|
|
||||
|Kerne pro Chip|1|4|
|
||||
|Floating Point Unit|Nein|Ja|
|
||||
|Multiple Issue|Statisch, in-order|Dynamisch, OoO + Spec.|
|
||||
|Pipeline-Stufen|14|14|
|
||||
|Branch Prediction|2-Level|2-Level|
|
||||
|L1 Cache|32 KB I, 32 KB D|32 KB I, 32 KB D|
|
||||
|L2 Cache|128–1024 KB|256 KB|
|
||||
|L3 Cache|-|2–8 MB (shared)|
|
||||
|Max Instr/Takt|2|4|
|
||||
|
||||
---
|
||||
|
||||
### 🔄 Pipelines im Vergleich
|
||||
|
||||
#### ARM Cortex-A8
|
||||
|
||||
- Pipeline: Statisch geplante Ausführung (in-order)
|
||||
|
||||
- Einfachere Hardware → energieeffizient
|
||||
|
||||
- Optimiert für mobile Geräte
|
||||
|
||||
|
||||
#### Intel Core i7
|
||||
|
||||
- Pipeline: Dynamisch, out-of-order, mit Speculation
|
||||
|
||||
- Komplexere Hardware → höherer Energiebedarf
|
||||
|
||||
- Optimiert für High-Performance-Anwendungen
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🧮 Instruction-Level Parallelism (ILP)
|
||||
|
||||
#### 💡 Multiple Issue:
|
||||
|
||||
- ARM: **Statische Planung** (Compiler entscheidet Reihenfolge)
|
||||
|
||||
- Intel: **Dynamische Planung** (CPU entscheidet zur Laufzeit)
|
||||
|
||||
- Dynamische Planung bietet bessere Ausnutzung, aber höheren Hardwareaufwand.
|
||||
|
||||
|
||||
#### 🛠 Matrix-Multiplikation (Beispiel)
|
||||
|
||||
- **C-Code (mit Loop Unrolling & SIMD):**
|
||||
|
||||
- Nutzt AVX-Befehle (_mm256)
|
||||
|
||||
- **Assembly-Code:**
|
||||
|
||||
- Parallele Berechnungen mit YMM-Registers (256-Bit)
|
||||
|
||||
- Beispiel: `vmulpd`, `vaddpd`, `vbroadcastsd`
|
||||
|
||||
|
||||
---
|
||||
|
||||
### ⚠️ Fallacies & Pitfalls
|
||||
|
||||
#### 🚧 Irrtümer
|
||||
|
||||
- **„Pipelining ist einfach“:** Nur die Grundidee ist einfach, Details (Hazard Detection, Forwarding) sind komplex.
|
||||
|
||||
- **„Pipelining ist unabhängig von Technologie“:** Fortschritte in Halbleitern machten es erst praktikabel.
|
||||
|
||||
|
||||
#### 💥 Probleme
|
||||
|
||||
- Komplexe ISAs (z. B. x86) erschweren effiziente Pipeline-Implementierung.
|
||||
|
||||
- **Delayed Branches:** erhöhen Designaufwand
|
||||
|
||||
- **IA-32 Micro-Op-Ansatz:** wandelt komplexe Instruktionen in einfache Mikro-Operationen um
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📜 Fazit
|
||||
|
||||
✅ ISA-Design beeinflusst Datapath- und Steuerwerk-Design – und umgekehrt
|
||||
✅ Pipelining steigert Durchsatz, nicht Latenz
|
||||
✅ Hazards (structural, data, control) sind zentrale Herausforderungen
|
||||
✅ ILP steigert Parallelität, aber nur begrenzt durch Abhängigkeiten
|
||||
✅ Komplexität → Energieverbrauch (Power Wall)
|
||||
|
||||
---
|
||||
|
||||
### 📝 Für die Klausur merken
|
||||
|
||||
✅ Unterschied ARM ↔ Intel (In-order vs. OoO, TDP, Pipelines)
|
||||
✅ Statische vs. Dynamische Planung
|
||||
✅ Vor- & Nachteile von ILP und Multiple Issue
|
||||
✅ Fallacies (Irrtümer) beim Pipelining-Design
|
||||
✅ Warum einfache ISAs (RISC) Pipelines erleichtern
|
||||
|
||||
---
|
||||
@@ -1,160 +0,0 @@
|
||||
## 📘 **Zusammenfassung: V8b Speicheranbindung – Computerarchitektur**
|
||||
|
||||
---
|
||||
|
||||
### 🚨 Bottleneck: Speicher
|
||||
|
||||
- CPU-Leistung steigt schneller als Speicherleistung → **Memory Wall**
|
||||
|
||||
- Lösung: **Speicherhierarchie**
|
||||
|
||||
- Nutzt das **Prinzip der Lokalität**
|
||||
|
||||
- **Zeitliche Lokalität:** kürzlich verwendete Daten werden bald wieder benötigt
|
||||
|
||||
- **Räumliche Lokalität:** benachbarte Daten werden bald benötigt
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🏛 Speicherhierarchie
|
||||
|
||||
|Ebene|Beispiel|Größe|Geschwindigkeit|
|
||||
|---|---|---|---|
|
||||
|Register|CPU-Register|Bytes|ns|
|
||||
|L1-Cache|SRAM|KB|~1 ns|
|
||||
|L2/L3-Cache|SRAM|MB|~10 ns|
|
||||
|Hauptspeicher|DRAM|GB|~100 ns|
|
||||
|Sekundärspeicher|SSD/HDD|TB|ms|
|
||||
|
||||
- **Hit:** Zugriff erfolgreich in oberer Ebene
|
||||
|
||||
- **Miss:** Daten müssen aus unterer Ebene geholt werden (Miss Penalty)
|
||||
|
||||
- **Miss Ratio = 1 – Hit Ratio**
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 💾 Speichertechnologien
|
||||
|
||||
- **SRAM:** schnell, teuer, klein → Caches
|
||||
|
||||
- **DRAM:** langsamer, günstiger, groß → Hauptspeicher
|
||||
|
||||
- **DDR, QDR:** Transfers auf steigender & fallender Flanke
|
||||
|
||||
- **Flash (EEPROM):** nicht-flüchtig, schneller als HDD, aber begrenzte Lebensdauer
|
||||
|
||||
- **NOR-Flash:** Random Access, Embedded Systems
|
||||
|
||||
- **NAND-Flash:** Blockweise Zugriff, USB, SSDs
|
||||
|
||||
- **Magnetische Platten (HDD):** große Kapazität, langsamer Zugriff
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📦 Cache-Grundlagen
|
||||
|
||||
#### 📌 Organisation
|
||||
|
||||
- **Direct-Mapped Cache:** 1 Block pro Adresse
|
||||
|
||||
- **Set-Associative Cache:** mehrere mögliche Plätze pro Block
|
||||
|
||||
- **Fully-Associative Cache:** jeder Block kann überall hin
|
||||
|
||||
|
||||
#### 📌 Komponenten
|
||||
|
||||
- **Tag:** identifiziert Block
|
||||
|
||||
- **Valid-Bit:** zeigt an, ob Block gültig ist
|
||||
|
||||
- **Replacement Policies:**
|
||||
|
||||
- LRU (Least Recently Used)
|
||||
|
||||
- Random
|
||||
|
||||
|
||||
#### 📌 Schreibstrategien
|
||||
|
||||
- **Write-Through:** gleichzeitiges Schreiben in Cache & Speicher
|
||||
|
||||
- - Einfach
|
||||
|
||||
- – Langsam, Lösung: Write Buffer
|
||||
|
||||
- **Write-Back:** Schreiben nur bei Block-Verdrängung
|
||||
|
||||
- - Schnell
|
||||
|
||||
- – Komplexer (dirty-bit notwendig)
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🏎 Cache-Performance
|
||||
|
||||
- **Miss Types:**
|
||||
|
||||
- **Compulsory:** erste Referenz
|
||||
|
||||
- **Capacity:** Cache zu klein
|
||||
|
||||
- **Conflict:** Set-Associative Caches
|
||||
|
||||
- **Formeln:**
|
||||
|
||||
- **AMAT (Average Memory Access Time):**
|
||||
|
||||
AMAT=HitTime+MissRate×MissPenaltyAMAT = HitTime + MissRate × MissPenalty
|
||||
- **Effective CPI:**
|
||||
|
||||
CPIeff=CPIbase+MemoryStallsCPI_{eff} = CPI_{base} + MemoryStalls
|
||||
|
||||
---
|
||||
|
||||
### 🔥 Optimierungen
|
||||
|
||||
#### 🪜 Multilevel-Caches
|
||||
|
||||
- **L1:** klein & schnell, Fokus auf kurze Zugriffszeit
|
||||
|
||||
- **L2/L3:** größer, Fokus auf niedrige Missrate
|
||||
|
||||
|
||||
#### 📐 Cache Blocking (Beispiel DGEMM)
|
||||
|
||||
- Matrix-Multiplikation optimiert durch Blockierung → bessere Cache-Nutzung
|
||||
|
||||
- Vermeidet Cache-Pollution & reduziert Misses
|
||||
|
||||
|
||||
```c
|
||||
#define BLOCKSIZE 32
|
||||
for (sj = 0; sj < n; sj += BLOCKSIZE)
|
||||
for (si = 0; si < n; si += BLOCKSIZE)
|
||||
for (sk = 0; sk < n; sk += BLOCKSIZE)
|
||||
do_block(n, si, sj, sk, A, B, C);
|
||||
```
|
||||
|
||||
#### 🚀 Software-Optimierung
|
||||
|
||||
- Compiler & Algorithmus-Anpassung nutzen Lokalität besser aus
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 📝 Für die Klausur merken
|
||||
|
||||
✅ Prinzip der Lokalität (zeitlich & räumlich)
|
||||
✅ Speicherhierarchie & typische Zugriffszeiten
|
||||
✅ Direct-Mapped vs. Set-Associative vs. Fully-Associative
|
||||
✅ Write-Through vs. Write-Back + Vor- & Nachteile
|
||||
✅ AMAT-Formel und Cache-Performance-Berechnungen
|
||||
✅ Cache Blocking bei DGEMM (Grundidee)
|
||||
|
||||
---
|
||||
@@ -1,129 +0,0 @@
|
||||
## 📘 **Zusammenfassung: V9 Assembler – Computerarchitektur**
|
||||
|
||||
---
|
||||
|
||||
### 🏷 Begriffsklärungen
|
||||
|
||||
|Begriff|Bedeutung|
|
||||
|---|---|
|
||||
|**Assembler**|Programm, das Assemblersprache in Maschinensprache übersetzt|
|
||||
|**Assemblersprache**|Maschinennahe Programmiersprache mit 1:1-Abbildung auf Maschinenbefehle|
|
||||
|**Cross-Assembler**|Läuft auf Host-System, erzeugt Maschinencode für Target-System|
|
||||
|**Disassembler**|Rückübersetzt Maschinencode in Assembler (Bezeichner, Kommentare gehen meist verloren)|
|
||||
|**Macro-Assembler**|Unterstützt Makros zur Vereinfachung wiederkehrender Befehlssequenzen|
|
||||
|**Pseudobefehl**|Befehl für den Assembler, der im Maschinencode aus mehreren echten Instruktionen besteht|
|
||||
|
||||
---
|
||||
|
||||
### 🎯 Vorteile von Assemblersprache
|
||||
|
||||
✅ Direkter Zugriff auf alle Merkmale der Hardware
|
||||
✅ Sehr kompakter & schneller Code möglich
|
||||
✅ Zeitkritische Routinen exakt steuerbar
|
||||
✅ Besseres Verständnis der Prozessorarchitektur
|
||||
|
||||
---
|
||||
|
||||
### ⚠️ Nachteile von Assemblersprache
|
||||
|
||||
❌ Schwierige Programmierung & Wartung
|
||||
❌ Zeitaufwändig, keine modernen Programmierkonzepte
|
||||
❌ Hardwareabhängig (nicht portabel)
|
||||
👉 **Kompromiss:** Inline-Assembler in Hochsprachen für kritische Teile
|
||||
|
||||
---
|
||||
|
||||
### 🖥️ MASM (Microsoft Macro Assembler)
|
||||
|
||||
- Verwendet für x86-Architektur
|
||||
|
||||
- Teil von Microsoft Visual Studio
|
||||
|
||||
- **Anweisungsformat:**
|
||||
|
||||
```
|
||||
[Label] Opcode Operanden ; Kommentar
|
||||
```
|
||||
|
||||
- **Pseudobefehle:** Anweisungen an den Assembler, nicht an die CPU
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🔁 Makros
|
||||
|
||||
- **Makrodefinition:** wie eine Inline-Funktion
|
||||
|
||||
- **Makroaufruf:** Ersetzung durch Makro-Rumpf
|
||||
|
||||
- **Mit Parametern:** ermöglicht Wiederverwendung mit unterschiedlichen Werten
|
||||
|
||||
- Vorteil ggü. Prozeduraufruf: kein Overhead durch Call/Return
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🏃 Zwei-Pass-Assembler
|
||||
|
||||
#### 1️⃣ Erster Lauf
|
||||
|
||||
- Aufbau von Tabellen:
|
||||
|
||||
- **Symboltabelle:** Marken, Adressen
|
||||
|
||||
- **Opcode-Tabelle:** Mnemonics & Binärcode
|
||||
|
||||
- **Pseudobefehlstabelle**
|
||||
|
||||
- Berechnung der **Instruction Location Counter (ILC)**
|
||||
|
||||
|
||||
#### 2️⃣ Zweiter Lauf
|
||||
|
||||
- Übersetzung in Maschinencode
|
||||
|
||||
- Nutzung der Symboltabelle für Adressauflösungen
|
||||
|
||||
- Erzeugung des Objektprogramms
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🔗 Binden (Linking) & Laden
|
||||
|
||||
- **Linker-Aufgaben:**
|
||||
|
||||
- Erstellen des virtuellen Adressraums
|
||||
|
||||
- Auflösen externer Referenzen
|
||||
|
||||
- Relokation (Anpassung der Speicheradressen)
|
||||
|
||||
- **Relokationsregister:** Hardware fügt Startadresse hinzu
|
||||
|
||||
- **Paging:** nur Seitentabelle wird geändert
|
||||
|
||||
|
||||
---
|
||||
|
||||
### 🌐 Dynamisches Binden (Dynamic Linking)
|
||||
|
||||
|Plattform|Mechanismus|
|
||||
|---|---|
|
||||
|**MULTICS**|Linkage-Segment mit Prozedur-Infos, Ausnahmebehandlung beim ersten Aufruf|
|
||||
|**Windows**|DLLs (Dynamic Link Libraries), Implicit & Explicit Linking|
|
||||
|**Unix**|Shared Libraries (SO-Dateien)|
|
||||
|
||||
---
|
||||
|
||||
### 📝 Für die Klausur merken
|
||||
|
||||
✅ Unterschied Assembler ↔ Compiler
|
||||
✅ Vor- & Nachteile Assemblersprache
|
||||
✅ Zwei-Pass-Assembler: Ablauf & Tabellen
|
||||
✅ Unterschied Pseudobefehl ↔ echter Maschinenbefehl
|
||||
✅ Makros: Definition, Aufruf, Parameter
|
||||
✅ Linker-Aufgaben: Relokation, externe Referenzen
|
||||
✅ Dynamisches Binden: Windows (DLL), Unix (SO)
|
||||
|
||||
---
|
||||
@@ -1,167 +0,0 @@
|
||||
## 📘 **Kompaktes Lernskript: Computerarchitektur (alle 13 Vorlesungen)**
|
||||
|
||||
---
|
||||
|
||||
### **1️⃣ Einführung – Computerarchitektur**
|
||||
|
||||
- **Computerarchitektur**: Sicht des Programmierers (ISA, Speicher, I/O)
|
||||
- **Computerorganisation**: Umsetzung auf Hardware-Ebene (Mikroarchitektur)
|
||||
- **Von-Neumann-Architektur**:
|
||||
- Gemeinsamer Speicher für Daten & Programme
|
||||
- Vorteil: Einfachheit; Nachteil: Von-Neumann-Flaschenhals
|
||||
- **Harvard-Architektur**:
|
||||
- Trennung von Daten- und Programmspeicher
|
||||
- **Abstraktionsebenen**:
|
||||
- Ebene 0: Digitale Logik
|
||||
- Ebene 1: Mikroarchitektur
|
||||
- Ebene 2: ISA
|
||||
- Ebene 3: Betriebssystem
|
||||
- Ebene 4: Assemblersprache
|
||||
- Ebene 5: Hochsprachen
|
||||
- **Historie**: Zuse Z3 → ENIAC → IBM System/360 → Intel 4004 → ARM
|
||||
|
||||
---
|
||||
|
||||
### **2️⃣ Architekturen**
|
||||
|
||||
- **RISC vs. CISC**:
|
||||
|
||||
|Merkmal|RISC|CISC|
|
||||
|---|---|---|
|
||||
|Befehlssatz|Einfach, gleich lang|Komplex, unterschiedliche Länge|
|
||||
|Hardware|Einfach|Komplex|
|
||||
|Beispiele|ARM, MIPS|x86 (Intel, AMD)|
|
||||
|
||||
- **Befehlssatztypen**:
|
||||
- Stack, Akkumulator, Register-Memory, Load/Store
|
||||
- **Moore’s Law**: Verdopplung der Transistorzahl alle ~18 Monate
|
||||
- **Leistungskennzahlen**: MIPS, FLOPS, CPI, IPC
|
||||
|
||||
---
|
||||
|
||||
### **3️⃣ Schaltnetze & Endliche Automaten**
|
||||
|
||||
- **Schaltnetz**: stateless, keine Rückkopplung
|
||||
- **Endlicher Automat (FSM)**: stateful, mit Rückkopplung
|
||||
- **Flip-Flops**: Zustandspeicher, getaktet
|
||||
- **DEA**: Zustandslogik + Zustandspeicher + Takt
|
||||
|
||||
---
|
||||
|
||||
### **4️⃣ Prozessor (Teil 1)**
|
||||
|
||||
- **MIPS-ISA**:
|
||||
- R-Typ: `add $s1, $s2, $s3`
|
||||
- Load/Store: `lw`, `sw`
|
||||
- Branch: `beq`, `bne`
|
||||
- **CPU-Leistungsformel**:
|
||||
CPU-Zeit=IC×CPI×CTCPU\text{-Zeit} = IC \times CPI \times CT
|
||||
- **Datenpfad-Bausteine**: ALU, Registerfile, Steuerwerk
|
||||
|
||||
---
|
||||
|
||||
### **5️⃣ Prozessor (Teil 2)**
|
||||
|
||||
- **Steuersignale**:
|
||||
- MemtoReg, RegWrite, ALUSrc, Branch, Jump
|
||||
- **ALU Control**: Bestimmt Operation aus Opcode + Funct
|
||||
- **Erweiterter Datenpfad**: Unterstützung für Jumps & Branches
|
||||
|
||||
---
|
||||
|
||||
### **6️⃣ Pipelining**
|
||||
|
||||
- **5 Pipeline-Stufen**: IF → ID → EX → MEM → WB
|
||||
- **Vorteil**: Erhöhter Durchsatz, gleiche Latenz
|
||||
- **Hazards**:
|
||||
- **Strukturell**
|
||||
- **Datenhazards**: Forwarding, Stalls
|
||||
- **Kontrollhazards**: Branch Prediction (Static/Dynamic)
|
||||
|
||||
---
|
||||
|
||||
### **7️⃣ Pipelining: Datapath & Control**
|
||||
|
||||
- **Forwarding**: Bypassing von EX/MEM, MEM/WB
|
||||
- **Load-Use Hazard**: 1-Stall einfügen
|
||||
- **Branch Prediction**:
|
||||
- 1-Bit, 2-Bit Predictors
|
||||
- Branch Target Buffer (BTB)
|
||||
|
||||
---
|
||||
|
||||
### **8️⃣ Pipelining: Exceptions, Interrupts & ILP**
|
||||
|
||||
- **Exceptions**: Fehler innerhalb CPU → EPC speichert PC
|
||||
- **Interrupts**: externe Ereignisse
|
||||
- **ILP**:
|
||||
- **Static (VLIW)** vs. **Dynamic (Superscalar)**
|
||||
- **Speculation**: Branch & Load Speculation
|
||||
- **Register Renaming**: Verhindert WAW & WAR
|
||||
|
||||
---
|
||||
|
||||
### **9️⃣ Intel vs. ARM**
|
||||
|
||||
|Feature|ARM Cortex-A8|Intel Core i7|
|
||||
|---|---|---|
|
||||
|Planung|Statisch, in-order|Dynamisch, out-of-order|
|
||||
|TDP|2 W|130 W|
|
||||
|Max Instr./Takt|2|4|
|
||||
|
||||
---
|
||||
|
||||
### **🔟 Speicheranbindung**
|
||||
|
||||
- **Speicherhierarchie**: Register → Cache → RAM → SSD/HDD
|
||||
- **Caches**:
|
||||
- Direct-Mapped, Set-Associative, Fully-Associative
|
||||
- Write-Through vs. Write-Back
|
||||
- **AMAT**:
|
||||
AMAT=HitTime+MissRate×MissPenaltyAMAT = HitTime + MissRate \times MissPenalty
|
||||
- **Cache Blocking**: Optimiert Speicherzugriffe
|
||||
|
||||
---
|
||||
|
||||
### **1️⃣1️⃣ Assembler**
|
||||
|
||||
- **Assembler**: Übersetzt Assemblersprache → Maschinencode
|
||||
- **Zwei-Pass-Assembler**: Symboltabelle, Opcode-Tabelle
|
||||
- **Linker**: Relokation & externe Referenzen
|
||||
- **Makros**: Ersetzung bei Übersetzung
|
||||
- **Dynamisches Binden**: DLL (Windows), SO (Unix)
|
||||
|
||||
---
|
||||
|
||||
### **1️⃣2️⃣ Compiler**
|
||||
|
||||
- **Compiler-Phasen**:
|
||||
1. Lexikalische Analyse
|
||||
2. Syntaktische Analyse (AST)
|
||||
3. Semantische Analyse
|
||||
4. Zwischencode (3-Adress-Code)
|
||||
5. Optimierung (lokal, global)
|
||||
6. Codegenerierung
|
||||
- **Optimierungstechniken**: Loop Unrolling, Constant Folding, Dead Code Elimination
|
||||
|
||||
- **Tools**: `cc -E`, `cc -S`, `cc -c`, `cc -o`
|
||||
|
||||
|
||||
---
|
||||
|
||||
### **1️⃣3️⃣ Zuverlässigkeit & Virtualität**
|
||||
|
||||
- **Zuverlässigkeit**:
|
||||
Availability=MTTFMTTF+MTTRAvailability = \frac{MTTF}{MTTF + MTTR}
|
||||
- **Hamming-Codes**: SEC/DED, ECC DRAM
|
||||
- **Virtuelle Maschinen (VMs)**:
|
||||
- Vorteile: Isolation, Sicherheit
|
||||
- VMM: verwaltet Ressourcen, Traps für privilegierte Instruktionen
|
||||
- **Virtueller Speicher**:
|
||||
- Page Tables, TLB, Page Fault Handling
|
||||
- **Cache-Kohärenz**:
|
||||
- Snooping, Directory-basierte Protokolle
|
||||
|
||||
---
|
||||
|
||||
💡 **Merke**: Prinzip der Lokalität & Speicherhierarchie sind Schlüsselthemen für Performance!
|
||||
Reference in New Issue
Block a user