Sie sind auf Seite 1von 46

lOMoARcPSD|4653659

ERA Mini-Skript komplett

Einführung in die Rechnerarchitektur (IN0004) (Technische Universität München)

StuDocu wird von keiner Universität gesponsert oder unterstützt.


Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)
lOMoARcPSD|4653659

Schichten eines Rechners:


- ISA
- Binärrepräsentierung
- Von-Neumann-Schicht
- Mikroarchitektur-Schicht
- Bauelemente-Schicht
- Gatter-Schicht
- Physikalische Schicht

Von-Neumann-Architektur:
1. Struktur des Rechners unabhängig vom bearbeiteten Problem
2. Rechner besteht aus 4 Werken:
- Hauptspeicher (RAM)
- Leitwerk
- Rechenwerk
- Ein-/Ausgabewerk
3. Hauptspeicher unterteilt in fortlaufend nummerierte Zellen gleicher Größe
4. Programm und Daten im selben Speicher, beide können verändert werden
5. Maschine benutzt Binärcodes
6. Programm besteht aus einer Folge von Befehlen, die sequentiell ausgeführt wird
7. Von sequentieller Ausführung kann durch bedingte und unbedingte Sprünge abgewichen werden

Memory Access Register -> Adresse der Zelle des Hauptspeichers, die gelesen/geschrieben werden
soll
Memory Data Register -> vom Hauptspeicher ausgelesener Inhalt / zu schreibender Inhalt

Drei Arten von ASM-Befehlen:


arithmetisch-logische Befehle, Speicherbefehle, Sprünge

Sprungarten:
unbedingt, bedingt, Unterprogrammaufruf (CALL)

Adressierungen:
unmittelbare Adressierung, Register-Adressierung, Speicheradressierung, dynamische
Adressrechnung

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Adressierungsarten:
- direkte Adressierung [1234]
- registerindirekte Adressierung [eax]
- registerindirekte Addr. mit Prädekrement/Postinkrement [eax++] (theoretisch)
- registerindirekt mit Displacement [eax + 12]
- indiziert mit Displacement [eax + 12]
- indiziert mit Skalierungsfaktor (2er-Potenz) [eax + 2 * ebx]
- indiziert mit Skalierungsfaktor (2er-Potenz) und Displacement [eax + 2 * ebx + 12]
- Befehlszähler-relative Adressierung
- speicherindirekte Adressierung [[eax]] (theoretisch)

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Zwei ISA-Arten:
CISC (Complex Instruction Set Computer), RISC (Reduced Instruction Set Computer)

Adressformen:
Nulladressform (Kellermaschine), Einadressform (Akkumulatormaschine), Zweiadressform
(Registermaschine), Dreiadressform (Speicher-Speicher/Register-Register-Modell)

Interrupts (nach jedem Zyklus abgefragt, asynchron) vs Exceptions (bei Ausführung erzeugt,
synchron)

Ringe/Privilegienstufen:
Systemmodus (Ring 0) für Betriebssystem, Benutzermodus (Ring 3) für Prozesse

Prozess = Programm + Daten + Kontext + Stapel

Virtuelle Adressen:
Um Speicher vor unerlaubtem Zugriff zu schützen:
Jeder Prozess muss mit virtuellen Adressen arbeiten
MMU (Memory Management Unit) übersetzt virtuelle Adressen in physikalische Adressen
Paging: Seitenbasierte Speicherverwaltung, Seite hat jeweils fortlaufende Adressennummern
und Startadresse
Übersetzung virtuelle Seiten <> physikalische Kacheln
Offset in Seite entspricht Offset in Kachel, Seite/Kachel umfasst ca. 4-8 KiB
Grund: 1:1-Tabelle wäre zu groß -> Zusammenfassen mehrerer Adressen zu Seite/Kachel

Seitentabelle ordnet Seiten zu Kacheln zu, enthält Zugriffsinfos über Seite


Translation Lookaside Buffer ist Cache für Seitentabellen

Auslagerung: Seiten können, wenn der Speicher voll ist, auf die Festplatte ausgelagert werden
OS verwaltet Seiten, sodass möglichst effizient ausgelagert wird (selten verwendete Seiten auf
Festplatte)

ISA:
Assembler-Befehle werden zu Opcodes übersetzt (z.B. 0x04 für add)
RISC-ISAs haben feste Opcode-Länge (z.B. ARM -> 32 Bit)
IA-32 ist aber typische CISC-ISA (Opcodes unterschiedlich lang)
IA-32 ist Little Endian; 0x12345678 wird im Speicher zu "78.56.34.12"

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Objdump: mit "objdump -M intel -d Dateiname" kann man ein Programm in Assemblercode
zurückverwandeln

Aufrufkonventionen:
Am Anfang einer Unterfunktion steht oft:
push ebp
mov ebp, esp

und am Ende:
pop ebp
ret

So kann man ebp nutzen, um auf lokale Variablen zuzugreifen


z.B. wenn man schreibt:

push dword 100


push dword 10
mov eax, [ebp-4] ; 100 nach eax
sub eax, [ebp-8] ; 100 - 10

würde in eax 90 stehen

Parameter: auf per Call an die aktuelle Funktion übergebene Parameter


kann man z.B. mit [ebp+8] zugreifen,
wobei +8 der erste Parameter ist (als letztes vor CALL gepusht), +12 der zweite (als vorletztes vor
CALL gepusht), usw.
an [ebp+4] liegt die Rücksprungadresse
an [ebp] liegt logischerweise der alte gesicherte Wert von ebp (push ebp ganz am Anfang)

Callee-saved: diese Register müssen per normaler Aufrufkonvention unverändert bleiben:


ebx, esi, edi, ebp, esp
deshalb z.B. auch push ebp am Anfang, bevor wir mov ebp, esp machen

AT&T-Notation:
statt
add eax, 1
schreibt man

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

add $1, %eax


das Zielregister steht als letztes Register,
bei Registern kommt ein % davor, bei Konstanten und Adressen ein $

Kompilieren von C-Programmen:


cc -m32 Dateiname -o2 -o Ausgabename

Optimierung: O2 ist die Optimierungsstufe 2,


z.B. werden sinnlose Schleifen wegoptimiert
(Beispiel mit for-Summe von 1 bis 9 ->
mit cc Kompiliert und mit objdump wieder zu Assembler:
im Assembler-Code steht gleich 45 statt die Schleife, Compiler hat also optimiert)

SSE/AVX:
Lange Register werden mit mehreren Werten beladen, und dann eine Operation
darauf ausgeführt
Dadurch hat man weniger Datentransfers und weniger Rechenoperationen
SSE: Streaming SIMD Extension (128 Bit)
AVX: Advanced Vector Extension (neuer, 256 Bit)

Vereinfachendes Beispiel:
man will die 16-Bit-Shorts a + b und c + d addieren,
speichert a und c jeweils in den ersten 16 Bit von den ints e und f
und b und d in den letzten 16 Bits von jeweils e und f
dann addiert man die beiden ints e + f und hat in den ersten 16 bit die Summe a + b
und in den letzten 16 Bits die Summe c + d
So hat man statt 2 Rechenoperationen nur eine gebraucht, nämlich e + f

ARM:
ARM-Prozessoren sind RISC
ARM v8: neueste ISA von ARM, unterstützt jetzt auch 64 Bit, bis zu ARMv5 rückwärtskompatibel
Little Endian und auch Big Endian wird unterstützt (bei Intel nur Little Endian)
Register-Register-ISA (z.B. add ziel, op1, op2 -> drei Operanden statt 2 wie bei Intel)
Stack-Pointer muss bei ARM immer 16-Byte-aligned sein

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Bei ARM wird "w0/x0" als Rückgaberegister genutzt (bei Intel eax)
w ist die 32-Bit-Variante, x die 64-Bit-Variante (wie ax und eax bei Intel)
w1/x1 bis w7/x7 für Argumente verwendet (bei Intel meistens Argumente im Stack)
es gibt auch ein Zero Register (wzr/xzr) -> hat immer den Wert 0
Link Register: enthält Rücksprungadresse zur aufrufenden Funktion

Faustregel für Assembler-Optimierung:


meist ist ca. 10% des Codes für 90% der Ausführungszeit zuständig
-> nur diesen kritischen Teil optimieren, weil alles in ASM zu schreiben zu lange dauert

Sektionen einer ASM-Datei:


section .text -> enthält Code (ASM-Funktionen)
section .data -> enthält Daten, z.B.

Sektion ".data":
section .data
mystring: db "Hallo Welt", 0

section .text
...
Definiert einen (null-terminierten, daher die 0) String "Hallo Welt!",
auf den man im Code mit "mystring" verweisen kann

