vault backup: 2025-07-07 19:57:44

2025-07-07 19:57:44 +02:00
parent 1638e96536
commit ed7da1341b
14 changed files with 1982 additions and 0 deletions
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,151 @@
+## 📘 **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 – ISA (Instruction Set Architecture):** Maschinensprache
+    
+4. **Ebene 3 – Betriebssystemebene:** Multiprogramming, IO-Abstraktion
+    
+5. **Ebene 4 – Assemblersprache:** maschinennahe Programmierung
+    
+6. **Ebene 5 – Höhere Programmiersprachen:** unabhängige Algorithmen
+    
+
+---
+
+### 📜 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)
+        
+
+---
+
+### 📝 Organisatorisches
+
+- **Vorlesung:** Do 13:30–15:00
+    
+- **Übung:** Do 15:15–16:00
+    
+- **Labor:** Do 16:15–19:15 (alle 2 Wochen)
+    
+- **Prüfung:** E-Klausur 90 min (mind. 50% zum Bestehen)
+    
+- **Voraussetzungen:** DIGIT & BESYST bestanden
+    
+
+---
+
+### 🧠 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?“
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,121 @@
+## 📘 **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`)
+
+---
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,152 @@
+## 📘 **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
+
+---
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,186 @@
+## 📘 **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
+        
+    - Geringerer Stromverbrauch
+        
+- Aber: Miniaturisierung wird zunehmend teurer und schwieriger.
+    
+
+---
+
+### 📊 Leistungsmessung von Computern
+
+- **System-Benchmarks:** Cinebench, 3DMark, HPC Challenge
+    
+- **Kennzahlen:**
+    
+    - Instruktionen/Sekunde (IPS), FLOPS
+        
+    - 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.
+    
+
+---
+
+### 🤖 Computer als endlicher Automat (Finite State Machine)
+
+- **Zustände:** durch Bitmuster repräsentiert
+    
+- **Operation:** Boolesche Funktion auf Teilzuständen
+    
+- Vergleichbare Modelle:
+    
+    - Schaltnetz (ohne Schleifen)
+        
+    - Endlicher Automat (deterministisch/nichtdeterministisch)
+        
+    - Kellerautomat (mit Stack)
+        
+    - Turingmaschine (unendliches Band)
+        
+
+---
+
+### 🚌 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
+    
+
+#### Steuerwerk
+
+- Verantwortlich für:
+    
+    - Ausführung der Befehle
+        
+    - Datenflusskontrolle
+        
+    - Ausnahmebehandlung & Interrupts
+        
+
+---
+
+### 🧵 Befehlssatzarchitekturen (ISA)
+
+#### 1️⃣ Stack-Architektur
+
+- Operanden und Ergebnisse liegen auf Stack.
+    
+- Vorteile: kompakter Code, minimaler Prozessorzustand
+    
+- 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
+    
+
+#### 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|
+
+---
+
+### 📝 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
+ 
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,111 @@
+## 📘 **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 (Beispiele)
+
+|**Kategorie**|**Befehl**|**Beispiel**|**Bedeutung**|
+|---|---|---|---|
+|Arithmetisch|`add`|`add $s1,$s2,$s3`|`$s1 = $s2 + $s3`|
+|Datentransfer|`lw`, `sw`|`lw $s1,20($s2)`|`$s1 = Memory[$s2+20]`|
+|Logisch|`and`, `or`|`and $s1,$s2,$s3`|`$s1 = $s2 & $s3`|
+|Bedingte Verzweigung|`beq`, `bne`|`beq $s1,$s2,Label`|Sprung, falls `$s1 == $s2`|
+|Unbedingter Sprung|`j`, `jal`|`j Label`|Sprung zu Adresse `Label`|
+
+---
+
+### 🧮 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)
+
+---
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,109 @@
+## 📘 **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
+
+---
+
+### 📦 Lernpaket (bisher)
+
+- **V1 Einführung** → Überblick, Historie, Abstraktionsebenen
+    
+- **V2 Architekturen** → ISA-Arten, RISC vs. CISC, Moore’s Law
+    
+- **V3a Schaltnetze & Automaten** → Logikstrukturen & FSM
+    
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,101 @@
+## 📘 **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
+
+---
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,108 @@
+## 📘 **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
+
+---
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,161 @@
+## 📘 **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
+
+---
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,139 @@
+## 📘 **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
+
+---
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,110 @@
+## 📘 **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
+
+---
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,160 @@
+## 📘 **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)
+
+---
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,129 @@
+## 📘 **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)
+
+---
--- a/6/COMARCH/Zusammenfassung/Vorlesung
+++ b/6/COMARCH/Zusammenfassung/Vorlesung
@@ -0,0 +1,244 @@
+## 📘 **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!