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!