Makros:
Makrodefinition <-> Makroaufruf <-> Makroerweiterung

Beispiel (2 gibt Anzahl der Parameter des Makros an, Parameter mit %1 und %2 und %n abrufbar):
%macro plus 2
mov eax, %1
add eax, %2
%endmacro

plus 2, 5

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

plus 2, 5 wird beim Assemblieren erweitert zu


mov eax, 2
add eax, 5
so spart man sich Schreibarbeit, wenn man denselben Codeblock leicht verändert oft braucht

Assemblierer (manchmal auch einfach "Assembler"):


ASM-Code wird vom Assemblierer in Opcodes umgewandelt (.o: Objektdatei)
Dabei zwei Durchläufe:
im 1. Durchlauf werden Labels, Variablen und Symbole (z.B. Makros oder "mystring" oben) aufgelöst
Position von Labels wird im Instruction Location Counter (ILC) gespeichert
im 2. Durchlauf wird auf Fehler geprüft (z.B. nichtexistente Variable/Register)
und die .o-Datei (Objektmodul) mit Opcodes und weiteren Informationen (s.u.) generiert

Linker:
Linker bindet mehrere Objektmodule (.o) zu einer ausführbaren Datei (z.B. .exe)
Das ist z.B. sinnvoll, wenn man eine .o-Datei mit einer bestimmten Funktion in mehreren
.exe-Dateien verwenden möchte ("Bibliothek" von Funktionen)

Objektmodule:
Erweiterung .o, meistens im ELF-Format
ELF enthält neben Opcodes noch zusätzliche Infos wie z.B. Einsprungspunkte (Startpunkte) für
public-Funktionen, damit andere .o-Dateien auf diese verweisen können
und auch eine Liste von relativen Adressen in den Opcodes, die beim Linken angepasst werden
müssen (da mehrere Dateien zu einer zusammengefasst werden)

readelf: Befehl "readelf" gibt Infos einer ELF-Datei aus

Linking:
Linker muss beim Linken die relativen Adressen anpassen, damit z.B. jmp und call in der
Ausgabedatei, die ja aus mehreren Dateien besteht, noch stimmen

Programmbibliotheken/Funktionsbibliotheken:
Dateien mit vielen public-Funktionen, die von anderen Programmen aufgerufen werden können
So schreibt man einmal eine Bibliothek und nutzt die Funktionen darin in unterschiedlichen
Programmen

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Bibliothekenarten: dynamisch und statisch


Dynamische Bibliotheken (.dll) sind eigenständige Dateien neben der .exe,
Statische Bibliotheken werden beim Linken in die .exe eingebunden

Dynamische Bibliotheken/.dlls sind austauschbar (z.B. bei Updates) und von vielen Programmen
gleichzeitig nutzbar, verlangsamen das Programm aber, weil sie von der Festplatte extra geladen
werden müssen
auch funktioniert die .exe nicht mehr, wenn sie fehlen

Real Mode/Protected Mode und Speicherbereiche:


Bei DOS in Real Mode gibt es folgende Speicherbereiche:
Lower memory area -> 0-640KB: BIOS-Daten, OS
Upper memory area -> 640 KB - 1 MB: Hardware, z.B. Grafikkarte
High memory area -> 1MB - 1.06MB
Extended memory area -> bis 4GB (nur mit DOS/4GW nutzbar)

DOS/4GW: DOS läuft in Real mode mit 16 Bit, mit DOS/4GW kann man den Prozessor mit 32 bit
in den Protected Mode schalten

Interrupts:
Interrupts haben immer eine bestimmte Nummer
int 12 löst z.B. manuell den Interrupt 12 aus

Interrupt-Vektor-Tabelle:
Tabelle mit Interrupt-Nummern und den Adressen der Programme im Speicher, die die Interrupts
abfangen
Bei Interrupt wird dort nachgeschlagen, wohin gesprungen werden soll

Interrupt Requests:
Programmable Interrupt Controller (PIC) prüft für Prozessor, ob Interrupts vorliegen
z.B. bei Mausdruck -> PIC gibt Interrupt Request (IRQ) an CPU weiter
Interrupt wird auf CPU ausgeführt
CPU teilt PIC mit, dass der Interrupt ausgeführt wurde
dann macht der CPU weiter, wo er aufgehört hat

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Bussystem:
Kommunikation zw. Prozessor, Speicher, IO-Geräten (und Caches/Cache Controller)
Besteht aus Datenbus, Adressbus und Kontrollbus
Bus Control Logic verwaltet Bussystem

Starten eines (DOS-)PCs:


5 Schritte:
1. Reset (Register initialisieren)
2. BIOS (Code an 0xFFFF0 ausgeführt)
3. Bootloader (von Festplatte in Speicher geladen;
für Starten des OS/Auswahl des zu startenden OS zuständig)
4. Betriebssystem (Bootvorgang z.B. mit Windows-Logo)
5. Programm

IO (Ein-/Ausgabe) mit PC:


Eingabegeräte erzeugen Interrupt Requests (s.o.)
Sound wird über Soundkarte ausgegeben

DMA (Direct Memory Access)-Controller kann für Prozessor das Laden von
Speicherbereichen/Ausgeben auf den Datenbus/Kommunizieren mit IO-Geräten übernehmen
Eine Art Miniprozessor, der dem Haupt-CPU Arbeit abnehmen kann und von diesem programmiert
wird
z.B. nützlich, um Datenstrom an Soundkarte weiterzuleiten
DMA früher zur "Auffrischung" des RAMs (Kondensatoren) verwendet

Video-Adapter-Karte/VGA-Karte:
früher verwendet, heutzutage Grafikkarten mit Treibern
Idee: ein bestimmter Bereich im Speicher repräsentiert Bildschirmgrafik
Dabei zwei Modi:
Textmodus: man schreibt den Text einfach in den RAM-Bereich und er wird auf dem Monitor
ausgegeben
Grafikmodus: Bytes im RAM-Bereich stehen für Pixel, Wert darin kodiert Farbe

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Planes: Grafik-Bereich im RAM hatte (in DOS) nur 256KB


um höhere Auflösungen/genauer beschriebene Farben (=mehr Bytes/Pixel) zu verwenden, musste
man erst angeben, welchen Bereich (=Plane) des Displays man verändern möchte, dieser wurde dann
in den 256KB-Bereich geladen und konnte verändert werden

Assembler-Performance-Hacks:
Register schneller auf Null setzen:
xor eax, eax
Schnelle Multiplikation mit 320:
z.B. eax = eax*320 = eax*(64+256)

mov ebx, eax ; Kopie von eax erzeugen


shl ebx, 6 ; ebx = ebx * 64
shl eax, 8 ; eax = eax * 256
add eax, ebx ; eax = eax * 64 + eax * 256 = eax * (64+256)

I/O auf heutigen PCs:


ISA (Industry Standard Architecture) -> PCI, PCI ist viel schneller
Statt IO-Ports: spezielle Register im Speicher
Statt vieler verschiedener IO-Schnittstellen nur USB

Compiler:
Präprozessor:
z.B. in C/C++ Einbinden von anderen Dateien

#include <iostream> // iostream enthält Funktionen für Konsolen-Ausgabe


#define PI 3.1415 // Konstante PI, wird beim Kompilieren ersetzt

Phasen des Compilers:


1. Lexikalische Analyse: Symboltabelle für Variablen -> Variablen Nummern zuweisen
2. Syntaktische Analyse: Struktur des Programms analysieren und Syntaxbaum aufbauen
dabei auch Suche nach Fehlern
3. Semantische Analyse: Typinformationen in Symboltabelle einfügen
Casts werden überprüft und berücksichtigt
4. Zwischencode-Gen.: Übersetzung in leicht zu optimierende Zwischenform

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

5. Code-Optimierung: Zwischencode wird optimiert, z.B. durch -O2


Hier z.B. Schleifenoptimierungen, Parallelisierung usw.
Dabei Konzept des Basisblocks:
Basisblock kann nur von einer Stelle aus betreten und
nur aus einer Stelle heraus verlassen werden
6. Code-Generierung:
Assembler-Code wird generiert, dabei wird genau abgewogen, welche Register für
was eingesetzt werden sollen und was man in den Speicher schreiben sollte
(um Programm schneller zu machen) -> "Register-Allokation"/"Register-Spilling"

Laufzeitumgebung: Programme brauchen zum Funktionieren auch eine Laufzeitumgebung (z.B.


Bibliotheken, Treiber, Schnittstellen zum OS usw.)

Interpretierte Sprachen:
Code wird ohne kompiliert zu werden direkt vom Interpreter ausgeführt
Flexibel, aber sehr langsam, da keinerlei Optimierung

