PC Games Hardware WISSEN "So funktioniert Ihr Computer" So funktioniert Ihr Computer (Vorschau)

www.pcgameshardware.de • www.pcghx.de

Wissen & Hintergründe • Viele Infografiken •

Illustrationen • Für Einsteiger & Profis

PC Games Hardware Wissen

164

Seiten

Wissen

So funktioniert

Ihr Computer

€ 11,99 01/2013

Österreich 13,50 € | Schweiz sfr 20,00 |

Holland/Belgien/Luxemburg € 13,90

DAS HARDWARE-MAGAZIN FÜR PC-SPIELER

Silencio 352 Silencio 550 Matte Silencio 550 White

Erhältlich bei:

alternate.de | atelco.de | bora-computer.de | caseking.de | gamersware.de | hardwareversand.de | kmcomputer.de

mindfactory.de | snogard.de | telbay.de | x-hardware.de | brack.ch | digitec.ch | steg-electronics.ch | ditech.at | e-tec.at

Editorial

PC Games Hardware Wissen

So funktioniert

Ihr Computer

Früher gab es Computer noch als Bausatz. Bevor IBM den

gleichnamigen PC auf den Markt brachte, war es üblich,

einen Haufen sündhaft teurer Elektronikteile selbst zusammenzubauen.

Familienväter, Studenten und Ingenieure

– oft begleitet vom ebenso neugierigen Nachwuchs

– zogen sich in den Hobbykeller zurück und schraubten

bessere Taschenrechner zusammen, begeistert von der

Technik und den geheimnisvollen Schaltkreisen.

Heute, fast 40 Jahre später, sind PCs natürlich nicht mehr

mit den Plastikkisten von damals zu vergleichen. Geblieben

jedoch ist die Faszination für die Technik: Wie wird

aus Stromimpulsen ein Rechenwerk, das Millionen Berechnungen

in einem Bruchteil einer Sekunde ausführt?

Wie kann eine lose Sammlung von unscheinbaren Chips

atemberaubend echt wirkende 3D-Landschaften auf den

Bildschirm zaubern? Und warum dauert der Rechnerstart

trotz aller Fortschritte immer noch so quälend lange?

Unser erster Band aus der Reihe „PC Games Hardware

Wissen“ nimmt sich dieser und vieler weiterer Fragen

an. Für alle, die ihren PC nicht nur einschalten, sondern

vielmehr an dem Geschehen hinter der Blechwand interessiert

sind, haben wir auf 160 Seiten detaillierte Erklärungen,

Dutzende Infografiken oder einfach nur Wissenswertes

zusammengestellt. Vielleicht bauen Sie ja auch

eines Tages einen Rechner aus Schaltkreisen zusammen

– denn das geht immer noch!*

Christian Gögelein

* Zum Beispiel unter www.mycpu.eu

So funktioniert ein PC 3

Inhalt

37

71

Prozessoren

Startseite .............................................7

Überblick .............................................8

Transistoren, Binärsystem ..................14

ALUs, Adder, FPUs etc.......................16

Pipelining, Branch Prediction etc........20

Caches...............................................24

SMP und SMT....................................27

Befehlssätze und Erweiterungen .......31

Integrierte Grafik................................ 34

Turbomodus...................................... 36

Grafikkarten

Startseite ...........................................37

Überblick .......................................... 38

Direct 3D 11 .......................................42

Texturen............................................. 48

Schatten ........................................... 53

Shader ...............................................56

HDR .................................................. 58

Anti-Aliasing .......................................62

Multi-GPU ......................................... 66

Mainboard

Startseite............................................71

Überblick ...........................................72

BIOS ..................................................78

PCI-Express ...................................... 84

USB .................................................. 88

SATA ................................................. 90

Thunderbolt .......................................92

Infrastruktur

Startseite .......................................... 93

RAM ................................................. 94

Festplatten (HDD) .............................100

Solid State Disks (SSD).....................104

Optische Laufwerke .........................108

Netzteile ........................................... 112

Peripherie

Startseite ......................................... 119

Monitore ...........................................120

Soundausgabe ................................126

Netzwerke ........................................130

WLAN ..............................................133

PowerLAN .......................................137

Mäuse ..............................................138

Tastaturen ........................................140

Windows

Startseite .........................................143

Systemstart .....................................144

Kernel ..............................................150

Dateisystem .....................................153

Treiber ..............................................156

4 So funktioniert ein PC

Inhalt

www.pcgh.de ■ www.pcghx.de

DAS HARDWARE-MAGAZIN FÜR PC-SPIELER

119

112

Ein Unternehmen der Marquard Media International AG

Verleger Jürg Marquard

Verlag

Vorstand

Chefredakteur (V.i.S.d.P.)

Computec Media AG

Dr.-Mack-Straße 83, 90762 Fürth

Telefon: 0911/2872-100

Telefax: 0911/2872-200

redaktion@pcgameshardware.de

www.pcgameshardware.de | www.pcghx.de

Albrecht Hengstenberg (Vorsitzender),

Rainer Rosenbusch, Ingo Griebl

Thilo Bayer (tb), verantwortlich für den redaktionellen Inhalt,

Adresse siehe Verlagsanschrift

Leitende Redakteure Marco Albert (ma)

Redaktion Frank Stöwer (fs), Carsten Spille (cs), Raffael Vötter (rv),

Andreas Link (al), Lars Craemer (lc), Stephan Wilke (sw),

Reinhard Staudacher (rs), Philipp Reuther (pr)

Product Manager Daniel Waadt (dw)

Mitarbeiter dieser Ausgabe Tom Loske (tl), Mark Mantel (mm), Dominik Neugebauer (dn)

Lektorat Claudia Brose (Ltg.), Birgit Bauer, Esther Marsch, Heidi Schmidt

Layout Frank Pfründer (Ltg.), Hans Strobel

Layoutkoordination Albert Kraus

Titelgestaltung Frank Pfründer

Fotografie Heft tb, ma, cs, fs, dw, sw, rv, rs, pr

Bildnachweis Sofern nicht anders angegeben: PC Games Hardware

CD, DVD, Video

COO

Vertrieb, Abonnement

Marketing

Produktion

Chefredakteur Online

Redaktion

Entwicklung

Webdesign

Jürgen Melzer (Ltg.), Alexander Wadenstorfer, Thomas Dziewiszek,

Michael Schraut, Daniel Kunoth, Marcus Winkler (Praktikant),

Dominik Pache (Praktikant)

Hans Ippisch

Werner Spachmüller (Ltg.), Nikolaus Krier

Jeanette Haag

Martin Closmann, Jörg Gleichmar

www.pcgameshardware.de

Thilo Bayer

Andreas Link, Lars Craemer, Marco Albert, Frank Stöwer, Carsten Spille,

Raffael Vötter, Stephan Wilke, Reinhard Staudacher, Philipp Reuther

Markus Wollny (Ltg.), René Giering, Aykut Arik, Tobias Hartlehnert

Tony von Biedenfeld, Emanuel Popa

Anzeigen

CMS Media Services GmbH, Dr.-Mack-Straße 83, 90762 Fürth

Anzeigenleiter

Gunnar Obermeier

verantwortlich für den Anzeigenteil, Adresse siehe Verlagsanschrift

Anzeigenberatung Print

Anne Müller: Tel.: +49 911 2872-251; anne.mueller@computec.de

Alto Mair: Tel.: +49 911 2872-144; alto.mair@computec.de

René Behme: Tel.: +49 911 2872-152; rene.behme@computec.de

Bernhard Nusser: Tel.: +49 911 2872-254; bernhard.nusser@computec.de

93

Anzeigenberatung Online Stöer Digital Media GmbH, Stresemannstraße 29, 22789 Hamburg

Telefon: Tel.: +49 40 46 85 67-0, Fax: +49 40 46 85 67-39

E-Mail: info@stroeerdigitalmedia.de

Anzeigendisposition anzeigen@computec.de

Datenübertragung via E-Mail: anzeigen@computec.de

Es gelten die Mediadaten Nr. 26 vom 01.01.2013.

PC Games Hardware wird in den AWA- und ACTA-Studien geführt. Ermittelte Reichweite: 351.000 Leser

Abonnement – http://abo.pcgameshardware.de

Die Abwicklung (Rechnungsstellung, Zahlungsabwicklung und Versand)

erfolgt über unser Partnerunternehmen DPV Direct GmbH:

Post-Adresse:

Leserservice Computec, 20080 Hamburg, Deutschland

Ansprechpartner für Reklamationen ist Ihr Computec-Team unter:

Deutschland

E-Mail: computec@dpv.de, Tel.: 0911-99399098, Fax: 01805-8618002*

Support: Montag 07:00–20:00 Uhr, Dienstag–Freitag 07:30–20:00 Uhr, Samstag 09:00–14:00 Uhr

* (0,14 €/Min. aus dem dt. Festnetz, max. 0,42 €/Min. aus dem dt. Mobilfunk)

Österreich, Schweiz und weitere Länder:

E-Mail: computec@dpv.de, Tel: +49-911-99399098, Fax: +49-1805-8618002

Support: Montag 07:00–20:00 Uhr, Dienstag–Freitag 07:30–20:00 Uhr, Samstag 09:00–14:00 Uhr

Abonnementpreis für 12 Ausgaben: Magazin € 47,88 (€ 51,60 Österreich, € 59,88 Ausland),

DVD € 60,- (€ 67,20 Österreich, € 72,- Ausland)

Einzelversand/Nachbestellung

Online: www.pcgh.de/go/shop, E-Mail: computec@dpv.de, Tel.: 0911-99399098 , Fax: 01805-8618002*

* (0,14 €/Min. aus dem dt. Festnetz, max. 0,42 €/Min. aus dem dt. Mobilfunk)

ISSN/Vertriebskennzeichen PC Games Hardware: 1616-6922 / B 53384

Vertrieb: DPV Deutscher Pressevertrieb GmbH, Düsternstr. 1-3, 20355 Hamburg, Internet: www.dpv.de

Druck: RR Donnelley Europe, ul. Obroncow Modlina 11, 30-733 Krakau, Polen

COMPUTEC MEDIA ist nicht verantwortlich für die inhaltliche Richtigkeit der Anzeigen und übernimmt keinerlei Verantwortung für in

Anzeigen dargestellte Produkte und Dienstleistungen. Die Veröffentlichung von Anzeigen setzt nicht die Billigung der angebotenen

Produkte und Service-Leistungen durch COMPUTEC MEDIA voraus. Sollten Sie Beschwerden zu einem unserer Anzeigenkunden,

seinen Produkten oder Dienstleistungen haben, möchten wir Sie bitten, uns dies schriftlich mitzuteilen. Schreiben Sie unter Angabe

des Magazins, in dem die Anzeige erschienen ist, inkl. der Ausgabe und der Seitennummer an: CMS Media Services GmbH, Franziska

Schmidt, Anschrift siehe oben.

Einsendungen Manuskripte und Programme:

Mit der Einsendung von Manuskripten jeder Art gibt der Verfasser die Zustimmung zur Veröffentlichung in den von der Verlagsgruppe

herausgegebenen Publikationen. Urheberrecht: Alle in PCGH veröffentlichten Beiträge bzw. Datenträger sind urheberrechtlich

geschützt. Jegliche Reproduktion oder Nutzung bedarf der vorherigen, ausdrücklichen und schriftlichen Genehmigung des Verlags.

Marquard Media

Deutschsprachige Titel

SFT, WIDESCREEN, PC GAMES, PC Games MMORE, PC GAMES HARDWARE, BUFFED,

X3, PLAY 3, GAMES & MORE, GAMES AKTUELL, N-ZONE, XBG GAMES, PLAY BLU

Polen

COSMOPOLITAN, JOY, SHAPE, HOT, PLAYBOY, CKM, VOYAGE

Ungarn

JOY, SHAPE, ÉVA, IN STYLE, PLAYBOY, CKM


dAS Kult-MAgAzIN füR gAMeR

KompleTT inTeraKTiv

KompleTT in DeuTsCh

nur für apple ipaD

eDGe is the trademark of future publishing limited, a future plc group company,

uK 2013. used under licence. all rights reserved.

edge de #259 – NOveMbeR 2013

Tom ClanCys The Division

Killer-app für XboX one

Jetzt IM APP StORe

MIt gRAtIS-leSePRObe!

Bild: Sven Döring/AMD

Prozessoren


Prozessor

Bild: Intel

Prozessoren mit Dutzenden Kernen lassen sich zwar realisieren (wie

hier im Bild beim Polaris-Prototyp), die Kerne selbst enthalten aber nur

einen Bruchteil der Funktionen vergleichbarer aktueller CPUs.

So funktioniert

ein Prozessor

Seit den Anfängen in den

70er-Jahren faszinieren

Prozessoren nicht nur

technikinteressierte Anwender

– in aktuellen Modellen

erreichen hunderte Millionen

von kleinsten elektrischen

Schaltern eine Rechenleistung,

die vor zwei Jahrzehnten den

schnellsten Supercomputern

vorbehalten war. Wie aus den

Schaltern eine komplexe Rechenmaschine

wird, zeigen die

folgenden Seiten; zunächst jedoch

ein kurzer Überblick der

Funktionsgruppen.

Prozessoraufbau

Ein aktueller Prozessor besteht

aus mehreren Baugruppen,

die unterschiedlich viel Platz

einnehmen. Die eigentlichen

Rechenwerke belegen oft nur

einen Bruchteil der Chipfläche.

Der restliche Platz wird für verschiedene

Funktionen benötigt,

das Gros des Transistor budgets

geht dabei für Cache-Speicher

drauf. Grundsätzlich verfügen

Prozessoren über:

z Den eigentlichen CPU-Kern

mit den Recheneinheiten

z Gegebenenfalls einen

Grafikkern

z Zwischenspeicher (L1, L2, L3)

z Ein- und Ausgabeeinheiten

z Einen Speichercontroller

(inkl. diverser North bridge-

Funktionen)

CPU intern

Die Recheneinheiten eines

Prozessors sind relativ einfach

gestrickt und funktionieren

grundsätzlich immer noch so

wie zu den Anfangszeiten der

Computergeschichte. Durch bestimmte

Verschaltungsmuster

können elementare Operationen

wie eine Addition durchgeführt

werden. Durch Kopplung

mehrerer dieser Einheiten lassen

sich auch Multiplikationen,

Divisionen und viele weitere

arithmetische Operationen umsetzen.

Befehlsverarbeitung

Das Prinzip der Befehlsverarbeitung

hat sich ebenfalls nicht

geändert: Ein Befehl wird zunächst

vom Prozessor geholt,

dann dekodiert und ausgeführt.

Schließlich wird das Ergebnis

zurückgeschrieben. Gleichwohl

hat sich die Geschwindigkeit

der Abarbeitung in den vergangenen

Jahrzehnten natürlich

drastisch erhöht.

Doch was ist eigentlich ein „Befehl“?

Mit dem ersten x86-Prozessor

führte Intel den gleichnamigen

x86-Befehlssatz ein.

Darin waren (und sind bis

heute) 80 Instruktio nen enthalten,

die hauptsächlich für

die Berechnung von mathematischen

Aufgaben, aber auch

für die Manipulation von Zeichenketten

oder Sprüngen im

Code verwendet werden. Einfache

Instruktionen heißen zum

Beispiel ADD (Addition), MOV

(Move, zum Bewegen von Daten

in Speicher bzw. Register)

oder CMP (Compare, vergleicht

Operanden).

Arbeitsschritte

Befehle lagen früher in Form

von Lochkarten vor, sind heute

aber in der Regel im Arbeitsspeicher

oder auf Festspeichern

wie einer Festplatte vorhanden.

Weil aber selbst der Arbeitsspeicher

noch bis zu 1.000-mal


Prozessor

langsamer ist, als die CPU intern

rechnen kann, setzen die

Entwickler auf chipinterne Zwischenspeicher,

die häufig benötigte

Daten „cachen“. Damit

wird das zeitraubende Laden

von Daten aus dem Arbeitsspeicher

nicht immer, aber relativ

häufig vermieden.

Die Befehlsdekodierung läuft je

nach Prozessor unterschiedlich

ab. Grundsätzlich wird dabei

ermittelt, welche Operation

durchgeführt werden soll (Addition,

Division, Sprung etc.).

Zusätzlich werden die Speicheradressen

festgelegt, in denen

sich die zu verarbeitenden Daten

befinden. Intel und AMD

zerlegen die standardisierten

x86-Operationen dabei zusätzlich

in kleinere, maschinengerechtere

Befehlsgruppen.

Micro- und

Makro-Ops

Intel nennt diese Gruppen Mikro-Instruktionen

(„Micro-Ops“),

bei AMD heißen sie Makro-Instruktionen

(„Makro-Ops“). Seit

Einführung der schlanken Instruktionen

mit dem Pentium

Pro gelten x86-CPUs auch als

RISC-Prozessoren. RISC-CPUs

verfügen über einen reduzierten

Befehlssatz („Reduced Instruction

Set Computer“), sind

dabei aber deutlich schneller

als solche mit einem komplexen

Befehlssatz („Complex Instruction

Set Computer“, „CISC“)

Sind alle Daten vorhanden, wird

der Befehl ausgeführt. Die Operanden

werden von einer Ausführungseinheit

(Arithmetic

Logic Unit, kurz: ALU) verarbeitet;

aus zwei Operanden wird

so zum Beispiel die Summe

gebildet. Schließlich wird das

Ergebnis in den (Cache-)Speicher

zurückgeschrieben. Der

Befehlszähler („Program Counter“)

wird erhöht und die Befehlsverarbeitung

wird mit der

nächsten Operation fortgesetzt

– so lange, bis das Programm

beendet ist.

Rechenwerke

Die Rechenwerke eines Prozessors

sind primär für Operationen

mit Ganzzahlen ausgelegt.

Viele Anwendungen,

darunter besonders Spiele,

haben aber einen hohen Anteil

an Berechnungen mit Kommazahlen

(Fließpunktoperationen).

Schon früh konstruierten

die Chip-Ingenieure spezielle

Fließpunkt-Einheiten. Anfangs

steckten diese noch in eigenen

Gehäusen und mussten über

das Mainboard mit dem Prozessor

verbunden werden. Seit der

486-Generation sind die Fließpunkteinheiten

Teil des Hauptprozessors.

Bald stieß auch die Fließpunkteinheit

an ihre Grenzen. Intel

führte mit dem Pentium III erstmals

eine SSE-Einheit ein. Diese

Einheit ist deshalb besonders

interessant, weil sie auf einen

eigenen Registersatz zurückgreift,

der viermal breiter ist

als bei einem 32-Bit-Prozessor.

So wird es möglich, mit einer

Instruktion mehrere Daten zu

verarbeiten, was bei einigen

Aufgaben deutliche Leistungsgewinne

bringt. Soll zum Beispiel

die Helligkeit eines Bildes

erhöht werden, kann eine Instruktion

(eine Addition auf den

Farbwert der RGB-Kanäle) auf

verschiedene Daten (die Pixel

des Bildes) angewendet werden

– mit nahezu vierfacher Geschwindigkeit.

Cache-Hierarchie

Während seiner Arbeit muss

der Prozessor ständig auf den

Mit Intels 486 hielten Fließpunkteinheiten Einzug in die Prozessor-Architektur.

Dies verhalf auch (3D-)Spielen zum Durchbruch.

Intels Pentium Pro brachte eine Reihe neuer Funktionen, unter anderem

die Befehlszerlegung in Micro-Ops

Noch relativ leicht zu überblicken war ein 8088-Prozessor mit knapp

29.000 Transistoren. Mit jeder neuen Generation kamen danach neue

Funktionen und Techniken hinzu

Bild: Intel

Bild: Intel

Bild: Intel


Prozessor

Prozessor-Trends:

Was bringt die Zukunft?

Die Prozessorentwicklung wird in mehrfacher Hinsicht gebremst.

Einerseits stoßen CPUs an ein Taktlimit, das bei knapp 4 Gigahertz

liegt. Seit knapp zehn Jahren hat kein Prozessor die Schwelle von 3,8

GHz überschritten. Andererseits kann auch die Zahl der CPU-Kerne

nicht beliebig gesteigert werden – jedenfalls nicht, wenn „normale“

CPU-Kerne verwendet werden. AMD und Intel werden künftig vermutlich

auf abgespeckte Kerne setzen, welche die vollwertigen Kerne bei

speziellen Rechenaufgaben unterstützen. Intel spricht konkret bereits

von Kryptographie-Kernen, welche die Verschlüsselung drastisch beschleunigen

sollen. Integrierte Grafikkerne sind bereits Realität.

Bild: Digital Revolution

Die niedrigen Spannungen aktueller Prozessoren benötigen aufwendige

Spannungswandler auf Mainboards. Aktuelle CPUs verwenden intern

sogar mehrere Spannungen.

Arbeitsspeicher (RAM) zugreifen.

Dieser ist zwar sehr preiswert,

aber im Vergleich zum

Prozessor sehr langsam.

Eine ausgefeilte Cache-Hierarchie

sorgt daher bei Prozessoren

für eine deutlich reduzierte

Anzahl von Speicheranfragen.

Der schnellste und leistungsfähige

Cache stellt Daten in der

Regel innerhalb von drei bis

vier Taktzyklen bereit. Er heißt

Level-1(L1)-Cache und wird nur

sparsam eingesetzt. Aktuelle

Prozessoren verfügen pro Kern

über 64 bis 128 Kilobyte L1-

Cache, der in einen Daten- und

einen Befehlscache unterteilt

ist.

An zweiter Stelle steht der L2-

Cache, der üblicherweise 256

bis 512 Kilobyte groß ist. Er ist

mit circa zehn bis 20 Taktzyklen

langsamer als der L1-Cache.

Schließlich steht ein gemeinsamer

Level-3-Cache für alle Kerne

zur Verfügung. Er ist meist

sechs bis acht Megabyte groß

und mit 40 bis 100 Taktzyklen

deutlich langsamer.

Im Gegensatz zum DRAM-Arbeitsspeicher

ist Cache-Speicher

aus SRAM-Zellen zusammengesetzt.

Diese bestehen aus

vier bis sechs Transistoren und

benötigen mehr Die-Fläche als

DRAM; dafür können Informationen

dauerhaft gespeichert

werden und müssen nicht in

festen Intervallen sogenannte

Refresh-Zyklen durchlaufen.

Pipelining und OoO

Die immer größer werdenden

Caches haben die Verarbeitung

von Daten zwar stark beschleunigt.

Sie können aber nicht verhindern,

dass manche Daten

immer noch aus dem Speicher

oder – noch schlimmer – von

der Festplatte geholt werden

müssen. Um die Recheneinheiten

besser auszulasten, verfügen

alle modernen x86-Prozessoren

seit dem Pentium über

„Pipelines“; gemeint ist damit,

dass mehrere Befehle parallel

abgearbeitet werden. Während

ein Befehl ausgeführt wird,

wird ein weiterer schon dekodiert

und ein dritter geholt.

Pipelining bringt vor allem

dann Vorteile, wenn die Befehle

unabhängig voneinander

ausgeführt werden können;

dies ist jedoch nur selten der

Fall. Viel häufiger kommt es vor,

dass ein Befehl auf das Ergebnis

einer anderen Operation

warten muss. Um die „Wartezeit“

sinnvoll zu nutzen, haben

AMD und Intel eine sogenannte

„Out-of-Order“(OoO)-Execution

ersonnen. Damit lassen sich

Befehle spekulativ ausführen,

was im Erfolgsfall einige Taktzyklen

spart (siehe Kasten im entsprechenden

Abschnitt).

Kommunikationswege

Ein Prozessor alleine könnte

wenig ausrichten. Mindestens

ebenso wichtig ist die Anbindung

an den Rest des Systems.

Während der Anwender beispielsweise

ein Spiel spielt, werden

in einer zentralen Schleife

permanent wichtige Parameter

wie Maus- und Tastatureingaben

abgefragt, Daten aus dem

Speicher geholt, verarbeitet, an

die Grafikkarte gesendet oder

zurückgeschrieben und viele

weitere Aufgaben erledigt. Bis

vor einigen Jahren wurde für

den kompletten Datenverkehr

von und zum Prozessor ein eigener

Bus verwendet, der „Front

Side Bus“. Diese Verbindung

wurde jedoch immer mehr zum

Flaschenhals und daher erst


Prozessor

von AMD, später auch von Intel

durch eine schnellere Punktzu-Punkt-Verbindung

ersetzt.

Die Speichermodule werden

zusätzlich von einem speziellen

On-Die-Controller angesprochen,

was die Wartezeit weiter

verkürzt hat.

Stromversorgung und

Leistungsaufnahme

Früher liefen Prozessoren noch

mit der einheitlichen I/O-Spannung

des Mainboards (5 bzw.

3,3 Volt). Aufgrund der stetig

steigenden Verlustleistung sind

die Hersteller jedoch bemüht,

die CPU-Spannung weiter zu

senken. Als Folge dieser Anstrengungen

laufen heutige Prozessoren

mit Spannungen um

ein Volt, die vom Mainboard eigens

bereitgestellt werden müssen.

Das hat zur Folge, dass die

Mainboard-Hersteller spezielle

Spannungswandler integrieren

müssen, die mittlerweile einen

beachtlichen Teil des Boards in

Anspruch nehmen und darüber

hinaus ordentlich Wärme produzieren.

Die Leistungsaufnahme der

Prozessoren steigt ebenfalls

mit jedem neuen Transistor.

Die Hersteller versuchen, dies

durch Energiesparfunktionen

wie Cool’n’quiet oder EIST

aufzufangen. Dennoch bleibt

das grundsätzliche Problem

bestehen: Bei jedem Transistor-Schaltvorgang

wird Energie

„verbraucht“. Würden alle Transistoren

eines Prozessors zur

gleichen Zeit schalten, würde

der Chip augenblicklich durchbrennen

– selbst mit einer Wasserkühlung.

Auf den folgenden Seiten erfahren

Sie, wie die Funktionsgruppen

eines Prozessors im Detail

funktionieren.

x86-Befehlssatz (Auszug)

Abkürzung

Bedeutung (engl.)

Englisch

AAA

ASCII adjust after addition

AAD

ASCII adjust before divide

AAM

ASCII adjust alter multiply

AAS

ASCII adjust after subtract

Abkürzung

JS

JZ

LAHF

LDS

LEA

ADC

Add with carry

LES

ADD

Add

LOCK

AND

And

LODS

CALL

Call

LODSB

CBW

Convert byte to word

LODSW

CLC

Clear carry flag

LOOP

CLD

Clear direction flag

LOOPE

CLI

Clear interrupt flag

LOOPNE

CMC

Complement carry flag

LOOPNZ

CMP

Compare

LOOPZ

CMPS

Compare string

MOV

CMPSB

Compare string bytewise

MOVS

CMPSW

Compare string wordwise

MOVSB

CWD

Convert word to double word

MOVSW

DAA

Decimal adjust after addition

MUL

DAS

Decimal adjust after subtract

NEG

DEC

Decrement

NOP

DIV

Divide (unsigned)

NOT

ESC

Escape (to external device)

OR

HLT

Halt

OUT

IDIV

Integer divide (signed)

POP

IMUL

Integer multiply (signed)

POPF

IN

Input from

PUSH

INC

Increment

PUSHF

INT

Interrupt

RCL

INTO

Interrupt if overflow

RCR

IRET

Interrupt return

REP

JA

Jump if above

REPE

JAE

Jump if above or equal

REPNE

JB

Jump if below

REPNZ

JBE

Jump if below or equal

REPZ

JCXZ

Jump if CX equal zero

RET

JE

Jump if equal

ROL

JG

Jump if greater

ROR

JGE

Jump if greater or equal

SAHF

JL

Jump if less

SAL

JLE

Jump if less or equal

SAR

JMP

Jump

SBB

JNA

Jump if not above

SCAS

JNAE

Jump if not above and not equal

SCASB

JNB

Jump if not below

SCASW

JNBE

Jump if not below and not equal

SHL

JNE

Jump if not equal

SHR

JNG

Jump if not greater

STC

JNGE

Jump if not greater and not equal

STD

JNL

Jump if not less

STI

JNLE

Jump if not less and not equal

STOS

JNO

Jump if no overflow

STOSB

JNP

Jump if no parity

STOSW

JNS

Jump if no sign

SUB

JNZ

Jump if not zero

TEST

JO

Jump if overflow

WAIT

JP

Jump if parity

XCHG

JPE

Jump if parity even

XLAT

JPO

Jump if parity odd

XOR

Bedeutung (engl.)

Jump if sign

Jump if zero

Load AH with flags

Load pointer using DS

Load effective address to register

Load pointer using ES

Lock Bus

Load string to AL/AX

Load string bytewise to AL

LODSW Load string wordwise to AX

Loop CX times

Loop CX times while equal

Loop CX times while not equal

Loop CX times while not zero

Loop CX times while zero

Move

Move string

Move string bytewise

Move string wordwise

Muliply (unsigned)

Negate

No Operation

Invert

Or

Output to

Pop

Pop flags

Push

Push flags

Rotate through carry left

Rotate through carry right

Repeat CX times

Repeat CX times while equal

Repeat CX times while not equal

Repeat CX times while not zero

Repeat CX times while zero

Return from procedure

Rotate left

Rotate right

Store AH into flags

Shift arithmetic left

Shift arithmetic right

Subtract with borrow

Scan string

Scan string bytewise

Scan string wordwise

Shift logical left

Shift logical right

Set carry flag

Set direction flag

Set Interrupt flag

Store string from AL/AX

Store string bytewise from AL

Store string wordwise from AX

Subtract

Test

Wait for test

Exchange

Translate byte to AL

Exclusive or


Prozessor

Beispiel: Wie ein Prozessor Verarbeitung funktioniert eines Tastendrucks

Vorbereitung

Programme werden normaler -

weise linear abgearbeitet. Ein

spezielles Register, der Program

Counter (PC), hält die Adresse

bereit, an welcher jener Befehl

steht, der als Nächstes bearbeitet

werden soll. Der PC wird nach

jeder Instruktion erhöht, bis das

Programm beendet ist.

1 Befehl analysieren

Der x86-Befehl wird nun dekodiert und in kleinere Instruktionen zerlegt. Diese kleineren Instruktionen haben den Vorteil,

dass sie alle einfach gehalten sind, die gleiche Länge haben und damit schnell ausgeführt werden können. Bei einigen

Prozessoren werden die bereits dekodierten Befehle in einem speziellen Cache gespeichert. Beim Pen tium 4 hieß dieser

„Trace Cache“, Sandy Bridge verfügt über einen ähnlich gestrickten „Micro-Op-Cache“, der annähernd 1.500 dekodierte

Mikro-Instruktionen aufnehmen kann. Bei Intel-Architekturen wird zwischen einfachen und komplexen x86-Befehlen

unterschieden; während für einfache Instruktionen drei Dekoder bereitstehen, gibt es für komplexe Anweisungen nur

einen. Bei der Befehlsdekodierung wird außerdem festgelegt, ob und welche Befehle sich umsortieren lassen. Durch die

„Out-of-Order-Execution“ können die Einheiten der CPU besser ausgelastet werden.

2

Am Anfang unseres Beispiels wird

also der erste (x86-)Befehl geholt,

er soll bereits im Speicher (RAM)

liegen. Dazu wird die entsprechende

Adresse an das RAM gesendet,

wo die entsprechenden Zeilen und

Spalten adressiert werden müssen.

Bis die Daten über den Bus (bzw.

die Punkt-zu-Punkt-Verbindung)

geschickt werden und dort ankommen,

vergehen Dutzende bis

mehrere Hundert CPU-Taktzyklen.

Muss das Programm von der Festplatte

geholt werden, vervielfacht

sich die Wartezeit. Meist werden

gleichzeitig die benachbarten

Speicherzellen mit ausgelesen und

in eine Cacheline des Prozessors

gelegt. Bei der Bearbeitung eines

Programmes liegen die Befehle

normalerweise hintereinander; die

folgenden Befehle sind dann schon

im (Instruktions-)Cache vorhanden

und können wesentlich schneller

bereitgestellt werden.

Ausführung vorbereiten

Der Befehl ist jetzt dekodiert und zerlegt – idealerweise können die Operanden gleich mit an die Ausführungs einheiten

übergeben werden. Ein Befehl der Art „Addiere 20 zu 6“ könnte also sofort verarbeitet werden. In der Regel wird ein

Compiler versuchen, die benötigten Daten im Voraus bereitzustellen. Wenn die Operanden aber von dem Ergebnis einer

vorhergehenden Instruktion abhängig sind, klappt dies nicht. Bis die Daten eintreffen, verharrt der Befehl in diesem Fall

in der „Reservation Station“. Je nachdem, welcher Befehl ausgeführt werden soll, nimmt die Operation nun unterschiedliche

Wege (im Folgenden dargestellt als 4a, 4b und 4c).

Befehl ausführen

Anschließend werden die Ausführungseinheiten für

die Befehlsausführung vorbereitet. Konkret heißt das,

dass die Recheneinheiten (ALUs) für die entsprechende

Operation mit den zugehörigen Registern verschaltet

werden. Je nach Architektur stehen unterschiedlich viele

ALUs für diverse Aufgaben bereit. Üblich sind heute drei

bis sechs ALUs für Ganzzahl- und/oder Speicherzugriffe

sowie drei weitere ALUs für Fließpunktoperationen (diese

heißen dann FPUs). Häufig setzen Chipentwickler auch

hybride Rechenwerke ein; so gibt es dann beispielsweise

mehrere Ausführungseinheiten für einfache Befehle, aber

nur eine Einheit, die komplexe Befehle berechnen kann.

Da komplexe Befehle selten gehäuft vorkommen, resultiert

daraus unterm Strich ein Performance-Plus.

4

4a

4b

4c

Integer-Operation

Im Fall 4a soll eine Ganzzahl verarbeitet werden; eine

einfache Addition kann bei einem Phenom zum Beispiel

von sechs verschiedenen Ausführungseinheiten berechnet

werden.

Fließpunkt-/SSE-Operation

Sollen bei dem Befehl Zahlen mit Nachkommastellen

verarbeitet werden, wird dafür eine Fließpunkteinheit

bemüht. Seit der Nehalem-Architektur gibt es eigene

Rechen werke für Fließpunkt-Additionen, -Multiplikationen

und -Divisionen. Für SSE-Befehle (bzw. MMX/3dnow) sind

ebenfalls spezielle Ausführungseinheiten vorgesehen.

Speicher-Operation

Oft müssen Daten vom und zum Speicher bewegt

werden (siehe Schritt 3); dafür bieten moderne Prozessoren

eigene Einheiten an. Zum Laden und Speichern

gibt es meist drei Einheiten (AGUs).

3

128 Entry ITLB 1

32 KB I-cache (8 way)

Instruction

Fetch Unit

µcode

Sequencer

Port 0

Complex Decoder

4 µops

x86 Instruction Pre-Decoder, Fetch Buffer

Simple

Decoder

128 bits

1 µops

7+ Entry µop Buffer

Simple

Decoder

4 µops

Register Alias Table and Allocator

4 µops

96 Entry Reorder Buffer (ROB)

3

4

2

4 µops

Simple

Decoder

1 µops 1 µops

32 Entry Reservation Station

4 µops

Retirement Register File

(Program Visible State)

Port 1 Port 2 Port 3 Port 4 Port 5

4c

Shared Bus

Interface

Unit

4 MB Shared

L2 Cache

(16 way)

64 Bit

ALU

4a

128 bit

FADD

128 bit

SSE

ALU

Shift Rotate

128 bit

FMUL FDIV

128 bit

SSE

4b

64 bit

ALU Branch

128 bit

SSE

Store

Data

Store Address

Memory Reorder Buffer (MOB)

Load

Address

Internal Results Bus

Symbolische Darstellung: Blockschaltbild bezieht sich auf die Core-Architektur

5

128 bits

6

Store

128 bits

32 KB dual ported D-cache (8 way) 256 Entry DTLB

Load

256 bits


Prozessor

Ergebnis schreiben

Schließlich liegt das Resultat der Operation vor; es wird aber nicht direkt in

den Cache geschrieben, sondern normalerweise in die „Reservation Station“

geschickt. Dort steht das Ergebnis unmittelbar für nachfolgende Instruktionen zur

Verfügung, was die Ausführungszeit verkürzt.

Andere Befehle dagegen sorgen dafür, dass weitere Operanden geladen werden

und wieder andere können den Program Counter direkt verstellen – was dann als

„Sprung“ bezeichnet wird.

Die Ergebnisse der Speicher-Einheiten (AGU) gehen in einen speziellen Puffer,

den Memory Reorder Buffer (MOB). Dort können die Zugriffe umsortiert werden.

Das ist sinnvoll, weil damit schnelle Lesezugriffe den langsamen Schreibzugriffen

vorgezogen werden können.

5 Speicher aktualisieren

6

Hat die Rechenoperation ein Ergebnis zur Folge, so wird

dieses schließlich in den Cache und/oder den Speicher

geschrieben. Bei einigen BIOS-Versionen kann man

das sogar steuern. „Write Back“ bedeutet dabei, dass

der Wert nur in den Cache geschrieben wird. Mit „Write

Through“ werden Cache und Speicher gleichermaßen

aktualisiert, was etwas mehr Zeit kostet.

Generell sind Schreibzugriffe weniger performancekritisch

als Lesezugriffe. Diverse Puffer und Algorithmen

sorgen dafür, dass die aktualisierten Daten ge bündelt

und am Stück in den Speicher geschrieben

werden.


Prozessor

Bild: Intel Bild: Intel

Prozessoren bestehen mittlerweile aus mehr als einer Milliarde Transistoren.

Intels erster Mikroprozessor, der 4004, vereinte gerade mal 2.300

elektrische Schalter.

Das Grundprinzip

eines Prozessors

Ein Transistor

unter dem

Mikroskop: In

der Mitte ist das

Metall (schwarz)

zu erkennen.

Wenn hier Strom

anliegt, können

Elektronen

von der Quelle

zum Ziel fließen

(schwarz, links

und rechts am

Rand)

Auch modernste Prozessoren

verarbeiten Befehle

immer noch nach

jenem Prinzip, welches der in

Ungarn geborene Mathematiker

John von Neumann bereits

im Jahre 1945 konzipierte.

Elementarer Aufbau

Sein früher Rechner bestand

aus den Funktionseinheiten

Steuerwerk, Rechenwerk, Speicher,

Eingabe- und Ausgabewerk,

wobei mit Ein- und Ausgabe

hier nicht Tastatur und

Bildschirm gemeint sind, sondern

die Schnittstellen außerhalb

der zentralen Recheneinheit,

also des Prozessors.

Zur Lösung eines Problems

muss von außen eine Bearbeitungsvorschrift,

das Programm,

eingegeben und im Speicher

abgelegt werden. Ohne dieses

Programm ist die Maschine

nicht arbeitsfähig. Programme,

Daten, Zwischen- und Endergebnisse

werden in demselben

Speicher abgelegt.

Der Speicher ist in gleich große

Zellen unterteilt, die fortlaufend

durchnummeriert sind.

Über die Nummer (Adresse)

einer Speicherzelle kann deren

Inhalt abgerufen oder verändert

werden. Aufeinanderfolgende

Befehle eines Programms werden

in aufeinanderfolgenden

Speicherzellen abgelegt. Das

Ansprechen des nächsten Befehls

geschieht vom Steuerwerk

aus durch Erhöhen der Befehlsadresse

um Eins.

Von-Neumann-Zyklus

Der Prozess der Befehlsverarbeitung

bei Von-Neumann-Rechnern

wird Von-Neumann-Zyklus

genannt und besteht aus folgenden

fünf nacheinander ablaufenden

Teilschritten: FETCH,

DECODE, FETCH OPERANDS,

EXECUTE, UPDATE INSTRUC-

TION POINTER.

Das grundlegende Prinzip dieser

Befehlsverarbeitung ist bis

heute unverändert geblieben,

der Einfachheit halber wird es

in CPU-Schaubildern manchmal

auf die drei Phasen Fetch

(engl.: „holen“), Decode

(engl.: „entschlüsseln“) und

Execute (eng.: „ausführen“)

reduziert.

Befehlsverarbeitung

im Detail

Beim FETCH-Schritt wird aus

RAM- oder ROM-Speicher der

nächste zu bearbeitende Befehl

geholt. Dieser Befehl wird bei

DECODE durch das Steuerwerk

in Schaltinstruktionen aufgelöst,

die das Rechenwerk „verstehen“

kann. Aus RAM oder ROM werden

nun bei FETCH OPERANDS

die Operanden geholt, also die

Werte, die durch den Befehl verändert

werden sollen bzw. die

als Parameter verwendet werden,

also etwa die beiden Operanden

einer Addition.

Bei EXECUTE wird die Operation

vom Rechenwerk ausgeführt.

Bei UPDATE INST-

RUCTION POINTER wird der

Befehlszähler erhöht, damit der

Rechner „weiß“, an welcher

Stelle des Programms er sich gerade

befindet. Das geschieht parallel

zum DECODE und FETCH

OPERANDS. Beim EXECUTE

kann der Befehlszähler wieder

verändert werden (Sprungbefehl).


Prozessor

Anschließend kann der Zyklus

von vorn beginnen und der

nächste Schritt des Programms

ausgeführt werden.

Schalter und

Transistoren

Prozessoren arbeiten mit

Strom, respektive mit elektrischen

Schaltern, Transistoren

genannt. Der Transistoreffekt

wurde 1947 durch William

Shockley, John Bardeen und

Walter Brattain in den Bell Laboratories

von der Firma AT&T

entdeckt. Später erhielten sie

dafür den Nobelpreis für Physik.

Durch einen kleinen Steuerstrom

kann in einem Transistor

ein wesentlich größerer Strom

gesteuert werden.

Der Transistor wurde auf der

Grundlage der Diode entwickelt.

Eine Diode besteht aus

zwei dotierten Halbleiterschichten

(NP- beziehungsweise

PN-dotiert) und lässt

Strom nur in einer Richtung

durchfließen. Ein Transistor ist

im Wesentlichen eine Zusammenschaltung

aus drei Diodenhälften

(NPN beziehungsweise

PNP), wobei die obere und

untere Schicht als Kollektor

beziehungsweise Emitter und

die mittlere Schicht als Basis

bezeichnet werden (siehe Bild).

Bipolartransistor

Beim Bipolartransistor steuert

ein Strom IB im Basis-Emitter-Kreis

einen (stärkeren)

Strom IC im Kollektor-Emitter-Kreis.

Der Vorteil dieser

stark miniaturisierten Schalter:

Es passen Tausende, ja Millionen

davon auf einen einzigen

Chip. Die Kombination aus diesen

Millionen von Transistoren

erlaubt die Darstellung von unzähligen

Funktionen, die wiederum

in ihrer Kombination den

Befehlssatz eines Prozessors

ausmachen.

Das Dual-System

Nein, das hat nichts mit Restmüll-Recycling

zu tun. Das Dual-System

beschreibt ein Stellenwertsystem

zur Darstellung von

Zahlen auf der Basis 2. Warum

ausgerechnet die 2? Wenn eine

Informationseinheit nur zwei

Zustände (Ein/Aus) annehmen

kann, dann kann man Zahlen

natürlich nicht im Dezimalsystem

(Basis 10) darstellen, wie

wir es normalerweise tun. Man

muss sich auf das Dual-System

beschränken. Während bei

unserem Dezimalsystem zehn

Zahlen (0 bis 9) möglich sind,

ehe wir eine zusätzliche Stelle

benötigen (10), sind es bei Dualzahlen

nur zwei. Zählen würden

wir demnach so: 0, 1, 10,

11, 100, 101, 110 usw., wobei die

Dualzahl 10 im Dezimalsystem

der 3 entspricht, die duale 11

der 4 usw. Es ändert sich also

nichts an den Zahlen, sondern

nur an der Schreib weise.

Mit diesen Dualzahlen im binären

Code (daher auch Binärzahlen

oder Zahlen im Binärcode

genannt) kann eine

aus Schaltungen bestehende

Maschine nun arbeiten. Man

muss nur festlegen, dass eine

Eins dem Zustand „Strom fließt“

bzw. „Spannung angelegt“ entspricht,

eine Null dem Zustand

„Strom fließt nicht“ bzw. „Keine

Spannung angelegt“. Der Übersicht

halber benötigt man noch

eine feste Größe, um bei einer

Zahlenfolge von 1110 erkennen

zu können, ob eine 1 und

eine 110 (also eine dezimale

1 und eine 6) oder eine 1110

(entspricht dezimaler 14) dargestellt

werden soll. Dazu muss

man sich zuvor auf die Bitlänge

einigen.

Wie ein Transistor

Strom leitet

Transistoren funktionieren wie Schalter: Liegt ein schwacher Strom

an (Mitte, blau), kann ein stärkerer Strom von der Quelle zur Ableitung

fließen (unten, gelb).

Wie ein Transistor

aufgebaut ist

Dotierung bedeutet zunächst nichts weiter als eine strukturelle Änderung

der Materialbeschaffenheit. Klingt zwar kompliziert, ist jedoch

sehr einfach. Unterschieden wird zwischen p- und n-Dotierung eines

Materials. N-dotiert bedeutet, dass zusätzliche negative Ladungsträger

(beispielsweise Elektronen) in das Material eingefügt wurden und

es somit über eine negative Ladung verfügt. P-dotiert kann zweierlei

bedeuten: Entweder es wurden zusätzliche positive Ladungsträger in

das Material eingefügt oder dem Material wurden Elektronen entzogen,

wodurch sogenannte Löcher entstehen.

Kommen eine p- und eine n-dotierte Schicht zusammen, dann wandern

die Elektronen aus der n- in die p-dotierte Schicht – ein Strom

fließt. Um dies zu verhindern, wird eine sogenannte Sperrschicht zwischen

die beiden unterschiedlich geladenen Schichten eingefügt, die

als Isolator fungiert. Somit fließt kein – oder kein messbarer – Strom.

Das Prinzip eines Transistors basiert auf der vorläufigen Deaktivierung

dieser Sperrschicht, sodass ein Stromfluss möglich ist (Schaltzustand

1), oder die Sperrschicht isoliert (Schaltzustand 0). Da hierfür lediglich

eine geringfügige Änderung in der Steuerspannung beziehungsweise

im Steuerstrom nötig ist, ermöglicht dies eine sehr hohe Schaltgeschwindigkeit

und somit eine sehr hohe Taktfrequenz.

Die Bezeichnung npn-dotiert oder pnp-dotiert bezeichnet übrigens

lediglich die Reihenfolge der dotierten Schichten. Ist ein Transistor aus

n-dotiertem Material, Sperrschicht, p-dotiertem Material, Sperrschicht

und n-dotiertem Material zusammengesetzt, dann spricht man von einem

npn-dotierten Halbleiter und umgekehrt.

Illustration: Carola Giese


Prozessor

So funktionieren Adder,

ALUs, FPUs und Register

Die Komponenten eines

Von-Neumann-Rechners

Das Grundprinzip eines Universalrechners nach von Neumann: Prinzipiell

arbeiten auch aktuelle CPUs noch nach diesen Vorgaben.

Wie ein Halbadder

die Summe berechnet

Halbadder: Das schematische Schaltbild zeigt die im Fließtext beschriebenen

Operanden A, B, S und C sowie die logischen Operatoren

XOR und UND.

A

B

Rechenwerk

Ein- und Ausgabe-System

Zentraleinheit

Verbindungseinrichtungen

S

C

Steuerarbeit

Speicher

A B C S

0 0 0 0

0 1 0 1

1 0 0 1

1 1 1 0

Der kleinste Datentyp,

den ein PC kennt, ist

das Byte, eine Zahl

bestehend aus acht Bit, also

acht Stellen. Das Byte wird

rechtsbündig geschrieben

und linksseitig mit Nullen aufgefüllt.

Beim Zählen 1, 2, 3,

… würde man also so schreiben:

00000001, 00000010,

00000011, ….

Der Halbadder

Mit dieser binären Schreibweise

kann man zwar Informationen

und Zahlen binär

speichern. Doch wie wird

ein ganzer Rechner daraus?

Dazu benötigt man getreu der

Von-Neumann-Architektur zusätzlich

ein Rechenwerk. Dieses

enthält eine oder mehrere ALUs

(Arithmetic Logic Unit), welche

die Berechnungen ausführen

und „Entscheidungen treffen“

können. Dazu wiederum sind

viele Teilschaltungen wie Vergleicher,

Halbadder, Volladder

usw. notwendig.

Um zu zeigen, wie man überhaupt

binär rechnen kann,

möchten wir beispielhaft die

Schaltung eines Halbadders erklären.

Ein Halbadder ist eine

elektrische Schaltung, die aus

zwei Ein-Bit-Ausgangswerten A

und B ein Zwei-Bit-Ergebnis produziert,

das aus einer Summe S

und einem Carry-Bit („Übertrag“)

C besteht. Der Aufbau ist

im Schaubild links dargestellt.

Die benötigten Funktionen (im

Fachjargon „Gatter“ genannt“)

sind: XOR („exklusives ODER“)

sowie AND („UND“). Ein XOR

liefert immer dann eine 1 als

Ergebnis, wenn A und B voneinander

differieren. Ansonsten

liefert XOR eine 0. Die

UND-Funktion dagegen liefert

immer dann eine 1 als Ergebnis,

wenn A und B mit 1 belegt sind.

Ansonsten liefert UND eine 0.

Neben diesen beiden Funktionen

gibt es noch das ODER.

Hier wird eine Eins als Ergebnis

geschrieben, wenn eine der

beiden Ausgangszahlen an der

Stelle eine Eins hatte. Bei einer

NICHT-Funktion dagegen wird

die Zahl einfach invertiert, also

überall, wo eine Null stand,

wird eine Eins geschrieben und

umgekehrt.

Wie die Summe berechnet

wird

Wir haben zwei Zahlen A und B,

eine Summe S und einen Übertrag

C. Beschränken wir uns auf

die Berechnung der Summe S.

Die Formel für die Schaltung

des Halbadders lautet: S = A XOR

B. Im Bild links sehen wir den

schematischen Schaltplan eines

Halbadders. Steht zum Beispiel

in Zelle A eine 1 und in B

eine 0, kann man mit logischen

Operatoren wie folgt rechnen.

Verknüpfen wir „A XOR B“, so

erhalten wir als Ergebnis eine 1.

Das XOR bedeutet also, dass in

dem Moment eine 1 als Ergebnis

geliefert wird, wenn einer

der beiden Operanden eine 1

als Wert hatte (aber nicht beide).

Verknüpfen wir dagegen mit

UND, so erhalten wir nur dann

eine 1, wenn beide Zahlen die

1 als Wert trugen. Der Operator

NICHT dagegen ist nur auf

einen Operanden anwendbar.

Er macht nichts anderes, als die


Prozessor

Zahl zu invertieren. War zuvor

eine 1 an der Stelle, erhalten

wir als Ergebnis eine 0 und umgekehrt.

Aus nichts anderem als

diesen logischen Verknüpfungen

ist ein Halbadder aufgebaut.

Natürlich funktioniert das Ganze

auch mit komplizierteren

Zahlen. „NICHT 0111“ würde

zum Beispiel als Ergebnis

„1000“ liefern. Eine ODER-Verknüpfung

zwischen „1001“

und „1010“ würde als Ergebnis

„1011“ ausspucken, während

ein XOR als Ergebnis „0011“ hätte.

Dieselben beiden Zahlen mit

UND statt mit ODER verknüpft,

hätte „1000“ als Ergebnis.

Rechenwerke

Wie man sieht, kann man mit

simplen logischen Funktionen

binäre Zahlen manipulieren

oder mathe matische Berechnungen

durchführen – wenngleich

dahinter eine ganze

Wissenschaft steckt. Mit der

richtigen Abfolge an Schritten

ist ein simpler Prozessor bereits

in der Lage, Zahlen zu addieren.

Ein paar dieser Einheiten miteinander

kombiniert – und man

kann subtrahieren, multiplizieren

oder Ganzzahlen dividieren.

Gatter und Flip-Flops

Neben den Gattern gibt es

weitere aus Transistoren aufgebaute

Schaltungen, die für

den Betrieb eines Rechenwerks

wichtig sind. An vorderster

Stelle steht das sogenannte Flip-

Flop, welches einen Zustand

(1 oder 0) über einen längeren

Zeitraum speichern kann. In

der einfachsten Ausführung, einem

ungetakteten RS-Flip-Flop,

werden zwei NAND-Gatter

(engl. für „Nicht-Und“-Gatter)

kombiniert, die zwei Eingänge

R und S schalten zwei Ausgänge

Q und ¬Q (siehe Grafik auf der

rechten Seite).

Register

Aus Flipflops bestehen auch die

prozessorinternen Speicher,

die sogenannten Register. Diese

beseitigen einen der vielen

Flaschenhälse in der ursprünglichen

Von-Neumann-Architektur.

Register sind schnelle Zwischenspeicher

direkt im Kern

des Prozessors. Damit stellt

der Prozessor letztlich seine eigentlichen

Berechnungen an.

So müssen die Daten nicht im

quälend langsamen Arbeitsspeicher

miteinander verrechnet

werden.

Registersätze

Ein klassischer x86-PC-Prozessor

verfügt über 14 Register:

acht Universalregister (GPR,

General Purpose Register)

sowie sechs spezialisierte Register,

in denen Zahlen zur

Berechnung abgelegt werden

oder Zeiger auf die Stelle des

Programmcodes gesetzt werden

können, an der sich der

Rechner gerade im Programmablauf

befindet. Ein Prozessor

kann Operationen auf Länge

der Register durchführen. Das

bedeutet, dass ein 32-Bit-Prozessor

Operationen mit 32-Bit-Zahlen

durchführen kann, also

mit Zahlen, die 32 Nullen oder

Einsen enthalten können. Jeder

Operand bei mathematischen

Operationen liegt also im Bereich

von 0 bis 4.294.967.295

(= 2 hoch 32).

Arbeiten

mit Registern

Der normale Anwendungsprogrammierer,

der eine Programmierhochsprache

wie C++, Visual

Basic oder Java beherrscht,

kommt normalerweise mit Regis

tern nie in Berührung. Er

Wie ein Flipflop arbeitet

Das Flip-Flop stellt die einfachste Form eines Speichers dar und kann

ein Bit so lange speichern, wie Strom anliegt (sogenannter flüchtiger

Speicher).

R

S

&

&

Flipflop-Typen

Registersatz einer x86-CPU

Diese Register besitzt ein klassischer 8086-16-Bit-Prozessor.

Bei 32-Bit-CPUs heißen die verlängerten Register EAX, EBX, usw.

(„E“ für „Extended“)

AX

BX

CX

DX

AH

BH

CH

DH

FLAGS

Q

Q

Es gibt nicht den einen Flipflop-Speicher; stattdessen wurden im Laufe

der Zeit viele verschiedene Typen entwickelt, die alle für unterschiedliche

Anforderungen

optimiert

sind. In Prozessoren

kommen

meist flankengesteuerte

Flipflops zum

Einsatz; diese

behalten ihre Information

auch

dann, wenn sich

das Eingangssignal

ändert.

Nicht taktgesteuerte

Flipflops

SP

BP

SI

DI

IP

CS

DS

SS

ES

Flipflops

AL

BL

CL

DL

FLAGS

R

0

0

1

1

Taktzustandsgesteuerte

Flipflops

Taktgesteuerte

Flipflops

Einflankengesteuerte

Flipflops

S

0

1

0

1

Taktflankengesteuerte

Flipflops

Q

1

1

0

0

Zweiflankengesteuerte

Flipflops

Accumulator Register

Base Register

Count Register

Data Register

Stack Pointer

Base Pointer

Sourceindex

Destination Index

Instruction Pointer

Status Flags

Code Segment

Data Segment

Stack Segment

Extra Segment


Prozessor

Bild: DEC

Server-Prozessoren

(hier Alpha

21164) besaßen

Features wie

64-Bit-Fähigkeit

schon lange vor

den Intel- und

AMD-Prozessoren.

Wie eine Fließkommazahl

zusammengesetzt ist

Eine Fließkommazahl besteht grundsätzlich aus drei Elementen: der

Mantisse, der Basis und einem Exponenten. Die Zahl 17,5 dargestellt

als Fließkommazahl würde man 1,75 mal 10 hoch 1 schreiben. Um eine

solche Zahl in ein 32 Bit breites Register zu quetschen, muss man zuerst

einmal definieren, welche Stellen wofür verwendet werden sollen.

Gemäß Spezifikation IEEE 754 für Float-Zahlen mit einfacher Genauigkeit

wird dabei ein Bit für das Vorzeichen verwendet (eine Fließkommazahl

kann ja auch negativ sein), 8 Bit für den Exponenten und der Rest

für die Nachkomma stellen (Mantisse).

Bit

31 24 23 16 15 8 7 0

S E E E E E E E E M M M M M M M M M M M M M M M M M M M M M M M

Exponent

Nachkommastelle (Mantisse)

Vorzeichen (Sign)

Zu Zeiten der 386er-Generation war es

üblich, Co-Prozessoren nachzurüsten.

Dafür gab es eigens einen Sockel auf

dem Mainboard. Mit dem 486 begann

später die Integration in die CPU.

programmiert mit einigermaßen

verständlichen Prozeduren,

Funktionen, Klassen und

Bibliotheken. Anders sieht die

Sache allerdings auf Maschinensprache-Ebene

aus. Hier können

die Register eines Prozessors

unmittelbar beschrieben, ausgelesen

und miteinander verarbeitet

werden. Im End effekt

werden natürlich auch die

Quellcodes von Hochsprachen

in Maschinensprache übersetzt.

Allerdings übernimmt diese Arbeit

der Compiler.

Von 32 zu 64 Bit

Das Bearbeiten größerer Zahlen

mit 32-Bit breiten (oder

noch kleineren) Registern ist

ziemlich umständlich, da die

Zahlen dann in zwei oder mehrere

Teile aufgespaltet werden

müssen – andernfalls würde ein

moderner PC ja schon an der

Berechnung der Staatsverschuldung

scheitern. Doch nicht

nur aus diesem Grund wünschen

sich die Programmierer

möglichst breite Register. Ein

32-Bit-Register kann auch nur

eine beschränkte Anzahl an Adressen

im Arbeitsspeicher aufnehmen;

für ein 32-Bit-System

bedeutet das: Bei 4 GByte RAM

ist Schluss. Mehr Speicher kann

ein 32-Bit-Prozessor nicht adressieren

(zumindest nicht auf

herkömmlichem Wege).

Die Einführung von 64-Bit-Prozessoren,

also von Prozessoren

mit 64 Bit breiten Registern,

entschärft das Problem, indem

hier rein rechnerisch 2 hoch

64 Byte RAM adressiert werden

können, also satte 16.777.216

Terabyte. Eine schier unvorstellbar

große Menge. Aus diesem

Grund haben die aktuellen

64-Bit-x86-Prozessoren eine

freiwillige Selbstbeschränkung:

Nur 40 Bit stehen für die Adressierung

des Arbeitsspeichers

zur Verfügung. Das sind 1 TByte

RAM, was für die nächsten Jahre

erst einmal genügen sollte.

Die FPU

Die normale ALU ist nicht in der

Lage, Fließkomma-Berechnungen

anzustellen – sie kann nur

ganze Zahlen verrechnen. An einer

Berechnung wie 125,4845

geteilt durch 17,5 scheitert die

ALU kläglich. Dafür ist sie nicht

konzipiert worden. Ein Programm,

das solche Berechnungen

mit einem x86-Prozessor

ohne FPU durchführen wollte,

musste die Funktion aufwendig

per Software emulieren. Mit einem

mathematischen Koprozessor

dagegen können solche

Berechnungen „in Hardware“

und damit wesentlich schneller

durchgeführt werden. Die

meisten FPUs stellen Operationen

für die Grundrechenarten,

Logarithmus-, Wurzel- und Potenzrechnung

und trigonometrische

Funktionen zur Verfügung.

Rundungsfehler

Bei der Darstellung und vor allem

bei der Weiterverarbeitung

von Fließkommazahlen sollte

man aber stets im Hinterkopf

behalten, dass eine solche Zahl

lediglich eine mehr oder minder

genaue Rundung der reellen

Zahl darstellt. Je geringer

dabei die Anzahl an Bits, die

für die Mantisse zu Verfügung

stehen, desto ungenauer die

Rundung. Ein Beispiel: Nehmen

wir die Berechnung 10 geteilt

durch 3. Dabei kommt 3,3

Periode heraus. Mit nur einer

Nachkommastelle erhält man

das Ergebnis 3,3. Multipliziert

man dieses Ergebnis mit 1.000,

kommt man auf 3.300 – was

falsch ist! Denn in Wahrheit ist

das Ergebnis 3.333,3 Periode.


Prozessor

Wie eine Pipeline funktioniert

Der ständig wiederkehrende Funktionsablauf in einem Prozessor besteht

im Wesentlichen aus den Stufen IF (Instruction Fetch), ID (Instruction

Decoding), EX (Execution) und WB (Write Back), wobei sich der

der Ablaufplan im Bereich EX je nach Darstellung um einen MEM- oder

Fetch-Operands-Zyklus erweitern lässt – schließlich müssen nicht nur

die Instruktio nen aus dem Speicher geladen werden, sondern auch

noch die zu verarbeitenden Daten. Gehen wir also in unserem Beispiel

einmal von der Reihenfolge IF, ID, EX, MEM und WB aus. Das sind fünf

verschiedene Vorgänge, die ein Prozessor nacheinander ausführen

muss, um einen einzigen Befehl zu verarbeiten – grundsätzlich spiegeln

diese auch die fünf Phasen der Befehlsverarbeitung eines Von-Neumann-Rechners

wider.

Leerlauf

Ein solcher vereinfachter Prozessor hätte einen CPI-Wert von fünf. Für

jeden Befehl benötigt die CPU also selbst im Idealfall fünf ganze Takte,

wobei dieser Idealfall höchst selten eintritt. Schließlich dauert bereits

ein Zugriff auf den im Verhältnis deutlich langsameren Arbeitsspeicher

etliche Dutzend bis hundert Prozessortakte. In dieser Zeit ist unser

Prozessor zum Warten verdammt; eine Zeit, in der die CPU nichts weiter

tun kann, als Däumchen zu drehen, bis die Infrastruktur die Daten

aus dem RAM gelesen hat.

Fließbandprinzip

Statt alle Einheiten an einer einzelnen Operation arbeiten zu lassen,

unterteilen aktuelle Prozessoren die Aufgaben in möglichst kleine Teilbereiche

– genau wie einst Henry Ford bei der Produktion von Autos.

Der Trick des Pipelinings ist es nun, die Schritte IF, ID, EX, MEM und

WB genau wie am Fließband zwar nach wie vor hintereinander auszuführen,

jedoch den nächsten IF-Arbeitsschritt bereits dann zu beginnen,

wenn Stufe 2 der Pipeline noch mit ID beschäftigt ist. So wird die

Pipeline bei jedem Takt mit einer neuen Instruktion gefüttert.

Effizientere Verarbeitung

Zwar dauert es genau wie am Fließband nach wie vor genauso viele

Taktzyklen wie ohne Pipeline, bis die erste Instruktion abgearbeitet

ist. Anschließend jedoch wird der Prozessor nach jedem Takt wieder

mit einer Instruktion fertig, während der Non-Pipelined-Prozessor hier

erst wieder mit seiner nächsten Instruktion beginnen würde. Durch die

CPU-Pipeline haben wir es also geschafft, den CPI-Wert unseres Beispielprozessors

von bisher bestenfalls 5 auf bis zu 1 zu verringern.

t

i

1 2 3 4 5 6 7 8 9

IF

ID EX MEM

IF

ID EX MEM

IF

ID EX MEM

IF

So funktionieren

Pipelines und OoO

ID EX MEM WB

IF ID EX MEM WB

Die fünfstufige Pipeline unserer Beispiel-CPU: Ab dem fünften Takt

wird die CPU mit jedem Zyklus mit einer Instruktion fertig.

WB

WB

WB

Um eine einzige Funktion

auszuführen, benötigte

der Urvater der

heutigen Prozessoren, der Intel

8086, unzählige Takte abhängig

von der Art der Instruktion. Der

Fachbegriff dafür lautet CPI

(Clockcycles per Instruction).

Dieser Wert beschreibt die Anzahl

der Takte, die benötigt werden,

um eine Instruktion auszuführen.

Dem grundsätzlichen Problem

der langwierigen Befehlsverarbeitung

versucht man mit dem

Fließbandprinzip zu begegnen;

wie einst bei Henry Ford erwies

es sich als zweckmäßig, die Verarbeitung

einer Instruktion in

mehrere, etwa gleich große

Einzelschritte zu zerlegen (detaillierte

Erklärung im Kasten

rechts).

Pipelining

Als erster Mikroprozessor mit

einer (einstufigen) Pipeline

gilt der MOS Technology 6502

von 1975. Aber auch in der x86-

Welt war bereits der allererste

IBM-kompatible Prozessor, der

Intel 8086 im Jahre 1978, mit

einer primitiven Form des Pipelinings

ausgestattet. Seine

Bus-Interface-Unit schickte die

Abfolge an Instruktionen durch

eine 6-Byte-Prefetch-Queue an

die Execution-Einheit, sodass

die Stufen Fetch und Execution

gleichzeitig ausgeführt werden

konnten.

Pionier 486

Als Vater des echten Pipelinings

auf den x86ern jedoch gilt der

Intel 80486, der eine dreistufige

Locate-Fetch-Execution-Pipeline

besaß und im Jahre 1989

eingeführt wurde. Damals, als

die Luft bei der CPU-Entwicklung

noch nicht so dünn war

wie heute, hatte die Einführung

einer neuen Prozessor-Generation

aufgrund der neuen Features,

zu denen auch Pipelining

gehörte, tatsächlich einen deutlichen

Performance-Schub bei

gleicher Taktfrequenz zur Folge.

Heute können die CPU-Designer

schon froh sein, wenn

eine neue Generation 20 bis

30 Prozent weniger CPI benötigt

als der Vorgänger. Das liegt

mitunter natürlich daran, dass

sich dieses Prinzip nicht beliebig

erweitern lässt.

Pipeline-Probleme

Ein Prozessor ist kein streng sequenzieller

Automat, bei dem

alle Vorgänge vorhersehbar

sind. Ein Programm ist vor allem

eine Ansammlung von unzähligen

Entscheidungsfindungen.

Die Wenn-dann-Struktur

eines Programms steht jedoch

in direkter Konkurrenz zu einer

möglichst tiefen Pipeline.

Das ist immer dann kritisch,

wenn beispielsweise die dritte

Instruktion vom Ergebnis der

ersten Instruktion abhängt.

Bereits in unserer äußerst kurzen

Beispiel-CPU mit fünf Pipeline-Stufen

ist das ein Problem,

denn wenn die Instruktion Nr.

3 in die ID-Stufe geladen wird,

ist die Instruktion Nr. 1 noch

nicht fertig berechnet.

Es gibt nun zwei Möglichkeiten,

eine CPU in so einem Fall

verfahren zu lassen: Entweder

wartet die CPU mit dem Start

der dritten Instruktion so lange,

bis das Ergebnis der ersten


Prozessor

Instruktion feststeht. Das ist die

einfachste Art der Implementierung,

aber auch die langsamste.

Im schlimmsten Fall arbeitet

der Prozessor wie ein Prozessor

ohne Pipeline, weil er ständig

auf das Ergebnis einer vorherigen

Stufe wartet.

Spekulative

Ausführung

Die andere Möglichkeit der

Im plementierung lautet, die

Pipeline einfach auf Verdacht

arbeiten zu lassen. Wenn die

Instruktion 1 zwei Takte später

das Ergebnis hat, das Instruktion

3 „angenommen“ hat, bleibt

die heile Welt des Pipelinings

erhalten.

Übel wird es allerdings, wenn

sich die CPU „verschätzt“ hat

und die Instruktion 3 unter

falschen Voraussetzungen auf

die Reise geschickt hat. Dann

muss die komplette Pipeline

geleert („geflusht“) werden, alle

in der Pipeline befindlichen

Stationen müssen ihre Arbeit

auf den Müll werfen. Wenn

das permanent geschieht, kann

eine Pipelined-CPU sogar langsamer

arbeiten als eine Non-Pipelined-CPU,

da das Flushen

einer Pipeline selbst bereits etliche

Takte für sich in Anspruch

nimmt.

Branch-Prediction

Trotzdem arbeiten fast alle

Pipelined-CPUs mit diesen

Berechnungen auf Verdacht.

Allerdings haben die CPU-Entwickler

ihren Babys ein Feature

mit auf den Weg gegeben,

das dafür sorgt, dass ein Pipeline-Flush

so selten wie möglich

nötig ist. Dieses Feature nennt

sich Branch-Prediction-Unit,

zu Deutsch: Sprungvorhersage.

Eine Sprungvorhersage (eigentlich

ist dies eine falsche

Übersetzung, „branch prediction“

lautet korrekt übersetzt

„Abzweigungsvorhersage“ oder

„Verzweigungsvorhersage“) versucht

zu erraten, welche Richtung

der Programmfluss bei

einem bedingten Sprung einlegen

wird. Hierbei werden die

verschiedenen Verzweigungsmöglichkeiten

des Programmflusses

genauestens geprüft und

nach Wahrscheinlichkeiten gewichtet.

Die Verzweigung mit

der höchsten Wahrscheinlichkeit

wird anschließend als weiterer

Verlauf des Programms definiert

und die Pipeline mit den

entsprechenden Instruktionen

gefüllt.

Doch wie das Wort „Wahrscheinlichkeit“

schon zeigt, gibt

es keine Garantie, dass der Programmfluss

die vorhergesagte

Richtung auch wirklich einschlägt.

Somit wird es immer

den Fall geben, dass aufgrund

eines Versagens der Sprungvorhersage-Logik

die Pipeline ausgespült

und neu gefüllt werden

muss. Die perfekte Sprungvorhersage

mit 99 Prozent Treffsicherheit

(oder gar mehr) hat

bisher noch niemand konstruieren

können, Informatiker und

Ingenieure rund um den Globus

beschäftigen sich mit dem

Modell der „Sprungvorhersage“.

Branch Target Buffer

Besser als eine bloße Sprungvorhersage

ist eine Sprungzielvorhersage.

Sobald man in der

ID-Stage erkennt, dass es sich

um einen Sprung handelt, kann

man prüfen, ob dieser Sprung

schon einmal stattfand, und

gegebenenfalls sein Sprungziel

aus einem Puffer holen. Somit

kann man den Programmzähler

sofort auf dieses Sprungziel

stellen und die dortigen Instruktionen

in die Pipeline laden.

Intels Pentium (1) brachte erstmals zwei Pipelines; eine davon konnte

aber nur einfache Aufgaben berechnen (V-Pipe), während die andere

universell einsetzbar war (U-Pipe).

Spekulative Ausführung

Speculative Execution: Wird ein Sprung zweimal hintereinander ausgeführt,

ändert der Predictor seine Vorhersage von Nojump auf Jump.

-

-

-

Beim K6 kombinierte

AMD den

Befehlssatz der

fünften CPU-Generation

mit der Outof-Order-Fähigkeit

der sechsten Gen e-

ration.

+

state 3: predict jump

state 2: predict jump

state 1: predict nojump

state 0: predict nojump

-

+

+

+

Quelle: www.kreissl.info

Bild: Intel


Prozessor

Wie ein super skalarer

Prozessor arbeitet

Eine fünfstufige Pipeline mit zweifacher Superskalarität. Hier können

zwei Befehle gleichzeitig ausgeführt werden.

Fetch Decode Execute


Fetch

Fetch

Decode

Decode

Fetch

Mem

Access

Mem

Access

Execute

Execute

Decode

Pipelining und

Out-of-Order-Execution

Write

Back

Write

Back

Mem

Access

Mem

Access

Execute


Im unserem abgebildeten Beispiel laufen drei Befehle parallel; erschwerend

kommt hinzu, dass die grüne Instruktion (addiere F1 und F2 und

schreibe das Ergebnis in F3) vom Ergebnis der roten abhängig ist. Im

oberen Teil der Grafik muss die grüne Instruktion warten, bis das Ergebnis

der roten vorliegt. Es müssen daher zwei Wartezyklen (S, stall) eingelegt

werden. Dies blockiert auch die blaue Operation. Dennoch sind

alle drei Aufgaben bereits nach 9 Taktzyklen erledigt – ohne Pipelining

hätten die drei Instruktionen 15 Taktzyklen benötigt.

In der unteren Hälfte ist die gleiche Aufgabe auf einem Out-of-Order-Execution-fähigen

Chip zu sehen. Hier wurde die ursprünglich dritte

Instruktion (blau) vorgezogen. Sie kann nun ohne Wartezeit bearbeitet

werden. Als Nebeneffekt ergibt sich, dass die grüne Instruktion nun nur

noch einen Takt auf das Ergebnis der roten Instruktion warten muss.

Taktzyklus

1 2 3 4 5 6 7 8 9

IF ID EX M WB

IF ID S S EX M WB

IF S S ID EX M WB

add F1, F2 => F3

add F1, F3 => F4

sub R1, R2 => R3

Taktzyklus

1 2 3 4 5 6 7 8 9

IF ID EX M WB

IF ID EX M WB

IF ID S EX M WB

Legende:

IF (Instruction Fetch): Der nächste Befehl wird geholt. ID (Instruction Decode): Der Befehl

wird dekodiert. EX (Execute): Der Befehl wird ausgeführt. M (Memory): Der Speicher wird

adressiert. WB (Write Back): Das Ergebnis der Berechnung wird geschrieben. S (Stall):

Die Pipeline läuft leer.

Dies geschieht in der Regel mithilfe

eines Branch Target Buffers

(BTB) oder eines Branch

Target Adress Cache. Diese

Tabelle enthält Vorhersageinformationen,

Zieladressen und

Tags.

Superskalarität

Mit einem strikt nach von Neumann

arbeitenden Prozessor

würde man niemals eine IPC >

1 erreichen können (bzw. CPI

< 1). Die Tatsache, dass heutige

Prozessoren einen IPC von

deutlich mehr als 1 haben, beruht

schlicht und ergreifend auf

der Tatsache, dass die Entwickler

die von-Neumann-Architektur

nach eigenen Vorstellung

etwas verbogen haben und den

Prozessoren, beginnend mit

dem Intel Pentium (586), die

superskalare Arbeitsweise eingeimpft

haben.

Dabei geht es nicht ausschließlich

um das Pipelining. Eine superskalare

CPU unterscheidet

sich von einem nicht-superskalaren

Prozessor hauptsächlich

im Leitwerk. So teilt das Leitwerk

einer Recheneinheit nicht

mehr lediglich eine Instruktion

pro Takt zu, sondern gleich

mehrere unterschiedliche Instruktionen

für mehrere unterschiedliche

Recheneinheiten.

Es gibt damit im Grunde nicht

nur eine Pipeline, sondern

mehrere parallele. Der Prozessor

ist damit in der Lage, mehrere

Instruktionen parallel abzuarbeiten,

solange diese oder

ihr Ergebnis nicht voneinander

abhängig sind.

Somit kann eine zweifach superskalare

CPU bei gleichem

Takt im Idealfall doppelt so viele

Instruktionen pro Sekunde

abarbeiten wie ein serieller Prozessor.

Um dies zu erreichen,

muss beispielsweise der Dekoder

mehr als nur eine Instruktion

pro Taktzyklus dekodieren

können. Es müssen mehrere

von einander unabhängige Recheneinheiten

vorhanden sein.

Die erste Implementierung superskalarer

Arbeitsweise fand

in der fünften x86-Generation

statt, im Intel 586 alias Pentium.

Out-of-order

Execution

Mit der Superskalarität wurde

es noch wichtiger, die Recheneinheiten

optimal auszulasten.

Zu diesem Zweck ersannen

die Entwickler die „Out-of-Order

Execution“ (kurz: OoO, zu

Deutsch: „Ausführung außerhalb

der Reihenfolge“). Sie bietet

einen enormen Zuwachs an

Geschwindigkeit, denn so können

Instruktionen bereits ausgeführt

werden, wenn sie noch

gar nicht an der Reihe sind.

Ein Beispiel: Nehmen wir an,

dass eine Instruktion Daten aus

dem Speicher einlesen muss.

Dies führt dazu, dass der Prozessor

für mehrere hundert

bis tausend Taktzyklen auf die

Daten warten muss und quasi

zum Nichtstun verdammt ist.

Gibt es jedoch in der Pipeline

Instruktionen, die von der derzeit

auf Daten aus dem Speicher

wartenden Instruktion weder

abhängen noch mit ihr in Zusammenhang

stehen, kann der

Prozessor die nötige Wartezeit

mit der Ausführung dieser Instruktionen

überbrücken.

Out-of-Order Execution wurde

in der x86-Welt erstmals mit

dem Pentium Pro eingeführt.

Dennoch gibt es auch heute

noch CPUs, die zugunsten einer

niedrigen Leistungsaufnahme

auf OoO verzichten – Intels

Atom ist ein Beispiel dafür.


Z87-GD65

GAMING

JUST GAME!

Stabile Netzwerkverbindung mit Killer Ethernet!

Geringe Latenzzeiten und ein optimaler Ping sorgen

dafür, dass du dich ganz dem Spiel widmen kannst.

Biete deinen Ohren beste Sound-Qualität! Der Audio

Boost Schaltkreis wurde konzipiert um hochwertiges

Audiomaterial perfekt wiederzugeben.

TOP QUALITÄT

& STABILITÄT

OVERCLOCKEN

IN 1 SEKUNDE

REALISTISCHER

SURROUND SOUND

game.msi.com

© 2013 Micro-Star Int‘l Co.,Ltd., Alle Rechte vorbehalten. Intel, das Intel Logo, Intel Inside, Intel Core und Core Inside sind Marken der Intel Corporation in den USA und

anderen Ländern. Weitere verwendete Marken und Handelsnamen beziehen sich auf die jeweiligen Eigentümer oder deren Produkte.

MSI Motherboards erhalten Sie bei: Amazon · Acom · Arlt · Alternate · Atelco · Bora Computer · Caseking · Computeruniverse · Cyberport · Home of Hardware · sowie im Fachhandel

Prozessor

So funktionieren

Caches

teme besaßen Cache-Bausteine

aus SRAM-Speicher auf den

Mainboards, um den Zugriff

auf häufig verwendete Codestellen

und Daten zu beschleunigen.


Cache kann man aufgrund der uniformen Struktur leicht auf dem Wafer

oder entsprechenden Bildern („Die-Shots“) erkennen.

Bei älteren Prozessoren nahm der Cache bis zu 50 Prozent der kompletten

Chipfläche ein (hier ein Core 2 Duo). Bei aktuellen Modellen ist

es aufgrund des integrierten Grafikkerns prozentual deutlich weniger.

Der klassische von-Neumann-Rechner

besitzt

keinen Cachespeicher,

ja nicht einmal

Register. Sämtliche Operationen

werden direkt aus dem

Speicher heraus ausgeführt

– und das dauert! Experimentierfreudige

Leser können das

gerne mal ausprobieren und im

BIOS des Computers L1- und

L2 Cache deaktivieren. Von

der enormen Performance des

Prozessors bleibt dann absolut

nichts mehr übrig.

Langsamer Speicher

Verantwortlich dafür ist zum

einen die Diskrepanz zwischen

CPU- und Speichertakt. Während

aktuel le Prozessoren mit

4 GHz Taktfrequenz und mehr

arbeiten, kriechen selbst die

schnellen DDR3-Speicher mit

knapp einem Gigahertz vor

sich hin – intern sind es gar nur

266 MHz.

Damit könnte man noch leben.

Doch noch schlimmer sind

die miserablen Zugriffszeiten

von DRAM-Speicher: Von

der Anforderung von Daten

bis zur Lieferung vergehen je

nach Plattform zwischen 150

und 500 Prozessortakte! Im

schlimmsten Fall (wenn OoO

oder andere Funktionen nicht

greifen), kann der Prozessor in

dieser Zeit nichts anderes tun

als warten.

Cache-Geschichte

Dieser Missstand wurde bereits

früh erkannt. Schon 8088-Sys-

Der Trick dabei: Daten, die bereits

einmal aus dem Speicher

geholt wurden, werden in einen

Puffer geschrieben. Benötigt

die CPU dieselben Teile

wenig später noch einmal,

was relativ häufig vorkommt,

braucht sie nicht erneut darauf

zu warten. Die Daten müssen

dann nicht mehr aus dem RAM

gelesen, sondern können relativ

schnell aus dem Pufferspeicher

bereitgestellt werden.

Cache-Hierarchie

Allerdings sind klassische

Cache-Bausteine auf den Mainboards

immer noch relativ

langsam, arbeiten sie doch

meist mit der Taktfrequenz

der Infrastruktur, während

die CPU meist 10 bis 20 Mal

so hoch taktet. Daher integrierte

Intel beim 80486 zum

ersten Mal zusätzlichen Cache

auch direkt in die CPU. Der

gestufte Cache war erfunden.

Beim 486er waren es meist 2x

4 KiByte Puffer in der CPU als

Level-1-Cache sowie größerer

(damals meist 256 kByte), aber

langsamerer Level-2-Cache auf

dem Mainboard.

Der Vorteil des in tegrier ten

Caches: Die Wege sind kürzer,

die Latenzzeiten sinken gewaltig,

der Cache arbeitet mit vollem

CPU-Takt und die Anbindung

kann breiter ausgeführt

werden, als es die Infrastruktur

vorgibt. Mit stetig verbesserten

Produktionstechniken konnte

einige Jahre später auch der

L2-Cache direkt in die CPU integriert

werden. Seitdem be-


Prozessor

sitzt praktisch jede CPU einen

On-Die-Level-1- und Level-2-

Cache.

SRAM-Speicher

Implementiert wird Cache

durch sogenanntes SRAM. Statisches

RAM (engl. Static Random

Access Memory) bezeichnet

einen Typ von flüchtigen

Speicherbausteinen. Im Gegensatz

zu DRAMs müssen außer

der Betriebsspannung keine

Signale zum Auffrischen erzeugt

werden, um die Daten zu

erhalten. Eine SRAM-Speicherzelle

besteht aus zwei Transistoren,

die als Flipflop (siehe

unter „Flipflop“ und im Artikel

„So funktioniert die Infrastruktur:

Speicher“) geschaltet sind,

und weiteren Transistoren für

die Steuerung des Schreib- und

Lesevorgangs.

In der Regel sind für eine Speicherzelle

sechs CMOS-Transistoren

nötig. Jede Speicherzelle

bildet 1 Bit ab. SRAM hat sehr

geringe Zugriffszeiten und

ist damit als Cachespeicher

prädestiniert. Aufgrund der

einfachen Ansteue rung ist es

auch die bevorzugte Speichertechnologie

für Embedded

Memory (im Chip integrierter

Speicher). Der Nachteil im Vergleich

zu DRAMs ist der höhere

Flächenbedarf auf dem Wafer

bei gleicher Speicherkapazität

und der damit vielfach höhere

Preis.

Cache-Arbeitsweisen

Je nach Prozessor ist ein zweigeteilter

Split-Cache oder ein

einheitlicher Unified-Cache

verbaut, der Daten und Befehle

gemischt speichert. Die

aktuellen CPUs von AMD und

Intel verwenden Split- Caches

für den L1- und Unified-

Cache für den L2-/L3-Zwischenspeicher.

Aus Platzgründen

kann der L1-Cache in der

CPU nicht sehr groß sein. Je

nach Philosophie des Prozessorherstellers

bewegt er sich

zwischen 16 und 128 kByte.

Cache-Organisation

Der Cache wird in Zeilen

(Cache Lines) oder Sets eingeteilt.

Erfolgt ein Lesezugriff auf

einen Bereich im Arbeitsspeicher,

dann füllt die CPU eine

Cache-Zeile mit dem Inhalt aus

diesem Speicherblock.

Es gibt verschiedene Organisationen

von Caches. Der

einfachste ist der Direct-mapped-Cache.

Hier ist jedem Set

nur ein Cache-Eintrag zugeordnet.

Der Nachteil des Direct-mapped-Caches

ist, dass

nur Speicherbereiche in der

Größe des Caches gepuffert

werden können. Wird auf Speicherbereiche

außerhalb dieses

Bereiches zugegriffen, ist der

gesamte Inhalt des Eintrages

wertlos und muss neu geladen

werden.

Assoziativer Cache

Hier eilen teil- oder mehrwegassozia

tive Caches zu Hilfe.

Die Adressen werden dabei in

mehreren Ebenen gespeichert

und miteinander verknüpft.

Erfolgt ein Zugriff auf eine Adresse

außerhalb des aktuellen

Blocks, die aber dieselbe Anfangsadresse

enthält, so wird

der Speicherblock nicht komplett

ausgetauscht, sondern in

einer anderen Ebene gespeichert.

Ein gern verwendeter Vergleich

ist der Briefträger: Er

sortiert die Post nicht nur in

Straßenzüge (Tags), sondern

obendrein auch nach der Straßenseite.

Bei einem Abstecher

Der 80386 (hier ein

selteneres Modell

von AMD statt von

Intel) musste noch

mit externem Cache

auf dem Mainboard

auskommen.

486-CPUs besaßen

als erste

x86-Prozessoren

einen 8 kByte

großen On-Die-L1-

Cache, Derivate

anderer Hersteller

(Cyrix, TI) mussten

mit 1 kByte auskommen.

Die Cachebausteine auf den Mainboards

waren früher in Form von

steckbaren Modulen verbaut. So

konnten sie – je nach Einsatzgebiet

– auch bequem (aber teuer)

nachgerüstet werden.


Prozessor

Wie Cache-Speicher

intern aufgebaut ist

Ein SRAM-Cache benötigt zur Speicherung eines einzigen Bits satte

sechs Transistoren. Vier Transistoren speichern die Information, die

restlichen werden zum Ein- und Auslesen benötigt. Daneben gibt es

aber auch eine Reihe alternativer und verbesserter SRAM-Designs;

in der Nehalem-Architektur beispielsweise kommen SRAM-Zellen mit

acht Transistoren zum Einsatz, die für einen geringeren Energiebedarf

sorgen sollen.

Warum es für kurze Zeit

Slot-Prozessoren gab

Der erste AMD Athlon besaß ebenso wie der Pentium III Katmai einen

L2-Cache in Form von auf der CPU-Platine aufgelöteten SRAM-Chips.

Dazu war damals die Slot-Bauweise nötig. Später passte der Cache

aufgrund des besseren Herstellungsprozesses wieder auf den Chip –

die Slot-Gehäuse verschwanden wieder.

Bild: AMD

in die Seitenstraße greift er

sich nur das Briefbündel für

eine Straßenseite und legt

das zweite Bündel der gegenüberliegenden

Straßenseite

der alten Straße weg. Wenn er

aus der Seitenstraße zurückkommt,

hat er immer noch das

Bündel der Seite in der Hand,

bei der er abgebogen ist. Level-

1-Caches aktueller CPUs sind

in der Regel 2-Wege-assoziativ,

Level-2-Caches 16-Wege-assoziativ.

Trace Cache

Mit dem Pentium 4 hat Intel einen

Sonderfall des L1-Instruction-

Cache eingeführt, den sogenannten

Trace Cache. Seit dem

6x86 arbeiten x86-Prozessoren

extern wie CISC-Prozessoren

mit komplexem Befehlssatz, dekodieren

jedoch jede Instruktion

vor ihrer Ausführung in RI-

SC-artige Mikro-Operationen.

Dieser Vorgang der Dekodierung

kostet natürlich Rechenzeit

und um diese zu sparen,

speicherte der Pen tium 4 im

12.000 Mikro-Operationen

(µOps) fassenden L1- Trace-

Cache die bereits dekodierten

RISC-artigen Befehle für die

weitere Verwendung ab. Der

Trace Cache verschwand wenig

später wieder, erlebte aber

mit der Sandy-Bridge-Architektur

ein Comeback und ist heute

Bestandteil fast aller Intel-Prozessoren.

Cacheverwaltung

Zusätzlich zu den erwähnten

Va rianten unterscheidet man

zwischen inklusiver und exklusiver

Cacheverwaltung. Bei der

inklusiven Verwaltung nehmen

die einzelnen Cache-Stufen

keine Rücksicht darauf, ob

Daten bereits in der anderen

Stufe liegen oder nicht. Es kann

also vorkommen, dass Daten

sowohl im L1- als auch im L2-

Cache liegen (oder analog dazu

im L2- und L3-Cache) und damit

mehrfach vorhanden sind.

Angesichts der geringen Größe

der Caches eigentlich eine

böse Verschwendung.

Allerdings arbeitet ein inklusiver

Cache aufgrund des niedrigeren

Verwaltungsaufwandes

in der Regel mit sehr niedrigen

Latenzzeiten. Beim exklusiven

Cache dagegen können Daten

niemals gleichzeitig in L1 und

L2 liegen und damit Platz verschwenden.

Die beiden Cachestufen

werden so verwaltet, als

wären sie ein großer Cache-

Pool – mit dem einzigen Unterschied,

dass der L1 noch

einmal schneller arbeitet als

der L2.

Cachegröße

Je größer der Cachespeicher,

desto mehr Daten kann die

CPU im Puffer halten und desto

größer ist die Wahrscheinlichkeit,

dass sich ein benötigtes

Datenpaket bereits im Cache

befindet. Aktuell scheint der

beste Kompromiss zwischen

Cache-Größe und Platzbedarf

auf dem CPU-Kern bei zirka

sechs bis acht Megabyte für

den L3-Cache zu liegen; sämtliche

Mittelklasse-Prozessoren,

egal ob bei AMD oder Intel, bewegen

sich in diesem Rahmen.

Bei den L1- und L2-Caches

herrscht bereits seit einigen

Jahren Stillstand. Die L1-

Caches sind bei AMD und Intel

pro Kern gleichermaßen

zwischen 64 und 128 Kilobyte

groß; beim L2-Cache gibt es

dagegen größere Unterschiede:

Während Intel in der Regel

zwischen 256 und 512 Kilobyte

pro Kern verbaut, spendiert

AMD bis zu 2.048 Kilobyte.


Prozessor

Mit der Pipelining-Technik

ist es den Dekodern

möglich, mehrere

Aufgaben eines Programms

gleichzeitig zur Ausführung

abzuschicken und somit im Idealfall

eine Leistungssteigerung

um den Faktor der Pipelinezahl

zu erreichen.

Allerdings ist das nur äußerst

selten der Fall, da innerhalb eines

Programms Operanden in

der einen Pipeline häufig vom

Ergebnis einer Operation in

einer anderen Pipeline abhängig

sind. Um die Auslastung zu

verbessern, versuchten die Entwickler

daher schon früh, ganze

Prozesse parallel laufen zu lassen.

Seit klar war, dass die physikalische

Taktgrenze, die bei

ungefähr vier bis fünf Gigahertz

liegt, mit aktuellen Techniken

kaum überwunden werden

kann, führte kein Weg mehr an

Multiprocessing vorbei.

Prozesse und

Threads

Wenn wir auf unserem Computer

ein Programm starten,

öffnen wir damit in der Regel

einen Prozess. Früher, zu

DOS-Zeiten, bestand ein Prozess

immer auch nur aus einem

Thread. Bei vielen Kommandozeilen-Anwendungen

ist das

auch heute noch so. Wenn das

Programm gestartet wird, sind

keine Ein- oder Ausgaben mehr

möglich, ohne die Laufzeit des

Programms zu unterbrechen.

So funktionieren

SMP und SMT

Windows-Programme oder

allgemein Programme mit

Benutzer oberfläche bestehen

zumindest aus zwei Threads:

der Oberfläche und dem eigentlichen

Arbeitsthread. So ist es

möglich, eine Oberfläche auch

dann noch zu bedienen, wenn

das Programm auf Vollgas werkelt,

bei einer Videosoftware

zum Beispiel während ein Film

umgewandelt wird.

Eine andere Möglichkeit ist,

Oberfläche und Programm

strikt zu trennen. In einem

solchen Fall öffnet die Oberfläche

beim Start der Videoumwandlung

ein zusätzliches

Programm, meist auf Kommandozeilenebene.

Ein typischer

Vertreter dieser Gattung

ist der MP3-Encoder Lame.

Multitasking

Bis zum Pentium III waren

x86-Prozessoren lediglich in

der Lage, immer nur einen

Thread eines Prozesses zu bearbeiten.

Dass moderne Betriebssystem

wie Linux oder

Windows seit dem Intel 80286

trotzdem in der Lage sind, ihren

Anwendern Multitasking

anzubieten – also das scheinbar

gleichzeitige Arbeiten mit mehreren

Programmen –, darf nicht

darüber hinwegtäuschen.

Dieses präemptive Multitasking

arbeitet mit einem Scheduler.

Der Reihe nach darf jede Anwendung

abhängig von ihrer

Priorität Prozessorzeit in Anspruch

nehmen – mit Betonung

auf „der Reihe nach“. Effektiv in

Bearbeitung ist aber immer nur

ein Thread. Der Anwender hat

lediglich den Eindruck, mehrere

Programme würden tatsächlich

gleichzeitig arbeiten, da

der Wechsel zwischen den einzelnen

Tasks sehr schnell vonstatten

geht.

Ob Zweikern-Prozessor oder SMP-System mit dutzenden Prozessoren

– Voraussetzung für eine Leistungssteigerung ist die Aufteilung

in Threads.

Hyper-Threading soll die Funktionseinheiten

moderner CPUs besser

auslasten. Bis heute klappt das im

Alltag aber nur selten.

Programme wie Seti@

Home eignen sich hervorragend

für die Zerlegung

in Teilaufgaben.

Bild: Intel


Prozessor

Mehr Prozessoren

Um tatsächlich mehrere Aufgaben

gleichzeitig zu erledigen,

sind Systeme mit mehreren

Prozessoren notwendig. Das

Betriebssystem kann dann

entweder mehrere Prozesse

gleichmäßig auf die Prozessoren

aufteilen. Daneben ist es

aber auch möglich, einen Prozess

auf mehreren Prozessoren

laufen zu lassen. Dazu muss der

Prozess aber aus mehreren unabhängigen

Threads bestehen.

Das zu realisieren fällt in das

Aufgabengebiet der Programmierer

und der Compiler.

Vorteil dieses Multi-Processings

oder Multi-Threadings: entweder

ein deutliches Geschwindigkeitsplus,

wenn das Programm

Mehrprozessor-Systeme

unterstützt, oder ein besseres

Ansprechverhalten, wenn nur

ein Prozessor mit einer Aufgabe

ausgelastet ist und der zweite

nach wie vor vollständig zum

Arbeiten zur Verfügung steht.

Hyper-Threading

Aus diesem Grund hat Intel vor

einigen Jahren eine – wenn man

so will – abgespeckte Version

von Symmetric Multiprocessing

(SMP) in seine Prozessoren integriert,

das Simultaneous Multi

Threading (SMT).

Vermarktet wurde dieses Feature

unter dem Namen Hyper-Threading

(HT). Der Clou

an HT ist nun, die Vorteile

von SMP-Systemen auf nur einen

Prozessor zu projizieren,

zumindest teilweise. Bei aktiviertem

HT gaukelt der Prozessor

dem System einfach zwei

CPU-Kerne vor, obwohl physikalisch

nur einer vorhanden

ist. Intel spricht dabei von logischen

Prozessoren (LPs). Das

Betriebssystem glaubt, zwei

Prozessoren gefunden zu haben,

und verwaltet das System

wie ein waschechtes Mehr-Prozessorsystem.

Mit optimiertem

Code können sich drastische

Leistungssteigerungen einstellen;

bei Single-Threaded-Software

passiert jedoch gar nichts,

in Einzelfällen arbeiten Hyper-Threading-CPUs

sogar langsamer

als Modelle ohne diese

Technik.

Echtes Multi-

Processing

Beim SMP dagegen werden

dem Betriebssystem nicht nur

zwei oder mehrere Prozessoren

bzw. Prozessorkerne in Form

von logischen Prozessoren vorgegaukelt,

es kommen tatsächlich

zwei oder mehr Prozessoren

zum Einsatz. Der Vorteil

liegt auf der Hand: Die Rechenleistung

des Systems steigt im

Idealfall mit der Anzahl der Prozessoren.

Im Normalfall ist jede

Standardsoft ware auf SMP-Systemen

einsatzfähig, wenn auch

mit unterschiedlichem Erfolg.

Die Voraussetzungen, damit

eine Software auch in der Praxis

von SMP profitiert, sind

dieselben wie beim SMT: Es

müssen mindestens so viele

Arbeitsprozesse bzw. Arbeitsthreads

existieren, wie Prozessoren

vorhanden sind. Wenn

das nicht der Fall ist, steht ein

Prozessor „Däumchen drehend“

herum, während der andere

unter Volllast arbeitet.

Beispiel: Wie Hyper-Threading Verarbeitung funktioniert eines Tastendrucks

Intel unterscheidet drei Arten, wie die Bauteile der CPU für zwei LPs verwaltet werden: shared, replicated und partitioned. Im Bild ist die ursprüngliche

Aufteilung der Funktionseinheiten im Pentium 4 zu sehen; bei der späteren Implementierung im Nehalem-Architektur stellte Intel weniger detaillierte Informationen

zur Verfügung und bis heute ist unklar, wie genau die Technik dort umgesetzt wurde.

I-Fetch Queue Rename Queue Sched

IP

Register

Read

Execute

L1 Cache

Store Buffer

Register

Write

Retire

Trace

Cache

Register

Renamer

Registers

L1

D-Cache

Registers

Re-Order

Buffer

Mit Hyper-Threading lassen sich sowohl der Core als auch die Anbindung des Pentium effizienter auslasten, sofern die Technik von der Software unterstützt wird (Darstellung: Intel).

Shared Partitioned Replicated

Gemeinsam genutzte

(„shared“) Einheiten:

Caches

Out-of-order execution

engine

Geteilte („partitioned“)

Einheiten:

Re-order buffers

Load/Store buffers

Queues

Duplizierte („replicated“)

Einheiten:

Per-CPU architect. states

Instruction Pointers (IP)

Renaming Logic

ITLB/Return Stack

Predictor


Prozessor

Multicore-CPUs

Multicore-Prozessoren vereinen

im Prinzip die Vorteile

von SMP und SMT: viele Prozessorressourcen,

gebündelt auf

möglichst kleiner Chipfläche.

Im Gegensatz zu SMP sind nicht

mehr mehrere Sockel nötig,

selbst vier oder mehr Kerne lassen

sich platzsparend und einigermaßen

kühl auf einem handelsüblichen

Desktop-Board

betreiben.

Einschränkungen

Bei grafisch intensiven Anwendungen

wie 3D-Spielen kann es

jedoch durchaus vorkommen,

dass die Performance eines

Computers sinkt, je mehr Prozessoren

man hinzufügt. Der

Grund liegt schlicht an den

Konflikten und daraus resultierenden

Stillständen der Prozessoren,

so genannten stalls

(engl.: to stall = zum Stillstand

bringen, stillstehen). Je mehr

Prozessoren versuchen, simultan

zum Beispiel auf die PCI-Express-Grafikkarte

zuzugreifen,

desto mehr Rechenzeit wird

mit Stillstand vergeudet.

Speicher-Probleme

Der gleiche Effekt tritt auch

beim Arbeitsspeicher auf. Hierfür

existiert das sogenannte

Locking (to lock = sperren, am

Zugang hindern). Multiprozessor-Kernel

von Betriebssystemen

müssen grundsätzlich

einige zusätzliche Befehle implementieren,

die beispielsweise

den Arbeitsspeicher vor parallelen

Zugriffen schützen, um

die Datenkonsistenz zu wahren,

sprich: um Datensalat zu vermeiden.

Greift eine CPU in einem

SMP-System auf den Arbeitsspeicher

zu, so wird der Zugriff

auf diesen zunächst für alle

weiteren vorhandenen Prozessoren

gesperrt und dem wartenden

Prozessor der exklusive

Zugriff gewährt. Anschließend

muss der Arbeitsspeicher wieder

für alle Prozessoren freigegeben

werden.

Das Problem an diesem Prozedere

ist, dass der dabei entstehende

Overhead gigantisch ist.

Dieser Vorgang, der den ohnehin

schon ausbremsenden

Zugriff auf den Speicher noch

weiter verlangsamt, wirkt nicht

sonderlich leistungsfördernd.

Das Problematische an diesem

Locking ist die Tatsache, dass

nicht nur Single-threaded-Applications,

also Programme, die

nicht für den Betrieb auf mehreren

Prozessoren konzipiert

sind, dieses Locking verursachen,

sondern auch Multi-threaded-Applications.

Aus diesem

Grund kann die Rechnung

„Leistungszuwachs um den Faktor

der CPU-Anzahl“ in der Praxis

niemals aufgehen. Bei ausschließlichem

Einsatz von nicht

SMP-optimierter Software kann

ein Programm sogar langsamer

arbeiten als der gleiche Rechner

mit nur einer CPU.

Cache-Probleme

Ein weiteres Problem stellt die

Kohärenz der Inhalte der unterschiedlichen

Cache-Hierarchien

dar. Cache-Kohärenz bedeutet

die Wahrung der Gültigkeit

der Inhalte der Caches. Wird

beispielsweise ein Wert aus

dem Arbeitsspeicher von beiden

Prozessoren in den jeweils

eigenen Cache geladen und

von einem der Prozessoren anschließend

(verändert) wieder

zurückgeschrieben, muss der

zweite Prozessor von diesem

Vorgang etwas mitbekommen,

um seine eigenen Caches entsprechend

zu aktualisieren.

Alle aktuellen CPUs kommunizieren über separate Links (hier: QPI beim

Nehalem) mit der Infrastruktur sowie anderen CPUs im System.

In traditionellen SMP-Systemen kommunizierten

die CPUs untereinander via Hyper Transport

(AMD) oder einen gemeinsamen Bus (Intel).

Warum viele Kerne bremsen

Ist der Programmcode an einer Stelle nicht parallelisierbar, helfen auch

Dutzende von Prozessoren kaum weiter. Selbst bei 95-prozentiger Parallelisierbarkeit

erreicht man mit acht Kernen nur einen Geschwindigkeitszuwachs

von rund 500 Prozent. Aktuelle Quadcore-CPUs scheinen

hier am Scheitelpunkt angekommen zu sein, denn auch die Kurve

gut parallelisierbaren Programmcodes flacht oberhalb von vier Kernen

spürbar ab. Diese Gesetzmäßigkeit formulierte Computerarchitekt

Gene Amdahl bereits 1967 – sie ist heute aktueller denn je.

Theoretisch mögliche Gewinne durch zusätzliche Prozessoren

Geschwindigkeitszuwachs

20

18

16

14

12

10

8

6

4

2

0

1

Parallelisierbarer Code-Anteil

n 50 % n 75 % n 90 % n 95 %

2

4

8

16

32

64

Anzahl der Prozessoren/Kerne

128

256

512

1.024

2.048

4.096

8.192

16.384

32.768

65.536

Bild: Intel


Prozessor

Welche Bedeutung das

M(O)ESI-Cacheprotokoll hat

Das MESI-Protokoll sorgt dafür, dass Daten im Arbeitsspeicher konsistent

bleiben – andernfalls könnte es passieren, dass Prozessor 1

Daten liest, verrechnet und erneuert, während Prozessor 2 mit den

alten, falschen Daten weiterrechnet. Dabei werden folgende Zustände

unterschieden.

Modified

Der Inhalt im Arbeitsspeicher wurde seit dem Spiegeln in den lokalen

Prozessorcache modifiziert und stimmt somit nicht mehr überein.

Exclusive

Der Inhalt im Arbeitsspeicher stimmt noch mit dem gespiegelten Inhalt

im Cache überein. Die Cache-Line befindet sich nur im Cache eines

einzelnen Prozessors.

Shared

Wie Exclusive – mit dem Unterschied, dass sich die Cache-Line in

mehreren Caches befindet. Bei Aktualisierung der ursprünglichen Daten

im Arbeitsspeicher werden alle Caches auf den neuesten Stand

gebracht.

Invalid

Der Inhalt im Prozessorcache ist ungültig, ein Zugriff erzeugt einen

Cache-Miss. Die Daten müssen neu aus dem RAM geladen werden.

Owner

Ähnlich wie Modified mit dem Unterschied, dass es nicht nur eine, sondern

mehrere Cache-Kopien gibt, die aktualisiert werden müssen.

Wie die NUMA-Architektur

aufgebaut ist

Seit der Nehalem-Generation hat Intel mehrstufige NUMA-Strukturen

bis hinab zu SMT integriert, um die Lokalität von Daten optimal nutzen

zu können.

System

NUMA Node 0 NUMA Node 1

Sockel 0 Sockel 1 Sockel 0 Sockel 1

Domain

Gruppe

CPU

NUMA-

Domaine

SMP-

Domainen

HT-

Domainen

SMP-Systeme haben hierfür

ein sogenanntes Cache-Kohärenz-Protokoll,

welches für die

Korrektheit der Daten sorgt.

Das traditionelle Protokoll dafür

ist das sogenannte MESI-Protokoll.

Jeder der Buchstaben steht

hierbei für einen bestimmten

Zustand einer Cache-Line (siehe

Extrakasten links). Die Erhaltung

der Korrektheit der Daten

kostet jedoch ein klein wenig

Performance, was je nach Umsetzung

des Protokolls unterschiedlich

gravierend ausfallen

kann.

Cache-Protokolle

Eine Erweiterung des ME-

SI-Protokolls stellt das MOE-

SI-Protokoll dar. Es ist zum ME-

SI-Protokoll voll kompatibel,

kennt jedoch den zusätzlichen

Status „Owner“. Dieser zeigt,

in welchem Cache welches

Prozessors sich die Daten befinden.

Somit können andere

Prozessoren diese bei Bedarf

aus dem Cache anfordern und

sparen sich den Hauptspeicherzugriff.

MOESI-Funktion

im Detail

Hierbei passiert Folgendes:

Stellt CPU 1 einen Read-Request

auf einen bestimmten

Speicherbereich, so wird dieser

in der Regel direkt aus dem Arbeitsspeicher

in den Cache der

CPU geladen. Merkt die interne

Logik jedoch, dass eine weitere

CPU genau diesen Speicherbereich

bereits im Cache hat,

so wird der Read-Request vom

langsamen Arbeitsspeicher auf

den schnellen Cache der betreffenden

CPU umgeleitet.

Somit werden massiv Taktzyklen

eingespart, die beim Zugriff

auf den im Vergleich zum Cache

um den Faktor 100 langsameren

Arbeitsspeicher mit Nichtstun

verbracht worden wären.

Weiterhin profitiert auch der

Speicherbus von dieser Taktik,

da weniger Zugriffe auf den

Speicherbus stattfinden und er

somit für andere Aufgaben verfügbar

ist.

ccNUMA

Was bei zwei Kernen bzw. Prozessoren

noch überschaubar

erscheint, gerät bei acht Kernen

bzw. Prozessoren zu einem

aufwendigen und bremsenden

Durcheinander. Ab einer

gewissen Komplexität ist das

System hauptsächlich damit beschäftigt,

auf Cache-Abgleiche

zu warten. Ein Ausweg ist das

ccNUMA-Modell, in dem es

einerseits für das Betriebssystem

zwar einen gemeinsamen

Speicherbereich gibt, andererseits

aber versucht wird, Daten

möglichst lokal an einem Node

zu halten, um Node-Hops zu minimieren

und Kohärenz-Overhead

damit schon im Keim zu

ersticken.

Software

Vor allem aber sind die Software-Entwickler

gefragt. Diese

müssen die Programmstrukturen

so gestalten, dass entweder

mehrere Threads oder Prozesse

unabhängig voneinander

arbeiten – wie es zum Beispiel

bei den BOINC-Distribu ted-

Computing-Projekten der Fall

ist, wo auf einem n-Kern-System

einfach n Prozesse gestartet

werden, die an n verschiedenen

Datensätzen arbeiten. Effektiv

arbeitet auch der Cinebench,

wo an einem Datensatz gerechnet

wird, der in n Teile zerlegt

wird, die unabhängig berechnet

werden können. Nur so lässt

sich das „Zuständigkeitsgerangel“

unter den Prozessoren und

Caches zuverlässig vermeiden.


Prozessor

Ob MMX, 3DNow oder

SSE; all diese Begriffe,

die aus dem Wortschatz

eines PC-Enthusiasten

nicht mehr wegzudenken sind,

haben eines gemeinsam: Es sind

Versuche der Prozessorhersteller,

die Unzulänglichkeiten der

ursprünglichen x86-Architektur

zu lindern.

Architektur-Defizite

Im Gegensatz etwa zu den

CPUs der Amiga-Rechner in

den 80er-Jahren waren der Intel

8086 und seine Nachfolger

nie dafür gedacht, 3D-Spiele auf

den Bildschirm zu zaubern oder

wie die Apple- bzw. Alpha-Prozessoren

komplexe Grafikberechnungen

in Echtzeit durchzuführen

und mit Vektoren im

dreidimensionalen Raum zu

hantieren.

Dass es im Endeffekt anders

gekommen ist, verdankt der PC

vor allem seiner weiten Verbreitung,

findigen Programmierern,

die es verstanden haben, mit

intelligenter Programmierung

beispielsweise auch Rennsimulationen

286-tauglich zu

machen, sowie etlichen Hardware-Entwicklungen

in diese

Richtung (3D-Add-on-Karten,

MPEG-Karten, etc).

Aufgrund seiner nur bedingt

tauglichen Konzeption suchten

die Ingenieure bei Intel und

AMD früh nach einer Möglichkeit,

dem PC-Prozessor weitere

Features mit auf den Weg zu geben,

ohne jedoch zu bestehender

Hard- und Software inkompatibel

zu werden.

So funktionieren

x86-Erweiterungen

MMX

Den Anfang machte Intel

1996 mit dem Pentium MMX.

Die MMX-Unit war die erste

SIMD-Einheit in einem x86-Prozessor.

Dieses Rechenwerk kann

mit einer Instruktion mehrere

Daten miteinander verarbeiten

(SIMD = Single Instruction,

Multiple Data). Dazu spendierte

man der CPU acht zusätzliche

Register namens MM0 bis MM7,

welche den neuen Datentyp

„Packed“ aufnehmen konnten.

Diese Register konnte man nun

mit verschiedenen Packed-Varianten

füllen. Zwei 32-Bit-Zahlen,

vier 16-Bit-Zahlen oder acht

8-Bit-Zahlen. Addiert man nun

beispielsweise MM0 mit MM1

(oder führt eine beliebige Rechenoperation

aus), so hat man

mit einer Instruktion im Idealfall

acht Zahlen miteinander

verrechnet statt nur eine mit

dem herkömmlichen Design.

3DNow und SSE

Bald jedoch stellte sich heraus,

dass SIMD zwar eine gute Idee

war, MMX im Speziellen sie

aber am Thema vorbei in die

Praxis umsetzte. Die MMX-Unit

war eine reine Ganzzahl-Einheit

und ließ damit die nötige Genauigkeit

bei Koordinaten- und

Grafikberechnungen vermissen.

Es musste eine Einheit her,

die auch Fließkomma-Berechnungen

anstellen konnte.

Das Ergebnis waren 3DNow

(AMD) und SSE (Intel); SSE hieß

zunächst noch KNI – als Abkürzung

für „Katmai New Instructions“.

Bis heute werden die

Befehlssatz-Erweiterungen neuer

CPUs bei Intel nach diesem

Schema abgekürzt. Die jüngst

erschiene Haswell-Architektur

Die erste Befehlssatz-Erweiterung in der x86-Welt brachte Intels

Pentium MMX – bis heute weiß niemand, wofür MMX eigentlich steht,

für „Multimedia Extensions“ jedenfalls nicht, wie Intel stets bekräftigte.

Ein aktueller

Prozessor verfügt

über ein

gutes Dutzend

Erweiterungen

des ursprünglichen

Befehlssatzes.

Je

besser diese

genutzt werden,

desto größer der

Leistungs gewinn.

Eine Erweiterung des Befehlssatzes gehört mittlerweile zu jeder neuen

CPU-Generation. Auch in Zukunft plant Intel neue „Extensions“.

Bild: Intel


Prozessor

Bild: Intel

Wie SSE-Register

aufgebaut sind

SSE erhöht die Rechenleistung drastisch: Die zusätzlichen Register

sind „breiter“, was bedeutet, dass sie mehr Bits aufnehmen und verarbeiten

können. So können entweder sehr große/lange Zahlen (beispielsweise

mit vielen Nachkommastellen) oder mehrere kurze Zahlen

in einem Schritt verrechnet werden.

SSE-Register

Mit SSE ist es möglich, bis zu 16 8-Bit-Zahlen in einem Aufwasch miteinander

zu verrechnen.

127 63 0

0 5 0 2 6 1 6 0 9 0 4 7 8 2 1 7

+ +

9 1 2 6 1 5 0 6 0 7 1 0 1 7 1 1

9 6 2 8 7 6 6 6 9 7 5 7 9 9 2 8

SSE-2-Register

Entscheidende Innovation von SSE 2 war die Verarbeitung von

64-Bit-Double-Precision-Floatzahlen.

addpd, xmm1, xmm2

127 63 0

- 0.3 7.2 xmm1

+

- 1.2 2.1 xmm2

=

- 1.5 9.3 xmm1

xmm1

n Quell-/Ziel-Register

n Quelle 2

n Überschriebenes

Register

xmm2

xmm1

SSE-4.2-Befehle adressierten vor allem die Stringverarbeitung. Sofern

der Programmierer bzw. Compiler sie nutzt, beschleunigen diese das

Parsing von zum Beispiel XML-Dateien drastisch.

bringt beispielsweise die Erweiterung

HSI mit („Haswell New

Instructions“).

SSE hatte den Vorteil, auf einen

Satz von 128 Bit breiten

Datenregistern zurückgreifen

zu können, während 3DNow

auf 64-Bit-Größe beschränkt

war. Damit konnte man bei SSE

zum Beispiel vier Single-Precision-Floatzahlen

gleichzeitig verrechnen,

während mit 3DNow

nur zwei möglich waren. Unter

anderem deshalb hat sich SSE

letztlich durchgesetzt.

Erweiterung SSE 2

Mit SSE kam die Entwicklung

von Befehlssatz-Erweiterungen

erst richtig in Schwung.

Mit dem Pentium 4 führte Intel

den Nachfolger SSE 2 ein.

SSE 2 ermöglichte es nun auch,

Doule-Precision-Floatzahlen,

also Fließkommazahlen mit

64-Bit-Genauigkeit, zu berechnen,

während SSE und 3DNow

hier auf 32-Bit-Zahlen beschränkt

waren. Bei der Verdoppelung

der Datenregister-Breite

blieb es jedoch nicht. Zusätzlich

spendierte Intel 144 neue Befehle,

was die Mächtigkeit und

die Bandbreite an möglichen

Einsatzgebieten deutlich erhöhte.

Gerade was die Berechnung

von Videomaterial betrifft, bietet

SSE 2 dem Programmierer einige

Werkzeuge „in Hardware“

an, die entweder das Encoding

beschleunigen können oder

die Wiedergabe mit niedrigerer

CPU-Last möglich machen.

Die Nachfolger:

SSE 3, SSSE 3, SSE 4

Deutlich weniger spektakulär

war die Einführung des

SSE-3-Befehlssatzes, einer erneuten

Erweiterung der SSE-Basis.

SSE 3 erweiterte den SSE

2-Befehlssatz um zusätzliche

13 Instruktionen zur Wandlung

von Gleitpunktzahlen

in Ganzzahlen, für komplexe

Arithmetik, zur Video-Kodierung,

zur Unterstützung der

Grafik-Aufbereitung und zur

Thread-Kommunikation bei

den Intel-Hyper-Threading-Prozessoren.

Erstmals zum Einsatz

kam SSE 3 beim Intel Pentium 4

Prescott (PNI: Prescott New Instructions).

SSSE 3 (Supplemental

Streaming SIMD Extensions

3) bezeichnet die mit Intels

Core-Architektur eingeführten

Erweiterungen des SSE-3-Befehlssatzes.

Während SSSE 3 mit 32 neuen

Befehlen nur eine geringfügige

Erweiterung zu SSE 3 darstellt,

ist SSE 4 mit 50 neuen

Opcodes eine substanzielle Verbesserung.

SSE 4 wurde mit den

45-nm-Prozessoren beginnend

ab dem Penryn eingesetzt. SSE 4

besteht aus zwei „Subsets“, nämlich

SSE 4.1 (ab Penryn) und SSE

4.2 (ab Nehalem). SSE 4a dagegen

ist eine AMD-spezifische

Erweiterung, die ab dem Barcelona-Kern

zum Einsatz kommt.

AES, AVX und AVX 2

Intels i5-Modelle auf Clarkdale-Basis,

die Gulftown-Sechskerner

und alle i5-/i7-CPUs ab

der Sandy-Bridge-Architektur

beherrschen den „Advanced

Encryption Standard“ (AES) in

Hardware. Die Erweiterung umfasst

sieben Instruktionen, welche

kryptografische Operationen

beschleunigen. Truecrypt

unterstützt AES und kann im

Ideal fall bis zu viermal schneller

arbeiten. Meist limitieren

aber andere Komponenten,

etwa die Festplatte.

Statt SSE 5 hieß die nächste Befehlssatz-Erweiterung

bei Intel

AVX. Nach den „Streaming SIMD


Prozessor

Extensions“ kommen nun also

„Advanced Vector Extensions“

(AVX) zum Einsatz. Die neuen

Instruktionen verdoppeln die

Vektorgröße und Registerbreite

von 128 auf 256 Bit und erlauben

damit in der Theorie acht

32-Bit-Gleitkomma-Operationen

auf einmal oder alternativ

vier Operationen mit doppelter

Genauigkeit (64 Bit). AVX wurde

erstmals mit der Sandy-Bridge-Architektur

eingeführt. AVX

kann bei Microsoft erst mit

dem Betriebssystem Windows

7 ab SP1 oder höher genutzt

werden.

Die vorerst letzte Erweiterung

heißt AVX 2 und wurde mit

den Haswell-Prozessoren 2013

eingeführt. Die AVX-2-Befehle

ermöglichen unter anderem

schnellere, gezielte Manipulationen

und Abfragen von

einzelnen Bits in einem längeren

String. Intel verspricht die

Beschleunigung von diversen

Multimediaanwendungen, insbesondere

Spielen, Audio- und

Video-Bearbeitung.

FMA 4, FMA 3, XOP

Bei allen Erweiterungen hatte

AMD das Problem, mit seinen

x86-Prozessoren kompatibel

zu bleiben, gleichzeitig aber

auch Eigenentwicklungen unterzubringen.

So unterstützen

aktuelle AMD-CPUs nicht nur

SSE4.1, SSE4.2, AVX (Advanced

Vector Extensions) sowie hardwareseitig

AES; AMD legt noch

FMA4 und XOP obendrauf.

„Fused-Multiply-Add“ sorgt für

eine genauere und schnellere

Berechnung von Instruktionen,

dies ist für High-Performance-Computing

interessant, aber

auch Spiele können profitieren.

XOP ist aus AMDs geplanter,

aber letztlich erfolgloser

SSE-5-Implementierung entstanden

und bietet wie AVX

Befehle zur Beschleunigung

von Vektor-Operationen. Während

FMA 4 und XOP mit dem

Bulldozer debütierten, erhält

Piledriver FMA 3, welches die

Kompatibilität mit Intel-Prozessoren

sicherstellt. Die kleinere

Zahl („3“ statt „4“) hat ihre Ursache

in der Art der Befehlsverarbeitung

und nichts mit einer

Versionierung zu tun.

Befehlssatzerweiterungen

heute

Die Erweiterungen des ursprünglichen

x86-Befehlssatzes

sind eine Erfolgsstory. Mit jeder

neuen Version wurden Schwächen

und Unzulänglichkeiten

der ursprünglichen x86-Architektur

beseitigt. Zwar dauert es

jeweils einige Jahre, bis die Verbreitung

der CPUs so hoch ist,

dass sich die Entwickler trauen,

ihre Software entsprechend

zu compilieren; doch der Leistungsgewinn

ist hoch und so ist

zum Beispiel Far Cry 2 von 2007

schon lange nicht mehr das einzige

Spiel, welches SSE 2 zwingend

voraussetzt.

Abseits von x86

Außerhalb des x86-Universums

hören die Erweiterungen auf die

Namen Altivec, VMX, Velocity

Engine (Motorola-CPUs in den

alten Apple-Power-PCs) oder

VMX128 in IBMs Xenon-Power-

PC-CPU, in der Xbox 360 oder

dem IBM Cell in der Playstation

3. Altivec galt seinen Pendants

aus der Intelwelt lange Zeit als

deutlich überlegen. Bis zu acht

Datenpakete lassen sich hier

mit einer Instruktion verarbeiten.

Die Mächtigkeit des Befehlssatzes

galt als so hoch, dass

es schwierig war, den CPU-Kern

schnell genug mit Daten zu versorgen.

Mit synthetischen Benchmarks ist es möglich, den Einfluss von SIMD-

Befehlen auf die Leistung zu testen und zu vergleichen.

AMD

FMA4

MMX, SSE, SSE2,

SSE3, SSSE3,

SSE4, AVX, AES

FMA3, CLMUL

SSE4a

XOP

CVT16

AVX2

Intel

Transactional

Memory

RdRand

Mehr als ein Dutzend Erweiterungen des Befehlssatzes sind in aktuellen

Prozessoren implementiert. Leider sind nicht alle kompatibel, nur die

Schnittmenge (Bildmitte) wird sowohl von AMD als auch Intel unterstützt.

Befehlssatz-Erweiterungen werden nicht nur bei AMD und Intel verwendet

– auch IBM setzt beim Cell-Prozessor (Bild) auf spezielle Befehle.

Bild: IBM


Prozessor

Bild: Intel


So funktionieren

Grafik- und Spezialkerne

Von links nach rechts: Nehalem, Westmere und

Sandy Bridge. Gut zu sehen ist, wie der Grafikkern

(Westmere, Mitte) für eine „Streckung“ des

Dies bei Sandy Bridge sorgt.

Beim Haswell „ULT“ packt Intel einen Dualcore

samt GT3-Grafikkern (links) mit dem PCH (rechts)

auf ein Package, das komplette Multi Chip

Module (MCM) kommt auf 15 Watt TDP.

Intel Clarkdale: Der in 45-Nanometer-Technik

gefertigte Grafikkern

(links) ist deutlich größer als

die 32-nm-CPU (rechts).

Die Taktfrequenz-Barriere,

die bei etwa vier

bis fünf Gigahertz liegt,

zwang die CPU-Hersteller schon

zur Jahrtausendwende, über

alternative Wege zur Leistungssteigerung

nachzudenken.

Kern-Barriere

Nachdem die Steigerung der

CPU-Kerne ebenfalls an ihre

Grenzen stößt (siehe „Amdahl‘s

Law“), geht der Trend zu Spezialkernen

und der Integration

von (Mainboard-)Komponenten

in den Prozessor. Den Anfang

machte ein Grafikkern, der

bis dato nur in der Northbridge

mancher Mainboards zu finden

war. Eine solche integrierte

Grafik eignete sich in der Regel

nicht für anspruchsvolle Spiele,

ermöglichte aber zumindest das

Arbeiten mit Office-Programmen

ohne separate Grafikkarte.

Integrations-Stufen

Intels Clarkdale-Kern brachte

im Jahr 2010 erstmals einen

auf dem Prozessor integrierten

Grafikkern. Die Integration beschränkte

sich jedoch lediglich

darauf, dass CPU und GPU auf

einem gemeinsamen Trägersubstrat

untergebracht waren.

Nicht einmal der Herstellungsprozess

war identisch; während

der Prozessor schon im feineren

32-Nanometer-Prozess gefertigt

wurde, kam beim Grafikkern

noch das ältere 45-Nanometer-Verfahren

zum Einsatz – der

Grafikkern war daher auch flächenmäßig

deutlich größer als

der CPU-Doppelkern.

Neben den niedrigeren Herstellungskosten

war es vor allem

der gesunkende Energiebedarf,

der für den Einsatz eines solchen

Chips sprach. Dennoch

konnte sich Clarkdale nicht

recht durchsetzen, was vielleicht

auch an seinem früh vorgestellten

Nachfolger lag.

Die-Level-Integration

Bei der Sandy-Bridge-Architektur,

die ein Jahr später erschien,

war die Grafikeinheit bereits in

das CPU-Silizium integriert. Sie

kommuniziert per Ringbus-Controller

mit den CPU-Kernen

sowie dem gemeinsam genutzten

Last-Level-Cache und profitiert

sogar vom Turbo-Modus.

Neben abermals gesunkenen

Herstellungskosten war es vor

allem die deutliche Leistungssteigerung,

welche diese Form

der integrierten Grafik populär

machte. Mit Einschränkungen

waren sogar 3D-Spiele ruckelfrei

zockbar.

AMD verfolgte einen ähnlichen

Ansatz und packte den

Grafikkern zusammen mit den

CPU-Kernen auf ein gemeinsames

Siliziumplättchen („Die“).

Bei der „Fusion“-Architektur

(Kerne Llano, Bobcat und andere)

waren beide Teile des Chips

zunächst im 45-Nanometer-Verfahren

gefertigt, einen gemeinsamen

L3-Cache gab es aber

nicht – die Speicherzugriffe liefen

zunächst getrennt ab. Erst

mit den Folge-Architekturen

wurde auch ein gemeinsamer

Speicherzugriff ermöglicht.

GPU-Computing

Auch aus einem anderen Grund

ist ein integrierter Grafikkern

interessant: Dieser kann unter

Umständen wesentlich schneller

rechnen als ein allgemeiner

CPU-Kern. Die Idee hinter


Prozessor

„GPU-Computing“ und dessen

Schlagwortvorläufer GPGPU

(„General Purpose Computation

on Graphics Processing

Unit“) ist es, die vielen parallel

arbeitenden Rechenwerke in

modernen Grafikprozessoren

gewinnbringend auch außerhalb

der Grafikberechnung

einzusetzen. Aufgrund ihrer

großen Anzahl können sie bei

den entsprechenden Problemstellungen

wesentlich schneller

arbeiten als herkömmliche

Hauptprozessoren.

Erstmals sinnvoll möglich wurde

dieser Verwendungszeck mit

Direct-X-9-Chips und eine der

ersten verbreiteten Anwendungen

war der Folding@Home-Client

für AMDs X1000-Grafikchips.

Mittlerweile gibt es eine

ganze Reihe von Anwendungen,

welche die Ausführungseinheiten

(„Execution Units“)

eines Grafikchips nutzen können,

darunter unter anderem

Photoshop.

Parallele Nutzung

Den Grafikkern gibt es bei fast

jedem aktuellen Prozessor praktisch

zum Nulltarif dazu. Da

somit viele PCs über zwei Grafikbausteine

verfügen, liegt es

nahe, diese auch gemeinsam zu

nutzen, zum Beispiel um mehrere

Monitore an einem Rechner

zu betreiben.

Lucids Virtu-Technik geht dabei

noch einen Schritt weiter:

Bei den unterstützten CPUs

werden die Aufgaben so verteilt,

dass nur die aufwendigen

Berechnungen von der (energiehungrigen)

externen Grafikkarte

vorgenommen werden

– alle übrigen übernimmt der

vergleichsweise sparsame Grafikkern

im Prozessor, was die

Leistungsaufnahme senkt.

Verschmelzung

der Kerne

Die Grafikintegration hat jedoch

weitaus mehr Potenzial.

AMD beispielsweise strebt eine

heterogene Architektur an,

in der CPU- und GPU-Befehle

gleichsam gemischt werden.

Ein entsprechend compilierter

Quellcode soll die Ausführungseinheiten

optimal ausnutzen,

was die Geschwindigkeit in Extremfällen

um den Faktor zehn

erhöhen könnte. Schon 2014

will AMD entsprechende Produkte

auf den Markt bringen.

Spezialkerne

Die Verschmelzung von CPU

und GPU ist jedoch nur ein

erster Schritt. AMD und Intel

arbeiten daran, weitere Spezialfunktionen

und -kerne zu

integrieren. Anfang 2012 wurden

Gerüchte laut, nach denen

AMD einen ARM-Kern in

manche seiner kommenden

Prozessoren einbauen könnte;

eine solche heterogene Systemarchitektur

(HSA) soll dann die

Stärken komplett unterschiedlicher

Rechnerarchitekturen

miteinander vereinen. Generell

scheint der Trend zum „System

on a chip“ zu gehen, wobei Prozessorbauteile

und -kerne gezielt

für bestimmte Aufgaben

zusammengestellt und produziert

werden.

Grafikeinheit

Integration des Grafikkerns bei Westmere (links) und Sandy Bridge

(rechts): Die Grafikeinheit ist nun integraler Bestandteil des Dies.

Theoretische Rechenleistung im Überblick

SP-GFLOPS gesockelter CPUs oder Chipsätze

700

GFLOPS (Single-Precision)

600

500

400

300

200

100

0

n AMD (GFLOPS)

n Intel (GFLOPS)

2005

Radeon

X1950 XTX

Radeon

HD 3870

Radeon

HD 5670

2006 2007 2008 2009 2010 2011 2012 2013

Bemerkungen: Ausgehend von den Xpress- sowie HD-Grafikeinheiten in älteren Southbridges legte AMD erst

seit 2011 mit den APUs an Rechenleistung zu. Intels frühe GMA-Versuche sind schwachbrüstig, seit 2011 gibt der

Hersteller ebenfalls Gas. Die Iris Pro 5200 (832 GFLOPS) fehlt, da es diese nur in AIOs und Notebooks gibt.

Kern Kern Kern Kern

Gemeinsamer L3-Cache

Memory Controller

Bild: Intel

System

Agent,

Display

Engine &

Speicher-

Controller



Prozessor

Bild: Intel

Wie der Turbomodus

Anwendungen beschleunigt

Ein Intel-Schaubild verdeutlicht die Funktionsweise von „Turbo Boost“.

In der oberen Reihe ist ein Prozessor dargestellt, der ohne Turbo

auskommen muss. Egal ob ein, zwei oder vier Kerne ausgelastet sind

(blaue Säule), die maximale Taktfrequenz ändert sich nicht.

Anders in der unteren Reihe: Hier wird je nach Auslastung eine oder

mehrere Multiplikatorstufen draufgepackt, hier dargestellt durch ein

orangefarbenes Quadrat. Wird nur ein Kern genutzt, darf dieser bei

diesem Prozessormodell um vier Multiplikatorstufen höher getaktet

werden. Sind alle vier Kerne aktiv, dürfen es immerhin noch zwei Multiplikatorstufen

sein (einer Stufe entsprechen meist 133 MHz, die genaue

Zahl der Stufen variiert je nach Prozessormodell).

AMD brachte 2010 „Turbo Core“ erstmals mit dem Phenom II X6 und

Thuban-Kern. Der Modus wird immer dann aktiv, wenn drei oder mehr

Kerne ruhen. Voraussetzung ist ein aktuelles BIOS.

So funktioniert

der Turbomodus

Der Turbomodus erschien

unter dem Namen

„Turbo Boost“

erstmals 2008, zusammen mit

den Intel-Prozessoren der Nehalem-Generation.

Zu Beginn

verwendete Intel auch die Bezeichnung

„Dynamic Speed

Technology“. AMD integrierte

wenig später eine ähnlich Funktion

in seine Prozessoren, die

dort „Turbo Core“ heißt.

Turbomodi

In der grundsätzlichen Funktionsweise

sind beide Techniken

gleich: Bei Bedarf können

die Prozessoren selbsttätig die

Frequenz einzelner Kerne steigern.

Salopp gesagt, übertaktet

der Prozessor einzelne Kerne

so weit wie es die Kühlung hergibt.

Als Grenze dient hier die thermische

Verlustleistung, kurz:

TDP. Solange der Chip innerhalb

dieses Thermalbudgets

bleibt, darf er etwas schneller

arbeiten; sind etwa nur zwei

von vier Kernen beschäftigt,

legt der Taktgeber für diese

noch ein paar Megahertz drauf.

Dies geschieht über die Regulierung

des Multiplikators,

der gemeinsam mit dem Referenztakt

von üblicherweise 133

MHz den Kerntakt ergibt; bei

einem Core i7-920 beispielsweise

kann der Multiplikator

von 20 auf 21 oder gar 22 steigen,

der Kerntakt damit von

2,67 also auf 2,93 GHz. Je nach

CPU-Modell kann der Takt aber

abweichen.

Turbo in der Praxis

Die sogenannte „Power Control

Unit“, kurz PCU, überwacht in

Echtzeit mithilfe der Temperatursensoren

und der Spannungswandler,

wie viel Strom

die CPU gerade zieht – der Uncore-Bereich

bleibt hierbei jedoch

außen vor.

Die TDP ist nicht nur abhängig

von der CPU-Auslastung, dem

Takt und den Spannungen der

einzelnen Kerne, sondern auch

von deren Temperatur. Wird

die TDP überschritten – etwa

durch (zu) hohe Temperaturen

oder Spannungen –, drosselt

die CPU wieder ihren Takt.

AMDs „Turbocore“ geht unabhängig

von der TDP und der

Temperatur zu Werke: Werden

maximal drei Kerne belastet,

legt beispielsweise ein Phenom

II X6 1055T gleich 500 MHz

obendrauf und taktet mit 3,30

GHz. Hierbei ist egal, ob einer

oder drei Kerne belastet wird.

Es werden immer gleich drei

Kerne mit mehr Spannung versorgt

und hochgetaktet, Intels

„Turboboost“ geht hier differenzierter

zu Werke. So etwas wie

eine PCU gibt es bei AMD nicht

– dies zieht zwei Konsequenzen

nach sich: Die Leistungsaufnahme

steigt teils stark an, dafür

gibt die CPU aber auch immer

Volldampf.

Mit neueren Prozessorgenerationen

kamen in den vergangenen

Jahren auch einige

Nachbesserungen oder neue

Funktionen. Seit der Sandy-Bridge-Generation

verfügen

Intel-Prozessoren über „Turbo

Boost 2.0“, welches es nun auch

erlaubt, den Grafikkern zu übertakten.

Außerdem dürfen nun

auch alle Kerne gleichzeitig höher

getaktet werden.


Grafikkarten


Grafikkarte

Die Grafikchips aktueller

Grafikkarten sind

so leistungsfähig, dass

sie nicht mehr nur für

Spiele eingesetzt werden,

sondern immer häufiger

auch für Anwendungen.

Aktuelle High-End-

Grafikkarten sind vor

allem auf schnellen Speicher

ange wiesen; üblich

sind zwei Gi Byte GDDR5-

Speicher mit bis zu drei

GHz Taktfrequenz.

So funktioniert

eine Grafikkarte

Die Grafikkarte ist der

bestimmende Bestandteil

moderner PCs,

wenn es um die Leistungsfähigkeit

für aktuelle 3D-Spiele geht.

Doch wie funktioniert dieses

komplizierte Stück Technik

und was ist die Aufgabe von

Jedi-Geheimeinheiten wie den

ROPs oder der Polymorph-Engine?

Grafikkarten – viel

drauf

Die zweifellos wichtigste Komponente

einer Grafikkarte ist

der Grafikprozessor, auch als

Grafikchip oder kurz GPU, analog

zur CPU, bezeichnet. Dieser

übernimmt sämtliche Berechnungen,

die für die Grafikausgabe

notwendig sind. Unterstützt

wird er von diversen anderen

Bauteilen wie der Platine selbst,

den Spannungswandlern samt

Stromzufuhr und natürlich

dem Grafik- oder auch Videospeicher

(V-RAM). Für eine verständliche

Erklärung der Grafikchip-Funktionen

müssen wir

auch darüber zunächst einige

Worte verlieren.

Die Platine der

Grafikkarte

Das sogenannte Printed Circuit

Board („PCB“), also die Platine,

in der die Leiterbahnen eingelassen

sind, stellt das Mainboard

der Grafikkarte dar. Hierüber

findet der komplette Datenverkehr

ebenso statt wie die Erzeugung

und Regulierung der benötigten

Spannungen für Chip

und Speicher, die Ansteuerung

der Monitoranschlüsse sowie

die Verbindung mehrerer Grafikchips

für SLI- oder Crossfire-Systeme.

Je schneller und damit meist

auch stromhungriger eine Grafikkarte

ist, desto komplizierter

und damit auch teurer fällt

das PCB der Karte aus. Die bis

zu 512 Datenleitungen, mit denen

der Speicher an den Grafikprozessor

angebunden ist, sind

in mehreren Lagen innerhalb

des PCB untergebracht, sodass

High-End-Modelle mitunter 12-

oder gar 14-schichtige Platinen

benötigen, was wiederum die

Kosten bei der Produktion in

die Höhe treibt.

Unter Spannung

Ähnliches wie für das Board

selbst gilt auch für die Spannungsversorgung

bzw. die

VRMs, was im Englischen

für „Voltage Regulator Modules“

steht. Die VRMs wandeln

die Zufuhr aus den 3,3- und

12-Volt-Leitungen des Netzteils

in die nötigen Spannungen um

und werden aus dem PCI-Express-Steckplatz

selbst gespeist,

über den 3,3 und 12 Volt mit insgesamt

maximal 75 Watt laufen.

Zusätzlich gibt es direkte Anschlüsse

an das Netzteil. Die

sechsadrige Variante liefert dabei

ebenfalls 75 Watt; befinden

sich acht Kabel am Steckerschuh,

sind bis zu 150 weitere

Watt möglich. Die Anzahl der

Stromanschlüsse lässt auf den

ungefähren Stromhunger der

Grafikkarte schließen:

z Bis 75 Watt (kein Extrakabel)

z 75 - 150 Watt (1x 6-Pol)

z 150 - 225 Watt

(2x 6- oder 1x 8-Pol)

z 225 - 300 Watt

(1x 6- und 1x 8-Pol)


Grafikkarte

Je leistungsfähiger der Grafikchip,

desto wichtiger ist eine

gute, das heißt möglichst störungsfreie

Versorgung mit der

von ihm benötigten Spannung.

Diese liegt für aktuelle Grafikchips

in der Regel bei 0,9 bis

1,15 Volt und muss zum Teil

sehr schnell hin- und hergeschaltet

werden, wenn der Grafikchip

zwischen den verschiedenen

Stromsparmodi hin- und

herwechselt.

Auch die hohen Stromstärken

von zum Teil über 100 Ampere

müssen in Sekundenbruchteilen

an die jeweils herrschenden

Lastzustände angepasst werden

können und dabei weite Bereiche

überbrücken. Nicht selten

sind vier- bis zehnphasig ausgelegte

VRMs nötig, spezielle

Übertakterkarten für Overclocking-Fans

setzen auf eine

noch höhere Anzahl an Phasen.

Das treibt direkt und indirekt

über zusätzlich nötige Platinenlänge

die Kosten in die

Höhe

Anschluss gesucht

Über den heute üblichen

PCI-Express-Anschluss gelangen

die Daten zur Grafikkarte.

Der üblicherweise mit 16

parallelen Leitungen verbundene

Grafikkartensteckplatz

(auch als PEG, „PCI-Express for

Graphics“, bezeichnet) kann

gleichzeitig Daten senden und

empfangen und pro Richtung

aktuell bis zu 8 GByte übertragen.

Stehen weniger pa rallele Bahnen

(engl. „Lanes“) zur Verfügung,

sinkt die Transferrate

entsprechend – allerdings reagieren

nur die wenigsten Spiele

mit deutlichen Fps-Verlusten

auf einen Betrieb mit beispielsweise

acht PCI-E-Lanes.

Video-RAM

Im Grafikspeicher werden

(nach Möglichkeit) sämtliche

Daten zwischengelagert,

die zur Anzeige des Bildes nötig

sind. Zwar befinden sich

schnelle Zwischenspeicher

direkt im Grafikprozessor, oft

genug jedoch muss auf Daten

aus dem Hauptspeicher der

Grafikkarte zurückgegriffen

werden.

Für diese Fälle wird der V-RAM

besonders bei High-End-Karten

so schnell wie möglich ausgelegt

und auch über viele parallele

Datenleitungen mit dem

Chip verbunden. Das wiederum

kostet Platz und damit

Geld – wie auch die Speicherchips

selbst. Aktuell sind folgende

Speicherstandards mit

den angegebenen Takt raten gebräuchlich:

z GDDR5 (bis ca. 3.500 MHz)

z GDDR3 (bis ca. 1.250 MHz)

z DDR3 (bis ca. 800 MHz)

z DDR2 (bis ca. 500 MHz)

GDDR4 kam zwischenzeitlich

auf einigen Radeon-Karten zum

Einsatz, konnte sich aber nicht

durchsetzen, da GDDR3-RAM

den Taktnachteil schnell eingeholt

hatte. Günstige Grafikkarten

nutzen oft DDR2- oder

DDR3-Speicher – kommt ein

solches Modell in die engere

Auswahl, achten Sie auf DDR3-

oder GDDR5-Bestückung.

Der Grafikchip

im Detail

Auf der folgenden Doppelseite

stellen wir exemplarisch die

Funktionsweise eines aktuellen

Grafikchips vor und beschreiben

anschaulich, welche

Bedeutung die jeweiligen

Baugruppen für die einzelnen

Aufgaben in Spielen haben.

Worin sich Grafikchip und

Prozessor unterscheiden

Prozessoren werden grundsätzlich mit dem Ziel entwickelt, die unterschiedlichsten

Aufgaben möglichst schnell auszuführen. Die unzähligen

Erweiterungen des ursprünglichen x86-Befehlssatzes sind dafür

ebenso ein Instrument wie die enorm hohe Taktfrequenz von vier Gigahertz

und mehr.

Grafikkarten dagegen arbeiten vergleichsweise langsam – der Takt des

Chips beträgt „nur“ rund ein Gigahertz und die Einsatzgebiete sind eng

gesteckt. Dafür können mehrere hundert Rechenoperationen pro Takt

durchgeführt werden, während es bei Prozessoren gerade mal eine

Handvoll ist.

Grafikchips („GPUs“) und Prozessoren („CPUs“) werden manchmal

auch mit Flugzeugen verglichen. Dabei sollen Prozessoren schnellen

Düsenjets entsprechen, die einen oder zwei Reisende blitzschnell an

einen anderen Ort bringen können. GPUs sind dagegen vergleichbar

mit Passagierflugzeugen, die deutlich länger für die gleiche Strecke

brauchen, dafür aber sehr viel mehr Passagiere gleichzeitig transportieren

können.

Control

Cache

Speicher

CPU

ALU

ALU

ALU

ALU

Speicher

GPU

Grafikkarten wie MSIs Hawk-Reihe

(im Bild: HD 5770 Hawk) verfügen für

besseres Overclocking-Potenzial über

zusätzliche Phasen der Spannungsversorgung.


Grafikkarte

Beispiel: Verarbeitung eines Tastendrucks

Wie eine Grafikkarte funktioniert

6

5

4

3

2

1

Speicher-Controller

ROP

Shader-Engine + Texture

Rasterizer

Triangle-Setup

Scheduler

Host-Interface

Schnittstelle zum System

(„Host-Interface“)

1

Kein noch so fortschrittlicher Grafikchip kann derzeit ohne

Vorarbeit ein Spiel berechnen. Sämtliche nötigen Daten,

seien es nun Informationen zum weiteren Spielablauf, die

der Hauptprozessor liefert, oder Textur- bzw. Geometriedaten

zur Darstellung auf dem Bildschirm, müssen durch

die Schnittstelle zum Wirtsystem, englisch auch „Host“

genannt. Über diese Schnittstelle kommt auch der vom

Grafikkartentreiber in Maschinensprache übersetzte Kommandostrom,

über den der Grafikkarte mitgeteilt wird, was

als Nächstes zu berechnen ist.

Darin enthalten sind zum Beispiel auch Shader-Programme

für die Pixelbeleuchtung oder Animationsberechnung.

Zurzeit findet die Kommunikation zwischen

Grafikchip und dem restlichen PC über die PCI-Express-2.0-Schnittstelle

statt. Bei voller Bestückung des

Steckplatzes mit 16 Datenbahnen sind darüber 8 GByte

pro Sekunde und Übertragungsrichtung möglich. Zurzeit

stellt das Host-Interface keinen nennenswerten Flaschenhals

dar, solange das Datenaufkommen den Grafikspeicher

nicht überlastet.

PCI-Express

Der Vorarbeiter und Organisator („Scheduler“)

Das Steuerwerk des Chips. Hier werden die anstehenden Aufgaben verwaltet und den einzelnen

Ausführungseinheiten wie Shader-Kernen oder Textureinheiten zugeteilt. Da es bis zum fertigen

Pixel meist Dutzende, wenn nicht gar Hunderte von Arbeitsschritten sind, muss sich der Scheduler

auch darum kümmern, den Fortschritt der Aufgaben zu protokollieren und teilweise abgearbeitete

Befehlsketten neu in die Pipeline einzuspeisen. Das kann zum Beispiel passieren, wenn

im Rahmen eines Direct-X-11-Programms über Geometryshader oder Tessellation zusätzliche

Dreiecke erzeugt worden sind, die danach im Vertexshader-Programm animiert werden müssen

und schließlich von einem Pixelshader mit der endgültigen Farbe versehen werden. Je nach

Hardware fasst der Scheduler die pixelbasierten Aufgaben zu sogenannten Threads zusammen –

Gruppen von Instruktionen, die auf die Shader-, Textur- oder Rastereinheiten aufgeteilt werden. In

anderen Fällen bekommt er diese Gruppierung bereits vom Treiber aufbereitet serviert.

2


Grafikkarte

Shadereinheiten #1:

Seit der mit der Geforce 8800 GTX/S

eingeläuteten Direct-X-10-Generation

verfügen alle Grafikchips über einheitliche

Shader-Einheiten. Diese können, im Gegensatz

zu DX9- oder älteren Grafikkarten,

jede Art von Shaderprogramm ausführen –

unabhängig von Geometrie-, Vertex- oder

Pixelberechnungen. Der Vorteil liegt auf

der Hand: Der Chip ist flexibler, da immer

alle Einheiten beschäftigt werden können;

ob die Spielszene nun sehr dreiecks- oder

sehr pixellastig ist, spielt keine Rolle.

Im Rahmen der 3D-Berechnungen müssen

die Pixel in spe jetzt allerdings Runden

drehen und die Shadereinheiten mehrfach

durchlaufen. Zum Beispiel …

• für Geometryshader und Tessellation

• für den Vertexshader

• für den Pixelshader

4.1

Shader-Engine #2: Geometrie

Bevor die Pixel Pixel werden, haben sie schon einiges hinter sich. In einem ersten Schritt werden Vertikel eingelesen

und durch die Shadereinheiten im Rahmen der Vertex- und bei Direct X 11 der Hullshaderstufe berechnet

– dabei werden die Koordinaten der Vertikel in das System der 3D-Welt umgewandelt. Außerdem wird, falls

nötig, der Tessellationsfaktor bestimmt, also der Grad der Unterteilung in feinere Geometrie. Diese neuen Vertikel

kommen dann im Falle von Direct-X-11-Tessellation zu der vorgesehenen Hardware und werden dort dem zuvor

festgelegten Wert entsprechend verfeinert.

Als Nächstes werden die Domain- (bei DX11)

und Geometryshaderstufe ausge führt. In

Ersterer wird die endgültige Position jedes

Vertikels berechnet, die auf den Werten des

zuvor durchlaufenen Hullsha ders basiert. In

der Stufe des Geometryshaders wird dabei

Geometrie hinzugefügt oder entfernt – je

nach Vorgabe des Sha derprogramms. Danach

folgt die sogenannte Viewport-Transformation

und Perspektivenkorrektur zur

Darstellung in der 3D-Ansicht. Sollen weitere

Vertex-basierte Operationen ausgeführt

werden, so wird das Vertex-Gitter in einen

Zwischenspeicher geschrieben.

Ohne Tessellation

Mit Tessellation

4.2

Speichercontroller

Diese für die Leistung der Grafik karte

elementare Einheit ist meist in mehrere

Blöcke unterteilt. Sie sorgen dafür, dass

Textur- und Shadereinheiten möglichst

schnell mit Daten versorgt werden.

Eine der wichtigsten Aufgaben der einzelnen

Controller ist es, Speicherzugriffe so

zusammenzufassen, dass möglichst wenig

Verschnitt entsteht und die in der Regel

aus 64 parallelen Datenleitungen bestehende

Anbindung an die Speicherchips

effizient ausgelastet wird.

6

Setup und Rasterisierung

In dieser Stufe der Verarbeitung werden aus dem Vertikelgitter erstmals echte Vielecke, indem die einzelnen

Punkte untereinander verbunden werden. Das sogenannte Edge-Setup errechnet die Kanten der späteren

Polygone. Hier setzt auch die erste Effizienzmaßnahme an: Durch Backface-Culling werden alle Dreiecke aus der

Verarbeitung entfernt, deren Oberfläche vom Spieler weg zeigt und die deshalb nicht sichtbar wären. Der nächste

Schritt ist die Rasterisierung. Darunter versteht man das Erzeugen von Pixeln entsprechend der Bildschirmauflösung.

Der oder die Rasterizer rechnen aus den Kantengleichungen der Primitive nun die Entsprechung in Pixeln

innerhalb der Bildschirmauflösung aus – ist Kantenglättung (Multisampling) aktiv, wird der Bedeckungsfaktor

pro AA-Sample bestimmt, ansonsten einer pro Pixel. In der Regel arbeiten Rasterizer 16 Pixel pro Takt ab; im

Falle des GF10x sind es nur acht, dafür sind dort mehrere Einheiten parallel aktiv. Von hier aus geht es über die

Z-Culling-Einheit weiter. Diese übernimmt auf Pixelebene, was das Backface-Culling auf Dreiecksebene geleistet

hat: Die meisten Pixel, die im endgültigen Bild durch andere verdeckt und daher nicht sichtbar sind, werden von

der weiteren Verarbeitung ausgeschlossen.

3

Raster-Endstufen („ROPs“)

In die passend benannten Raster-Endstufen gelangen die Pixel bei heutigen

Spielen erst kurz vor dem Ende ihrer Reise in Richtung Bildschirm. Die auch

ROPs („Raster Operation Processor“) genannten Einheiten führen für die

Antialiasing-Leistung und bei Schattenberechnungen wichtige Tiefentests durch

und sind für das zum Beispiel bei Vegetationsdarstellung häufig genutzte Alpha-

Blending zuständig.

Ohne Kantenglättung

Mit Kantenglättung

5

Shader-Engine #3: Pixel

4.3

Endlich auf Ebene der Pixel angekommen, werden nun die Pixelshaderprogramme

über die Shadereinheiten ausgeführt. Die dabei zum Einsatz

kommenden Effekte sind vielfältig, zumeist aber mit irgendeiner Art von

Texturen verknüpft. Um die Bereitstellung der Pixel-Tapeten kümmern

sich die Textureinheiten, auch als TMU (vom englischen „Texture Mapping

Unit“) bekannt, die bei heutigen Grafikchips direkt an die Shader-Engines

angeschlossen sind. Bei Nvidias aktuellen GF104/106-Chips zum Beispiel

teilt sich jeder Block von 32 Shader-Einheiten acht TMUs – beim HD 5000

waren es noch 32:4. AMDs Cypress-, Juniper- und Redwood-Chips weisen

ein 20:1-Verhältnis auf, die kleineren Cedar-GPUs der Radeon HD 5450

eines von 10:1. Je mehr dieser Einheiten vorhanden sind und je effizienter

sie arbeiten, desto weniger lang müssen die Shader auf die benötigten

Werte warten, bevor sie weiterarbeiten können.

Kein AF

16:1 AF


Grafikkarte

Bild: Microsoft

Direct X 11.2 bringt Unterstützung

für Mega-Texturing, das größere und

schönere Texturen ermöglicht

Als eines der ersten Direct-X-11.1-

Spiele gilt Battlefield 4, das im Herbst

2013 erschienen ist.

So funktioniert

Direct 3D 11

Direct 3D 11 ist die bis

heute aktuelle Evolutionsstufe

der für Spieler

interessanten Windows-API.

Wir blicken auf die Techniken

im Einzelnen und erläutern diese

ausführlich.

Direct-X-Evolution

Mit Windows 95 gewann der PC

als Spieleplattform zunehmend

an Bedeutung; vorbei waren die

Jagd nach dem letzten Kilobyte

im „oberen Speicherbereich“,

der Kampf von QEMM und Konsorten

gegen den CD-ROM-Treiber

und die manuelle IRQ-Zuweisung

an die Soundkarte.

Mit Windows sollten Spiele

massentauglich werden. Auch

die aufkommende 3D-Beschleunigung

wollte Microsoft

neben einheitlicher Ansteuerung

von Joysticks, Soundkarten

und Netzwerkkonfiguration

in die Hände der dazu

geschaffenen API Direct X legen.

Das Mittel der Wahl war

Direct 3D – so nannte man den

Teil der API, welcher sich mit

der 3D-Beschleunigung beschäftigt.

Während insbesondere die ersten

vier Versionen noch wie

hilflose Gehversuche des Softwareriesen

auf ungewohntem

Terrain wirkten, wandelte sich

das Bild mit späteren Versionen.

Jede der folgenden Hauptversionen

von Direct X wurde durch

ein größeres Merkmal charakterisiert,

welches der API-Sammlung

hinzugefügt wurde:

z Direct X 6: Multi-Texturing

z Direct X 7: Hardware Transform

and Lighting

z Direct X 8: Pixel- und Vertexshader

1.x

z Direct X 9: Gleitkomma-Genauigkeit

und neue Shader-Versionen

z Direct X 10: Verheinheitlichung

der Shader-Programmierung,

neuer Geometrieshader

Hinzu kam, dass Direct X 10

sowohl mit der Abwärtskompatibilität

brach als auch ausschließlich

unter Windows Vista

verfügbar war. Was Microsoft

zunächst für einen cleveren

Schachzug gehalten haben mag,

um die Verkäufe des neuen

Betriebssys tems anzukurbeln

und Kosten zu sparen, entpuppte

sich im Nachhinein auch aufgrund

der relativ schwachen

Performance der ersten Direct-X-10-Grafikkarten

aus Mittel-

und Einsteigerklasse als

Flop.

Direct X 11 und die

Kompatibilität

Bei Direct 3D 11 ging der Redmonder

Software-Riese daher

anders vor. Die Schnittstelle

war auch unter Vista verfügbar,

nach wie vor aber nicht

für ältere Betriebssysteme wie

Windows XP. Dennoch wurden

mehrere Techlevels definiert,

mit deren Hilfe auch ältere

Hardware in den Genuss

ei niger der Verbesserungen

kommen kann. Andere Neuerungen

dagegen benötigten

zwingend passende Direct-X-11-

Hardware.

Direct X 11 war dank der oben

erwähnten Möglichkeit, Teile

der Fähigkeiten auch mit älterer

Hardware zu nutzen, für

Entwickler deutlich interessan-


Grafikkarte

ter. Denn während ein Spiel für

Direct X 9 und 10 mit separaten

Renderern ausgestattet werden

musste, die den Aufwand massiv

in die Höhe trieben, konnte

diese Arbeit nun entfallen. Bei

Direct X 11 genügt ein gemeinsames

Grundgerüst, welches

dann über verschiedene interne

Pfade die jeweiligen Hardware-

Generatio nen anspricht.

Direct 3D 11

Die 11er-Version der Direct-3D-

API enthält im Wesentlichen

fünf größere Merkmale, welche

sie von den früheren Versionen

abhebt:

z Compute-Shader

z Tessellation (samt Hullund

Domainshader)

z Verbessertes Multi-Threading

z Dynamic-Shader-Linking

z Erweiterte Texturkompression

Analog zu früheren Direct-X-Versionen

steht auch

für DX11 der Sprung auf eine

neue Stufe an: In der neuen API

wird das Shader-Modell 5.0 unterstützt,

während Direct X 10

noch 4.0 beziehungsweise 4.1

in DX10.1 mitbrachte.

Compute-Shader

Mit den Compute-Shadern folgte

Microsoft dem Trend, die

Rechenleistung der GPU auch

außerhalb typischer Spieleumgebungen

zu nutzen. Nvidia

und Ati hatten bereits zuvor

mit CUDA bzw. Ati Stream entsprechende

Lösungen angeboten

und auch das herstellerunabhängige

Open CL drängte in

diese Nische.

Die Compute-Shader liegen logisch

gesehen außerhalb der

normalen Bearbeitungsreihenfolge

für 3D-Anwendungen,

werden aber von den normalen

Shader-Einheiten berechnet,

da sich der vereinheitlichte

Shaderansatz auch in der tatsächlichen

Hardware durchgesetzt

hat. Compute-Shader sind

eines der Merkmale, für die

auch Versionen in den niedrigeren

Techlevels 4.0 und 4.1

vorgesehen sind. Damit können

auch ältere Radeon-Karten

der HD-4800/4600-Reihe sowie

DX10-fähige Geforce-Karten

auf eine Untermenge der Compute-Shader-Möglichkeiten

zugreifen.

Gemeinsamer

Speicher

Die GPGPU-Shader haben Zugriff

auf einen kleinen, lokalen

Speicher, der Thread Local Storage

(TLS) oder Shared Memory

genannt wird. Dieser erlaubt

den Datenaustausch zwischen

verschiedenen Berechnungen

(Threads) oder auch die gemeinsame

Nutzung der Daten

und kann so eine Menge Bandbreite

einsparen.

Einige Fullscreen-Effekte wie

Blur, Tiefenschärfe („Depth of

Field“) oder das beliebte Ambient

Occlusion („SSAO“) erfordern

oftmals, die Ausgangswerte

für anfallende Berechnungen

mehrfach anzufordern. Sind die

Texturcaches, welche zusätzlich

natürlich auch die entsprechenden

Texel aufnehmen müssen,

zu klein, fällt die x-fache

Bandbreite an.

Über einen Compute-Shader

kann der TLS die benötigten

Eingabewerte aufnehmen und

die Shader-ALUs versorgen,

ohne die Bandbreite für Texturen

oder Bildpuffer zu beeinträchtigen.

Ein Gauß’scher

Weichzeichner benötigt laut

AMD rund 16 Lese-/Schreibope-

CS-basierte Fast-Fourier-Transformation-Berechnungen

erzeugen bei

Direct X 11 das Height-Field für die

Darstellung des Ozeans.

Wie die Zerlegung (Tessellation)

bei DX11 funktioniert

Direct X 11 bringt erstmals die Möglichkeit, Objekte grafikkartenseitig

zu zerlegen. Dabei kommen so genannte Hull- und Domainshader zum

Einsatz, welche die Arbeit des fest verdrahteten Tesselators in die restliche

logische 3D-Pipeline integrieren.

Eingabewerte für den Hullshader:

Kontrollpunkte vom Vertexshader

Hullshader-Ausgabe

2: Kontrollpunkte des

neuen Drahtgitters und

Tessellationsfaktoren

Hullshader

Domainshader

Tesselator

Domainshader-Ausgabe: Ein tesseliertes Vertex

Tesselator-Ausgabe:

Dreieckskoordinaten

Hullshader-Ausgabe

1: Tessellationsfaktoren

pro

Dreieck

Domainshader-Eingabewerte: Koordinaten

für ein Vertex


Grafikkarte

rationen pro Pixel, während

dasselbe Programm als Compute-Shader

mit einem Viertel davon

auskommt.

Tessellation

Unter dem Begriff Tessellation

versteht man die Zerlegung eines

Körpers. Bereits die normalen

Dreiecke, mit denen die

3D-Pipeline arbeitet, sind also

eine Tessellation der geometrischen

Körper, mit denen Spieleentwickler

arbeiten.

Da neben Texturen und Bildpuffern

auch geometrische Informationen

den besonders in

Spielkonsolen wertvollen Speicherplatz

belegen, arbeitet man

bereits seit langer Zeit an einer

Möglichkeit, diese geometrischen

Informatio nen zu komprimieren.

Nichts anderes ist

die nach den Direct-X-8-Versuchen

mit RT- (Geforce 3) und

N-Patches (Radeon 8500) wiederentdeckte

GPU-Tessellation

in Direct X 11.

Stark vereinfacht gesagt, wird

dabei eine simple geometrische

Struktur zur Grafikkarte

übertragen. Erst dort findet die

Zerlegung in feinere Strukturen

über den vom Entwickler

festgelegten Tessellationsfaktor

statt. Im Vergleich zu einem auf

herkömmliche Weise erzeugten

Drahtgittermodell lässt sich die

benötigte Datenmenge je nach

Tessellationsstufe um den Faktor

sieben bis acht reduzieren.

Zudem sind durch die Einbeziehung

der Tiefenwerte auch dynamische,

aber einfach umzusetzende

Level-of-Detail-Systeme

möglich, die den geometrischen

Detailgrad elegant mit abnehmender

Entfernung zur Betrachterposition

ansteigen lassen.

Auch eine blickrichtungsabhängige

Tessellation ist möglich.

Die Silhouetten – also überall

dort, wo ein nach vorn gerichtetes

an ein nach hinten gerichtetes

Dreieck stößt – erhalten eine

höhere Tessellationsstufe als der

Rest des Körpers.

Tesselator, Hull- und

Domainshader

In der logischen 3D-Pipeline von

Direct X liegt die Tessellationseinheit

hinter dem Vertexshader

und arbeitet an sogenannten

Patches. Diese Felder bestehen

aus den Daten eines Dreiecks

und denen der direkt angrenzenden

Flächen. Der Tesselator

wird als konfigurierbare Fest-

Wie Tessellation eine bessere Bildqualität erzeugt

Seit Direct X 11 können Objekte, die von der CPU bereitgestellt werden, von der Grafikkarte in kleinere Objekte zerlegt werden, was die Detailgenauigkeit

drastisch erhöhen kann. Ein Beispiel soll das zeigen, der Zugewinn an geometrischem Detail mit höherer Tessellationsstufe (32) ist besonders deutlich am

Ohr sichtbar:

Objektrendering ohne Tessellation

In der Basisauflösung des Drahtgitters sind vergleichsweise wenige Polygone

zu sehen – einige Details fallen dadurch eckig und wenig realistisch aus.

Objektrendering mit Tessellation

Im Tessellationslevel 32 steigt die Detaildichte beachtlich an, auch die früheren

„Problemzonen“ sehen nun wesentlich realistischer aus.


Grafikkarte

funktionseinheit durch die frei

programmierbaren Hull- und

Domainshader unterstützt, welche

dem Tesselator vor- beziehungsweise

nachgelagert sind.

Der Hullshader berechnet die

zusätzlichen Kontrollpunkte

des Patches, wofür Daten der

benachbarten Dreiecke benötigt

werden. Das Rohmaterial

dafür erhält er aus der Vertexshader-Stufe

der Pipeline.

Zudem übergibt er die einzelnen

Tessellationsstufen, welche

er pro Patch errechnet hat,

an den Tesse lator. Dieser führt

die eigentliche Unterteilung

des Vertizes um den vorher bestimmten

Faktor (bis zu einem

Maximum von 64) durch und

reicht die Koordinaten an den

Domainshader weiter. Die so erzeugten

neuen Vertizes können

sowohl im festen Abstand zueinander

liegen als auch einzeln

festgelegt oder per Exponentialfunktion

bestimmt werden.

Der Domainshader schließlich

fügt aus den Daten des Tesselators

und den vom Hullshader

übergebenen Ausgabe-Kontrollpunkten

und Tessellationsstufen

die Daten für jedes einzelne

der neu erzeugten und versetzten

Vertizes zusammen. Die se

können dann wie bisher von

den restlichen Verarbeitungsstufen

genutzt werden.

Multithreading

Multithreading, also die Aufteilung

der Arbeit in mehrere parallele

Stränge, ist nichts Neues

– auch Direct X beherrscht diese

Funktion zur Nutzung multipler

Prozessorkerne bereits seit

geraumer Zeit. Allerdings widmete

sich Microsoft erst mit

Direct X 11 einer vernünftigen

Leistungsoptimierung, nachdem

klar wurde, dass die Leistungsfähigkeit

der Prozessoren

pro Kern nicht in dem Maße

wachsen würde wie in der Vergangenheit.

Der überarbeitete Ressourcen-Manager

erlaubt die gleichzeitige

Arbeit an Geometrie- und

Texturdaten von verschiedenen

Quellen. Sowohl das Anlegen

von Ressourcen wie Vertex-

oder Konstantenpuffern,

Texturen und Shadern als auch

das Laden in den Grafikkartenspeicher

können mit Direct X 11

unsynchronisiert ne ben dem eigentlichen

Rendering erfolgen.

Befehlsketten

Auch bisherige Performance-Bremsen

wie die sogenannten

Draw-Calls können mit

DX11 auf mehrere Kerne verteilt

und parallel vorbereitet

werden – im Extremfall kann

sogar jedes einzelne Objekt einen

eigenen Thread erhalten.

Dazu wird neben dem unmittelbaren

Render-Kontext eine variable

Zahl verzögerter, paralleler

Kontexte angelegt, in denen

die Kommandos nach Möglichkeit

bereits für die GPU umgewandelt

werden.

Im Idealfall braucht der unmittelbare

Kontext später nur noch

mit einem einzigen Kommando

die bereits fertige Befehlskette

auszuführen. Entwickler

müssen lediglich darauf achten,

dass für jeden Arbeitsstrang genug

zu tun ist, da das Anlegen

der Kontexte erst einmal zusätzliche

Arbeit bedeutet. Mit

anderen Worten: Erst muss ein

bisschen investiert werden, bevor

sich ein Effekt einstellt, und

besonders der Entwickler muss

dem neuen Multithreading bei

der Programmierung Rechnung

tragen. Das Direct-X-11-Multithreading

ist eine der Neuerun-

gen, welche auch mit älterer,

sogenannter „Downlevel“-Hardware

möglich ist. Ein geringer

Effekt ist bereits allein mit der

neuen Direct-X-Ver sion möglich,

sofern der Entwickler sein

Spiel entsprechend ausgelegt

hat. Den größeren Teil steuert

die Unterstützung dieser Funktion

im Grafikkartentreiber bei.

Orig

Orig

Orig

Orig

Absoluter Fehler

Texturkompression

für HDR-Formate

„High-Dynamic-Range“

Detaillierte gegenüber adaptiver Tessellation: Letztere (oben) konzentriert

den Dreieckseinsatz auf die Bereiche, wo die größten optischen

Vorteile entstehen.

BC3

BC7

BC3

BC7

Im Vergleich zum alten BC3- verspricht das BC7-Verfahren für Direct

X 11 eine wesentlich authentischere Wiedergabe des originalen

Texturinhaltes.

oder

hoher Kontrastumfang, wofür

das Kürzel HDR steht, beginnt

in der Echtzeit-Computergrafik

bereits bei einer Genauigkeit

von 16 Bit für jeden der vier Pixelbestandteile

Rot, Grün, Blau

und Alpha-Transparenz (RGBA).


Grafikkarte

Diese Formate verschlingen wesentlich

mehr Speicherplatz

und infolgedessen auch ein

Vielfaches an Bandbreite gegenüber

herkömmlichen 8-Bit-Integer-Formaten.

Zudem ist bei

vielen Berechnungen im Texturenbereich

für HDR-Formate

mehr als ein Taktzyklus fällig.

Doch HDR-Rendering ist

die Grundvoraussetzung für

eine realistische Beleuchtung

in Spielen, die durch den hohen

Kontrastumfang nicht auf billige,

fehleranfällige Tricksereien

angewiesen ist und wie aus einem

Guss wirken kann.

Block-Kompression

Textur- oder – wie es seit DX10

heißt – Block-Kompression soll

hier Abhilfe schaffen. Doch besonders

die großen HDR-Formate

wurden bis dato stiefmütterlich

behandelt. Mit BC6 und

BC7 hat Microsoft bei DX11

zwei neue Kompressionsverfahren

eingeführt, welche die

anfallende Datenmenge bei

16-Bit-Texturen auf ein Drittel

(BC6, 3-Komponenten-Texturen)

bis bestenfalls auf ein

Siebtel (BC7) zusammenstauchen.

Dabei nutzen beide Techniken

ein adaptives Verfahren,

welches für jeden Block mit 16

Pixeln Größe unterschiedlich

komprimieren kann. D3D11 definiert

zugunsten der Qualität

dabei bitgenau, wie stark die

komprimierte von der originalen

Textur abweichen darf.

Da für diese Funktionen Änderungen

an den Textureinheiten

nötig sind, ist BC6- und -7-Komprimierung

allein DX11-Hardware

vorbehalten. Die theoretisch

mögliche Emula tion über

die Shadereinheiten würde

sehr viel Rechenzeit verschlingen

und scheidet damit aus.

Direct X 11.1 und 11.2

Nach der Präsentation von Direct

X 11 im Jahr 2009 folgten

nur noch kleinere Optimierungen.

So brachte Direct X 11.1,

das mit Windows 8 erschien, einige

Detail-Verbesserungen, die

vor allem bei der Tessellation

ansetzen. Als eines der ersten

Spiele soll Battlefield 4 Direct X

11.1 nutzen. Zurzeit unterstützen

nur Radeon-Grafikkarten

das komplette Featureset von

Direct X 11.1, Nvidia-Chips sind

aber zumindest in weiten Teilen

DX11.1-kompatibel.

Mega-Texturing

Die vorerst letzte Ausbaustufe

Direct X 11.2 wird mit Windows

8.1 erscheinen. Eines der wichtigsten

Features, welches Direct

X 11.2 einführt und standardisiert,

nennt sich Tiled Ressources

– auch bekannt als Partially

Resident Textures (AMD) oder

Mega-Texturing (id Software).

Das Problem von Texturen ist

die Größe für entsprechende

Details, was mit viel Speicherverbrauch

sowie einer hohen

Datentransfer-Rate einhergeht,

zumal oft nicht die komplette

Pixeltapete dargestellt, aber

geladen wird. Da die Gesamtmenge

an Texturen den Platz

im Videospeicher bei Weitem

übersteigt, müssen diese abhängig

von der Perspektive gestreamt

werden.

Daher nutzen Entwickler in der

Praxis Software-Tiling, also Kacheln

von Texturen, um diese

Daten anzuliefern, gerade mit

anisotroper Filterung steigt

der Overhead jedoch stark an

und sorgt für Probleme. Mit

Hardware-Tiling und 64 KiByte

pro Kachel fällt dieses Problem

weg, Direct 3D 11.2 gibt dafür

den Standard vor. Entsprechende

Hardware ist aber noch nicht

verfügbar, AMD will aber für

seine HD-7000-Karten einen

entsprechenden Treiber veröffentlichen,

der den vollen Funktionsumfang

von Direct X 11.2

bereitstellt.

Beispiel: Wie die 3D-Pipeline Verarbeitung bei eines DX11 Tastendrucks

aufgebaut ist

Je neuer die DX-Version, desto mehr verschiedene Stufen sind in der logischen Abarbeitungsabfolge integriert. Die Bestandteile mit abgerundeten Kanten

sind programmierbar, die eckigen Einträge fest verdrahtet; der Tessellator in Direct X 9 und 10(.1) ist eine AMD-eigene Erweiterung und in der API

selbst nicht vorgesehen oder direkt ansprechbar.

3D-Pipeline: Direct X 11 3D-Pipeline: Direct X 10(.1) 3D-Pipeline: Direct X 9

Input-Assembler

Input Assembler

Input Assembler

Vertexshader

Tessellator

Tessellator

Hullshader

Tessellator

Domainshader

Geometryshader

Rasterizer

Pixelshader

Stream Output

Data Structure

Compute-

Shader

Memory/Resources

Vertexshader

Geometryshader

Domainshader

Rasterizer

Pixelshader

Stream Output

Memory/Resources

Vertexshader

Rasterizer

Pixelshader

Output Merger

Output Merger

Output Merger


Grafikkarte

Wie Spiele Direct X 11 nutzen und damit schöner aussehen

Ohne DX11-Schatten

Mit DX11-Schatten

Stalker: Call of Pripyat

Die Direct-X-11-Version von Stalker: Call of Pripyat stellt die Schatten realistischer dar: Statt durchgehend harten oder weichen Schattenkanten variieren

diese abhängig von der Entfernung des Schatten werfenden Objektes. Je näher sich der Schatten am Objekt befindet, desto schärfer sind die Kanten, je

weiter weg, desto weicher werden diese – wie im echten Leben.

Ohne Tessellation

Mit Tessellation

Colin McRae Dirt 2

Das Rennspiel Colin McRae Dirt 2 nutzt unter anderem das Direct-X-11-Feature Hardware Tessellation, um Objekte wie diese Fahne detaillierter darzustellen.

Hardware Tessellation wird aber auch für besser animierte Zuschauer und für dynamische Wasseroberflächen eingesetzt, die beim Durchfahren

Auswirkungen auf das Fahrverhalten haben.

Ohne HD Ambient Occlusion

Mit HD Ambient Occlusion

Weltraum-Shooter

Dieser Weltraum-Shooter nutzt neben Tessellation für Charaktere und Umgebungen High Definition Ambient Occlusion, welches eine realistischere

Beleuchtung respektive Schattierung ermöglicht. Hierbei werden Vertiefungen in der Oberflächen-Geometrie erkannt und entsprechend abgedunkelt –

wie auch in der Realität.


Grafikkarte

Bevor 3D-Grafik texturiert wurde, gab es in sehr frühen Spielen reine

Drahtgittermodelle, später dann gefüllte Flächen und schließlich Flatund

Gouraud-Shading

Aus der rohen, aber bereits schattierten 3D-Geometrie (links) werden

durch verschiedene Texturtypen realistisch anmutende Spiel-Charaktere

So funktionieren

Texturen

Die Grafik aktueller Spiele

ist vor allem deswegen

so verblüffend,

weil dutzende mehr oder weniger

aufwendig berechnete Effekte

zum Einsatz kommen. Wie

entstehen die Effekte und wo

stoßen sie an ihre Grenzen?

Texturen

Beginnen wollen wir mit dem

Grund element heutiger 3D-Grafik:

der Textur. Eine Textur, blumig

auch gern als „Pixeltapete“

bezeichnet, ist in ers ter Linie

eine Datei, welche verschiedene

Informationen enthält.

Grundsätzlich wird zwischen

bildgebenden und nicht bildgebenden

Texturen unterschieden.

Die in den Texturen enthaltenen

Informationen können

von einfachen Farbwerten bis

hin zu einer Tabelle mit vorberechneten

Werten (Look-uptable

oder LUT) alle möglichen

Formen haben.

Im Falle bildgebender Texturen

dienen sie jedoch alle nur

der Täuschung des Auges. Mit

Texturen wird nämlich eines

der Hauptaufgabengebiete der

3D-Grafik vorangetrieben: Fälschung.

Bildgebende Texturen

vermitteln Oberflächeneindrücke,

Bump-Mapping jeder Art

erweckt den Anschein zusätzlicher

geometrischer Details,

Schattentexturen täuschen eine

realistische Beleuchtung vor. Je

nach Art der enthaltenen Information

sind Texturen auch unterschiedlich

groß. Maßgeblich

für die Größe ist einerseits die

Auflösung, die Kompression,

die Anzahl der Kanäle und die

Farbtiefe.

Eine bildgebende Textur enthält

in der Regel vier Farb- und einen

Transparenzkanal (Alpha);

je ein Farbkanal stellt eine der

PC-Grundfarben Rot, Grün und

Blau dar. Je größer und genauer

die Informationen wiedergegeben

werden sollen, des to eher

ist auch eine hohe Bittiefe nötig.

Stehen zu wenig Bit pro Farbe

zur Verfügung, entstehen stufige

anstelle sanfter Farbverläufe.

Aktueller Standard sind 32 Bit –

8 Bit pro Kanal –, während für

High-Dynamic-Range-Rendering

in der Regel 16 Bit pro Kanal

anfallen.

Wie funktioniert

Texturierung?

Texturierung ist eine sehr aufwendige

Angelegenheit. Belegt

ein Spiel den rundlichen Kopf

eines 3D-Charakters mit einer

flachen Textur, so muss zuerst

die Verzerrung der einzelnen

Texturpunkte berechnet werden

– im Fachjargon heißt das,

die Texturkoordinaten müssen

in den Screenspace transformiert

werden. Dies ist der erste

Rechenschritt. Neben den

weiteren fälligen Gleitkommaberechnungen

sind zusätzlich

etliche aufwendige Speicherzugriffe

nötig, welche allerdings

durch Cache-Speicher zum Teil

aufgefangen werden.

Liegen die Daten dann vor, müssen

sie miteinander verrechnet

werden. Das kostet zusätzliche

Rechenzeit. Für all dies sind jedoch

spezielle Schaltungen im

Grafikchip integriert, welche

auf genau diese Operatio nen

spezialisiert sind und diese sehr

schnell, meist in einem Taktzyklus,

ausführen können.


Grafikkarte

Für aufwendigere Filter (trilinear

oder anisotrop) sind

mehrere Durchläufe der Textureinheit

nötig, ebenso für Texturen,

welche über das normale

32-Bit-Format hinausgehen. Um

zusätzlich Speicherbandbreite

zu sparen, liegen viele Texturen

im komprimierten Format vor,

welches erst zur Laufzeit in den

Textureinheiten entpackt und

verarbeitet wird. Dadurch kann

bei nur geringem visuellen Verlust

die nötige Bandbreite oft

um 50 bis 75 Prozent reduziert

werden – oder die Texturauflösung

entsprechend erhöht.

Single- und

Multi-Texturing

Grundlegende Texturierung

von 3D-Objekten erfordert eine

sogenannte Base-Map, die Basistextur.

Diese ist in aller Regel

von der bildgebenden Abteilung

und beinhaltet zum

Beispiel ein Gesicht oder ein typisches

Materialmuster wie das

von Holz. Tatsächlich begnügten

sich die ersten 3D-Spiele

mit nur einer Texturschicht.

Mit der Voodoo 2 hielt dann

auch Multi-Texturing in Spielen

Einzug. Mit einer zweiten Textur

ist es zum Beispiel möglich,

eine Detailschicht zur Base-Map

hinzuzufügen oder mittels

Light-Map einen Lichtschein

zu simulieren, ohne tatsächlich

eine echte, dynamisch berechnete

Lichtquelle in das Spiel zu

integrieren (Beispiel: brennende

Fackeln).

Environment-

Mapping

Weitere Texturschichten können

zum Beispiel einen Glanz-,

Spiegel- oder auch Transparenzeffekt

erzeugen. Ein Anwendungsfall

ist das (Cube-)

Environment-Mapping. Dabei

wird ein Reflexionseffekt erzeugt,

der die Umgebung widerspiegelt

– besonders beliebt

bei Auto rennspielen. Die dazu

nötigen Daten werden aus den

innen liegenden Texeln eines

virtuellen Texturwürfels (Cube-Map)

gewonnen und perspektivisch

korrigiert mittels

Multi-Texturing mit der eigentlichen

Oberflächentextur des

Objektes verrechnet.

Bump-Mapping

Mittels Bump-Mapping werden

Erhebungen und, wie der Name

andeutet, Beulen (Bumps) in

Oberflächen simuliert. Unter

diesen Sammelbegriff fallen eigentlich

auch aktuelle Techniken

mit eigenständiger Bezeichnung

wie zum Beispiel

Parallax-Occlusion-Mapping.

Natürlich könnte der Spieleentwickler

auch einfach zusätzliche

Dreiecke in der Szene unterbringen,

doch ein ähnlicher

Effekt lässt sich durch die Verwendung

von Bump-Maps erreichen.

Eine grundsätzliche Schwäche

aller Bump-Mapping-Verfahren

sind sehr flache Blickwinkel,

in denen der Betrachter dann

doch merkt, dass eben keine

echte Geometrie vorhanden ist.

Auch sind die virtuellen Kanten,

welche zum Beispiel durch

Parallax-Occlusion-Mapping erzeugt

werden, nicht durch normales

MSAA zu glätten.

Weitere Mapping-

Effekte

Bereits 1998 mit der Voodoo

2 wurde einfaches Emboss-Bump-Mapping

möglich.

Diese Spielart wird mittels einfachen

Multi-Texturings realisiert,

erzielt aber aufgrund der

ungenauen Arbeitsweise nur

mit hohem Aufwand und mehreren

Durchläufen ansprechen-

Wie anisotrop gefilterte

Texturen das Bild schärfen

In diesem Bild erkennen Sie die Wirkungsweise des anisotropen Texturfilters.

Mit höheren Filterstufen (v. l. n. r., trilinear bis anisotrop) bleiben

die Bodentexturen länger scharf.

Bump-Mapping

Parallax-Mapping (Offset)

Parallax-Occlusion-Mapping

Von der Seite betrachtet zeigt sich, dass keine Art von Bump-Mapping

echte geometrische Details erzeugen kann.


Grafikkarte

de Ergebnisse. Einen Schritt

weiter gehen bereits Environment-Mapped-

und Dot-3-Bump-

Mapping. Dot-3-Bump-Mapping

errechnet dynamische und im

Vergleich zur Emboss-Variante

pixelgenaue Beleuchtung

– daher wurde das Verfahren

auch schon sehr früh unter „Pixel-Shading“

eingestuft. Technisch

ist Dot-3-Bump-Mapping

kein Glanzpunkt mehr und

mittlerweile praktisch komplett

aus dem Spielealltag verschwunden.

Normal-Mapping

Im Gegensatz zur Höhenspeicherung

bei klassischen Formen

des Bump-Mappings

kommen beim sogenannten

Normal-Mapping in einer dreikanaligen

Textur gespeicherte

Vektoren zum Einsatz, aus denen

die Beleuchtungsinformationen

eines Objektes errechnet

werden können. Der Vorteil

liegt darin, dass die Normalen-Texturen

üblicherweise

während der Modellerstellung

erzeugt werden. Zu diesem

Zeitpunkt wird noch mit zehnbis

hundertfach detaillierteren

Modellen gearbeitet, deren Beleuchtungsgenauigkeit

durch

das Normal-Mapping annähernd

erreicht wird.

Parallax-Mapping

Ein Problem haben die bisher

vorgestellten Bump-Mapping-Verfahren:

Die vorgetäuschten

Unebenheiten haben

keine dritte Dimension und

Wie Bump-Mapping funktioniert

Bump-Mapping

Bump-Mapping





Bei diesem Betrachtungswinkel überzeugt Parallax-Occlusion-Mapping.

Auch wird deutlich, dass Kantenglättung bei den hinzugefügten Texturdetails

wirkungslos ist.

In der Draufsicht zeitigt selbst normales Bump-Mapping, das am wenigsten

aufwendige der drei Verfahren, gute optische Resultate.


Grafikkarte

können sich daher bei der Bewegung

des virtuellen Betrachters

nicht gegeneinander verschieben.

Auch einzelne Teile

der Textur, zum Beispiel einer

Mauer, können sich so nicht

überlagern. Parallax-Mapping

nutzt eine Höhentextur, um die

Texturkoordinaten relativ zur

Betrachter ebene neu zu berechnen

und so den 3D-Effekt zu simulieren.

Einfache Parallax-Mapping-Algorithmen

vernachlässigen dabei,

dass sich aus entsprechenden

Blickwinkeln auch verschiedene

Teile derselben Textur gegenseitig

überlagern können,

und verzerren dadurch das

Bild bei sehr flachen Blickwinkeln

stark. Diesem Umstand

trägt das rechenaufwendige Parallax-Occlusion-Mapping

Rechnung.

In der Regel wird dafür

ein umfangreiches Shader-

3.0-Programm genutzt, welches

einen einfachen Raytracer im

Pixel-Shader simuliert und damit

den Schnittpunkt von Blickrichtung

und virtuellem Raum

berechnet.

Displacement-

Mapping

Wörtlich übersetzt handelt es

sich hierbei um eine Verdrängungs-

oder Verschiebungstextur.

Diese Bezeichnung trifft

den Nagel auf den Kopf: Ein

vorhandenes Drahtgittermodell

wird mittels einer speziellen

Textur, in welcher die

Verschiebungsparameter enthalten

sind, verändert, sodass

aus einer Kugel zum Beispiel

Stacheln wachsen können. Dieses

Verfahren findet seit seiner

(Hardware-)Vorstellung

2002 mit der Matrox Parhelia

immer wieder Erwähnung, ist

aber eigentlich erst mit Direct-

X-10-Hardware auf der Grafikkarte

möglich. Die dortigen

Geometry-Shader durchbrechen

erstmals das 1-in-1-out-

Prinzip und können zusätzliche

Geometrie ohne Zuhilfenahme

der CPU erzeugen.

Prozedurale Texturen

Der Begriff „prozedural“ bezeichnet

allgemein Dinge, die

durch eine „Prozedur“ erzeugt

werden, in diesem Zusammenhang

also eine Textur, welche

im Gegensatz zu klassischen Pixeltapeten

nicht im Entwicklerstudio

vorberechnet wird, aus

einer Fotografie entsteht oder

gar von einem Künstler manuell

angefertigt werden muss,

sondern auf dem PC des Anwenders

erzeugt wird. Prozedurale

Texturen werden anhand

von Algorithmen, also mathematischen

Formeln, errechnet,

welche nur als Programmcode

vorliegen. Da der Speicherplatz

für eine solche Formel deutlich

kleiner als für ein vorberechnetes,

wenn auch komprimiertes

Bild ausfällt, sparen prozedurale

Texturen eine große Menge

Speicherplatz, kosten aber

mehr Rechenleistung, als wenn

alles bereits vorgebacken auf

der Silberscheibe ausgeliefert

würde.

Mit einer prozeduralen Textur

kann beispielsweise die natürlich

vorkommende Maserung

von Holz oder Marmor imitiert

werden. Auch ist es möglich,

andere natürliche Phänomene,

welche nach gewissen Gesetzmäßigkeiten

entstehen, prozedural

zu imitieren – Glas mit

einer Frostschicht, Wasserbewegungen

und so weiter.

Vorteile prozeduraler

Texturen

Es gibt mehrere Gründe, zumindest

stellenweise prozedural er-

Bereits im ersten Unreal-Engine-

Spiel von 1998 zeigte Epic – damals

noch MegaGames – zaghafte Ansätze

prozeduraler Texturen.

In der Demo-Szene sind prozedurale Texturen schon lange sehr beliebt.

Mit kkrieger haben Farbrausch sogar ein ganzes Spiel in 96 kiByte gequetscht.

Das auch über den Xbox-360-Download-Dienst

Live Arcade vertriebene

Puzzle-Spiel Roboblitz profitiert stark

vom gesparten Platz durch prozedurale

Texturen.


Grafikkarte

Textur-Techniken

Prozedurale Texturen

Prozedurale Texturen werden dynamisch berechnet und sparen dadurch

Platz. Weil sie aber auch viel Rechenleistung brauchen, kommen

sie in Spielen bislang nur sporadisch zum Einsatz

Bunny (Holo)

Head (Holo)

Frozen Glass

Fur

Bunny (Solid)

Head (lit2)

Volumetrische Texturen

Eher im wissenschaftlichen Umfeld sind volumetrische Texturen angesiedelt.

Hier einige Beispiele für 3D-Effekte, die damit umgesetzt

werden können

Psychedelic

Water

zeugte anstelle herkömmlicher

Texturen zu verwenden. Einer

ist die preiswertere Produktion

solcher Texturen, der andere

die Qualität. Viele prozedurale

Texturen aus der Anfangszeit

der 3D-Spiele nutzten aufgrund

der beschränkten Rechenleistung

damaliger PCs eher einfache

mathematische Formeln

und waren dementsprechend

auch leicht an ihrer repetitiven

Struktur und ihrem synthetischen

Aussehen zu erkennen –

das muss für heutige Lösungen

nicht mehr gelten. Zudem bieten

sie aufgrund ihrer Auslieferung

als reine Formel beziehungsweise

Shader-Code sehr

viel mehr Qualität pro Byte, da

stark komprimierende Algorithmen

für bildhafte Texturen

nicht verlustfrei arbeiten und

so beim Entwickler immer ein

Kompromiss zwischen Datenmenge

und Bildqualität gefunden

werden muss.

Flexibel und schlank

Zudem können prozedurale

Texturen auch abhängig von

den Fähigkeiten des Host-Rechners

erzeugt werden: Ab Direct

X 10 können Texturen mit

einer Kantenlänge von bis zu

8.192 Pixeln genutzt werden.

Vor solchen Texturen schrecken

die meisten Spieleentwickler

zurück, da sie nur auf

einem Bruchteil der PCs Verwendung

finden würden. Selbst

Hi-Res-Texturen-Mods sind in

der Regel lediglich mit Texturgrößen

zwischen 2.048 x 2.048

und 4.096 x 4.096 Pixeln ausgestattet.

Neben den geringen Erstellungskosten

kommt die extrem

geringe Datenmenge besonders

unter dem Aspekt der

elektronischen Vertriebswege

zum Tragen: Das Unreal-Engine-3-Spiel

Roboblitz von Naked

Sky Entertainment setzte zum

Beispiel auf viele prozedural erzeugte

Texturen und benötigte

zur Veröffentlichung über

Xbox Live nur rund 50 Megabyte

Speicherplatz. Die PC-Version

belegt aufgrund der umfangreicheren

Ausstattung ca. 186

Megabyte – für ein komplettes

Spiel mit 19 Levels kein besonders

großer Download.

Volumetrische

Texturen

Neben klassischen Oberflächenmustern

mit zwei Dimensionen

(Länge und Breite) gibt es

auch die sogenannten volumetrischen

Vertreter ihrer Zunft.

3D- oder Volumentexturen sind

in Spielen derzeit kaum verbreitet,

sondern werden vorwiegend

in der Forschung oder in

anderen wissenschaftlichen Anwendungsbereichen

eingesetzt.

Dort wird unter anderem die Visualisierung

aus der Computertomographie

mittels volumetrischer

Texturen durchgeführt.

Auch die Erforschung von Ölund

Gasvorkommen wird auf

diese Weise visualisiert.

Ermittelte oder je nach Anwendung

vorberechnete Dichtewerte

dienen als Basis und

werden mithilfe komplexer

Pixel-Shader-Programme (zum

Beispiel Shear-Warp- oder klassischer

Raymarching-Algorithmus)

in beliebiger Tiefe unter

der Oberfläche ausgewertet –

Texturen „kleben“ nicht mehr

nur auf einem Objekt, sondern

durchdringen es quasi.

In Spielen können 3D-Texturen

am ehesten zu Beleuchtungsmodellen

wie SH-Modellen

(Spherical Harmonics) oder für

volumetrische Wolken sowie

Nebel genutzt werden.


Grafikkarte

Ohne Schatten ist es für

das menschliche Auge

schwierig, die richtigen

räumlichen Zuordnungen

zu treffen: Man weiß beispielsweise

nicht auf Anhieb, ob ein

Spiel-Charakter noch Bodenkontakt

hat oder quasi über den

Dingen steht.

Frühe Schatten

Schon in den Kindertagen der

3D-beschleunigten Welten gab

es daher einfachste Schattendarstellungen

wie einen schwarzen

Fleck unter einem Spiel-Charakter

auf dem Boden. Später wurden

die Techniken zur Schattenerzeugung

fortschrittlicher, es

entstand das Shadow-Mapping.

Shadow-Mapping

Shadow-Mapping ist in der

Spieleentwickler-Szene sehr beliebt,

da die zugrunde liegenden

Algorithmen komplett im

sogenannten Image-Space ausgeführt

werden und für das

Rendering keine Informationen

über die Geometrie der restlichen

Szenerie vorhanden sein

müssen. Prinzipiell arbeitet das

Shadow-Mapping-Verfahren mit

So funktioniert

die Schattenerzeugung

mehreren Schritten – und zwar

für jede Lichtquelle getrennt.

Während der ersten Phase wird

die Kamera versetzt, sodass die

Szene aus der Sicht der Lichtquelle

betrachtet wird. Dann

wird ein einfacher Tiefenpass

gerendert, in welchem geprüft

und festgehalten wird, in welcher

Entfernung zur Lichtquelle

sich die einzelnen Pixel befinden.

Das Ergebnis wird in einer

einkanaligen Textur, der sogenannten

Shadow-Map, abgespeichert.

Dieser Vorgang wird

für jede Lichtquelle wiederholt,

die einen Schatten werfen soll.

Im zweiten Durchgang werden

die Tiefenwerte des zu berechnenden

Pixels und der entsprechende

Wert aus der zuvor

angelegten Shadow-Map verglichen.

Dazu muss zunächst die

Schattentextur in den Eye-Space

transformiert werden, da

diese zuvor aus Sicht der Lichtquelle

angelegt worden ist und

nun aus der Sicht des Spielers

benötigt wird. Hinzu kommen

Tricks und Kniffe wie ein geringfügiger

Polygon-Offset oder

gedimmte Diffuse-Beleuchtung,

um schattierte Objekte nicht zu

flach wirken zu lassen.

Performance

Schattentexturen sind wie andere

Texturen in ihrer Auflösung

begrenzt. Aus Performance-Gründen

fällt diese

Begrenzung meist noch etwas

enger aus als theore tisch

möglich. In weitläufigen Landschaften

sind hochauflösende

Schatten jedoch wichtig,

da die Schatten in großer Entfernung

sonst sehr undeutlich

würden und Präzisionsproble-

me bekämen. Selbst moderne

Spiele wechseln relativ früh

und abrupt auf eine geringere

Shadow-Map-Auflösung und

blenden die Schatten in einiger

Entfernung ganz aus, um die genannten

Probleme zu vermeiden.

Zwar gibt es mit Layeredoder

Variance-Shadow-Mapping

bereits praktikable Ansätze, die

jedoch sehr leistungshungrig

sind.

Closer Filtering

Seit Direct X 10 existiert das

„Percentage Closer Filtering“

genannte Verfahren. Damit können

die TMUs einen Punkt aus

der Schattentextur zurückliefern,

der bereits quasi bilinear

gefiltert und damit an den

Kanten mit einem weichen

Übergang zur Vermeidung von

Shadow-Map-Aliasing ausgestattet

ist.

Wie Shadow-Maps die Qualität bestimmen

Auflösung von Schattentexturen im direkten Vergleich: Während die schattenwerfende Geometrie – hier die Spielfigur mitsamt Ausrüstung wie dem Pfeilköcher

– immer in derselben Auflösung vorliegt, variiert die Auflösung der Schattentextur von 128 über 1.024 bis 2.048 Pixel pro Kante von links nach

rechts. Gut zu erkennen: der hohe Detailgewinn bei den Schatten zwischen 128 und 1.024 Pixeln.


edle BOOKAZi

iM PReMiuM-FORMAT

Satte 148 Seiten

So machen Sie

Super-Fotos

64 Tipps für

tolle Motive

Alle neuen

iOS-7-Features

Nur € 9,99

WeiTeRe PReMiuM-BOOKAZiNeS iM HANdel:

Auf 164 Seiten

Bessere Fotos in jeder Lage:

Basiswissen ■ Foto-Technik

Ausrüstung ■ Studiobilder

Portraits ■ Tierfotos

und vieles mehr

Nur € 11,99

ZuM KiNO-HiT RuSH!

Biografie & Zeitgeschichte

James Hunt & Niki Lauda:

Was wirklich geschah

Zwei Hefte in einem!

Auf 164 Seiten

Nur € 9,99

NES

Auf 148 Seiten

So werden Sie

zum Web-Profi

Gmail &

Google Drive

Google + und

Google Maps

Nur € 9,99

148 Seiten

Der perfekte Leitfaden für

alle Samsung-Galaxy-Modelle

■ Samsung-Super-Tests

■ Noch mehr Akkulaufzeit

und vieles mehr

Einfach mit dem

Smartphone

abfotografieren

und hinsurfen!

Nur € 9,99

Auf 164 Seiten

■ Wissen und Hintergründe

■ Für Einsteiger und Profis

und vieles mehr

Nur € 11,99

Überall im Handel oder bequem online bestellen: shop.computec.de/edition

Grafikkarte

Bilder: Matrox

Rückblick: Wie Shader-

Effekte auf den PC kamen

Den ersten Shadereffekt brachte eine Techdemo: Darin zeigte Matrox

für die G400-Reihe, wie sich Environment Mapped Bump Mapping

(EMBM) per Shader erzeugen lässt. Während Matrox’ G400, die erste

Radeon-Generation und Power-VRs Kyro-Chips sich noch ihrer TMUs

bedienten, mussten Nvidia-Nutzer auf die Pixelshader-Einheiten der

Geforce 3 warten, bis sie EMBM bestaunen konnten.

Im Frühjahr 2001 brachte Nvidia dann mit der Geforce 3 (200/230 MHz)

die erste Grafikkarte, die Microsofts DX8-Anforderungen erfüllte und

über Hardware-Shader für Pixel und Vertizen verfügt. Die Ati Radeon

8500 erschien im Herbst desselben Jahres und beherrschte bereits PS

1.4. Nahezu zeitgleich erschienen die ersten Spiele auf Basis der Unreal-Engine,

welche Shadereffekte unterstützten – Clive Barker’s Undying

war eines der bekanntesten, es kam 2001 auf den Markt.

So funktionieren

Shader

Auch wenn viele der bereits

genannten Effekte

hauptsächlich texturbasiert

sind, wird bereits für vergleichsweise

einfaches Environment-Mapped-Bump-Mapping

(EMBM) seit den Zeiten von

Geforce 3 und Radeon 8500 die

Hilfe der „Shader“ in Anspruch

genommen.

„Shader“-Ursprünge

„Shading“ im Sinne der 3D-Grafik

hat seinen Ursprung bei zunächst

einfarbigen Flächen,

deren wortgemäße „Schattierung“

berechnet werden musste.

Der Begriff wurde im Lauf

der Zeit allgemein für Aufgaben

benutzt, mit denen das Aussehen

eines Oberflächenpunktes

bestimmt wird. Noch vor

der offiziellen Einführung der

„Shader-Modelle“ in Microsofts

Direct X 8 benannte Nvidia beispielsweise

die Geforce 2 mit

dem Zusatz „GTS“ – „Giga Texel

Shader“ in Anlehnung an die

Texturfüllrate.

Mit der Einführung der Direct-

X-8-API wurden die Shader-Klassen

nach Pixel- und Vertexarbeit

unterteilt und in verschiedene

Versionen hinsichtlich der

Flexibilität verpackt. Die Hardware,

welche die Shader-Programme

ausführte, wurde aus

dem englischen „Shader-Units“

(Shader-Einheiten) innerhalb

kürzester Zeit selbst zu „Shadern“

verkürzt, sodass bis heute

im deutschen Sprachraum

keine klare Trennung zwischen

Hard- und Software-Teilen der

Shader herrscht und der Begriff

„Shader“ sowohl für die Ausführungseinheiten

der Hardware

als auch die auszuführenden

Software-Programme steht.

Shader-Einheiten

Die Shader-Einheiten bestehen

in der Regel aus flexiblen Rechenwerken,

die pro Takt ein

sogenanntes MADD (Multi ply-

Add, auch Fused-MAC) ausführen

können – diese dienen auch

als Gradmesser der viel zitierten

GFLOPS-Leistung. Diesen

zur Seite steht eine geringere

Anzahl an Ausführungseinheiten,

die zusätzlich weniger oft

benötigte Funktionen wie Wurzel

(SQR) oder Sinus/Kosinus

implementieren. Obwohl diese

Rechenwerke mittlerweile

so flexibel sind, dass sie auch

Funktionen der Textureinheiten

oder der Ras ter-Endstufen

(ROPs) ausführen könnten,

sind aus Effizienzgründen dafür

weiterhin spezialisierte, kaum

programmierbare Einheiten

vorhanden.

Was können Shader?

Shader-Einheiten haben die Arbeit

der früheren Textur- und

Register-Combiner übernommen.

Dadurch stehen per Shader-Programm

natürlich auch

alle Effekte zur Verfügung,

die zuvor durch reine Texturen-Kombinatorik

erzeugt wurden.

Das sind neben relativ

simplen Dingen wie Ein- und

Mehrfachtexturierung auch

Bump- Mapping bis hin zur Environment-Mapped-Version

–

der Spitze dessen, was mit reinen

Textureinheiten noch

möglich war.

Generell sind selbst einfache Pixel-Shader-Programme

des Shader-Modells

1 bereits zu folgenden

Effekten fähig:


Grafikkarte

z Per-Pixel-Beleuchtung in einem

Rendering-Pass

z Phong-Shading

z Anisotrope Beleuchtung

z Non-Photorealistic-Rendering

z Per-pixel Fresnel-Term

z Volumetrische Effekte

z Erweitertes Bump-Mapping

z Prozedurale Texturen

Shader-Programme

Als Standard zusammengefasst

wurden die Shader zunächst in

Microsofts Direct X 8 und sie

begannen mit Version 1.1 für Pixel-

und Vertexshader (1.0 war

für 3dfx’ nie erschienenen Rampage-Chip

vorgesehen). Die erste

nennenswerte Erweiterung

gab es mit der Radeon 8500,

welche die fortschrittlicheren

Pixelshader 1.4 unterstützte.

Mit Direct X 9 hielten 2.0-Shader

Einzug, die aufgrund der

deutlich gestiegenen Instruktionsanzahl

optional auch mit höherer

Genauigkeit, namentlich

im Gleitkommaformat, rechnen

mussten – damit war auch der

Grundstein für HDR-Rendering

gelegt.

Das Shader-Modell 3 erweiterte

die DX9-Fähigkeiten noch einmal.

Es enthielt einige Verbesserungen,

welche das HDR-Rendering

besser und performanter

einsetzbar machten, beispielsweise

die Fähigkeit der Textureinheiten,

auch HDR-Texturen

zu verarbeiten (mehr zum Thema

HDR im folgenden Unterkapitel).

Erstmals zum Einsatz

kam dieser Fortschritt in einem

Patch für Far Cry (dt.), das erste

Shader-Modell-3-Spiel „ab Werk“

war Splinter Cell Chaos Theory.

Unified Shader

Wirklich große Änderungen

gab es erst unter Windows Vista

mit Direct X 10. Hier wurden

vereinheitlichte Shader vorausgesetzt

– Pixel- und Vertex-Einheiten

mussten mit demselben

Programmcode ansprechbar

sein. Die Hersteller setzten diese

Vorgabe in den GPUs entsprechend

um: Seit DX10 gibt es bei

allen GPUs von Nvidia, AMD/

Ati, Intel und S3 Graphics nur

noch eine Art der Ausführungseinheit

(„Unified Shader“).

Direct X 10 brachte außerdem

die Unterstüzung für eine neue

Shader-Stufe, den Geometryshader.

Mit diesem war es erstmals

möglich, neue Geo metrie direkt

auf dem Grafikchip zu erzeugen.

Dadurch lässt sich der

Detailgrad eines Modells erhöhen

(„Geo metry Amplification“),

ohne dass eine nennenswert

größere Last außerhalb

der Grafikkarte entsteht. Effektiv

handelt es sich beim Geometryshader

also um eine Art

Geo metriekompression.

Mithilfe dieses Shader-Typs können

weitere Details zu vorhandenen

Modellen hinzugefügt

werden. Im Gegensatz zu Displacement-

oder Parallax-Occlusion-Mapping

sind diese jedoch

„echt“. Das heißt, dass sie nicht

je nach Blickwinkel in einer

Textursuppe verschwimmen,

sondern dass sie von normalem

Multisampling-FSAA erfasst

werden und sich auch sonst

genauso verhalten wie auf der

CPU erzeugte Details.

Compute Shader

Die neben (oder vielleicht

noch vor) Tessellation wichtigste

Neuerung von Direct

X 11 waren die sogenannten

Compute-Shader. Eine ausführliche

Erklärung beider Techniken

finden Sie im Abschnitt

„Direct X 11“ weiter vorne in

diesem Heft.

Überblick: Shader-Versionen

Direct X

Pixelshader

Vertex -

shader

Geometryshader

Weitere

Shader

1.0 - 7.0 Keine Keine Keine Keine

8.0 1.0, 1.1 1.0, 1.1 Keine Keine

8.1 1.2 - 1.4 1.1 Keine Keine

9.0 2.0 2.0 Keine Keine

9.0a/b 2.x 2.x Keine Keine

9.0c 3.0 3.0 Keine Keine

10.0 4.0 4.0 4.0 Keine

10.1 4.1 4.1 4.1 Keine

11 5.0 5.0 5.0 Hull-, Compute-Shader

Shader-Einheiten können auch dazu eingesetzt werden, aus einem

dreidimensionalen Datensatz die Visualisierung einer Tomografie-

Aufnahme zu erstellen – so wie hier in einer AMD-Techdemo.

Ohne Shadereffekte sind Spiele und

Demos kaum noch vorstellbar. Der „Shadermark“

– hier im Bild – misst die Shaderleistung

eines Grafikchips

Bild: AMD


Grafikkarte

So funktioniert

High Dynamic Range (HDR)

Bereits die Radeon 9700 Pro als

erste DX9-Karte war schon 2002

in der Lage, HDR-Rendering

durchzuführen. Das Bild stammt

aus der Demo „Debevec RNL“.

Was die Bittiefe über die

Texturqualität aussagt

Die Anzahl der Bits bestimmt, wie genau eine Information abgespeichert

werden kann. In der Tabelle sind typische Farbtiefen pro Kanal

aufgeführt

Bits 1 2 4 5 6 8 10 16

Mögliche 2 4 16 32 64 256 1.024 65.536

Zustände

Bereits im 3D Mark 2001 zeigte Mad Onion,

Vorläufer von Futuremark, einfache Überstrahleffekte.

Mit echtem HDR-Rendering

haben diese jedoch nichts zu tun

HDR ist nicht nur ein

simpler Grafik effekt,

sondern vielmehr ein

(nicht mehr ganz so) neuer Ansatz

für eine korrekte(re) Beleuchtung

in der digitalen Bilderzeugung.

HDR-Anfänge

Die Abkürzung „HDR“ steht für

High Dynamic Range, übersetzt

„hoher Dynamik- bzw. Kontrastumfang“,

und kommt aus dem

Bereich der Fotografie. Bereits

im vordigitalen Zeitalter wurde

dort versucht, mittels Kombination

mehrerer Negative mit unterschiedlichen

Belichtungen

den Kontrastumfang innerhalb

eines Bildes über das normale

Maß hinaus zu erhöhen.

In neuerer Zeit gelten Gregory

Ward (als Erfinder des Bildformates

„RGBE“) und Paul Debevec

(mit seiner Arbeit über

die Einzelbildkomposition zu

HDR-Bildern von 1997) als Pioniere.

Während man im Bereich

von digitaler Bildbearbeitung

und dem Offline-Rendering

zum Beispiel für Kinoproduktionen

höhere Anforderungen

stellt, spricht man im Bereich

der 3D-Echtzeitgrafik spätestens

bei einer (Gleitkomma-)Genauigkeit

von 16 Bit für jeden der

vier Informationskanäle (Rot,

Grün, Blau und Alpha) eines Pixels

von HDR-Rendering.

RGBA – vier Pixel -

komponenten

In der Regel werden die Informationen

zu Farbe und Transparenz

eines jeden Bildpunktes in

einem von vier Kanälen gespeichert:

Rot, Grün, Blau und ein

Kanal für Transparenzinformationen.

Aus diesen vier Informationen

werden – zum Teil nach

vielen Berechnungen – die finalen

Pixelfarben zusammengemischt.

Es ist naheliegend, dass

das Bild nur hochwertiger werden

kann, wenn diese Informationen

genauer sind.

In den Anfangstagen der

3D-Grafik nutzte man oft ein

Format mit insgesamt 16 Bit,

die sich als RGB565 (Alpha fiel

hierbei unter den Tisch) ungleich

verteilten. Der menschlichen

Wahrnehmung entsprechend

wird der Grünkanal mit

64 Abstufungen am höchsten

aufgelöst, Rot und Blau mussten

mit 32 Stufen auskommen.

Andere Formate dieser Zeit hatten

jeweils vier Bit Auflösung

(RGBA4444) und konnten somit

nur 16 Zustände für jeden

Kanal abbilden. Das klingt zunächst

nicht allzu wenig, allerdings

müssen zum Beispiel

durch Überlagerung verschiedener

Texturschichten, also

nach diversen Rechenschritten,

diese 16 Abstufungen pro Kanal

immer noch für das fertige

Bild ausreichen. In der Praxis

führt das häufig zu unschönen

Farbsäumen, sogenanntem Color-Banding.

Heutzutage beträgt die übliche

Mindestgenauigkeit immerhin

schon 8 Bit und damit 256 Stufen

für jeden Kanal. Einige Formate

teilen die entsprechenden

32 Bit jedoch auch anders

auf, nämlich mit 10 Bit (entsprechend

1.024 Abstufungen)

für jeden Farb- und zwei Bit für

die Transparenzinformationen

im Alpha-Kanal. Die Verwendung

dieses Formates wird zum


Grafikkarte

Teil schon als „HDR“-Ren dering

bezeichnet. All diese Formate

haben eines gemein: Es handelt

sich um Integer- oder Fixpunkt-Formate,

das bedeutet,

dass lediglich ganzzahlige Werte

zur Verwendung erlaubt

sind.

2.0-Shader bringen

Gleitkommagenauigkeit

Erst mit der Einführung von

Direct X 9 Ende 2002 wurde

die Unterstützung sogenannter

Gleitkommaformate Pflicht,

im Englischen „Floating-Point“

oder kurz „FP“ genannt, und

auch die Bitgenauigkeit wurde

stark erweitert. Anstelle einer

Gesamtgenauigkeit von 32 Bit

mussten nun einige Teile der

3D-Pipeline für jeden einzelnen

Kanal mit 32 Bit rechnen können

– und das, wie erwähnt, in

Gleitkommapräzision.

Damit wurden nicht nur die Anforderungen

an die Rechenwerke

der Grafikkarten stark gesteigert,

auch die Genauigkeit

konnte extrem verbessert werden.

Die zur Verfügung stehenden

Bits sind bei den damals

neu definierten Gleitkommaformaten

in separate Anteile für

Exponent und Mantisse aufgeteilt

worden, sodass eine logarithmische

Verteilung der Werte

möglich ist. Zum Beispiel

haben beim RGBE8-Format

die drei Farbkanäle je 8 Bit Basis

und teilen sich einen ebenfalls

achtbittigen Exponenten,

der im Alpha-Kanal gespeichert

wird (daher auch das „E“ anstelle

des „A“).

Zwar ist noch eine Umrechnung

per Pixelshader nötig, bevor

der Texturwert genutzt werden

kann, danach steht jedoch ein

Vielfaches an Farbpräzision zur

Verfügung. Mittels sogenannten

„Signings“ und „Biasings“, also

einer Vorzeichenvergabe und

konstanter Wertverschiebung,

können so auch einfach größere

Dynamikbereiche als die

üblichen zwischen 0 und 1 erzeugt

werden.

HDR-Rendering

Es gibt drei grundlegende

Abschnitte im Renderprozess

einer Grafikkarte, die für

HDR-Rendering mit hoher Genauigkeit

ausgeführt werden

können und sollten: zum einen

das Ausgangsmaterial in Form

der Texturen, dann die Präzision

der Rechenwerke (Shader,

Textureinheiten und ROPs)

und schließlich die verwendeten

Zwischenspeicher. Bei

Letzteren kann es sich um Bildpuffer

(sogenannte Render-Targets)

oder Texturen handeln.

Die Helligkeitsdarstellung

ohne HDR-Rendering ist auf

achtbittige Integerwerte, also

256 Stufen zwischen dem

hellstmöglichen (weiß) und

dem dunkelsten Bildpunkt

(schwarz), beschränkt. Höhere

und niedrigere Werte, die während

der Berechnung entstehen,

werden an diesen Grenzen

einfach gekappt (im Fachjargon

„clamping“) und bleiben so

bei maximal 1 und minimal 0.

Soll beispielsweise eine Umgebungsreflexion

per Cube-Mapping

einer Lichtquelle auf einer

Oberfläche dargestellt werden,

die das einfallende Licht nicht

zu 100 Prozent reflektiert, wird

die maximale Helligkeit durch

diesen Reflexionsfaktor kleiner

1 beschränkt, egal wie hell das

Licht eigentlich ist.

Wird eine FP-Textur mit höherem

Dynamikumfang, also eine

HDR-Cube-Map, genutzt, kann

Keine Post-Processing-Effekte

Bloom-Effekt

HDR-Rendering

TES 4: Oblivion kann entweder einen simplen Überstrahleffekt (Bloom)

oder echtes HDR-Rendering für die Beleuchtungsberechnungen nutzen

(unten).

Wie Fließpunkt-Berechnungen

die Qualität erhöhen

Diese HDR-Rendering-Demo zeigt den Unterschied zwischen herkömmlichen

INT8- und HDR-tauglichen FP16-Formaten bei hoher

„Exposure“ (Belichtung). Im INT8-Format entstehen hässliche Farbsäume,

die FP16-Bilder haben hingegen genügend Reserven in Sachen

Kontrastumfang.

8 Bit pro Kanal (Textur & Bildpuffer) 16 Bit pro Kanal (Textur & Bildpuffer)

8 Bit pro Kanal (Textur & Bildpuffer)





Grafikkarte

das Licht in korrekter Helligkeit

reflektiert werden.

HDR-Darstellung

Zwar kann das menschliche

Auge potenziell Kontraste

im Bereich von 1.000.000

zu 1 wahrnehmen, muss diesen

Bereich jedoch durch verhältnismäßig

langsame Anpassung

wie zum Beispiel die

Iriskontraktion und -erweiterung

erreichen. Der statisch

wahrnehmbare Kontrastumfang

liegt demgegenüber nur

bei etwa einem Prozent dieses

Maximalwertes. Auch übliche

PC-Bildschirme, egal ob

Röhren- oder Flachbildmonitor,

können nur einen – im Vergleich

zum HDR-Wertebereich

– arg begrenzten Dynamikumfang

erreichen. Damit der ganze

Aufwand beim HDR-Rendering

nicht für die Katz ist, müssen

die errechneten Helligkeitswerte

aus dem hohen Kontrastumfang

sinnvoll in den darstellbaren

Bereich zwischen 0 und 1

gebracht werden. Diesen Vorgang

des Umrechnens nennt

man Tone-Mapping.

Prinzipiell sind zwei Arten von

Tone-Mapping gebräuchlich.

Eine Variante nutzt dabei eine

globale Umrechnungsformel

für alle Bildpunkte, die auf der

mittleren Helligkeit des gesamten

Bildes basiert. Eine zweite

Methode berücksichtigt die Eigenheiten

menschlicher Wahrnehmung,

sodass zum Beispiel

lokale Kontraste eine größere

Rolle spielen.

Typische Effekte

Wenn ein Spieleentwickler den

größten Teil der Berechnungen

bereits in einem passend erweiterten

Wertebereich ausführt,

kann er diese natürlich auch

für herkömmliche Effekte nutzen

und diese durch HDR-Rendering

aufwerten. Beispiele dafür

sind etwa Überstrahleffekte

(„Bloom“) oder Linsenreflexionen

(„Flare“).

Im Falle des beliebten Bloom-

Effektes wird der Eindruck simuliert,

den eine sehr helle

Lichtquelle hervorruft, wenn

sie in einen dunk len Bereich

scheint. Dieser Effekt ist bei al-

HDR-Beleuchtungsvarianten

Cube-Mapping

Tone-Mapping

Bei voller Reflektivität zeigen 8-Bit-Texturen keinen Nachteil (oben), reflektiert

ein Objekt aber nicht vollständig, wird die Dynamik gekappt (unten).

Ohne Tone-Mapping (oben) überstrahlen helle Lichter stark. Tone-Mapping

(Mitte) sorgt für „korrekte“ Darstellung, auch eine Blauverschiebung (unten)

ist möglich.


Grafikkarte

len nicht perfekten, runden Optiken

zu beobachten, die das

Licht einer punktartigen Lichtquelle

erfassen. Ist die Belichtung

der Optik auf einen dunklen

Raum eingestellt, durch

dessen Fenster helles Tageslicht

hereinscheint, wirkt es, als würde

das Licht über die Ränder

des Fensterrahmens hinauslaufen.

Genauer gesagt handelt es

sich dabei also um „Bleeding“,

das Aus- oder Überlaufen von

Farbe oder Helligkeit in andere

Bildbereiche.

Der herkömmliche Wertebereich

verfügt dabei nicht über

genügend Dynamikreserven,

sodass der Programmierer

höchs tens die Helligkeit des gesamten

Bildes anpassen kann,

während es im HDR-Bereich

möglich ist, aus dem korrekten

Verhältnis der dunkelsten und

hellsten Bildteile die Stärke des

Überlaufeffektes zu errechnen

und vor dem Tone-Mapping anzuwenden.

Wie HDR-Effekte erzeugt werden

Die Anwendung von Effekten beim HDR-Rendering verdeutlicht ein Beispiel aus dem Direct-X-SDK – dort werden

hochdynamische Beleuchtungs informationen des Ausgangsbildes mit einem Color-Bleeding-Effekt, der via

Unschärfe-Filter erzeugt wird, und einer in Echtzeit berechneten Helligkeitsfunktion kombiniert.

Das Ausgangsbild: 32 Bit pro Kanal, Wertebereich größer 0 bis 1

Ein Arbeitsgang dient zur

Ermittlung der durchschnittlichen

Helligkeit mithilfe des

Grafikpro zessors.

In jedem der Schritte wird die

Achsenauflösung um Faktor 3

per Mittelwertbildung heruntergerechnet.

Für den Blur-Effekt müssen Pixel

eine Mindesthelligkeit erreichen.

Die Achsenauflösung wird

zweimal jeweils halbiert.

Lens Flares

Auch „(Lens) Flares“, also

Lin senreflexe, werden zur

Realismus stei gerung eingesetzt.

Das ist vor allem deswegen erstaunlich,

weil damit eher der

Effekt einer gefilmten Aufnahme

mit verschieden vergüteten

Linsen optiken simuliert wird

als die echte menschliche Wahrnehmung.

Dabei wird prinzipiell

ein ähnliches Verfahren

angewandt wie oben beschrieben.

Der bekannteste Effekt ist

dabei vielleicht der klassische

TV-Lens-Flare, der die bei Formel-1-Übertragungen

früher

üblichen Lichtreflexe der Sonne

nachstellt, sich aber auch

in etlichen Weltraumspielen

hoher Beliebtheit bei dramatischen

Kameraschwenks

durchs Geschehen erfreut.

Die Operationen sind

gleitkomma genau, entsprechend

ausgestattete Hardware

beschleunigt den Vorgang.

Downsampling-Stufe 4 zeigt

anstelle der 730 x 730 Pixel des

Ausgangsbildes nur noch

9 x 9 Bildpunkte.

Der vorletzte Schritt hat die

Helligkeit bereits auf eine

Textur mit den Maßen

3 x 3 Pixel eingedampft.

Der letzte Schritt erzeugt

ein einzelnes Pixel, das die

durchschnittliche Helligkeit

des Ausgangsbildes enthält.

Nach Verrechnung der Helligkeit und Anwendung

des Unschärfeeffektes, der das Auslaufen der

(hellen) Farben in dunkle Bereiche simuliert, folgt

noch das Tone-Mapping.

Erst die so verringerte Pixelzahl

wird zunächst horizontal und …

… danach vertikal mit Weichzeichnung

(„Blur“) versehen.


Grafikkarte

Bild: 2K Games

Glatte Kanten und Übergänge steigern die Grafikqualität

erheblich – hier kommt Downsampling, eine

Variante des Supersampling-AA, zum Einsatz.

Welche Anti-Aliasing-Varianten

unterschieden werden

Kürzel Bedeutung Merkmale/Funktion

FSAA Full-Screen/Scene-Anti-Aliasing Allgemeiner Begriff für Vollbild-Anti-Aliasing

SSAA Super-Sampling-Anti-Aliasing Überbegriff für mehrfaches Sampling

aller Pixel

OGSSAA Ordered Grid Super-Sampling-AA SSAA mit geordnetem Abtastmuster

SGSSAA Sparse Grid Super-Sampling-AA SSAA mit gestreutem Abtastmuster

MSAA Multi-Sampling-Anti-Aliasing Überbegriff für mehrfaches Sampling

von Polygonkantenpixeln

SGMSAA Sparse Grid Multi-Sampling-AA MSAA mit gestreutem Muster – der

Standard seit Jahren

TMSAA Transparency Multi-Sampling-AA Nvidias MSAA für transparente Texturen

TSSAA Transparency Super-Sampling-AA Nvidias SSAA für transparente Texturen

AAA Adaptive Anti-Aliasing AMDs adaptives AA für transparente

Texturen

CSAA Coverage Sample Anti-Aliasing Nvidias Erweiterung von MSAA

EQAA Enhanced-Quality Anti-Aliasing AMDs Erweiterung von MSAA (erst seit

der HD-6900-Reihe verfügbar)

CFAA Custom Filter Anti-Aliasing AMDs verbesserte Downfilter für glattere

Bilder; fungiert als „Aufsatz“ für MSAA

oder SSAA (verfügbar ab HD 2000)

MLAA Morphological Anti-Aliasing AMDs Post-Processing-AA im Catalyst-Treiber

FXAA Fast Approximate Anti-Aliasing Günstiges, kontrastbasiertes Post-Process-AA

SRAA Subpixel Reconstruction AA Fortschrittliches Post-AA, derzeit in

Entwicklung

EER Edge-Equivalent Resolution Qualitätsmerkmal von FSAA (mehr =

besser)

TXAA Temporal Approximate AA Shader-basiertes AA-Verfahren v. Nvidia

So funktioniert

Anti-Aliasing

Früher war vieles einfacher

– aber nicht besser!

Die ersten polygonbasierten

Spiele Anfang der 90er-Jahre

hatten andere Probleme als

fehlendes Anti-Aliasing: Wo nur

ein paar Hundert Vielecke pro

Bild auftauchen, gibt es auch

wenige Kanten, die man glätten

müsste.

Ein Blick zurück

Erst um die Jahrtausendwende

hatten Spiele ein Grafikniveau

erreicht, das eine genauere Berechnung

lohnenswert machte.

3dfx stellte im Jahr 2000 erstmals

hochwertige Bildglättung

in den Vordergrund: Sparse

Grid Supersampling-AA (SGS-

SAA). Doch die Wahrnehmung

der Spieler war damals noch

nicht so weit, Anti-Aliasing

galt als Effekt, der das Bild unscharf

macht – und zudem viel

Leistung kostet. Mit 3dfx verschwand

auch SGSSAA von der

Bildfläche und der Siegeszug

des Multisamplings (MSAA) begann.

Rasterizing:

Probleme …

Jedes aktuelle Spiel basiert auf

Rastergrafik. Dabei werden die

ursprünglichen Vektorgrafiken

„rasterisiert“, das heißt durch

einzelne Bildpunkte (picture

elements = Pixel) dargestellt.

Da deren Anzahl limitiert ist,

geht dieser Schritt mit Informationsverlust

einher: Wird ein filigranes

Objekt mit zu wenigen

Pixeln abgetastet („gesampelt“),

bleiben Feinheiten auf der Strecke,

die sich nicht rekonstruieren

lassen. Besonders fatal ist

dies in Bewegung, beispielsweise

wenn Sie in Battlefield 3

an einem Zaun vorbeirobben.

Der Draht ist in Entfernung feiner

als ein Pixel, also ein Aliasing-Ernstfall.

Nun gilt: Entweder

liegt das Drahtstück in der

Mitte des Pixels – dann wird es

dargestellt – oder eben nicht,

dann fehlt das Stück vor Ihren

Augen. Das Kernproblem ist,

dass mehrere Texel um einen

einzigen Darstellungsplatz als

Pixel kämpfen. In Bewegung resultiert

dies in einem unschönen

Abwechslungsspiel, bei

dem die Feinheiten des Zauns

wild durchs Bild flimmern.

Ähnliches gilt bei der Darstellung

von Vegetation (etwa in

Crysis) oder Texturen und Pixel-Shadern,

bei denen die Entwickler

Abtastregeln missachten.

Ebenfalls der endlichen

Auflösung (Gesamtheit der Pixel)

geschuldet ist der berüchtigte

Treppeneffekt: Es ist unmöglich,

Schrägen mithilfe

eines Pixelrasters darzustellen,

ohne dass Abstufungen sichtbar

sind – rechte Winkel hingegen

liegen oft genau auf dem Raster.

… und Lösungsversuche

Treppchenbildung ist unnatürlich

– die Realität wird schließlich

mithilfe einer unendlichen

Auflösung dargestellt. „Dann erhöhen

wir einfach die Anzahl

der Pixel“, werden Sie jetzt denken.

Richtig, mehr Bildpunkte,

also eine feinere Abtastung, helfen

gegen Alias-Effekte. Spielen

Sie in 1.920 x 1.080 (Full HD),

wird die Grundinformation gegenüber

1.280 x 720 mit mehr

als doppelt so vielen Pixeln wiedergegeben.

Das ist fein, denn

Sie bekommen mehr Details


Grafikkarte

und gemindertes Aliasing zu Gesicht.

2.560 x 1.600 legt gegenüber

Full HD nochmals um Faktor

2 zu. Dieses Spiel ist nicht

zielführend, da keine Endkunden-Monitore

mit einer noch

höheren Auflösung existieren

und der Rechenaufwand linear

mit der Pixelzahl zunimmt. Was

also tun?

Supersampling(-AA)

Wenn sich die Anzahl der Pixel

nicht weiter steigern lässt, muss

während des Renderings die

Abtastung pro Pixel erhöht werden.

Genau das passiert beim

Supersampling (super = über/

mehr): Jeder Bildpunkt wird

an verschiedenen Stellen mehrfach

erfasst und die Über-Information

vor der Ausgabe an den

Monitor verrechnet. Letzteren

Vorgang, bei dem ein Tiefpassfilter

(Downfilter) angewandt

wird, nennt man im Fachjargon

„Downsampling“. An dessen

Ende entstehen Farbzwischenstufen,

ein gewollter Effekt, den

Sie als Anti-Aliasing kennen.

Beim Supersampling passiert

dies mit jedem Bildpunkt, es

entsteht eine Vollbildglättung –

Full-Scene-AA (FSAA). Ob die Anzahl

der Pixel verdoppelt oder

pro Pixel die doppelte Samplezahl

genommen wird, spielt

für den Rechenaufwand theoretisch

keine Rolle, die enormen

Leistungskosten bleiben.

Supersampling-AA mit gestreutem

Abtastmuster ist nach wie

vor das hochwertigste AA-Verfahren.

Multisampling(-AA)

Die Überlegung hinter Mul -

tisamp ling (multi = mehrfach)

lautet: Warum sollte das

komplette Bild x-fach berechnet

werden, wenn man nur

die Kanten glätten will? Beim

MSAA werden daher nur die

Pixel an Polygonkanten mehrfach

berechnet, um Rechenzeit

zu sparen. In der Folge wurde

MSAA anno 2001, als es mit Nvidias

Geforce 3 debütierte, als

„High-Res-AA“ beworben. Zwar

war es damals aufgrund mangelnder

Effizienz nicht deutlich

schneller als SSAA, aber es war

klar, wohin die Reise geht. Für

die Texturverbesserung, zuvor

vom SSAA erledigt, wurde der

anisotrope Filter geboren.

Die Kombination aus MSAA und

AF brachte einige Jahre hübsche

Bilder. Mit dem Aufkommen

pixelbasierter Effekte und

Einsparungen am AF – Dinge,

die von MSAA nicht erfasst werden

– wurden die Rufe nach

besserem AA lauter. Erst im

Herbst 2009 wurde deren Idee

im Retail-Markt wiederbelebt:

AMD startete mit der HD-5000-

Serie die Renaissance des SGS-

SAAs, Nvidia folgte (inoffiziell).

Post-Processing-AA

Die beliebten Deferred-Renderer

sind – zumindest unter

DX9 und auf den DX9-Konsolen

– praktisch inkompatibel zu

MSAA. Sie werden dennoch genutzt,

um aufwendige Szenen

mit zahlreichen Lichtquellen

effizient zu berechnen. Supersampling

ist nach wie vor möglich,

wird jedoch aufgrund der

Rechenkosten gemieden. Um

das Bild dennoch zu glätten,

schossen in jüngster Vergangenheit

einige neue Verfahren

aus dem Boden. FXAA, MLAA

und Konsorten glätten das Bild

erst nach der fertigen Berechnung,

weshalb sie als Aufsatz

fungieren können, wenig Leistung

kosten und in immer mehr

Spielen auch angeboten werden

(mehr dazu auf der folgenden

Doppelseite). Qualitativ ist

„echtes“ AA aber besser.

Wie Supersampling die

Bildqualität verbessert

Da Multisampling nur die Geometrie (Polygonkanten) bearbeitet, bleibt

alles Weitere unangetastet. Die Folge: In zahlreichen Spielen flimmern

Texturen, Pixel-Shader oder Specular Maps. Dagegen hilft nur

Supersampling, egal ob als SGSSAA per Grafiktreiber oder via Downsampling

(= OGSSAA). Beim SSAA wird jedes Pixel super, das heißt

mehr als nur einmal gesampelt, mit der Folge, dass das ganze Bild eine

Glättung erfährt. Der Nachteil: N-faches SSAA kostet n-fache Leistung,

weshalb günstige Alternativen wie FXAA entwickelt werden.

Half-Life 2: „Shader-Wasser“ mit Multisample-AA – keine Glättung, pixelig

Half-Life 2: „Shader-Wasser“ mit 8x Supersample-AA – glatt und flimmerfrei

GTA 4 Original: Keine Kantenglättung möglich, Spiel flimmert

GTA 4 mit Downsampling: Vollbild-Glättung (hier: 2x2 = 4x OGSSAA)


Grafikkarte

So funktioniert

Post-Processing-AA

te und flimmrige Kontraste

werden vermischt. Das sieht

im Stand oft hervorragend aus,

kann in Bewegung aber nur wenig

gegen Aliasing auf Subpixelebene

ausrichten.

Bei einem Postfilter handelt

es sich um einen

Effekt, der am Ende des

eigentlichen Rendervorgangs

angewendet wird. Dies kann helfen,

den erforderlichen Rechenaufwand

zu reduzieren. Beispiele

für Post-Effekte sind Bloom

(Voll bild-Überstrahlung),

SSAO (Schattierung) und kontrastbasiertes

Anti-Aliasing.

FXAA, MLAA und Co.

Im Unterschied zu echter Kantenglättung,

die während der

Kalkulation jedes einzelnen

Bilds wirkt und Aliasing an der

Wurzel behandelt, tritt Post-AA

erst am Ende der Renderkette

in Kraft. Der Zweck: Linderung

der Aliasing-Beschwerden. Was

nach einer Eier legenden Wollmilchsau

klingt, ist aber nur ein

notdürftiger Ersatz für Superund

Multisampling.

Die Entstehung von FXAA,

MLAA und weiteren Post-AA-

Modi ist eng mit Speichermangel

auf Konsolen und dem Deferred-Rendering

verzahnt.

Letzteres Verfahren erlaubt

dank seiner hohen Effizienz

auch auf schwachbrüstiger

(Konsolen-)Hardware hübsche

Grafik und wird daher immer

öfter verwendet. Unglücklicherweise

kollidiert seine Funktionsweise

mit MSAA – zumindest

auf der DX9-Basis. SSAA ist

auch mit einem Deferred-Renderer

möglich, wird aufgrund

des Leistungshungers aber verschmäht.

In der Folge entwickelte man

Methoden, um die ohne AA gerenderten

Szenen nachträglich

aufzupolieren – Post-AA war geboren.

Post-AA in aktuellen

Spielen

Metro 2033 bot im Frühjahr

2010 als erstes Spiel die Option

auf „Analytical-AA“ (AAA),

primär, um unter Direct 3D 9

irgendeine Form der Glättung

bereitzustellen. Unter DX11/10

steht außerdem 4 x MSAA zur

Verfügung – sehr rechenaufwendig

und speicherintensiv,

weshalb AAA erstmals in

das Bewusstsein der Spieler

rückte. Mittlerweile ist es das

Fast-Approximate-AA (FXAA),

das, nomen est omen, dank

schneller Berechnung in zahlreichen

Neuerscheinungen angeboten

wird.

Neben den geringen Leistungskosten

spricht vor allem der

Vollbild-Effekt für FXAA: Wie

beim Supersampling wird das

komplette Bild bearbeitet, har-

MLAA

Zum Start von Barts, dem Herz

der Radeon-HD-6800-Grafikkarten,

integrierte AMD eine eigene

Post-AA-Methode in den Catalyst-Treiber:

Morphologische

Filterung, kurz MLAA. Hierbei

handelt es sich um einen anderen

Algorithmus als bei FXAA,

eine kontrastbasierte Vollbildglättung

ist aber auch hier Programm.

MLAA geht relativ aggressiv vor,

es werden auch Objekte „geschliffen“,

die es nicht unbedingt

nötig hätten – aus spitzen

Ecken werden mitunter Rundungen.

Bei FXAA bleibt dieser

Effekt aus, obgleich es ebenfalls

Unschärfe über das komplette

Bild legt – eine Kanten-Erkennung

(Edge-Detection) scheint

noch etwas Hirnschmalz bei

der Weiterentwicklung zu erfordern.

Überblick der wichtigsten Post-Processing-Methoden

FXAA und MLAA sind die bekanntesten

Post-AA-Modi, da sie einfach

zu integrieren sind. Die Nachteile,

etwa Unschärfe über das gesamte

Bild und der Mangel an Subpixel-Information,

die richtige Hilfe gegen

Flimmern verhindert, rufen neue

Algorithmen auf den Plan.

Raster (Vector Input) 1x AA (kein AA) MLAA SRAA

16.384x OGSSAA

SRAA (Subpixel Reconstruction

AA) und SMAA (Enhanced Subpixel

Morphological Antialiasing) versuchen

sich an der Rekonstruktion

von Subpixel-Info. Das sieht stellenweise

sehr gut aus, SRAA muss

allerdings in Spiele integriert werden

– Treiber-Forcierung ist nicht

möglich. SMAA gibt es als Inject.

Bild: Nvidia


Grafikkarte

Bei „Downsampling“ handelt

es sich um ein Kantenglättungsverfahren,

das ohne Ausnahme funktioniert

– im Gegensatz zu Multisample-AA,

welches mit vielen

neuen Spielen inkompatibel ist

oder trotz hoher Leistungskosten

nicht alle Kanten erfasst.

Downsampling:

Funktionsprinzip

Das Downsample-Funktionsprinzip

ist simpel: Die Spiele

werden von der Grafikkarte intern

mit einer sehr hohen Auflösung

berechnet und vor der

Ausgabe an den Monitor, der

eine geringere Auflösung darstellt,

he runtergerechnet. Der

letztgenannte Vorgang, bei dem

die Über-Information der internen

Auflösung auf das kleinere

Ausgabeformat gebracht wird,

nennt sich (namensgebend)

Downsampling.

Je größer die interne von der

externen Auflösung abweicht,

desto besser ist die Glättung

des ausgegebenen Bildes. Allerdings

ist es nicht zielführend,

intern wahllose Pixelmengen

zu berechnen, ideal

So funktioniert

Downsampling

sind ganzzahlige Faktoren. Ein

Beispiel dafür: Pro Achse, X

und Y, werden pro nativ dargestelltem

Pixel zwei Bildpunkte

verrechnet, was der Auflösung

3.840 x 2.160 zu 1.920

1.080 entspricht. Da jedes Picture

Element (Pixel) nur einen

Farbwert haben kann und

der Faktor 2:1 beträgt, werden

die Farben umliegender Pixel

gleichwertig miteinander verrechnet.

Downsampling-

Zukunft

Weder AMD noch Nvidia bieten

eine offizielle Unterstützung

für Downsampling an, die Technik

ist nach wie vor ein Feature

für Bastler. Dabei wissen die

beiden großen GPU-Hersteller

über die Beliebtheit des Features

bei Enthusiasten Bescheid

– doch nur Nvidia macht kleinere

Fortschritte auf dem Gebiet.

Wie Downsampling als

anisotroper Filter wirkt

Der durch Downsampling mögliche Gewinn an Texturqualität lässt sich

auch in Zahlen fassen: Wird die Render-Auflösung pro Achse verdoppelt,

dann tut es ihr der Anisotropie-Grad gleich. 3.840 x 2.160 bringt

auf 1.920 x 1.080 Pixel heruntergerechnet 2:1 AF. Zusammen mit 16:1

AF per Treiber bekommen Sie folglich 32:1 AF zu Gesicht, durch 2.880

x 1.620 noch 24:1 AF. Bei Radeon-Karten liegt das Limit bei ~22:1 AF

(2.720 x 1.530 Pixel).

WoW in 1.920 x 1.080

(kein AF, trilineare Filterung)

WoW in 3.840 x 2.160

(kein AF, trilineare Filterung)

Wie Downsampling für eine hochwertige Grafik sorgt

In hohen Auflösungen werden Texturdetails auch bei ungünstigen Winkeln länger aufrechterhalten als in niedrigen. Down sampling hilft ergo, dass filigrane

Strukturen nicht in einem groben Pixelraster verschluckt werden.

Bioshock Infinite in 1.920 x 1.080 (kein AF)

Bioshock Infinite in 3.840 x 2.160 (kein AF)


Grafikkarte

SLI-on-a-Stick: Nvidia Geforce GTX 690

So funktionieren

Multi-GPU-Systeme

Ähnlich wie bei der Anzahl von Prozessoren

und deren Kernen lässt sich auch

die Grafikleistung steigern, indem mehrere

Chips parallel betrieben werden.

AMD wie Nvidia setzen seit Jahren auf Multi-GPU-Systeme – wie hier

auch auf einer einzigen Grafikkarte – als Speerspitze auf der Jagd nach

Benchmarkrekorden.

Der Slogan „Die Kraft

der zwei Herzen“ trifft

auf Grafikkarten schon

deutlich länger zu als auf Prozessoren

– zumindest für den

Heimanwender. Die Möglichkeit,

zwei Grafikkarten zu koppeln,

gab es schon im vorigen

Jahrtausend. Doch wie funktionieren

Multi-GPU-Systeme und

warum kommt es dabei bis heute

manchmal immer noch zu

Problemen?

Teamarbeit in der

IT-Steinzeit

Prozessoren sind nicht immer

so hoch integriert gewesen, wie

wir sie heute kennen. In den

Anfangsjahren und -jahrzehnten

war es eher die Regel als die

Ausnahme, dass verschiedene

Teile eines Systems in einzelne

Mikrochips gegossen waren.

Intels berühmt-berüchtigter

iAPX-432-Flop zum Beispiel

sollte zu Beginn der 1980er-Jahre

in drei einzelnen Chips – einer

zum Einlesen, einer zum

Berechnen und einer für die

Peripherie – die x86-Architektur

beerben. Diese nutzte selbst

jahrelang mehrere Chips: den

Hauptprozessor, die North- und

Southbridge (zusammen der

„Chipsatz“) und optional eine

x87-Gleitkommaeinheit.

Bei üblichen Grafikkarten fand

als letzter separater ASIC (Application

Specific Integrated

Circuit) der RAMDAC zur Signalumwandlung

für die Ansteuerung

analoger Monitore

den Weg in den integrierten

2D-Grafikchip.

Die gute alte Zeit

Mit dem Aufkommen von

3D-Beschleunigung erlebte

auch der einstige Multi-GPU-König

3Dfx seinen Aufstieg zum

Branchenprimus. Entgegen der

landläufigen Meinung nutzte

die „Voodoo-Grafik“ nämlich

schon auf den Einsteigerprodukten

das Zusammenspiel

mehrerer Chips: einer Bildpuffer-

und einer Textur-Einheit.

Die anfangs nur im professionellen

Markt erhältliche Kopplungstechnik

SLI, das steht damals

für Scan Line Interleave

(die Erklärung folgt später),

bringt 3Dfx 1998 mit der Voodoo

2 auch in den Spielermarkt.

Die Vorteile waren enorm:

Nicht nur erlaubte ein V2-SLI,

wie die Kombination aus insgesamt

sechs Recheneinheiten

auf zwei Karten abgekürzt wurde,

gegenüber einer Einzelkarte

die Erhöhung der maximalen

Auflösung von 800 x 600

auf 1.024 x 768 Pixel inklusive

Z-Puffer.

Auch die Fps-Leistung stieg in

den meisten Spielen deutlich

an, wenn der Hauptprozessor

die Daten nur schnell genug anliefern

konnte. So verwundert

es nicht, dass V2-SLI bald zur

Standardausrüstung gut betuchter

Gamer gehörte. Denn mit

Preisen von knapp 500 DM für

die 8-MiB- und knapp 600 DM

für die 12-MiB-Version war ein

Multi-GPU-System auch damals

kein billiges Vergnügen.

Viel mehr Leistung

Doch viel wichtiger war die Skalierbarkeit

der Lösung, also die

maximal mögliche Steigerung

der Bildrate. Von vielen im-


Grafikkarte

mer noch als Heiliger Gral der

Multi-GPU-Systeme angesehen,

hatte es 3Dfx’ Scan Line Interleave

wesentlich einfacher als

heutige Lösungen, die Bildrate

ohne Nebenwirkungen zu verbessern.

Die geometrische Vorarbeit,

also das Berechnen des

kompletten Dreiecksgerüstes

eines jeden Bildes, wurde damals

noch vom Hauptprozessor

ausgeführt, sodass sich die beteiligten

Grafikchips lediglich

um die Pixelarbeit kümmern

mussten.

Mehrere, in der Regel zwei,

Karten arbeiten bei 3Dfx’ Scan

Line Inter leave gemeinsam

an der Berechnung jedes einzelnen

Bildes, welches dafür

in Zeilen(-gruppen) aufgeteilt

wurde. Bildübergreifende Darstellungstechniken,

vor allem

die sogenannten Post-Processing-Effekte,

gab es zu dieser

Zeit noch nicht. Daher können

die Voodoo-Chips noch problemlos

nach dem Fire-and-Forget-Prinzip

rechnen, denn einmal

berechnete Daten muss

die Zweitkarte nur über das interne

Kabel an die Primär-Voodoo

schicken, damit diese es

zusammen mit ihren eigenen

Bildzeilen an den Monitor sendet.

Geometrie und

Nachbearbeitung

Mit Direct X 7 kam hardwarebeschleunigtes

„Transform and

Lighting“, kurz HTnL, in den

Massenmarkt und die Geometrieverarbeitung

auf den Grafikchip.

Das erschwerte die Arbeitsteilung

mehrerer GPUs,

da man nun die Geometriearbeit

doppelt machen oder auf

die Hardwarebeschleunigung

verzichten musste, um den Pixelpart

dahinter aufteilen zu

können. Denn quasi „mitten im

Chip“ kann die nun fertig berechnete

Geome trie nicht mehr

abgefangen werden, um sie zeilenweise

auf die immer noch

chronisch überlasteten Pixelbeschleuniger

zu verteilen.

SLI-Pionier 3dfx (nun mit kleinem

„d“) entzog sich durch

einstweiligen Verzicht auf

HTnL dieser Problematik. Doch

andere Hersteller sannen auf

eine Lösung des Problems, darunter

Ati (später von AMD

aufgekauft) und die Firma 3D

Labs, Hersteller professioneller

3D-Beschleuniger für Workstations.

Während Letzterer auf

der Wildcat Realizm 800 einen

separaten Geometriebeschleuniger

(VSU, Vertex Scalable

Unit) vor zwei normale Grafikchips

schaltete, versuchte sich

Ati an der Rage Fury Maxx.

AFR-Technik

Diese setzte auf zwei ganz normale

Rage-Grafikchips samt jeweils

eigenem, 32 Megabyte

großem Grafikspeicher, wie sie

die Kanadier auch einzeln auf

ihren Grafikkarten verkauften.

Jeder dieser Chips arbeitete an

einem kompletten, eigenen

Bild, sodass auf Kosten eines

zusätzlichen Bilds die Bildrate

teils verdoppelt werden konnte.

Dieses AFR genannte Verfahren

erklären wir zusammen

mit anderen Möglichkeiten

auf der folgenden Seite. Da jedoch

die Rage- 128-Chips noch

über keine HTnL-Einheit verfügen,

musste der Prozessor dafür

schnell oder die Grafiklast hoch

genug sein.

Der Rage Fury Maxx war mit

dem Aufkommen von Windows

2000 ein jähes Ende beschieden,

da die Treiber nicht zur

AFR-Mitarbeit unter dem neuen

Betriebssystem bewegt werden

Warum Multi-GPU-Technik

schon jahrzehntealt ist

Multi-GPU-Systeme existierten bereits lange vor der Einführung des

Begriffs „GPU“ – die Technik stammt eigentlich aus dem Profibereich.

Bevor es „richtige“ 3D-Chips gab, arbeiteten bereits viele spezialisierte

Prozessoren zusammen an der Darstellung von 3D-Grafik – die damals

zumindest für die Echtzeitbearbeitung allerdings nur aus Drahtgittermodellen

bestand. Diese Chips wurden mit der Zeit immer spezialisierter,

sodass sich auf Workstation-Karten etwa von Evans & Sutherland,

Intergraph oder 3D Labs zunehmend die Aufteilung auf einen Geometriebeschleuniger

und einen Raster-Chip herauskristallisierte.

Im Gegensatz zu Direct X profitierte die Open-GL-Schnittstelle aus

diesem Grund auch quasi automatisch von GPUs mit Hardware-TnL.

Mit 3Dfx betrat 1996 ein neuer Spieler das Feld. Seine Wurzeln liegen

ebenfalls im professionellen Bereich, kamen die Gründer doch von Silicon

Graphics Inc. (SGI). Bei 3Dfx konzentrierte man sich von Anfang an

auf Spielegrafik – Voodoo Graphics war eigentlich für Spielhallen-Geräte

vorgesehen und setzte direkt auf die Zusammenarbeit mehrerer

Grafikchips auf verschiedenen Ebenen. Mindes tens ein sogenannter

Texel- und Pixel-FX waren nötig, damit überhaupt ein Bild entstand.

Optional ließen sich mehrere Karten per Scan Line Interleave, kurz SLI,

koppeln.

Was im Endkundenmarkt zunächst ein Preistreiber war, bedeutete für

Arcade-Automaten einfache Skalierbarkeit für verschiedene Aufgabengebiete,

sprich Spiele mit unterschiedlicher Komplexität. Den PC-

Markt eroberte man dagegen eher zufällig dank eines zeitlich genau

passenden Preisrutsches beim EDO-Speicher, welcher es erlaubte, die

Karte für rund 400 DM anzubieten.

Überblick: Multi-GPU-Anbieter

und -Lösungen

Hersteller Multi-GPU-Lösung Bemerkungen

3Dfx Scan Line Interleave Der Consumer-„Urvater“

3D Labs Vertex/Scalability Unit Separater Vertexprozessor

Ati (später AMD) Crossfire/Crossfire X Bis heute im Einsatz

Nvidia Scalable Link Interface Bis heute im Einsatz

S3 Multi-Chrome Rein PCI-E-basiert

XGI „Duo“ Nur auf Dual-GPU-Karten


Grafikkarte

konnten und die neue, schnellere

Generation sowieso vor der

Tür stand.

Spätestens mit den vereinheitlichten

Shader-Prozessoren ab

Direct X 10 spielte das Problem

der doppelten Geometrieverarbeitung

zumindest aus Leistungssicht

nur noch eine untergeordnete

Rolle.

Post-Processing

Die zweite, weitaus gravierendere

Herausforderung jedoch

wurde mit der Zeit immer verheerender:

Nachbearbeitung

oder im IT-Sprech Post-Processing.

Dabei handelt es sich um

Filter oder Effekte, die auf das

komplette, fertige Bild angewandt

werden.

Was bei einzelnen Render-

Frames noch kein größeres Problem

im Zusammenhang mit

Multi-GPU-Systemen ist, wird

spätestens dann schwierig,

wenn ein Effekt Daten aus mehreren

Bildern verrechnen will.

Besonders spaßig wird es, sobald

das heute nahezu durchgehend

genutzte Alternate- Frame-

Rendering-Verfahren dabei zum

Einsatz kommt – doch dazu später

mehr.

Das Problem mit den

Bilddaten

Ein prominentes Beispiel für einen

solchen „Problem-Effekt“

ist die Bewegungsunschärfe.

Sofern sie nicht von der Spielengine

her bereits auf die Verwendung

mehrerer Grafikprozessoren

ausgelegt ist – denn

auch das wäre denkbar –, werden

hier die Daten mehrerer,

fertig berechneter Bilder benötigt,

um das optische Nachziehen

in Bezug auf Geschwindigkeit

und Richtung korrekt

umzusetzen.

In einem Multi-GPU-System

müsste nun theoretisch vor jedem

Bildwechsel einmal das aktuell

berechnete Werk an die

beteiligten GPUs verschickt

werden, damit diese für die

kommende Aufgabe die richtigen

Ausgangsdaten, also das aktuelle

Bild vorliegen haben.

Das gilt für Verfahren wie Tiling

und SFR. Doch sobald AFR ins

Spiel kommt, müssen die GPUs

streng genommen sogar in Reihe

arbeiten, wenn Sie jeweils

auf das zuletzt gerenderte Bild

ihres Partners warten und erst

dann selbst loslegen können.

Eine solche Konstellation erklärt

auch manchen Performance-Verlust

beim Einsatz eines

SLI- oder Crossfire-Systems.

Seit der (Wieder-)Einführung

von Multi-GPU-Systemen 2005

arbeiten die Entwickler-Kontakte

von Nvidia und AMD allerdings

mit Hochdruck daran,

dass in Spielen keine solchen

Performance-Killer mehr zum

Einsatz kommen – jedoch haben

sie dabei nicht immer Erfolg.

Mikroruckel-Manifestation

Aktuelle Multi-GPU-Systeme

sind, abgesehen von ihren Anschaffungs-

und Betriebskosten,

von drei Problemen geplagt,

die wir auch in diesem Artikel

nicht unerwähnt lassen wollen:

Abhängigkeit von einem funktionierenden

Treiberprofil, Eingabeverzögerung

und Mikroruckeln.

Treiberprofil

Ohne Ersteres weiß der Treiber

nicht, wie er die Arbeit möglichst

gut auf die beiden GPUs

verteilen soll, und arbeitet in einem

Standardmodus. Das kann

bei Spielen mit bekannter Engine

wie der UE3 recht gut funktionieren,

aber sogar ein Absinken

der Leistung bewirken.

Nvidia erlaubt Fortgeschrittenen

in Programmwerkzeugen

von Drittanbietern über sogenannte

SLI-Bits manuelle Eingriffe.

Die Treiberabteilungen von

AMD und Nvidia sind bemüht,

den Treiber für „wichtige“ Titel

rechtzeitig zur Veröffentlichung

oder groß angelegten Beta-Phase

fit zu machen. In seltenen Fällen

jedoch wird, wenn ein Spiel

größere Probleme bereitet, in

den Single-GPU-Modus zurückgeschaltet,

sodass der Spieler zumindest

keine Nachteile mehr

in Kauf nehmen muss.

Eingabeverzögerung

Die Eingabeverzögerung wird

durch den AFR-Modus bedingt,

weil hier schlicht und ergreifend

mindestens ein zusätzliches

Bild gerade „in Bearbeitung“

ist, welches in den Ablauf

von Eingabe, Verarbeitung und

Ausgabe eingebunden werden

muss und so die Verzögerung

zwischen Steuerbefehl

und Ausgabe des Monitorbildes

erhöht. Mit Direct X 11.2,

welches derzeit an Windows

8.1 gebunden ist, bringt Microsoft

mit „SetMaximumFrame-

Latency“ ein neues Kommando;

im Idealfall lässt sich damit

vom Entwickler beeinflussen,

wie hoch die Eingabeverzögerung

ausfallen darf – völlig klar

sind Funktion und Umsetzung

jedoch noch nicht.

Mikroruckeln

Das erwähnte Mikroruckeln

kann mehrere Ursachen haben

und wird technisch am besten

durch stark unregelmäßige

Bildlaufzeiten beschrieben,

die zum Beispiel durch Übertragung

von Bildinformationen

zwischen verschiedenen GPUs

zustande kommen können. So

kann ein Benchmark 30 Fps

bescheinigen, was 33 ms pro

Bild entspräche. Die ungleiche

Verteilung führt nun aber

dazu, dass Bild 1 nach 33 ms

ankommt, das parallel berechnete

Bild 2 mit 2 Millisekunden

Verspätung und weitere

Ergebnisse erst mal 64 Millisekunden

auf sich warten lassen.

Durch die Ungleichmäßigkeit

entsteht zwar kein Ruckeln im

eigentlichen Sinne, aber winzige

Hakler können sichtbar

werden und in jedem Fall fühlt

sich ein Spiel nicht so flüssig

an, wie es mit 30 gleichmäßigen

Bildern pro Sekunde der

Fall wäre.

Nvidia versucht derzeit, dem

mit einer Ausgabesteuerung im

Treiber entgegenzuwirken, und

auch AMD kündigte unlängst einen

Treiber mit sogenanntem

„Frame Pacing“ an.

Multi-GPU-Renderingverfahren

AMD und Nvidia haben es mit ihren

aktuellen Verfahren schwer,

ein einwandfreies Spiel erlebnis

anzubieten. Alternative Verfahren

stünden bereit und sind

auch bereits genutzt worden,

doch SFR und Tiling erfordern

mehr Aufwand bei der Arbeitsverteilung

und bringen keine

so eindrucksvollen Fps-Steigerungen

in Benchmarks.

Immerhin arbeiten beide Hersteller

inzwischen mehr oder

weniger aktiv an Lösungen,

um die Bildausgabe gleichmäßiger

zu gestalten. So wird

Multi-GPU-Rendering bis auf

Weiteres eine Ergänzung für

ambitionierte Anwender im

High-End-Bereich bleiben.


Grafikkarte


Wie Multi-GPU-Rendering funktioniert

Alternate Frame Rendering

Das meist als AFR abgekürzte Verfahren wird heute mit Abstand am häufigsten

genutzt, weswegen wir es zuerst beschreiben.

Beim AFR werden die beteiligten Grafikchips immer mit der Berechnung

eines kompletten Bildes beauftragt, welches sie nach Fertigstellung über

die MGPU-Brücken und/oder den PCI-Express-Anschluss an die Hauptkarte,

an welcher der Monitor angeschlossen ist, zurücksenden. Mithilfe

dieser Technik ist mit bis zu100 Prozent Fps-Zuwachs pro beteiligter GPU

die theoretisch höchste Leistungssteigerung möglich – was wohl auch ein

Grund für die Beliebtheit des Verfahrens ist. Ein weiterer Vorteil von AFR

ist die einfache Verteilung der Arbeit auch auf mehr als zwei Grafikkarten.

Die Nachteile wie eine erhöhte Eingabeverzögerung (Inputlag) werden

dabei prinzipbedingt in Kauf genommen. Auch die Tendenz zu Mikrorucklern,

verursacht durch ungleichmäßige Bildberechnungszeiten, muss sich

der Jagd nach höheren Bildraten meist unterordnen.

Split Frame Rendering

Das SFR-Verfahren ist dem Scan-Line-Interleave ähnlich: Das Bild wird

streifenweise zwischen den beteiligten Grafikkarten aufgeteilt.

Beim SFR, auch als Scissoring bekannt, wird das Bild horizontal geteilt.

Die Anzahl der Streifen ist theoretisch variabel, in der Praxis wurde bei

dem heute kaum noch genutzten Verfahren aber meist grob 60:40 zwischen

oberer und unterer Bildhälfte aufgetrennt, da im oberen Bereich

meist die wenig rechenintensive Himmelstextur den Löwenanteil der Fläche

beanspruchte und man eine möglichst gleichmäßige Verteilung der Rechenlast

für das komplette Bild erreichen wollte. Da die Dreiecke ohne Engine-Unterstützung

in der Regel erst nach der Rasterisierung der Bildhälfte

zugeordnet werden können, muss die Geometrieverarbeitung entweder

von einem separaten Prozessor oder auf jedem der Grafikchips redundant

erfolgen. SFR erlaubt, besonders in einer dynamischen Version, eine noch

gute Lastverteilung, aber keine Fps-Gewinne von 100 Prozent wie AFR.

GPU 2

GPU 1

GPU 1

GPU 2

(Super) Tiling

Tiling stammt vom englischen Wort für Kachel und entsprechend wird das

Bild hier nicht nur horizontal, sondern auch vertikal aufgeteilt.

Wie beim SFR muss hier für Geometrie zusätzlicher Aufwand betrieben

werden, da erst spät im Renderprozess feststeht, in welchem Bildbereich

das fertige Dreieck liegt. Mehr noch: Es kann auch in verschiedene

„Tiles“(oder Streifen) hineinragen und muss dann natürlich entsprechend

an alle ausführenden GPUs verteilt werden. Doch das Tiling hat einen entscheidenden

Vorteil: Es skaliert aufgrund der horizontalen wie vertikalen

Unterteilung unabhängig vom Bildinhalt gut mit einer variablen Anzahl an

GPUs und lastet diese voll aus. Theoretisch ist es bei verteiltem Rechnen

wie Raytracing-Farmen sogar möglich, vollkommen unterschiedliche

Prozessoren einzusetzen. Im Echtzeitbereich jedoch spielt auch der

Verteilungsaufwand eine wichtige Rolle, sodass von diesem Verfahren im

praktischen Einsatz wieder Abstand genommen wurde.

Scan Line Interleave

Der Urvater aktueller Multi-GPU-Systeme verteilt die Pixellast auf fest den

einzelnen GPUs zugeordneten Bildschirmstreifen.

Als 3Dfx die Multi-GPU-Bühne betrat, war die Pixelwelt noch in Ordnung,

sprich einfach und übersichtlich. Wenn der Arbeitsauftrag an die Pixelbeschleuniger

erging, war bereits klar, wo in der Szene welche Objekte und

Dreiecke hingehörten, und es musste sich nur noch um die Bildpunkte mit

überschaubarer Effektvielfalt gekümmert werden. Entsprechend leicht war

es für das Scan-Line-Interleave-Verfahren, das Bild in Streifen zu zerteilen

und an verschiedene Grafikkarten oder -chips zu verteilen. 100 Prozent

gesicherte Informationen sind schwer zu bekommen, doch deutet die verfügbare

Dokumentation auf einzeilige Streifen bei Voodoo und Voodoo 2

hin – Quad-basierte Pipelines und Texturcaches gab es noch nicht. Bei der

Nachfolgearchitektur VSA-100 auf den Voodoo-5-Karten sollen es dagegen

32 Pixel breite Interleaves gewesen sein. Mit einem solchen Schema konnte

man die Lokalität der Texturdaten mithilfe der Texturcaches besser nutzen.

GPU 1

GPU 2

GPU 1

GPU 2


Das TesT-Magazin

für digitale UnterhaltUng

das beste aUs allen technik-Welten:

Flat-TVs | Smartphones | Tablets | Notebooks | Digitalkameras | Video | HiFi

plus: die coolsten sPiele und alle film-blockbUster

Auch als

Magazin-Variante

ohne DVD

für € 2,99

QR-Code scannen

und hinsurfen!

WWW.sPielefilmetechnik.de

Neue Ausgabe jetzt am Kiosk erhältlich

oder einfach online bestellen unter:

shop.spielefilmetechnik.de

Auch erhältlich als ePaper bei:

Mainboards


Mainboard

Auf der Epoxidharz-

Platine eines Mainboards

werden

neben den elektronischen

Bauteilen

wie Kondensatoren

(rechts) alle wichtigen

Chips verlötet

– in der Bildmitte

zum Beispiel eine

SLI-Brücke.

Die Zahl der Schnittstellen „onboard“

nimmt stetig zu. Im Laufe der vergangenen

Jahre setzen sich zunehmend

Buchsen für eSATA, Firewire, Sound

und Display-Port durch.

So funktioniert

ein Mainboard

Das Mainboard (auch

„Hauptplatine“ oder

„Mother board“ genannt)

ist die Schaltzentrale

in jedem PC. Was der PC kann,

hängt zum großen Teil von

den Funktionen dieser Platine

ab. Wie die einzelnen Bauteile

funktionieren und welche

Techniken dabei zum Einsatz

kommen, zeigt der folgende Artikel.

Vielschichtige Bretter

Auch wenn hunderte Bauteile

auf einem aktuellen Mainboard

sitzen, ist die darunter liegende

Platine („Printed Circuit

Board“, kurz: PCB) mindestens

genauso wichtig wie die Masse

der Chips, die auf ihr sitzen.

Über das PCB werden alle Bauteile

mit elektrischer Energie

versorgt, auch der Datentransfer

findet darüber statt. Damit

dies möglich ist, ist die Platine

aus mehreren Schichten (engl.

„Layer“) aufgebaut, die unterschiedliche

Aufgaben übernehmen.

Je komplexer eine Hauptplatine

aufgebaut ist, desto mehr

Schichten (auch: Lagen, engl.:

Layer) hat sie. Während viele

Mittelklasse-Hauptplatinen aus

sechs Lagen aufgebaut sind,

handelt es sich bei Oberklasse-Mainboards

häufig um acht

Schichten: Die Anbindung von

sechs RAM-Steckplätzen für den

Triple-Channel-Betrieb stellt

beispielsweise bei Intel höhere

Ansprüche an das Design als

eine Dual-Channel-Anbindung

mit vier Slots. Selbst wenn sich

Datenleitungen so verlegen lassen,

dass ein Board mit weniger

Platinenlagen auskommt, werden

für eine stabilere Stromversorgung

oder eine bessere

Abschirmung der Schichten untereinander

zur Minimierung

elektromagnetischer Interferenzen

manchmal mehr Schichten

verwendet.

Der Chipsatz

Ein klassischer Mainboard-Chipsatz

umfasst eine North- und

eine South bridge. Deren Namensgebung

leitet sich von der

üblichen Positionierung auf

dem PCB ab – die Northbridge

sitzt oben, nahe bei der CPU

und dem RAM, die Southbridge

befindet sich unten, bei den

Steckplätzen für Erweiterungskarten

und Laufwerksanschlüssen.

Für diese Anordnung gibt

es einen guten Grund: Je näher

die Komponenten und Schnittstellen

bei einander liegen, die

über den Chipsatz kommunizieren,

desto effizienter ist der

Aufbau eines Mainboards. Je

mehr Leitungen quer durch die

Platine geführt werden müssen,

desto komplizierter gestaltet

sich die Entwicklung und Fertigung,

was unnötige Kosten verursacht.

Die Northbridge

Dieser Teil des Chipsatzes

hat in den letzten Jahren die

größte Änderung erfahren.

Sockel-775-Systeme waren im

Desktop-Bereich die letzten,

bei denen die Kommunikation

über einen Frontside-Bus erfolgte.

Sowohl AMD als auch Intel

ersetzten den veralteten Bus

durch eine schnelle Punkt-zu-

Punkt-Verbindung. Mit dieser

Änderung ging die Verlagerung

des Speichercontrollers von der

Northbridge in die CPU einher.


Mainboard

Typischerweise war die verbaute

Northbridge namengebend

für den ganzen Chipsatz.

Die Southbridge

Die Southbridge sorgt dagegen

für die Schnittstellenvielfalt

im PC: USB, PATA, SATA und

LAN werden in der klassischen

Chipsatz-Architektur über die

Southbridge an das System angebunden.

Das Gleiche gilt für

den Onboard-Sound. Häufig

stellt die Southbridge weitere

PCI-E-Lanes bereit. Diese sind

aber nicht für die Grafikkarte,

sondern für zusätzliche Erweiterungskarten

oder einen LAN-

Chip vorgesehen.

Nur noch ein Chip

Vom Single-Chip-Design spricht

man, wenn die Aufgaben der

North- und Southbridge nur

von einem einzigen Chip erledigt

werden – daneben

können natürlich Dutzende

Einzelchips für andere Zwecke

auf dem Board sitzen. Das

Single-Chip-Design wurde früher

häufig bei Niedrigpreislösungen

verwendet, die weniger

Funktionen boten als teure

Chipsätze.

Mittlerweile werden aber immer

mehr Aufgaben des Chipsatzes

vom Prozessor übernommen;

der Speichercontroller

ist wie erwähnt bereits seit einigen

Jahren in den Prozessor

integriert und eine etwaige

Onboard-Grafik ist nun nicht

mehr „onboard“ – also auf dem

Mainboard – untergebracht,

sondern ebenfalls im Prozessor.

Das spart Kosten und erhöht

die Leistung.

Im Vergleich zu einer Northbridge

der späten 90er-Jahre

wäre eine aktuelle Northbridge

praktisch „leer“ – nahezu

alle Funktionen sind in andere

Komponenten „abgewandert“.

Intel nennt den zentralen Chip

nur noch „PCH“ („Platform

Controller Hub“). Dieser übernimmt

die verbliebenen Aufgaben

von North- und Southbridge.

Der Mainboard-Chip wird

meist entweder per PCI-Express

(bei Intel DMI, Direct

Media Interface genannt) oder

Hyper Transport (AMD) an den

Prozessor angebunden.

Das BIOS

Beim Basic Input Output System

handelt es sich um die Firmware

eines PCs, die auf einem

EEPROM oder Flashspeicher abgespeichert

ist und nach jedem

Start des PCs ausgeführt wird.

Noch bevor Windows geladen

wird, sorgt es dafür, dass alle

wichtigen Systemkomponenten

auf ihre Funktion überprüft

und angesprochen werden können.

Der BIOS-Nachfolger (U)

EFI erlaubt hier noch weit mehr

Funktionen und sorgt für eine

einfachere Bedienung, mehr Informationen

dazu finden Sie im

entsprechenden Abschnitt auf

den folgenden Seiten.

Updates

Fehler im BIOS können heutzutage

bei jedem Mainboard

durch Flashen, also das Neubeschreiben

des Chips mit einer

neuen BIOS-Version, behoben

werden. Das war früher nicht

möglich und hat sich erst in den

90er-Jahren flächen deckend

durchgesetzt. Angebunden wird

das BIOS bei aktuellen Boards

häufig über den Serial Peripheral

Interface Bus (SPI). Befindet

sich am Mainboard ein SPI-Anschlussfeld,

kann das BIOS

auch über ein externes Gerät

wie das DFI BIOSecure aktualisiert

werden. Es ist übrigens

Einige Mainboards können die Funktionen hochwertiger Soundkarten

übernehmen – hier im Bild Creatives Soundcore-3D-Chip auf einem Gigabyte

G1.Sniper5.

Wie sich Mainboards

weiterentwickelt haben

In den vergangenen Jahren hat sich viel getan, wie ein Vergleich

zwischen einem Epox 8NPA SLI von 2005 (Bild unten) und der Standardausstattung

aktueller Platinen zeigt: Das Epox-Board hat nur zwei

RAM-Slots (2013: 4-6 Slots), die kompatiblen Sockel-754-CPUs bieten

lediglich einen Single-Channel-Modus (2013: Dual/Triple Channel). Der

zusätzliche 12-Volt-ATX-Stromstecker ist 4-polig, bei aktuellen Platinen

ist er 8-polig ausgeführt.

Obwohl das Board vier Mal SATA 3 Gb/s zur Verfügung stellt (2013: 6 x

SATA 6 Gb/s), sind noch zwei PATA-Anschlüsse verbaut (2013: max. 1

x PATA). Der BIOS-Chip ist gesockelt (2013: oft nicht wechselbar). Es

gibt keine separate North- und Southbridge, der Nforce 4 SLI ist wie

die PCHs von Sockel-1155-Boards im Single-Chip-Design ausgeführt.

Gekühlt wird der Chip aktiv, 2013 ist Passivkühlung populär.


Mainboard

Spannungsversorgungen

im Vergleich

Hochwertige Komponenten bei der Spannungsversorgung haben

großen Einfluss auf die Stabilität – besonders im übertakteten Zustand.

Klassische Elektrolytkondensatoren und Drosseln („Chokes“)

mit Eisenkern sind mittlerweile out. Die langlebigeren Solid Caps und

Ferrit-Chokes sind hingegen auch heute noch auf günstigen Boards

üblich.

2007: Simple Kondensatoren und Eisen-Chokes.

2009: Solid Caps und Chokes mit Ferrit-Kern.

2013: Blackwing-Chokes mit Goldschicht und Kühlung.

ein Irrtum, dass vom Hersteller

vorkonfigurierte Fertigrechner

mit OEM-Mainboard lediglich

ein (modifiziertes) BIOS benötigen,

um übertaktet werden zu

können. Besonders häufig bei

Notebooks ist der Taktgeber

gegen das Absenken und Anheben

des Systemtakts geschützt,

sodass Lötarbeiten erforderlich

sind, um den PC außerhalb der

Spezifika tion zu betreiben.

ISA undercover

Manche Leser werden sich vielleicht

noch an den 1981 eingeführten

ISA-Bus erinnern, der

Mitte der Neunziger vom PCI-

Bus abgelöst wurde. Nach fast

30 Jahren steckt immer noch

ein Teil ISA-Technik in aktuellen

Mainboards, auch wenn die dazugehörigen

Erweiterungskarten

ausgestorben sind. Die Rede

ist vom Low Pin Count (LPC),

der auf Software-Ebene wie ein

ISA-Bus angesprochen wird.

Im Gegensatz zu PCI(-Express)

wird der LPC-Bus nicht für Erweiterungskarten

ausgeführt,

sondern dient lediglich der Anbindung

veralteter Peripherie

zum Beispiel über PS/2, der seriellen/parallelen

Schnittstelle

und den Floppy-Anschluss.

CPU-Versorgung

Auch wenn jedes Bauteil auf der

Hauptplatine mit Energie versorgt

werden muss, unterscheidet

sich die Stromversorgung

des Hauptprozessors allein im

Umfang deutlich von der anderer

Komponenten. In den letzten

Jahren ist die Bedeutung der

Spannungsversorgung gewachsen.

Dies verwundert nicht,

denn sie trägt maßgeblich zur

Energieeffizienz, zur Langlebigkeit

und zum Overclocking-Potenzial

bei. Die Stromversorgung

umfasst im Wesentlichen einen

PWM-Controller für die einzelnen

Phasen, MOSFETs samt

Treiber, Kondensatoren und

Spulen. Auch wenn allgemein

nur von der CPU-Spannung die

Rede ist, liegen innerhalb eines

Prozessors verschiedene Spannungen

für unterschiedliche

Teilbereiche an.

Bei aktuellen Prozessoren wird

der Uncore- bzw. North bridge-

Teil der CPU unabhängig von

den Kernen versorgt. Aus diesem

Grund werden die einzelnen

Phasen getrennt genannt:

Erfolgt die Stromversorgung

etwa über „4+1 Phasen“, so sind

von den insgesamt fünf Phasen

vier für die Kernspannung und

eine für den Uncore-/Northbridge-Bereich

zuständig. Bei

manchen CPUs kommt noch

die Spannung für die integrierte

Grafikeinheit hinzu. Die

Energiezufuhr der CPUs wird

seit mehreren Jahren über die

12-Volt-Schiene des Netzteils realisiert.

Brandneue CPUs (Haswell) verfügen

über einen integrierten

Spannungswandler, der alle

Kerne und den Ringbus mit

Strom versorgt. Die Spannungswandler

auf dem Mainboard

fallen dann deutlich kompakter

aus als bislang.

Phasen

Je mehr Phasen ein Mainboard

hat, desto besser lässt sich die

Last auf verschiedene MOS-

FET-Gruppen verteilen: Bei

vier Phasen beträgt die effektive

Arbeitszeit nur 25 Prozent,

bei sechs liegt sie schon unter

20 Prozent. Damit das funktioniert,

muss der Phasenwechsel

zuverlässig funktionieren.

Mehr Phasen sind nicht zwangsläufig

besser, da auch die Qualität

der einzelnen Bauteile


Mainboard

eine große Rolle spielt und bei

zunehmender Komplexität Signal-

und Timing-Proble me eher

auftreten können. Auch die

Energieeffizienz kann von einer

überdimensionierten Stromversorgung

in Mitleidenschaft

gezogen werden. Bei manchen

Mainboards wird die Phasenanzahl

daher lastabhängig variiert.

Trends

Statt Bus-Systemen (FSB, PCI)

sind heute Punkt-zu-Punkt-Verbindungen

angesagt, deren

Datentransferrate deutlich hö-

her ist. Auch die Verfrachtung

des RAM-Controllers und aller

Cache-Stufen vom Mainboard

in die CPU zeigt, dass es bei

grundlegenden Veränderungen

meist darum geht, für die Leistung

entscheidende Bestandteile

nicht durch ihre Anbindung

auszubremsen. Im Retail-Markt

setzen die Hersteller neben der

Optik und besserer Ausstattung

inzwischen verstärkt auf Übertaktungsfunktionen,

um sich

von der Konkurrenz abzuheben

und die Produktpalette zu komplettieren.

Mainboard-Anschlüsse in der Übersicht

1 3 5

2

7

9 9

2

4

6

8

2 10

1 PS2-Anschluss

5 Bluetooth-Dongle

9 Netzwerk-/Ethernet-

Anschluss

2 USB-2.0-Anschüsse 6 E-SATA-Anschluss

3 Koax. S/PDIF-Ausgang 7 Firewire-Anschluss

10

USB-3.0-Anschlüsse

(blau!)

4 Opt. Digitalausgang 8 E-SATA-p-Anschluss


Mainboard

Die Mainboard-Bauteile im Detail

PCI-Express-Slot

Von den sechs mechanischen PCI-E-16x-

Steckplätzen sind nur der erste und der fünfte

von oben auch elektrisch als 16x-Variante

ausgeführt.

PCI-Slot

Der einzige PCI-Slot ist an die Southbridge

angeschlossen und teilt sich den PCI-Bus

mit dem Firewire-Controller T.I. TSB43AB23.


Taktgeber

Der von Realtek stammende Taktgeber

Realtek RTM880N-793 ist programmierbar

und ermöglicht somit das Übertakten des

Systems.

Dual-BIOS-ROM

Da ein Mainboard lediglich einen BIOS-Chip

benötigt, dient der zweite als Backup. Nicht

gesockelte Chips lassen sich nicht austauschen.

Anschlussfeld

Hier werden der An- und Aus- sowie der Resetknopf

des Gehäuses und Zustands-LEDs,

die z. B. die Festplattenaktivität anzeigen,

angeschlossen.

Batterie

Die Batterie sorgt dafür, dass bestimmte

Daten wie die Uhrzeit und das Datum nicht

bei jedem Start erneut eingegeben werden

müssen.


Mainboard

Externe Anschlüsse

Neben Eingabegeräten (PS/2, USB) lassen

sich hier unter anderem Plug&Play-Datenspeicher

(USB/E-SATA), Netzwerk-Hardware

(LAN) und Audio-Geräte anschließen.

CPU-Stromversorgung (8 + 2 Phasen)

Einer der PWM-Controller ist der ISL6324ACRZ von Intersil. Für die

Stromversorgung der CPU sowie der CPU-Northbridge kommen zehn

Polymerkondensatoren und Ferritkernspulen sowie 20 MOSFETs zum

Einsatz.

Stroman schluss

Mit Energie wird das Mainboard über einen

24-poligen ATX-Stromanschluss und ein

separates, 8-poliges ATX-12-Volt-Anschlussfeld

versorgt.

CPU-Sockel AM3

Obwohl Sockel-AM3-Prozessoren über

938 Pins verfügen, gibt es im Sockel 941

Kontaktstellen, wodurch unter anderem die

Abwärtskompatibilität zu Sockel-AM2(+)-

CPUs sichergestellt wird.

Northbridge

Der 890FX-Chip bietet 42 PCI-E-2.0-Lanes.

Davon werden bis zu 32 von Grafikkarten

genutzt. Eine PCI-E-Lane nutzt der USB-3.0-

Controller von NEC.

Southbridge

Die Southbridge bietet

Anschlüsse für USB und

SATA 6 Gb/s. An sie angeschlossen

sind neben

dem PCI-Bus Chips für

Audio, Firewire, LAN

sowie alte Schnittstellen

über den LPC-Bus.

DDR3-RAM-Slots

Für den Dual-Channel-Betrieb muss ein

Speicherriegel-Paar in gleichfarbige Slots

eingesetzt werden. Maximal lassen sich 4 x

4 GiBye verbauen. Der Arbeitsspeicher ist

direkt an die CPU-Northbridge angebunden.

Stroman schluss

Mit Energie wird das Mainboard über einen

24-poligen ATX-Stromanschluss und ein

separates, 8-poliges ATX-12-Volt-Anschlussfeld

versorgt.


Mainboard

Der Speicherchip,

der das zentrale

Steuerprogramm

eines PCs enthält,

ist meist an einem

Aufkleber mit dem

Herstellernamen

zu erkennen.

Während das BIOS älterer PCs spartanisch blau daherkommt (rechts),

ähnelt der BIOS-Nachfolger UEFI (links) einem Mini-Betriebssystem mit

grafischer Oberfläche und Maus-Unterstützung.

Um eine Windows-8-Zertifizierung zu erhalten, muss die Hauptplatine

eine UEFI-Implementierung haben. Damit wird das klassiche BIOS in

den kommenden Jahren allmählich vom Markt verschwinden.

So funktioniert

das BIOS

Für die Steuerung des PCs

ist eine kompakte Software

nötig, die in einem

kleinen Speicherchip auf dem

Mainboard untergebracht ist.

Wie das sogenannte „BIOS“

funktioniert, zeigt der folgende

Artikel.

Systemstart

Das BIOS, ausgeschrieben „Basic

Input Output System“, ist

das erste Programm, das beim

Start eines PCs aufgerufen

wird. Mit dessen Hilfe werden

weitere höhere Programme,

beispielsweise Windows, ausgeführt

und auch die zur Verfügung

stehende Hardware ermittelt.

Es handelt sich dabei um

einen nicht flüchtigen Speicher

auf dem Mainboard, den der

PC beim Systemstart automatisch

ausliest. Wird dieser beim

Hochfahren beschädigt, kann

der PC nicht mehr fehlerfrei

starten (engl.: „booten“).

Wozu dient das

BIOS?

Das BIOS beseitigt zwei Probleme,

die ansonsten beim

Hochfahren jedes Rechners

auftreten würden: Zum einen

kümmert es sich um das sogenannte

„Bootstrapping“. Darunter

versteht man Folgendes:

Programme und Software sind

im Regelfall auf einem Datenträger,

zum Beispiel der Festplatte,

abgespeichert. Diese

Daten müssen, bevor sie verwendet

werden können, zunächst

in den Hauptspeicher

des PCs gelesen werden. Für

diesen Vorgang benötigt die

CPU aber wiederum Software.

Somit entsteht das klassische

Henne-Ei-Problem.

Bei frühen Rechnern wurde

dieses dadurch gelöst, dass das

System nach dem Anschalten

in einen Pausemodus versetzt

wurde. Anschließend wurde

entweder manuell oder mittels

spezieller Hardware ein minimales

Programm in den Hauptspeicher

gebracht, das man als

Bootloader, Ladeprogramm

oder Urlader bezeichnet. Dieses

Minimalsystem ist heute Teil

des Basic Input Output Systems.

Da dieses automatisch beim

Start des Rechners ausgeführt

wird, ist das Henne-Ei-Problem

somit gelöst.

Ein weiteres Problem ist, dass

ein Rechnersystem aus unterschiedlichsten

Hardware-Komponenten

zusammengesetzt

ist. Jede einzelne benötigt

eine spezielle Ansteuerungssoftware

(Treiber). Dadurch musste

früher ein Betriebssystem

auf jeden Rechnertyp speziell

zugeschnitten werden. Dieses

Problem wird dadurch gelöst,

dass die Ansteuerungssoftware

in das BIOS ausgelagert wird.

Somit kann das Betriebssystem

auf diese zugreifen. Aktuelle Betriebssysteme

verwenden diese

Standard-Treiber aber nur in

der Ladephase und greifen danach

auf optimierte Treiber zur

Leistungssteigerung zurück.

Wo finde ich das

BIOS?

Das BIOS befindet sich als separater

Baustein auf der Hauptplatine

des Rechners. Zum Einsatz

kommen entweder EPROMs

oder Flash-Speicher. Der Hauptunterschied

zwischen den beiden

Speicherlösungen besteht


Mainboard

darin, dass Erstere nicht ohne

Weiteres überschreibbar ist,

wohingegen die andere annähernd

beliebig oft neu bespielt

werden kann. Lokalisiert ist das

BIOS im Regelfall auf einem herausnehmbaren

Speicher-Chip

auf der Vorderseite des Mainboards.

Was passiert beim

Starten?

Im Wesentlichen lässt sich der

Startvorgang des BIOS in zwei

Aufgabengruppen einteilen:

Zum einen wird der Power-

On-Self-Test (POST) ausgeführt

und zum anderen die Hardware

initialisiert. Bei Ersterem handelt

es sich um einen Vorgang,

in dem überprüft wird, ob die

grundlegenden Elemente des

PCs funktionstüchtig sind. Fehler

in dieser Phase werden in

der Regel durch die bekannten

Pieptöne gemeldet. Einige

Mainboards verfügen alternativ

über eine zweistellige Digitalanzeige

für die Fehlerdarstellung.

Der POST geht nach folgender

Priorisierung vor: Zuerst wird

die Funktionsfähigkeit der CPU

überprüft und anschließend

eine Prüfsummenbildung des

CMOS-RAM vorgenommen. Damit

wird die Integrität des Systems

sichergestellt. Daraufhin

werden sowohl der Cache- als

auch der Grafik- sowie der Anfang

des Arbeitsspeichers getestet.

Wenn die Prüfung erfolgreich

ist, kann die Grafikkarte

in Betrieb genommen werden.

Dadurch werden die weiteren

Tests auf dem Bildschirm sichtbar.

Test der Hardware

In der Regel folgt nun die Untersuchung

des restlichen Arbeitsspeichers

und anschließend

wird geprüft, ob Tastatur und

andere Peripheriegeräte wie

Festplatten vorhanden sind.

Abhängig vom verwendeten

BIOS können weitere Tests

hinzukommen oder einzelne,

etwa die Überprüfung des Arbeitsspeichers,

abgeschaltet

werden. Dazu kann während

des POST-Vorgangs das BIOS-

Set up-Programm aufgerufen

werden. Der Power-On-Self-Test

ist damit abgeschlossen und es

beginnt die Initialisierung der

zur Verfügung stehenden Hardware.

In dieser Phase werden beispielsweise

die vorhandenen

Steckkarten erkannt. Hierzu

wird in einem speziellen Speicherbereich

des BIOS, dem sogenannten

„ESCD“ (Extended

System Configuration Data),

die Ressourcenzuteilung der

Erweiterungskarten abgelegt.

Im späteren Verlauf kann das

Betriebssystem beispielsweise

auf diese Informationen zurückgreifen.

Ist die Initialisierung

abgeschlossen, wird der

Benutzer zur Eingabe des BI

OS-Passworts, falls gesetzt, aufgefordert.

Sofern vorhanden,

werden nun BIOS-Erweiterungen

diverser Untersysteme, beispielsweise

dem Grafik-Chip,

dem RAID-Controller oder dem

Netzwerk-Chip, ausgeführt.

Danach legt das BIOS fest, von

welchem Datenträger das Betriebssystem

gestartet werden

soll. Abschließend wird der

darauf befindliche Bootloader

und damit das Betriebssystem

ausgeführt.

BIOS und Sicherheit

Das BIOS stellt auch eine Sicherheitsstufe

dar, die den unberechtigten

Zugriff auf den

Rechner verhindern kann.

Dazu dient zum einen das

BIOS-Passwort und zum ande

BIOS-Varianten

Der POST-Screen zeigt meistens

unter anderem Infos zu CPU, RAM,

Laufwerken und angeschlossenen

USB-Geräten, wird aber oft durch ein

Herstellerbild verdeckt.

Neben den gesockelten BIOS-Bausteinen (oben) finden derzeit gerade

aufgelötete Chips (Mitte) den Weg auf die Boards. Letztere kommen

meist in doppelter Form vor. Sapphire und EVGA setzen auf eingekapselte

Bausteine (unten).

Gesockeltes BIOS

Gelötetes BIOS

Eingekapseltes BIOS


Mainboard

Master-Passwörter

für Award-BIOS

256256 bios lkw peter

589589 BIOS lkwpeter

589721 biosstar PASSWORD

1322222 biostar SER

?award CONCAT setup

1EAAh CONDO SKY_FOX

admin condo SWITCHES_SW

alfarome djonet Sxyz

aLLy efmukl SZYX

aPAf g6PJ t0ch20x

award h6BB t0ch88

AWARD SW HELGA-S ttptha

award_? HEWITT RAND TTPTHA

award_ps HLT TzqF

AWARD_PW j09F wodj

AWARD_SW j256 ZAAADA

AWARD?SW j262 zbaaaca

award.sw j322 zjaaadc

awkward j64 zjaaade

Master-Passwörter

für AMI-BIOS

589589 AMI.KEY AMISETUP

ami ami.kez bios310

A.M.I. ami° BIOSPASS

aammii AMI~ CMOSPWD

AMI amiami helgasss

AMI_SW amidecod HEWITT RAND

AMI!SW amipswd KILLCMOS

AMI?SW

AMIPSWD

So gelangen Sie ins BIOS

Hersteller

AMI-BIOS

Award-BIOS

Ebenfalls häufig

Alte Systeme

Tastenkombinationen

Entf, F1

Entf, Strg + Alt + Esc, Strg + Alt + S

Esc, F1, F2

Alt + Enter, F10, Strg + Alt + Einfg, Strg + Alt + Enter,

Strg + Alt + Esc, Strg + Alt + S, Strg + S

ren das BIOS-Setup-Passwort.

Beide können in der Regel unabhängig

voneinander gesetzt

werden. Ziel des BIOS-Passworts

ist es, noch vor dem

Starten des Betriebssystems

die Nutzungsberechtigung des

Computers zu erfragen, wohingegen

das Setup-Passwort

nur die Anpassungen am BIOS

beschränkt. Der tatsächliche

Schutz, den die beiden Passwort-Abfragen

darstellen, ist

jedoch eher zweifelhafter Natur,

da sie über diverse Mechanismen

ausgehebelt werden

können.

BIOS zurücksetzen

Falls Zugriff auf die Hardware

des Rechners besteht, ist es

ein Leichtes, das BIOS-Passwort

zurückzusetzen. Abhängig

vom eingebauten Mainboard

kann dies entweder über das

temporäre Entfernen der BI-

OS-Batterie oder das Löschen

des CMOS über Schalter sowie

Jumper-Stellung bewerkstelligt

werden. Zur Rücksetzung des

CMOS auf die Standardwerte benötigen

Sie in der Regel die Beschreibung

Ihrer Hauptplatine.

In dieser finden Sie im Normalfall

den Eintrag „Clear CMOS“.

Dabei handelt es sich entweder

um einen gesonderten Schalter

oder eine Kombination aus

zwei Pins und einem Jumper.

Wenn Sie diesen betätigen beziehungsweise

entfernen, wird

das CMOS zurückgesetzt. Beachten

Sie, dass dazu eventuell

der Rechner von der Steckdose

getrennt werden muss.

Als Alternative zur Löschung

des CMOS können Sie auch versuchen,

über ein Masterpasswort

Zugriff auf den Rechner

zu erlangen. Beachten Sie, dass

Masterpasswörter nur auf älteren

Boards funktionieren. Neuere

Varianten generieren in der

Regel anhand der Seriennummer

einen eigenen Schlüssel,

der dann ausschließlich auf diesem

System funktioniert.

Sollte lediglich das BIOS-Setup

mit einem Passwort versehen

sein, besteht zusätzlich die

Möglichkeit, dieses über die

Systemkonsole zurückzusetzen.

Wählen Sie dazu im Startmenü

von Windows „Ausführen“

aus. Alternativ können Sie auch

„Windows-Taste + R“ benutzen.

Geben Sie nun im Ausführen-Dialog

„cmd“ ein und klicken Sie

auf „OK“. In der erscheinenden

Systemkonsole tippen Sie einen

der folgenden Befehlsblöcke

ein:

debug

o 70 2e

o 71 ff

Q

debug

o 70 17

o 71 17

Q

Da die oben aufgeführten Befehle

je nach BIOS-Typ variieren

können, besteht keine Garantie,

dass sie auch auf Ihrem

PC funktionieren. Falls Sie jedoch

tatsächlich das Passwort

für das Setup vergessen haben,

schadet ein Versuch auch nicht.

Grundsätzlich bietet das BIOS

eine geringe Sicherheit. Da nur

der Zugriff auf das Rechnersystem

als Ganzes unterbunden

wird, bleiben die Daten auf der

Festplatte ungeschützt. Im einfachsten

Szenario kann also einfach

der Datenträger ausgebaut

und mit einem anderen System

verbunden werden, um Zugriff

auf die darauf befindlichen Informationen

zu erhalten.


Mainboard

Der Aufruf des Setups

muss in der Regel in

den ersten Sekunden

des Neustarts erfolgen. Dazu

wird normalerweise die Taste

„F2“ oder „Entf“ betätigt. Sollte

dies ohne Auswirkungen bleiben,

müssen Sie in Ihrer Mainboard-Beschreibung

nachschlagen.

Setup aufrufen

In manchen Fällen wird auch

die nötige Taste beim Boot-Vorgang

angezeigt. Viele aktuelle

BIOS-Versionen quittieren

den Tastendruck, indem der

Ladebildschirm zum Beispiel

„Entering Setup“ anzeigt. Ist der

bereits beschriebene POST-Vorgang

abgeschlossen, gelangen

Sie in das Set up. Hier können

Sie auf diversen Seiten unterschiedliche

Einstellungen vornehmen.

Die gängigste Einteilung

möchten wir anhand eines

Award-BIOS etwas näher erläutern.

Die BIOS-Einstellungen

und -Menüs im Einzelnen

Die einzelnen Funktionen sind übersichtlich

in Gruppen zusammengefasst

(siehe Fließtext).

Standard CMOS

Features

In diesem Menü können unter

anderem Laufwerke, beispielsweise

Festplatten, die während

des POST-Vorgangs erkannt

wurden, nachträglich konfiguriert

werden. Dadurch lässt sich

der Startvorgang beschleunigen.

Daneben besteht auch die

Option, Datum und Uhrzeit des

Systems einzustellen. Häufig

werden zudem Informationen

über die Größe des eingebauten

Arbeitsspeichers dargestellt.

Adv. BIOS Features

Dieser Abschnitt bietet erweiterte

Funktionen des BIOS.

Dazu zählen unter anderem

die Konfigura tion der Boot-Reihenfolge

oder die Anzeige des

Full-Screen-Logos. In vielen Fällen

kann hier auch eingestellt

werden, ob sich das Passwort

lediglich auf das Setup, den

Boot-Vorgang oder beides beziehen

soll.

Integrated

Peripherals

Unter diesem Bereich werden

weitere Konfigurationsmöglichkeiten

der Hardware-Komponenten

angeboten. Hierzu

zählen der Onboard-Netzwerkchip

sowie der SATA-Controller.

Auch der Soundchip des Boards

kann hier meist an- oder abgeschaltet

werden.

Power Management

Setup

Hier können Sie beispielsweise

einstellen, wie sich das System

beim Drücken des Netzschalters

verhalten soll. Besonderes

Augenmerk sollten Sie in die-

sem Menü auf den ACPI-Modus

legen. Über diesen können Sie

festlegen, welchen Stromsparmodus

das System maximal

nutzen kann. Zur Auswahl stehen

in der Regel die Modi S1,

S3 oder S4. Letzterer stellt dabei

Eine Ausnahme stellen Mainboards mit

Ami-BIOS-Oberfläche dar; neben den

Bezeichnungen für die meisten Optionen

ist auch das Design leicht geändert. Die

Funktionen sind aber dieselben.

den Ruhezustand dar, bei dem

der Inhalt des Arbeitsspeichers

auf der Festplatte gespeichert

wird. Um dies verwenden zu

können, muss jedoch unter

Windows die entsprechende

Einstellung unter „Systemsteu-


Mainboard

Unter „PC Health Status“ (Award) zeigt das BIOS einige Kennzahlen wie

die aktuelle CPU-Temperatur oder die Lüfterdrehzahlen an.

Bessere Hauptplatinen bieten über das BIOS

oder UEFI Hilfsprogramme, die den Anwender

beim Übertakten unterstützen sollen. Der

Nutzen ist jedoch zweifelhaft, denn nicht immer

sind die Tools auch ausgereift.

BIOS zum Durchklicken: Die Seite von JZ Electronic liefert zu mehr als

100 Gigabyte-Hauptplatinen die entsprechenden BIOS-Menüs. Zusätzlich

werden Detail-Informa tionen zu den einzelnen Einstellungsmöglichkeiten

angeboten.

erung“ – „Energiemanagement“

vorgenommen werden. Daneben

unterstützen viele Boards

Funk tionen zum Anschalten

des Systems über Maus sowie

Tastatur oder sogar einen automatischen

Start zu einer bestimmten

Uhrzeit.

PnP/PCI

Configurations

Dieses Menü dient zur Einteilung

von Systemressourcen.

Beispielsweise können hier

IRQs und DMAs vergeben werden.

Bei Ersteren handelt es

sich um eine Unterbrechungsaufforderung,

die von einer

Hardware-Komponente gesendet

wird, wenn ein neues Ereignis

eintritt.

Dies wird beispielsweise ausgelöst,

wenn auf der Netzwerkkarte

Daten empfangen

werden. Unter DMA verbirgt

sich eine Adresse des Arbeitsspeichers.

Auf diese kann die

Hardware-Komponente direkt

zugreifen, ohne den Umweg

über den Prozessor gehen zu

müssen. Dadurch wird dieser

nicht ausgebremst und kann

für andere Auf gaben eingesetzt

werden.

PC Health Status

In diesem Abschnitt des BIOS

können primär Informationen

über das System angesehen

werden. Beispielsweise werden

hier Details zu den verschiedenen

Spannungen für CPU und

Arbeitsspeicher, die aktuellen

Drehzahlen der angeschlossenen

Lüfter oder die aktuelle

Temperatur von Prozessor und

Mainboard-Chip (meist nur ein

angenäherter Wert) angezeigt.

Darüber hinaus kann häufig

auch ein Grenzwert für Temperatur

oder Drehzahl festgelegt

werden.

Zusätzlich zu den beschriebenen

Menüs werden meist

Funktionen für das Laden der

Werkseinstellungen oder einer

optimierten BIOS-Konfiguration

angeboten. Auch das Setzen

des Passworts wird in der Regel

als separater Punkt im Hauptfenster

aufgelistet. Wenn Sie

alle Einstellungen vorgenommen

haben, können Sie über

„Save and Exit“ das BIOS-Setup

verlassen und das System mit

der angepassten Konfiguration

neu starten. Zum Verwerfen

der Änderungen wählen Sie die

Funktion „Exit without Saving“.

Hilfeseiten

Weiterführende Infos über das

BIOS finden Sie in der Regel

auf der Hersteller-Homepage

Ihrer Hauptplatine. Darüber

hinaus haben sich aber auch

weitere Internet-Projekte dieses

Themas angenommen. Das

Referenzwerk bildet hierbei

das BIOS-Kompendium, das

aber leider nicht mehr weiter

aktiv betreut wird; für ältere

Platinen sind die Erläuterungen

aber noch immer hilfreich. Unter

www.bios-kompendium.de

finden Sie die Informationen

zu BIOS-Typen verschiedener

Hersteller.

Ein weiteres Projekt, das hier

Erwähnung finden sollte, ist

die Seite www.jzelectronic.de.

Diese Webseite hat sich dem

Hersteller Gigabyte verschrieben

und bietet unter „Support“

– „BIOS Anleitung“ – „Gigabyte

BIOS Anleitungen“ Übersichten

zu mehr als 100 BIOS-Varianten

aktueller Boards. Hierbei

werden die BIOS-Menüs zum

Durchklicken samt weiterführenden

Beschreibungen angeboten

und bilden so quasi ein

virtuelles BIOS des gewählten

Mainboards.


Mainboard

Obwohl BIOS und UEFI

sehr ähnliche Aufgaben

erfüllen, ist der

technische Unterschied gewaltig.

Wir geben einen Überblick,

was das UEFI („Unified Extensible

Firmware Interface“) technisch

von seinem Vorgänger unterscheidet.

Implementierung

Ähnlich wie das klassische BIOS

ist das UEFI zunächst nur ein minimales

System zur geordneten

Initialisierung der Komponenten.

Anders als sein Vorgänger

stellt es jedoch kein Interface

zum Zugriff auf die Hardware

zur Verfügung, sondern übergibt

die Kontrolle so schnell wie

möglich an den Bootloader und

somit das Betriebssystem. Da

erheblich weniger Programmcode

ausgeführt wird, startet es

auch wesentlich schneller.

Die entscheidende

Änderung im Vergleich

zum BIOS

ist die Fähigkeit,

mehr als nur 216

Byte Speicher zu

adressieren. In Zusammenhang

mit

der Tatsache, dass UEFI

im Gegensatz zum monolithischen

BIOS ein modulares System

darstellt, ergeben sich für

die Programmierer wesentliche

Vorteile bei der Implementierung

von Zusatzfunktionen.

Mehr Funktionen

Sehr beliebt ist die Einbindung

von Grafiktreibern über das

EBC („EFI Byte Code“)-Interface.

Apple nutzt diese Schnittstelle,

um den gesamten Bootvorgang

grafisch anspruchsvoll zu gestalten

und dem Anwender

das PC-typische 80x25-Zeichen-

Reintext-BIOS-Bild zu ersparen.

Zudem enthält ein UEFI von

Wie der BIOS-Nachfolger

UEFI arbeitet

Haus aus das sogenannte „Preboot

Execution Environment“

(PXE), das zum Booten über ein

Netzwerk benötigt wird. Die

nötigen Netzwerkkartentreiber

werden hier ebenfalls über das

EBC zur Verfügung gestellt.

Festplatten und SSDs

Ein weiterer Unterschied zwischen

BIOS und UEFI besteht

darin, wie Festplatten angesprochen

werden können. Während

das BIOS lediglich solche mit

MBR-Partitionsschema („Master

Boot Record“) adressieren

kann, unterstützt UEFI die Partitionierung

nach GPT-Standard

(„GUID Partition Table“).

GPT hebt die

wesentlichen Nachteile

des MBR-Standards,

etwa die Beschränkung

auf vier

primäre Partitionen

oder die Kapazitätsgrenze

von knapp über zwei

TiByte, auf.

Weitere Unterschiede

Während man bei einem BIOS

lediglich die Festplatte wählen

kann, auf der dann im Master

Boot Record der Verweis auf

das zu ladende Betriebssystem

zu finden ist, können Sie mit

UEFI bereits angeben, auf welcher

Partition der Bootcode des

zu ladenden Betriebssystems

zu suchen ist. Außerdem bietet

UEFI eine EFI-Shell (unter anderem

zur Fehlersuche) und kann

deutlich mehr als den im Flash-

Chip verfügbaren Speicher ansprechen.

Die UEFI-Bootsequenz beginnt mit der Initialisierung der Treiber, anschließend

der Zusatzapplikationen und des Bootcodes. Zum Schluss

erfolgt die Übergabe an das OS.

Unterschiede BIOS/UEFI

Programmierung

(Programmiersprache)

Bittigkeit des Programmcodes

Adressierbarer Arbeitsspeicher

Sicherheit

BIOS

Assembler

UEFI

C

16 Bit 32 bis 64 Bit

Maximal 216 Byte

= 1 MiByte

Theoretisch bis zu 264 Byte

= 16.384 PiByte

Wie so häufig bei der Einführung neuer Technologien gibt es auch bei

UEFI die volle Bandbreite an Kritik: Von berechtigten Sicherheitsbedenken

bis hin zu – seit Snowden gar nicht mehr so hanebüchenen – Verschwörungstheorien

ist alles mit dabei. Beispielsweise ermöglicht UEFI

dank der eingebauten Netzwerkfunktionalität die Verbindung zum Internet

ohne geladenes Betriebssystem. Dadurch ließe sich ein PC theoretisch

fernsteuern oder aus der Ferne auslesen, da die Sicherheitsmechanismen

des Betriebssystems, egal ob Windows oder Linux, erst

greifen, wenn das System gestartet ist. Zwar sollte dies Heimanwender

weniger beunruhigen, die Industrie (Spionage) und das Bankenwesen

(Sabotage, Manipulation) empfinden UEFI jedoch als Sicherheitsrisiko.

Durch die Implementierung eines TPM-Chips könnte außerdem theoretisch

der gesamte Eingabe-/Ausgabe-Datenstrom auf unterster

Hardware-Ebene überwacht werden – was seit den jüngsten NSA-Enthüllungen

sicher nicht nur Paranoiker stören dürfte. Mit Windows 8 gibt

es keine Wahl mehr; fast jeder Windows-8-PC hat auch UEFI.


Mainboard

PCI-Express stellt

höchste Bandbreiten

zur Verfügung, die

unter anderem von

Grafikkarten benötigt

werden – nur so

laufen auch High-

End-Spiele ruckelfrei.

Ein aktueller PCI-Express-x16-

Steckplatz (ganz unten, schwarz).

Unmittelbar darüber befindet sich ein

x1-Steckplatz (ebenfalls schwarz), der

deutlich kürzer ist.

So funktioniert

PCI-Express

Seit knapp zehn Jahren

ist PCI-Express die wohl

wichtigste Schnittstelle

auf der Hauptplatine. PCI-Express

gilt als Nachfolger zweier

Techniken, nämlich der

AGP-Schnittstelle für Grafikkarten

und des PCI-Busses für alle

anderen Steckkarten

PCI und PCI-Express

Um zu verstehen, wie PCI-Express

funktioniert, ist ein Blick

in die Vergangenheit hilfreich:

Der PCI-Bus hatte sich über eine

ganze Dekade, etwa von 1994

bis 2004, bewährt und brachte

unzählige Erweiterungskarten

hervor. Die Spezifikationen

wurden von der PCI-SIG ausgearbeitet,

einem 1992 gegründeten

Konsortium, bestehend aus

führenden Unternehmen im

IT-Bereich.

Ein riesiger Vorteil und eines

der Hauptanliegen bei der Entwicklung

von PCI-Express war

es, dass sich das Software-Modell

nicht vom klassischen

PCI-Bus unterscheidet. Für

das Betriebssystem sind demnach

keine PCI-Express-Treiber

nötig, anders als es etwa

bei AGP der Fall war, wo ein

spezieller GART-Treiber nötig

war; ein Umstand, der für viele

Stabilitätsprobleme verantwortlich

war.

Die Technik hinter

PCI-Express

PCI-Express unterscheidet sich

im Aufbau erheblich vom alten

PCI-Bus. Während PCI die parallele

Datenübertragung benutzte,

setzt PCI-Express wie

viele neuere Protokolle auf eine

serielle Datenübertragung. Zudem

ist die Hierarchie eine völlig

andere. PCI war ein Bus, an

dem zahlreiche PCI-Slots oder

Onboard-Komponenten angeschlossen

waren, die sich die

zur Verfügung stehende Bandbreite

teilen mussten. Wollten

mehrere Geräte gleichzeitig auf

den PCI-Bus zugreifen, musste

ein Bus-Arbiter entscheiden,

wer zugreifen darf. Ein vorgeschriebenes

Verfahren gab es

nicht, weswegen einige Hersteller

auf ein simples Zeitscheibenverfahren

zurückgriffen,

andere auf komplexere Methoden

mit Priorisierungs- und Parking-Funktionen.

PCI-Express dagegen ist kein

Bus mehr, sondern eine bzw.

mehrere Punkt-zu-Punkt-Verbindungen,

die über einen

Switch skalierbar sind, ähnlich

wie bei einem LAN. Aufgrund

des seriellen Aufbaus kann

PCI-Express auf deutlich höhere

Taktfrequenzen zurückgreifen.

Während beim klassischen

PCI-Bus bei 33 MHz und 32 Bit

Busbreite das Ende der Fahnenstange

erreicht war (die Server-Derivate

wie PCI-X erreichten

zuletzt bis zu 133 MHz bei

64 Bit Breite), arbeitet PCI-Express

mit einer Grundfrequenz

von 1,25 GHz. Die Pfadbreite

wird von der Art des Einsatzes

bestimmt. Der Hersteller kann

wählen, wie viele sogenannte

Lanes er für ein Gerät oder einen

Steckplatz verwenden will.

Lanes und

Bandbreiten

Eine Lane besteht aus einer

Hin- und einer Rückleitung,

die wiederum jeweils aus einem

Leitungspaar bestehen.


Mainboard

Für eine Lane sind physisch

also vier Leitungen notwendig,

die aufgrund einer sehr geringen

Spannung sehr nahe beieinanderliegen

können, ohne

sich gegenseitig durch elektromagnetische

Effekte zu stören.

Durch die serielle Übertragung

kann pro Takt nur ein Bit übertragen

werden, weswegen 1,25

GHz Taktfrequenz in einer

Transferrate von 1,25 GBit/s

resultiert. Da die Übertragung

jedoch im 8B10B-Code erfolgt,

wo 2 Bit der Fehlerkorrektur

dienen, bleiben unter dem

Strich nur 1 GBit/s oder 125

GB/s an Nutzbandbreite übrig

– eine Verschwendung von immerhin

20 Prozent. Da PCI-Express

jedoch gleichzeitig in beide

Richtungen übertragen kann,

liest man oft auch von 250 GB/s

Gesamtbandbreite je Lane.

Damit ist also bereits die einfachste

PCI-Express-Variante

mit nur einer Lane bei erheblich

geringerem Implementierungsaufwand

schneller als der

alte PCI-Bus. Für Geräte, die

noch mehr Transferrate benötigen,

etwa Grafikkarten oder

SAS-Raid-Controller, können

mehrere dieser Lanes zusammengefasst

werden. Daher gibt

es für PCI-Express nicht nur

eine Slot-Variante, sondern mit

x1, x4, x8 und x16 gleich mehrere.

Warum nicht gleich einen

Slot mit der maximalen Lane-Anzahl?

Für viele Anwendungen

wäre diese Bandbreite überdimensioniert

und außerdem war

es eines der Ziele der PCI-SIG,

eine möglichst kostengüns tige

Fertigung zu ermöglichen.

PCI-Express 2.0

Nur wenige Jahre später folgten

PCI-Express-Implementierungen

bereits der Revision 2.0

des Standards. Er wurde Anfang

2007 vorgestellt. Hier wurde die

Grundfrequenz von 1,25 GHz

auf 2,5 GHz verdoppelt, was

auch zu einer Verdoppelung der

möglichen Transferrate führte.

PCI-Express-2.0-x16-Geräte

(zum Beispiel Grafikkarten)

können damit bis zu 4 GB/s senden

und empfangen, was einer

Gesamtbandbreite (hin und

zurück) von 8 GB/s entspricht.

Dennoch ist PCIe 2.0 voll abwärtskompatibel

zum PCIe-

1.x-Standard. PCIe-2.0-Geräte

können demnach problemlos

in PCIe-1.x-Slots eingesetzt werden,

PCIe-1.x-Geräte in PCIe-2.0-

Slots. Im Gegensatz zu den Kompatibilitätsproblemen

bei PCI

und vor allem bei AGP in früheren

Tagen gibt es bei PCI-Express

praktisch keine Klagen

mehr, was für ein sehr engmaschiges

Spezifikationsregelwerk

spricht, das kaum Spielraum für

Implementierungsfehler lässt.

Dennoch werden von Revision

zu Revision jeweils auch zahlreiche

Bugs, sogenannte Errata,

beseitigt, die im Laufe des Praxiseinsatzes

entdeckt wurden.

Wie eine PCI-Express-Lane

aufgebaut ist

PCI-Express kann auf separaten Leitungen in beide Richtungen gleichzeitig

senden. Die Kombination der dafür nötigen Leitungspaare nennt

man Lane.

Takt

Wie PCI-Express auf dem

Mainboard eingesetzt wird

PCI-Express wird nicht nur für die Anbindung einer externen Grafikkarte

genutzt, auch viele Onboard-Chips wie etwa ein Gigabit-LAN-Baustein

werden auf diese Weise einfach und schnell integriert. Früher war

es auch üblich, PCI-Express für die Kommunikation zwischen Northund

Southbridge einzusetzen.

Grafikkarte

HDD

Mobiles

Docking

Gb

Ethernet

Add-In

Gerät

A

PCI-

Express

ATA

Serial

PCI-

Express

Stromversorgung

Ein Problem, das sich im Laufe

der Jahre bei PCI und AGP entwickelt

hatte, war die Stromversorgung.

Als die Spezifikationen

festgelegt wurden, hatte

niemand daran gedacht, dass

eine Grafikkarte 100 Watt oder

mehr an elektrischer Leistung

aufnehmen würde. Entsprechend

wackelig konnte ein solches

System in Sachen Stabilität

sein, denn der PCI-Slot war lediglich

für 25 Watt spezifiziert.

Bei einem PEG(PCIe-x16)-Slot

sind es immerhin 75 Watt, was

aber immer noch zu wenig

ist. Bei High-End-Grafikkarten

sieht die Spezifikation daher

unterschiedliche Zusatzstecker

zur Stromversorgung vor, soge

PCI-

Express

Paket

Switch

CPU

Paket

Memory

Bridge

I/0

Bridge

PCI

Express

PCI

Gerät

B

USB 3.0

Speicher

Lokales I/0

Takt


Mainboard

Übertragungsgeschwindigkeiten

im Vergleich

Jahr Max. Takt Max. Bitbreite Max. Datenübertr. (x32)

ISA (XT-Bus) 1981 4,77 MHz 8 Bit 4,77 MByte/Sek.

ISA (AT-Bus) 1984 8 MHz 16 Bit 16 MByte/Sek.

EISA 1988 8,33 MHz 32 Bit 33 MByte/Sek.

VLB (Vesa Local Bus) 1992 40 MHz 32 Bit 160 MByte/Sek.

PCI 1.0 1991 33 MHz 32 Bit 133 MByte/Sek.

PCI 2.x/3.0 1992 66 MHz 64 Bit 533 MByte/Sek.

PCI-X 1.0 1998 133 MHz 64 Bit 1.066 MByte/Sek.

PCI-X 2.0 2003 533 MHz 64 Bit 4.264 MByte/Sek.

PCI Express 1.x* 2003 1.250 MHz 8Bit/10 Bit 2 x 8.000 MByte/Sek.

PCI Express 2.0* 2007 2.500 MHz 8Bit/10 Bit 2 x 16.000 MByte/Sek.

PCI Express 3.0* 2011 4.000 MHz 128Bit/130Bit 2 x 31.508 MByte/Sek.

* Voll-Duplex-Datenübertragung, maximal 32 PCI-Express-Bahnen spezifiziert

** Wechsel der Datenkodierung von 8/10 Bit auf 128/130 Bit, dadurch höhere Netto-Ausbeute

Transferraten

Taktfrequenz Transferrate Overhead Datenrate

1.x 1,25 GHz 2,5 GT/s 20% 250 MB/s

2.0 2,5 GHz 5 GT/s 20% 500 MB/s

3.0 4 GHz 8 GT/s 0% 1 GB/s

Die Transferraten der unterschiedlichen PCI-Express-Revisionen je Lane.

Wie PCI-Express-Lanes

Daten übertragen

Die Daten werden bei PCIe seriell auf einer oder mehreren Lanes übertragen.

Durch Zusammenschalten mehrerer Lanes wird die Transferrate

ver-x-facht.

...

Byte 5

Byte 4

Byte 3

Byte 2

Byte 1

Byte 0

Byte 3

Byte 2

Byte 1

Byte 0

8b/10b

P > S

Byte 4

Byte 0

8b/10b

P > S

Byte 5

Byte 1

8b/10b

P > S

...

Byte 5

Byte 4

Byte 3

Byte 2

Byte 1

Byte 0

Byte 6

Byte 2

8b/10b

P > S

Byte 7

Byte 3

8b/10b

P > S

Lane 0 Lane 0 Lane 1 Lane 2 Lane 3

nannte PCI-Express (Graphics)

Power Supply Connector (auch

PEG-Connector), die +12V liefern.

Die erste Version der Zusatzstecker

hat 6 Pins und kann

bis zu 75 Watt zusätzlich liefern,

wodurch die dem Gerät maximal

bereitgestellte Leistung auf

150 Watt steigt. Bei Nutzung

zweier solcher Stecker sind sogar

bis zu 225 Watt möglich. In

der Spezifikation von PCI-Express

2.0 wurde ein neuer Zusatzstecker

mit 8 Pins definiert,

der maximal 150 Watt führen

kann. Für noch höhere Leistungen

kann ein zusätzlicher Stecker

mit 6 Pins genutzt werden,

der jedoch nur weitere 75 Watt

führt, wodurch die maximale

Aufnahmeleistung einer PCI-Express-Karte

auf insgesamt 300

Watt begrenzt ist.

PCI-Express 3.0

Seit 2011 ist PCI-Express 3.0

Standard bei Hauptplatinen

und High-End-Grafikkarten. Im

Vordergrund stand wieder die

Verdopplung der Datenübertragungsrate.

War der Wechsel von

PCI Express 1.x auf 2.0 noch

von der Anhebung von 2,5 auf

5,0 Milliarden Datenübertragungen

(Gigatransfers, GT/s)

pro Sekunde bestimmt, stellte

eine weitere Steigerung um den

Faktor 2 die PCI Special Interest

Group (PCI-SIG) als zuständiges

Gremium vor offenbar unlösbare

Probleme. 10 Gigahertz

über eine Steckverbindung

zu übertragen, war unter den

Vorgaben der kostengünstigen

Bauweise und der Abwärtskompatibilität

nicht in die Praxis

umzusetzen. Vorhergehende

PCI-Express-Standards nutzen

zur Übertragung vom Sender

zum Empfänger eine Kodierung

von 8 Bit Nutzdaten in 10

Bit große Datenpakete. Dieser

25-prozentige Overhead erklärt

auch, warum von der Bruttogeschwindigkeit

2,5/5,0 GBit/

Sek. nur 250/500 MByte/Sek. je

Bahn umgesetzt werden.

Für PCI Express 3.0 konnte

man mit den herkömmlichen

Methoden eine Übertragungsgeschwindigkeit

von 8,0 Gigatransfers

pro Sekunde erreichen

– 60 Prozent mehr als im

2.x-Standard definiert. Den Rest

zur (beinahe!) verdoppelten

Übertragungsgeschwindigkeit

trägt die veränderte Kodierung

bei, welche für die Datenpakete

verwendet wird. Anstelle

des vorigen 8b/10b-Schemas

kommt nun ein Verfahren zum

Einsatz, bei dem 130 Bit große

Datenpakete übertragen werden,

die jeweils 128 Bit Nutzdaten

enthalten. Der Overhead

sinkt auf rund 1,6 Prozent.

Insgesamt gelangen dadurch

beinahe doppelt so viele Nutzdaten

pro Sekunde über die

PCI-Express-Verbindung. Um

die In tegrität der Daten auch

bei hohen Taktfrequenzen gewährleisten

zu können, nutzt

PCI Express 3.0 eine individuell

anpassbare Verzerrung des

Signals. Anstelle eines festen

Koeffizienten für die Signalform

wird dieser für jede Verbindung

neu ausgehandelt. Wie

zuvor spezifiziert auch der neue

Standard bis zu 32 einzelne

Bahnen, wovon voraussichtlich

aber wieder nur 16 aus praktischen

Gründen (Steckplatzlänge)

genutzt werden.

Aktuelle Prozessoren tragen

den PCI-Express-Controller direkt

in der CPU. Das verkürzt

die Latenzzeiten erheblich;

allerdings beherrschen erst

brandneue Ivy-Bridge-CPUs

auch den aktuellen PCIe-3.0-

Standard.


Mainboard

Wie USB-Anschlüsse vom

Typ A und B aussehen

USB-Anschlüsse können in zwei Varianten ausgeführt werden: Der Typ

A (links) dürfte den meisten vertraut sein; etwas seltener kommt der

Typ B (rechts) zum Einsatz, meist auf Geräteseite. Der Typ B hat bei

USB-3.0-Geräten zusätzlich einen Aufsatz, damit er nicht in ältere Geräte

gesteckt werden kann. Schließlich gibt es noch Mikro-Varianten für

den Anschluss von Kleinstgeräten.

Wie sich neue USB-

Anschlüsse unterscheiden

Im Bild rechts unten gut zu sehen sind die

zusätzlichen fünf Kontakte beim blauen USB-

3.0-Anschluss, über welche die Signale im Superspeed-Modus

laufen.

So funktioniert

USB

Zehnmal so schnell wie

der Vorgänger – das ist

selbst im Hardware-Bereich

eine enorme Leistungssteigerung.

Mit 625 MByte

pro Sekunde beziehungsweise

5.000 MBit pro Sekunde ist

die aktuelle, dritte Version des

USB-Standards sogar schneller

als SATA II (375 MByte/s). Bereitgestellt

wird die schnelle

Schnittstelle – wie so viele andere

– vom Mainboard.

Universell und erweiterbar

Der Universal Serial Bus (USB)

ist in seiner Urform bereits seit

1996 in Umlauf. Dank seiner Erweiterbarkeit

durch sogenannte

Hubs, also Verteiler, können

bis zu 127 Geräte an einem einzigen

Anschluss betrieben werden.

Der USB macht seinem Namen

alle Ehre: Er ist universell.

Von Tastatur und Maus über

Fotokameras und Fernseher bis

hin zu portablen SSDs und allerlei

PC-getriebenen Spaßartikeln

reicht die Palette möglicher Geräte.

Die erste USB-Variante verfügte

noch über zwei Geschwindigkeiten

namens Low- und Full-

Speed, welche langsame 1,5

beziehungsweise 12 MBit pro

Sekunde übertragen. Ab dem

Frühjahr 2000 stand dann die

finale Version von USB 2.0 mit

dem Hi-Speed-Modus zur Verfügung.

Mit bis zu 480 MBit pro

Sekunde vervierzigfachte man

kurzerhand die Übertragungsrate,

von der im Praxiseinsatz

allerdings weniger als 40 Megabyte

pro Sekunde übrig bleiben.

Da diese Übertragungsrate

für moderne Festplatten aber

immer noch viel zu langsam

war, wurde 2008 die vorerst

letzte Ausbaustufe USB 3.0 spezifiziert.

Flächendeckend verbreitet

ist USB 3.0 aber bis heute

noch nicht.

Technik hinter USB 3

USB 3.0 („Superspeed-USB“)

ist so ausgelegt, dass sowohl

die Schnittstellen als auch die

Geräte voll auf- und abwärtskompatibel

bleiben. So kann

sowohl ein USB-3.0-Endgerät an

einem USB-2.0-Port betrieben

werden (natürlich mit der Einschränkung,

dass ein Transfer

dann länger dauert) als auch

ein USB-2.0-Endgerät an einer

USB-3.0-Schnittstelle.

Eine wichtige Rolle spielt dabei

das USB-Kabel. Um Kompatibilität

zu gewährleisten, bleiben

die alten USB-Kontakte in den

Steckern bestehen. Um USB 3.0

nutzen zu können, muss jedoch

ein spezielles Kabel verwendet

werden, das zusätzlich zu den

alten Kontakten weitere Verbindungen

auf Glasfaserbasis

besitzt. Nur so kann die bis zu

zehnmal so hohe Übertragungsgeschwindigkeit

gegenüber USB

2.0 genutzt werden, da Lichtwellenleiter

unempfindlich gegen

Signalrauschen und andere

elektrischen Störquellen sind.

Das bedeutet jedoch auch: Wer

ein USB-3.0-Endgerät an einem

USB-3.0-Computer einsetzt, aber

nur ein herkömmliches USB-2.0-

Kabel verwendet, bremst den

PC, da die Glasfaserkomponenten

im Kabel fehlen.

Softwaremodell

Ebenfalls zu Kompatibilitätszwecken

verwendet USB 3.0


Mainboard

das gleiche Softwaremodell

wie bisher. Es ist also möglich,

USB 3.0 zu nutzen, ohne dafür

irgendwelche proprietären

Miniport-Treiber verwenden

zu müssen, wie es damals bei

Windows NT der Fall war, das

keinerlei Unterstützung für USB

ab Werk mitbrachte. Neben

mehr Geschwindigkeit hat USB

3.0 auch die Zuverlässigkeit erhöht,

indem sich Sender und

Empfänger beim Datentransfer

über „acknowledgements“

ständig unterhalten und die

fehlerfreie Übertragung anfragen

und bestätigen. Um bei all

der Geschwindigkeit und Übertragungssicherheit

das Thema

Stromverbrauch nicht zu

ignorieren, bietet USB 3.0 die

Möglichkeit, im Leerlauf auf einen

niedrigeren Level der Leistungsaufnahme

zu schalten –

ähnlich wie es Prozessoren tun,

die Speedstep oder Cool‘n‘quiet

beherrschen. Sobald der Anwender

wieder Leistung abfragt,

schaltet der Controller in

den normalen Modus zurück,

um wieder volle Performance

liefern zu können.

So unterscheiden

sich USB-Anschlüsse

Äußerlich sind USB-3.0-taugliche

Buchsen üblicherweise

durch die blaue Färbung und bei

genauem Hinsehen durch die

fünf zusätzlichen Kontakte für

den 5 GBit/s schnellen Superspeed-Modus

zu identifizieren

– im Bildkasten auf der vorhergehenden

Seite können Sie den

Unterschied gut erkennen. Neben

diesem „A-Typ“ genannten

Anschluss sind die B-Typ-Stecker

im nahezu quadratischen Format

sowie die Micro-USB-Anschlüsse

gebräuchlich. Mini-USB

wird seit 2007 nicht mehr weiter

gepflegt, aber noch verwendet.

Während der Standard-Stecker

Typ A rein mechanisch in alle

Typ-A-Buchsen passt, sind für

den USB-3.0-Modus spezielle

Kabel mit zwei zusätzlichen

Ader-Paaren erforderlich. Die

entsprechenden Kabel sind

deutlich dicker und weniger

biegsam als ihre USB-2.0/1.x-Entsprechungen.

USB-Kabel vor

USB 3.0 können aufgrund der

definierten Signallaufzeit bis zu

fünf Meter lang sein, bevor sie

einen Repeater zur Signalaufbereitung

benötigen. USB 3.0

selbst spezifiziert keine maximale

Kabellänge, drei Meter gelten

aber als das realistischerweise

erreichbare Maximum.

Optimale Anbindung

Dabei kommt es auf die richtige

Anbindung des USB-3.0-Con-

trollers an: Die meisten aktuellen

Boards (ab circa 2012) unterstützen

„von Haus aus“ USB 3.0. Im

Chipsatz sind die entsprechenden

Funktionen vorhanden. Bei

nicht ganz neuen PCs (in der

Regel älter als 2012) musste USB

3.0 aber noch per Zusatzchip angebunden

werden.

Wie USB 3.0 aufs

Mainboard kommt

Dass die dritte USB-Generation bis heute nicht bei allen PCs verfügbar

ist, liegt auch an der schleppenden Einführung entsprechender Chipsätze

(Bild ganz unten). Bis dato musste die USB-3.0-Funktionalität

von zusätzlichen Controllern (Bild ganz oben und Mitte) bereitgestellt

werden – was entsprechende Mainboards zusätzlich verteuerte.

USB-3.0-Anbindung ohne Switch (Beispiel: Gigabyte P55A-UD6)

P55-Chip

2 x USB 3.0

NEC-Contr. LAN-Contr. LAN-Contr.

1 Lane 1 Lane 1 Lane

PCI-E 1.0 PCI-E 1.0 PCI-E 1.0

2 x SATA 3

PCI-Express

LAN 1

RJ45

LAN 2

RJ45

1 Lane

PCI-E 1.0

Marvell-Contr.

USB-3.0-Anbindung mit Switch (Beispiel: Gigabyte P55A-UD7)

2 x USB 3.0

P55-Chip

NEC-Contr.

PCI-Express

1 Lane

PCI-E 2.0

Die bessere Lösung war es dabei,

einen Switch-Chip zu verwenden,

der vier PCI-E-1.0-Lanes

der Southbridge in zweimal

eine PCI-E-2.0-Lane umwandelt.

Bei einigen Mainboards fehlte

dieser Switch jedoch und USB

3.0 lief so nur mit gebremster

Geschwindigkeit.

PEX8608 Bridge

4 Lanes

PCI-E 1.0

1 Lane

PCI-E 2.0

2 x SATA 3 Marvell-Contr.

USB-3.0-Anbindung im Chipsatz

2 x USB 3.0

LAN 1

LAN 2

Kleine USBs: Links

im Bild der aktuelle

Micro-3.0-Standard,

der die zusätzlichen

Kontakte links

herausführt, rechts

im Bild der bekannte

USB-2.0-Mini-Anschluss.

P55-Chip

2 x SATA 3

1 Lane

PCI-E 2.0

PCI-Express

RJ45

RJ45

LAN-Contr. LAN-Contr.

1 Lane 1 Lane

PCI-E 1.0 PCI-E 1.0

1 Lane

PCI-E 1.0

Marvell-Contr.


Mainboard

Beim aktuellen SATA-6Gb/s-Standard kann es zu Problemen

mit älteren SATA-Kabeln kommen. Spezielle

SATA-6-GBit/s-Kabel hält der Fachhandel bereit.

So funktioniert

Serial ATA

SATA (rechts) und

der platzsparende

m-SATA-Anschluss

(Mitte), welcher

auch des Öfteren auf

Mainboards für SSD-

Caching zum Einsatz

kommt.

Aktuelle SSDs, Festplatten

und optische Laufwerke

werden per

Serial-ATA oder kurz SATA angeschlossen.

Wie schon bei den

Prozessorbussen und PCI-Express

werden bei Serial-ATA die

einzelnen Bits nacheinander

übertragen, was höhere Taktfrequenzen

erlaubt.

In der ersten Variante konnten

bei einem Takt von 1,5 GHz annähernd

150 Megabyte pro Sekunde

übertragen werden. Der

Anteil nutzbarer Daten beträgt

dabei 80 Prozent – die verbleibenden

20 Prozent dienen der

Prüfung und Fehlerkorrektur.

Für platterbasierte Festplatten

reichte diese Geschwindigkeit

aus, doch mit leistungsfähigen

SSD-Speichern wurden auch immer

schnellere Versionen von

SATA nötig.

NCQ und AHCI

Zudem fanden im Laufe der

Zeit nützliche Funktionen wie

AHCI („Advanced Host Controller

Interface“) und NCQ

(„Native Command Queuing“)

ihren Weg in die Spezifikation,

durch welche die Datenströme

effizienter abgearbeitet werden

können.

Stehen mehrere Zugriffe zeitnah

an, so kann der Controller

sie beim NCQ unter Berücksichtigung

der Zugriffs- und Rotationslatenz

so umsortieren, dass

die Schreib- und Leseköpfe von

Festplatten nur möglichst kurze

Wege zurücklegen müssen.

Auch SSDs können von NCQ

profitieren, da der Con troller

mehrere Zugriffe auf den Inhalt

einer Flash-Speicherzelle

kombinieren kann statt mehrfach

die umständliche Read-Modify-Write-Prozedur

für jeden

Datenblock auszuführen.

SATA 3 GBit/s

Mit der zweiten Revision SATA

3 GBit/s, oft und nicht ganz

korrekt auch als SATA II bezeichnet,

verdoppelte man

die Übertragungsrate auf 300

Megabyte pro Sekunde und damit

auf das Niveau der damals

schnellsten SSDs. Hinzu kamen

außerdem Funktionen wie das

angesprochene NCQ, aber auch

Erweiterungen wie „Staggered

Spinup“ – diese Technik erlaubt

das verzögerte Einschalten der

Festplatten. Der Hintergrund:

Das Anlaufen und Beschleunigen

des Festplattenmotors sorgt

beim Einschalten für eine sehr

hohe Leistungsaufnahme; werden

mehrere Festplatten gleichzeitig

eingeschaltet, kann das

zur Überlastung des Netzteils

führen.

SATA 6 GBit/s

Die dritte SATA-Generation3

bietet eine maximale Bandbreite

von 6.000 Megabit pro Sekunde

und kann somit Daten doppelt

so schnell übertragen wie

der SATA-3-Gb-Standard (3.000

MBit/s). Daher wird diese auch

oft „SATA 6 GBit/s“ genannt.

Lassen Sie sich nicht verwirren:

Bei Ports mit der Beschriftung

„SATA 3 GBit/s“ handelt es sich

nur um alte SATA-II-Anschlüsse.

Zum besseren Verständnis verwenden

wir den Begriff SATA 3

anstelle von SATA 6 GBit/s.

Die Bandbreite wurde beim

neuen Standard für HDDs, SSDs

und optische Laufwerke zwar


Mainboard

verdoppelt, dennoch sind die

neuen Ports abwärtskompatibel

und eignen sich daher auch

für SATA-3-GBit/s-Laufwerke

der Revision 2.6. Theoretisch

lassen sich sogar die gleichen

Kabel weiterhin verwenden.

Die offizielle Webseite serialata.

org gibt jedoch an, dass manche

Kabel aus minderwertigem Material

hergestellt sind und daher

bereits an der Leistungsgrenze

von SATA-3-GBit/s liegen.

Neue Anschlüsse

Zudem gibt es bei der dritten

SATA-Generation zusätzlich

kleinere Anschlüsse etwa für

Notebooks, Netbooks oder

DVD-Player. Während SATA-3-

GBit/s-Geräte die Funktion Native

Command Queuing (kurz:

NCQ) unterstützen, bietet SATA

6 GBit/s zusätzlich NCQ Streaming.

Damit soll der Transfer

von Audio- und Video-Dateien

verbessert werden.

Stromsparfunktionen

Neu sind zudem mehrere

Stromsparfunktionen. So musste

die Festplatte bisher auf Erlaubnis

des Hosts warten, bevor

sie in den Schlafzustand wechseln

konnte. Bei SATA 6 GBit/s

können sowohl Host als auch

Laufwerk den Schlummer-Modus

starten, ohne sich abstimmen

zu müssen. Das Laufwerk

muss auch nicht mehr vorher in

den aktiven Modus gelangen.

Obwohl der PHY-Chip (physikalische

Schnittstelle, kodiert und

dekodiert die entsprechenden

Daten) beim SATA-6-GBit/s-

Standard im aktiven Modus eine

höhere Leistungsaufnahme

hat als entsprechende SATA-3-

GBit/s-Chips, ist der Verbrauch

des Controllers insgesamt nur

ungefähr halb so hoch wie bei

einem SATA-3-GBit/s-Gerät.

E-SATA

Die externe Variante E-SATA

erlaubt den Anschluss von Datenträgern

ohne Brückenchips,

die sonst nötig sind, um den

Kommandostrom zum Beispiel

nach USB umzusetzen. Die Eigenschaften

externer Geräte

entsprechen denen im Gehäuse

montierter SATA-Laufwerke inklusive

der maximalen theoretischen

Übertragungsraten.

Die bis zu zwei Meter langen

Kabel sind allerdings speziell

abgeschirmt und nicht mit

den internen Geräten kompatibel.

Ein Manko, welches

den externen Einsatz verkompliziert,

ist das Fehlen einer

Stromversorgung in normalen

E-SATA-Anschlüssen. Daher

benötigen per E-SATA angeschlossene

Geräte entweder

ein Netzteil oder ein zusätzliches

USB-Kabel. E-SATA-p (für

„powered“) behebt diesen

Missstand, indem es E-SATAund

USB-Buchse kombiniert –

hieran arbeiten auch normale

USB-Geräte.

SATA Express

Einige SSD-Festplatten nutzen

bereits die volle Bandbreite

von SATA 6 GBit/s aus. Mit dem

kommenden Standard SATA 8

GBit/s soll der Engpass erneut

geweitet werden. Technisch gesehen

handelt es sich dabei um

eine PCI-Express-Verbindung

mit einer Lane. Die Erweiterung

des SATA-Standards (Revision

3.2) sieht zudem die Benutzung

einer zweiten Lane vor

– so lassen sich bis zu 16 GBit/s

erreichen, was für die nächsten

SSD-Generationen ausreichen

sollte. Danach wäre erneut eine

Verbesserung notwendig; vielleicht

wurde Serial-ATA bis dahin

aber auch schon von einer

anderen Schnittstelle abgelöst.

Theoretische Bandbreiten

Theoretische Bandbreite

in Megabyte/s

Theoretische Bandbreite

in Megabit/s

USB 2.0 60 MByte/s 480 MBit/s

USB 3.0 625 MByte/s 5.000 MBit/s

SATA 187,5 MByte/s 1.500 MBit/s

SATA 3 GBit 375 MByte/s 3.000 MBit/s

SATA 6 GBit 750 MByte/s 6.000 MBit/s

Eine PCI-E-Lane 250 MByte/s 2.000 MBit/s

Eine PCI-E-2.0-Lane 500 MByte/s 4.000 MBit/s

Eine PCI-E-3.0-Lane 985 MByte/s 7.880 MBit/s

LAN (100 MBit) 12,5 MByte/s 100 MBit/s

LAN (Gigabit) 125 MByte/s 1.000 MBit/s

Wie Schnittstellen an den

Chipsatz angebunden sind

Der P55-Chip liefert bis zu acht PCI-Express-Lanes. Jeweils eine steht

den Controllern für SATA 3, USB 3.0 und Gigabit-LAN zur Verfügung.

Der Rest geht an die Slots.


Mainboard

So funktioniert

Thunderbolt

Thunderbolt-

Integration

Damit Thunderbolt funktioniert,

ist bei aktuellen Mainboards

ein zusätzlicher Controller

nötig. Er ist in der Regel über

vier PCI-Express-2.0-Lanes mit

dem Mainboard-Chip verbunden.

Chipsätze mit integrierter

Thunderbolt-Unterstützung

sind auf absehbare Zeit nicht zu

erwarten.

In den Steckern von Thunderbolt-Kabeln

sitzen aktive

Chips. Das macht die Kabel

vergleichsweise teuer.

Die Form des Thunderbolt-

Anschlusses gleicht einem

Mini-Display-Port, braucht aber

andere Kabel. Im Hintergrund

erkennbar: der Thunderbolt-

Controller-Chip von Intel.

Wie Thunderbolt Daten

überträgt

Bei Thunderbolt können verschiedene Dateninhalte gemischt werden.

So können nicht nur externe Geräte wie Massenspeicher angeschlossen

werden, sondern auch Anzeigegeräte via Display Port.

Die Schnittstelle der Zukunft

heißt Thunderbolt;

jedenfalls wenn

es nach Intel geht. Der Chiphersteller

präsentierte die neue

Technik erstmals im Herbst

2009, damals noch unter dem

Namen „Light Peak“.

Optische

Übertragung

Der Name leitet sich von der optischen

Übertragungstechnik

ab – Intel stellte „Light Peak“ ursprünglich

mit Lichtleitern als

Kabel vor; diese waren jedoch

für den kommerziellen Einsatz

im PC zu teuer; Intel überarbeitete

daraufhin die Technik, realisierte

eine Transferrate von 10

GBit mit Kupferkabeln und ersann

den neuen Namen „Thunderbolt“.

Thunderbolt soll die bisherigen

Standards wie USB und Display

Port ablösen. Schließlich eignet

sich Thunderbolt sowohl zur

Übertragung von Daten (etwa

für externe Laufwerke) als auch

für Video- und Audiosignale (für

Displays) und ist selbst mit nur

einem duplexfähigen 10-GBit/s-

Kanal pro Richtung derzeit theoretisch

doppelt so schnell wie

USB 3.0. Entsprechende Mainboards

sind bereits verfügbar.

Theoretisch könnte Thunderbolt

auch Serial-ATA ersetzen.

Die Auswahl preiswerter Mainboards

und passender Endgeräte

ist allerdings noch gering:

Es gibt ein Apple-Display sowie

eine Handvoll externer Laufwerke.

Dabei muss man unterscheiden

zwischen Modellen, die mit

einem zusätzlichen Stromkabel

an die Steckdose angeschlossen

werden, und Laufwerken, die

per Thunderbolt-Anschluss mit

Strom versorgt werden und daher

mit einem einzelnen Kabel

auskommen.

Strom über

Thunderbolt

Der Thunderbolt-Port stellt

zehn Watt zur Verfügung. Da

der Controller, der in einem externen

Laufwerk mit Thunderbolt-Anschluss

sitzt, ebenfalls

relativ gierig ist, bleibt nicht

mehr viel für die enthaltene

SSD übrig. Bei Geräten, die mit

einer Stromquelle verbunden

sind, ist das natürlich kein Problem.

Zudem bieten diese meistens

zwei Anschlüsse.

Thunderbolt unterstützt die Daisy-Chain-Technik,

so können bis

zu sechs Thunderbolt-Geräte

(mit zwei Anschlüssen) und ein

Monitor per Display Port verbunden

werden – alles mit einem

einzigen Port auf dem Board.

Thunderbolt 2

Im Juni 2013 präsentierte Intel

die nächste Generation „Thunderbolt

2“, welche die Transferrate

mit bis zu 20 GBit/s verdoppelt.

Thunderbolt 2 soll bis

Ende 2013 verfügbar sein.


Infrastruktur


Infrastruktur

Bild: Intel

So funktioniert

Speicher (RAM)

Bei der Einführung neuer Herstellungsverfahren

werden die ersten

Wafer üblicherweise wegen ihres

einfachen Aufbaus mit SRAM-Zellen

bestückt – wie hier bei einem

der ersten 45-nm-Wafer.

Eine SRAM-Zelle unter dem Mikroskop: Das Flipflop, welches die Daten

speichert, ist an den waagerechten Linien zu erkennen.

Jeder hat ihn. Wenn er

knapp wird, geht erst mal

nichts mehr. In puncto

Menge ist es wie mit dem Hubraum

bei Verbrennungsmotoren:

Er ist durch nichts zu ersetzen

außer durch noch mehr

davon. Der Arbeitsspeicher,

auch RAM genannt, ist wichtiger

Bestandteil eines jeden PCs,

seit der erste Computer in den

Labors der Wissenschaftler das

Licht der Welt erblickte.

Grundbegriffe

Im Zusammenhang mit Arbeitsspeicher

geistern eine Unmenge

an Begriffen und Abkürzungen

durch die Medien, die nicht

immer auf den ersten oder

zweiten Blick verständlich sind

und nicht selten fälschlicherweise

in einem Topf landen.

Der im Englischen für Arbeitsspeicher

verwendete Begriff

RAM steht für „Random Access

Memory“. Dabei soll mitnichten

auf Zufallszugriffe angespielt

werden, vielmehr wird mit diesem

Namen das Prinzip hervorgehoben,

dass jede beliebige,

also zufällig gewählte Speicherzelle

in exakt gleicher, also konstanter

Zeit angesprochen und

ausgelesen werden kann.

Umgangssprachlich wird zwar

häufig zwischen RAM und ROM

(„Read-only memory“, nur lesbarer

Speicher) unterschieden,

technisch handelt es sich

bei einem ROM jedoch genauso

um RAM. Das gilt auch für

Flash-Speicher, wie er in USB-

Sticks oder SSDs zum Einsatz

kommt: Auch hier kann jeder

beliebige Block in konstanter

Zeit ausgelesen werden.

Im Gegensatz dazu stehen Medien

wie Festplatten oder DVDs,

die Daten auf einer rotierenden

Platte speichern und somit per

definitionem nicht immer in

konstanter Zeit liefern können.

Flüchtige Speicher

Es gibt grundsätzlich zwei Typen

RAM: volatile (flüchtige)

Speicher (VRAM) und nichtvolatile

Speicher (NVRAM). Die

Definition ist simpel: Ein volatiler

Speicher verliert ohne

Spannungsversorgung seine Informationen,

ein nichtvolatiler

Speicher nicht.

Die heutzutage am häufigsten

vorkommenden Arten von beschreibbarem

RAM sind DRAM

(dynamisches RAM), SRAM (statisches

RAM) und Flash, Letzteres

ist im Gegensatz zu den

ersten beiden nicht volatil. Die

Bauform wird mit Begriffen wie

SIMM, DIMM oder SO-DIMM bezeichnet.

SRAM

Der primäre Unterschied zwischen

SRAM und DRAM liegt

in der Speichertechnik, also

auf elektrotechnischer Ebene

in der Art und Weise, wie ein

Bit gespeichert wird. SRAM

verwendet hierfür ein sogenanntes

Flipflop, bestehend aus

sechs Transistoren: vier zum

Speichern der eigentlichen

Informa tion (T3-T6) und zwei

für die Ein-/Ausgabe (T1-T2).

Da es sich um ein Flipflop handelt,

enthält ein SRAM immer

zwei Ausgänge, A und Nicht-A.

Dadurch lassen sich Fehler, die

durch Rauschen entstehen können,

sofort erkennen und gege


Infrastruktur

benenfalls durch erneutes Auslesen

korrigieren.

Der größte Nachteil von SRAM

ist die verhältnismäßig komplexe

Art der Speicherung

und die da raus resultierende

benötigte Fläche. Der größte

Vorteil ist die Tatsache, dass

die Information im Gegensatz

zu dynamischem RAM nicht regelmäßig

aufgefrischt werden

muss, sondern erhalten bleibt,

solange Spannung anliegt. Aufgrund

dieses hohen Levels an

Datenkohärenz und der hohen

Geschwindigkeit im Vergleich

zu DRAM kommt SRAM primär

in Caches zum Einsatz, zum Beispiel

in den drei Cache-Stufen

moderner Mikroprozessoren.

DRAM

Als dynamisches RAM bezeichnet

man einen Typ Arbeitsspeicher,

bei dem die gespeicherte

Information sogar höchst flüchtig

ist. Im Gegensatz zu SRAM

wird pro Bit lediglich ein Transistor

und ein Kondensator benötigt.

Da Kondensatoren einen

Zustand aufgrund von Leckströmen

jedoch nur für einen

beschränkten, direkt zur Kapazität

proportionalen Zeitraum

halten können, muss dieser in

regelmäßigen Zeitabständen

aufgefrischt werden. Ein Vorteil

ist die im Vergleich zu SRAM

hohe Speicherdichte, da die benötigte

Fläche pro Bit um ein

Vielfaches geringer ist. DRAM

kommt primär in Speichermodulen

für PCs zum Einsatz, da

der Vorteil der hohen Speicherdichte

die Nachteile der im

Vergleich zu SRAM schlechten

Performance und der Notwendigkeit

des regelmäßigen Auffrischens

aufwiegt.

Das heute zum Einsatz kommende

SDRAM steht am Ende

einer langen Kette von Entwicklungen,

von FPM-DRAM („Fast

Page Mode“) über EDO-DRAM

(„Extended Data Output“) zum

„(A)Synchronous DRAM“. Synchronität

bedeutet bei DRAM

schlichtweg eine Taktung, die

im Optimalfall zum Systembus

gleichgeschaltet ist. Asynchron

synchrones DRAM bedeutet,

dass der Takt von Systembus

und Speichermodul nicht synchron

ist, sondern verschieden.

Funktionsprinzip

Jede Speicherzelle eines

DRAM-Moduls besteht wie bereits

erwähnt aus einem Kondensator

und einem Transistor.

Der Kondensator übernimmt

das eigentliche Speichern der

Funktion, der Transistor ist

für Lese- und Schreibzugriffe

zuständig. Jede Speicherzelle

kann somit ein Bit speichern

und verfügt über eine „Wordline“

und eine „Bitline“. Die

„Wordline“ gibt den Befehl zur

Schaltung an den Transistor,

wodurch die Information über

den Zustand des Kondensators

(1 oder 0) an die „Bitline“ weitergeleitet

wird.

An eine „Wordline“ können

theo retisch beliebig viele Speicherzellen

angeschlossen werden.

In diesem Fall spricht man

von einer sogenannten „Page“

oder auch Speicherzeile. Wird

die „Wordline“ aktiviert, kann

theoretisch die gesamte Speicherzeile

in einem Rutsch ausgelesen

werden. In der Praxis

tritt dieser Fall jedoch äußerst

selten auf, es werden meist einzelne,

über die Spaltenadresse

definierte Speicherzellen angesprochen.

Mehrere Speicherzeilen lassen

sich zu einer Speicherbank zusammenschalten.

Dabei handelt

Wie SRAM und DRAM

Daten speichern

SRAM

SRAM-Speicherzellen sind im Vergleich zu DRAM-Zellen sehr komplex.

Zum Speichern eines einzelnen Bits werden sechs Transistoren (T1-T6)

benötigt, die Schaltung der Transistoren T3 bis T6 erfolgt in Form eines

sogenannten Flipflops. Die Transistoren T1 und T2 steuern den Zugriff

auf das Flipflop, die Zelle verfügt über die Ausgänge bl und Nicht-bl.

DRAM

Eine DRAM-Speicherzelle benötigt hingegen lediglich einen Transistor

und einen Kondensator, an eine Wordline können theoretisch beliebig

viele Zellen angeschlossen werden. Anders als eine SRAM-Speicherzelle

verfügt eine DRAM-Zelle lediglich über einen Ausgang und arbeitet

zudem deutlich langsamer.


Infrastruktur

*Dual-Channel

Wie Speicher früher aussah

Bis Ende der 80er-Jahre wurden die Speicherchips (DIPs) meist einzeln

auf das Mainboard gelötet. Eine Speicheraufrüstung war daher schwierig

– und hatte mit maximal 1 MBit pro Chip enge Grenzen. Einfacher

wurde es mit SIP-Modulen von bis zu 1 MByte, welche sich aufstecken

ließen. Sie wurden von SIMMs abgelöst; auf ihnen kamen FPM-Speicherchips

zum Einsatz, später das schnellere EDO-RAM (im Bild ein

EDO-SIMM mit 4 MiByte).

1996 folgten die DIMMs, auf ihnen das noch heute übliche SDRAM

– zunächst in „Single Data Rate“-Ausführung. Ende 1999 schließlich

kamen die RDRAM-Chips der Firma Rambus sowie DDR-SDRAM auf

den Markt.

Speichertypen in der Übersicht

Bezeichnung Speichertakt I/O-Takt Datendurchsatz

PC66 66 MHz SDR 66 MHz SDR 533 MiByte/s

PC100 100 MHz SDR 100 MHz SDR 800 MiByte/s

PC133 133 MHz SDR 133 MHz SDR 1.066 MiByte/s

DDR-200 100 MHz DDR 100 MHz DDR 1.600 MiByte/s (PC-1600)




DDR2-400 100 MHz DDR 200 MHz DDR 3.200 MiByte/s (PC2-3200)









DDR3-2133 266 MHz DDR 1.066 MHz DDR 17.066 MiByte/s (PC3-17000)

RD300 300 MHz DDR 300 MHz DDR 1.200 MiByte/s (PC600)

RD400 400 MHz DDR 400 MHz DDR 1.600 MiByte/s (PC800)

RD3200* 400 MHz DDR 400 MHz DDR 3.200 MiByte/s (RIMM 3200)



es sich um eine zweidimensionale

Matrix mit konstant langen

Speicherzeilen. Ein Adressdekoder

sorgt dafür, dass aus der

Speicheradresse die korrekte

Speicherzeile ermittelt und

über die „Bitline“ an den Ausgabekontakt

übermittelt wird. Die

Anzahl der Ausgabekontakte bestimmt

die Datenbreite der jeweiligen

Chips – wird lediglich

ein Pin ausgeführt, so hat der

Speicherchip eine Datenbreite

von 1 Bit.

DRAM-Chips werden immer zeilenweise

gelesen. Wird das Speichermodul

adressiert, sorgt der

Adressdekoder zunächst für die

Dekodierung der Adresse und

die Ermittlung der benötigten

Speicherzeile. In aller Regel enthält

diese bei modernen Speichermodulen

4.096 Speicherzellen,

also 512 Byte. Bei der bei

x86-Prozessoren üblichen Page

Size von 4 KiByte müssen also

bei jedem Speicherzugriff vier

komplette Speicherzeilen gelesen

oder geschrieben werden.

Lese-/Schreibzugriffe

Ein solcher Lese-/Schreibzugriff

ist in drei Phasen unterteilt:

Vorbereitung, Ausführung des

eigentlichen Lese-/Schreibvorgangs

in einer Speicherzeile

und Nachbereitung. Während

der Vorbereitung werden zwei

Schritte durchgeführt: Zunächst

ermittelt der Adressdekoder

aus der ihm übergebenen

Zeilenadresse die korrekte

Speicherzeile. Die Länge dieser

Adresse hängt dabei von der

Anzahl der in der Speicherbank

vorhandenen Speicherzeilen ab

– bei einer acht Bit langen Zeilenadresse

können 28 Zeilen adressiert

werden. Anschließend

wird die benötigte Speicherzeile

aktiviert, indem zunächst die

im Ruhezustand an der „Bitline“

anliegende Spannung gekappt

und anschließend an die „Wordline“

Spannung angelegt wird.

Im zweiten Schritt wird nun der

eigentliche Lese- oder Schreibzugriff

auf die Speicherzeile

durchgeführt. Bei einem Lesezugriff

wird zunächst die Spaltenadresse

ermittelt und die benötigten

„Bitlines“ über einen

Leseverstärker, der aufgrund

der Länge der Leitungen notwendig

ist, mit der Datenleitung

des Speicherchips verbunden.

Diese Daten werden dann mit

dem nächsten Taktsignal ausgegeben.

Ein Schreibvorgang verläuft

ähnlich. Zunächst wird die

Spaltenadresse vom Spaltendekoder

entschlüsselt und die benötigten

Speicherzellen mit der

Datenleitung verbunden. Die

zu schreibenden Informationen

laufen nun durch den Leseverstärker

und setzen die Bits in

den korrespon dierenden Speicherzellen.

Im Nachgang an einen Lese-/

Schreibzugriff muss die Speicherzeile

wieder deaktiviert

werden. Hierfür wird die

„Wordline“ wieder von der anliegenden

Spannung getrennt,

wodurch die Transistoren in

den jeweiligen Speicherzellen

dieser Speicherzeile die Kondensatoren

der Speicherzellen

von den Bitleitungen abkoppeln.

Zuletzt werden die „Bitlines“

wieder mit Spannung

versorgt und nehmen ihren Ursprungszustand

an.

Auffrischung

Wie bereits erwähnt unterscheidet

sich dynamisches RAM

von statischem RAM dadurch,

dass die Daten flüchtig sind und

regelmäßig aufgefrischt werden

müssen. Diese Wiederauffrischung

führen die primären


Infrastruktur

Leseverstärker in definierten

Abständen (meist 32 oder 64

Millisekunden) durch. Dabei

macht man sich die Tatsache zunutze,

dass die Daten bei jedem

Schreibvorgang die Leseverstärker

durchlaufen und erst dann

in die Speicherzellen geschrieben

werden. Die Leseverstärker

sind mit T4-SRAM, also 1-Bit-Datenspeicher

als Flipflop realisiert,

mit vier Transistoren ausgestattet

und somit in der Lage,

jeden beliebigen Zustand so

lange zu halten, wie Spannung

anliegt. Der Refresh erfolgt also

regelmäßig aus diesen „Latch“

genannten Registern, wobei

hier der komplette Schreibzyklus,

abgesehen von der Bindung

der „Bitline“ an die Datenleitungen,

durchlaufen wird.

Wartezeiten

Aufgrund dieses hochkomplexen

Vorgangs beim Zugriff auf

Speicherzeilen und -zellen müssen

zwischen den Schritten definierte

Pausen eingelegt werden.

Diese Wartezyklen werden

als Latenzen bezeichnet und

vom Speichercon troller festgelegt.

Der Wert gibt die Taktzyklen

an, die für bestimmte Aktionen

gewartet werden muss.

Da es sich um eine Zeiteinheit

handelt, werden die Latenzen

mit tXYZ bezeichnet, wobei

XYZ die jeweils spezifische Latenz

definiert. In der Reihenfolge

eines Lesezugriffs sind

folgende Latenzen relevant:

Zunächst bestimmt die tRP

die „RAS precharge“, also die

Anzahl der Taktzyklen, die vergehen

müssen, bevor in einem

Speicherchip eine spezielle

Zeile adressiert werden kann.

Die tRAS („Row Access Strobe“)

bestimmt die Anzahl der Taktzyklen,

die benötigt werden, um

eine Zeile in der Speicherbank

Wie ein Speicherchip aufgebaut ist

DRAM-Speicherfeld*

DRAM-Speicherchip*

CS

Chip

Select

BA

Bank

Address

Ax

Address

Steuersignale

RAS

Row Address

Strobe

CAS

Column

Address Strobe

WE

Write

Enable

DQ

1 4

2

3

5

7

Adresspuffer

DRAM-

Steuerung

Daten schreiben

Daten lesen

9

Zeilendekoder

1 2 3 ..

2

3

..

6

Spaltendekoder

Daten Daten

schreiben lesen

Datenpuffer

8

Ausgewählte

1-Bit-Zelle

Speicherfeld

(Matrix)

Zeile 4.096

Spalte 1.024

DRAM-Chip 16Mx8

4 MBit x 4 x 8 = 128 MBit

Bank 3

Bank 2

Bank 1

Bank 0

4 MBit x 8 = 32 MBit

8 Speicherfelder à 4 MBit

* Vereinfachte Darstellung

Ablauf eines Lesezugriffs (vereinfacht):

1) Über die „Chip-Select“- (CS) und „Bank-Address“-Pins (BA) werden der

Chip und die Bank mit der gesuchten Speicherzelle ausgewählt.

2) Der Speichercontroller übergibt die Zeilenadresse dieser Zelle in den

Adresspuffer.

3) Das Steuersignal RAS wird über die RAS-Pins übergeben – so erfährt

die DRAM-Steuerung, dass es sich bei der Adresse um eine Zeile handelt,

noch nicht um eine Spalte.

4) Die DRAM-Steuerung übergibt die Adresse vom Puffer an den

Zeilendekoder, der nun die richtige Zeile („row“) auswählt.

5) Nach kurzer Verzögerung folgt die Spaltenadresse mit dem CAS-Signal.

6) Der Spaltendekoder wählt anhand dieser Adresse die Spalte

(„column“) aus.

7) Das WE-Signal („Write Enable“) bleibt inaktiv. Es werden also keine

Daten geschrieben, sondern nur ausgelesen; bei einem Schreibzugriff

würde dieses Signal aktiviert.

8) Die gewählte Speicherzelle entlässt ihren Inhalt über die Bitleitung in

den Datenpuffer.

9) Der Datenpuffer übergibt die Informationen über die DQ-Pins an den

Datenbus zum Speichercontroller, der sie dann an die CPU

weiterreicht.


Infrastruktur

DRAM-Alternativen

Die zahlreichen Nachteile von DRAM (Zellauffrischung, vergleichsweise

langsamer Zugriff etc.) sorgten schon früh dafür, dass Entwickler nach

besseren Alternativen suchten. Bis heute jedoch konnte sich DRAM

gegen zahlreiche Konkurrenztechniken behaupten.

RDRAM

Mit RDRAM legten Intel und Rambus vor einigen Jahren beim Versuch,

einen SDRAM-Nachfolger zu etablieren, eine spektakuläre Bauchlandung

hin. RDRAM erschien erstmals 1999 und sollte der Speicher für

Intels Pentium 4 werden. Diverse Probleme sowie hohe Preise zwangen

Intel jedoch dazu, einen Chipsatz für das erheblich günstigere und

zu diesem Zeitpunkt weit verbreitete DDR-SDRAM anzubieten. Die

RDRAM-Module mit 16-Bit-Bus wurden im Dual-Channel-Mode betrieben

und erreichten bis zu 3.200 MiByte/s.

TTRAM, ZRAM und TRAM

Bei TTRAM („twin transistor RAM“) handelt es sich um eine Weiterentwicklung

von DRAM, bei der das Funktionsprinzip erhalten bleibt, der

Kondensator jedoch durch einen Transistor ersetzt wird. Es entstehen

somit keine Leckströme, womit kein Wiederauffrischen nötig ist.

ZRAM („zero capacitor RAM“), eine Technologie, die von AMD übernommen

wurde und Verwendung bei zukünftigen CPUs finden könnte,

ist eine von DRAM und SRAM unabhängige Eigenentwicklung. Da zum

Speichern lediglich ein einzelner Transistor benötigt wird, ermöglicht es

noch höhere Speicherdichten als DRAM – bei mit SRAM vergleichbarer

Performance.

Auch TRAM („thyrstor RAM“), ebenfalls eine vollständige Neuentwicklung,

könnte zum Einsatz kommen. Es macht sich den negativen differenziellen

Widerstand von Transistoren zunutze. Die Speicherzellen der

kommenden Generation sollen bereits die Speicherdichte von DRAM,

jedoch eine höhere Performance als T6 SRAM erreichen.

MRAM, FRAM und PRAM

Seit den 90er-Jahren wird „magneto-resistives RAM“ (MRAM) entwickelt,

das nicht mit elektrischen, sondern mit magnetischen Ladungselementen

arbeitet – und das schneller als DRAM. Es kamen sogar einige

MRAM-Chips in den Handel, blieben aufgrund des hohen Preises

aber bis heute Nischenprodukte.

Seit 1999 wird FRAM angeboten, „ferroelektrisches RAM“. Anstelle des

gewöhnlichen wird ein „ferroelektrischer“ Kondensator verwendet, der

seine Ladung auch ohne Spannung über Jahre hinweg hält. Die Herstellung

ist aber sehr aufwendig.

PRAM („Phase Change RAM“) arbeitet nach einem ähnlichen Prinzip

wie die DVD: Der elektrische Widerstand des Speichermaterials in der

Zelle wird durch Stromstöße geändert; hoher und niedriger Widerstand

stehen für die Bit-Werte 0 und 1.

zu aktivieren. tRCD („RAS low

to CAS low delay“) legt fest, wie

lange es dauert, bis die benötigten

Spalten aktiviert sind. Und

zuletzt die bekannteste aller Latenzen,

die tCL, die bestimmt,

wie viele Takte vergehen müssen,

bis davon ausgegangen

werden kann, dass die Daten

vollständig aus den benötigten

Speicherzellen ausgelesen wurden.

Stabilität contra

Übertakten

Damit lässt sich auch der Zusammenhang

aus Spannung, schärferen

Timings und höherer Stabilität

erklären. Angenommen,

Sie verringern die tCL Ihres

Speichermoduls. Damit nimmt

der Speichercon troller bereits

einen Taktzyklus vor dem vom

Speicherhersteller vorgesehenen

Zeitraum die Korrektheit

der ausgelesenen Daten an und

arbeitet damit weiter. Stimmen

diese jedoch noch nicht, kann

es zu Lese- oder Schreibfehlern

und in direkter Folge zu einem

Absturz des Systems kommen.

Wenn Sie jedoch die Spannung

des Speichers minimal anheben,

sinkt die benötigte Zeit,

um definierte Ladungszustände

schneller zu erreichen. Das System

kann wieder stabil werden.

Das Gleiche gilt in dieser Form

natürlich auch für alle anderen,

hier nicht beschriebenen Latenzen.

Doppeltes Lottchen

Bei DDR-SDRAM, einer Weiterentwicklung

von SDRAM,

wandte man einen Trick an, um

die Datenrate zu verdoppeln.

Da die Taktfrequenz der Speicherchips

nicht signifikant erhöht

werden konnte, entschlossen

sich die Ingenieure, beide

Taktflanken, also an- und absteigend,

zur Übertragung von

Daten zu nutzen. Dadurch kann

ein mit 100 MHz getaktetes

DDR-SDRAM Modul theoretisch

doppelt so viele Daten übertragen

wie ein mit 100 MHz getaktetes

SDR-SDRAM-Modul.

In der Praxis gehen ein paar

Prozent Leistung aus strukturellen

Gründen verloren. DDR2-

SDRAM, das im Vergleich zu

DDR-SDRAM wieder eine Verdopplung

der effektiven Datenrate

beinhaltet, stellt dies

dadurch sicher, dass sowohl der

Prefetch-Buffer von zwei auf

vier Bit als auch der I/O-Takt,

mit dem das Modul nach außen

kommuniziert, verdoppelt wurden.

Das gleiche Prinzip wurde

noch einmal bei DDR3-SDRAM

angewandt – Verdopplung des

Prefetch-Buffers von vier auf

acht Bit und Vervierfachung

des I/O-Takts in Relation zum

Speichertakt.

Der Preis für diese Verdopplung

war ein drastischer Anstieg der

Latenzen, da sich an der grundlegenden

Speichertechnik der

DRAM-Speicherchips nichts geändert

hatte. Faktisch sind die

Latenzen bei DDR2-SDRAM im

Vergleich zu DDR-SDRAM also

fast doppelt, bei DDR3-SDRAM

sogar fast viermal so hoch. Rechnet

man den Takt jedoch in Nanosekunden

um, ergeben sich

fast identische Wartezeiten.

Datenkohärenz

Bei besonders hochkapazitiven

RAM-Modulen kommt eine spezielle

Technik zum Einsatz, da

die Informationen aus den Speicherchips

sonst unzuverlässig

sein könnten. Die Rede ist von

sogenannten Registered-Modulen.

Hierbei setzt man auf ein

gesondertes externes Register,

welches zwischen dem Spei-


Infrastruktur

Wie ein Speichermodul aufgebaut ist

Speicherchips

Je nach Kapazität des Speichermoduls

enthält es unterschiedlich viele Speicherchips.

Die meisten Module mit hoher

Kapazität verfügen über Chips auf Vorderund

Rückseite.

Register

Diese zusätzlichen Chips finden

sich ausschließlich bei Registered-

Modulen (Server). Sie entlasten den

Speichercontroller und ermöglichen

höhere Kapazitäten.

Kerbe

Die Kerben an der Seite fixieren die Module

in den Speichersockeln und verhindern ein

ungewolltes Herausrutschen. SO-DIMM-Module

verfügen aufgrund der höheren Anforderungen

über Metallsicherungen.

Pins

Auch die Anzahl der Kontakte variiert – 168

bei SDR-SDRAM, 184 bei DDR-SDRAM,

240 bei DDR2- und DDR3-SDRAM. SO-

DIMM-Module, die speziell für Laptops

entwickelt wurden, verfügen über 144

(SDR), 200 (DDR und DDR2) oder 204

(DDR3) Kontakte.

Kerbe

Da die Spannung von SDR-,

DDR-, DDR2- und DDR3-Modulen

unterschiedlich ist, verfügen

sie über unterschiedliche

Kerben. Dadurch wird

sichergestellt, dass sie nur in

PC Games Hardware WISSEN "So funktioniert Ihr Computer" So funktioniert Ihr Computer (Vorschau)

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.