Merge remote-tracking branch 'origin/main'

Semester 6/COMARCH/Zusammenfassung/Fragenkatalog.md

@@ -0,0 +1,14 @@
+# Übung 1
+- Beim von-Neumann-Rechner lassen sich Programme im Speicher genauso ändern wie Daten. Wo könnte das sinnvoll sein?
+- Beim der Rechner der Harvard-Rechner sind Programme und Daten strikt getrennt. Wo könnte das sinnvoll sein?
+- Welche Gatter kennen Sie?
+- Welche Darstellungen (graphisch) von Gattern kennen Sie?
+- Wie viele unterschiedliche Gatter gibt es, sind möglich?
+- Was für Komponenten kennen Sie eine Abstraktionsebene über den Gattern?
+- Noch eine Ebene höher?
+- Beim der Rechner der Harvard-Rechner sind Programme und Daten strikt getrennt. Wo könnte das sinnvoll sein?
+- Was beschreibt das Moore’sche Gesetz?
+
+- Auf einem Datenpfad benötigt das Laden der Eingaberegister 5 ns, die ALU-Verarbeitung 10 ns und das Rückspeichern 5 ns. Wie viel MIPS hat dieser Rechner?
+$\frac{1}{20^{-9}s} = 0.05 * 10^9  = 50 \text{ MIPS}$
+

Semester 6/COMARCH/Zusammenfassung/Vorlesung 1.md

@@ -22,10 +22,10 @@
 
 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
+3. **Ebene 2 – Befehlssatzachritektur  (ISA):** Maschinensprache
+4. **Ebene 3 – Betriebssystem:** Multiprogramming, IO-Abstraktion
 5. **Ebene 4 – Assemblersprache:** maschinennahe Programmierung
-6. **Ebene 5 – Höhere Programmiersprachen:** unabhängige Algorithmen
+6. **Ebene 5 – Problemorientierte Sprachen:** unabhängige Algorithmen, Compiler oder Interpreter
 
 ---
 
@@ -87,16 +87,6 @@
 
 ---
 
-### 📝 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  

Semester 6/COMARCH/Zusammenfassung/Vorlesung 2.md

@@ -17,7 +17,7 @@
 - Auswirkungen:
     - Kleinere Strukturen → geringere Kosten    
     - Mehr Komponenten → höhere Leistung    
-    - Geringerer Stromverbrauch    
+    - > Resultierend: Geringerer Stromverbrauch    
 - Aber: Miniaturisierung wird zunehmend teurer und schwieriger.
 
 ---
@@ -25,12 +25,12 @@
 ### 📊 Leistungsmessung von Computern
 
 - **System-Benchmarks:** Cinebench, 3DMark, HPC Challenge
-- **Kennzahlen:**
-    - Instruktionen/Sekunde (IPS), FLOPS    
+- **Kenngrößen:**
+    - Instruktionen/Sekunde (IPS), FLOPS (Floating point operations/second)  
     - Taktzyklen pro Instruktion (CPI), Instruktionen pro Takt (IPC)    
     - Speicherzugriffszeit, Durchsatz    
     - Netzwerk- & Grafikleistung (FPS, TPS)    
-- Kritik an MIPS: „Misleading Information to Promote Sales“ – nicht immer aussagekräftig.
+- Kritik an MIPS: „Misleading Information to Promote Sales“ – nicht immer aussagekräftig. (MIPS => Million instructions per second)
 
 ---
 
@@ -39,10 +39,13 @@
 - **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)    
+	 - Schaltnetz: keine Schleifen, keine Rückkopplung)
+	- Endlicher Automat (Deterministisch und Nichtdeterministisch)
+	- Kellerautomat (unendlich, aber Zugriff nur auf oberstes Element)(Hardwarelimitierungen?)
+	- Turing-Maschine (endliche Zustände des Automaten, unendliches Band zum Lesen und Schreiben)
+![[Pasted image 20250708185128.png]]
+![[Pasted image 20250708185152.png]]
+![[Pasted image 20250708185618.png]]
 
 ---
 
@@ -64,22 +67,44 @@
 - Operationen: +, −, *, /, logische Operationen
 - Moderne CPUs: mehrere Register → direkte Register-Register-Operationen
 - Ältere CPUs: Akkumulator-Register für ALU-Operationen
-
+![[Pasted image 20250708185932.png]]****
 #### Steuerwerk
-
 - Verantwortlich für:
     - Ausführung der Befehle    
     - Datenflusskontrolle    
     - Ausnahmebehandlung & Interrupts    
 