Java:
Eine "ISA für alle Betriebssysteme", dabei liest die Java Virtual Machine den Java-Bytecode
und führt ihn auf dem jeweiligen Betriebssystem aus
Java Virtual Machine muss für jedes Betriebssystem einzeln implementiert werden

Speicherverwaltung:
Unterschied bei Speicherverwaltung zwischen Java und C:
in Java automatische Garbage Collection, Objekte werden durch GC gelöscht, sobald nicht mehr
gebraucht
in C ist Programmierer selbst verantwortlich für Speicherreservierung und anschließende Freigabe
(malloc(...) und free(...))

High Performance Computing (HPC):


Verwendung bei Wettervorhersagen, Nuklearphysik usw.
Flops = Fließkommaoperationen pro Sekunde
zurzeit 10^15 Flops

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Ansätze zur Leistungssteigerung:


- algorithmische Verbesserung (z.B. schnellere Verfahren)
- Hardwareverbesserung (Befehlsparallelisierung, Datenparallelisierung, usw.)

Rechenhierarchie bei HPCs: Knoten -> Prozessor -> Rechenkern

Rechnen mit GPU: GPU hat viele SM (Symmetric Multiprocessors) statt einen CPU
GPUs zunächst nur für Grafik eingesetzt, mittlerweile immer mehr für...

Parallelisierung:
Parallelisierung wird immer wichtiger, da individuelle Kerne nur
sehr schwer noch schneller gemacht werden können
(Ende von Dennard Scaling/exponentiellem Frequenzzuwachs ca. 2005)

Moore's "Gesetz": Anzahl der Transistoren pro Flächeneinheit verdoppelt sich alle zwei Jahre

Leistung eines HPCs:


Beispiel für Berechnung der maximalen Leistung eines Supercomputers in Flops:
Intel-Prozessorfamilie "Sandy Bridge" ->
SIMD mit AVX 256 (SSE) -> Faktor 4
Multiplikation und Addition kann man kombinieren -> Faktor 2
Kerngeschwindigkeit -> 2.7 GHz/Kern
-> Leistung eines Kernes: 4 * 2 * 2.7 = 21.6 GFlops
Sandy Bridge hat 8 Kerne -> 8 * 21.6 = 172.8 GFlops
SuperMUC hat 9216 Knoten, pro Knoten 2 CPUs
-> 9216 * 2 * 172,8 GFlops = 3.185 PFlops

Speicherbandbreite: GPUs haben eine 4-8 Mal so hohe Bandbreite wie CPUs
-> viel mehr Datentransfers/Sekunde, deshalb oft statt CPUs für HPC eingesetzt

Roofline-Modell: zeigt Einfluss verschiedener Faktoren, wie z.B. SIMD oder Fused Multiply-Add,
auf Maximalleistung in GFlops/s

Moderne Probleme bei HPC: Leistung in Flops zwar hoch, aber Datenübertragung (z.B. zwischen CPU
und RAM) immer noch langsam -> Versuch, Hauptspeicherzugriffe zu reduzieren und mehr Caching
zu verwenden

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Parallelisierungs-Bibliotheken:
OpenMP und CUDA

OpenMP:
mit Hinweisen dem Compiler mitteilen, wenn z.B. eine Schleife parallel ausgeführt werden soll
z.B. C-Code:
int test[1234];
// Diese for-Schleife parallel ausführen:
#pragma omp parallel for
for(int i = 0; i < 1234; i++)
test[i] = i;

CUDA:

Aufteilung der logischen Schicht in Gitter (Grid) -> Block -> Thread
Grid: Array aus zu verarbeitenden Daten
Block: Unterteil eines Grids, je ein SM-Prozessor erhält einen Block
die Threads eines Blocks teilen sich einen Speicher -> Austausch von Daten
Thread: mehrere Threads pro Block

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

*** Mikroarchitektur: ***

Schaltnetze: gedächtnislos / zustandslos / stateless


-> gleiche Eingaben produzieren immer gleiche Ausgaben
Schaltwerke: haben Zustände / stateful
-> Ausgabe ist auch von vorherigen Eingaben abhängig -> interne Zustände

Beispiele für Schaltnetze:


Multiplexer: viele Eingabequellen, eine Ausgabe; Steuersignal sagt, welche Quelle auf den Ausgang
gelegt wird
Dekodierer: viele Ausgaben, Eingabesignal entscheidet, auf welche Ausgabe eine 1 ausgegeben wird
Tore: UND-Gatter mit einem Signal und einem Steuersignal als Eingabe
-> Steuersignal kontrolliert, ob Signal durchgelassen wird

Implementierung der ISA:


Optionen für die Implementierung der ISA in der Mikroarchitektur:
-> fest verdrahtete ISA: ISA ist mit fester elektronischer Logik realisiert, kann nicht verändert werden
+ schneller, da Optimierung möglich
- schwer zu entwickeln
- anfällig für Fehler
- kann nicht mehr angepasst werden
-> programmierbare ISA: ASM-Opcodes werden durch Unterprogramme realisiert
- langsamer
+ einfacheres Design
+ einfach veränderbar
+ leichte Fehlerkorrektur

Definitionen:
- Makrobefehl: Assembler-Befehl
- Mikrobefehl: Befehl in der Mikroprogrammierung, steht im MPS (Mikroprogrammspeicher)
- Mikroinstruktionswort: (hier) 80-bit-breites Bitfeld mit Steuersignalen für einzelne Komponenten
(Rechenwerk, Leitwerk, Multiplexer, ...)

Achtung: Unterschied Mikroinstruktionsregister <> Makroinstruktionsregister

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Mikroprogrammzyklus: taktgetriebene Ausführung des Mikroprogramms

1. IFETCH -> Adresse des nächsten Mikrobefehls anhand des Makrobefehls bestimmen
2. Befehl aus Mikroprogrammspeicher auswählen
3. Befehl in Mikroinstruktionsregister laden
4. Signale im Mikroinstruktionswort lösen Operationen in allen Elementen aus

MI-Maschine:
Mikroleitwerk: Am 2910
berechnet die Adresse des nächsten Befehls
Rechenwerk: Am 2901
Statuswerk (Wortrandlogikbaustein): Am 2904

Spezifikationen:
Daten-/Adressbreite: 16 Bit
Hauptspeicher: 64K * 16 Bit
Mikroinstruktionsbreite: 80 Bit (s.o.)
Mikroprogrammspeicher: 4K * 80 Bit

Tri-State-Bus: parallel nutzbare Busse, zeitbasierte Verschachtelung der Nutzung


-> jeder darf immer abwechselnd schreiben

Mikroinstruktionsformate:
Horizontal: direkte Ansteuerung von Elementen (Leitwerk, Multiplexer), ...
Vertikal: Signale sind kodiert, müssen zuerst z.B. von Decodern entschlüsselt werden,
bevor sie an die Elemente weitergereicht werden
-> kompakt, aber sehr langsam

Optionen beim Mikroprogrammspeicher:


ROM (Read-Only-Memory), PROM (Programmable ROM), RAM -> bei jedem Programmstart neu
beschrieben

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Adressen-Abbildungsspeicher:
Makroinstruktion wird durch Adressen-Abbildungsspeicher auf
Adresse der Mikroinstruktion abgebildet
-> JMAP an Leitwerk, um zu dieser Instruktion zu springen

Mikroleitwerk:
- kleiner Stack (Tiefe 5) für Unterprogrammaufrufe
- Adressen-Multiplexer -> wählt Adresse der nächsten Mikroinstruktion
gesteuert durch PLA (Programmable Logic Array)
Quellen:
- Null-Konstante
- Externe Adresse (z.B. aus MIR)
- Mikro-Befehlszähler + 1
- Zählerregister
- Oberstes Stapelelement

Befehle für PLA:


- JMAP: Sprung zu Adresse des entsprechenden Mikroprogramms für aktuellen Befehl
- CONT: Mikrobefehlszähler erhöhen, aktuelles Mikroprogramm weiter ausführen
- JZ: Sprung an die Adresse 0 (IFETCH) und Löschen des Stacks
- CJP: wenn CC (kommt vom Wortrandlogikbaustein) = 1 (Fail), dann wie CONT
wenn CC = 0 (Pass), dann je nach OE_En:
OE_En = PL: Adresse aus Adressfeld im MIR
OE_En = Map: Adresse aus Abbildungsspeicher (s.o.)
- CJS: wenn CC = 1 (Fail), dann wie CONT
wenn CC = 0 (Pass), dann sichern der Rücksprungadresse auf dem Mini-Stack
und Sprung je nach OE_En wie bei CJP mit CC = 0
- CRTN: wenn CC = 1 (Fail), dann wie CONT
wenn CC = 0 (Pass), wird letzter Wert vom Mini-Stack geladen (Pop) und angesprungen
(Rücksprung aus Unterprogramm)

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Ablauf von IFETCH:

