====== Prozessoren ======
===== Busse =====
  * Address
  * Daten
  * Status (CPU --> dev)
  * Kontroll (Dev --> CPU)
  * clock

===== Architekturen =====
==== Akkumulator ====
  * Nur 1 Register (ACC)
  * Jeder Befehl: Nur 1 Operand (eine Mem Adresse)
  * Arbeit in ACC + 1 Mem
  * Ergebnis nach ACC

==== Memory-memory ====
  * Keine Register
  * Jeder Befehl: 3 Operanden (Mem Adresse)
  * Arbeit in Mem + Mem
  * Ergebnis nach Mem

==== Stack ====
  * Keine Register
  * Jeder Befehl: 0 Operanden
  * push/pop Befehle: 1 Operand (Mem Adresse)
  * Arbeit oben auf dem Stack
  * Ergebnis oben auf das Stack

==== Load-store ====
  * Viele Register
  * Jeder Befehl: 3 Operanden (Register Adressen)
  * load/store Befehle: 1 Operand (Register Adresse) + 1 Operand (Mem Adresse)
  * Arbeit in Registern
  * Ergebniss in Register
===== CPU Aufbau =====
==== Register ====
  * **SCR** Sequence Control Register / **PC** Programm Counter
  * **CIR** Current Instruction Register
  * **MAR** Memory Address Register
  * **MDR** Memory Data Register
  * **ACC** Accumulator
==== Einheiten ====
  * **ALU** Arithmetic Logic Unit
  * Control unit (CIR, ALU, SCR)
  * Hauptspeicher (MAR, MDR)

===== Sprachliche Begriffe =====
  * **RISC** Reduced Instruction Set
  * **CISC** Complex Instruction Set
  * Maschienen//sprache//
  * Maschienen//code// (Bienärform)
  * Instruktionsformat
    * Funktionscode (Opcode)

===== North Bridge =====
  * RAM
  * AGP/PCI (nur für GraKa)
  * FSB --> CPU
  * South Bridge

===== Caches =====
==== Hardware ====
^ DRAM ^ SRAM ^
| billiger | teurer |
| langsamer | schneller |
| kleiner | größer |
| weniger Energie | mehr Energie |
| Kondensatoren | Flip Flops |

==== Lokalität ====
  * **Zeitliche / temporale:** Erneuter Zugriff -> Caches
  * **Räumliche / spatiale:** Array durchgehen -> Prefetch -> Caches

==== Mapping ====
Jeweils //Present-Bit// ob Daten vorhanden/aktuell.

  * **Direct mapped:** ''ram-address mod cache-size = cache-adress'' (Adress Rest wird auch im cache gespeichert)
  * **Voll assoziativ:** //Paraleler// Vergleich aller Cache Zeilen mit Adresse
  * **Satz assoziativ:** //Voll assoziativ// leitet weiter auf //Direct mapped//

==== Amdahls Gesetz ====
  * P = Relative Zeit die verbessert werden kann (Cachebarer Zugriff etc.)
  * N = Verbesserunksfaktor wenn 100% verbesserbar
  * T = Relative Verbesserte Zeit
  * S = Realer Verbesserungsfaktor (Speedup)

\[
T = \frac{P}{N} + (1 - P)
\]

\[
S = \frac{1}{T} = \frac{1}{\frac{P}{N} + (1 - P)}
\]

===== Pipelines =====
Konflikt = Hazzard

Die Technick nent sich //stalling//, bei der eine //bubble// in der Pipeline für einen //delay// sorgt.

http://www.cs.umb.edu/cs641/notes25.html

Schöne Pipeline "Schaltung": http://en.wikibooks.org/wiki/Microprocessor_Design/Pipelined_Processors

Hazzards & Pielining: http://en.wikipedia.org/wiki/Classic_RISC_pipeline


^ Problem ^ Lösung ^
| //Kontrollfluss//konflikt (Sprünge) | * Warten (doof) \\ * Sprungvorhersage \\  - statisch: Meistens wird gesprungen (loop) \\  - dynamisch: Statistiken erstellen (meh) \\ * Delayed Branch (es wird //immer// noch der nächste Befehl nach dem Sprung ausgeführt, egal was ist) |
| //Daten//konflikt | * Out of order Execution (Umordnen) \\ * stalling with bubbles (Warten (doof)) \\ * Forwarding/Bypassing (Daten auf die gewartet wird direkt aus der Stufe der jüngeren Instruktion abgezapft, anstadt zu warten bis es am ende ankommt (eine abkürzung / nicht rein ins register, raus aus dem register)) |
| //Resourcen//konflikt \\ (z.B. 2 Stufen brauchen gleichzeitig die ALU) | * stalling with bubbles (Warten (doof)) \\ * Superskalare Architektur (langsame Stufen vervielfachen) \\ * Ausbalanzierte Pipeline Stufen |
| Cache miss | * stalling with bubbles (Warten (doof)) |
| Interrupt | |

MIPS //Architektur// legt nicht fest wie die Pipelines aufgebaut sind. Jeder hersteller kann es //Implementieren// wie er will (das beeinflust auch nicht die Programmierung):
  - **Instruction Fetch:** Fetch Instruction, Increment PC
  - **Instruction Decode:** Decode Instruction, Read Registers
  - **Execute:**
    * Mem-ref:          Calculate Address
    * Arith-log: Perform Operation
  - **Memory:**
    * Load:   Read Data from Memory
    * Store:  Write Data to Memory
  - **Write Back:** Write Data to Register

===== Paraleles Rechnen =====
==== Hyper-Threading ====
  * Dopperlter Register Satz
  * Gemeinsame ALU
  * Threads werden verteilt (OK, angeblich können auch Prozesse verteilt werden)

==== Multi Core ====
  * Alles Mehrfach
  * Prozesse werden verteilt

==== Flynn's taxonomy ====
[[http://en.wikipedia.org/wiki/Flynn's_taxonomy]]
^ ^ //S//ingle //D//ata ^ //M//ultiple //D//ata ^
^ //S//ingle //I//nstruction | **SISD** \\ Alte, normale CPUs | **SIMD** \\ Normale CPUs mit SSE/3Dnow \\ Vektorprozessoren / Arrayprozessoren |
^ //M//ultiple //I//nstruction | **MISD** \\ Fehlertolerante Rechner (Flugzeuge) | **MIMD** \\ Normale Multicore CPUs \\ Rechnerverbunde (Supercomputer) |

==== Vernetzung ====
=== Art der Verbindung ===
  * **Paketvermittlung / packet switching**: Paketierung -> unabhängiges routing der pakete
  * **Leitungsvermittlung / circuit switching**: Datenstrom über dedizierte (virtuelle) Punkt zu Punkt verbindung.

=== Adressierung ===
  * **Zielbasieret**: Knoten bestimmen Weg (anhand von ziel)
  * **Quellenbasiert**: Absender bestimmt Weg (im Vorraus)

=== Hypercube ===
Mit XOR die Differenzen zwischen aktueller Adresse und Ziel finden, ein Bit der untersciede fixen und da hingehen.