PowerPC - Weblearn

Transcription

PowerPC - Weblearn

Referat
Rechner-Strukturen-Labor
PowerPC
Laborgruppe:
Christina Priebe
Carsten Wellbrock
Stefan Rauer
33253
32412
32496
Inhalt
1
2
3
4
5
Die Geschichte des PowerPC G1-G4...........................................................................................2
1.1
Das PowerPC - Konsortium................................................................................................2
1.2
PowerPC Prozessoren ..........................................................................................................3
1.3
G1 anhand des PPC 601.......................................................................................................5
1.4
G2 anhand des PPC 604.......................................................................................................9
1.4.1
Instruction Flow .........................................................................................................12
1.5
G3 anhand des PPC 750.....................................................................................................13
1.6
G4 anhand des MPC 7400 .................................................................................................15
1.7
Der G5................................................................................................................................16
Der PowerPC 970 Prozessor ......................................................................................................17
2.1
Die AltiVec-Erweiterung ...................................................................................................18
2.2
Die Architektur des 970 Prozessors ...................................................................................28
2.2.1
Front End ...................................................................................................................29
2.2.1.1 Branch prediction Konzepte...................................................................................30
2.2.1.2 Decode, cracking und group formation..................................................................30
2.2.2
PowerPC 970 Execution Core ...................................................................................34
2.2.2.1 Rename Register ....................................................................................................35
2.2.2.2 Die CR Logical Unit ..............................................................................................35
2.2.2.3 Load-Store Units ....................................................................................................36
2.2.2.4 Floating Point Units ...............................................................................................36
2.3
Die Pipeline........................................................................................................................37
2.4
Apple G5 System ...............................................................................................................38
LCT Hardware Teil....................................................................................................................40
3.1
Aufgabenbeschreibung.......................................................................................................40
3.2
Die Software ......................................................................................................................40
3.3
Der Simulator.....................................................................................................................40
3.4
Instruction-Format .............................................................................................................44
3.5
Ergebnisse ..........................................................................................................................47
3.6
Optimierung auf Assembler-Ebene....................................................................................49
Literaturliste PowerPC G1-G4, IBM PowerPC 970 und Bildquellen .......................................49
Anhang .......................................................................................................................................51
1
1 Die Geschichte des PowerPC G1-G4
1.1 Das PowerPC - Konsortium
Quelle: http://core.de/core/powerpc.html, http://www.fhwedel.de/cis/archiv/seminare/ws9900/ue/PowerPC/PowerPC.html
1991 fanden sich die Firmen Apple, IBM und Motorola in einem, auch AIM genannten,
Konsortium zusammen, um einen neuen RISC–Prozessor zu entwickeln der ihren besonderen
Ansprüchen genügte.
IBM wollte die Entwicklungskosten für ihre neue POWER genannte Architektur senken. POWER
(Performance Optimization With Enhanced RISC) wurde mit der RS/6000 in den Markt eingeführt,
aber man war an einer Einzelchipversion interessiert und wollte neue Märkte damit erobern.
Apple suchten einen Nachfolger für die von Ihnen verwendeten 68000/68040 Prozessoren von
Motorola. Der von IBM für deren High-End-Workstations entwickelte POWER-Prozessor war
wegen seiner leistungsfähigen und erweiterbaren Architektur ein interessanter Kandidat, jedoch zu
teuer in der Herstellung. Motorola brachte in die Entwicklung die Speicherverwaltung- und
Cacheeinheit ihrer 88000 RISC-Prozessoren ein (die 88K Familie wurde daraufhin eingestellt).
Gleichzeitig mit der Entwicklung der PowerPC-Prozessoren sollte auch eine Referenzplattform
geschaffen werden, die zur Konkurrenz gegen die etablierten Intel-Basierten PCs werden sollte.
Dabei zeigte sich dann allerdings, dass die Allianz der drei Firmen nicht in allen Belangen einer
Meinung war und die eher zurückhaltenden Bemühungen verliefen im Sande.
Die Ansprüche an den PowerPC waren umfangreich:
Abwärtskompatibilität bis zur Assemblerebene sowohl zum 68000/68040 und zum RS/6000
Preiswert
Einfacher Aufbau
Hohe Taktraten
Load/Store-Architektur
Fest definierte Architektur, die sowohl ein 32-Bit wie auch 64-Bit Modell umfaßt
Drei-Operanden-Befehle (die Vektor Einheiten (AltiVecTM) ab der G4 Generation beinhalten auch
Vier-Operanden-Befehle)
Geringe Chipfläche
Universelles Konzept für Desktop-, Server- und Embedded–Einsatz (High- und Lowend)
Multiprozessorfähig
2
1.2 PowerPC Prozessoren
Quelle: u. a. http://www.computer-archiv.de/
Jahr Bezeichnung Generation Hersteller
1992
1994
1994
1994
1994
1994
1995
1995
1996
1996
1996
1997
1997
1998
1998
1999
1999
2001
2002
2003
2003
PPC 601
PPC 601+
PPC 603
PPC 603+
PPC 604
PPC 620
PPC 603e
PPC 603ev
PPC 604e
PPC 613
PPC 614
PPC 750
PPC RS64
PPC AS
PPC Nothstar
PPC Pulsar
PPC 7400
PPC 7450
PPC 7455
PPC 85XX
PPC 970
G1
G1
G2
G2
G2
G2
G2
G2
G2
G2
G2
G3
G3
G3
G3
G3
G4
G4+
G4+
G5
G5
Registerbreite / bit L1 Cache / KB
Apple / IBM
Apple / IBM
IBM / Motorola
Motorolla
Apple / IBM
Apple / IBM
IBM
Apple / IBM
Apple / IBM
Apple / IBM
Apple / IBM
IBM / Motorola
IBM
Apple / IBM
IBM
IBM
IBM / Motorola
IBM / Motorola
IBM
IBM
IBM
32
32
32
32
32 / 64
64
32
32
32
32
32
32
64
64
64
64
32
32
32
64
64
32
unbekannt
16
32
unbekannt
32
32
unbekannt
unbekannt
unbekannt
unbekannt
unbekannt
unbekannt
unbekannt
unbekannt
unbekannt
unbekannt
unbekannt
unbekannt
unbekannt
64
Abbildung 1 Auswahl von PPC-Prozessoren im zeitlichen Verlauf
Bei einer vollständigen Auflistung aller entwickelten PPC-Prozessoren inklusive etlicher
Sonderanfertigungen käme man vermutlich auf einige hundert Prozessoren, wobei sich die
Prozessoren einer Generation kaum unterscheiden. Die Varianten besitzen lediglich
unterschiedliche Cache- oder Busbreiten.
3
Abbildung 2 Roadmap Motorola
4
Abbildung 3 Roadmap IBM
1.3 G1 anhand des PPC 601
Quelle:
http://www-1.ibm.com/servers/eserver/pseries/hardware/whitepapers/power/ppc_601.html
1992 kommt der erste PowerPC, PPC 601 oder auch G1 heraus:
Entwickelt in Austin, Texas
Basisdesign stammt von RISC Single Chip (RSC) von IBM
Basis für die Entwicklung des Businterfaces war der Motorola 88110
In 0,60m - Technologie umgesetzt
32 KB first-level Cache
Multiprozessorfähig
33–120 MHz
Der PowerPC 601 Mikroprozessor ist ein in hohem Grade integrierter single–chip Prozessor, der
eine leistungsfähige RISC Architektur, eine superskalare Maschinen–Organisation und eine
vielseitige leistungsstarke Busschnittstelle kombiniert. Der Prozessor enthält 32KB unified Cache
und ist zum Dispatchen, zur Ausführung und zum Beenden von bis zu 3 Anweisungen pro Zyklus
fähig. Die Businterface Konfiguration versorgt eine breite Palette von Systembusschnittstellen,
sowie seriellen und gesplitteten Transaktionen. Das PowerPC - Konsortium hat sich verpflichtet,
eine breite Palette von Prozessoren mit der PowerPC Architektur zu unterstützen.
Das Projekt 601 hatte einige Schlüsselziele. Zuerst war es wichtig, dass sich die PowerPC
Architektur möglichst früh im Markt etablieren kann. Zweitens mußte der Prozessor eine
konkurrenzfähige Leistung zu niedrigen Kosten anbieten.
5
Um diese Ziele zu erreichen, stellte sich die Gruppe mit dem 601 Design einem aggressiven 12monatigem Entwicklung Zeitplan. Zur Entwicklung nutzte man Technologien aus, die bei IBM und
bei Motorola schon vorhanden waren. Von IBM wurde der RISC Single Chip (RSC)
Mikroprozessor für das Basisdesign des 601 verwendet. Der 601 wurde um die superskalare
Maschienenorganisation erweitert um größere Performance zu erlangen und es wurden zusätzliche
maßgeschneiderte Schaltkreise verwendet um die Größe zu reduzieren und den Betrieb mit höherer
Frequenz zu erlauben. Das Motorola 88110 Mikroprozessor-Businterface bildete die Grundlage der
Entwicklung des Busdesign der 601 Architektur.
Prozessor-Funktionseinheiten
Der Mikroprozessor PPC 601 besteht aus den folgenden Units:
Instruction–Queue und Dispatch–Queue
Branch processing Unit
Fixed–Point–Unit
Floating–Point–Unit
Instruction Fetch Unit
Memory–Management–Unit
Cache
Memory Queue
Bus Interface Unit
Sequencer Unit
Common on–chip processor Unit
Abbildung 4 Blockdiagramm PPC 601
Blockdiagramm
Wie im Blockdiagramm gezeigt, ist die 601Architektur ein superskalares Design mit drei durch
Pipelines geleiteten Durchführungseinheiten. Der Prozessor kann bis zu drei 32-bit Anweisungen
pro Zyklus schicken, eine je zur Fixed–Point–Unit (FXU), zur Floating–Point–Unit (FPU) und zur
Branch–Unit (BPU). Die übliche „common on – chip processor“ unit (COP) ist die master control
logic für den built–in Selbsttest (BIST), Debug-, und andere Test–Features auf dem 601–Chip. Der
6
32KB Einheitscache stellt eine 32-bit Schnittstelle zur FXU, eine 64-bit Schnittstelle zur FPU und
eine 256-bit Schnittstelle zur Instruction–queue und zur Memory–queue zur Verfügung. Die Chip
I/O beinhalten einen 32-bit Adressbus und einen 64-bit Datenbus. Außerdem unterstützt der Chip
eine spezielle asynchrone serielle Schnittstelle, den COP Bus, der erweitertes Debuggen und andere
Test–Features liefert.
Abbildung 5 Pipeline PPC 601
Pipeline-Beschreibung
Die Entwickler optimierten die 601 Struktur mit Pipelines für hohe Leistung und gleichzeitige
Abarbeitung der Anweisungen in jeder der Ausführungseinheiten. (Siehe Abbildung 5). Im
allgemeinen dient die FXU als Masterpipeline, und synchronisiert die Steuerung, die erforderlich
ist, um exakte Ausnahmen zu erzielen. Die Fixedpoint Pipeline führt alle Ganzzahl- alle
Arithmetisch-Logischen Operationen (ALU) und alle Prozessor–Load- und Storeanweisungen,
einschließlich der Gleitkomma–Load – und Storeoperationen durch. In einigen Fällen können
Gleitkomma–Load- und Storeoperationen auch durch die Gleitkommapipeline geleitet werden. Die
Hardware behandelt alle Hazards und Abhängigkeiten. Die Weiterleitungslogik ermöglicht es, die
Integer–ALU gepipelined zu betreiben. Es kostet einen Zyklus, die Abhängigkeiten nach dem
Laden zu bearbeiten.
7
Abbildung 6 Instruction Queue und Dispatch PPC601
Die Branchpipeline hat nur zwei Stufen. Die erste Stufe kann dispatchen, decodieren, auswerten
und wenn notwendig die Sprungadresse eines Verzweigungsbefehls in einem Zyklus voraussagen.
Im folgenden Zyklus kann der resultierende Fetch auf die Anweisungen im Cache zugreifen. Dieses
erlaubt dem Prozessor, auf Sprunganweisungen schnell zu reagieren, und so die Latenzzeit für
weitere Anweisungen zu vermindern.
Die Floating - Point–instruction–Pipeline enthält sechs Stufen und ist für Pipelining von single–
precision–Operationen optimiert worden. Obwohl die Hardware alle double–precision–Operationen
unterstützt und die meisten von ihnen in Pipelining ausgeführt werden, müssen jene welche
Multiplikationen beinhalten doppelt durch die Stufen Execute1 und Execute2 der Pipeline geführt
werden.
8
Quelle: Advance Information PowerPC 604 RISC Microprocessor Technical Summary (IBM / Motorola)
•
•
•
•
•
•
•
•
•
•
•
•
•
•
•
1994 kommt der PowerPC 604 (G2) raus:
Superskalare Architektur mit sechs Pipelines
Aus der Fixed-Point Unit des PPC601 werden Drei Integer Units, nämlich
o Zwei Single-Cycle Integer Units (SCIUs)
o Eine Multiple-Cycle Integer Unit (MCIU)
Floating-Point Unit (FPU)
Branch Processing Unit (BPU)
Load / Store Unit (LSU)
Rename Buffers, 12 GPR Rename Buffers und 8 FPR Rename Buffers
Aus der MMU des PPC601 werden zwei, nämlich
o Data MMU
o Instruction MMU
Die Branch Processing Unit bietet jetzt eine dynamische Sprungvorhersage und die
spekulative Ausführung von zwei Sprüngen.
512-entry branch history table mit jeweils Zwei-Bit Predictor
64-entry Branch Target Address Cache mit 32-bit Adressen (logisch)
Integer von 8, 16 und 32 bit (single- und doubleprecision)
Floating-Point Daten von 32 und 64 bit (singleprecision)
In 0,25 micron CMOS–Technologie hergestellt
Bis zu 350 MHz getaktet
Abbildung 7 Beispielspezifikation
9
Der Mikroprozessor PPC 604 besteht aus den folgenden Units:
•
•
•
•
•
•
•
•
•
•
Instruction Unit
o Fetch
o Branch–Processing Unit
o Instruction Queue (8 word)
o Dispatch - Unit
Memory - Management Units
o Instruction MMU
o Data MMU
Multi - Cycle Integer Unit
2 x Single–Cycle - Integer Unit
Floating - Point Unit
Register
o 32 General Purpose Registers (GPRs)–File (12 rename register)
o 32 Floating–Point Registers (FPRs) – File (8 rename register)
Condition Register (CR) – File (8 rename register)
Load / Store Unit
Completion Unit
Bus Interface Unit
Abbildung 8 Blockschaltbild PPC 604
Legende:
BTAC: Branch Target Adress Cache
SR: Segment Register
10
Der 604 Prozessor implementiert die PowerPC–Architektur, wie sie für 32 bit Adressen spezifiziert
ist. So werden 32 bit logische Adressen, Integer–Daten aus 8, 16 und 32 bit und Floating–Point–
Daten mit 32 und 64 bit (single und double precision) unterstützt. Für 64–bit–Anwendungen
unterstützt die Architektur auch 64 bit Integer–Daten und 64 bit Adressen.
Der PPC 604 ist ein Superskalarer Prozessor der in der Lage ist vier Instruktionen simultan
auszugeben. Im Idealfall können bis zu sechs Instruktionen parallel ausgeführt werden.
Die sechs parallelen Pipelines laufen über folgende Ausführungseinheiten:
• Floating–Point–Unit (FPU)
• Branch–Processing–Unit (BPU)
• Load / Store Unit (LSU)
• Drei Integer–Units (IUs):
o
Zwei Single–Cycle–Integer Units (SCIUs)
o
Ein Multiple–Cycle Integer Unit (MCIU)
Dieses parallele Design kombiniert mit der PowerPC–Spezifikation mit einheitlichen Instruktionen
erlaubt eine schnelle Ausführungszeit und erzeugt so einen hohen Durchsatz.
Der PPC 604 hat separate Memory–Management–Units (MMUs) und teilt den on–chip Cache in
Daten und Instruktionen. Er hat zwei 128 Einträge fassenden, Zwei–Wege - Associative–
Translation–Lookaside Buffer (TLBs) (jeweils 64 Einträge), einen für Instruktionen und einen für
Daten. Sowohl der Cache wie auch der TLB benutzen den Least–Recently–Used–Algorithmus.
Abbildung 9 Blockdiagramm der internen Datenpfade
Der 604 hat einen externen 72 bit Datenbus (64-bit Daten und 8-bit parity) und einen 36 bit
Adressbus (32-bit Daten und 4-bit parity). Das Interface–Protokoll erlaubt den Multimasterbetrieb.
Der Bus kann in Systemen mit verschiedenen Buszuteilungstaktiken eingesetzt werden.
11
1.4.1 Instruction Flow
Verschiedene Einheiten auf dem 604 garantieren den einwandfreien Fluß von Instruktionen und
Operanden.
•
Fetch–Unit: Benutzt die nächste sequenzielle Adresse oder die Adresse, die die BPU liefert,
wenn ein Sprung möglich oder sicher ist. Die Fetch–Unit liefert die Instruktionen in einen
Acht–Wort–Instruction–Buffer.
•
Decode / Dispatch Unit: Die Decode / Dispatch Unit dekodiert Instruktionen und verteilt sie
zu den entsprechenden Ausführungseinheiten. Während des Dispatchens werden die
Operanden von den Registern zur Ausführungseinheit geliefert.
•
Branch Processing Unit (BPU): Außer die Fetch–Unit mit vorausgesagten Sprungzielen zu
beliefern, wenn ein Sprung vorausgesagt wurde, führt die Unit alle Condition–Register–
Logical und Flow–Control–Instruction durch.
•
Instruction Completion Unit: Die Completion–Unit beendet ausgeführte Instruktionen in
der Programmreihenfolge und überwacht die Aktualisierung des Maschinenstatus.
12
Quelle: Advance Information PowerPC 750 RISC Microprocessor Technical Summary (IBM / Motorola)
•
•
1997 kommt der PowerPC 750 (G3) raus:
Superskalare Architektur mit sechs Pipelines nämlich:
o Zwei Integer-Units
o System–Register–Unit
Führt verschiedene Systemlevel Instruktionen aus sowie logische Registeroperationen.
Ausserdem move to/from aus Spezialregistern
• Floating-Point Unit (FPU)
• Store Queue
• Branch processing Unit (BPU)
• Level 2 Cache Bus Interface mit Controller
• Zwei-Wege Set-Assoziativer L2 Cache
• Externer Daten-SRAM
• Support für 256 KB, 512 KB und 1 MB L2 Cache
• bis 400MHz getaktet
Der Mikroprozessor PPC750 besteht aus den folgenden Units:
•
•
•
•
•
•
•
•
•
•
Instruction Unit
o Fetcher
o Branch–Processing Unit
o Instruction Queue (6 word)
o Dispatch - Unit
o Branch processing Unit 0
Memory - Management Units
o Instruction MMU
o Data MMU
Zwei Integer Units
o Integer Unit 1, kann alle Integer–Instruktionen ausführen
o Integer Unit 2, kann nur addieren und subtrahieren
System Register Unit
Register
o General Purpose Registers (GPRs)–File (12 rename buffers)
o Floating–Point Registers (FPRs) - File (8 rename buffers)
Load / Store Unit
Floating - Point Unit
Completion Unit
60x Bus Interface Unit für Level 1 cache interface
Neu ist die separate Businterface Unit mit Controller für den Level 2 cache
13
Die Möglichkeit, verschiedene Instruktionen parallel auszuführen ergibt eine hohe Effektivität und
einen hohen Durchsatz für die auf dem PPC 750 basierenden Systeme. Die meisten Integer–
Instruktionen können innerhalb eines Zyklus ausgeführt werden. Die FPU ist gepipelined, die
Tasks, die sie ausführt werden zerteilt in Subtasks. Implementiert wurde dies in drei aufeinander
folgenden Stufen. Normalerweise belegt eine Floating–Point–Instruktion immer nur eine der drei
Stufen. Diese wird nach dem Zyklus für die nächste Floating–Point–Instruktion frei. So können sich
gleichzeitig drei Single–Precision–Floating–Point–Instruktions in der FPU befinden. Double–
Precision–Additions–Instruktionen haben eine Latenzzeit von drei Zyklen und Double–Precision–
Multiplikationen (mit und ohne Addition) haben eine Latenzzeit von vier Zyklen.
Das Blockschaltbild zeigt die parallele Organisation der Ausführungseinheiten.
Der PPC 750 hat zwei voneinander unabhängige, on–chip, 32 KB, acht–Wege, setassoziativen und
physikalisch adressierbaren Caches, einen für Instruktionen und einen für Daten und außerdem
unabhängige Instruktions- und Daten- Memory–Management–Units (MMUs). Jede MMU kann 128
Einträge fassen, sie hat einen zwei–Wege, setassoziativen TLB (DTLB und ITLB), welcher die
Übersetzungen der letzten verwendeten Speicheradressen enthält.
Der L2 Cache ist mit einem Zwei–Wege, setassoziativen Tag–Memory und mit externem,
synchronem SRAM für die Datenhaltung ausgestattet. Der externe SRAM ist verbunden mit einem
geeigneten L2–Cache–Port verbunden der eine Bank mit bis zu 1 MB synchronem SRAM
unterstützt.
14
1.6 G4 anhand des MPC 7400
Quelle: Advance Information MPC 7400 RISC Microprocessor Hardware Specifications (Motorola)
1999 der PowerPC 7400 (G4) kommt heraus.
Superskalare Architektur mit acht Pipelines, nämlich:
• Zwei Integer-Units
• System Register Unit
• Floating-Point Unit (FPU)
• Branch processing Unit (BPU)
• Vector Unit
• Vector Permute Unit
• Vector ALU
o Vector Simple Integer Unit
o Vector Complex Integer Unit
o Vector Floating Point Unit
Abbildung 11 Blockschaltbild MPC 7400
Das eigentlich neue in dieser Generation von PowerPCs ist die nun unabhängigen Vektor–
Verarbeitung AltiVecTM sowie die Implementierung des Instruktionssatz. Hiermit soll eine bessere
Grafikfähigkeit erreicht werden.
Der PPC 7400 hat signifikante Verbesserungen der Memory–Subsystem (MSS) Bandbreite erfahren
und bietet optional ein MPX Buserweiterung zum 60x Prozessorinterface mit einer hohen
Bandbreite.
15
Die Floating–Point–Unit hat jetzt die gleiche Latenzzeit für Single- und Doubleprecision
Operationen einschließlich Multiplikationen.
Die Completion Queue wurde auf acht Slots erweitert.
Es gab jedoch keine signifikanten Änderungen an den skalaren Pipelines und das vierstufige
Pipelinemodel des PPC 750 ist unverändert übernommen worden.
1.7 Der G5
Quelle: Power Mac G5 Technology and Performance Overview (Apple)
Abbildung 12 Blockschaltbild G5
2003 kam die fünfte Generation des PowerPC heraus.Die superskalare Architektur ist hier auf 10
Pipelines angewachsen. Sowohl eine Floating–Point–Unit wie auch eine Load / Store
Ausführungseinheit kam hinzu.
16
2 Der PowerPC 970 Prozessor
Der PowerPC 970 wurde für Desktop-PCs und für kleinere Serversysteme entwickelt. Der Kern des
PowerPC 970 Prozessors basiert auf dem des Power4 Prozessors. Der Power4 Prozessor ist für den
high end Server-Markt entwickelt worden.
Der 970 Prozessor ist der bisher schnellste PowerPC-Prozessor. Der Chip ist als erster in einer
neuen Familie von High-End PowerPC-Prozessoren für Geschwindigkeiten bis 2.0 GHz entwickelt.
Er besitzt eine Single Instruction Multiple Data Einheit (SIMD, als „Velocity Engine" bei Apple
bezeichnet) und ist in der Lage, Daten in 64-Bit-Abschnitten zu verarbeiten und rechenintensive
Anwendungen wie Multimedia und Grafik zu beschleunigen.
Er besitzt eine 1 GHz-Kommunikationsverbindung (Bus) zur Beschleunigung des Datenaustausches
zwischen Prozessor und Hauptspeicher-Controller. Der Bus hat eine Spitzenbandbreite von 8 GB/s
(Gigabyte pro Sekunde) und kann somit hohe Datenmengen an den Prozessor liefern. Die
Bandbreite der 1 GHz-Kommunikationsverbindung zwischen Prozessor und HauptspeicherController ist groß genug, um z.B. die Daten von einem durchschnittlichen Spielfilm in weniger als
zwei Sekunden vom Hauptspeicher an den Prozessor zu befördern. Das Bussystem, auf das später
eingegangen wird, wurde exklusiv für Apple entwickelt.
Natürlich unterstützt der PowerPC 970–Prozessor nicht nur 64-bit-Computing für neue
Anwendungen, sondern auch traditionelle 32-bit-Anwendungen. Das Design unterstützt
symmetrisches Multi-Prozessing (SMP). Dies ermöglicht es, Systeme mit multiplen Prozessoren zu
bauen, die im Verbund und damit mit erheblich mehr Gesamtprozessorleistung arbeiten. Geplant ist
die Produktion des G5-Chip in IBMs neuer 300 mm-Wafer-Chip-Fabrik im Staat New York. Dabei
kommt eine ultradünne 0,13-Micro-Verdrahtung (fast 800x dünner als menschliches Haar) zum
Einsatz. Der Chip enthält fast eine Viertel-Meile (ca. 400 m) Kupfer-Verdrahtung und ca. 59
Millionen Transistoren auf Basis der IBM Silicon-on-Insulator-Technologie (SOI). Durch den
Einsatz der SOI-Technologie, bei der eine vergrabene Isolationsschicht unter der
Siliziumoberfläche die elektrischen Eigenschaften integrierter Schaltungen verbessert, siehe
Abbildung unten, verspricht sich IBM schnellere und sparsamere Chips.
Quelle: IBM
Die 'Silicon-On-Insulator'-Technologie vermindert Effekte, die durch interne parasitäre
Kapazitäten und Transistoren im Silizium entstehen, die die weitere Verkleinerung von integrierten
Schaltungen erschweren. Kleinere Strukturen machen Chips nicht nur schneller, weil Signalwege
verkürzt werden, sondern benötigen auch weniger Ansteuerspannung und damit weniger Leistung.
Mit der durch die SOI-Technologie geringeren kapazitiven Einflüsse ließen sich, laut IBM, SOIChips bei gleicher Leistungsaufnahme mit bis zu 35 Prozent höheren Frequenzen betreiben. Die
Verlustleistung würde damit um den Faktor 1,7 bis 3 gesenkt. Vor allem portable Geräte aller Art
können davon profitieren. SOI ist nichts wirklich Neues, zumal seit mehr als 30 Jahren an der
17
Herstellung einkristalliner SOI-Schaltungen geforscht wird. Bahnbrechend ist jedoch die
wirtschaftliche Herstellung der bislang nur für teure Spezialanwendungen genutzten Technologie.
IBM verspricht sich einen SOI-Vorsprung von ein bis zwei Jahren gegenüber anderen
Halbleiterherstellern.
Obwohl die Produktionskosten des PowerPC 970 niedriger als die des Power4 Prozessors sind und
er auch günstiger zu erwerben ist, übersteigt dessen Performance die des Power4 Prozessors in
vielen Gebieten. In punkto Zuverlässigkeit jedoch kann der PowerPC 970 Prozessor jedoch nicht
mit dem Power4 Prozessor konkurrieren. Der PowerPC 970 Prozessor ist, im Vergleich zum
Power4 Prozessor, für eine höhere Leistung auf Kosten der Zuverlässigkeit ausgelegt. Die höhere
Zuverlässigkeit beim Power4-Prozessor begründet sich unter anderem auf dem Einsatz der ECCSpeichertechnologie (Error Checking Correction). Auf diese Technologie, die zur Optimierung der
Zuverlässigkeit und Fehlerbehebung von L2- und L3-Cache-Speicher sowie des Hauptspeichers
eingesetzt wird, und die Vielzahl der anderen im Serverbereich eingesetzten Technologien, wird an
dieser Stelle jedoch nicht weiter eingegangen.
Der PowerPC 970-Prozessor entstammt der bewährten und weit unterstützten Architektur des
Power4 Prozessors und enthält dadurch einen für hohe Durchsätze geeigneten I/O-Prozessor, 512
Kilobyte L2-Cache und Verfügbarkeitsmerkmale wie Error Correction Code ECC (automatische
Korrektur von fehlerhaft übertragenen Bits), die aus der Serverwelt stammen.
Das folgend dargestellte Blockdiagramm zeigt den Vergleich zwischen PowerPC 970 Prozessor und
Power4 Prozessor in groben Zügen:
Quelle: arstechnica.com
Die farblichen Markierungen zeigen, welche Komponeten des PowerPC 970 Prozessors der
Architektur des Power4 Prozessors entstammen.
Hier wird deutlich, dass ein CPU Kern von dem Dual-CPU-Kern des Power4 Prozessors entfernt
wurde. Die Größe des L2-Cache ist auf 512 KB reduziert und wurde für die Verbindung zum
einzelnen Kern optimiert. Ebenfalls wurde eine SIMD Vektor AltiVec Einheit hinzugefügt.
2.1 Die AltiVec-Erweiterung
Die AltiVec-Einheit stellt, ähnlich wie Intels MMX-Erweiterung für die Pentium-Reihe, eine
Multimedia-Erweiterung speziell für den PowerPC dar. Dabei handelt es sich, wie bei MMX, um
eine Vektorrecheneinheit. Zusätzlich zu den typischen Anwendungen wie Grafik und Multimedia
ist AltiVec, im Gegensatz zu MMX, aber auch auf die Verarbeitung von IP-Telefonie-,
Spracherkennungs- und Netzwerk-Diensten ausgelegt. Das Haupteinsatzgebiet der PowerPCProzessoren liegt bei Multimediaanwendungen und kleineren (speziell Kommunikations-) Servern.
Deshalb ist auch die AltiVec-Erweiterung auf Bild-, Video- und Sprachverarbeitung ausgelegt. Wie
man im Vergleich der folgend dargestellten Prozessor-Dies des G3- und G4-Prozessors erkennen
kann, hat die AltiVec-Erweiterung im G4-Prozessor einen hohen Stellenwert.
18
G3-Die
Quelle: realworldtech.com
G4-Die
Wie in der Grafik des G4-Die zu erkennen ist, ist das gesamte obere Viertel des G4-Dies von der
Vektorrecheneinheit eingenommen. Da die Ausnutzung der Fläche des Dies einer der wesentlichen
Kostenfaktoren eines Prozessors ist, wird hier deutlich, dass Motorola der neuen
Vektorrecheneinheit eine sehr große Bedeutung zumisst.
Die AltiVec-Erweiterung führt maximal 16 Befehle „parallel“ aus, d.h. ein Vektor besteht aus
maximal 16 Elementen.
Die AltiVec-Einheit bildet, gleichwertig zu den anderen Einheiten, eine unabhängige
Ausführungseinheit. Sie besteht intern weiterhin aus wiederum 2 voneinander unabhängigen
Einheiten, einer Vektor-ALU und einer zweiten Einheit, die für Permutationen zuständig ist. Die
AltiVec Einheit verarbeitet 128 Bit-Vektoren und besitzt 32 eigene 128-Bit Register und einen
ebenso breiten Bus zum Hauptspeicher. Mit einem Load-Befehl wird ein kompletter Vektor in ein
Register geladen. Für den Einsatz der neuen Vektoreinheit stehen 162 neue Befehle zur Verfügung.
Dabei bezieht sich ein Befehl auf maximal 3 Quell- und ein Zielregister. Die AltiVec-Einheit bietet
neben den erwarteten algorithmischen Befehlen auch komplexere Befehle an, die häufig verwendete
Rechenschritte zu einem einzigen Befehl zusammenfassen. Das erkennt man an dem im Vergleich
zu „herkömmlichen“ Assemblerbefehlen zusätzlichen Quellregister (3 statt 2).
Die 128-Bit Register können in 16x8-Bit-, 8x16-Bit- oder 4x32-Bit-Elemente aufgeteilt werden. So
kann man z.B. acht 16 Bit Integer zu acht weiteren 16 Bit Integer addieren um acht 16 Bit
Ergebnisse zu erhalten, was durch eine einzige „vector add“ Instruktion passiert. Die AltiVec
Einheit unterstützt 8 Bit, 16 Bit und 32 Bit Integer Operationen genauso wie 32 Bit floating point
Operationen. Die folgende Grafik zeigt die Möglichkeiten zur Unterteilung der Elemente.
19
Quelle:realworldtech.com
Die AltiVec Einheit stellt also eine SIMD Vektor Einheit dar, weil sie auf mehreren Elementen in
einem Vektorregister mit nur einer SIMD-Instruktion arbeitet.
Beispielweise seien die beiden arrays A und B gegeben:
A
1
2
3
4
5
6
7
8
B
80
70
60
50
40
30
20
10
Wenn diese beiden Register nun addiert werden sollen, werden sie beide jeweils in ein Vektor
Register geladen und eine SIMD Vektor Instruktion liefert dann das Ergebnis:
81
72
63
54
45
36
27
18
Der folgend dargestellte und aus dem Handbuch des PowerPC 970 Prozessor entnommene VektorBefehl zeigt die Addition von zwei 4x32-Bit Vektoren.
20
Quelle: IBM
Für AltiVec-Befehle gibt es die Befehlsformate VA-Form, VX-Form, VXR-Form und X-Form, die
auf den folgenden Seiten, anhand von Ausschnitten aus der Spezifikation der Befehle, dargestellt
werden. Die Bits 21-31 stellen bei dem hier am Beispiel des Befehls vaddfp dargestellten VX21
Format, das erweiterte Opcode Feld dar (Extended Opcode Field). VSCRN ist das Vector-Statusund-Control-Register. Es besitzt zwei definierte Bits, das AltiVec non-Java-Mode(NJ)-Bit
(VSCR[15]) und das AltiVec-Saturation-(SAT)-Bit (VSCR[31]). Das Non-Java-Mode-Control-Bit
bestimmt, ob AltiVec Floating-Point Operationen im Java-IEEE-C9X-fähigen-Mode ausgeführt
werden oder möglicherweise in einem schnelleren non-Java/non-IEEE-Mode ausgeführt werden.
Ist das Non-Java-Mode-Control-Bit auf 0 gesetzt, so ist der Java-IEEE-C9X-fähigen-Mode gewählt.
Ist es auf 1 gesetzt, so ist der non-Java/non-IEEE-fähigen-Mode gewählt. Dieser Mode ist unter
Umständen dann sinnvoll, wenn Real-Time-Performance wichtiger ist, als sich streng an den Java
und IEEE-Standard zu halten. Das AltiVec-Saturation-Bit wird für Saturation(Überlauf)-Detection
benutzt. Saturation tritt dann auf, wenn das Ergebnis einer Saturation-Operation nicht in das
Ergebnisfeld passt.
Quelle: IBM
22
Quelle: IBM
23
Quelle: IBM
24
Quelle: IBM
Die Altivec SIMD Einheit wurde von IBM und Motorola gemeinsam entwickelt. Motorola hat aber
die Rechte für den Namen „Altivec“. Deshalb taucht diese Bezeichnung nicht im Blockdiagramm
mit auf.
25
Die AltiVec Vektor Einheit bearbeitet also gleichzeitig 128-Bit Operanden. Sie besteht aus der:
-
Vector Permute Unit (VPU) für Operationen wie pack, unpack, merge. Um z.B. ein Register
mit den Bytes von 2 anderen Registern zu füllen.
Vector Arithmetic Logic Unit (VALU)
o Vector Simple Integer Unit (VSIU) für Vektorinstruktionen mit kurzer Latenz wie
Addition, Subtraktion, Vergleichs- und Bit-Schiebebefehle.
o Vector Complex Integer Unit (VCIU) für Instruktionen mit langer Latenz wie
Befehle, die eine Multiplikation enthalten oder Summen über die Elemente eines
einzelnen Vektors bilden.
o Vector Floating-Point Unit (VFPU) zur Bearbeitung von Fliesskommabefehlen.
Die Permutationseinheit wird eingesetzt, um die Elemente innerhalb der Vektoren anzuordnen.
Wurde etwa in einem Vektor, der 16 Elemente enthält, für je vier benachbarte Elemente das
Minimum bestimmt, so entsteht ein Ergebnisvektor, der nur an vier Positionen brauchbare Daten
enthält (die vier Minima), die restlichen 4x3 Felder sind leer. Wurde diese Operation auf 4
Vektoren ausgeführt, so lassen sich die 4x4 Ergebnisse zu einem neuen Vektor zusammenfügen, um
damit weiterzurechnen.
Beispiele für den Einsatz der AltiVec-Erweiterung
Als erstes Beispiel sei an dieser Stelle die Berechnung des Skalarproduktes von 16-elementigen
Vektoren angeführt. Dabei werden die Vektoren komponentenweise miteinander multipliziert, die
Produkte werden aufsummiert. In die Summe kann zusätzlich der Ergebnisvektor einer
vorhergehenden Berechnung mit einfließen. Der gesamte Vorgang umfasst mit dem G3-PowerPCProzessor ohne AltiVec-Erweiterung 36 Befehle, die sich nun auf nur 2 AltiVec-Befehle reduzieren.
Ein weiteres Beispiel ist die Einsparung ganzer Kontrollflusssequenzen. Die Sequenz
for (i=0; i<16; i++) {
if(a[i]==b[i])
r[i]=x[i];
else
r[i]=y[i];
}
//16 8-Bit-Elemente
//Vergleich der Elemente zweier Vektoren
//x: erste Quelle
//y: alternative Quelle
//r: Ergebnis
lässt sich z.B. durch zwei Vektor-Befehle ausdrücken. Dabei werden zuerst die beiden Vektoren a
und b miteinander verglichen und eine Ergebnismaske berechnet, die an der Stelle i eine 0 enthält,
wenn die beiden Elemente a[i] und b[i] unterschiedlich waren, sonst den Wert FF. Dann wird mit
dem vsel-Befehl (Vektor select), siehe Abbildung unten, der Ergebnisvektor abhängig von der
berechneten Maske aus den beiden Quellvektoren x und y zusammengestellt (Permutationseinheit).
Dadurch wird eine vorher 48 Befehle lange Sequenz auf 2 Vektor-Befehle reduziert.
26
Quelle: IBM
Pro Taktzyklus können zwei neue AltiVec Operationen gestartet werden.
Im Vergleich zur Altivec Implementation des PowerPC G4, besitzt die des 970 Prozessors eine
zusätzliche „Vector Issue Queues Einheit.
27
Der PowerPC 970 Prozessor kann 4 Vektor Operationen per Zyklus zu den zwei Vector Issue
Queues weiterleiten, der G4 nur 3. Die linke VPU Vector Issue Queue kann 16, die rechte VALU
Queue kann 20 Einträge beinhalten. Von diesen 2 Queues kann dann pro Zyklus
jeweils eine beliebige Vektor Operation an die angebundene(n) Einheit(en) weitergeben werden.
Wie man auch in der Abbildung erkennen kann, können der G4e und der 970 Prozessor pro Zyklus
die selbe Anzahl an Vektor Operationen an ihre angebundenen Altivec Einheiten liefern. Der 970
Prozessor ist in der Kombination der Operationen eingeschränkt, weil einer der 2 Ops eine „vector
permute“ sein muss. Ein direkter Vorteil ist aus der umstrukturierten AltiVec Einheit nicht zu
erkennen. Sie ist lediglich an den Prozessor-Kern des Power4-Prozessors und damit an den des
PowerPC 970 angepasst worden.
2.2 Die Architektur des 970 Prozessors
Die Architektur des PowerPC 970-Prozessors lässt sich mit der folgenden Grafik darstellen:
28
Wegen der Tiefe der Pipeline und der Breite des Ausführungskerns spendierten die Designer einen
beträchtlichen Block der Chip-Ressourcen der Sprungvorhersage. Damit die Pipeline ständig gefüllt
ist und der großflächige Ausführungsbereich ständig benutzt wird, ist eine genaue
Sprungvorhersage essentiell.
Der PowerPC 970 hat mehr Ressourcen für die Sprungvorhersage als der P4 und sein Vorgänger,
der G4e, zusammen. Er hat, für jeden Sprung, auf den er stößt, für die Sprungvorhersage zwei
unterschiedliche Konzepte zur Verfügung. Für jeden Sprung wird dann das am besten geeignete
Konzept der Sprungvorhersage ausgewählt.
2.2.1 Front End
29
Im Front End Bereich werden 8 Instruktionen pro Zyklus aus dem L1-Cache in die Instruction
Queue geholt. Die Branch Prediction Unit durchsucht dabei die im fetch-Vorgang geholten acht
Instruktionen nach branches, um Sprungvorhersagen zu treffen. Dabei können maximal zwei
braches ermittelt werden. Ist eine der zwei branches ein bedingter Sprung, dann liefert die branch
prediction unit eine Vorhersage des bedingten Ergebnisses (taken or not taken) und/ oder die ZielAdresse durch die Nutzung eines der beiden branch prediction-Konzepte.
2.2.1.1Branch prediction Konzepte
Das erste branch predicition Konzept, das vom PowerPC 970 verwendet wird, ist das Standard
Konzept, das auf der branch history-Tabelle basiert und beim P4 und G4 zum Einsatz kommt. Beim
Power4 und 970 Prozessor wird hier hingegen von „local predictor“ gesprochen. Dieses Konzept
arbeitet mit 16K Einträgen, viermal so viele Einträge wie z.B. beim P4. Für jeden dieser 16K
Einträge gibt es ein 1-bit Flag das aussagt, ob der Sprung gemacht werden soll oder nicht.
Das zweite Konzept beinhaltet eine weitere Tabelle mit 16K Einträgen, die global predictor –
Tabelle. Jeder Eintrag in dieser Tabelle ist assoziiert mit einem 11-bit Vektor (global history
vector), der den aktuellen Ausführungsverlauf der letzten 11 fetch-Gruppen (a 8 Instruktionen)
aufnimmt. Jedes Bit in dem global history vector bestimmt, ob die nächste fetch-Gruppe aus dem
sequentiell folgenden Cache-Sektor geholt wird oder nicht. Im Fall eines notwendigen
nichtsequentiellen Holens von fetch-Gruppen aus dem Cache, wird der global history vector
korrigiert. Der global history vector ist, unter Verwendung eines Bit-weisen Exklusiv-Oder oder
der Adresse der branch-Instruktion, gehashed. Das Ergebnis indiziert die global predictor table, um
dort das 1-bit Flag für die Vorhersage zu setzen.
Schließlich gibt es noch eine dritte Tabelle mit 16K Einträgen, die in den Front-End Block
involviert ist und entscheidet, welches von den zwei branch prediction-Konzepten am besten für
jeden einzelnen Sprung geeignet ist. Dabei vergleicht der Prozessor die Erfolgsaussichten der
beiden branch prediction-Konzepte und hält dann in der dritten Tabelle, namens selector table fest,
welches Konzept am besten für den jeweiligen Sprung geeignet ist. Die selector table ist genauso
indiziert, wie die global predictor table. Die genaue Funktionsweise der selector table wird von
IBM leider nicht preisgegeben. Dieses branch-prediction-Konzept wurde vom Power4 Prozessor
übernommen.
2.2.1.2Decode, cracking und group formation
Der IBM PowerPC 970 holt sich acht Instruktionen pro Zyklus aus dem L1-Cache in die Instruction
Queue . Von dort aus werden pro Zyklus acht Instruktionen zur Dekodierung geholt. Sein
Vorgänger, der G4e, konnte nur vier Instruktionen pro Zyklus holen und dekodieren. Im Vergleich
zum PowerPC 970 Prozessor holt der P4 nur eine x86 Instruktion pro Zyklus. Der P4 besitzt aber
auch den Trace Cache, siehe Abbildung auf der nächsten Seite. Der Trace-Cache speichert
Sequenzen von Micro-Operationen aus dem dynamischen Instruktionsstrom. Um Sprünge zu
optimieren, besitzt er eine unabhängige Sprungvorhersageeinheit auf Mikro-Operation Basis.
Komplexe x86-Instruktionen bestehen oft aus vielen Mikro-Operationen. Deshalb speichert der
Trace-Cache nur die jeweils erste Mikro-Operation solcher Instruktionen ab.
30
Trace-Cache beim Pentium 4
Quelle: Intel.com
Die fetch und decode Phasen des P4 und des PowerPC 970 sind aber in einem wichtigen Punkt
gleich. Beide Prozessoren brechen die im ISA Format (Instruction Set Architecture) vorhandenen
Instruktionen in ein kleineres Format, das im Inneren der CPU verarbeitet wird, herunter. Der P4
bricht jede x86 CISC Instruktion in kleinere Mikro-Operationen herunter, wobei die meisten dieser
Instruktionen in 2 oder 3 Mikro-Operationen heruntergebrochen werden. Komplexere oder selten
benutzte Instruktionen werden in viele Mikro-Operationen heruntergebrochen.
Der PowerPC 970 bricht die Instruktionen in sogenannte „IOPs“, „internal operations“, herunter.
Wie die Mikro-Operationen des P4 werden auch die IOPs des PowerPC 970 Prozessors in
beliebiger Reihenfolge von der Ausführungseinheit (Execution Core) ausgeführt.
Bis auf wenige Ausnahmen werden fast alle ISA Instruktionen des PowerPC genau in eine IOP
übersetzt. Für die Instruktionen, die in mehr als eine IOP übersetzt werden, unterscheidet IBM
zwischen
-
Einer „cracked instruction“, eine Instruktion, die in genau zwei IOP aufgeteilt wird.
Einer „millicoded instruction“, eine Instruktion, die in mehr als zwei IOPs aufgeteilt wird.
Beispiele für das Herunterbrechen in „IOPS“ werden von IBM nicht angegeben, so das dieser
Vorgang spekulativ ist.
Diese Art, in der Instruktionen klassifiziert werden, ist nicht willkürlich gewählt. Vielmehr ist dies
in einer sehr wichtigen Entscheidung über das Design festgelegt worden, die ursprünglich von den
Designern des Power4 Prozessors gemacht wurde in Bezug darauf, wie der Chip mit Instruktionen
in verschiedenen Ausführungsphasen umgeht. Dies soll anhand der folgenden Teil-Grafik und den
folgenden Erläuterungen erklärt werden:
31
Bei Betrachtung dieser Grafik der Gesamtarchitektur (Die Architektur des 970 Prozessors) wird
deutlich, dass nach der „decode, cracking and group formation“ Phase im Front End fünf Kästen
folgen. Diese fünf Kästen werden von IBM als „group“ bezeichnet. Jede Gruppe oder „group“
besteht aus fünf IOPs, wie in der Programmreihenfolge durch feststehende Regeln und
Beschränkungen festgelegt ist. Es sind eben diese organisierten Gruppen von fünf IOPs und nicht
einzelne IOPs, die der PowerPC 970 in dieser Reihenfolge an die 6 „Issue Queues“ und damit an
die Ausführungseinheit (Execution Core) schickt. Haben die IOPs, die sich ja in einer Gruppe
befinden, ihre zugehörige „Issue Queue“ erreicht, können sie in beliebiger Reihenfolge den
Ausführungseinheiten zugeteilt werden, wobei 8 IOPs pro Zyklus für alle Queues insgesamt
zugeteilt werden können. Bevor sie aber die Abschlussphase (completion stage“) erreichen, müssen
sie zurück in ihre Gruppenformation gebracht werden, so dass eine gesamte Gruppe von 5 IOPs in
einem Zyklus abgearbeitet werden kann.
Der PowerPC 970 bringt also immer Gruppen von IOPs zur Ausführung. So werden, anstelle von
z.B. 100 einzelnen IOPs nacheinander, 20 Gruppen à 5 IOPs ausgeführt. Durch diese
Gruppenbildung wird der Overhead in bezug auf Zuteilung und Umordnen des sehr großen
Volumens an Instruktionen reduziert, indem man das „tiefe und breite“ Design des PowerPC 970
Prozessors ausnutzt. Der Preis für die so erreichte Reduzierung des Overheads ist ein Verlust an
Effizienz bei der Ausführung, verursacht durch die eingeschränkte Möglichkeit individuelle
Instruktionen einplanen und zuteilen zu können, was im folgenden erklärt werden soll. Wenn die
Front End Einheit des PowerPC 970 eine IOP-Gruppe zusammenbaut, gibt es festgelegte Regeln,
die befolgt werden müssen. Die erste Regel besagt, dass die fünf in der IOP-Gruppe verfügbaren
Plätze durch IOPs in Programmreihenfolge belegt werden müssen, angefangen mit der ältesten IOP
an der ersten Stelle (Platz 0), bis hin zur neusten IOP an der 5ten Stelle (Platz 4). Eine weitere
Regel besagt, dass alle branch Instruktionen an die 5te Stelle (Platz 4) kommen und somit der letzte
Platz in der Gruppe für eine branch Instruktion reserviert ist. Wenn aber nun vom Front End keine
branch Instruktion gefunden werden konnte, die an die letzte Stelle in der IOP-Gruppe gehört, dann
können eben nur 4 Instruktionen in diesem Zyklus weitergegeben werden. Es gibt weitere
Situationen, in denen die Front End Einheit für bestimmte IOPs vorgesehene Plätze mit noops
belegen muss, um die Belegung des letzten Platzes in der IOP-Gruppe mit einer branch Instruktion
zu erzwingen. Anders ausgedrückt muss also die Front End Einheit manchmal IOP-Plätze in der
Gruppe und damit im Instruktionsfluss unbelegt lassen, um die schon beschriebenen Regeln, die für
jede Gruppe gelten, zu erfüllen. Dabei sind die oben genannten Regeln nicht die einzigen, die bei
der Bildung von IOP-Gruppen eingehalten werden müssen. Eine weitere Regel schreibt z.B. vor,
dass Instruktionen, die für die conditional register unit (CRU) bestimmt sind, nur an die erste und
zweite Stelle (Platz 0/1) der IOP-Gruppe kommen dürfen. Zusätzlich gibt es noch die Regel für die
oben erwähnten „cracked and millicoded“ Instruktionen, die vorschreiben, dass bei „cracked“
Instruktionen, also Instruktionen, die in genau zwei IOP aufgeteilt sind, die beiden IOPs derselben
Gruppe zugeteilt sein müssen. Wenn sie nicht in dieselbe Gruppe passen, wird die Gruppe
verworfen und es wird eine neue Gruppe aufgebaut. Instruktionen, die auf „cracked“ Instruktionen
32
folgen, können nur dann derselben Gruppe zugeteilt werden, wenn genügend Platz vorhanden ist.
„Millicoded“ Instruktionen bilden hingegen immer eine neue Gruppe. Die Instruktionen, die auf
„millicoded“ Instruktionen folgen, bilden erneut eine neue Gruppe.
Weiterhin muss eine Gruppe die folgend aufgelisteten Ressourcen zur Verfügung haben, bevor sie
zur Ausführungseinheit (Execution Core) weitergebenen werden kann:
-
-
-
Group Completion Table entry: Der GCT ist das PowerPC 970 Äquivalent eines
Umordnungs- Puffers. Der GCT hat 20 Einträge. Mit diesen Einträgen kann er sich 20
aktive Gruppe merken, während sich die einzelnen Instruktionen der Gruppen in ihren ca.
100 Ausführungsstadien in der Pipeline befinden. Sind die 20 Einträge im GCT voll, kann
keine neue Gruppe zum GCT hinzugefügt werden, egal wie viele Instruktionen (durch
unvollständig Gruppen) zu einem gewissen Zeitpunkt in der Ausführungsphase sind.
Issue Queue slot: Wenn nicht genügend Plätze (slots) in den zugeteilten Issue Queues
vorhanden sind (VPU Vector Issue Queue kann 16, die VALU Queue kann 20 Einträge
beinhalten), um alle Instruktionen einer Gruppe unterzubringen, dann muss die Gruppe auf
ihre Abwicklung warten.
Rename Registers: Es müssen genug Ressourcen für Register-Umbenennung vorhanden
sein, so dass Instruktionen, die Register Umbenennung benötigen, diese zur Verfügung
haben, wenn sie ihrer Issue Queue zugeteilt werden.
Zusammengefasst ist es damit möglich, dass eine einzelne Instruktion, die eine der Regeln nicht
erfüllt, die ganze Gruppe in ihrer Ausführung behindert.
Wegen eben dieser Benutzung von Gruppen ist die PowerPC 970 InstruktionsAbfertigungsbandbreite aufgrund vieler komplexer Faktoren sehr empfindlich, nicht zuletzt wegen
einer Art internen Fragmentierung des GCT (Group Completion Table), die das Aufkommen einer
unnötigen Drosselung der Ausführungsbandbreite zur Folge hat, wenn zu viele Gruppen im GCT
nicht vollständig bestückt sind oder fast leer sind.
Theoretisch ist der PowerPC 970 Prozessor in der Lage, 200 Instruktionen in den verschiedenen
Stufen fetch, decode, execution und completion pro Zyklus unterzubringen. In Wirklichkeit ist es
jedoch wahrscheinlicher, dass unter gegebenen Umständen eine nicht geringe Anzahl an
Ausführungssegmenten wegen unvollständiger Gruppenbildung aufgrund von Einschränkungen
durch die erwähnten Regeln leer verbleiben.
Im Vergleich zu multi-length-Instruktionen bei modernen CISC-Architekturen, ist der Aufwand
zum Herunterbrechen der Instruktionen in einfache interne Instruktionen beim PowerPC 970
Prozessor wesentlich geringer. Bei verschieden langen Instruktionen stellt sich das Problem, wie die
CPU wissen soll, wo sich die nächste Instruktion befindet. Diese kann herausgefunden werden,
indem man die erste Instruktion dekodiert, was Zeit kostet und ein Performance-Bottleneck
darstellt. RISC CPUs hingegen besitzen keine multi-length –Instruktionen, wodurch sich das
Dekodieren bedeutend einfacher gestaltet.
Die x86 CPU besitzt 8 Register, deutlich weniger als der PowerPC 907 Prozessor. Die Vorstellung
einer Schleife mit 10 Variablen in Iteration setzt bei einer x86 CPU Hardware-Hilfestellung voraus.
Diese Hilfestellung ist die eingesetzte Out-Of-Order-Execution, wobei rename-Register zum
Einsatz kommen. Out-Of-Order-Execution wird hauptsächlich dazu benutzt, um die Performance zu
erhöhen, indem die CPU verschiedene Instruktionen gleichzeitig ausführt. Sowohl die x86 CPU als
auch die PowerPC 970 CPU setzt dieses Verfahren ein. Bei der x86 CPU mit den 8 Registern wird
dies problematisch, da der voraus folgende Programmfluss untersucht werden muss, um
Instruktionen zu finden, die außerhalb der Programmreihenfolge ausgeführt werden können. Das
bedeutet für die x86 CPU, dass die 8 Register sehr oft umbenannt werden müssen, was eine
komplexe Logik erfordert. Die RISC-Architektur des PowerPC 970 hat hier einen erneuten Vorteil,
da mehr Register zur Verfügung stehen, was die Umbenennungs-Logik reduziert und damit den
Hardwareaufwand.
RISC CPUs, wie der PowerPC 970 Prozessor, haben gegenüber CISC CPUs den weiteren Vorteil,
33
dass sie hohe Performance bei deutlich niedrigerem Energieverbrauch liefern. Der PowerPC 970
Prozessor bietet ebenfalls Multi-Threading, was die Performance verdoppelt. Intel´s HyperThreading hingegen steigert die Performance nur um 20%.
Als Apple die ersten benchmarks des neuen PowerPC 970 veröffentlichte, führt dies zu
Streitigkeiten. Die Werte, die Apple für einen Dell PC im Vergleich zum PowerPC 970 angab,
waren erheblich schlechter, als die, die auf der Website von SPEC präsentiert wurden. Apple wurde
dafür stark kritisiert. Der Grund für die unterschiedlichen Werte lag aber in der Verwendung von
unterschiedlichen Compilern. Die Verwendung des GCC Compilers z.B. erzeugt fehlerhaften Code
für einige PowerPC-Anwendungen.
Quelle: c`t-Magazin
2.2.2 PowerPC 970 Execution Core
Der PowerPC 970 beinhaltet insgesamt 12 Ausführungseinheiten. Zwei von diesen Einheiten sind
34
sogenannte Integer Units, kurz IUs, die nahezu alle Integer Instruktionen ausführen. Der PowerPC
970 unterscheidet sich somit von Prozessoren wie dem G4e oder P4, die Integer Operationen in die
zwei Typen „simple“ und „complex“ einteilen. Diese beiden IUs sind verbunden mit 80
Mehrzweckregistern (GPRs, General Purpose Registers), davon 32 feste und 48 rename-Register.
Diese beiden Integer Units sind aber nicht symmetrisch. Laut der Dokumentation des Power4
Prozessors führt die erste Integer-Unit alle Integer-Instruktionen aus, während die zweite alle
Integer-Instruktionen bis auf Multiplikation und Division ausführt und auch für Operationen mit
den special-purpose-Registern vorgesehen ist. Alle anderen Integer-Instruktionen können
wahlweise die erste oder zweite Einheit nutzen. Integer-Division und special-purpose-registerInstruktionen sind relativ selten, so dass die Performance durch diese Separierung nicht
nennenswert zunimmt. Da der 970 Prozessor aber mit Instruktionsgruppen arbeitet, scheint dieser
geringfügige Grad an Spezialisierung schon sinnvoll. Während IBM aber bis jetzt noch keine
Angaben zu Latenzzeiten der Instruktionen gemacht hat, zeigen die beim Power4 Prozessor
veröffentlichten Angaben, dass der größte Teil der Integer Instruktionen in einem Zyklus ausgeführt
wird, während einige wenige komplexere Integer Instruktionen mehrere Zyklen benötigen. Von
anderen Instruktionen unabhängige Integer-Instruktionen brauchen also nur einen Zyklus, während
von anderen Instruktionen abhängige Integer-Instruktionen dann mit einem Wartezyklus insgesamt
2 Zyklen brauchen. Durch die zwei separaten Integer Einheiten kann dann in einer dieser Einheiten
die abhängige Integer- Instruktion gehalten werden, während in der anderen die Instruktion
ausgeführt werden kann, von der die andere abhängt.
2.2.2.1Rename Register
Der PowerPC 970 hat viel mehr rename-Register als z.B. der G4e. Das Instruktionsfenster (bis zu
200 Instruktionen in den verschiedenen Stufen fetch, decode, execution und completion) ist
ebenfalls bedeutsam größer als das vom G4e(bis zu 16 Instruktionen). Natürlich braucht dann der
PowerPC 970 auch viel mehr rename-Register, um alle nützlichen Möglichkeiten wie z.B. loop
unrolling für ein so großes Instruktionsfenster zu ermöglichen. Je mehr Instruktionen sich in den
unterschiedlichen Phasen der Ausführung befinden, desto mehr Daten müssen in Registern
gespeichert werden.
2.2.2.2Die CR Logical Unit
35
Beim PowerPC 970 Prozessor gibt es eine Extrabehandlung für logische Operationen, die
normalerweise von einer Integer Einheit gehandhabt werden. Für diesen Fall hat der 970 Prozessor
eine separate Ausführungseinheit, die CR Unit. Diese Einheit ist für die Handhabung von logischen
Operationen in bezug auf das condition-register zuständig. Das condition register ist ein Teil der
ISA (instruction set architecture) des PowerPC 970, das dieselbe Funktion wie das x86er Prozessor
Status Wort (PSW) hat und diese in einer flexiblen und programmiererfreundlichen Art kontrolliert.
Fast alle arithmetischen Operationen haben nach ihrer Ausführung die Möglichkeit, verschiedene
Flags in dem 32-bit PowerPC 970 condition- register zu setzten. Mit einer Ansammlung von
Instruktionen zur Manipulation von Flags, kann der Programmierer diese durch logische
Operationen wie AND, OR, NOT... manipulieren, was dann von der CR-Unit ausgeführt wird.
2.2.2.3Load-Store Units
Der PowerPC 970 Prozessor hat zwei identische Load-Store Einheiten die, wie hier aufgrund
fehlender Informationen angenommen werden muss, alle LOADs und STOREs für den gesamten
Chip ausführen. Das gibt dem PowerPC 970 Prozessor buchstäblich zweimal soviel load-store
Hardware wie dem G4e. Bei der Größe des Ausführungsfensters des PowerPC 970 scheinen zwei
dieser Einheiten auch nötig zu sein, um alle Instruktionen im Ausführungsfenster mit Daten zu
versorgen.
Die großen Unbekannten sind hier die LOADs und STOREs für Vektor Operationen. Der Power4
Prozessor hat keine Vektor-Ausführungseinheit, was es unmöglich macht, mit irgendeiner
Gewissheit eine Aussage zu machen, wie der PowerPC 970 Prozessor mit Vektor-SpeicherOperationen umgeht. Es könnte vermutet werden, dass Vektor LOADs in der einen Load-StoreEinheit und Vektor STOREs in der anderen gehandhabt werden. Es wäre aber auch möglich, dass
der PowerPC 970 nach dem Modell des P4 vorgeht und nur die Vektor LOADs in den Load-StoreEinheiten handhabt und die Vektor STOREs einer der Vektor-Ausführungspipelines überlässt.
2.2.2.4Floating Point Units
Die Floating-Point-Implementation des PowerPC 970 Prozessors ist beinahe exakt dieselbe wie
beim G4e. Der PowerPC 970 hat aber zweimal soviel Hardware für diese Einheit wie der G4e. Hier
gibt es, wie bei den Load-Store-Einheiten vermutet, zwei identische Floating Point Units (FPUs),
von denen jede die schnellste Floating-Point Instruktion innerhalb von 6 Zyklen ausführen kann.
Wie beim G4e brauchen Operationen mit Einfachgenauigkeit oder Doppelgenauigkeit für die
Ausführung dieselbe Zeit. Die beiden Floating-Point Einheiten sind für alle Operationen außer
Floating-Point Divisionen voll gepipelined. Floating-Point Die schnellsten Floating-PointInstruktionen, wie z.B. FMADD (siehe folgende Abbildung), brauchen 6 Zyklen.
Quelle: IBM
Der PowerPC 970 hat ebenfalls im Vergleich zum G4e Prozessor eine größere Anzahl an FloatingPoint Registern. Insgesamt gibt es davon 80, wovon 32 feste und 48 rename Register sind.
Durch die doppelte Anzahl der Floating-Point-Einheiten im Vergleich zum G4e ist anzunehmen,
dass hier gegenüber dem G4e zwar nicht eine doppelt so große Perfomance besteht, jedoch eine
Performancesteigerung zu erwarten ist. Dies ist besonders der Fall, wenn man die tiefere Pipeline
und den Vorteil der Taktrate in die Betrachtung mit einbezieht.
36
Weiterhin gibt der schnelle Frontsidebus des PowerPC (getaktet mit der halben Core Clock Speed)
und der hohen Bandbreite des Speichers (Dual-Channel DDR400, 2x32-bit Kanäle) dem PowerPC
970 einen erheblichen Vorteil gegenüber dem G4e in Sachen Floating-Point Code.
2.3 Die Pipeline
Die bis zu 16 Stufen tiefe Pipeline ist die größte Stärke des PowerPC 970 Prozessors und
gleichzeitig seine wohl größte Schwäche. Um eine so lange Pipeline gefüllt zu halten, sind
massive Ressourcen zur Sprungvorhersage notwendig. Das Instruktionsfenster muss aber so groß
gestaltet sein, damit durch ungenutzte Lücken in der Pipeline („pipeline bubbles“ bei
unvollständigen Instruktionsgruppen) keine Nachteile in Sachen Performance entstehen.
Der P4 Prozessor kann, im Vergleich zum PowerPC 970 Prozessor, weniger pipeline bubbles
tolerieren, weil es dort auch nicht so viele Ausführungs-Slots gibt.
Betrachtet man die in der Präsentation von Pete Sandon (http://www3.ibm.com/chips/techlib/techlib.nsf/techdocs/A1387A29AC1C2AE087256C5200611780/$file/PPC
970_MPF2002.pdf) bei der Vorstellung des neuen PowerPC 970 Prozessors verwendete Grafik der
Pipeline, werden im Vergleich zum Power4 Prozessor einige Fragen aufgeworfen und einige
Pipeline-Stufen wirken etwas mysteriös. Die in der folgend dargestellten Grafik rot markierten
Stufen sind entweder spekulativ oder unbekannt. Die Beschriftungen in den einzelnen Kästchen
sind in der ursprünglichen Grafik nicht vorhanden.
Zuerst fällt auf, dass schon in der fetch-Pipeline eine unbekannte Stufe existiert. Man könnte
37
vermuten, dass es sich um die Sprungvorhersage Stufe handeln könnte. Es würde aber keinen Sinn
machen, die Sprungvorhersage als einen Teil der fetch/decode Pipelinestufe in dieser Grafik zu
bestimmen. In einer solchen Grafik wird normalerweise die kleinste Anzahl an Zyklen dargestellt.
Es ist also untypisch, hier extra für die Sprungvorhersage eine Stufe darzustellen, die nur dann
auftaucht, wenn ein Sprung gegeben ist. Sicher ist auch nicht, ob die zusätzliche, unbekannte Stufe
genau an dieser Stelle in der fetch/decode-Pipeline auftaucht.
Das Zweite was auffällt, sind die zwei Xfer-Stufen in der Vektor-Pipeline. Beim Power4 Prozessor
sind die Xfer Stufen eine Art von Haltestufen, wo Instruktionen solange warten, bis sie einer
Instruktions-Gruppe zugeordnet werden. Beim Power4 Prozessor taucht eine Xfer- Stufe genau vor
der Zuteilungsstufe (dispatch stage) auf und IOPs (internal operations) verbleiben dort, während sie
auf die Freigabe von Ressourcen warten. Danach können sie einer Gruppe zugeteilt werden und zur
Ausführungseinheit weitergeleitet werden. In der Ausführungsphase werden die IOPs in beliebiger
Reihenfolge der Ausführungseinheit zugeteilt und wenn die Ausführung abgeschlossen ist, warten
die Instruktionen in den anderen Xfer-Stufen auf das Fertigwerden der anderen Instruktionen ihrer
Gruppe. Sind alle Instruktionen einer Gruppe mit der Ausführung fertig und ihrer Ergebnisse in die
Register zurückgeschrieben, wechseln sie in die CP-Stufe (Complete Phase), wo sie schließlich
abschließen. Der 970 Prozessor realisiert zwei neue Xfer-Stufen. In der Grafik befinden sich diese
rechts nach der GD (group dispatch, Gruppenzuteilung) Stufe und vor der CP-Stufe (Complete
Phase). Die erste neue Xfer Stufe wurde vermutlich hinzugefügt, um es den Vektor Instruktionen zu
ermöglichen, zu der Vektor-Ausführungseinheit (vector execution unit) zu gelangen, die sich etwas
weiter entfernt von dem Hauptkern befindet. Das VRF (vector register file) wurde bei den anderen
register-files platziert, um load-store-Latenzzeit zu minimieren, was im Gegenzug aber die erste
neue Xfer-Stufe notwendig macht. Die zweite neue Xfer Stufe wurde wegen der Rückkehr der
Vektor-Instruktionen von der Vektor-Ausführungseinheit implementiert, um mit den anderen
Instruktionen in ihrer Gruppe abschließen zu können. Diese beiden Stufen sind eine Art
„Beförderungsstufen“, die hinzugefügt wurden, um eine Anpassung an die angeschlossene AltivecEinheit vorzunehmen.
Durch die zwei benötigten Beförderungsstufen innerhalb der Pipeline, die der Prozessor benötigt,
um die Instruktionen hin und her zu schicken, scheint die Altivec-Einheit (VektorAusführungseinheit) ziemlich isoliert zu sein. Dadurch wäre auch eine Begründung für die dritte
und letzte, neu hinzugefügte zweite RF-Stufe (register file read) gefunden. Weil die VPERM
(Vector Permute Logic Unit) und VALU (Vector Arithmetic Logic Unit) so weit entfernt von dem
Vektor Register File (VRF) sind, wird ein extra Zyklus benötigt, damit diese Operanden aus dem
Register auslesen können. Eine entsprechende Extra-WriteBack Stufe wird nicht benötigt (passiert
während Xfer), auch wenn es eines Extra-Zyklus bedarf, um die modifizierten Werte zurück in das
VFR zu bringen. Das ist aus zwei Gründen so. Erstens ist ein WriteBack, wie z.B. ein STORE eine
„ausführen und vergessen“ Operation. Weiterhin muss ein WriteBack abgeschlossen sein, bevor die
Instruktion abschließen kann. Dies wird durch die hinzugefügte Xfer Stufe realisiert, die der
Vektoreinheit einen Extra-Zyklus verschafft, den sie braucht, um ein Zurückschreiben der
modifizierten Werte vornehmen zu können.
2.4 Apple G5 System
Weil IBM nicht Mitglied im HyperTransport-Konsortium ist, besitzt der PowerPC 970 ein anderes
Buskonzept, das aber, genauso wie beim Hypertransport, eine bidirektionale Punkt-zu-PunktVerbindung mit einer effektiven Bandbreite von bis zu 6,4 GByte/s realisiert. Es ist aber möglich,
einen Brückenbaustein (Bridge) zu Hypertransport einsetzten.
Der PowerPC 970 900MHz frontside Bus arbeitet mit 450MHz DDR . Der Bus besteht dabei aus
zwei unidirektionalen 32-bit point-to-point Verbindungen. Eine Verbindung ist dabei von der CPU
zum angebundenen Chip (die Northbridge) und die andere vom Chip zur CPU. Beide Verbindungen
arbeiten mit 900MHz. Bei der Übertragung von 4 Byte hin und zurück bei 900MHz ergibt das 3,6
GB/s in jede Richtung. Insgesamt ist die Bandbreite also 7,2 GB/s. Zieht man den Command- und
Address-Overhead ab, erhält man 6,4 GB/s.
38
Der PowerPC 970 Prozessor soll den G5-Mac laut Hersteller zum „schnellsten PC der Welt“
machen. Doch es fehlt an G5-optimierten Anwendungen und einem 64-Bit-Betriebssystem.
Ein weiteres Problem zeigt sich bei der versuchten Integration eines G5-Prozessors in ein
Notebook. Laut dem Chef-Entwickler von Apple, Jon Rubinstein, ist der Energieverbrauch des G5Prozessors das Problem. Der Prozessor benötigt, laut Rubinstein, sehr große Kühlkörper. Primäres
Ziel ist es jetzt, in Zusammenarbeit mit IBM, den Stromverbrauch zu senken, so dass man in
Zukunft ein PowerBook mit G5 Prozessor anbieten kann.
Auch lieferte der G5 Prozessor sehr gemischte Benchmark-Resultate, als er von Testern der
Zeitschrift c’t getestet wurde. Hierbei kamen verschiedenen von IBM zur Verfügung gestellte
Compiler zum Einsatz, von denen die neuesten die besten Ergebnisse lieferten. Der ursprüngliche
Compiler stammt vom Power 4 Prozessor und wurde von IBM in der Optimierung ergänzt. Für das
G5-System wurde im wesentlichen die Power4 Architektur übernommen auf die Bedürfnisse
modifiziert. Die Architektur wurde auf Wachstum ausgelegt und die am höchsten entwickelten
Technologien wie etwa AGP 8X, Hypertransport und PCI-X, verwendet.
Quelle: ct
Die neuen G5-Modelle gibt es mit 1,6-, 1,8- und zwei 2,0-GHz-Prozessoren. Wie auch in der
obigen Abbildung zu erkennen ist, hat Apple nicht nur den Prozessor erneuert, sondern die gesamte
Systemarchitektur auf den neusten Stand gebracht. Durch die langsame Weiterentwicklung des G4Vorgängersystems hätte Apple fast den Anschluss im PC-Markt verloren.
Im G5-Top-Modell arbeitet ein zwei mal 32-Bit breiter Frontsidebus mit, laut Apple, 1GHz. Hierbei
handelt es sich wiederum um 500 MHz mit jeweils zwei Datenpaketen pro Takt (DDR). Somit wird
beim G5-Top-Modell ein effektiver Datendurchsatz von 7,1 GByte/s zwischen Prozessor und
Controller erreicht. Die G5-Modelle mit 1,8- und 2,0-GHz sind durch ein Speicher-Interface mit
zwei DDR-400-Kanälen, die bis zu 6,4 Gbyte/s Daten zwischen dem Prozessor und dem
Arbeitsspeicher übertragen können, auf dem neusten Stand der Technik. Der maximale
Speicherausbau beträgt 8 GByte, wobei mit geeigneten Speicher-Riegeln auch ein Ausbau auf 16
Gbyte möglich sein soll. Wie schon am Anfang dieses Kapitels erläutert, sind Komponeten wie
PCI-X, Gigabit Ethernet, FireWire, USB 2.0 und Serial ATA über eine HyperTransport-Brücke
39
angeschlossen. Die HyperTransport-Brücke arbeitet bidirektional mit jeweils 16-Bit (nur mit halber
Kraft) und, laut Apple mit 800 MHz (2 x 400 MHz), also der halben Taktrate wie beim AMD
Opteron. Die Geamtübertragungsrate beträgt hier 3,2 GByte/s. Wie auch in der obigen Abbildung
zu erkennen, ist der Grafikkarten-Steckplatz, AGP-8X, direkt an den System-Controller
angeschlossen. Weiterhin gibt es zwei unabhängige Serial-ATA-Busse, die für maximal zwei
Festplatten vorgesehen sind. Maximal ist zur Zeit 500 Gbyte Plattenspeicher möglich.
In allen Modellen gibt es 3 Steckplätze für Erweiterungskarten, wobei diese im 1,6 GHz-Modell
noch der alten PCI-Norm entsprechen (64 Bit, 33 MHz). In den anderen G5-Modellen erfüllen sie
den PCI-X Standard (1 x 64 Bit mit 133 MHz, 2 x 64 Bit mit 100 MHz, abwärtskompatibel zu
bisherigen PCI-Normen). Damit ist theoretisch ein Datendurchsatz von insgesamt 2 GByte pro
Sekunde zu erreichen.
Für die Möglichkeit von digitalen Surround-Sound sorgen optische Audio-Ein- und -Ausgänge.
3 LCT Hardware Teil
3.1 Aufgabenbeschreibung
Wir haben uns zur Aufgabe gemacht, den PowerPC auch in punkto Hardware zu untersuchen.
Dabei haben wir uns, soweit es möglich war, am DLX-Laborversuch orientiert. Gleichzeitig soll
aber auch auf die verwendete Softwareumgebung eingegangen werden.
3.2 Die Software
Wir verwendeten den „XRAY-Simulator für PowerPC“ von der Firma „Accelerated Technology“.
Hierbei handelt es sich um eine Testversion, deren Laufzeit durch eine Lizenzdatei begrenzt wird.
Mit im Paket befindet sich ebenfalls ein Compiler für C-Programme von der Firma „Microtec“, der
den für PowerPC optimierten Assembler-Code erzeugt. Das kompilieren geschieht wie folgt:
mccppc -g -o Demo.x Demo.c
Das „-g“ erzeugt Debug-Informationen und auf „-o“ folgt der Name des Output-Files. Zum Schluss
muss noch die Quelldatei angegeben werden.
3.3 Der Simulator
Der „XRAY-Simulator“ ist eine Art Debugger, der die Umgebung einer bestimmten
Prozessorfamilie simuliert. In unserem Fall handelt es sich um den G2-PowerPC 603. Außerdem
werden folgende PowerPC-Prozessoren unterstützt:
• Motorola/IBM PowerPC 603, 603e, 604, 604e, 740, 750
• Motorola MPC505, MPC509, MPC555, MPE603e, MPC821, MPC823, MPC850,
MPC850SAR, MPC860, MPC860SAR, MPC860T, MPC8240,
MPC8260 PowerQUICC II
• IBM PowerPC 403GA/GB/GC/GP/GCX, 401GF
Die AltiVec-Einheit wird nicht unterstüzt.
Nachdem man seine Applikation erstellt und kompiliert hat, kann sie in den Simulator geladen
werden. Es gibt dann zwei Möglichkeiten den Programmcode zu betrachten. Zum einen ist er als
Assemblerprogramm zu sehen und mittels Low-Level-Steps zu verfolgen. Die andere Möglichkeit
ist, sich nochmal das C-Programm anzuschauen und es mittels Hi-Level-Steps zu verfolgen.
Zwischen beiden Möglichkeiten kann beliebig hin und her gewechselt werden. In beiden Fällen gibt
es aber eine Markierung, die anzeigt, bei welchem Schritt sich das Programm gerade befindet.
40
Natürlich kann man auch das ganze Programm auf einmal ausführen.
Außerdem können Haltepunkte im Programm gesetzt werden, bei denen gestoppt werden soll.
Diese können auch an Bedingungen geknüpft werden, z.B. an einen bestimmten Wert den eine
Variable des C-Programms haben soll.
Zu Speicheradressen von Variablen, die im Speicher abgelegt werden, kann per Eingabe ihres
Namens direkt gesprungen werden. Zusätzlich gibt es mehre Ansichtsmöglichkeiten in Form von
ASCII, Long, Short usw. und durch Verändern der Spaltenanzahl im Speicherfenster. Das gleiche
gilt auch für den Stack.
Mit am Wichtigsten ist aber das Register-Fenster. Hier können sämtliche Register des Prozessors
betrachet. Das Fenster ist durch mehrere Registerkarten unterteilt. Es gibt z.B. eine Registerkarte
für die Floating-Point-Register und eine andere für die CPU-Register wie das Link-Register oder
die 32 General-Purpose-Register.
Bei Speicher, Register und Stack wird der jeweilige Wert, der sich verändert hat, durch ein
Verändern der Farbe markiert.
Im oberen Screenshot ist links der Hi-Level-Code zu sehen. In Zeile 9 ist das Programm angehalten
worden. Dies wird durch den rechteckigen Kasten um die auszuführende Zeile gekennzeichnet.
Rechts daneben befinden sich die CPU-Register mit den 32 General-Purpose-Registern, MachineStatus-Register, Control-Register, Link-Register etc. Im unteren Teil befindet sich die Ansicht auf
den Speicher. Er wird als „Long“ dargestellt mit 8 Spalten.
41
In diesem Screenshot ist statt der Hi-Level-Ansicht jetzt die Low-Level-Ansicht auf den Code zu
sehen. Auch hier ist die Stelle im Code wieder durch einen rechteckigen Kasten markiert, wo das
Programm angehalten wurde. Im rechten Teil sieht man die Floating-Point-Register und an erster
Stelle das Floating-Point-Status-Control-Register. Der Stack ist im unteren Bereich angeordnet. Die
Markierung “<- SP, FP“ zeigt auf die aktuelle Position des Stacks.
42
Register
Beim PowerPC sind die Register in drei logische Sätze
unterteilt. Es gibt die User Instruction Set Architecture
(UISA), die Virtual Enviroment Architecture (VEA) und die
Operating Enviroment Architecture (OEA). Für uns ist die
UISA von Bedeutung. Die beiden anderen ArchitekturSichten erweitern diese Sicht um weitere Register, die für
unsere Untersuchungen nicht von Bedeutung sind.
Die 32 General-Purpose-Register (32 Bit) werden
hauptsächlich für Speicherung von Adressen,
Adressberechnung und Rechnung mit Integer-Werten
benutzt. Auf Beispiele wird später noch genauer
eingegangen.
Weiterhin gibt es 32 Floating-Point-Register (64 Bit), die für
Gleitkommarechungen zur Verfügung stehen. Sie beinhalten
Gleitkommazahlen nach IEEE.
Das Condition-Register (32 Bit) ist eine Besonderheit
gegenüber herkömmlichen Prozessoren (x86, MIPS, etc.).
Hauptsächlich wird es für Vergleiche von Integer-Werten
und deren Ergebnissen benutzt.
Beim Floating-Point-Status (32 Bit) und Control-Register
handelt es sich um ein Register, das verschiedene Flags für
die Gleitkommarechnung zur Verfügung stellt. Dabei handelt
es sich z.B. zum Aufzeichnen von Exceptions (Division
durch 0) oder auch die Festlegung des aktuellen
Rundungsmodus.
Das XER-Register (32 Bit) wird bei bestimmten Operationen
benutzt, um Flags für Overflow oder Carry etc. zu setzen.
Die Sprungzieladresse wird im Link-Register (in unserem
Fall 32 Bit) abgelegt.
Das Count-Register (in unserem Fall 32 Bit) kann zusammen
mit Sprungbefehlen von Bedeutung sein. U.a. kann es auch
mit der Berechnung von Sprungvorhersagen in
Zusammenhang stehen.
43
3.4 Instruction-Format
Eine Instruktion beim PowerPC ist 32 Bit lang. Die ersten 5 Bit beinhalten den Primary-OP-Code.
Zusätzlich benötigen einige Befehle noch einen Secondary-OP-Code. Die restlichen Bits werden für
verschiedene Befehlsformat verwendet. Im Grunde jedoch ist das Befehlsformat des PowerPCs
ähnlich des MIPS oder der DLX.
Zur Verdeutlichungen sollen hier ein paar Beispiele gezeigt werden:
Die I-Form wird z.B. für Branch-Befehle verwendet. Das Feld LI enthält die Zieladresse zu der
gesprungen werden soll. AA und LK sind zusätzliche Parameter. Wenn LK=1 ist, dann wird die
Adresse der Folgeinstruktion als Rücksprungadresse ins Linkregister gespeichert. AA gibt an, ob
die Adresse in LI relativ zur jetzigen Adresse der Instruktion ist oder es sich um eine absolute
Adresse handelt.
Bei der B-Form kann es sich z.B. um einen Branch-Conditional-Befehl handeln. AA und LK
werden wieder wie oben schon erwähnt verwendet. Hier ist BD die Zieladresse für den Sprung. Die
Felder BO und BI geben die Bedingungen für den Sprung an. Diese beziehen sich auf einen zuvor
ausgeführten Vergleich durch den Compare-Befehl (CMP), dessen Ergebnis im Condition-Register
(CR) steht. So geben die Bits in BO an, welches CR-Bit benutzt werden soll und die Bits in BI
liefern die Bedingung bei dem der Sprung ausgeführt wird.
Beispiel:
BI = 00000 (Negatives Ergebnis des Vergleichs)
BO = 011zy (Springe, wenn die Bedingung wahr ist)
Es wird also gesprungen, wenn das Ergebnis negativ war. Die mit ‚z’ benannten Bits werden
ignoriert. Das ‚y’-Bit gibt an, ob es möglich erscheint, dass der Sprung ausgeführt wird.
Die B-Form kann aber auch als normaler Sprung-Befehl benutzt werden. Dazu müsste dann in BO
„1z1zz“ stehen. Somit würde immer an die Adresse in BD gesprungen.
Die D-Form wird hauptsächlich für arithmetische und logische Befehle benutzt (z.B. Addieren,
AND, OR, aber auch für Store-Word, Load-Word).
44
Load Floating-Point Double (LFD) gehört zur D-Form. In das in D angegebene Floating-PointRegister wird das Doppelwort von einer Speicheradresse geschrieben. Die Speicheradresse
berechnet sich aus dem Wert in Register A und dem Offset d.
Ein weiterer Befehl, der zur D-Form gehört, ist Add Immidiate (ADDI). Dabei wird in das Register
D die Summe aus dem Register A und des Wertes in SIMM geschrieben.
Auch Store Word (STW) gehört in die Kategorie der D-Form-Befehle. Hierbei wird der Wert aus
Register S in den Speicher geschrieben. Die zugehörige Adresse setzt sich aus dem Wert in Register
A und dem Offset d zusammen.
OR Immidiate (ORI) gehört ebenfalls zur D-Form. Hierbei werden der Wert aus Register A und der
Wert UIMM miteinander oder-verknüpft. Das Ergebnis wird ins Register S geschrieben. Oft wird
der Befehl „ori 0,0,0“ als nop (no-operation) verwendet.
Beim Compare Immidiate (CMPI) werden die Werte aus dem Register A und dem SIMM-Feld
verglichen. Das Ergebnis des Vergleichs wird in das Condition Register D geschrieben. Dieser
Befehl gehört auch in die D-Form-Kategorie. L ist für spätere Befehlserweiterung (z.B. 64 Bit)
reserviert und hat somit für die 32-Bit Operationen keine Bedeutung und sollte eine 0 enthalten, da
sonst der Befehl ungültig ist.
45
Compare Logical Immidiate (CMPLI) funktioniert nach dem gleichen Prinzip wie der Compare
Immidiate Befehl zuvor. Jedoch muss es sich im Feld UIMM um ein Unsigned Immidiate handeln.
Der „einfache“ Compare-Befehl (CMP) gehört zur X-Form. Diese Form hat einen Secondary-OPCode, der in den Bits 21-30 enthalten ist. A und B bezeichnen die Register, die miteinander
verglichen werden sollen. In crfD ist die Zielposition im Condition-Register (CR) für das Ergebnis
des Vergleichs enthalten. L ist für spätere Befehlserweiterung (z.B. 64 Bit) reserviert und hat somit
für die 32-Bit Operationen keine Bedeutung.
Das sind im Groben alle Befehle bzw. Formate, die wir bei der Untersuchung des PowerPCs mit
dem Simulator entdeckt haben bzw. vom Compiler verwendet wurden.
46
3.5 Ergebnisse
Grundsätzlich besteht ein Assembler-Programm aus einer 32-Bit Programmadresse und einem 32Bit Befehl. Da aber die Lesbarkeit des Befehls schlecht ist, erzeugt der Simulator als dritte und
vierte Spalte den entsprechenden Assemblercode. Bestimmte Adressen im Speicher oder im
Programm werden hinter ‚#’ dargestellt. Somit bekommt man folgendes zu sehen:
0001001C 3BE00003
00010020 3C600001
00010024 93E3234C
addi
addis
stw
31,0,0x3
3,0,0x1 # 0x1234C hi(a)
31,0x234c(3)
Globale Variablen werden im Speicher abgelegt. Der obere Programmausschnitt zeigt die
Zuweisung des Wertes ‚3’ zur globalen Variablen ‚a’. Zu erst wird das Ergebnis der Addition aus
den Werten ‚3’ und ‚0’ ins Register 31 geschrieben. Ins Register 3 wird der Wert 0x10000H für die
Adressberechnung für den Speicherplatz geschrieben. Anschließend wird die ‚3’ aus Register 31 an
die Adresse 0x1234cH geschrieben. Diese Adresse setzt sich aus dem Wert in Register 3 und dem
Offset 0x234cH zusammen.
Der Stack wird in unserem Fall im Speicher ab Adresse 0x32500H verwaltet. In Register 1 liegt
immer der aktuelle Wert des Stackpointers. Lokale Variablen werden in Abhängigkeit von diesem
Wert auf dem Stack abgelegt. Das zeigt die folgende Zeile:
00010098 9081000C
stw
4,0xc(1)
Hierbei wird der Wert aus Register 4 auf dem Stack gelegt. Die Adresse ist dabei um 0xcH höher
als der Wert im Register 1 (der aktuelle Stackpointer).
Zu Beginn der main()-Methode im C-Programm werden einige Register gerettet. Dies wird
gemacht, da diese Register innerhalb der Methode verändert werden und sie nach Abschluss wieder
gebraucht werden, um Aufräumarbeiten durchzuführen.
00010000
00010004
00010008
0001000C
00010010
00010014
00010018
7C0802A6
9421FFE8
93C10010
93E10014
9001001C
90610008
9081000C
mfspr
stwu
stw
stw
stw
stw
stw
0,LR
1,-24(1)
30,0x10(1)
31,0x14(1)
0,0x1c(1)
3,0x8(1)
4,0xc(1)
Die Rücksprungadresse wird in Register 0 gesichert (mfspr = move from special purpose register).
Danach wird der Stackpointer neu gesetzt, der alte Wert aus Register 1 an die neue Adresse
geschrieben und der neue Wert wieder ins Register 1 (stwu = store word and update). In
Abhängigkeit vom aktuellen Stackpointer (Register 1) werden jetzt die Register 30, 31, 0, 3 und 4
auf dem Stack gesichert.
Am Ende der main()-Methode werden diese Wert wieder vom Stack geholt und in die Register
zurückgeschrieben. Auch bei Funktionsaufrufen werden u. U. solche Sicherungen vorgenommen.
47
Sowohl for- als auch while-Schleife in C werden vom Compiler wie folgt umgesetzt:
for(i=1; i<=zahl; i++)
{
...
}
000100C8
000100CC
000100D0
...
000100EC
000100F0
000100F4
while(i <= zahl)
{
...
i++;
}
7C032000
41810028
...
cmp
bc
0,0,3,4
0xc,0x1,fakultaet+0x44
#0x000100F4
7C032000
4081FFE0
...
cmp
bc
0,0,3,4
0x4,0x1,fakultaet+0x20
#0x000100D0
Wie schon beim Instruction-Fromat erwähnt, vergleicht der PowerPC erst den Wert und schreibt
das Vergleichsergebnis in das Condition-Register (CR). Daraufhin wird dann ein Sprung ausgeführt
oder nicht. Bevor jetzt die for-Schleife durchlaufen wird, wird überprüft, ob das Durchlaufen
überhaupt erforderlich ist. Wenn der Wert aus Register 3 (i) größer ist als der in Register 4 (zahl),
dann überspringe die Schleife. Konkret wird im Branch-Befehl überprüft, ob das Ergebnis größer ist
(0x1) und wenn das zutrifft (0xc), soll gesprungen werden. Nachdem die Befehle in der Schleife
ausgeführt wurden, wird wieder überprüft, ob die Schleife noch mal durchlaufen werden muss.
Dazu wird jetzt überprüft, ob das Ergebnis größer ist (0x1). Ist die nicht der Fall (0x4), dann springe
zurück.
do
{
...
i++;
} while(i <= zahl);
Bei der do…while-Schleife verhält es sich anders. Hierbei wird nur noch ein Vergleich benötigt,
denn sie wird mindestens einmal durchlaufen. Somit fällt aus dem oben gezeigten AssemblerProgramm der erste Vergleich mit Sprung weg. Der untere Teil verändert sich nicht. Wir haben aber
dadurch eine Optimierung des Codes auf C-Ebene erreicht, da wir drei Zeilen weniger im
Assembler-Programm benötigen. Denn auch der Vergleichswert in Register 4 (zahl) braucht nicht
am Anfang geladen zu werden.
Bei dem folgenden Funktionsaufruf werden die Variablen x und y in Registern übergeben. Erst in
der Funktion selber werden die Werte auf dem Stack gesichert. Auch das Ergebnis wird wieder im
Register zurückgegeben und nach der Rückkehr in die entsprechende Variable im Speicher
geschrieben.
int
addieren(int x, int y) {
return x + y;
}
48
3.6 Optimierung auf Assembler-Ebene
Hierbei hat uns der Simulator leider im Stich gelassen. Es gibt zwar die Möglichkeit bei dem
mitgelieferten Compiler den Assembler-Code aus dem C-Programm zu bekommen. Somit konnte
dieser auch bearbeitet werden. Hierfür wird folgender Compiler-Aufruf benötigt:
mccppc –S Demo.c
Damit erhält man den Assemblercode des C-Programms in der Datei Demo.src.
Das Problem bestand aber jetzt darin, den bearbeiteten Assembler-Code wieder in den Simulator zu
laden. Denn dazu bräuchte man ein sog. „absolute File“ z.B. mit der Endung „.x“. Um solche
Dateien aus Assembler-Code zu bekommen, wird ein Compiler für Assembler-Code benötigt. Nach
stundenlangen Recherchen in den beigefügten Dokumentationen und im Internet auf den Seiten des
Herstellers, ist es uns nicht gelungen eine adäquate Lösung für dieses Problem zu finden. Die
einzigen Ergebnisse waren mehrere Abstürze des Simulators. Da es sich aber bei der Software um
eine Testversion handelt, wurde auf mehrere Tools vom Hersteller verzichtet bzw. wurde eine
Ausführung durch Eingrenzen der Lizenzrechte verhindert. Dies bestätigt auch folgende Meldung,
die bei einem der vielen Versuche erschien:
(F) #C0698 licensing failure (-10)
4 Literaturliste PowerPC G1-G4, IBM PowerPC 970 und
Bildquellen
IBM:
http://www-5.ibm.com/de/pressroom/presseinfos/2003/030624_2.html
Artikel: PowerPC 970: First in a new family of 64-bit high performance PowerPC processors
Manual: PowerPC Microprocessor Family: AltiVec(TM) Technology Programming Environments Manual
Artikel von Jon Stokes:
http://www.arstechnica.com/cpu/02q2/ppc970/ppc970-1.html
http://www.arstechnica.com/cpu/03q1/ppc970/ppc970-0.html
c't-Artikel:
Johannes Schuster
Jon Rubinstein, Chef der Hardware-Entwicklung bei Apple, im c't-Interview
aktuell,Apple,G5, Rubinstein, PowerPC 970, IBM
c't 21/03, Seite 46
Christof Windeck, Jörg Wirtgen, Herbert Schmid
Stufe vier
AMD Athlon 64, Apple PowerMac G5, FX und die Konkurrenz
Prüfstand,AMD Athlon 64 -- Apple Power Mac G5,AMD-8000,PowerPC 970,PPC970,G4,Athlon
XP,Opteron,Intel Pentium 4,Xeon,E7505,i865,i875,DDR400,PC3200R,Registered,Benchmark,ZweikanalRAM,Chipsatz,K8X800 PROII,AMD Athlon 64 FX-51,PowerMac G5,Dual 2.0
c't 20/03, Seite 98
Johannes Schuster, Stephan Ehrmann, Christoph Laue (jes)
64 in spe
Apples Power Mac G5 mit 1,6 GHz im ersten Test
Prüfstand,Power Mac G5 ,Power Mac G5 1,6 GHz, PowerPC 970, HyperTransport, USB 2.0, PCI-X
49
c't 19/03, Seite 114
AltiVec-Bilder
http://page.inf.fu-berlin.de/~vratisla/RA99/altivec.html
Sonstige Links:
http://www.realworldtech.com/page.cfm?AID=RWT101502203725
http://www.intel.com/technology/itj/2002/volume06issue01/art01_hyper/p06_execution_engine.ht
m
Die Geschichte des PowerPC G1-G4:
http://www.apple.com/de/
http://www.motorola.com/de/
http://core.de/core/powerpc.html, http://www.fhwedel.de/cis/archiv/seminare/ws9900/ue/PowerPC/PowerPC.html
http://www.computer-archiv.de/
http://www-1.ibm.com/servers/eserver/pseries/hardware/whitepapers/power/ppc_601.html
Advance Information PowerPC 604 RISC Microprocessor Technical Summary (IBM / Motorola)
Advance Information PowerPC 750 RISC Microprocessor Technical Summary (IBM / Motorola)
Advance Information MPC 7400 RISC Microprocessor Hardware Specifications (Motorola)
Quellen zum Hardwareteil:
Accelerated Technology
Microtec
www.acceleratedtechnology.com
www.mentor.com/microtec
50
5 Anhang
Quellcode
int a;
int b;
int summe;
void addierenG();
int addierenL();
void fakultaet();
int
main(int argc, char **argv) {
a = 3;
b = 4;
addierenG();
summe = addierenL(4 , 5);
fakultaet(3);
return 0;
}
void
addierenG() {
summe = a + b;
}
int
addierenL(int x, int y) {
return x + y;
}
void
fakultaet(int zahl) {
int result = 1;
int i = 1;
for(i=1; i<=zahl; i++)
{
result = result * i;
i++;
}
}
51
Compilierter Assemblercode
>>> DEMO\#1..9
stack.sizeof:
00010000 7C0802A6
00010004 9421FFE8
00010008 93C10010
0001000C 93E10014
00010010 9001001C
00010014 90610008
00010018 9081000C
>>> DEMO\#10
0001001C 3BE00003
00010020 3C600001
00010024 93E3234C
>>> DEMO\#11
00010028 3BC00004
0001002C 3C600001
00010030 93C32348
>>> DEMO\#12
00010034 4800003D
>>> DEMO\#13
00010038 38800005
0001003C 63C30000
00010040 48000051
00010044 3C800001
00010048 906424DC
>>> DEMO\#14
0001004C 63E30000
00010050 48000061
>>> DEMO\#15
00010054 38600000
>>> DEMO\#16
00010058 8001001C
0001005C 7C0803A6
00010060 83C10010
00010064 83E10014
00010068 38210018
0001006C 4E800020
>>> DEMO\#17..20
addierenG:
00010070 3C600001
00010074 8063234C
00010078 3C800001
0001007C 80842348
00010080 7C632014
00010084 3C800001
00010088 906424DC
>>> DEMO\#21
0001008C 4E800020
>>> DEMO\#22..24
addierenL:
00010090 9421FFF0
00010094 90610008
00010098 9081000C
>>> DEMO\#25
0001009C 80610008
000100A0 8081000C
000100A4 7C632014
>>> DEMO\#26
000100A8 38210010
000100AC 4E800020
>>> DEMO\#27..29
fakultaet:
000100B0 9421FFE8
000100B4 90610008
>>> DEMO\#30
000100B8 38600001
000100BC 9061000C
>>> DEMO\#31..32
000100C0 90610010
000100C4 80810008
mfspr
stwu
stw
stw
stw
stw
stw
0,LR
1,-24(1)
30,0x10(1)
31,0x14(1)
0,0x1c(1)
3,0x8(1)
4,0xc(1)
addi
addis
stw
31,0,0x3
3,0,0x1 # 0x1234C hi(a)
31,0x234c(3)
addi
addis
stw
30,0,0x4
3,0,0x1 # 0x12348 hi(_edata)
30,0x2348(3)
bl
addierenG
addi
ori
bl
addis
stw
4,0,0x5
3,30,0x0
addierenL
#0x00010090
4,0,0x1 # 0x124DC hi(summe)
3,0x24dc(4)
ori
bl
3,31,0x0
fakultaet
addi
3,0,0x0
lwz
mtspr
lwz
lwz
addi
bclr
0,0x1c(1)
LR,0
30,0x10(1)
31,0x14(1)
1,1,0x18
0x14,0x0
addis
lwz
addis
lwz
addc
addis
stw
3,0,0x1 # 0x1234C hi(a)
3,0x234c(3)
4,0,0x1 # 0x12348 hi(_edata)
4,0x2348(4)
3,3,4
4,0,0x1 # 0x124DC hi(summe)
3,0x24dc(4)
bclr
0x14,0x0
stwu
stw
stw
1,-16(1)
3,0x8(1)
4,0xc(1)
lwz
lwz
addc
3,0x8(1)
4,0xc(1)
3,3,4
addi
bclr
1,1,0x10
0x14,0x0
stwu
stw
1,-24(1)
3,0x8(1)
addi
stw
3,0,0x1
3,0xc(1)
stw
lwz
3,0x10(1)
4,0x8(1)
#0x00010070
#0x000100B0
52
000100C8 7C032000
000100CC 41810028
>>> DEMO\#33..34
000100D0 80610010
000100D4 8081000C
000100D8 7C8321D6
000100DC 9081000C
>>> DEMO\#32
000100E0 30630001
000100E4 90610010
000100E8 80810008
000100EC 7C032000
000100F0 4081FFE0
>>> DEMO\#35..36
000100F4 38210018
000100F8 4E800020
cmp
bc
0,0,3,4
0xc,0x1,fakultaet+0x44
lwz
lwz
mullw
stw
3,0x10(1)
4,0xc(1)
4,3,4
4,0xc(1)
addic
stw
lwz
cmp
bc
3,3,0x1
3,0x10(1)
4,0x8(1)
0,0,3,4
0x4,0x1,fakultaet+0x20
addi
bclr
1,1,0x18
0x14,0x0
53
#0x000100F4
#0x000100D0

PowerPC - Weblearn

Transcription

Similar documents

i = 0

wichtige sicherheitshinweise!