1. Befehlszähler wird auf Adressbus ausgegeben


MWE = R, BZ_EA = E (Ausgabe des BZ auf Adressbus), CONT (Weiter zu Befehl 2)

2. Befehl liegt auf Datenbus, wird in Instruktionsregister geladen,


zudem wird der Befehlszähler inkrementiert
IR_LD = L (Datenbus-Wert ins IR laden), BZ_INC = 1 (BZ inkrementieren), CONT (Weiter zu Befehl 3)

3. Abbildungsspeicher berechnet Adresse des entsprechenden Mikroinstruktionsprogramms,


über JMAP wird zu diesem gesprungen
JMAP

Nebeneffektfreiheit:

Achtung: Bei jedem Befehl muss "nebeneffektfrei" gearbeitet werden


-> andere Komponenten des 80-Bit-Worts so setzen, dass sonst nichts passiert

Rechenwerk:

Ein Rechenwerk (Slice) ist zuständig für 4 Bit


Verknüpfung zu beliebig langen RWs möglich
-> BitSlice-Technologie, standardmäßig 16 Bit (4 Slices)
Gesamt-Zero-Flag ist nur gesetzt, wenn alle Zero Flags der einzelnen Slices gesetzt sind
Gesamt-Carry-Flag wird durchgereicht
Gesamt-Sign-Flag nur gesetzt, wenn Sign-Flag des höchsten Slices gesetzt

Register:
16 Register (davon nur 8 für Makro/ASM sichtbar -> eax, ebx, ecx, edx, ebp, esp, edi, esi)

Operandenauswahl ALU:
Über einen Multiplexer wählt man die zwei Operanden R und S für die ALU aus:
Register Q: "Zwischenspeicherregister" für vorheriges Ergebnis (siehe QREG unten)
Register D: externer Eingang des Rechenwerks

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Mögliche Kombinationen:
AQ -> Register A (aus Makrobefehl) und Q
AB -> A und B
ZQ -> Q und 0
ZB -> B und 0
ZA -> A und 0
DA -> D und A
DQ -> Q und A
DZ -> D und 0

ACHTUNG: Es gibt kein DB!

Rechenwerk-Befehle:
8 Befehle (3 Bit kodiert, Tabelle auf Merkblatt):
ADD: R + S
SUBR: S - R
SUBS: R - S
OR: R | S
AND: R & S
NOTRS: ~R & S
EXOR: R ^ S
EXNOR: ~(R ^ S)

Ein-/Ausgang des Rechenwerks:


Das Rechenwerk hat einen externen Ausgang (Y) und einen externen Eingang (D)
Externer Eingang D: von Datenbus oder Konstante (KMUX wählt aus)
Externer Ausgang Y: zu Datenbus oder Adressbus (YMUX wählt aus)

Register-Eingaben A und B beim Rechenwerk:


ASEL und BSEL bestimmen jeweils, ob die Registernummer aus dem Makroinstruktionsregister
oder dem Mikroinstruktionsregister geladen wird
Übergabe an A-MUX und B-MUX, wo die richtige Quelle ausgewählt wird

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Beispiel: man möchte den ASM-Befehl "ADD r1, r2" realisieren

1. als Rechenwerk-Operation "ADD" auswählen, bei ASEL "IR" und bei BSEL "IR" setzen,
als Quelloperanden AB auswählen
-> die beiden angegebenen Register werden ins Rechenwerk geladen
2. RAMF verwenden (siehe unten), um das Ergebnis der Addition ins
Register B zu speichern

Speichern der Ausgabe des Rechenwerks:


Ausgabe des Rechenwerks lässt sich ins Register B oder ins Register Q speichern
(Tabelle bei Klausur bereitgestellt):
QREG: Ergebnis ins Zwischenspeicherregister Q speichern (und auf den Y-Ausgang geben)
RAMF: Ergebnis nach Register B (aus BSEL) speichern (und auf den Y-Ausgang geben)
RAMA: Ergebnis ins Register B (aus BSEL) speichern und Register A auf den Y-Ausgang geben
NOP: Ergebnis verwerfen

Wortrandlogikbaustein:
Mikrostatusregister und Makrostatusregister:
Makrostatusregister für ASM/ISA, Mikrostatusregister für MI

Flags der Statusregister:


OF (Overflow)
CF (Carry)
SF/NF (Sign/Negative)
ZF (Zero)

Mit den Instruktionswort-Bits ~CEµ und ~CEM (~ für "negiert") lassen sich
Änderungen des Statusregisters vermeiden -> auf 1 = keine Änderungen zulassen

Statusbedingungen können abgefragt und ans Mikroleitwerk weitergeleitet werden (Eingang ~CC),
z.B. für einen CJP (Conditional Jump)

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Statusabfragen:
Mnemos für Abfragen (Instruktionswort-Feld "Test"):
Zero (ZF = 1?)
NotZero (ZF = 0?)
UGTEQ (unsigned greater equal; CF = 1?)
ULT (unsigned lower; CF = 0?)
UGT (unsigned greater; CF = 1 (greater equal) && ZF = 0 (not equal?), also greater?)
ULTEQ (unsigned lower equal; CF = 0 (lower?) || ZF = 1 (equal?))

Nebenwirkungsfreiheit:
Im Instruktionswort sicherstellen, dass nichts Unerwünschtes geschieht
Hinweis: Ausgabe H bedeutet 1 (High)

Hauptspeicher: keine Ausgabe auf Daten-/Adressbus (vom Rechenwerk)


-> ~DBUS und ~ABUS auf H, um Y-MUX auszuschalten

Rechenwerk: Ergebnis nicht in Register speichern, verwerfen


-> NOP als Befehl
Ansonsten Befehle egal, z.B. ADD und QZ auswählen

Wortrandlogikbaustein: Flags nicht verändern -> ~CEM und ~CEµ auf H

Leitwerk: einfach weitermachen


-> CONT, evtl. auch Rücksprung zu IFETCH (JZ)
~CCEN auf 1, um keine Bedingung abzufragen

Mikroprogrammierung heutzutage:
kaum mehr verwendet, da viel zu langsam
-> stattdessen Mikro-Ops (Firmen halten das geheim)

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

*** Physikalische Schicht und Bauelemente ***

Implementierung der Schaltungen mit Transistoren


Transistor hat einen Eingang (Source), einen Ausgang (Drain)
und ein Steuersignal (Gate)
Steuersignal entscheidet, ob Strom vom Eingang zum Ausgang fließt
zwei Arten:
Arbeitskontakt -> leitend, wenn Steuersignal an
Ruhekontakt -> leitend, wenn Steuersignal aus

Übergang von leitend zu nichtleitend erfolgt graduell als Funktion


des Stroms, der am Steuereingang einliegt, und nicht sprunghaft

Halbleiter: meistens Silizium, mit Verunreinigungen, um es auch


bei Raumtemperatur leitend zu machen
-> Verunreinigungen: p-dotiert (Aluminium) oder n-dotiert (Phosphor)

MOSFET: am meisten verwendete Transistorart (Metal Oxide Semiconductor Field Effect Transistor)

Herstellung von Halbleitern:


1. Oxidation
2. Fotolackbeschichtung
3. Belichtung durch Maske
4. Entwicklung
5. Fensterätzung im Oxid
6. Fotolackentfernung
7. Diffusion
8. Weitere Schritte (vereinfachend weggelassen)

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

*** Gatter-Schicht ***

Schaltnetze:
gedächtnislos
Jedes Ausgabesignal realisiert eine Funktion der Eingabesignale
z.B. Encoder, Decoder, Multiplexer, Demultiplexer (Umsetzung anschauen!)
auch ROM (Read-Only-Memory)

Schaltfunktion:
eine oder mehrere Eingaben (n) werden abgebildet auf eine Ausgabe (0 oder 1)
z.B. Negation (0 -> 1; 1 -> 0) mit n = 1
oder Konjunktion/Und (0,0 -> 0; 0,1 -> 0; 1,0 -> 0; 1,1 -> 1) mit n = 2

Einsmenge: alle n-Tupel (Eingabekombis), für die das Ergebnis 1 ist


Nullmenge: alle n-Tupel (Eingabekombis), für die das Ergebnis 0 ist

Tipp: Konjunktion ist wie Minimum der Eingänge, Disjunktion ist wie Maximum

Symbole für Gatter:


& AND
>=1 OR
=1 XOR
° Negation (Kringel beim Ein-/Ausgang)

Achtung: Negation der Eingänge != Negation des Ausgangs

Datenflussplan: Schaltungsplan mit Ein-/Ausgängen und Gattern (z.B. bei RS-Flip-Flop)

