1. No category

TECHNISCHE UNIVERSITÄT MÜNCHEN
Fakultät für Elektrotechnik und Informationstechnik
Lehrstuhl für Datenverarbeitung
Prof. Dr.-Ing. K. Diepold
Computersysteme
SS 2015
BH-Phase
Kap. 4.2.1,
4.2.2
ZusatzLogik für
komplexe
Befehle
AF-Phase Integer
Rechenwerk/ALU
Kap. 4.2.5, 4.2.6, 4.4.4
Takt
BD-Phase
Kap. 4.2.3,
4.2.4,
TLB
AF-Phase Gleitkomma
Rechenwerk/ALU
Kap. 4.4.4
Bus
Kap. 1.1.2
Logik für BusSchnittstelle
Kap. 5
Befehls-Cache
Kap. 6.3
TLB
Daten-Cache
Kap. 6.3
1-1
MikroprogrammLogik, ~ Kap. 4.4.5
Sprung-Vorhersage, ~Kap. 8.2
Inhalt
1! Motivation: Wie funktioniert ein Computer?................................ 1-3!
1.1! Komponenten eines Computers ............................................................................................... 1-3!
1.1.1! Peripherie-Geräte und Netzteil ...................................................................................... 1-5!
•! Netzteil................................................................................................................................... 1-5!
•! Grafikkarte ............................................................................................................................. 1-8!
•! DVD-ROM .......................................................................................................................... 1-17!
•! DVD-Brenner ...................................................................................................................... 1-25!
•! Festplatte .............................................................................................................................. 1-26!
1.1.2! Komponenten auf der Hauptplatine - Überblick ........................................................... 1-34!
•! Prozessor .............................................................................................................................. 1-36!
•! Arbeitsspeicher .................................................................................................................... 1-41!
•! Busse .................................................................................................................................... 1-48!
•! GMCH = Graphics and Memory Controller Hub (B) ......................................................... 1-57!
•! ICH5 = Input/Output Controller Hub (5. Generation) (C) .................................................. 1-57!
•! SIO-Controller = Super Input/Output Controller (D) .......................................................... 1-57!
1.2! Von Neumann-Architektur....................................................................................................... 1-58!
1.3! Harvard-Architektur ................................................................................................................. 1-62!
1.4! Vom Algorithmus zum Prozessor – Abstraktionsebenen .................................................... 1-63!
1-2
1 Motivation: Wie funktioniert ein Computer?
In diesem Kapitel geben wir Ihnen eine kleine Einführung in den Vorlesungsstoff der Computertechnik.
Dieses Kapitel ist jedoch mehr als nur eine Einführung. Es dient als Überblick über den Aufbau und
die Funktionsweise gängiger Arbeitsplatzrechner. Während dieses Kapitel dabei einen kompletten PC
betrachtet, fokussieren die restlichen Kapitel fast ausschliesslich auf den Prozessor.
Ziel dieses Kapitel ist es, Ihnen das Umfeld von Prozessoren und die Interaktion von Prozessoren mit
diesem Umfeld näherzubringen. Wenn Sie verstanden haben, welche Aufgabe Prozessoren in diesem
Umfeld haben, dann kennen Sie automatisch auch das Funktionsvermögen von Prozessoren, wissen
also, was so ein Prozessor eigentlich können muss. Dies ist die Voraussetzung für die restlichen Kapitel dieses Skripts, in denen wir uns einen eigenen Prozessor zusammenbauen werden.
1.1 Komponenten eines Computers
In diesem Kapitel öffnen wir einen gewöhnlichen Arbeitsplatzrechner und schauen uns einmal an, was
da alles drinnen steckt. Dabei werden wir die zutage tretenden Komponenten hinsichtlich Funktion
und Aufbau untersuchen. Nachdem wir uns bis zu den auf der Hauptplatine befindlichen Komponenten vorgearbeitet haben, werden wir durch eine Abstraktion (Verstecken von Details) die prinzipielle
Funktionsweise des PCs zu erläutern.
Nach dieser Abstraktion werden wird wieder detailreicher, wenn wir das reale (nicht abstrahierte) Zusammenspiel der einzelnen Komponenten betrachten.
Nachfolgende Abbildung zeigt den Arbeitsplatzrechner, den wir im Folgenden zerlegen werden.
Abb. 1: Computer-Arbeitsplatz
1-3
Wir schrauben die Seitenverkleidung ab …
Abb. 2: Öffnen eines Computers
… und identifizieren die dann erscheinenden Komponenten.
DR
NT
DB
DL
GK
FP
FW
Abb. 3: Geräte in einem Computer
1-4
1.1.1
Peripherie-Geräte und Netzteil
• Netzteil
Das mit NT gekennzeichnete Gerät ist das Netzteil. Es dient zur Stromversorgung des PCs.
Abb. 4: Computer-Netzteil
Computernetzteile wandeln die aus der Steckdose kommenden 230 V Wechselspannung in folgende
Gleichspannungen um:
− +3,3 V und +5 V für das Mainboard (die grosse grüne Platine) und die darauf befindlichen bzw.
damit verbundenen elektrischen Bauteile.
− +12 V für die Motoren der Laufwerke und Lüfter.
− -5 V und -12 V, die heutzutage meist gar nicht mehr verwendet werden, sondern zumeist nur
noch aus Gründen der Kompatibilität zu älteren Geräten vorhanden sind (z.B. -5 V und -12 V für
den ISA-Bus, der in der heutigen Zeit fast nur noch in der Industrie zur Maschinensteuerung
(z.B. CNC-Fräßmaschine) verwendet wird oder -5 V zur ±5 V-Versorgung älterer FloppyController, die zur Verstärkung des Lesesignals noch Operationsverstärker ohne Ladungspumpe einsetzen).
Insbesondere der hohe Stromverbrauch des Hauptprozessors und der Grafikkarte erfordern die Bereitstellung hoher Ströme. Nachfolgende Abbildung zeigt eine typische Aufteilung der Leistung auf die
+3,3 V, +5V und +12 V Leitungen. Die Leitung mit der Bezeichnung +5 VSB (SB = Standby) dient zur
Versorgung bestimmter Rechner-Komponenten im Standby-Modus (z.B. Arbeitsspeicher).
1-5
Ausgangsspannung
Strom (max.)
+3,3 V
+5 V
+5 VSB
+12 V
26 A
42 A
2,5 A
18 A
12,5 W
216 W
Leistung (max.)
220 W
max. Gesamtleistung
450 W
Abb. 5: Typische Ausgangsleistung eines ATX-Netzteils
Aufgrund dieser hohen Ströme erfolgt die Spannungsreduktion von 230 V auf die gewünschten Ausgangsspannungen nicht durch einen gewöhnlichen Transformator, sondern durch den Einsatz eines
Schaltnetzteils.
In PCs eingesetzte Schaltnetzteile haben oft folgenden Aufbau:
Gleichrichter
°
230 V ~
°
°
•
~
°•
°
•
•
°
LeistungsSchalter
Gleichrichter
HF-Trafo
•
=
°
°
°
1
2
°
°
°
°
~
3
°•
°
Potentialtrennung
°
°
°
°
TiefpassFilter
°
°
•
°
°
•
°
•
•
4
°
•
=
5
Regler
=
7
6
Abb. 6: Prinzip-Aufbau eines Schaltreglers
Eine mögliche Zuordnung der Komponenten ist in nachfolgender Abbildung angegeben.
4
3
2
5
2
6
1
3
7
3
Abb. 7: Identifizierung von Schaltregler-Komponenten
1-6
°
5V=
°
Der in Abb. 6 gezeigte Schaltregler funktioniert wie folgt:
− Die Netzspannung (230 V Wechselspannung, 50 Hz) wird an einen Gleichrichter (1) angelegt,
der daraus eine Gleichspannung generiert.
− Über einen Leistungsschalter (2) wird diese Spannung der Primärseite eines HF-Trafos (3) zugeführt. Der Leistungsschalter sorgt durch permanentes Ein- und Ausschalten dafür, dass die
am HF-Trafo angelegte Spannung mit einer Frequenz von ca. 20 – 200 kHz ein- und ausgeschaltet wird.
− Der HF-Trafo (3) überträgt die an der Primärseite angelegte Spannung auf seine Sekundärseite.
− Der Gleichrichter (4) erzeugt aus der sekundärseitigen Wechselspannung wieder einen rein positiven Spannungsverlauf, der durch das Tiefpassfilter (5) auf einen Mittelwert gebracht wird.
− Dieser Mittelwert entspricht der aktuellen Ausgangsspannung.
− Die Ausgangsspannung dient als Eingang für den Regler (6), der zur Aufgabe hat, die Ausgangsspannung auf einem bestimmten Niveau zu halten. Dies erreicht der Regler durch Änderung des An-/Aus-Verhältnisses des Signals, das den Leistungsschalter steuert. Die Ausgangsspannung des Schaltnetzteils ist dabei lediglich abhängig vom Tastverhältnis (Verhältnis der
An-/Aus-Zeit) des Signals, das den Leistungsschalter ein- bzw. ausschaltet.
− Die Potentialtrennung (7), die in der Regel durch Optokoppler erreicht wird, verhindert, dass die
230 V Netzspannung über den Regelkreis zum Ausgang des Netzteils gelangt.
Zwar müssen in Schaltreglern auch Trafos eingesetzt werden, diese können jedoch wesentlich kleiner
gebaut werden, da sie durch die Verwendung einer hohen Frequenz (20 – 200 kHz statt 50 Hz Netzfrequenz) wesentlich mehr Leistung (proportional zur Frequenz) übertragen können und die Windungsanzahl somit gering bleiben kann.
Wenige Windungen auf der Sekundärseite ⇔ geringer Innenwiderstand der Sekundärseite ⇔ in der
Sekundärseite wird wenig Leistung in Wärme umgewandelt ⇒ guter Wirkungsgrad.
Nachfolgend angegebene Steckerbelegung eines ATX-Netzteils zeigt, dass aufgrund der hohen
Strombelastung bei +3,3 V und +5 V diese Spannungen über mehrere Kontakte parallel übertragen
werden.
+3,3 V
11
1
+3,3 V
-12 V
12
2
+3,3 V
GND
13
3
GND
PS_ON
14
4
+5 V
GND
15
5
GND
GND
16
6
+5 V
GND
17
7
GND
-5 V
18
8
PW_OK
+5 V
19
9
+5 VSB
+5 V
20
10
+12 V
Abb. 8: Steckerbelegung eines (ATX-) Netzteils
Die Signale PS_ON und PW_OK haben folgende Funktion:
− PS_ON ist die Abkürzung für Power supply on. Dieses Signal ist ein Eingangs-Signal und dient
dazu, das Netzteil einzuschalten. Die Leitung PS_ON muss dabei auf Masse (GND für engl.
Ground) gelegt werden.
− PW_OK ist die Abkürzung für Power ok. Dieses Signal liegt beim Einschalten des Netzteils auf
Masse und wechselt auf einen Pegel von etwa 5 V, wenn sich die vom Netzteil gelieferte Spannung nach dem Einschalten stabilisiert hat. PW_OK ist auf der Hauptplatine mit dem Taktgeber
des Prozessors verbunden und sorgt über die Reset-Leitung dafür, dass der Prozessor erst
dann mit der Abarbeitung von Befehlen beginnt, wenn sich die Versorgungsspannung stabilisiert hat. Auf diese Weise wird verhindert, dass der Prozessor in einen undefinierten Zustand
gerät.
1-7
• Grafikkarte
Die in Abb. 3 auf Seite 1-4 mit GK gekennzeichnete Einsteck-Platine ist die Grafikkarte.
Stecker für zusätzliche Stromversorgung
Anschluss für den
Monitor (DVI)
Speicherchips mit Kühlkörper
BIOS
Anschluss für den
Monitor (VGA)
GPU mit Kühlkörper
(GPU = Graphics
Processing Unit)
AGP-Anschluss
(Verbindung zum Prozessor)
Abb. 9: Grafikkarte
Die Grafikkarte besteht aus folgenden Komponenten:
− GPU (Graphics Processing Unit): Der Prozessor der Grafikkarte. Die GPU implementiert die von
der Grafikkarte bereitgestellten Funktionen:
+
+
+
+
+
Kommunikation mit dem PC-Prozessor (hier über AGP)
Ansteuerung der Speicherchips
RAMDAC → Wandlung der digitalen Bildinformationen in analoge Bildschirm-Signale (s.u.)
Kommunikation mit dem Monitor (über VGA oder DVI)
Beschleunigung von 3D-Funktionen
− Speicherchips, um Bilddaten und sonstige anfallende Daten abspeichern zu können
− BIOS (Basic Input Output System), um die Grafikkarte auch schon vor dem Laden von Grafikkartentreibern verwenden zu können (s.u.)
− AGP-Anschluss (oder auch PCI-Express) zur Kommunikation mit dem PC-Prozessor
− VGA- bzw. DVI-Anschluss zur Kommunikation mit dem Monitor
1-8
Die Grafikkarte hat im wesentlichen zwei Aufgaben:
− Sie dient als Schnittstelle zwischen Computer und Bildschirm.
− Sie beschleunigt grafikrelevante Berechnungen (insbesondere 3D-Berechnungen).
Als Schnittstelle zwischen Computer und Bildschirm übersetzt die Grafikkarte die Daten, die der Prozessor liefert, in Signale, die der Bildschirm zur Anzeige benötigt.
Die Grafikkarte verfügt über einen sog. Grafik-Speicher (oft auch Video-Speicher genannt).
− In diesen Speicher schreibt der Prozessor die Daten, die er als Bild angezeigt bekommen will.
− Die Grafikkarte liest diese Daten aus und erzeugt aus diesen Daten die entsprechenden Bildschirm-Signale.
1
Die einzelnen Byte im Video-Speicher werden direkt auf Pixel -Farben abgebildet. Die Farbe eines
einzelnen Pixels ergibt sich dabei aus der Kombination eines roten (R), grünen (G) und blauen (B)
Bildschirmpunkts. Nachfolgende Abbildung zeigt, wie die im Video-Speicher abgelegten Byte der Intensität (Helligkeit) der jeweiligen Bildschirmpunkte (Grundfarben) zugeordnet werden.
Video-Speicher in der Grafikkarte
Bildschirm
0x3F
pro Grundfarbe 1 Byte
⇒ 24 Bit Farbtiefe
G
R
0x00
B
0x78
1 Pixel
0xE8
B
B
R
G
R
G
R
G
R
0xFF
B
B
B
R
G
R
G
R
G
B
B
R
…
R
G
…
…
Abb. 10: Abbildung der im Video-Speicher abgelegten Werte auf die Intensität von Bildschirm-Punkten
Durch Ändern einzelner Byte im Grafik-Speicher kann der Prozessor die Intensität jedes rot (R)-, grün
(G)- oder blau (B)-Anteils eines Pixels ändern. Soll ein Pixel beispielsweise Rot erscheinen, werden
den zugehörigen drei Byte im Grafik-Speicher die Werte R = 0xFF, G = 0x00, B = 0x00 zugeordnet.
Grün entspricht dann R = 0x00, G = 0xFF, B = 0x00 und ein dunkles Grau etwa R = 0x60, G = 0x60, B
= 0x60.
Zum Verständnis der Umwandlung der im Grafik-Speicher der Grafikkarte abgelegten Byte in ein Bildschirm-Signal ist es sinnvoll zu wissen, wie diese Bildschirmsignale überhaupt aussehen.
Bildschirm-Signale, die aus dem DVI-Anschluss kommen, sind digital und können in der Regel nur von
TFT-Bildschirmen verwendet werden.
Die Signale, die aus dem VGA (Video Graphics Array)-Anschluss einer Grafikkarte kommen, sind
analog und so aufgebaut, dass sie sich sehr leicht von einem Röhrenmonitor verarbeiten lassen. Aus
diesem Grund schauen wir uns erst einmal kurz an, wie ein Röhrenmonitor funktioniert (auch wenn
diese gerade von TFT-Bildschirmen vom Markt gedrängt werden).
1
Pixel ist ein aus picture element zusammengesetztes Kunstwort und bezeichnet die Punkte, aus denen gerasterte Bilder
aufgebaut sind. Die Farbe eines Pixels wird dabei aus den drei Grundfarben rot, grün und blau zusammengemischt.
1-9
Ein (Farb-)Röhrenmonitor enthält drei Kathoden, die jeweils einen Elektronenstrahl aussenden. Jeder
Elektronenstrahl (und somit jede Kathode) ist dabei für eine der drei Grundfarben (RGB) zuständig.
Die drei Elektronenstrahlen können in der Röhre durch sog. Ablenkspulen derart abgelenkt werden,
dass der Auftreffpunkt der Elektronenstrahlen auf der Bildschirmvorderseite horizontal und vertikal
verschoben werden kann. Durch Anlegen einer geeigneten Spannung kann man den Elektronenstrahl
somit an einer beliebigen Stelle auf der Vorderseite der Bildröhre auftreffen lassen.
Abb. 11: Durch geeignete Spannungen an den Ablenkspulen
kann der Auftreffpunkt der drei Elektronenstrahlen beliebig
in horizontaler und vertikaler Richtung verschoben werden.
Um aus den Elektronenstrahlen Farben erzeugen zu können, sind innen auf der Bildschirmvorderseite
abwechselnd phosphorhaltige Stoffe aufgebracht, die bei Elektronenbeschuss entweder Rot, Grün
oder Blau leuchten. Damit die Elektronenstrahlen immer nur die drei zu einem bestimmten Pixel gehörigen Punkte treffen und nicht auch noch benachbarte, ist zwischen den Kathoden und der fluoreszierenden Schicht noch eine Lochblende eingebaut.
Kathoden
3 Elektronenstrahlen
Lochblende
G
R
B
B
B
B
R
G
R
G
R
G
B
B
R
R
G
…
Spulen zur Ablenkung
der Elektronenstrahlen
B
R
G
R
G
R
G
R
Fluoreszierende Schicht
B
Abb. 12: Die von den Kathoden abgegebenen drei Elektronenstrahlen werden von Spulen
abgelenkt und treffen dann auf eine Lochblende, welche die Elektronenstrahlen genau
auf die rot, grün oder blau fluoreszierenden Punkte des gewünschten Pixels fokussiert.
1-10
…
Führt man die drei Elektronenstrahlen wie in nachfolgender Abbildung angegeben über den Bildschirm, werden alle rot, grün und blau fluoreszierenden Punkte von den zugehörigen Elektronenstrahlen getroffen.
Abb. 13: Weg der drei Elektronenstrahlen über den Monitor
An den Ablenkspulen zur horizontalen Ablenkung muss also eine periodisch ansteigende Spannung
(Sägezahn) Hsync anliegen, so dass die drei Elektronenstrahlen von links nach rechts wandern.
− Hat Hsync einen bestimmten negativen Wert, dann befindet sich der Elektronenstrahl ganz
links.
− Hat Hsync einen bestimmten positiven Wert, dann befindet sich der Elektronenstrahl ganz
rechts.
Bei den Ablenkspulen zur vertikalen Ablenkung muss ebenfalls eine von einem bestimmten negativen
Wert bis zu einem bestimmten positiven Wert ansteigende Spannung Vsync angelegt werden, so dass
die drei Elektronenstrahlen von oben nach unten wandern. Vsync muss dabei jedoch eine um die
Anzahl der Bildzeilen niedrigere Frequenz als Hsync haben. So gelangen die drei Elektronenstrahlen
erst dann am unteren Ende der Bildröhre an, wenn alle Zeilen von links nach rechts durchlaufen wurden.
Nachfolgende Abbildung zeigt die von einem VGA-Anschluss gelieferten Signale. Hsync und Vsync
sind dabei die gerade besprochenen Spannungen zur Positionierung der drei Elektronenstrahlen, R,
G, und B sind die Spannungen, welche die Strahlungsintensität der zugehörigen Kathoden und damit
die Intensität jeder Pixel-Grundfarbe steuern.
R
G
B
Hsync
Vsync
t
1. Zeile
2. Zeile
letzte Zeile
1. Bild
Abb. 14: Signale am VGA-Anschluss
1-11
1. Zeile
2. Bild
Zur Umwandlung der im Grafik-Speicher abgelegten Daten in die analogen Signale R, G und B verwenden Grafikkarten sog. RAMDACs. Diese RAMDACs wenden auf die im Grafik-Speicher (GrafikRAM; RAM = Random Access Memory, s.u.) abgelegten Byte eine Digital-/Analog-Wandlung (DAC =
Digital Analog Converter) an. Die Daten werden dabei byteweise ausgelesen und dann in die analogen Spannungen umgewandelt, die am VGA-Anschluss (vgl. Abb. 14) der Grafikkarte herauskommen.
Nachfolgende Abbildung zeigt den Verlauf der Daten auf dem Weg vom Prozessor zum Bildschirm.
0x3F
RAMDAC (für Rot)
0x00
0x78
RAMDAC (für Grün)
0xFF
0xE8
Video-Speicher
auf der Grafikkarte
c:\>
RAMDAC (für Blau)
…
…
…
Prozessor
• •••
•• •
•• •
•• •
• •
Digital-Analog-Wandler
(RAMDAC)
VGABuchse
Bildschirm
Abb. 15: Datenverlauf vom Prozessor zum Bildschirm
Die Darstellung von Bildern auf dem Bildschirm funktioniert wie folgt:
− Der Prozessor schreibt die Farbwerte für die Pixel in den Video-Speicher.
− Die im Video-Speicher liegenden Daten werden permanent vom RAMDAC in VGA-Signale
übersetzt und über die VGA-Buchse an den Bildschirm ausgegeben, der das Bild dann anzeigt.
− Das am Bildschirm angezeigte Bild bleibt solange dasselbe, bis der Prozessor andere Werte in
den Video-Speicher der Grafikkarte schreibt.
Die Daten, die der Prozessor in den Video-Speicher schreibt, müssen jedoch erst berechnet werden,
was im Vergleich zu den von der Grafikkarte auszuführenden Aktionen (Auslesen der Daten aus dem
Grafik-Speicher und Wandlung durch die RAMDACs [und der Darstellung am Bildschirm]) relativ lange
dauert.
Nehmen Sie an, auf den Bildschirm soll eine Linie mit einer bestimmten Dicke und einer bestimmten
Länge gezeichnet werden, wie z.B. die nachfolgend abgebildete Linie.
Abb. 16: Linie
Um im Grafik-Speicher für jedes Pixel die Intensität der drei Grundfarben Rot, Grün und Blau ablegen
zu können, muss der PC-Prozessor zunächst berechnen, welche Pixel beim Zeichnen der Linie mit
welcher Farbe eingefärbt werden müssen.
1-12
Ausgehend von einer mathematischen Beschreibung der Linie, z.B. der Geradengleichung y = mx + t,
kann man bestimmen, welche Pixel von der Linie überhaupt getroffen werden.
2
Nachfolgende Abbildung zeigt, wie ein kurzer Ausschnitt der Linie auf den Pixeln zu liegen kommt.
Farbpunkte
auf dem
Bildschirm
zu zeichnende
Linie
einzelne
Pixel
Abb. 17: Ausschnitt der Linie
Für alle Pixel, die von der Linie berührt werden, muss der Prozessor jetzt berechnen, zu welchem Teil
die Pixel von der Linie bedeckt werden.
− Bedeckt die Linie den Pixel vollständig, wird er schwarz eingefärbt, d.h. im Grafik-Speicher werden an der entsprechenden Speicherstelle für Rot, Grün und Blau jeweils die Werte 0 eingetragen.
− Bedeckt die Linie die Pixel nur zu 40 Prozent, so trägt die Farbe der Linie (hier schwarz) auch
nur zu 40 Prozent zur Farbe des Pixels bei. Die restlichen 60 Prozent der Farbe des Pixels entsprechen der ursprünglichen Farbe des Pixels (bei uns also der Farbe weiss). Mit RGBschwarz =
(0, 0, 0) und RGBweiss = (255, 255, 255) ergibt sich damit für die neue Farbe RGBneu = (0,4 ⋅ 0 +
0,6 ⋅ 255 , 0,4 ⋅ 0 + 0,6 ⋅ 255 , 0,4 ⋅ 0 + 0,6 ⋅ 255), also der neue Farbwert RGBneu = (153,
153, 153).
Die Pixel-Darstellung der Linie ergibt sich damit wie folgt:
Abb. 18: Pixeldarstellung der Linie
Der Übergang von der Darstellung „Linie mit y = mx + t“ in die Pixeldarstellung wird in der Computergrafik als rendern bezeichnet.
Das Vorgehen, von der Linie berührte Pixel nicht einfach in der Farbe der Linie darzustellen, sondern
die Farbe des Pixels aus dem prozentualen Anteil der Überdeckung zu Mischen, wird Antialiasing
genannt.
2
Im obersten linken Pixel ist noch einmal dargestellt, wie die Pixel auf dem Bildschirm durch rote, grüne und blaue Punkte
erzeugt werden.
1-13
Die für die Render-Vorgänge benötigten Berechnungen werden von optimierten Assembler-Routinen
durchgeführt, die im Betriebssystem verankert sind. Diese Routinen können über die Schnittstelle des
Betriebssystems aufgerufen werden, so dass jeder Programmierer Linien, Kreise, aber auch einzelne
Punkte auf dem Bildschirm zeichnen kann.
Obwohl die Render-Vorgänge bereits als optimierter Assembler-Code geschrieben sind, dauert deren
Ausführung (im Vergleich zur Darstellung der im Video-Speicher abgelegten Daten auf dem Bildschirm) relativ lange.
Würden die langsamen Render-Vorgänge direkt auf dem Grafik-Speicher ausgeführt werden, dann
würden Objekte bereits dann auf dem Bildschirm erscheinen, wenn sie noch gar nicht fertig berechnet
sind, was vom Betrachter insbesondere bei bewegten Objekten als sehr störend empfunden würde
(flickern).
Aus diesem Grund wird beim Rendern nicht direkt in den Grafik-Speicher, sondern in einen sog. BackBuffer gerendert, der ebenfalls auf der Grafikkarte zu finden ist. Ist das Bild fertig gerendert, werden
Grafik-Speicher und Back-Buffer vertauscht. Dabei werden die in den Puffern enthaltenen Daten jedoch nicht kopiert, sondern es wird den RAMDAC-Bausteinen einfach mitgeteilt, dass sich der GrafikSpeicher jetzt an einer anderern Adresse befindet. Der ehemalige Grafik-Speicher wird dann automatisch zum Back-Buffer.
0x3F
0x00
0x78
wird gerade dargestellt
0xFF
0xE8
…
RAMDAC (für Rot)
…
RAMDAC (für Grün)
• •••
•• •
•• •
•• •
• •
c:\>
RAMDAC (für Blau)
0x4C
…
0x38
0x79
0x00
0xFE
wird gerade erstellt und
im Anschluss dargestellt
…
Prozessor
Front- und
Back-Buffer
Digital-Analog-Wandler
(RAMDAC)
VGABuchse
Bildschirm
Abb. 19: Front- und Back-Buffer
Um das Verhältnis von Grafik-Speicher und Back-Buffer zu verdeutlichen, wird der Grafik-Speicher
auch oft Front-Buffer genannt.
1-14
Zu Beginn dieses Abschnitts hatten wir erwähnt, dass die Grafikkarte nicht nur als Schnittstelle zwischen Computer und Bildschirm dient, sondern auch 3D-Berechnungen beschleunigt, worauf wir im
Folgenden kurz eingehen werden.
In der 3D-Computergrafik (wie z.B. bei PC-Spielen) werden Objekte bzw. deren Oberflächen durch
Polygone (z.B. Dreiecke) modelliert (vgl. nachfolgende Abbildung).
Abb. 20: Modellierung von Objekten durch Polygone (Daten für die Grafikkarte)
Diese Modellierung wird vom PC-Prozessor durchgeführt. Wenn sich beispielsweise in einem PCSpiel Personen bewegen, berechnet der PC-Prozessor permanent die Positionierung der verschiedenen Polygone. Die Polygone haben natürlich ganz bestimmte Oberflächeneigenschaften wie Farbe,
Struktur etc. Diese Oberflächeneigenschaften übergibt der Prozessor zusammen mit den 3DKoordinaten der berechneten Polygonpunkte der Grafikkarte, die die aktuelle Szene dann in ein normales Bild umwandelt (vgl. nachfolgende Abbildung).
Abb. 21: Von der Grafikkarte erzeugtes Bild
Die Grafikkarte „initialisiert“ dabei jedes Polygon mit der zugehörigen Oberfläche (Struktur und Grundfarbe). Anschliessend berechnet die Grafikkarte für jede Polygon-Position die gerade aktuellen Lichtverhältnisse der Umgebung und ändert das Erscheinungsbild der Polygone dementsprechend. Ausserdem berechnet die Grafikkarte, welche Polygone von anderen verdeckt werden und wandelt so das
dreidimensionale Bild in ein zweidimensionales Bild um. Im Anschluss rendert die Grafikkarte die Polygone, d.h. sie erzeugt aus den Polygonen die Farbwerte der einzelnen Pixel, die sie dann in den
Back-Buffer überträgt. Zur Darstellung des Bilds auf dem Bildschirm müssen dann nur noch Front- und
Back-Buffer umgeschaltet werden.
1-15
Die Berechnungen zur Oberflächenstrukturierung, Beleuchtung und Verdeckung sind sehr aufwendig.
Ohne Grafikbeschleunigung müssten diese Berechnungen alle vom PC-Prozessor ausgeführt werden.
Mit Grafikbeschleunigung kann die Arbeit des PC-Prozessors auf die Berechnung der PolygonPositionen beschränkt bleiben, da die Grafikkarte den Rest erledigt. Da die Grafikkarte auf diese Art
von Berechnungen spezialisiert ist, kann sie diese wesentlich schneller ausführen als der PCProzessor. Darüber hinaus arbeitet die Grafikkarte parallel zum Prozessor, so dass die Grafikkarte
beispielsweise ein Bild rendern kann, während der PC-Prozessor gerade die Polygon-Positionen des
nächsten Bildes berechnet.
1-16
• DVD-ROM
Das in Abb. 3 auf Seite 1-4 mit DR gekennzeichnete Gerät ist das DVD-ROM-Laufwerk.
DVD-ROM-Laufwerke dienen zum Lesen von DVDs und CDs. Diese Laufwerke können also keine
Daten aufzeichnen (ROM = Read Only Memory ⇒ nur lesen), sondern sie lediglich lesen.
Um den Aufbau eines DVD-ROM-Laufwerks leichter verstehen zu können, schauen wir uns erst einmal an, wie Daten auf einer DVD gespeichert werden.
Wie in nachfolgender Abbildung gezeigt, besteht eine DVD aus Spuren, die spiralförmig von innen
nach aussen verlaufen.
Abb. 22: Spuren auf einer DVD
1-17
Die Spuren bestehen dabei aus einer Folge verschieden langer Erhöhungen, den sog. Pits, die auf
dem sog. Land aufgebracht sind.
Pits
Land
Abb. 23: Pits und Land
Pits und Land sind aus dem gleichen Material und mit einer Aluminium-Schicht verspiegelt, so dass
sowohl Pits als auch das Land auftreffendes Licht reflektieren. Die reflektierende Seite ist mit einer
Schicht aus Polycarbonat vor Kratzern geschützt, die andere Seite dient der Beschriftung der DVD.
Von der Seite betrachtet, ergibt sich für Pits und Land somit folgendes Bild:
Beschriftung der DVD/Etikett
Drehrichtung
Träger (Land)
reflektierende
ALU-Schicht
Land
Pit
Polycarbonat
Leseseite der DVD
Abb. 24: Aufbau einer DVD-ROM
1-18
Zum Auslesen der DVD wird die Leseseite der DVD mit einem Laser bestrahlt und das von der ALUSchicht reflektierte Laser-Licht von einem Photo-Detektor aufgefangen.
Beschriftung der DVD/Etikett
Drehrichtung
Träger (Land)
reflektierende
ALU-Schicht
Land
Pit
Polycarbonat
Leseseite der DVD
Halbdurchlässiger Spiegel
Photo-Detektor
Laser
Auswertung der Signale
Umwandlung in einzelne
Byte
Abb. 25: Prinzip-Darstellung eines DVD-ROM-Laufwerks
Angenommen, die DVD bewegt sich in der angegebenen Drehrichtung. Was für ein Licht-Signal
kommt dann beim Photo-Detektor an?
− Auf den ersten Blick scheint sich beim Photo-Detektor keine Änderung des Licht-Signals zu ergeben, da sowohl die Pits als auch das Land das Laser-Licht reflektieren.
− Wenn die Höhe der Pits auf dem Land jedoch ein Viertel der Wellenlänge des Lasers beträgt,
erscheint das von den Pits reflektierte Licht wesentlich dunkler als das vom Land reflektierte
Licht. Warum?
Nachfolgende Abbildung zeigt mehrere Licht-Wellen. Die oberen beiden Wellen sind dabei in Phase,
die unteren beiden sind gegenphasig, haben also einen Phasenversatz von 180°.
einzelne Lichtwellen
Summe
konstruktive Interferenz:
destruktive Interferenz:
Abb. 26: Konstruktive und destruktive Interferenz
Man erkennt deutlich, dass sich bei der Addition beider Wellen bei
− gleichphasigen Wellen eine gleichartige Welle mit grösserer Amplitude ergibt. Die Wellen überlagern sich also konstruktiv, man spricht von konstruktiver Interferenz.
− gegenphasigen Wellen beide Wellen genau auslöschen. Die Wellen überlagen sich also destruktiv, man spricht von destruktiver Interferenz.
1-19
Betrachtet man die Pits und das Land auf der DVD von der Leseseite her, fällt folgendes auf:
destruktive Interferenz
konstruktive Interferenz
Ansicht von unten
(Leseseite)
Laser
destruktive
Interferenz
Abb. 27: Auftreffen des Lasers auf der DVD
− Trifft der Laser auf reines Land, wird er einfach reflektiert.
− Trifft der Laser jedoch auf ein Pit, so trifft er neben dem Pit auch noch auf Land, da der Radius
des Laserstrahls grösser ist als die Breite eines Pits. Das reflektierte Laser-Licht enthält also
sowohl Licht, das vom Land reflektiert wurde, als auch Licht, das vom Pit reflektiert wurde.
Nachfolgende Grafik zeigt diese Situation von der Seite betrachtet. Darunter ist das von der DVD-Spur
reflektierte Laser-Licht abgebildet, das dann auf den Photo-Sensor trifft.
Ansicht von der Seite
(Querschnitt)
von der Leseseite
reflektiertes Laserlicht
konstruktive Interferenz
(es wird viel Licht reflektiert)
Abb. 28: Reflexionen an der DVD
Die rotierende DVD reflektiert also
− beim Auftreffen des Laserstrahls auf Land das komplette Licht.
− beim Auftreffen des Laserstrahls auf Pits fast kaum Licht.
1-20
destruktive Interferenz
(es wird fast kein Licht
reflektiert, da sich die
Wellen gegenseitig auslöschen)
Der Photo-Detektor bekommt dabei bei rotierender DVD eine Folge von „Licht an/Licht aus“ mit, die er
als Rechteck-Spannung an einen im DVD-Laufwerk eingebauten Chip weiterleitet.
Spannung
Zeit
Abb. 29: Vom Photo-Detektor erzeugte Rechteck-Spannung
Dieser Chip tastet die Rechteckspannung ab und wandelt die darin gespeicherte Information in Bits
um. Die Bits sind jedoch nicht direkt als Pits und Land codiert. Das hat folgende Gründe:
− Sich rasch ändernde Bitfolgen wie z.B. 10101 können vom Laser nicht mehr aufgelöst werden.
− Bei sich sehr langsam ändernden Bitfolgen wie z.B. 00000000000000000000000111111
111111 geht die Synchronisation verloren, d.h. es kann nicht genau gezählt werden ob jetzt
bspw. 23 oder 24 Nullen in der Bitfolge vorkamen. Das liegt daran, dass die Umdrehungsgeschwindigkeit der DVD während des Lesens schwanken kann und Zeitmessungen dadurch nur
für relativ kurze Zeiten in die von der aktuellen DVD-Spur zurückgelegte Strecke (und damit die
Anzahl der Bits) umgerechnet werden kann.
Aus diesen Gründen hat man bei der Standardisierung der DVD folgendes festgelegt:
− es müssen auf der DVD immer zwei Pit-Stellen bzw. zwei Land-Stellen in Folge auftreten, d.h.
es darf keine Kombinationen 101 oder 010 geben.
− nach spätestens zehn Pit-Stellen oder zehn Land-Stellen muss ein Wechsel stattfinden.
Zwischen zwei Einsen können also zwei bis zehn Nullen auftreten. Dies führt zur sog. Eight-to3
Fourteen-Modulation (EFM), in der ein Byte (8 Bits) durch 14 sog. Channel-Bits kodiert wird. Damit
auch beim Aneinanderfügen von Channel-Codewörtern die obige Forderung nicht verletzt wird, werden zwischen zwei Channel-Codewörtern noch drei sog. Merge-Bits eingefügt. Zur Codierung eines
Bytes sind somit 14 + 3 = 17 Bits notwendig. Diese Bits werden zusammen mit weiteren Bits zur Fehlerkorrektur und Adressierung als Pits und Lands auf die DVD gepresst.
Aus Gründen der Fehlerrobustheit werden gesetzte Bits (1) dabei immer nur als Pit-/Land- bzw. Land/Pit-Übergang codiert. Eine Folge von Pits oder Lands entspricht immer gelöschten Bits (0).
1 0 0 1 0 0 0 0 1 0 0 0 0 0 0 1 0 0 1 0 0 0 1 0 0 0 0 1 0 0 1 0
0 1 0 0 0 1 0 0 1 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 1 0 0 1 0 0 0 1
0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 1 0 0 1 0 0 0 0 0 1 0
Abb. 30: Codierung der Bits in Pit-/Land-Übergange
3
14
Von den mit 14 Bit darstellbaren 2 Bitkombinationen entsprechen lediglich 267 Kombinationen den oben genannten Forde8
rungen. Von diesen 267 gültigen Folgen wurden 256 ausgewählt, um ein Byte (8 Bit, also 2 = 256 verschiedene Werte) zu
codieren.
1-21
Zur Erhöhung der Speicherkapazität können auf jeder DVD-Seite Daten auf zwei Ebenen, den sog.
Layern abgespeichert werden. Der dem Laser nähere Layer ist dabei halbtransparent ausgeführt, so
dass der Laser von diesem zwar reflektiert wird, der untere Layer aber auch noch erreicht werden
kann. Die Auswahl der Layer erfolgt durch Einstellung des Brennpunkts des Lasers (Bewegung der
Linse) entweder auf den einen oder den anderen Layer.
reflektierender Layer
halbtransparenter Layer
verschiebbare Linsen
Abb. 31: Doppel-Layer DVD
Die Verschiebung der Linsen kann beispielsweise über Schrittmotoren oder Elektromagnete erfolgen.
Nachfolgende Abbildung zeigt den prinzipiellen Aufbau einer DVD-Mechanik.
Linse
DVD
Antriebsmotor
Gewindestange
Spulen zur vertikalen Positionierung der Linse
Motor zur horizontalen Positionierung der Linse
Abb. 32: Prinzip-Aufbau einer DVD-Mechanik
Im echten DVD-Laufwerk sieht das folgendermaßen aus:
Abb. 33: DVD-Laufwerk
1-22
In der Grossaufnahme kann man den Motor zum horizontalen Verschieben der Linse gut erkennen:
Auflagepunkt
für die DVD
(Antrieb)
Motor zum horizontalen
Verschieben der Linse
Linse
Abb. 34: Innenleben eines DVD-ROM-Laufwerks
Die horizontale Positionierung der Linse erfolgt folgendermaßen:
− Zunächst wird die ungefähre Position der Linse durch Parameter wie Spurbreite, mittlere PitLänge etc. berechnet.
− Anschliessend wird die Linse an die berechnete Position gefahren und und es werden einige
Daten gelesen; die gelesenen Daten enthalten dabei in einem Header abgelegte Adressinformation.
Header mit Adress-Information
Daten
Trailer
Abb. 35: Auf der DVD werden Adressinformationen im Header gespeichert
− Diese Adressinformation wird jetzt weiterverwendet, um eine genauere Positionierung der Linse
vorzunehmen.
1-23
Vergrössert man den Bildausschnitt noch weiter, kann man auch gut die Elektromagnete/Spulen erkennen, mit denen die Linse vertikal positioniert wird:
Spulen zur Positionierung der Linse
Linse
Spulen zur Positionierung der Linse
Abb. 36: Vertikale Positionierung der Linse durch Elektromagnete/Spulen
1-24
• DVD-Brenner
Das in Abb. 3 auf Seite 1-4 mit DB gekennzeichnete Gerät ist ein DVD-Brenner.
DVD-Brenner funktionieren im Prinzip genauso wie DVD-Leser. Die DVD-Medien sind jedoch anders
aufgebaut: Unterhalb der Reflektierenden Schicht ist eine spezielle Schicht eingebracht, die sich bei
Bestrahlung mit sehr starkem Laser-Licht dunkel färbt und das Licht dann nicht mehr so gut reflektiert.
Auf diese Weise wird die gegenphasige Auslöschung der DVD-ROM nachgeahmt.
Beschriftung der DVD/Etikett
Drehrichtung
Schutzschicht
reflektierende
Schicht
Land
Pit
Leseseite
nicht reflektierende
schwarze Punkte
Polycarbonat
Abb. 37: Beschreibbare DVD (DVD-R)
Bei beschreibbaren DVDs muss das Laufwerk die Adresse der zu beschreibenden Stellen finden können. Nachfolgende Grafik zeigt das Verfahren, das bei der DVD+RW angewendet wird: Die Pits werden in eine Art „Spurrille“, den sog. Grooves geschrieben. Die Seiten der Grooves sind jedoch nicht
gerade, sondern durch eine Modulation von Sinus-Signalen geprägt. Diesen wellenförmigen Seiten
kann das DVD-Laufwerk die Information über die aktuelle Position auf der DVD entnehmen und damit
Daten adressieren.
Grooves (Vertiefungen)
Land
Pits
Abb. 38: Adressierung von beschreibbaren DVDs
Im Gegensatz zu einmal beschreibbaren DVDs (DVD-R) müssen mehrfach beschreibbare DVDs auch
gelöscht werden können. Dies wird durch eine spezielle Metall-Legierung als Reflexionsschicht erreicht: In Abhängigkeit der Stärke des Lasers, der die DVD beschreibt, wird das Material entweder
amorph (ungeordnete Anordnung der Moleküle, schlecht reflektierend) oder kristallin (regelmäßige
Anordnung der Moleküle, gut reflektierend).
1-25
• Festplatte
Das in Abb. 3 auf Seite 1-4 mit FP gekennzeichnete Gerät ist die Festplatte.
Abb. 39: Festplatte
Die Festplatte ist ein magnetisches Speichermedium, das sehr grosse Datenmengen aufnehmen
kann. Aufgrund des technischen Fortschritts können ca. alle 12 Monate Festplatten mit doppelter Kapazität hergestellt werden.
Im Inneren bestehen Festplatten in der Regel aus ein bis vier drehbar gelagerten festen Platten (deswegen der Name Festplatte – im Gegensatz zur biegsamen Floppy-Disk [engl. floppy = schlapp]), die
übereinander montiert sind und immer gleichzeitig gelesen bzw. beschrieben werden. Die Platten sind
in der Regel entweder aus Aluminium oder aus Glaskeramik gefertigt und mit einer magnetisierbaren
Oberfläche (z.B. Eisenoxyd, Kobalt etc.) beschichtet, auf der noch eine Schutzschicht aus Graphit
aufgebracht wird.
Armpositionierung
(Elektromagnet)
Permanentmagnet
Schreib-/Lese-Kopf
schwenkbarer
Arm
magnetisierbare
Speicherplatte
Anschluss für die Elektronik
Abb. 40: Aufau einer Festplatte
1-26
Das Abspeichern von Daten auf die Festplatte erfolgt durch die sog. Schreib-/Leseköpfe, die (wie bei
einer Audio-Cassette) Teile der Plattenoberfläche magnetisieren (vgl. nachfolgende Abbildung).
Magnetfeldlinien
-
+
Spule
Schreib-/Lesekopf
N N
S S
N N
S S
N N
magnetisierbare
Schicht
S
Bewegungsrichtung der Platte
Trägermaterial
aus Glaskeramik
Stromverlauf
beim Schreiben
t
Abb. 41: Datenspeicherung auf der Festplatte durch Magnetisierung
Nachfolgende Abbildung zeigt den Vorgang der Magnetisierung der Festplatte.
+
Spule
-
Magnetfeldlinien
ungeordnete
Elementarmagnete
geordnete
Elementarmagnete
N
S
Magnetisierung (Äquivalent-Magnet)
keine Magnetisierung
Abb. 42: Magnetisierung
1-27
Die Schreib-/Leseköpfe haben die Gestalt eines auf einer Seite aufgesägten „O“ und sind mit einer
Spule umgeben. Wird die Spule bestromt, bildet sich in ihr ein Magnetfeld, das durch den Schreib/Lesekopf (eine Art Ferrit) geleitet wird. Da Feldlinien stets geschlossen sind, bildet sich zunächst im
Luftspalt des Schreib-/Lesekopfes (die „aufgesägte Stelle“) ein Magnetfeld. Wird der Spalt in die Nähe
der magnetisierbaren Platte gebracht, schließen sich die Feldlinien nicht mehr über die Luft, sondern
über das magnetisierbare Material, da sich Feldlinien leichter über magnetische Leiter als über mag4
netische Nichtleiter schließen.
Durch die magnetische Kraft der Feldlinien werden die im Plattenmaterial befindlichen Elementarmagnete dabei so geordnet, dass sie ihre Nord-Süd-Ausrichtung alle in dieselbe Richtung haben. Die
Feldlinien der Elementarmagnete heben sich dann also nicht mehr gegenseitig auf (wie auf der rechten Seite von Abb. 42), sondern bilden zusammen einen „Äquivalent-Magneten“ (linke Seite von Abb.
42). Diese „Äquivalent-Magnete“ bilden die in Abb. 41 gezeigten Magnetfeldlinien, die dauerhaft erhalten bleiben.
Schaltet man die Stromversorgung der Spule des Schreib-/Lesekopfes ab, lässt sich mit dem Schreib/Lesekopf die zuvor auf die Platte aufgebrachte Magnetisierung wieder detektieren.
Strommessung
(siehe Stromverlauf)
•
•
Magnetfeldlinien
+
OpAmp
-
Spule
Schreib-/Lesekopf
N N
S S
N N
S S
N N
magnetisierbare
Schicht
S
Bewegungsrichtung der Platte
Trägermaterial
aus Glaskeramik
Stromverlauf
beim Lesen
t
t1
t2
Abb. 43: Auslesen von der Festplatte
Detektiert werden dabei lediglich die Grenzen unterschiedlicher Magnetisierung, die sich in kurzen
„Stromstößchen“ (einige µA) äussern (vgl. Abb. 43). Diese Unterschiede im Stromverlauf werden mit
geeigneten elektrischen Schaltungen verstärkt, detektiert und dann ausgewertet.
Die abgespeicherte Information steckt dabei in den unterschiedlichen Längen zwischen den Stromstößen. In Abb. 43 ist erkennbar, dass die Zeit t1 wesentlich kürzer ist als die Zeit t2. Diese Zeitunterschiede werden von dem auf der Festplatte integrierten Controllerchip (Festplatten-Controller) registriert, ausgewertet und in einzelne Byte dekodiert. Diese Byte stellen dann die auf der Festplatte abgespeicherte Information dar.
Um die Oberfläche der Festplatte nicht zu beschädigen, sind die Schreib-/Leseköpfe auf einem sog.
Schlitten montiert, der im Betrieb durch den von den Platten verursachten Luftzug nach oben gedrückt
wird. Die Schreib-/Leseköpfe liegen also beim Schreiben/Lesen nicht auf den Platten auf, sondern
schweben ganz knapp über ihnen. Wird die Festplatte ausgeschaltet, verringert sich die Rotation der
Platten und der Luftzug reicht nicht mehr aus, um die Köpfe über den Platten schweben zu lassen.
Deshalb wird der schwenkbare Arm, auf dem die Köpfe montiert sind, in eine Park-Position gezogen.
4
Das ist wie beim elektrischen Strom, der auch lieber durch einen Leiter als durch einen Nichtleiter fließt: Überbrückt man einen
Widerstand (Nichtleiter) mit einem Draht (Leiter), dann fließt der ganze Strom durch den Draht und nicht durch den Widerstand.
1-28
Die Park-Position sind Spuren am Innenrand der Platten, da dort die Plattengeschwindigkeit am geringsten ist, der Abrieb beim Landen der Köpfe also gering bleibt. Da die Spuren im Landebereich der
Köpfe nicht zum Abspeichern von Daten verwendet werden, tritt kein Datenverlust auf.
Um auf der Festplatte gespeicherte Informationen zu finden, müssen die Daten auf der Festplatte in
irgendeiner Form organisiert sein. Dazu werden die einzelnen Platten in sog. Spuren aufgeteilt.
Spuren
Sektor
Abb. 44: Spuren und Sektoren bei einer Festplatte
Da die Platten übereinander montiert sind, bilden die übereinander liegenden Spuren jeweils einen
Zylinder, weswegen man mit dem Begriff Zylinder alle übereinander liegenden Spuren meint.
Platten
Alle übereinander liegenden Spuren bilden jeweils einen Zylinder
Abb. 45: Zylinder
Aktuelle Festplatten verfügen über mehrere tausend Zylinder, also mehrere tausend Spuren pro Plattenoberfläche, wobei die Platten auch beidseitig beschrieben werden. Da die Spuren mehrere Mega-
1-29
byte (MB) gross sein können, werden die Platten zudem noch in Sektoren (vgl. Abb. 44) eingeteilt. Die
Sektoren sind dabei so gross, dass sie (je nach Hersteller) ca. 570 Byte an Daten speichern können.
Ca. 60 dieser Byte werden für Verwaltungsinformation verwendet.
− Werte zur Synchronisation für den Taktgenerator, der die Zeit zwischen zwei Stromstössen (vgl.
Abb. 43) nur messen kann, wenn er die genaue Umdrehungsgeschwindigkeit der Platte kennt.
− Prüfsummen
− Speicherung der Nummer des aktuellen Zylinders
− Speicherung der Nummer des aktuellen Sektors
− Speicherung der Nummer des aktuellen Schreib-/Lesekopfs
− Start- und Ende-Marken für den Datenbereich
− mehrere „Leer-Byte“ als Toleranzzone für unterschiedliche Umdrehungsgeschwindigkeiten
Die restlichen Byte sind die Nutzdaten des Sektors, welche in der Regel 512 Byte lang sind.
Das Aufbringen dieser Verwaltungsinformation wird Grundformatierung genannt. Sie steht im Gegensatz zur logischen Formatierung, bei der Betriebssystem-spezifische Daten zur Verwaltung von Dateien auf die Platten geschrieben werden (z.B. ein Inhaltsverzeichnis).
Um Daten aus einem bestimmten Sektor einer bestimmten Spur einer bestimmten Platte auslesen zu
können, werden die Schreib-/Leseköpfe über dem gewünschten Zylinder positioniert und der von der
Festplatte gelieferte Datenstrom gelesen. Der Festplatten-Controller wartet solange, bis er in dem
Datenstrom des betreffenden Schreib-/Lesekopfs die gewünschte Sektor-Nummer detektiert, macht
sich dann lesebereit und liest beim Auftreten der nächsten Start-Marke solange Werte ein, bis er eine
Ende-Marke detektiert. Da alle Schreib-/Leseköpfe an einem einzigen schwenkbaren Arm befestigt
sind, können alle zu einem Zylinder gehörigen Spuren gleichzeitig gelesen werden.
Die Positionierung der Schreib-/Leseköpfe ist dabei eine sehr heikle Angelegenheit. Betrachten Sie
dazu die in nachfolgender Tabelle angegebenen typischen Daten einer Festplatte:
Abmessung der Schreib-/Leseköpfe
0,3 mm x 0,1 mm
Dicke des Luftkissens, auf dem die Köpfe schweben
20 nm
Umdrehungsgeschwindigkeit der äußeren Spuren
(Radius = 4 cm, 7200 U/min)
110 km/h
Spurabstand (bei 1500 Spuren pro cm)
6,7 µm
Bit-Abstand
0,5 µm
Abb. 46: Festplatten-Daten
Um uns diese Daten besser vor Augen führen zu können, rechnen wir sie einmal so um, dass die
Dicke des Luftkissens 1 cm beträgt, die Schreib-/Leseköpfe also 1 cm über den Platten schweben. Zur
Skalierung müssen wir dann alle Festplatten-Parameter mit 1 cm / 20 nm = 500.000 multiplizieren. Es
ergeben sich dann folgende Werte:
Abmessung der Schreib-/Leseköpfe
150 m x 50 m
Dicke des Luftkissens, auf dem die Köpfe schweben
1 cm
Umdrehungsgeschwindigkeit der äußeren Spuren
(Radius = 4 cm, 7200 U/min)
55.000.000 km/h
Spurabstand (bei 1500 Spuren pro cm)
3,35 m
Bit-Abstand
25 cm
Abb. 47: Skalierte Festplatten-Daten
1-30
Nach dieser Skalierung wären die Schreib-/Leseköpfe gut eineinhalb mal so lang und ein halbes mal
so breit wie die Münchener Frauenkirche hoch ist und würden mit einer Geschwindigkeit, mit der sie in
2,6 Sekunden die Erde umrunden, nur 1 cm über dem Boden gleiten. Dabei würden Sie Daten auslesen und schreiben, die nach links und rechts nur 3,35 m von anderen Daten entfernt sind und nach
vorne und hinten bereits nach 25 cm an ihre Nachbarn stoßen. Eine unvorstellbare Leistung!
Typische Festplattenlaufwerke haben eine durchschnittliche Zugriffszeit von ca. 8 ms, das bedeutet,
sie benötigen ca. 8 ms, um ein Drittel aller auf der Oberfläche befindlichen Spuren zu überqueren und
dann zielsicher auf der richtigen Spur zu landen. In unserem Skalierungs-Beispiel beträgt die Entfernung, die in den 8 ms von den Schreib-/Leseköpfen in Frauenkirche-Grösse zurückgelegt werden
müssen, gute 5 km. Das entspricht einer Seitwärts-Geschwindigkeit von 625.000 km/h (in knappen 4
Minuten um die Erde).
Wie kann so eine schwierige Aufgabe gelöst werden? Modernste Regelungstechnik macht’s möglich!
Da die Schreib-/Leseköpfe im Betrieb nicht auf den Platten aufliegen, ergibt sich bei der Bewegung
der Arme so gut wie keine Reibung. Die Arme können also mit minimalstem Kraftaufwand bewegt
werden. Sie lassen sich also auch ruckfrei anfahren und abbremsen. Der Antrieb erfolgt dabei durch
magnetische Kräfte:
− Am drehbar gelagerten Arm ist an der Hinterseite eine Spule angebracht, deren Magnetfeld sich
vom Festplatten-Controller steuern lässt.
− Im Gehäuse der Festplatte sind zwei sehr starke Permanent-Magnete montiert, zwischen denen
die Spule des drehbaren Arms eingebettet ist.
Wird die Spule bestromt, stößt sie sich vom Permanent-Magneten ab und bewegt dabei die SchreibLeseköpfe über die Platten.
PermanentMagnet zum
Halten des
Arms in der
Parkposition
PermanentMagnete
Spule (am Arm montiert)
Drehlager zur Rotation
des Arms
drehbar gelagerter
Arm
Abb. 48: Mechanik zur Armpositionierung
1-31
Doch woher weiß der Festplatten-Controller, wieviel Strom er durch die Spule schicken muss, um die
Schreib-/Leseköpfe genau auf den gewünschten Zylinder (auf die gewünschten Spuren) zu positionieren?
Die Antwort ist: Auf den Platten sind sog. Servo-Informationen gespeichert, in denen auch die Nummer des jeweiligen Zylinders gespeichert ist.
Diese Servo-Informationen werden in der Regel zwischen den einzelnen Sektoren gespeichert.
Sektoren
Servo-Informationen
Abb. 49: Servo-Information
Zur Positionierung wartet der Festplatten-Controller zunächst, bis ein Schreib-/Lesekopf über einen
Servo-Bereich fährt. Der Festplatten-Controller liest die Servo-Information ein und ermittelt dadurch
die aktuelle Position des Arms (Ist-Position). Durch Vergleich mit der Soll-Position (Ziel-Zylinder) ermittelt der Festplatten-Controller, wie weit die Schreib-/Leseköpfe noch vom Ziel-Zylinder entfernt sind
und erhöht oder verringert den Spulenstrom dementsprechend. Die Platte dreht sich dabei weiter.
Wenn die Schreib-/Leseköpfe das nächste mal einen Servo-Bereich überfahren, vergleicht der Festplattencontroller wieder die aktuelle Position des Arms mit der Soll-Position und berechnet daraus
wieder eine geeignete Spulenspannung. Diese Prozedur wird nun solange wiederholt, bis der Arm
über dem richtigen Zylinder steht. Anschließend findet noch eine Feinpositionierung statt, die mithilfe
spezieller (ebenfalls im Servo-Bereich abgespeicherten) Fein-Positionierungs-Informationen durchgeführt wird.
Im Festplatten-Controller ist also unter anderem ein Regler implementiert, der aus den Laufwerkspa5
ramtern, der Ist- und der Soll-Position den nötigen Spulenstrom bestimmt.
Soll-Position
+
aktueller
Fehler
Ist-Position
Regler
•
Spulenstrom
Laufwerk
Abb. 50: Regelkreis
5
Wie solche Regler funktionieren und wie sie ausgelegt werden müssen, um nicht nur sehr schnell, sondern auch noch stabil zu
arbeiten, können Sie beispielsweise in „Regelungs- und Steuerungstechnik“ bei Prof. Buss oder in einem guten Buch über
Regelungstechnik (z.B. Horn, Dourdoumas, Regelungstechnik, ISBN 3-8273-7059-0) erfahren.
1-32
Um gute Zugriffszeiten der Festplatte zu erreichen, muss der Arm möglichst schnell von seiner IstPosition in die Soll-Position bewegt werden. Er darf dabei jedoch nicht über sein Ziel hinausschiessen
und zu weit fahren. Gute oder schlechte Zugriffszeiten von Festplatten sind somit nicht zuletzt auf die
verwendeten Regelungs-Algorithmen zurückzuführen.
Zur Verbesserung der Zugriffszeit der Festplatte kann die Umdrehungsgeschwindigkeit der Platte
erhöht werden, so dass die zeitlichen Abstände, in denen die Servo-Informationen an die Schreib/Leseköpfe gelangen, verringert werden.
Eine weitere Möglichkeit zur Beschleunigung der Kopfpositionierung besteht darin, die Servoinformationen nicht nur zu Beginn eines Sektors, sondern auch in kürzeren Abständen auf die Platten zu
speichern. Eine verbreitete Vorgehensweise spendiert eine komplette Plattenoberfläche allein für die
Servo-Informationen. Diese Festplatten erkennt man oft daran, dass sie über eine ungerade Anzahl
an Schreib-/Lese-Köpfen verfügen.
Die Servo-Informationen werden vom Festplatten-Hersteller auf die Platte geschrieben und können
nicht gelöscht werden. Auch nicht mit der zuvor erwähnten Grundformatierung.
In diesem Kapitel haben wir uns diejenigen Peripherie-Geräte angeschaut, die uns unmittelbar nach
dem Öffnen des PCs aufgefallen sind: Netzteil, Grafikkarte, DVD-Laufwerk, DVD-Brenner und die
Festplatte.
DR
NT
DB
DL
GK
FP
FW
Abb. 51: Geräte in einem PC
Wir haben dabei gemerkt: Die betrachteten Geräte sind ziemlich intelligent. Sie können selber schwierige Aufgaben ausführen (z.B. Kopf-Positionierung bei der Festplatte) und dadurch den PC-Prozessor
entlasten. Die Intelligenz und hohe Leistungsfähigkeit der Geräte rührt von den eingebauten Chips
her, die z.T. sehr ähnlich aufgebaut sind wie PC-Prozessoren, mit denen wir uns in dieser Vorlesung
hauptsächlich beschäftigen werden.
1-33
Jetzt tauchen wir jetzt tiefer in den PC hinein, indem wir das Netzteil und die Steckkarten entfernen
und die dahinter liegende Hauptplatine untersuchen.
1.1.2
Komponenten auf der Hauptplatine - Überblick
Nach dem Ausbau des Netzteils und der Grafikkarte ergibt sich vom Innenleben unseres PCs folgendes Bild:
D3
D5
D6
D
C1
D1
A
B4
B4
D2
D4
B4
B4
FS
B1
C5
B
C3
C6
LA
B2
HI
C7
B3
C7
C3
C
C2
C7
C4
C8
C9
C7
C7
C7
Abb. 52: Hauptplatine eines Computers
Die grosse grüne Platine ist die Hauptplatine unseres Computers, die auch Mainboard oder
Motherboard genannt wird. Auf der Hauptplatine sind alle wichtigen Komponenten des PCs untergebracht, die nicht so wie die Festplatte oder das DVD-Laufwerk als Peripherie-Geräte angesehen werden. Auf ihr befindet sich der Prozessor (A) der Hauptspeicher (B4), der Chipsatz (B, C), viele Anschlussmöglichkeiten für Steckkarten (B2, C7), für interne Geräte (C3, D4) wie beispielsweise DVDROM und für externe Geräte (z.B. D1, D2).
Da die Hauptplatine auf den ersten Blick ziemlich kompliziert aussieht, haben wir davon auf der nächsten Seite eine Schema-Darstellung angefertigt, aus der hervorgeht, wie die einzelnen Bausteine auf
der Hauptplatine heißen und wie sie miteinander verschaltet sind.
1-34
A
Prozessor
Intel P4
RechenWerk
NT
230 V ~
Netzteil
SteuerWerk
Adress-Umsetzer
BefehlsCache
DatenCache
FSB Logik/Treiber
FS
B
TFTBildschirm
B1
DVI
Analoger VGAAnschluss
Intel 82865G
GMCH
GrafikController
B2
Grafikkarte
Prozessor-Bus, 4⋅200 MHz
(FSB = Front Side Bus)
AGP-
AGP-Port
DDR-RAM
DDR-RAM
2,1 GByte/s Controller Controller
GK
Gigabit-EthernetCSAController
Controller
266
MByte/s
B3
1 GBit/s
HI
LA
LANAnschluss
C
100 MBit/s
C1
FP
C2
Festplatte
DVDROM
DVDBrenner
DR
DB
C3
C4
480 MBit/s
Anschlüsse
für USB 2.0
2 Anschlüsse 150 MByte/s
für Serial-ATA
100 MByte/s
2 Anschlüsse
für ATA 100
Audio-Codec
AC `97 3
DDR-RAM B4
Kanal A
3,2 GyteB/s
DDR-RAM
HI Controller
B4
DDR-RAM B4
Kanal B
3,2 GByte/s
HI = Hub Interface
266 MByte/s
Intel 82801EB
ICH5
C6
Takt-Generator
CPU, PCI, …
Ethernet- SystemController Managmnt.
PCIUSB2.0Controller Controller
2 SATAController
B4
CMOSRAM
C7
6 PCI-Slots
PCI-Bus
133 MByte/s
FW
Batterie
C8
ATA 100 Bios-interf.
Controller Controller
Flash-Bios
C9
AC `97
SMBus
Controller Controller
SMBus 2.0/
I2C-Bus
FireWireAdapter
LPC-interface
Controller
LPC-Interface
(Low Pin Count)
D
Super
Input/Output
Controller
D4
D1 Anschluss für
seriellen Port
RS 232
Floppy
Controller Controller
Anschluss Disketten-Laufwerk
D2 Anschluss für
parallelen Port
LPT
Tastatur
Controller Controller
PS/2 Anschluss D5
Tastatur
Anschluss für
Ventilator
DrehzahlMaus
regelung Controller
PS/2 Anschluss
Maus
D3
Abb. 53: Schematischer Aufbau eines Computers
1-35
DL
DiskettenLaufwerk
Tastatur
Maus
D6
Die wichtigste Komponente dieser Schema-Darstellung ist der Prozessor (A).
• Prozessor
Nachfolgende Abbildung zeigt den auf der Hauptplatine befindlichen Prozessor (A), nachdem wir den
Kühlkörper entfernt haben.
Abb. 54: Prozessor (Pentium 4, Vorder- und Rückseite)
Der Prozessor ist die zentrale Rechen- und Steuereinheit des gesamten Computers. Wie bzw. was
der Prozessor rechnen oder steuern soll, steht in sog. Programmen, die aus einzelnen ProzessorBefehlen bestehen.
Die Prozessor-Befehle sind außerhalb des Prozessors gespeichert und werden vom Prozessor über
den sog. Front-Side-Bus (FSB – in Abb. 52 und Abb. 53 mit FS markiert) in den Prozessor geladen
und dann ausgeführt. Die zu den Befehlen gehörigen Operanden (die sog. Daten) liegen zunächst
ebenfalls außerhalb des Prozessors und müssen über den Front-Side-Bus in den Prozessor geladen
werden.
Um die über den FSB in den Prozessor geladenen Befehle und Operanden im Prozessor ablegen zu
können, verfügen Prozessoren über sog. Register. Register sind sehr schnelle Speicherelemente, die
genau soviele Bits aufnehmen können, wie sich intern parallel verarbeiten lassen. Die Anzahl dieser
Bits nennt man Wortbreite und den Inhalt eines Registers dementsprechend Datenwort oder auch nur
kurz Wort. Bei einem 32 Bit-Pentium-Prozessor beträgt die Wortbreite 32 Bit, die Register sind also 32
Bit breit und können somit genau 32 Bits aufnehmen.
jeweils 1 Bit
MSB
Numerierung der Bits:
…
…2 1 0
n-1
Datenwort mit Wortbreite n
Abb. 55: Datenwort
1-36
LSB
Die Bitstelle mit der geringsten Wertigkeit (ganz rechts) wird auch LSB (engl. Least Significant Bit ⇔
dt. niederwertigstes Bit) genannt. Die Bitstelle mit der höchsten Wertigkeit (ganz links) wird MSB (engl.
Most Significant Bit ⇔ dt. höchstwertigstes Bit) genannt.
Um Befehle sowohl abspeichern, als auch über den Bus übertragen zu können, werden Befehle genauso wie Operanden und Adressen als Zahlen codiert. Der Befehl „Addiere zwei Zahlen“ kann beispielsweise als 0x20 codiert sein, also der Bitfolge 00100000 entsprechen. Diese Bitfolge kann dann
problemlos abgespeichert bzw. übertragen werden.
Die nachfolgenden Abbildungen zeigen die Abarbeitung von Befehlen durch den Prozessor: Der als
nächstes auszuführende Befehl wird aus einem externen Speicher über den FSB in das BefehlsRegister transportiert. Anschliessend werden die zugehörigen Operanden (ebenfalls über den FSB)
geladen.
FSB = Front Side Bus
2
BR:
BZ:
3
Steuerung
1
•
Registerblock
mit Registern
•
ALU
Flags:
•
Steuerwerk
Abb. 56: Laden von Befehlen in den Prozessor
6
Dazu wird vom sog. Steuerwerk zuerst der im Befehlszähler BZ (ein Register im Steuerwerk) stehende Wert als Adresse auf den FSB gelegt (1). Diesen Vorgang nennt man Befehlsadressierung, da im
Befehlszähler immer die Zahl steht, die der Adresse des als nächstes auszuführenden Befehls entspricht. Auf den FSB wird also die Adresse des nächsten Befehlsworts gelegt.
Kurz danach erhält der Prozessor über den FSB das gewünschte Befehlswort, das er dann im Befehlsregister BR ablegt (2).
Nachdem das Befehlswort ins Befehlsregister übertragen wurde, wird es von der Steuerung analysiert
(3). Die Steuerung ermittelt dabei, von woher sie die Operanden des Befehls laden soll, ob die Operanden also z.B.
− direkt im Befehlswort abgelegt sind,
− bereits in den Prozessor geladen wurden und jetzt in Registern stehen, oder
− erst über den FSB in den Prozessor geladen werden müssen.
6
Der Name Steuerwerk leitet sich von der Aufgabe des Steuerwerks ab: Es steuert die Abarbeitung von Befehlen. Es wird oft
auch als Leitwerk bezeichnet, da es zum einen die Befehlsausführung leitet (leiten im Sinne von überwachen, verantwortlich
sein), zum anderen die Befehle und Operanden zu den jeweiligen Prozessor-Komponenten hinleitet (leiten im Sinne von entlangleiten, hinführen).
1-37
Nach dieser Analyse sorgt das Steuerwerk dafür, dass die benötigten Operanden der sog. ALU (Arithmetic Logic Unit), der Recheneinheit des Prozessors, zugeführt werden.
− Stehen die Operanden direkt im Befehlswort, werden sie von dort zur ALU geleitet (4).
− Stehen die Operanden in Registern, adressiert die Steuerung die entsprechenden Register (5),
d. h. sie teilt dem Registerblock mit, welche Register ausgelesen werden sollen. Anschliessend
sorgt sie dafür, dass die adressierten Operanden aus dem Registerblock an die ALU geleitet
werden (6).
FSB = Front Side Bus
BR:
BZ:
Steuerung
4
•
•
5
5
Registerblock
mit Registern
6
4
ALU
Flags:
•
Steuerwerk
Abb. 57: Bereitstellung von Operanden:
Direktoperanden und Register-Operanden.
− müssen die Operanden erst über den FSB in den Prozessor geladen werden,
+ legt die Steuerung zunächst die Adresse der Operanden auf den FSB (7) und
+ leitet die dann über den FSB gelieferten Daten als Operanden
• entweder direkt an die ALU (8)
• oder erst mal in ein Register (9), von wo aus sie dann von anderen Befehlen der ALU
zugeführt werden können (10).
FSB = Front Side Bus
7
9
BR:
BZ:
Steuerung
•
7
•
Registerblock
mit Registern
8
10
ALU
Flags:
•
Steuerwerk
Abb. 58: Bereitstellen von Operanden über den FSB
1-38
Nachdem die Steuerung alle Operanden an die ALU angelegt hat, teilt sie der ALU den auszuführenden Befehl (z.B. Addieren, Multiplizieren etc.) mit (11) und startet dann die Befehlsausführung (12).
FSB = Front Side Bus
BR:
BZ:
•
Steuerung
13
Registerblock
mit Registern
•
11
12
ALU
Flags:
14
Steuerwerk
•
Abb. 59: Berechnung des Ergebnisses
Treten bei der Befehlsausführung in der ALU unvorhergesehene Ereignisse/Fehler auf (z.B. Division
durch Null), werden diese der Steuerung gemeldet (13), die dann weitere Maßnahmen trifft.
Hat die ALU die ihr aufgetragenen Berechnungen abgeschlossen, meldet sie bestimmte Eigenschaften des Ergebnisses (z.B. Ergebnis ist Null, Ergebnis ist negativ), indem Sie das im Steuerwerk untergebrachte Flag-Register aktualisiert (14).
Nachfolgende Abbildung zeigt ein Beispiel für ein Flag-Register.
Overflow: Überlauf bei vorzeichenbehafteten Zahlen
Carry (Übertrag): Überlauf bei vorzeichenlosen Zahlen
Zero: Ergebnis ist Null
Sign (Vorzeichbit): Ergebnis ist negativ
OC Z SW I X E
Gleitkomma-Zahl ungenau (z.B. 1.0/3.0)
Gleitkomma-Division durch Null
Ungültige Gleitkomma-Operation (z.B. −1 )
Überlauf bei Gleitkomma-Festkomma-Wandlung
Abb. 60: Flag-Register
1-39
Je nach ausgeführtem Befehl muss die Steuerung jetzt das am ALU-Ausgang anliegende Ergebnis
− über den FSB verschicken (15). Dazu muss die Steuerung neben dem Ergebnis auch die
Zieladresse (Adresse im Arbeitsspeicher oder Peripherie-Gerät) mit auf den FSB legen (16).
− in ein Register des Registerblocks transportieren (17). Hierbei muss die Steuerung durch Anlegen der Registeradresse an den Registerblock diesem mitteilen, in welches Register das Ergebnis abgelegt werden soll (18).
FSB = Front Side Bus
20
BR:
BZ:
Steuerung
Registerblock
mit Registern
•
18
16 21
•
Flags:
19
15
Steuerwerk
ALU
•
17
Abb. 61: Sichern des Ergebnisses
Wird das Ergebnis in einem Register abgelegt, kann es
− sofort wieder verwendet werden (19). Eine zeitaufwendige Datenübertragung über den FSB ist
hier nicht notwendig.
− auch vom Register aus über den FSB verschickt werden (20). Dazu muss die Steuerung wieder
die Zieladresse an den FSB anlegen (21).
Um den nächsten Befehl über den FSB in den Prozessor zu laden, muss der Befehlszähler (die Adresse auf den nächsten Befehl) angepasst werden. Dazu wird zu dem aktuellen Wert des Befehlszählers die Wortbreite eines Befehls (in Byte) addiert und der Wert des neuen Befehlszählers dann wieder
auf den FSB gelegt [(1) aus Abb. 56 (Seite 1-37)].
Addierer
Wortbreite des
aktuellen Befehls
+
BZ
zum FSB
Abb. 62: Anpassen des Befehlszählers
Ab diesem Zeitpunkt wiederholen sich die in den Abb. 56 bis Abb. 61 dargestellten Schritte. Die im
Speicher stehenden Befehle werden der Reihen nach ausgeführt.
1-40
Fast genauso wichtig wie der Prozessor ist der Arbeitsspeicher, in dem sowohl die auszuführenden
Befehle, als auch die zugehörigen Operanden (die sog. Daten) stehen.
• Arbeitsspeicher
Die in den Abb. 52 und Abb. 53 mit B4 gekennzeichneten Komponenten sind die DDR-RAM-Module,
die zusammen den Arbeitsspeicher des Computers bilden.
Abb. 63: DDR-RAM (Arbeitsspeicher)
Die Aufgabe des Arbeitsspeichers ist die temporäre Speicherung von Daten und Befehlen. Mit temporär ist gemeint, dass
− zum Einen die im Arbeitsspeicher abgelegten Daten mit dem Ausschalten des PCs verloren gehen. Der Arbeitsspeicher wird deshalb auch als volatiler (= flüchtiger) Speicher bezeichnet.
− zum Anderen im Arbeitsspeicher nur diejenigen Daten bzw. Befehle liegen, mit denen gerade
gearbeitet wird, woher sich auch der Name Arbeitsspeicher ableitet.
Im Gegensatz dazu ist die Festplatte ein nicht volatiler (= nicht flüchtiger) Speicher. Die Daten auf der
Festplatte gehen also nicht verloren, wenn man sie ausschaltet. Auf der Festplatte sind alle Daten und
Programme (Folge von Befehlen) gespeichert, die man irgendwann einmal verwendet hat oder evtl.
einmal verwenden wird. Mit den Daten auf der Festplatte wird also nicht aktuell gearbeitet, die Daten
werden auf der Festplatte nur gelagert.
Um mit Daten/Programmen zu arbeiten, müssen diese erst von der Festplatte in den Arbeitsspeicher
geladen werden (1) (vgl. nachfolgende Abbildung). Die Daten werden dann vom Arbeitsspeicher in
den Prozessor transportiert (2), dort verarbeitet (3) und dann wieder im Arbeitsspeicher abgelegt (4).
Sollen die Daten erneut bearbeitet werden, müssen sie wieder vom Arbeitsspeicher in den Prozessor
geladen werden (5). Dort werden Sie weiterverarbeitet (6) und im Anschluss wieder in den Arbeitsspeicher zurückgeschrieben (7). Würde der Rechner jetzt ausgeschaltet werden, gingen die Daten
verloren. Um sie permanent zu speichern, müssen sie auf der Festplatte abgelegt werden (8).
1-41
36
2
4
5
7
8
1
Abb. 64: Datenfluß im PC
Nachfolgende Abbildung zeigt, dass der Arbeitsspeicher wie eine Tabelle funktioniert.
SpeicherAdressen
Adresse 1
z.B. 0x00..02
Steuerleitungen
Lesen
Schreiben
0x00..00
0x00..01
0x00..02
0x00..03 5
0x00..04 10
0x00..05
2
3
8
Daten
0x10
0x2F
0x4B 11
0xC3
0x96
0x83
4
•
0x4B 6
7 0x4B
Speicher-Inhalt
(Daten)
9
0xFF..FF
0x5D
Datum (1 Byte)
Abb. 65: Speicher
Um auf Daten im Arbeitsspeicher zuzugreifen, muss man dem Speicher zuerst mitteilen, auf welches
Datum der Zugriff erfolgen soll. Dazu legt man am Eingang Adresse die Adresse der gewünschten
Speicherstelle an (1). Diese sog. Adressierung hat zur Folge, dass im Speicher die Speicher-Stelle mit
dem gewünschten Datum ausgewählt wird (2).
− Soll das ausgewählte Datum aus dem Speicher ausgelesen werden, muss man dies dem Speicher durch ein Signal auf der Steuerleitung Lesen mitteilen (3). Der Speicher reagiert darauf, indem er zwischen der adressierten Speicherstelle und der mit Daten gekennzeichneten Spei-
1-42
cher-Schnittstelle eine Verbindung freischaltet (4), so dass das gewünschte Datum nach aussen
geleitet wird (5) und dann dort abgegriffen werden kann (6).
− Soll an die ausgewählte Stelle jedoch ein neues Datum geschrieben werden, muss dieses Datum zunächst an die Daten-Schnittstelle angelegt werden (7). Durch ein Signal auf der Steuerleitung Schreiben (8) wird dann eine Verbindung zwischen der Daten-Schnittstelle und der
adressierten Speicherstelle hergestellt (9), über die das Datum dann transportiert wird (10). Das
Datum wird anschliessend an der adressierten Speicherstelle abgespeichert (11).
Die Daten-Schnittstelle zum Speicher muss also bidirektional ausgelegt sein, d.h. sie dient beim Lesen
als Ausgang und beim Schreiben als Eingang.
Die Adress- und Steuer-Schnittstelle des Speichers ist unidirektional. Sie dient immer nur als Eingang
und niemals als Ausgang.
Neben der zuvor besprochenen Eigenschaft, dass der Arbeitsspeicher ein nicht flüchtiger Speicher ist,
gibt es noch eine weitere Eigenschaft, die ihn von anderen Speichermedien wie z.B. Festplatte oder
DVD unterscheidet: Ganz egal, auf welche Speicherstelle man gerade geschrieben hat oder von welcher Speicherstelle man gerade gelesen hat, dauert der Zugriff auf eine beliebige andere Speicherstelle immer gleich lang. Man spricht deshalb auch von einem Speicher mit wahlfreiem Zugriff, was im
englischen mit RAM (Random Access Memory) abgekürzt wird.
Im Gegensatz dazu muss bei einer Festplatte in Abhängigkeit der Position des gerade adressierten
Datums zur Adressierung eines anderen Datums der Schreib- und Lesekopf einmal mehr, einmal weniger weit verschoben werden, was natürlich Zeit kostet. Darüberhinaus kann nach der Positionierung
des Schreib- Lesekopfs erst dann auf den gewünschten Sektor zugegriffen werden, wenn sich dieser
unter dem Schreib-Lesekopf befindet.
Bei DVD-Laufwerken, bei denen die DVD mit gleicher Linear-Geschwindigkeit, also mit unterschiedli7
cher Winkel-Geschwindigkeit rotiert, muss zusätzlich noch die Geschwindigkeit erhöht bzw. verringert
werden.
RAMs lassen sich in zwei Gruppen einteilen:
− SRAMs (= Statisches RAMs) und
− DRAMs (Dynamisches RAMs).
Eine SRAM-Speicherzelle benötigt zur Abspeicherung eines Bits sechs Transistoren, von denen sich
vier gegenseitig Sperren bzw. Durchschalten, wie in nachfolgender Abbildung gezeigt.
UB
P2
Spaltenleitung
P1
N1
N2
N4
N3
Bit
Spaltenleitung invertiert
Zeilenleitung (Auswahl)
Bit
Abb. 66: SRAM-Speicherzelle
Die Speicherzelle wird über die sog. Zeilenleitung (oder auch Auswahlleitung) adressiert. Das Bit wird
dann über die Spaltenleitungen (Bit bzw. Bit invertiert) ein- und ausgelesen.
7
Sollen die auf der DVD geschriebenen Daten vom Laser mit konstanter Rate abgetastet werden, muss sich die DVD umso
schneller drehen, je weiter innen auf der DVD die Daten gelesen werden.
1-43
Nachfolgende Abbildung zeigt, wie man in dieser rückgekoppelten Transistor-Schaltung ein Bit abspeichern kann. Spannungspegel auf der Höhe der Versorgungsspannung sind dabei mit „+“, Masse
durch „–“ gekennzeichnet.
Spaltenleitung
12
+
- 11
P1
5
+
13
+
+ N1
X
7
N3 10
UB
2 Bit = 1 (+)
16
+
15
+ P2
Y
+
6
N2 9 18
8
+ N4
14
- 17
-
Spaltenleitung invertiert
Zeilenleitung (Auswahl)
1 4 +
19 -
3 Bit = 0 (-)
Abb. 67: Abspeichern eines Bits im SRAM
Im Grundzustand liegt die Zeilenleitung auf Masse (1). Da an den Gates der beiden N-KanalTransistoren N1 und N2 dann ebenfalls Masse anliegt, sperren beide. Die aus den vier Transistoren
P1, P2, N3 und N4 aufgebaute Rückkopplungsschaltung ist somit von der Aussenwelt isoliert.
Will man ein Bit mit dem Wert „1“ in dieser Speicherzelle abspeichern, legt man zunächst den Eingang
Bit auf 1, also auf den Pegel der Versorgungsspannung UB (2) und den Eingang Bit invertiert auf 0,
also auf Masse (3).
Wählt man anschließend durch Anlegen der Versorgungsspannung an die Zeilenleitung (4) die
SRAM-Zelle aus, liegen die Gates der beiden Transistoren N1 und N2 auf UB (5, 6).
Da die Spaltenleitung Bit auf UB liegt (2), liegt auch am Source-Anschluss von N1 UB an (7), weswegen dieser sperrt. Punkt X wird von N1 also auf keinen bestimmten Spannungspegel gezogen.
Da die Spaltenleitung Bit invertiert auf Masse liegt (3), liegt der Source-Anschluss von N2 ebenfalls
auf Masse (8). Da das Gate von N2 auf UB-Pegel liegt (6) schaltet N2 durch und zieht den Punkt Y auf
Masse (9). Aus diesem Grund werden auch die Gates von N3 und P1 auf Masse gezogen (10, 11).
Da bei N3 sowohl Gate (10) als auch Source auf Masse liegen, sperrt dieser. Bei P1 hingegen liegt
Source auf UB (12), so dass P1 leitend wird und der Punkt X auf UB-Potential gezogen wird (13).
Dies hat wiederum zur Folge, dass die Gates von N4 und P2 ebenfalls auf UB-Potential liegen (14,
15). Da bei P2 jetzt sowohl Source (16) als auch Gate (15) auf UB-Potential liegen, sperrt dieser.
N4 leitet jedoch, da sein Gate auf UB-Potential (14) und Source auf Masse (17) liegt. Daraus folgt,
dass Punkt Y auch dann auf Masse-Pegel bleibt (18), wenn an der Zeilenleitung wieder UB-Pegel angelegt wird (19), die Transistoren N1 und N2 damit nicht mehr durchschalten und die aus P1, P2, N3
und N4 bestehende Rückkopplungsschaltung wieder von der Aussenwelt abtrennen.
Durch die Rückkopplung der vier Transistoren P1, P2, N3 und N4 liegt Punkt X somit auf +UB und
Punkt Y auf Masse. Dieser Zustand entspricht dem abgespeicherten Wert „1“. Läge Punkt X auf Masse und Punkt Y auf +UB, entspräche das dem abgespeicherten Wert „0“.
1-44
Wie der im SRAM gespeicherte Wert wieder ausgelesen werden kann, zeigt die nachfolgende Abbildung.
UB/2
5
UB/2
5
4 +
N5
2 3 +
7 -
4 +
N6
Precharge
6
UB/2
6
UB/2
UB
P2
Y
Spaltenleitung
P1
N1
N2
X
N3
N4
Spaltenleitung invertiert
Zeilenleitung (Auswahl)
1 8 +
16 -
Bit
Bit
10
-
9
+ +
+UB ⇒ 1 11
- UB ⇒ 0 12
Abb. 68: Auslesen einer SRAM-Speicherzelle
Um das gespeicherte Bit auszulesen, muss getestet werden, ob
− entweder Punkt X auf positivem Potential und damit Punkt Y auf negativem Potential liegt (dann
ist eine „1“ gespeichert),
− oder Punkt X auf negativem Potential und damit Punkt Y auf positivem Potential liegt (dann ist
eine „0“ gespeichert).
Für diesen Test werden durch Anlegen von +UB an die Zeilenleitung (8) die beiden Transistoren N1
und N2 durchgeschaltet und die Potentiale der Punkte X und Y an einen Differenzverstärker weitergeleitet (9, 10), dessen Ausgang dann je nach abgespeichertem Bit entweder +UB (abgespeichertes Bit
war eine 1) oder auf -UB (abgespeichertes Bit war eine 0) liefert (11, 12).
Damit beim Durchschalten der Transistoren N1 und N2 am Differenzverstärker möglichst schnell die
Pegeldifferenz der Punkte X und Y anliegt, sollten die beiden Spaltenleitungen (Bit und Bit invertiert)
vor dem Durchschalten auf selbem Potential liegen.
− Da die beiden Spaltenleitungen aufgrund der daran angeschlossenen Transistoren und der
Verdrahtung über eine gewisse Kapazität verfügen, ist auf ihnen stets eine gewisse Ladung gespeichert.
− Im ungünstigen Fall hat diese Ladung ein zur Ladung an den Punkten X und Y genau entgegengesetztes Vorzeichen.
− Diese Ladung auf den Spaltenleitungen muss beim Durchschalten der Transistoren erst überwunden werden, was einen Zeitverlust darstellt.
1-45
− Liegen beide Spaltenleitungen vor dem Durchschalten von N1 und N2 jedoch auf selbem Potential, genügt bereits der Transport einer sehr geringen Ladungsmenge, um den zwischen den
Punkten X und Y vorhandenen Potentialunterschied durch den Differenzverstärker detektieren
zu können.
− Die Detektion erfolgt dann sehr schnell, was eine sehr kurzen Auslesezeit der Speicherzelle zur
Folge hat.
Im Grundzustand liegen die Zeilenleitung und die Steuerleitung Precharge jeweils auf Masse (1, 2).
Die aus P1, P2, N3 und N4 bestehende Rückkopplungsschaltung ist somit von den Spaltenleitungen
getrennt.
Um die Spaltenleitungen auf gleiches Potential (in diesem Beispiel UB/2) zu legen, wird auf der Steuerleitung Precharge für kurze Zeit die Spannung +UB angelegt (3). Da das Gate (4) der Transistoren N5
und N6 dann auf höherem Pegel liegt als die zugehörigen Source-Anschlüsse (5), schalten N5 und N6
durch. Die Spaltenleitungen Bit und Bit invertiert werden somit beide auf UB/2-Potential aufgeladen (6)
und die beiden Transistoren N5 und N6 durch Anlegen von Masse an die Precharge-Leitung (7) danach wieder gesperrt.
Selbst wenn bei einer abgespeicherten „1“ N1 aufgrund des geringen Spannungsunterschiedes (ΔU =
UB – UB/2 = UB/2) zwischen Gate und Source nicht durchschalten sollte, führt die Spaltenleitung Bit
aufgrund der Aufladung zumindest positives Potential. Die Spaltenleitung Bit invertiert wird bei einer
abgespeicherten „1“ hingegen definitiv über N2 auf Masse gezogen, so dass am Differenzverstärker
das Vorzeichen der Pegeldifferenz der Punkte X und Y sofort detektiert werden kann.
1-46
Im Gegensatz zu SRAM-Speicherzellen sind DRAM-Speicherzellen wesentlich einfacher aufgebaut:
Sie bestehen lediglich aus einem Transistor und einem Kondensator.
Zeilenleitung
Spaltenleitung
C
Abb. 69: DRAM-Speicher
Der Transistor dient – wie die beiden Transistoren N1 und N2 beim SRAM – zur Isolierung des Speicherelements von der Aussenwelt. Das Speicherelement ist hier jedoch nicht eine rückgekoppelte
Transistorschaltung, sondern ein Kondensator.
Um ein Bit im DRAM abzulegen, wird der Transistor durchgeschaltet und der Kondensator über die
Zeilenleitung dann entweder ge- oder entladen. Anschliessend wird der Transistor wieder gesperrt, so
dass die im Kondensator gespeicherte Ladung erhalten bleibt.
Aufgrund von Leckströmen verliert der Kondensator jedoch mit der Zeit seine Ladung, weshalb er
immer wieder aufgefrischt werden muss. Die Speicherzelle muss dabei ausgelesen und dann mit dem
selben Wert wieder beschrieben werden.
Da Laden und Entladen bei Kondensatoren immer Zeit benötigt (U(t) = U0 ⋅ e
fe auf DRAMs im Vergleich zu Zugriffen auf SRAMs wesentlich langsamer.
-RC/t
), sind Speicherzugrif-
Da für DRAM-Speicherzellen vier Bauteile weniger benötigt werden als für SRAM, kann DRAM billiger
hergestellt werden als SRAM. Zudem benötigt eine DRAM-Speicherzelle wesentlich weniger SiliziumFläche als eine SRAM-Speicherzelle, weshalb deutlich mehr DRAM-Speicherzellen als SRAMSpeicherzellen auf einen Chip passen. Aus diesem Grund erreicht man bei einer bestimmten Speichergrösse mit DRAM auch eine höhere Ausbeute als mit SRAM, was den Preis von DRAM im Vergleich zu SRAM weiter senkt.
Gerade diese Wirtschaftlichkeit hat dafür gesorgt, dass als Arbeitsspeicher fast ausschliesslich
DRAM-Speicher verwendet wird.
Da die Zeilen- und Spaltenleitungen des Chips beim Be- und Entladen der Speicherzelle belegt sind
und somit nicht zum Be- und Entladen von anderen Speicherzellen des Speicherchips verwendet
werden können, sind die Daten aufeinanderfolgender Adressen in der Regel in verschiedenen Speicherchips abgelegt. Auf diese Weise kann bei den häufig auftretenden konsekutiven Speicherzugriffen
(Zugriffe auf aufeinanderfolgende Adressen) die eine Speicherzelle bereits ausgelesen werden, während in die andere noch die beim Auslesen verlorengegangene Ladung zurückgeladen wird.
Solche Verfahren haben zu einer Vielzahl unterschiedlicher DRAM-Speicherarten geführt. Eine von
diesen ist auch das in unserem PC verwendete DDR-RAM (Double-Data-Rate RAM), das eine Weiterentwicklung des SD-RAMs (Synchronous DRAM) ist.
1-47
Wie wir in Abb. 64 auf Seite 1-42 gesehen haben, werden zwischen Prozessor und Arbeitsspeicher
Daten transportiert. Prozessor und Arbeitsspeicher sind dazu über einen sog. Bus miteinander verbunden. Dass dieser Bus in Abb. 53 auf Seite 1-35 noch von einem weiteren Chip, dem GMCH (früher
Northbridge genannt), gekreuzt wird, soll uns hier erstmal nicht stören. Wir nehmen zunächst einfach
an, dass der Arbeitsspeicher direkt mit dem Prozessor verbunden ist (vgl. nachfolgende Abbildung).
Arbeitsspeicher
Prozessor (CPU)
Bus
BR:
•
Steuerwerk/
Leitwerk
•
Registerblock
mit Registern
Rechenwerk/
ALU
Abb. 70: Prozessor, Arbeitsspeicher und Bus
Desweiteren betrachten wir zunächst auch nicht den in unserem Rechner real verwendeten Bus, sondern wir wählen eine Art „Phantasie-Bus“, mit dem sich das Prinzip der Datenübertragung leichter
verstehen lässt. Wenn Sie das Prinzip des Datenaustauschs über Busse verstanden haben, schauen
wir uns die in unserem Rechner vorkommenden realen Busse an.
• Busse
Ein Bus ist nichts anderes als eine Menge paralleler Leitungen, die in ihrer Gesamtheit eine bestimmte
Funktion erfüllen: Das Übertragen von Daten von einem Sender zu einem Empfänger. In unserem
Beispiel vom Prozessor zum Arbeitsspeicher bzw. vom Arbeitsspeicher zum Prozessor.
Wie viele reale Bussysteme, gliedert sich auch der von uns hier betrachtete Phantasie-Bus in drei TeilBusse auf:
− Datenbus: Der Datenbus dient zur Übertragung der Daten, die zwischen dem Prozessor und
dem Arbeitsspeicher ausgetauscht werden sollen.
− Adressbus: Der Adressbus dient zur Adressierung. Unter Adressierung versteht man das Auswählen bestimmter Speicherstellen (oder Geräte – s.u.):
+ Beim Schreiben von Daten in den Speicher werden durch die Adressierung diejenigen
Speicherstellen bestimmt, in die die Daten geschrieben werden sollen.
+ Beim Lesen von Daten aus dem Speicher werden durch die Adressierung diejenigen Speicherstellen bestimmt, aus denen die Daten ausgelesen werden sollen.
1-48
− Steuerbus: Der Steuerbus steuert die Datenübertragung.
+ Wenn der Prozessor Daten in den Speicher schreibt, gibt bei unserem Phantasie-Bus eine
fallende Flanke auf der Schreibleitung Schreiben an, dass
• die auf dem Datenbus befindlichen Daten gültig sind und vom Speicher übernommen
werden können.
• die auf dem Adressbus befindliche Adresse gültig ist und vom Speicher verwendet werden kann.
• der Schreibvorgang jetzt durchgeführt werden soll.
+ Wenn der Prozessor Daten aus dem Speicher liest, gibt eine fallende Flanke auf der Leseleitung Lesen an, dass
• der Datenbus jetzt hochohmig (Tristate) ist, so dass der Speicher Daten auf den Datenbus ablegen kann, ohne dass es zu einem Kurzschluss kommt.
• die auf dem Adressbus befindliche Adresse gültig ist und vom Speicher verwendet werden kann.
• der Lesevorgang jetzt durchgeführt werden soll.
+ Wenn der Prozessor Daten aus dem Speicher liest, übernimmt er bei der steigenden Flanke
auf der Leseleitung Lesen die auf dem Datenbus anliegenden Daten und speichert sie intern ab.
Nachfolgende Abbildung zeigt die Verwendung unseres Phantasie-Busses bei einem Schreibvorgang.
Dabei wird der 4-Bit-Wert 10102 an die Speicheradresse 01102 geschrieben.
Adress-Bus:
Bit 3
Bit 2
Bit 1
Bit 0
1
3
Adr.
0
1
0
1
0
1
0
8
Daten-Bus:
2 0110
1 1010
5
Bus
Bit 3
Bit 2
Bit 1
Bit 0
4
1
0
1
0
1
0
1
0
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
Inhalt
1010 9
7
Steuer-Bus:
Lesen
Schreiben
Prozessor schreibt
Daten 1010 an
Adresse 0110
und gibt an der
Leitung „Schreiben“ eine fallen- Bus besteht aus Adress-,
de Flanke aus. Daten- und Steuer-Bus.
1
0
1
6
0
t
tschreiben
Spannungs-Pegel auf den Busleitungen in Abhängigkeit der Zeit.
Wert am Adress-Bus wählt
die Speicherzelle aus, in die
die Daten geschrieben werden.
Abb. 71: Bussignale und deren Verwendung beim Schreibzugriff
1-49
Zuerst legt der Prozessor das Datenwort (1), das abgespeichert werden soll, zusammen mit der Adresse (2), an die das Datenwort abgespeichert werden soll, auf den Bus.
Die grau hinterlegten Bereiche (3) und (4) zeigen die Adresse und das Datenwort als Signalpegel auf
den Busleitungen.
Nachdem der Prozessor Datenwort und Adresse am Bus angelegt hat, teilt er dem Speicher durch
eine fallende Flanke (5) auf der Steuer-Bus-Leitung Schreiben (6) mit, dass der Speicher die Daten
jetzt abspeichern kann.
Sobald der Speicher die fallende Flanke auf der Schreib-Leitung detektiert (7), wählt er die durch den
Adressbus adressierte Speicherzelle aus (8) und schreibt dorthin das am Datenbus anliegende Datenwort (9).
Das Einlesen von Daten aus dem Speicher in den Prozessor funktioniert so ähnlich:
Adress-Bus:
Bit 3
Bit 2
Bit 1
Bit 0
1
2
Adr.
0
1
0
1
0
1
0
6
Daten-Bus:
1 0110
10 1010
3
9
Bus
Bit 3
Bit 2
Bit 1
Bit 0
8
1
0
1
0
1
0
1
0
Prozessor legt
Adresse 0110
Steuer-Bus:
4 9
auf den Adress1
Lesen
Bus, hält den
0
Datenbus hochSchreiben 1
ohmig und gibt
0
auf der Leitung
t
Lesen eine faltschreiben
lende Flanke
aus. Damit zeigt
er, dass die
Adresse jetzt
Bus besteht aus Adress-, Spannungs-Pegel auf den Busgültig ist und
leitungen in Abhängigkeit der Zeit.
sofort gelesen Daten- und Steuer-Bus.
werden soll.
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111
Inhalt
1010 7
5
Wert am Adress-Bus wählt
die Speicherzelle aus, aus der
die Daten gelesen werden.
Zunächst legt der Prozessor die Adresse der Speicherstelle (1), von der die Daten eingelesen werden
sollen, auf den Adressbus. Der am Adressbus grau hinterlegte Bereich (2) zeigt, wie das Adresswort
0110 auf dem Bus als Logik- bzw. Spannungs-Pegel übermittelt wird.
Mit einer fallenden Flanke (3) auf der Steuerleitung Lesen (4) signalisiert der Prozessor dem Arbeitsspeicher, dass dieser den Inhalt der zur am Adressbus anliegende Adresse gehörigen Speicherstelle
auf den Daten-Bus legen soll. Detektiert der Arbeitsspeicher die fallende Flanke auf der Lesen-Leitung
(5), wählt er die adressierte Speicherstelle aus (6) und legt dann die dort abgespeicherten Daten (7)
am Datenbus an (8).
Der Prozessor wartet eine bestimmte Zeit und generiert dann auf der Lesen-Leitung eine steigende
Flanke (9), die er selber dazu benutzt, die auf dem Datenbus anliegenden Daten zu übernehmen (10).
1-50
Busse sind jedoch viel universeller, als dass sie nur die Datenübertragung zwischen Prozessor und
Arbeitsspeicher übernehmen könnten: Über Busse können auch alle im PC installierten Geräte angesteuert werden. Der Verdrahtungsaufwand ist dabei gering, da alle Kommunikationsteilnehmer sich
einfach an den Busleitungen „einklinken“ können, jede Busleitung also mit jedem Gerät verbunden ist.
Die nachfolgende Abbildungen zeigen, wie Daten nicht nur zwischen Prozessor und Speicher, sondern auch zwischen Prozessor und einem beliebigen Peripherie-Gerät übertragen werden können.
Das Schreiben von Daten in ein Peripheriegerät funktioniert dabei wie in nachfolgendem Beispiel: Der
Prozessor schreibt das Datenwort 1010 an die Adresse 0110. Die Adresse 0110 ist in diesem Fall
jedoch nicht dem Arbeitsspeicher, sondern einer bestimmten Speicherstelle in einem der vier an den
Bus angeschlossenen Geräte zugeordnet.
Adress-Bus:
Bit 3
Bit 2
Bit 1
Bit 0
1
2
0
3
1
0110
0
4 1010
10
Bus
Bit 2
Bit 1
Bit 0
Adresse ==
meine?
nein
8
6
0
1
0
Daten-Bus:
Bit 3
ja
1010
1
3
1 0110
Gerät 1
7
0110
5
Gerät 2
7
Adresse ==
meine?
nein
ja 9
1010
1
6 12
0
1010
1
0
1
0
3
1
0110
0
1010
Gerät 3
7
ja
Adresse ==
meine?
nein
8
6
Steuer-Bus:
Lesen
Schreiben
1
3
0
1
11
0110
0
Prozessor schreibt
Daten 1010 an
die Adresse 0110
und gibt an der
Leitung „Schreiben“ eine falBus besteht aus Adress-,
lende Flanke
Daten- und Steuer-Bus.
aus.
t
tschreiben
Pegel auf den Busleitungen
in Abhängigkeit der Zeit.
1010
Gerät 4
7
ja
Adresse ==
meine?
nein
6
8
Am Bus angeschlossene Geräte überprüfen die Adresse
und übernehmen ggf. die Daten.
Abb. 72: Schreiben von Daten in ein am Bus angeschlossenes Gerät (z.B. Steuerbefele fürs DVD-ROM)
Wie zuvor beim Schreibzugriff auf den Arbeitsspeicher legt der Prozessor zuerst die Adresse auf den
Adress-Bus (1). Die Adresse wandert über den Adressbus (2) und liegt dann bei allen am Bus angeschlossenen Geräten an (3).
Als nächstes legt der Prozessor die zu schreibenden Daten (4) auf den Daten-Bus (5), so dass auch
diese an allen am Bus angeschlossenen Geräten anliegen (6).
Jedes der am Bus angeschlossenen Geräte überprüft nun, ob es für die auf dem Adress-Bus anliegende Adresse (3) zuständig ist (7). In unserem Beispiel erkennen die Geräte 1, 3 und 4, dass sie
nicht für die am Adress-Bus anliegende Adresse zuständig sind, weshalb sie nichts unternehmen (8).
1-51
Gerät 2 erkennt jedoch, das die am Bus anliegende Adresse von ihm selber verwendet wird (9) und
bereitet sich darauf vor, die am Datenbus anliegenden Daten zu übernehmen.
Sobald der Prozessor das Übernahme-Signal (10) generiert und es über die Steuerleitung Schreiben
(11) an die am Bus angeschlossenen Geräte gelangt, übernimmt Gerät 2 die am Datenbus anliegenden Daten in seine durch 0110 adressierte Speicherstelle (12).
Das Lesen von Daten aus am Bus angeschlossenen Geräten funktioniert sehr ähnlich:
Adress-Bus:
Bit 3
Bit 2
Bit 1
Bit 0
1
2
0
3
1
0110
0
ja
5
0
1
0
Daten-Bus:
12 1010
7
11
Bus
Bit 3
Bit 2
Bit 1
Bit 0
Adresse ==
meine?
nein
1
3
1 0110
Gerät 1
4
0110
10
1010
1
Gerät 2
4
Adresse ==
meine?
nein
ja 6
9
0
1010
1
0
1
0
3
1
0110
Gerät 3
4
ja
0
Adresse ==
meine?
nein
5
Steuer-Bus:
Lesen
Schreiben
1
8
11
3
0
0110
1
Gerät 4
4
ja
0
Adresse ==
meine?
nein
5
t
Prozessor liest
Daten aus der
Speicherstelle
0110 eines ex- Bus besteht aus Adress-,
ternen Geräts Daten- und Steuer-Bus.
ein.
Pegel auf den Busleitungen
in Abhängigkeit der Zeit.
Am Bus angeschlossene Geräte überprüfen die Adresse
und legen ggf. die Daten auf
den Bus.
Abb. 73: Einlesen von Daten von einem am Bus angeschlossenen Gerät (z.B. Daten vom DVD-ROM)
Zuerst legt der Prozessor die Adresse, von der er etwas einlesen will, auf den Bus (1). Die Adresse
wird über den Bus übertragen (2) und liegt dann an allen am Bus angeschlossenen Geräten an (3).
Jedes Gerät überprüft nun, ob es für diese Adresse zuständig ist (4). In obiger Abbildung sind wieder
die Geräte 1, 3 und 4 nicht für die am Bus befindliche Adresse zuständig und ignorieren somit die
Anfrage (5). Gerät 2 erkennt, dass es für die am Bus anliegende Adresse zuständig ist (6) und macht
sich für weitere Schritte bereit.
Um den Datentransfer einzuleiten, legt der Prozessor eine fallende Flanke (7) auf die Steuerleitung
Lesen. Die Flanke wird vom Bus übertragen (8) und dann von den Geräten detektiert. Sobald das
Gerät 2 die fallende Flanke erkennt, legt es die an der Adresse 0110 gespeicherten Daten auf den
Datenbus (9), über den sie dann übertragen werden (10) und schliesslich am Prozessor anliegen. Mit
der auf die fallende Flanke folgenden steigenden Flanke (11) übernimmt der Prozessor die auf dem
Datenbus befindlichen Daten (12).
1-52
Nachdem wir nun wissen, wie der Prozessor Peripheriegeräte ansprechen kann, können wird das in
Abb. 70 auf Seite 1-48 gezeigte Bild wie nachfolgend angegeben erweitern:
Arbeitsspeicher
B4
C9
Bus
Prozessor (CPU)
Bios-Daten
(batteriegepuffert)
in C enthalten
•
•
•
Bios-Programm
(Flash)
Peripherie:
A
BR:
Steuerwerk/
Leitwerk
•
•
DL
Diskettenlaufwerk
Registerblock
mit Registern
•
FP
Festplatte
Rechenwerk/
ALU
•
•
DR
DB
•
C1
CD-/DVD-Laufwerk
LAN, USB, FireWire
c:\>
Bildschirm
• GK
D5
Tastatur
Abb. 74: Vereinfachter Aufbau eines Computers
Der Prozessor ist über einen Bus mit der Aussenwelt verbunden. Der Bus dient als einziges Kommunikationsmittel zwischen dem Prozessor und den restlichen Komponenten und wird (bis auf DMAZugriffe) vom Prozessor gesteuert. Die restlichen Komponenten gliedern sich in drei Gruppen:
− Im Flash-Speicher-Chip (C9), der sich auf der Hauptplatine befindet, sind diejenigen Befehle
abgespeichert, die nach dem Start des Computers als erstes ausgeführt werden; man spricht
hier vom sog. BIOS (Basic Input Output System), da in diesem Chip Programme abgelegt sind,
die eine rudimentäre Ansteuerung von Ein- und Ausgabegeräten ermöglichen. Benutzerdefinierte Einstellungen, die beim Starten des Rechners durchgeführt werden sollen, sind dabei in einem batteriegepufferten RAM abgelegt, das bei unserem Computer im ICH5 (Input Output Controller Hub der 5. Generation – das durch „C“ gekennzeichnete Bauelement) untergebracht ist.
− Der Arbeitsspeicher (B4) nimmt sowohl Daten als auch Befehle auf. In ihm stehen neben den
Programmen, die der Prozessor ausführt, auch die Daten, mit denen der Prozessor seine Berechnungen anstellt.
− Die Peripherie dient zur Ein- und Ausgabe von Daten
1-53
+ zwischen Mensch und Maschine (Tastatur und Bildschirm).
+ zwischen Maschine und Maschine (Festplatte, CD, DVD, Diskette, LAN-Adapter, USB- oder
FireWire-Adapter).
Der gesamte Ablauf in einem Computersystem lässt sich damit im wesentlichen auf drei Schritte zurückführen:
− Der Prozessor liest Daten aus dem Speicher oder einem Peripherie-Gerät ein.
− Der Prozessor verarbeitet diese Daten oder führt sie als Programm aus.
− Der Prozessor speichert verarbeitete Daten ab oder schickt sie an ein Peripherie-Gerät.
Wenn wir unseren Computer einschalten, beginnt der Prozessor automatisch damit, Befehle aus einer
bestimmten Speicheradresse zu holen und dann als Programm auszuführen. Diese allererste Speicheradresse liegt im Hauptplatinen-BIOS. Der Prozessor führt also zunächst Befehle aus, die in dem
auf der Hauptplatine aufgelöteten Flash-Speicher abgelegt sind. Mit diesen Befehlen wird zunächst
die Hardware der Hauptplatine überprüft (POST = Power On Self Test).
Im Anschluss überprüft der Prozessor den Arbeitsspeicher auf Kapazität (Menge des verfügbaren
Speichers) und Funktionsfähigkeit.
Um die auf der Hauptplatine befindliche Hardware einzustellen, werden die im batteriebepufferten
BIOS-Daten-RAM gespeicherten Einstellungen ausgelesen, verarbeitet und die Ergebnisse dann auf
bestimmte Speicheradressen geschrieben, die auf Befehls- und Daten-Register des Chipssatzes zeigen. Auf diese Weise werden im Chipsatz z.B. Einstellungen für das Ansprechen des Arbeitsspeichers
(Verzögerungszeiten etc.) oder für die Zugriffsweise auf den PCI-Bus getätigt.
Die Ausführung des im BIOS abgelegten Codes sorgt auch dafür, dass die BIOS-Bausteine der
Steckkarten und Peripherie-Geräte ausgelesen werden und der dort abgelegte Befehlscode vom Prozessor teilweise ausgeführt wird. Bei der Ausführung dieses Codes werden dann die zugehörigen
Steckkarten bzw. Peripherie-Geräte initialisiert. Dazu schreibt der Prozessor wieder Daten an Adressen, die auf Speicherstellen in den Steckkarten (z.B. Grafikkarte) bzw. in den Peripherie-Geräten verweisen. Diese Daten werden von den entsprechenden Geräten dann als Befehle interpretiert und
ausgeführt, was beispielsweise zu einer Grund-Einstellung der Grafikkarte führt.
Desweiteren werden aus den BIOS-Bausteinen rudimentäre Treiber für die zugehörigen Steckkarten
bzw. Geräte ausgelesen und im Arbeitsspeicher abgelegt. Der Begriff „rudimentär“ meint dabei, dass
die Treiber einen sehr eingeschränkten Funktionsumfang aufweisen und lediglich dafür Sorge tragen,
dass beim Starten des PCs die betreffenden Geräte in ihrer Grundfunktionalität verwendet werden
können.
Sollen beim Starten des Computers Funktionen einer Steckkarte ausgeführt werden, verzweigt der
Programmfluss in den Treiber, der dann die Kommunikation mit der Karte übernimmt, ihr die durchzuführende Aktion mitteilt und evtl. ein Ergebnis zurückliefert. Beispielsweise ermöglicht der Treiber des
Grafikkarten-BIOS, Text und einfache Grafik-Ausgaben auf dem Bildschirm auszugeben, was zur
Überwachung des PC-Startvorgangs vollkommen ausreichend ist. Erst beim Laden des Betriebssystems werden von der Festplatte dann die „richtigen“ Treiber für die Grafikkarte geladen, mit denen sich
das volle Leistungsspektrum der Grafikkarte ausschöpfen lässt.
8
Da es wesentlich günstiger ist, Treiber von der Festplatte zu laden, als jede Steckkarte bzw. jedes
Gerät mit einem Flash-Speicherchip auszurüsten, verfügen nur diejenigen Steckkarten/Geräte über
einen BIOS-Chip, die bereits beim Booten des Rechners funktionieren müssen:
− Grafikkarten, da diese evtl. Fehlermeldungen auf dem Bildschirm ausgeben müssen.
− Netzwerkkarten, da der Rechner evtl. über das Netzwerk gestartet werden soll, der sog. Bootloader (s. u.) sich somit auf einem anderen Rechner befindet und erst über die Netzwerkkarte in
den Arbeitsspeicher geladen werden muss.
8
Zum Einen ist es preislich günstiger, da Speicherplatz auf einem Flash-Speicher wesentlich teuerer ist als Speicherplatz auf
einer Festplatte. Zum Anderen ist es bei einem Treiber-Update wesentlich einfacher, eine Datei aus dem Internet herunterzuladen und in einem bestimmten Ordner abzulegen, als den Flash-Speicher neu zu programmieren.
1-54
Nach dem Laden/Ausführen der BIOS-Routinen der Steckkarten sorgt das im Hauptplatinen-BIOS
abgelegte Programm dafür, dass an die Festplatte Daten geschickt werden, die von dieser als Befehle
zur Adressierung des Bootrecords (Zylinder 0, Kopf 0 und Sektor 1 der ersten IDE-Festplatte) erkannt
werden. Im Bootrecord steht der sog. Bootloader, das Programm, das das Betriebssystem von der
Festplatte in den Arbeitsspeicher lädt.
Ist der Bootloader gefunden, sorgt das BIOS-Programm dafür, dass der Bootloader in den Arbeitsspeicher geladen und dann vom Prozessor ausgeführt wird. Die Kontrolle geht in diesem Moment vom
BIOS-Programm an den Bootloader über, der zunächst die Festplatte nach einem gültigen Betriebssystem durchsucht und den Programmcode des Betriebssystems dann ebenfalls in den Arbeitsspeicher lädt und dann vom Prozessor ausführen lässt. Jetzt geht die Kontrolle vollständig an das Betriebssystem über, das der Reihe nach immer mehr Daten von der Festplatte in den Arbeitsspeicher
lädt und dann als Programm ausführt. Dabei werden neben Betriebssystem-Code insbesondere auch
die auf der Festplatte gespeicherten Treiber der Peripherie-Geräte in den Arbeitsspeicher geladen
(und z.T. ausgeführt), so dass die am PC angeschlossenen Geräte über diese Treiber-Schnittstelle
angesprochen/verwendet werden können.
Aber nicht nur beim Starten des PCs dreht sich alles darum, dass der Prozessor Daten aus dem Arbeitsspeicher oder den Peripherie-Geräten einliest, verarbeitet (oder ausführt) und dann wieder ausgibt:
Wir haben zuvor gesehen, dass die ganze Darstellung des Bildschirminhalts darauf basiert, dass der
Prozessor Daten in den Video-Speicher der Grafikkarte schreibt.
Drückt man eine Taste auf der Tastatur wird dies dem Prozessor gemeldet und über den Bus wird
dann der Wert der gedrückten Taste ausgelesen.
Beim Bewegen der Maus wird dem Prozessor über den Bus mitgeteilt, um wieviele Längeneinheiten
die Maus nach links/rechts bzw. vorne/hinten bewegt wurde. Der Prozessor berechnet dann aus dieser Information die neue Position des Maus-Cursors, rendert im Arbeitsspeicher die neue Bildschirmansicht, die den verschobenen Mauszeiger darstellt und überträgt dieses Bild dann wieder in den Video-Speicher der Grafikkarte.
Da sich im PC also alles nur darum dreht, Daten von einem Ort zum anderen zu transportieren, ist
auch die Architektur eines PCs auf genau diesen Zweck ausgelegt.
Die auf der nächsten Seite noch einmal abgebildete Rechner-Architektur entspricht der realen Implementierung der in Abb. 74 auf Seite 1-53 gezeigten stark vereinfachten Rechner-Architektur.
Die Unterschiede sind klar erkennbar:
In unserem vereinfachten Modell (Abb. 74) sind alle Komponenten direkt an den Prozessor angeschlossen. Es gibt nur einen Bus, über den alle Komponenten und Peripherie-Geräte miteinander und
mit dem Prozessor verbunden sind. Unabhängig davon, wie schnell die einzelnen Geräte Daten verarbeiten oder übertragen können. So ein System wäre prinzipiell lauffähig, aber sehr langsam, da die
langsamen Geräte am Bus die schnellen ausbremsen.
Die reale Rechner-Architektur aus Abb. 75 verwendet mehrere verschiedene Busse, die unterschiedlich schnell sind und über sog. Bridges miteinander verbunden sind. Die englische Bezeichnung
Bridge trifft die Funktion dieser Bausteine auf den Kopf: Bridges sind Brücken, die verschiedene Bussyteme miteinander verbinden. Dabei werden die Daten, die über den sehr schnellen FSB mit dem
9
spezifischen FSB-Protokoll an den GMCH geschickt werden und nicht für ein direkt mit dem GMCH
verbundenes Gerät bestimmt sind, in das Bus-Protokoll des etwas langsameren HI-Busses gepackt
und dann an den ICH5 übertragen. Sind die Daten auch für keine direkt im ICH5 integrierte Komponente gedacht, werden die Daten in das entsprechend nächste Protokoll gepackt und dann auf dem
entsprechenden Bus weitergeschickt. Beispielsweise werden die mit dem HI-Protokoll an den ICH5
gelieferten Daten in das PCI-Bus-Protokoll eingebettet und dann über den PCI-Bus an eine Steckkarte
geschickt. Der auf der Steckkarte befindliche Controller entpackt die Daten dann wieder aus dem PCIProtokoll und verarbeitet sie.
9
Unter einem Bus-Protokoll versteht man die Regeln, nach denen die Kommunikation über den Bus abläuft. Beispiele für solche Regeln sind: Zuerst legt der Sender die Adresse für mindestens 20 ms auf den Adress-Bus. 5 ms, nachdem die Adresse
am Bus anliegt, folgt ein fallender Pegel auf der Lesen-Leitung...
1-55
Die gesamte Rechner-Architektur ist also gekennzeichnet durch ein von Bridges aufgespanntes Verbindungsnetzwerk, dessen Übertragungsrate höher wird, je näher man dem Prozessor kommt und
niedriger wird, je weiter man sich vom Prozessor entfernt.
A
Prozessor
Intel P4
RechenWerk
NT
230 V ~
Netzteil
SteuerWerk
Adress-Umsetzer
BefehlsCache
DatenCache
FSB Logik/Treiber
FS
B
TFTBildschirm
B1
DVI
Analoger VGAAnschluss
Intel 82865G
GMCH
GrafikController
B2
Grafikkarte
Prozessor-Bus, 4⋅200 MHz
(FSB = Front Side Bus)
AGP-
AGP-Port
DDR-RAM
DDR-RAM
2,1 GByte/s Controller Controller
GK
Gigabit-EthernetCSAController
Controller
266
MByte/s
B3
HI
LA
LANAnschluss
C
100 MBit/s
C1
FP
C2
Festplatte
DVDROM
DVDBrenner
DR
DB
C3
C4
Anschlüsse
für USB 2.0
480 MBit/s
2 Anschlüsse 150 MByte/s
für Serial-ATA
2 Anschlüsse
für ATA 100
Audio-Codec
AC `97 3
100 MByte/s
DDR-RAM B4
DDR-RAM
HI Controller
1 GBit/s
Kanal A
3,2 GyteB/s
Kanal B
3,2 GByte/s
B4
DDR-RAM B4
HI = Hub Interface
266 MByte/s
Intel 82801EB
ICH5
C6
Takt-Generator
CPU, PCI, …
Ethernet- SystemController Managmnt.
PCIUSB2.0Controller Controller
2 SATAController
B4
CMOSRAM
PCI-Bus
133 MByte/s
C7
6 PCI-Slots
FW
Batterie
C8
ATA 100 Bios-interf.
Controller Controller
Flash-Bios
C9
AC `97
SMBus
Controller Controller
SMBus 2.0/
I2C-Bus
FireWireAdapter
LPC-interface
Controller
LPC-Interface
(Low Pin Count)
D
Super
Input/Output
Controller
D4
D1 Anschluss für
seriellen Port
RS 232
Floppy
Controller Controller
Anschluss Disketten-Laufwerk
D2 Anschluss für
parallelen Port
LPT
Tastatur
Controller Controller
PS/2 Anschluss D5
Tastatur
Anschluss für
Ventilator
DrehzahlMaus
regelung Controller
PS/2 Anschluss
Maus
D3
Abb. 75: Architektur eines Computers
1-56
DL
DiskettenLaufwerk
Tastatur
Maus
D6
Im Folgenden sind die Funktionen der Haupt-Bridges stichpunktartig zusammengestellt.
10
• GMCH = Graphics and Memory Controller Hub (B)
− ist direkt am Prozessor angeschlossen ⇒ „Datenverteiler“ für sehr schnelle Geräte
− führt für den Prozessor Zugriffe auf den Arbeitsspeicher (engl. Memory, hier: DDR-RAM) aus
− verfügt über einen integrierten Grafik-Controller (eine integrierte Grafik-„Karte“), mit der der Prozessor Bilder auf einem Monitor ausgeben kann ⇒ Begriff „Graphics“ in GMCH
− kann externe Grafikkarten über den AGP-Port ansprechen, so dass der Prozessor Bilder auch
auf diesem Weg auf einem Monitor ausgeben kann ⇒ Begriff „Graphics“ in GMCH
− bietet eine Anschlussmöglichkeit für einen Gigabit-Ethernet-Controller, über den der Prozessor
Daten mit bis zu 1 GBit/s über ein Netzwerk übertragen kann
− kann vom Prozessor konfiguriert (eingestellt) werden
− früher auch Northbridge genannt (North, da „oben beim Prozessor“ und Bridge, da Verbindung
zwischen zwei Bussen [Brückenfunktion])
• ICH5 = Input/Output Controller Hub (5. Generation) (C)
− „Datenverteiler“ für mittel schnelle bis schnelle Geräte
11
12
− verfügt über diverse Ein- und Ausgabe-Controller, insbesondere für PCI und IDE
− internes batteriegepuffertes RAM zur Sicherung von Konfigurationsdaten (z.B. BIOSEinstellungen)
− bietet Anschlussmöglichkeit für den Flash-BIOS-Chip, der den System-Startup-Code enthält
− früher auch Southbridge genannt, (South, da unterhalb der Northbridge und Bridge, da Brückenfunktion zwischen verschiedenen Bussen)
• SIO-Controller = Super Input/Output Controller (D)
− „Datenverteiler“ für langsame Geräte
− verfügt insbesondere über die Controller für serielle/parallele Schnittstellen, Floppy, Tastatur
und Maus
10
Controller = aktive Komponente, die andere Elemente steuert (engl. to control = steuern).
PCI = Peripheral Component Interconnect: Standardisierter Peripheriebus ⇒ Peripherie-Geräte (z.B. Erweiterungskarten)
werden nicht direkt an den Prozessor oder den FSB angeschlossen, sondern über den standardisierten PCI-Bus. Der grosse
Vorteil besteht darin, dass bereits angeschaffte Peripherie-Geräte auch über mehrere Prozessorgenerationen hin verwendet
werden können. Bei der Entwicklung neuer Prozessoren, die evtl. auch über einen geänderten FSB verfügen, muss dann nur
ein neuer GMCH bzw. ICH eingesetzt werden, der aus den neuen FSB-Signalen dann wieder die standardisierten PCI-Signale
erzeugt. Die ganzen Peripherie-Geräte können dann trotz geändertem FSB weiterhin am (standardisierten) PCI-Bus betrieben
werden.
12
IDE = Integrated Drive Electronics: Standardisierte Schnittstelle zum Anschluss von Festplattenlaufwerken (sowie CD, DVD
etc.). Der Name „Intergrated Drive Electronics“ begründet sich darin, dass Festplatten vor IDE-Zeiten über keine eigenen Controller-Chip verfügten, also direkt vom Prozessor gesteuert wurden. Mit der Einführung von IDE wurden die Steueraufgaben der
Festplatte (z.B. Kopfpositionierung) von einer im Festplattengehäuse untergebrachten Steuerelektronik (dem Controller) erledigt, was zu einer starken Entlastung des Hauptprozessors führte. Durch die Standardisierung von IDE und der Entkoppelung
vom Prozessor/FSB ergeben sich die selben Vorteile wie beim PCI-Bus.
11
1-57
1.2 Von Neumann-Architektur
Die Architektur unseres Rechners geht unter anderem auf den Mathematiker John von Neumann zurück, weswegen sie auch von Neumann-Architektur genannt wird.
John von Neumann wurde 1903 in Budapest/Ungarn geboren, wo er als Sohn des Bankiers Max
Neumann aufwuchs. Da John von Neumanns Vater Max Neumann im Budapest zu Beginn des 19. Jh.
zu einer bedeutenden Figur geworden war (Adelstitel als Ehrung) und die Angewohnheit hatte, ausgewählte Kunden seiner Bank zu sich nach Hause zum Abendessen einzuladen und seiner Familie
auch Proben oder Modelle neuer industrieller Unternehmungen, die er finanzierte, mit nach Hause
brachte, erfuhr John von Neumann schon sehr früh von Joseph-Marie Jacquard, dessen Lochkartenbetriebene Webstühle in Abhängigkeit der Codierung der Lochkarte jedes beliebige Muster weben
konnte. Dieser Webstuhl kann als der erste Computer angesehen werden.
John von Neumann war ein Wunderkind. Bereits zu Schulzeiten konnte ihm kein Mitschüler auch nur
annähernd das Wasser reichen. Während seine Kameraden auf dem Pausenhof spielten, stand der
kleine Johnny eher abseits und analysierte das Verhalten seiner Mitschüler. Sein Vater förderte ihn,
indem er Professoren anstellte, die Johnny nach der Schule daheim unterrichteten.
Johnny wollte Mathematiker werden, doch sein Vater drängte ihn, in Berlin Chemieingenieur zu studieren, da diesem Beruf gute Zukunftsaussichten nachgesagt wurden. Johnny entschloss sich schließlich
für einen ehrgeizigen Kompromiss, der ihn zum Einen absicherte, zum Anderen aber auch alle Karriere-Chancen offen ließ: Noch bevor er sich für das Studium als Chemieingenieur einschrieb, schrieb er
sich an der Universität Budapest als Doktorand in Mathematik ein. Er hatte vor, als Student und Doktorand gleichzeitig zu arbeiten – und zwar in zwei mehreren hundert Kilometer auseinanderliegenden
Städten. Um diese Unverfrohrenheit auf die Spitze zu treiben, wollte der damals 17-jährige Gymnasiast in seiner Doktorarbeit die Axiomatisierung der Mengenlehre Georg Cantors versuchen – das strittigste Themen der zeitgenössischen Mathematik, das bereits einige berühmte Professoren aufs Glatteis geführt hatte. Das Studium als Chemieingenieur in Berlin sah John von Neumann eher als lästige
Nebentätigkeit an, weshalb er es auch nach zwei Jahren ohne Abschluss beendete und dafür im
Herbst 1923 die Aufnahmeprüfung für das zweite Jahr des Vierjahreskurses „Chemieingenieur“ an der
13
rennomierten ETH (Eidgenössische Technische Hochschule) Zürich bestand.
John von Neumann hatte eine aussergewöhnliche Begabung: Er konnte sich sehr schnell in fremde
Thematiken einlesen und dann die in diesem Bereich tätigen Forscher mit seinem Wissen meilenweit
überholen.
Abb. 76: John von Neumann
13
Albert Einstein – mit dem John von Neumann später in Princeton zusammenarbeitete – versagte 1895 bei der Aufnahmeprüfung der ETH, woraufhin er eine Stelle im Berner Patentamt annahm. Dort entwickelte er dann die Spezielle Relativitätstherorie.
1-58
Das gelang ihm auch in nicht technischen Disziplinen: Er leistete mit seinem Buch über Spieltheorie
und der Niederschrift zu seinem Vortrag „Über gewisse Gleichungen in der Ökonomie und eine Verallgemeinerung von Brouwers Fixpunkt-Theorem“ wichtigste Beiträge zu den Wirtschaftswissenschaften.
Ende der 1980er Jahre wurde die genannte Niederschrift von berühmten Wirtschaftswissenschaftlern
als „der wichtigste Artikel auf dem Gebiet der mathematischen Ökonomie, der jemals geschrieben
wurde“ bezeichnet.
John von Neumanns Beiträge zur Computertechnik liegen insbesondere in der Programmierbarkeit
von Computern. Bevor John von Neumann die Computertechnik revolutionierte, waren Computer darauf ausgerichtet, die Lösung für ein ganz bestimmtes Problem zu berechnen. Die Computer wurden
damals „programmiert“, indem die Kabelverbindungen zwischen den Komponenten des Computers
geändert wurden. John von Neumann erinnerte sich an die in seiner Kindheit kennengelernten Webstühle von Joseph-Marie Jacquard, die in Abhängigkeit einer Lochkarte jedes beliebige Muster weben
konnten und übertrug dieses Prinzip auf die von Eckert und Mauchly am IAS (Institute for Advanced
Studies) in Princeton gebauten festverdrahteten Rechner. Seitdem konnten Rechner in Abhängigkeit
von Lochkarten unterschiedliche Programme ausführen. Die Rechner waren damit nicht mehr auf ein
bestimmtes Problem zugeschnitten, sondern universell verwendbar. Das aufwendigen Umstecken von
Verbindungskabeln wich der Programmierung durch Lochkarten. Es waren keine Änderungen an der
Verkabelung der Rechner mehr nötig. Der Aufbau des Rechners war plötzlich unabhängig vom zu
lösenden Problem geworden.
Die Befehle auf den Lochkarten waren alle immer nach dem selben Prinzip aufgebaut. Anders als bei
der deutschen Sprache war der Sinn der einzelnen Befehle nicht vom Kontext abhängig, in dem der
Befehl stand. Betrachtet man beispielsweise im Satz „Fliegen ist schön.“ lediglich das erste Wort
„Fliegen“, so kann man nicht sagen, ob damit das Verb „fliegen“ gemeint ist, oder der Plural von „die
Fliege“. Man erkennt erst am zweiten Wort („ist“ und nicht „sind“), dass nicht über schöne Insekten,
sondern über die Fortbewegung in der Luft geredet wird.
Als John von Neumann vor dem Problem stand, Computerbefehle in einer Sprache zu formulieren, die
keine Mehrdeutigkeiten der gezeigten Art aufweist, kam ihm der Lateinunterricht zugute, den er auf
dem Lutheraner-Gymnasium in Budapest genossen hatte: Er übertrug die klare Regelmäßigkeit der
Lateinischen Sprache (z.B. Verb steht fast immer am Satzende) auf Computerbefehle und legte damit
das erste Befehlsformat der Welt fest.
(Die Befehle des MMIX-Prozessors, den wir im Laufe der Vorlesung noch kennenlernen werden, hat
ein äußerst regelmäßiges Befehlsformat: Das erste Byte ist immer der Befehl, die nächsten drei Byte
sind immer die Operanden.)
John von Neumann schlug vor, den von Eckert und Mauchly am IAS gebauten Computer um die Programmierbarkeit in einer kontextfreien Sprache zu erweitern. Nachdem er den Vorschlag schriftlich
festgehalten hatte, verschickte ein Kollege diesen Vorschlag als Publikation. Da von Neumann diesen
Vorschlag jedoch nur für interne Zwecke am IAS gedacht hatte, fehlten auf ihm die Namen von Eckert
und Mauchly, auf deren Computer sich die Erweiterungen bezogen. John von Neumann wurden somit
fälschlicherweise Ehren zugesprochen, die eigentlich Eckert und Machly zugestanden hätten, da der
von Eckert und Mauchly entwickelte Computer von aller Welt nun als von Neumanns Werk angesehen
wurde. Das ging soweit, dass die Rechner, die in Folge der „von Neumann-Veröffentlichung“ gebaut
wurden und in groben Zügen immer noch der Architektur unserer heutigen Rechner entsprechen, von
Neumann-Architektur genannt werden.
1-59
Der in der von Neumann-Veröffentlichung beschriebene Rechner hatte vier Funktionseinheiten, die bis
in unsere heutige Zeit als Rechnerkomponenten erhalten geblieben sind.
Speicher für Daten und Befehle
Registerblock
mit Registern
Ein- und
Ausgabe
c:\>
Steuerwerk/
Leitwerk
Rechenwerk/
ALU
Prozessor
Abb. 77: von Neumann-Architektur
− Das Rechenwerk verknüpft die Operanden, indem es Operationen auf sie anwendet. Beispiele
hierfür sind die vier Grundrechenarten (Addition, Subtraktion, Multiplikation und Division) und
Schiebeoperationen (links schieben/rechts schieben). Allein mit den vier Grundrechenarten lassen sich auch die kompliziertesten Formeln und Funktionen berechnen. Beispiele hierfür sind
die Verwendung von Potenzreihen zur Berechnung von Sinus und Cosinus:
sin x = x −
x3 x5 x7
x2n+1
+ − + ... + (−1)n ⋅
+ ...
3! 5! 7!
(2n + 1)!
− Im Speicher stehen sowohl die Befehle, als auch die Operanden/Daten. Beide sind als Zahlen
codiert. Bei einem Blick in den Speicher kann man somit keinen Unterschied zwischen Befehlen
und Operanden/Daten erkennen. Dass eine Bitfolge ein Befehl ist, erkennt man erst dann, wenn
sie vom Steuerwerk in das Befehlsregister geladen und dann ausgeführt worden ist.
− Das Steuerwerk steuert den Ablauf im Prozessor/Rechner. Es lädt die Befehle aus dem Speicher, analysiert sie, lädt die entsprechenden Operanden aus oder in den Speicher, teilt dem
Rechenwerk mit, welche Operation es ausführen soll und leitet das Ergebnis wieder an die gewünschte Stelle.
− Das Ein- und Ausgabewerk (E/A-Werk) ist die Schnittstelle zwischen Rechner und PeripherieGerät, zu von Neumanns Zeit also die Anbindung des Rechners an den Lochkartenleser. Im
letzten Abschnitt haben wir gesehen, dass bei unseren weiterentwickelten von NeumannArchitekturen das Ein- Ausgabewerk über verschiedene Bussysteme auf mehrere Chips
(GMCH, ICH, SIO) verteilt ist. Die Funktion ist prinzipiell aber noch genau die gleiche.
Zu vier genannten klassischen Funktionseinheiten ist später noch der Bus dazugekommen, der somit
nicht zu den original von Neumannschen Funktionseinheiten gehört.
1-60
Im Folgenden sind einige für von Neumann-Maschinen typische Merkmale aufgeführt:
− Der Aufbau des Rechners ist unabhängig vom Problem. Durch Laden eines bestimmten Programms in den Speicher kann der Rechner zu Lösung jedes beliebigen Problems verwendet
werden. Die Hardware (z.B. Verbindungsleitungen) muss also nicht mehr auf die jeweilige Problemstellung angepasst werden.
− Alle Daten (nicht nur die Operanden, sondern auch die Adressen und insbesondere auch die
Befehle) werden als Zahlen binär kodiert und im Speicher abgelegt. Der Speicher besteht dabei
aus gleich grossen, durchnumerierten Zellen.
− Die zu einem Programm gehörigen Befehle stehen sequentiell (einer nach dem anderen) im
Speicher und werden der Reihe nach ausgeführt. Lediglich bei Sprüngen findet eine Verzweigung statt.
14
Da von Neumann auf eine Patentierung seiner Erweiterungen verzichtete , konnte jede Forschungsanstalt/Firma ohne Lizenzgebühren auf diesen Erweiterungen aufbauen und sie weiter vorantreiben.
Es war genau dieser Sachverhalt, der sich als sehr fruchtbarer Boden für Weiterentwicklungen erwies
und damit zum Siegeszug der von Neumann-Architektur führte.
14
Eckert und Mauchly hatten hingegen vor, ihren Rechner als Patent anzumelden, was spätestens dann zum Scheitern verurteilt war, nachdem die von Neumann-Erweiterungen (unauthorisiert) publiziert wurden.
1-61
1.3 Harvard-Architektur
Der gemeinsame Speicher für Programme und Daten macht die Entwicklung und den Test von Programmen auf einer von Neumann-Architektur sehr einfach: Man schreibt in einem Texteditor ein Programm, übersetzt es in Maschinencode und kann es dann sofort ausführen. Während des Vorgangs
des Übersetzens sind die Befehle des generierten Maschinencodes die Daten, die das Übersetzungsprogramm erzeugt. Diese Daten werden erst zu einem Programm, wenn sie vom Prozessor in das
Befehlsregister geladen werden und dann ausgeführt werden. Da Daten und Programme nicht unterscheidbar im selben Speicher liegen, bedeutet es keinen zusätzlichen Aufwand, Daten als Programm
auszuführen.
Es ergibt sich jedoch auch ein Nachteil: Da Programme und Daten im selben Speicher liegen, müssen
beide über den gleichen Bus zum Prozessor transportiert werden. Während ein Befehl vom Speicher
in den Prozessor geladen wird, kann nicht gleichzeitig ein Datum aus dem Speicher gelesen oder in
den Speicher geschrieben werden. Befehle und Daten behindern sich somit gegenseitig, was insbesondere Programme mit hohem Datenvolumen (z.B. Videodecoder) ausbremst.
Abhilfe kann hier eine Architektur schaffen, bei der Daten und Befehle in separaten Speichern stehen:
Die sog. Harvard-Architektur.
Speicher für Daten
Prozessor
Registerblock
mit Registern
Ein- und
Ausgabe
c:\>
Steuerwerk/
Leitwerk
Rechenwerk/
ALU
Speicher für Befehle
Abb. 78: Harvard-Architektur
Da Daten- und Befehlsspeicher bei dieser Architektur getrennt sind, können sie über separate Busse
an den Prozessor angebunden werden. Somit kann gleichzeitig auf Befehle und Daten zugegriffen
werden, was insbesondere die Ausführung von Programmen mit hohem Datenverkehr beschleunigt.
Da solche Programme (z.B. ein Videodecoder in einer Set-Top-Box) besonders oft auf spezialisierten
Signalprozessoren ablaufen, verfügen Digitale Signalprozessoren (DSPs) ebenso wie Mikrocontrol15
ler häufig über eine Harvard-Architektur. Programme für DSPs und Mikrocontroller werden in der
Regel auf einem gewöhnlichen PC entwickelt (Cross-Plattform) und dann in den Befehls-Speicher des
Prozessors geladen. Da es zeitlich keinen Unterschied macht, ob die Befehle vom PC aus in den Daten- oder den Befehls-Speicher eines Signalprozessors geladen werden, hat die Verwendung einer
16
Harvard-Architektur für Embedded-Prozessoren keine Nachteile. Bei der Verwendung einer HarvardArchitektur als PC-Prozessor hingegen müsste nach der Übersetzung eines Programms der Programmcode erst vom Daten- in den Befehlsspeicher kopiert werden, was die Programmentwicklung
verlangsamen und umständlich machen würde.
15
Mikrocontroller sind Mikroprozessoren, die über zusätzliche Peripherie auf dem Chip (z.B. Ein- und Ausgabe-Ports, A/DWandler, Timer, Befehls- und Datenspeicher) verfügen. Mikrocontroller werden im Embedded-Bereich beispielsweise zur Steuerung von Waschmaschinen, Kochfeldern etc. verwendet.
16
Unter Embedded-Prozessoren bzw. Prozessoren für den Embedded-Bereich versteht man Prozessoren, die nicht in PCs,
sondern in anderen eigenständigen Geräten wie beispielsweise einer Mikrowelle, einer Waschmaschine oder einem DVDPlayer integriert (eingebettet) sind.
1-62
1.4 Vom Algorithmus zum Prozessor – Abstraktionsebenen
Nachdem wir bisher nur den Aufbau und die Architektur von Rechnern untersucht haben, betrachten
wir ab diesem Abschnitt, wie dieser Rechner zur Lösung von Problemen eingesetzt werden kann.
Problemlösung
in AlgorithmusForm
x = x + aibi
i =i–1
Beim Entwurf
Übersetzung durch
den Menschen
Hochsprachen-Ebene
*.c
Problemlösung
in Hochsprache
(z.B. C)
*.asm
Maschinennahe Form der
Problemlösung
*.c
Übersetzung
durch Compiler
Compiler
Assembler-Ebene
*.asm
Übersetzung
durch Assembler
Assembler
Bibliothek
*.obj
*.obj
Linker
Befehlssatz-Ebene
*.obj
Linker
Maschinencode
der Problemlösung
*.exe
Interpretation oder
direkte Ausführung
durch die Hardware
Mikroarchitektur-Ebene
Interpretation
HardwareSteuerung
Elektr.
Signale
Zur Laufzeit
Steuerung
Ebene der digitalen Logik
Gatter/Hardware
Aufbau von
Speicher, ALU..
aus LogikGattern
Transistoren
Aufbau von
Logik-Gattern
aus Transistoren
Halbleiter-Strukturen
Aufbau von
Transistoren
aus n- und pSchichten
Transistor-Ebene
Layout-Ebene
Mikroprogramm
Aufbau des
Problemlösers
(Rechner/Prozessor) aus
Speicher, ALU …
Abb. 79: Abstraktionsebenen
1-63
Computertechnik/Computersysteme
Algorithmus-Ebene
Integr. Schaltungen
i = n, x = 0
i>0
Grundl. d. Informatik
Nachfolgende Abbildung dient uns dabei als Wegweiser durch die nächsten Kapitel.
Die Abbildung zeigt im oberen Teil, wie ein Problem abstrakt dargestellt (Algorithmus-Ebene) und
dann von einem Programmierer in einer Hochsprache wie z.B. der Programmiersprache C (Hochsprachen-Ebene) formuliert werden kann.
Aufgabe der Algorithmus-Ebene ist es, Informationen und Anweisungen, die zur Lösung des betrachteten Problems notwendig sind, in einer einheitlichen Darstellung festzuhalten.
Beispiele für solche Darstellungen sind z.B. Lösungsformeln
Èb1 ˘
Í ˙
Íb2 ˙
Í ˙
a n ] ◊Í ˙ = a1b1 + a 2b2 + L + a n bn
Í M˙
Í ˙
Íbn ˙
ÎÍ ˚˙
x = [a1 a 2 L
Abb. 80: Formel zur Berechnung eines Skalarprodukts
oder Diagramme.
i = n, x = 0
i>0
x = x + aibi
i =i–1
Abb. 81: Nassi-Shneiderman-Diagramm/Struktogramm
Ist die gewählte Darstellungsart hinreichend bekannt, kann sie zur Weitergabe von Informationen oder
Lösungsverfahren genutzt werden. Wenn Sie beispielsweise wissen, wie man die in Abb. 80 dargestellten Buchstaben, Zahlen (Indices) und Symbole interpretieren muss und zusätzlich über die Information verfügen, dass die in Abb. 80 dargestellte Formel zur Berechnung von Skalarprodukten dient,
können sie automatisch auch Skalarprodukte berechnen.
Die Darstellungen auf der Algorithmus-Ebene dienen also zum Informationsaustausch zwischen Menschen.
Für Maschinen (Computer) sind diese Darstellungsarten zu abstrakt.
Ein Computer kommt mit einer Problem-Beschreibung auf Hochsprachen-Ebene wesentlich besser
zurecht. Das liegt insbesondere daran, dass bei der Entwicklung von Hochsprachen darauf geachtet
wurde, dass sie nicht nur vom Menschen (Programmierer), sondern auch vom Computer (Compiler)
gut verstanden werden kann. Eine Hochsprache ist also eine definierte Schnittstelle zwischen Mensch
und Maschine.
Nachfolgende Abbildung zeigt, wie ein Programmierer einen ihm als Nassi-Shneiderman-Diagramm
übermittelten Algorithmus in die Hochsprache C übersetzt.
i = n, x = 0
i>0
x = x + aibi
i =i–1
*.c
*.c
Abb. 82: Übersetzen eines Algorithmus’ auf Hochsprachen-Ebene
1-64
Der vom Programmierer erzeugte Hochsprachen-Code kann beispielsweise wie folgt aussehen:
void main()
{
int w, x;
const int n = 4;
// Vektordimension
int a[n]={1,2,3,4}, b[n]={10,20,30,40};
w = n;
x = 0;
while(w)
{
w = w - 1;
x = x + a[w] * b[w];
}
// in x steht jetzt der Wert des Skalarprodukts
}
Diese Darstellung ist für einen Menschen etwas schwieriger zu lesen als die Darstellung als Formel
oder Nassi-Shneiderman-Diagramm. Für eine Maschine ist diese Darstellung jedoch wesentlich angenehmer, da sie beispielsweise nur aus ASCII-Zeichen besteht.
Hochsprachen sind aber keineswegs die „Muttersprache“ eines Computer, also keine Sprache, die
Computer direkt verstehen können. Hochsprachen sind ein Kompromiss zwischen „für den Menschen
verständlich“ und „für den Computer verständlich“. Damit ein Computer den Sinn von HochsprachenAnweisungen verstehen kann, müssen diese in Maschinen-Code, die „Muttersprache der Computer“
übersetzt werden.
Dazu wird zunächst die Hochsprache mit Hilfe eines Compilers in Assembler-Befehle übersetzt.
Nachfolgende Abbildung zeigt den Ausschnitt aus Abb. 79, der in *.c-Dateien abgespeicherten CQuellcode in Assembler-Code übersetzt.
*.c
*.c
Compiler
*.asm
*.asm
Abb. 83: Compilation
Das entspricht einer Wandlung von Anweisungen der Hochsprachen-Ebene auf die Assembler-Ebene.
Die Darstellung auf der Assembler-Ebene hat dieselbe Struktur wie der zuvor als „Muttersprache der
Computer“ bezeichnete Maschinen-Code. Zusätzlich zu den vom Prozessor unterstützten Befehlen
findet man auf der Assembler-Ebene jedoch noch Anweisungen für den Assembler, also Anweisungen
für das Programm, das den Assembler-Code in Maschinen-Code übersetzt. Diese Anweisungen dienen zum Einen dazu, den Code lesbarer zu machen, zum Anderen, um festzulegen, wo im Speicher
das übersetzte Programm zur Ausführung abgelegt werden soll.
1-65
Im Folgenden ist der Assembler-Code des oben angegebenen C-Programms abgebildet.
LOC
GREG
Data_Segment
@
OCTA
OCTA
OCTA
OCTA
OCTA
OCTA
OCTA
OCTA
OCTA
4
1
2
3
4
10
20
30
40
Vektordimension
a1
a2
a3
a4
b1
b2
b3
b4
IS
IS
IS
IS
IS
IS
$1
$2
$3
$4
$5
$6
Für
Für
Für
Für
Für
Für
Start
LOC
SETL
LDA
LDA
LDO
MUL
BZ
SUB
LDO
LDO
MUL
ADD
JMP
#100
x,0
u,ADR_A1
v,ADR_B1
w,N
w,w,8
w,Ende
w,w,8
y,u,w
z,v,w
y,y,z
x,x,y
Start
Initialisierung
Referenz auf a1 in u speichern
Referenz auf b1 in v speichern
Vektordimension laden
verwendete Worte haben 8 Byte
wenn fertig -> Ende
w = w - 8
y = <u + w>
z = <v + w>
y = <u + w> * <v + w>
x = x + <u + w> * <v + w>
Ende
TRAP
0,Halt,0
N
ADR_A1
ADR_B1
u
v
w
x
y
z
Main
Parameter 1
Parameter 2
Parameter 3
das Ergebnis
Zwischenberechnungen
Zwischenberechnungen
Ergebnis steht in x
Das Assembler-Programm ist wesentlich länger als das C-Programm. Das liegt daran, dass Hochsprachen-Anweisungen wesentlich mächtiger sind (mehr „können“) als Assembler-Anweisungen. Aus
diesem Grund wird eine C-Anweisungen in mindestens eine, meist jedoch mehrere AssemblerAnweisungen übersetzt.
Damit ein Prozessor Assembler-Anweisungen verstehen kann, müssen diese erst in Maschinen-Code
übersetzt werden, der dann in einer Programm-Datei abgelegt wird. Diese Aufgabe wird vom Assembler übernommen. Besteht ein Programm aus mehreren Programm-Dateien, müssen diese zusätzlich
von einem Linker zu einer einzigen Programm-Datei (unter Windows die *.exe-Datei) zusammengefügt werden. Nachfolgende, der Abb. 79 entnommene Darstellung verdeutlicht diesen Vorgang.
1-66
*.asm
*.asm
Assembler
Bibliothek
*.obj
*.obj
Linker
*.obj
Linker
*.exe
Abb. 84: Übergang von der Assembler- zur Befehlssatz-Ebene
In der ausführbaren Programmdatei stehen neben den Maschinen-Befehlen unter anderem auch Anweisungen für das Betriebssystem (den Loader), der das Programm in den (Befehls-) Speicher lädt
und dann an einer bestimmten Stelle mit der Ausführung beginnt.
Nachfolgende Abbildung zeigt den Inhalt der zum oben angegebenen Assembler-Code gehörigen
Programmdatei.
98
09
01
01
3E
B7
E8
DB
98
01
20
01
00
00
00
00
00
00
00
00
00
00
00
04
00
00
00
00
00
00
00
01
00
00
00
00
00
00
00
02
00
00
00
00
00
00
00
03
00
00
00
00
00
00
00
04
00
00
00
00
00
00
00
0A
00
00
00
00
00
00
00
14
00
00
00
00
00
00
00
1E
00
00
00
00
00
00
00
28
98
01
00
01
00
00
01
00
98
06
00
03
73
6B
61
6C
70
72
6F
64
2E
6D
6D
73
98
07
00
18
E3
04
00
00
23
01
FE
08
23
02
FE
28
8D
03
FE
00
19
03
03
08
42
03
00
00
25
03
03
08
8C
05
01
03
8C
06
02
03
18
05
05
06
20
04
04
05
F1
FF
FF
FA
98
04
00
07
98
07
00
25
00
00
00
00
98
0A
00
FE
20
00
00
00
00
00
00
00
00
00
00
00
00
00
01
00
98
0B
00
00
20
3A
50
50
50
50
40
20
41
20
44
20
52
20
5F
30
41
09
31
08
83
20
42
09
31
28
84
40
40
20
45
20
6E
20
64
02
65
01
30
8B
40
40
30
4D
20
61
20
69
02
6E
01
00
81
09
4E
00
82
20
53
20
74
20
61
10
20
72
02
74
01
14
8C
10
1F
75
01
85
1F
76
02
86
1F
77
03
87
1F
78
04
88
1F
79
05
89
0F
7A
06
8A
98
0C
00
18
Die Programmdatei ist für einen Menschen kaum noch lesbar. Ein Computer hingegen interpretiert die
angegebenen Zahlen als Befehle, Operanden und Daten und führt entsprechende Aktionen aus.
Abb. 79 können Sie entnehmen, dass wir nun den kompletten oberen Bereich „Beim Entwurf“ durchlaufen haben. Von der Algorithmus-Ebene bis zur Befehlssatz-Ebene haben wir uns dabei stets mit
der Darstellung von Information beschäftigt. Wir haben die Informationsdarstellung schrittweise von
„für den Menschen gut lesbar, aber für den Computer schlecht lesbar“ bis „für den Menschen schlecht
lesbar, aber für den Computer gut lesbar“ verändert.
Die gezeigten Umwandlungen von einer Darstellung in eine andere finden immer beim Entwurf statt,
also während der Entwicklung des Programms.
1-67
Im Gegensatz dazu beschäftigt sich der in Abb. 79 unter der horizontalen Trennlinie befindliche Teil
mit Aktionen, die zur Laufzeit des Programms (oder bei der Entwicklung des Prozessors), jedoch nicht
bei der Entwicklung des Programms stattfinden.
Der angesprochene Bereich, der sich von der Mikroarchitektur- bis hin zur Layout-Ebene erstreckt,
beschreibt den Aufbau von Prozessoren.
Die Mikroarchitektur-Ebene abstrahiert dabei die darunter liegenden Schichten durch logische Baueinheiten, welche die als Nullen und Einsen codierten Programme interpretieren und ausführen.
Nachfolgende Darstellung zeigt die Mikroarchitektur des MMIX-Prozessors, mit dem wir uns im Laufe
der Vorlesung beschäftigen werden.
1-68
Ergebnisauswahl
BZ übernehmen
4
64
24..31
Steuerung
ALU-Funktion
Add
64
Registerblock
64
64
64
BZ
16..23
BefehlsSpeicher
Daten
32
8..15
Schreiben/ LeseLesen $X Daten $X
Lesen $Y
DatenSpeicher
8
SchreibDaten $X
LeseDaten $Y
64
SchreibDaten
64
64
ALU
0..7
LeseLesen $Z
Daten $Z
LeseDaten
Adr.
64
0
1
Adresse
64
64
Abb. 85: Einfacher MMIX-Datenpfad
Die einzelnen Elemente dieses sog. Datenpfads sowie deren Zusammenwirken werden im Laufe der
nächsten Kapitel erklärt werden.
Nachdem wir verstanden haben, wie ein Prozessor (ein Datenpfad) auf Mikroarchitektur-Ebene funktioniert, werden wir die Elemente des Datenpfads genauer untersuchen. Ausgehend von der Funktion
der Elemente werden wir deren Realisierung als Logikschaltung kennenlernen, die sog. Ebene der
digitalen Logik.
Ein Beispiel für die Realisierung eines dieser Elemente als Logikschaltung ist der in nachstehender
Abbildung angegebene Aufbau des Befehlszählers.
D0
Q0
D1
Q1
BZ
D2
Q2
D63
Q63
Abb. 86: Aufbau des Befehlszählers aus Logik-Gattern
1-69
Da Logikgatter immer als Transistorschaltung aufgebaut werden, werden wir im Anschluss auf der
Transistor-Ebene noch die Implementierung einiger Logikgatter mit Transistoren kennenlernen. Um
einen ersten Eindruck davon zu bekommen, ist in der nachfolgenden Abbildung bereits der Aufbau
eines NOR-Gatters in CMOS-Technik gezeigt.
Abb. 87: NOR-Gatter in CMOS-Technik
Nachdem wir den MMIX-Prozessor von der Mikroarchitektur-Ebene bis hin zur Transistor-Ebene kennengelernt haben und uns einen Eindruck davon verschafft haben, wie sich das Funktionsvermögen
eines Prozessors aus Transistoren entwickeln lässt, zeigen wir kurz anhand der sog. Layout-Ebene,
wie Transistoren auf einem Chip integriert werden können.
Eine kleine Vorschau gibt das nachstehende Layout der bereits kennengelernten Implementierung
eines NOR-Gatters:
VDD
Eingang 1
Ausgang
Eingang 2
GND
Abb. 88: Layout eines NOR-Gatters
Wir haben jetzt die Meilensteine der Vorlesung „Computertechnik“ kennengelernt, anhand derer wir
den Aufbau und die Funktionsweise von Prozessoren verstehen werden.
Damit ist es in „Computertechnik“ aber noch nicht getan. Im Kapitel „Performance“ werden wir erfahren, wie man die Leistungsfähigkeit von Prozessoren messen und bewerten kann. Im Anschluss werden wir dieses Wissen anwenden, um in den Kapiteln „Cache“ und „Pipeline“ gängige Verfahren zur
Leistungssteigerung von Prozessoren zu erarbeiten.
Zunächst schließen wir jedoch an die im Fach „Grundlagen der Informatik“ kennengelernte Algorithmus- und Hochsprachen-Ebene an, indem wir die darunter liegende Assembler- und BefehlssatzEbene zunächst allgemein untersuchen.
1-70