+#### Register
+- Program Counter PC
+- Befehlsregister (Instruction Registers IR)
+- **optional**: Stackpointer SP
+- **Statusregister**: Zustandsregister, Flags usw.
+- Einfache CPUs haben einen speziellen Akkumulator-Register (Accu)
+	- Aus diesem wird ein Wert gelesen
+	- Ergebnis einer Operation wird hier gelagert
+- Moderne CPUs können nicht direkt Daten aus dem Hauptspeicher in das Rechenwerk lesen (Sicherheit oder warum?)
+
+#### Bottleneck Datentransfer
+| Speichertyp          | Geschwindigkeit      |
+| -------------------- | -------------------- |
+| CPU Register         | < Nanosekunde        |
+| CPU Cache            | ~wenige Nanosekunden |
+| Arbeitsspeicher      | 60-70 Nanosekunden   |
+| Sekundärspeicher SSD | 0,4 ms               |
+| Sekundärspeicher HDD | 8-10 ms              |
+
 ---
 
 ### 🧵 Befehlssatzarchitekturen (ISA)
 
+**Befehle bestimmen die Architektur und umgekehrt**
+
 #### 1️⃣ Stack-Architektur
 
 - Operanden und Ergebnisse liegen auf Stack.
-- Vorteile: kompakter Code, minimaler Prozessorzustand
+- Benötigt Stack Pointer **SP Register**
+- Ergebnis wird final auf den Stack gelegt
+- Vorteile: kompakter Code, minimaler Prozessorzustand, sog. Null-Address Machine
 - Nachteil: viele Speicherzugriffe
 - Heute: nur noch in virtuellen Maschinen (JVM, p-Machine)
 
@@ -88,6 +113,7 @@
 - Ein Register (Akkumulator) für Operanden & Ergebnis
 - Speicherzugriff für zweiten Operand nötig
 - Kompakt, aber teuer durch Speicherzugriffe
+- **Ein-Adress-Maschine**
 
 #### 3️⃣ Register-Memory-Architektur
 
@@ -109,14 +135,27 @@
 
 ### 🔥 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|
+| **Merkmal**     | **RISC**                            | **CISC**                        |
+| --------------- | ----------------------------------- | ------------------------------- |
+| **Befehlssatz** | Einfach, einheitlich, kurze Befehle | Komplex, unterschiedliche Länge |
+| **Hardware**    | Einfach, energieeffizient           | Komplex oder Mikroprogramme     |
+| **Codegröße**   | Größer                              | Kompakter                       |
+| **Beispiele**   | ARM, MIPS, SPARC, PowerPC           | x86 (Intel, AMD), Zilog Z80     |
+| **Vorteile**    | Schneller bei genügend Registern    | Speichereffizient               |
+| **Nachteile**   | Mehr Programmspeicher nötig         | Langsame komplexe Befehle       |
+
+Unterschied zwischen CISC und RISC CPUs – Gibt es Mischformen?
+
+| ==Merkmal==      | ==CISC (Complex Instruction Set Computer)== | ==RISC (Reduced Instruction Set Computer)== |
+| :--------------- | :------------------------------------------ | :------------------------------------------ |
+| Befehlssatz      | Viele, komplexe Befehle                     | Wenige, einfache Befehle                    |
+| Hardwareaufbau   | Komplexe Steuerlogik oder Mikroprogramme    | Einfache, schnelle Hardware                 |
+| Befehlslänge     | Unterschiedlich lang (z. B. 1–15 Byte)      | Gleich lang (z. B. 4 Byte)                  |
+| Operationen      | Direkt mit Speicher möglich                 | Nur mit Registern (Load/Store-Prinzip)      |
+| Speicherbedarf   | Geringer, da kompakter Code                 | Höher, da mehr Befehle nötig                |
+| Energieeffizienz | Weniger effizient                           | Höher, da keine ungenutzten Logikblöcke     |
+| Fokus            | Effizienz bei Assembler-Programmierung      | Optimierung für Compiler und Pipeline       |
+
 
 ---
 

Semester 6/COMARCH/Zusammenfassung/Vorlesung 3.md

@@ -28,16 +28,9 @@
 - 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`|
-
+#### 🛠️ Befehle 
+![[Pasted image 20250708193917.png]]
+![[Pasted image 20250708193937.png]]
 ---
 
 ### 🧮 Aufbau der CPU: Datenpfad (Datapath)

Semester 6/COMARCH/Zusammenfassung/Vorlesung 4.md

@@ -3,90 +3,61 @@
 ### 🔁 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`)
-        
+    - **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
-        
+    - 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
-        
+    - **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
-        
+    - 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`|
-        
+
+| 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)
-            
+    - **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ä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
-        
+    - Aufteilung des Datenpfads in Stufen    
+    - Überlappende Bearbeitung mehrerer Instruktionen    
 
 ---
 

Semester 6/COMARCH/Zusammenfassung/Vorlesung 5.md

@@ -3,13 +3,9 @@
 ### 🚀 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
-    
 
 ---
 
@@ -28,13 +24,9 @@
 ### 📈 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
-    
 
 ---
 
@@ -43,57 +35,39 @@
 #### 🏗 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
-        
+    - **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
-            
+    - 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
-    
 
 ---