Binäre Boolesche Algebra/"Schaltalgebra": rechnen mit 1 und 0, NOT, AND und OR


Axiome wie bei Aussagelogik (Kommutativität, Assoziativität, Idempotenz, ...)

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Minimieren:
Jede Schaltfunktion eines Ausgangs durch viele Ausdrücke definierbar
z.B. (A AND B) AND (A OR B) = (A AND A) AND (B AND B) = ... = A AND B
-> Minimieren des Ausdrucks, um möglichst wenige Gatter zu verwenden
weniger Schaltglieder, Eingänge, Stufen und kürzere Leitungen
auch billigere Schaltglieder, z.B. NAND statt OR

Definitionen:
k-stelliges Monom: konjunktiver Term aus k (negierten) Monomen
Minterm: a UND b UND NICHT c UND ...
Disjunktives Polynom: Disjunktion von konjunktiven Monomen (meist DNF)
Benachbart: z.B. (01011, 00011) (Unterschied in genau einer Stelle)
Verschmelzungsmenge: Minterme werden zu einem k-stelligem Monom umgeformt
Für Beispiel zur Vereinfachung siehe Skript
Primimplikant: Minterm, der nicht mehr verschmolzen werden kann

Weitere Vereinfachungsmethoden: Würfel (bei n = 6), KV-Diagramm

Achtung beim KV-Diagramm: auch grenzübergreifende Zusammenfassung möglich


Also geht man rechts raus und kommt links wieder an
auch diagonale Übergänge sind möglich
-> auch diese Belegungen sind benachbart

KNF und DNF wie bei DS


auswählen je nachdem, welche Form kürzer ist, um eine Funktion auszudrücken

Funktionsbündel: Es lassen sich auch mehrere Funktionen (Funktionsbündel) zusammen optimieren

NAND/NOR: Meistens werden NAND und NOR eingesetzt, weil diese besser realisierbar sind (CMOS
billiger)
Jede Schaltfunktion kann durch NAND und NOR realisiert werden

Minimales disjunktives Polynom: günstige NAND-Form


Minimales konjunktives Polynom: günstige NOR-Form

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Umwandlung eines Schaltplans in NAND-Form:


alle Konjunktionen und Disjunktionen durch NANDs ersetzen

Hazards:
Ausbreitung von Signalen mit endlicher Geschwindigkeit, ca. 1ns für 10cm
Laufzeit schwankt in Abhängigkeit von Temperatur und Leitungslänge

Hazard: spezifikationswidriger Ausgabewert, der bei Umstellung


des Eingangswerts ensteht
(z.B. durch unterschiedlich schnell einkommende Eingabewerte)

Lösung: Taktung, Takt muss so lang sein wie der Worst Case-Unterschied in der Ankunftszeit

nach genügend langer Zeit liegt bei Schaltnetz richtiger Wert an


(weil alle Eingaben angekommen)

bei Schaltwerken allerdings ernsthafte Gefahr, da interner Zustand durcheinandergerät

Schaltwerke:
Schaltwerke haben inneren Zustand
-> Feedback-Schleife von (manchen) Ausgaben zu Eingaben, die Zustand speichert

Resultatsfunktion und Zustandsfunktion sind jeweils einzeln betrachtet Schaltnetze

Automaten:
Schaltwerke sind endliche Automaten
Zwei Typen von Automaten:
- Mealy-Automat: M(E, A, Q, λ, δ, q), dabei...
E: die möglichen Eingaben (Eingabealphabet), endlich
A: die möglichen Ausgaben (Ausgabealphabet), endlich
Q: die möglichen Zustände (Zustandsraum), endlich
λ: ExQ -> A die Ausgabefunktion (Resultatsfunktion)
δ: ExQ -> Q die Zustandsübergangsfunktion (Zustandsfunktion)
q: der Anfangszustand

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

- Moore-Automat: M(E, A, Q, λ, δ, q) wie Mealy-Automat, aber:


λ: Q -> A die Ausgabefunktion (Resultatsfunktion)
Also ist die Ausgabefunktion nur noch abhängig vom Zustand,
nicht mehr von der Eingabe

Mealy-Automat <> Moore-Automat:


Jeder Moore-Automat kann in einen Mealy-Automat überführt werden,
und umgekehrt

Moore zu Mealy: einfach E, A, Q, δ, λ und q übernehmen, sodass


bei jedem Übergang nach X für jede beliebige Eingabe Z
λ_Mealy(Z, X) = λ_Moore(X) gilt

Mealy zu Moore: E, A, q übernehmen

- für jeden Zustand X_Mealy erzeuge für jede Eingabe Z mit


λ_Mealy(Z, X_Mealy), d.h. für jeden mögl. Übergang nach X_Mealy im Mealy-Automaten,
einen Zustand XZ_Moore mit λ_Moore(XZ_Moore) = λ_Mealy(Z, X_Mealy)

- für jeden Übergang δ_Mealy(Eingabe R, Vorzustand P_Mealy) = X_Mealy


mit λ_Mealy(R, P_Mealy) = T
erzeuge Übergang δ_Moore(R, PZ_Moore) = XT_Moore für jede mögliche Ausgabe Z

Darstellung eines Automaten:


Darstellung eines Automaten immer entweder mit Automatentafel
oder mit Automatengraph (Zustandsdiagramm)

Latch:
gibt entweder Eingabe durch oder behält zuletzt ausgegebenes Signal bei
z.B. bei RS: 0, 0 behält das Latch letzte Ausgabe bei

RS-Latch mit NORs:


2 Eingänge (Reset, Set), 2 Zustände (q=1, q=0), 2 Ausgänge
Um zu RS-Latch mit NANDs zu machen: Eingänge negieren, NOR durch NAND ersetzen

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Instabilität bei RS-Latch:


Problem: wenn beide Eingaben 1, instabiler Zustand
Lösungen:
- Setzvorrang: ein AND-Gatter mit R-Eingang und negiertem S vor statt R verwenden
-> nur, wenn S=0, kann R=1 werden
- Rücksetzvorrang: wie Setzvorrang, nur mit S statt R

JK-Latch:
wie RS-Latch, aber mit sinnvoller Bedeutung für 1,1:
aktueller Zustand soll invertiert werden
es wird also zustandsabhängig eine der beiden Einsen am Eingang unterdrückt

D-Latch:
Basiert auf RS-Latch, aber nur ein Eingang und CLK
D-Latch hält Wert für den aktuellen Taktzyklus
sobald Rising Edge kommt, wird der Wert wieder auf den Eingang gesetzt

Problem: Gefahr von Hazards

Definitionen:

Prozess: zeitlich zergiederbare Handlung, z.B. Programmausführung

Parallelität: wenn es mind. zwei Schritte gibt, die zu mind. einem Zeitpunkt
parallel laufen, ist ein Prozess parallel
Synchronität: gesicherte Zeitbeziehung zwischen zwei Prozessen
z.B. P1 wartet immer, bis P2 mit einem gewissen Schritt fertig ist
Funktionalität: bei gleichen Eingaben entstehen immer die gleichen Ausgaben

Nur weil zwei Schaltnetze für sich funktional sind, müssen sie gemeinsam nicht auch
funktional sein!
-> Lösung: Takt; Synchronisieren durch Abwarten der "Worst Case"-Zeit

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Synchrones Schaltwerk: Schaltnetz, bei dem die Rückgabe durch ein Taktsignal gesteuert wird
-> Taktsignal steuert Freigabe des internen Zustandes
-> Nachteil: langsam

Flip-Flop:
Latch + Taktung = Flip-Flop

Race:
Unterschied Race <> Hazard: beim Race irrt ein Schaltwerk endgültig,
z.B. fehlerhafter Zustandsübergang
-> folgende Ausgaben auch betroffen
Lösung:
- wenn möglich, einschrittige Zustandsübergänge (nur 1 Zeichen verändert)
- Taktung: alle Rückkopplungswege des Schaltwerks zur gleichen Zeit freigegeben
-> alle Rückkopplungssignale kommen gleichzeitig an

Taktung:
Taktung erzeugt durch Oszillatoren, angegeben in GHz (z.B. moderne CPUs ca. 3-4 Ghz)
Verschiedene Taktungen für verschiedene Einheiten in einem System:
- CPUs am schnellsten
- E/A-Werke und Speicher etwas langsamer

Dynamische Frequenz:
Taktung/Frequenz früher fixiert, heutzutage steuerbar/dynamisch
-> Dynamic Voltage and Frequency Scaling (DVFS)
z.B. niedrigere Frequenz im Stromsparmodus
Leistung = Frequenz * Spannung ^ 2

Power Cap: wenn Prozessor droht zu überhitzen, wird die Frequenz und damit die Spannung
reduziert

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Hazards/Races bei Schaltwerken:


Absicherung gegen Hazards mit Taktung bei Schaltwerken:
Flip-Flop mit vorangestelltem Takt-Tor
(UND mit altem Bitwert und Takt als Eingänge) für jedes Rückkopplungssignal
Somit werden alle Rückkopplungssignale immer zur gleichen Zeit weitergegeben

Master-Slave-Flip-Flop: was, wenn die neue Ausgabe schon weg ist, sobald der Takt kommt?
-> Lösung: MS-FF: zwei Flip-Flops, miteinander verschaltet

Master nimmt Eingänge auf bei positiver Taktung auf, gibt sie
bei negativer Taktung an Slave weiter

Konstruktion eines synchronen Schaltwerks:


1. Anforderungen
Überlegen, welche Eingaben man bei welchen Ausgaben haben will
Welche Schaltungsbausteine (JK-FF, MS-FF, ...) sollte man verwenden?
2. abstraktes Schaltwerk
Zustände und Übergänge überlegen
3. Zustandscodierung
Zustände und Übergänge (und Ein-/Ausgaben) formalisieren
z.B. im Automatengraph
4. Schaltnetz konstruieren
Datenflussplan zeichnen

Rechner sind letztendlich Schaltwerke, da sie:


- endlich viele Eingaben/Ausgaben/Zustände (wenn auch sehr viele) haben
- deterministisch sind
Heutige Rechner sind aber durch die große Menge an möglichen Zuständen
praktisch unendlich

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Optionen beim Schaltungsentwurf:

- Zusammenbau einzelner Komponenten (Gatter & Standardbauteile)


- Integrated Circuits (VLSI = Very large scale integration):
z.B. CPU, GPU,
ASICs (Application Specific Integrated Circuits)
ASICs z.B. für Bitcoin Mining, Proteinfaltung

PLDs: Programmable Logic Devices


Programmierbare Schaltungen
Vorteil: einfacher handhabbar, "Rapid Prototyping"
- langsamer als ASICs
+ viel einfacher zu implementieren, flexibel

Arten von PLDs:


- SPLD (Simple Programmable Logic Device)
Schaltnetz aus vielen UND- und einem ODER-Array
-> einfache Darstellung einer disjunktiven Normalform
- PLA (Programmable Logic Array)
Durch Fuse Maps werden Verbindungen programmiert
-> Minterme und DNF können konstruiert werden
-> banale Methode, ein Schaltnetz zu implementieren
+ einfach programmierbar, Rapid Prototyping
- langsam, viele Pins
-> je nach verwendeter Art von "Fuses" (Sicherungen):
einmal oder mehrmals programmierbar
- P(G)AL (Programmable (General) Array Logic)
wie PLA, aber nur eine Ebene programmierbar
-> UND-Array programmierbar
-> ODER-Array fest verdrahtet
+ einfacher herzustellen, weniger Pins
+ schneller
- weniger flexibel
-> Achtung: je nach verwendeten "Fuses" (Sicherungen):

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Bei PAL: Non-Volatile (nur einmal programmierbar)


Bei GAL: Volatile (beliebig oft programmierbar)
- PROM: Programmable Read-Only-Memory
wie PLA, aber nur eine Ebene programmierbar
-> UND-Array fest verdrahtet
-> ODER-Array programmierbar
also genau andersrum wie beim P(G)AL
- CPLDs (Complex Programmable Logic Device):
Kombination mehrerer SPLDs
ca. 10 - 1000
-> E/A-Blöcke
Hersteller: z.B. Xilinx, Altera
- FPGA (Field Programmable Gate Arrays):
z.B. Einsatz im LHC (CERN), da Netzwerkanbindung möglich
Emulation von beliebigen Schaltungen
-> Logikblöcke
+ einfacher als CPLDs
+ elektronisch reprogrammierbar
-> Netzwerkanbindung (z.B. Ethernet)
-> wesentlich größer als CPLDs
Hersteller: auch z.B. Xilinx, Altera

Logikblöcke: Lookup Table (LUT) als zentrales Element


-> 3-6 Eingänge, 1 Ausgang, realisiert also Schaltfunktion
viele Multiplexer verbinden Logikblöcke, pro FPGA normalerweise ca. 500.000 Logikblöcke
+ schneller als CPUs
- Preis, Aufwand

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

*** VHDL ***

Etappen bei Programmierung von FPGAs:

1. Anforderungen bestimmen
Timing, Ein-/Ausgaben, Optimierungsziele (schnell? billig?)
2. Hardware-Beschreibung
in HDL (Hardware Description Language)
3. Functional Simulation
Simulation der Funktionalität:
- Eingaben vs Ausgaben
- Korrekte Umsetzung der Anforderungen
- Ausgeführt auf Hostrechner
4. Synthese
- Einbezug von Zeitinformation
- Optimierungen
- Übersetzung in Logikblöcke
5. Place and Route
- Abbildung auf konkreten FPGA
- Auswahl der optimalen Logikblock-Konfiguration
6. Timing Simulation (in GTKWave)
- welche Signale werden erzeugt
- tatsächliche Ausgabe vergleichen mit gewünschter Ausgabe
7. Bitstream-Generierung
- Übersetzung in eigentliche Sprache des FPGA
8. Hochladen in den FPGA

Hardware-Beschreibungssprachen:
- ähnliche Idee wie Hochsprachen
- inhärent parallel, im Gegensatz zu Hochsprachen
- Standardsprachen: VHDL (Very High Speed Integrated Circuit HDL) und Verilog

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

VHDL:

Mehrere Arten der Spezifikation von Schaltungen:


- Behavioral: beschreibt Verhalten der Schaltung
+ einfacher als structural
- weniger Kontrolle
- Structural: beschreibt direkt Struktur der Schaltung
+ volle Kontrolle
- aufwendig
- Automat:
- basierend auf Zustandsübergängen, Zustand im Signal zwischengespeichert
- Dataflow

Umsetzung in FPGA kann je nach Spezifikationsart unterschiedlich schnell sein

Basiskonzepte von VHDL:


Jede Komponente hat:
- Entity ("Hülle"/Schnittstelle)
- eine oder mehrere Architectures ("Implementierungen")

VHDL-Syntax:
Siehe Vorlesung #21 (21-vhdl), #22 (22-vhdl-2) oder ZÜ-Folien für Syntax

Testbench: Testprogramm für Schaltung


-> stellt Taktung und Eingaben bereit

Zeitoperationen in VHDL:
Beim Simulieren auch Zeitoperationen zulässig (z.B. wait for 1 s), oft hilfreich,
FPGAs kennen aber keine Zeit -> Zeitoperationen nicht synthetisierbar

Implementierung von Zeitoperationen im FPGA:


Mitzählen von Taktsignalen (z.B. alle 100 ms Takt -> 10 Taktzyklen warten = 1 s)
z.B. in einem Signal zwischenspeichern, CLK in Sensitivity List eines Process,
Signal erhöhen im Process, sobald Signal = 10, eine Aktion ausführen und Signal zurücksetzen

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Achtung: Initialisierung von Signalen auch nicht synthetisierbar


-> Initialisierung über Reset-Signal nötig

Funktionale Simulation:
Tool GHDL transformiert VHDL in ausführbare Simulation
-> generiert Trace-Datei
-> Trace-Datei kann in GTKWave analysiert werden

VHDL auf das FPGA bringen:


Umwandlung von VHDL in Bitstream und Hochladen auf FPGA mit IDE:
z.B. mit Xilinx Vivado
in IDE kann man Eingänge und Ausgänge auswählen
z.B. Eingänge mit Tasten und Ausgänge mit LEDs verschalten

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

*** Speicher und Caches ***

Memory Wall: Der "von Neumann-Flaschenhals"; Prozessoren werden immer schneller, Speicher
bleiben aber etwa gleich schnell
Prozessor muss häufig auf Speicher warten -> reduzierte Auslastung
-> von-Neumann-Architektur erweitert, um Speicherzugriffe schneller zu machen
- kleinere Latenz (Zugriffsdauer)
- mehr Bandwidth (Zugriffsdurchsatz)

Halbleiterspeicher-Arten:

- RAM: Random Access Memory (für von Neumann)


- ROM: Read-Only-Memory
- PROM: zerstörbare Sicherungen
- EEPROM: Kann "geflasht" werden (neu beschrieben)
Daten bleiben auch ohne Spannung erhalten
- Flüchtige Speicher:
- SRAM (Static RAM): ähnlich zu Flip-Flops
Datenzellen haben Bit und Nicht-Bit (zum Schreiben/Lesen)
Speicher ist 2D-Matrix von Speicherzellen + Decoder (zum Anwählen von Zellen)
-> Schreiben: anwählen über Select-Leitung, dann
Wert ausgeben (Wert auf Bit, inv. Wert auf nicht-Bit)
-> Lesen: Bit und Nicht-Bit auf 1 setzen
-> Spannungsabfall auf einem Ausgang durch Kondensatoren
-> auf welchem Ausgang Spannungsabfall gemessen wurde,
gibt Wert der Zelle an
+ sehr schneller Zugriff
- teuer
- hoher Energiebedarf

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

- DRAM (Dynamic RAM): Ladung in Kondensatoren


Kondensator, der Ladung halten kann
DRAM-Array: sehr breit, um Kapazität zu erhöhen
Zugriff liest immer gleich die ganze Zeile in Zeilenpuffer
SDRAM: Synchronous DRAM (alle Signale getaktet)
DDRAM: Double Data Rate SDRAM, mittlerweile DDR4
Speicherkontroller früher in North-Bridge, heute in CPU
-> Schreiben: Zelle anwählen, dann 0 oder 1 an Bitleitung anlegen
Kondensator lädt oder entlädt sich
-> Lesen: Zelle anwählen, Wert zwischen 0 und 1 an Bitleitung anlegen
Bei 0: Kondensator lädt sich, Spannungsabfall
Bei 1: Kondensator entlädt sich, Spannungszufluss
+ einfacher Aufbau
+ leichte Massenproduktion
- langsamer Zugriff
- Lesen zerstört die Information
- Kondensator verliert Ladung
-> Lösung:
-> nach Lesen werden Daten sofort wieder geschrieben
-> regelmäßiger Refresh durch DRAM
heute automatisch im Baustein integriert

Memory Wall: Lücke zwischen CPU-Leistung und Speicherleistung wächst


jedes Jahr um 50%

Forschungsansätze zur Überwindung der Memory Wall:


PIM (Processor In Memory), HBM (High Bandwidth Memory)

Aktuelle Ansätze zur Überwindung der Memory Wall:


Caches
-> kleine, schnelle Zwischenspeicher nahe am Prozessor
-> transparent für Programmierer, notfalls manuell steuerbar

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Lokalitätsprinzip bei Caches:


- zeitliche Lokalität
-> Zugriff auf eine Adresse wird sich wahrscheinlich bald wiederholen
- räumliche Lokalität
-> Zugriff auf eine Adresse macht Zugriff auf Nachbaradressen wahrscheinlicher

Lesezugriff auf Cache:


Cache-Hit: Datum im Cache vorhanden, gebe es zurück
Cache-Miss: Datum nicht vorhanden, Anfrage an Hauptspeicher weiterleiten
und Datum (+ Umfeld) aus Hauptspeicher laden
Tags: Adresse der Daten im Hauptspeicher
Statusbits: Infos über Daten (Eintrag gültig?)

Übersetzung Adresse im Hauptspeicher <> Adresse im Cache:


Offset-Bits: Index in einer Cachezeile (z.B. hat Cachezeile 32 Bytes -> welches Byte?)
Index-Bits: Cachezeile, in der Adresse sein kann (wie hashCode in Java)
Tag-Bits: Beschreiben, welche Daten in Cachezeile sind

Bei Cache Miss wird die Cachezeile mit dem entsprechenden Index durch das gelesene Datum ersetzt

Cache-Assoziativität:
-> Adressen können in eine von mehreren Cachezeilen abgebildet werden
-> weniger Index-Bits, mehr Tag-Bits

- Vollassoziativer Cache: jede Adresse auf jede Cachezeile abbildbar


- Mengenassoziativer Cache: jede Adresse auf Teil d. Cachezeilen abbildbar

Ersetzungsstrategie:
LRU (Least Recently Used): lange nicht verwendet
LFU (Least Frequently Used): sehr selten verwendet

Aktualisierungsstrategie bei Schreibzugriff auf Cache:


Write-through: Änderung sofort an Hauptspeicher weitergeleitet
Write-back: Änderung erst später weitergegeben

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Cache-Misses:
Compulsory Miss: erster Zugriff auf Adresse
Capacity Miss: Cache zu klein, um alle Daten zu halten
Conflict Miss: Speicherblock von anderem verdrängt
-> nur in nicht vollassoziativem Cache

Beispiel: zwei Schleifen zur Matrixmultiplikation,


Reihenfolge der Verschachtelung kann Geschwindigkeit um 8x erhöhen,
da eine Cacheline 64 Bytes hat

Kombination von Caches und Memory Management Unit:


- Virtually Indexed Cache: Cache vor MMU
+ direkter Zugriff ohne Übersetzung
- mehrere Prozesse nutzen die gleichen virtuellen Adressen
-> Cache bei Prozesswechsel löschen: langsam
-> Cache um PID erweitern: langsam
- Physically Indexed Cache: Cache nach MMU
+ übersteht Prozesswechsel
- Zugriff muss erst durch MMU

Translation Lookaside Buffer: merkt sich für Cache Übersetzungen der Adressen

Cache-Hierarchie:
Je kleiner ein Cache, desto schneller
3 Stufen von Caches, immer weiter vom CPU weg und immer größer
Intel: L1, L2, L3

Memory Mountain: Übergänge zwischen Cachestufen (Zeitdauer) bei Zugriff auf verschieden große
Arrays und verschieden weit entfernte Elemente in diesen Arrays gut sichtbar

Harvard-Architektur: getrennter L1-Cache für Code und Daten


Grund: Zugriffe behindern sich gegenseitig, andere Zugriffsmuster bei Code vs. bei Daten

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Inklusive/Exklusive Cache-Hierarchien:
- inklusive Cache-Hierarchie: alle Speicherblöcke in kleinem Cache auch in großem Cache
- exklusive Cache-Hierarchie: jeder Speicherblock höchstens einmal gecacht

Optimierung von Programmen für Cache:


- Umordnen von Daten
- Umordnen von Speicherzugriffen
- Schleifen vertauschen
- Cache Blocking: Aufteilen von Datenstrukturen, die in den Cache passen

Testen, wie gut der Cache genutzt wird:


- Zeitmessung im Code
- Hardware Counter: z.B. PAPI (Zählen von Misses in L1/L2/L3-Cache, Anzahl der Ladeinstruktionen)

Prefetching: Daten in Cache laden, bevor sie gebraucht werden


Implementierung in: Hardware, Compiler, Software

Software prefetching:
x86: PREFETCH-Instruktionen

Hardware prefetching:
Hardware entdeckt selbst Zugriffsmuster, liest zukünftige Daten

Optimierungen in modernen Prozessoren:


Hardware Pipelining: Rechenwerke am Arbeiten halten (z.B. bei Speicherzugriff)
Befehlszyklus:
1. Instruction fetch
2. Instruction decode
3. Execute
4. Memory Access
5. Write Back

Pipelining: taktsynchrone, verschachtelte Bearbeitung mehrerer Befehlszyklen auf einmal


Pipeline-Stufe: eine Verarbeitungseinheit

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Befehls-Pipelining: Zerlegung eines Maschinenbefehls in Teiloperationen,


parallele Verarbeitung

Auch Pipelining innerhalb der Pipeline selbst möglich

Hazards in der Pipeline:


- Structural Hazard: Ressourcenprobleme in Hardware
- Control Hazard: Pipelineneustart bei Sprüngen, nächster Befehl unbekannt
- Data Hazard: Datenabhängigkeit nicht erfüllt

- Data Hazards: Umgehen durch Forwarding/Bypassing


-> z.B. Weiterleiten der Daten an nächsten Befehlszyklus,
bevor sie ins Register geschrieben werden

- Control Hazards: wegen Sprungbefehl nächster Befehl unbekannt


-> Branch Predictor: sagt vorher, welche Befehle als nächstes ausgeführt werden
z.B. in Schleife: in 99% aller Fälle Rücksprung zum Schleifenanfang
-> Branch Delay Slots: N Befehle nach dem Sprung werden immer auch ausgeführt
zur Not mit NOP befüllen

Dynamisches Scheduling / Out-of-Order-Execution:


Voneinander unabhängige Instruktionen können parallel ausgeführt werden
-> Ausführung wird "Out of Order"
-> von außen weiterhin transparent

Superskalarprinzip:
mehrere Maschinenbefehle gleichzeitig ausführbar durch mehrere Rechenwerke
-> zwei oder mehr Pipelines statt nur einer

VLIW-Prozessoren (Very long instruction word):


mehrere Instruktionen in einem Befehl integriert
-> Compiler entdeckt Parallelität und kodiert sie in Instruktionen

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

*** Explizite Parallelität ***

Flynn's Classification:
- SISD: Single Instruction Single Data
-> Klassisches von Neumann
- SIMD: Single Instruction Multiple Data
-> SSE/AVX
-> GPUs: extremes SIMD
Ursprünglich für Grafiken (Dreiecke Zeichnen, Texturen, Shading)
Heutzutage z.B. für Deep Learning
- MIMD: Multiple Instruction Multiple Data
-> mehrere Hardware-Threads
jeder Thread führt eigenen Instruktionsstrom aus
gemeinsame Ressourcen, gemeinsamer Speicher (sonst getrennte Maschinen)
moderne GPUs sind MIMD (mehrere parallele SIMD Blöcke)
-> Mehrkern-Architekturen:
getrennte Kerne in einem Prozessor, gemeinsamer Speicher
-> Konsequenzen im ganzen System:
- mehrere Kerne greifen auf Bus zu
-> Speicherkontroller besser gleich in CPU integrieren
mehrere Speicherkontroller pro Prozessor
- Cache muss zwischen Kernen geteilt werden
-> man braucht automatische Cache-Kohärenz, um Konflikte zu vermeiden
-> Snooping:
Bus zwischen Caches
-> Write Invalidate: Schreibzugriff führt zu Invalidierung anderer Zeilen
-> Write Update: Propagieren des neuen Wertes
-> MSI-Protokoll:
jede Cachezeile verfolgt laufend ihren Status mit
Automat mit drei Zuständen:
- Modified: Cachezeile geändert, Speicher nicht kohärent
- Shared: Wert in mindestens zwei Caches, kohärent

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

- Invalid: Cache-Block ungültig oder veraltet


Automat nach jedem Zugriff aktualisiert
Erweiterung: MESI-Protokoll: MSI + Exclusive (Wert nur in einem Cache, automatisch kohärent)
-> Alternative: Directory Protocol
Statusbits in zentralem Verzeichnis
+ kein Bus mehr nötig, schneller
-> heutzutage meist statt Snooping verwendet
-> False Sharing: Cachezeilen wandern unnötig zwischen Caches
- neue Assemblerbefehle nötig: atomare Operationen (lock, unlock)

*** Threading ***

Hardware Thread: Ausführungseinheit im Prozessor, eigener BZ und Rechenwerk


Software Thread: Programmierabstraktion, beschreibt Ausführungszustand

Scheduling: Betriebssystem bildet Software-Threads auf Hardware-Threads ab

Stackaufbau bei mehreren Threads:


Jeder Thread hat eigenen Stack, Stacks im Heap versetzt

Varianten bei Threading:


- nebenläufige Programme
getrennte Aufgaben, lose Kooperation
z.B. GUI-Thread und Hauptthread
- parallele Programme
z.B. numerische Berechnungen

- Threads sind eng gekoppelt (gemeinsamer Adressraum)


- Prozesse sind lose gekoppelt (Inter-Process Communication/Sockets)

Fork: Masterthread läuft sequentiell, Fork startet neuen Thread


Join: Masterthread wartet, bis Worker-Thread beendet ist

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Kommunikation zwischen Threads:


Producer/Consumer-Modell, Locks

Sequentielle Konsistenz:
Ergebnis jeder Ausführung ist gleich der Ausführung der einzelnen Prozessor-
aufgaben in beliebiger Reihenfolge, Reihenfolge in Prozessoraufgaben bleibt immer gleich
- teuer
- langsam
-> die meisten Systeme nicht "sequentially consistent"

Locks:
- Spin Locks: falls Lock vergeben, warte in Schleife auf Freigabe
- Yielding Locks: falls Lock vergeben, führe anderen Thread aus

Achtung: Locks müssen atomar sein!

*** Eingabe/Ausgabe ***

Externe Busse:
Früher: viele Standards für Anschlüsse von Bildschirmen, Druckern, usw.
Heute: größtenteils durch USB (Universal Serial Bus) ersetzt

Interne Busse:
Früher: viele Standards (z.B. ISA = Industry Standard Architecture)
Heute: PCI (Peripheral Component Interconnect)
-> Anschluss aller möglichen Karten
-> 2003 Erweiterung: PCI Express (heute bis zu 63 GB/s)
-> Nachteil: weit von CPU weg -> langer Datentransfer
Initiativen:
- AMD Fusion (GPU und CPU in einem)
- prozessornahe Busse
- spezielle Anbindung: NVLINK von NVIDIA

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

Netzwerke:
WAN: Wide Area Network (weite Entfernungen, Internet)
LAN: Local Area Network (lokale Netzwerke, z.B. innerhalb Firma)
SAN: Storage Area Network: Anbindung von Speicher

Ethernet: einsetzbar für WAN/LAN/SAN


heutzutage bis zu 100 Gbit/s
+ niedriger Preis
+ gute Leistung
+ skalierbar
-> TCP/IP: Standard-Protokoll für Kommunikation über Internet

Alternative zu Ethernet: User-level Communication


-> OS baut Verbindung auf, danach direkte Kommunikation
von Programm zu Programm
+ schneller
meist Standard für HPC
-> VIA Architecture
am weitesten verbreitet: Infiniband
-> Entlastung des CPUs durch Netzwerkkarte

Netzwerk-Topologien:
Fat-Tree: Baumstruktur
Torus: 3D-Matrix-Struktur
Dragonfly: Sternstruktur
Hypercube: n-Dimensionaler Würfel

Shared-Nothing-Architektur in HPCs:
Knoten nur durch Netzwerk verbunden,
ansonsten keine gemeinsamen Ressourcen

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

*** Einbindung von Ein-/Ausgabegeräten in den Rechner ***

CPU braucht Zugriff auf Ein-/Ausgabegeräte


- Direct I/O:
- spezielle Befehle im Befehlssatz
- separate Adressen, die I/O-Geräte ansprechen
- separater Bus für I/O

- Memory Mapped I/O:


- Geräte über einen Bereich des Hauptspeichers angesprochen
- bestimmte physikalische Adressen sprechen E/A-Geräte an
- durch virtuelle Speicherverwaltung kontrollierbar, wer zugreifen darf

Kommunikation/Synchronisation:
- Direct I/O (Achtung: selber Name wie oben, andere Bedeutung):
Prozessor kontrolliert E/A direkt, wartet auf Daten
+ schnell
- Interrupt-driven:
- Prozessor löst Zugriff aus
- E/A-Einheit arbeitet alleine
- Interrupt bei Abschluss
- DMA = Direct Memory Access
- Prozessor beschreibt Transfer
- unabhängiger Kontroller (DMA) führt ihn aus
- Interrupt bei Abschluss

E/A im Mehrbenutzerbetrieb:
- gemeinsam genutzte Ressource
- Zugriffsbeschränkung nötig
- Aufgabe des Betriebssystems
- Direct I/O nur durch OS
- Memory Mapped I/O kontrolliert durch OS
-> Hardware muss virtualisierbar sein für direkten Zugriff
-> nach dem Mapping muss Speicherbereich für Prozess sicher sein

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)


lOMoARcPSD|4653659

-> Ansprechen der Geräte durch Gerätetreiber


Zwei Optionen:
- Block Devices: Blöcke von Daten, z.B. Dateisystem (zufälliger Zugriff)
- Stream Devices: Strom von Bytes, z.B. Tastatur (kein zufälliger Zugriff)

Hintergrundspeicher:
- Erweiterung des Hauptspeichers
- dauerhafte Speicherung von Daten
Häufige Verfahren:
- magnetische Aufzeichnung:
- Festplatte, Magnetband, Diskette
- Flash-Speicher (eingeschlossene Ladungen): USB
- Optische Speicher: CD, DVD

Oft als weitere Stufe in der Speicherhierarchie gesehen

Magnetische Aufzeichnung (Festplatten):


- zwei verschiedene Magnetisierungsrichtungen für 0 und 1
- Schreiben/Lesen durch Magnetkopf (Elektromagnet)
-> Einfügen von Prüfbits zur Fehlererkennung
- Plattenstapel: viele Platten pro Festplatte
- pro Platte des Plattenstapels zwei Köpfe (Lesekopf, Schreibkopf)
- mit der Zeit Abnutzung, Head Crashes
- Backups mit RAID (Redundant Array of Independent Disks)

NV-RAM / SSDs: Alternative zu magnetischer Aufzeichnung


-> Random Access Memory, das Daten ohne Strom hält
-> als NAND-Flash oder NOR-Flash
- NAND schneller und kleiner, aber nur Blockzugriff
Anzahl der Löschvorgänge begrenzt
-> Wear-Leveling nötig: breite Verteilung von Löschvorgängen
- NOR zuverlässiger, lässt Einzelzugriffe zu

Heruntergeladen durch Quantyna Ysua (teodorapatrascu33@yahoo.com)