powerpc - fbe - titleframe · 2.2.2 powerpc 970 execution core ... der von ibm für deren...

Referat

Rechner-Strukturen-Labor

PowerPC Laborgruppe: Christina Priebe 33253 Carsten Wellbrock 32412 Stefan Rauer 32496

Inhalt

1 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

2 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

3 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

4 Literaturliste PowerPC G1-G4, IBM PowerPC 970 und Bildquellen .......................................49 5 Anhang.......................................................................................................................................51

1

1 Die Geschichte des PowerPC G1-G4

1.1 Das PowerPC - Konsortium Quelle: http://core.de/core/powerpc.html, http://www.fh-wedel.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

http://core.de/core/powerpc.html

http://www.fh-wedel.de/cis/archiv/seminare/ws9900/ue/PowerPC/PowerPC.html


http://www.apple.com/de/

http://www.ibm.com/de/

http://www.motorola.com/de/

http://www.ibm.com/de/


1.2 PowerPC Prozessoren Quelle: u. a. http://www.computer-archiv.de/

Jahr Bezeichnung Generation Hersteller Registerbreite / bit L1 Cache / KB1992 PPC 601 G1 Apple / IBM 32 32 1994 PPC 601+ G1 Apple / IBM 32 unbekannt 1994 PPC 603 G2 IBM / Motorola 32 16 1994 PPC 603+ G2 Motorolla 32 32 1994 PPC 604 G2 Apple / IBM 32 / 64 unbekannt 1994 PPC 620 G2 Apple / IBM 64 32 1995 PPC 603e G2 IBM 32 32 1995 PPC 603ev G2 Apple / IBM 32 unbekannt 1996 PPC 604e G2 Apple / IBM 32 unbekannt 1996 PPC 613 G2 Apple / IBM 32 unbekannt 1996 PPC 614 G2 Apple / IBM 32 unbekannt 1997 PPC 750 G3 IBM / Motorola 32 unbekannt 1997 PPC RS64 G3 IBM 64 unbekannt 1998 PPC AS G3 Apple / IBM 64 unbekannt 1998 PPC Nothstar G3 IBM 64 unbekannt 1999 PPC Pulsar G3 IBM 64 unbekannt 1999 PPC 7400 G4 IBM / Motorola 32 unbekannt 2001 PPC 7450 G4+ IBM / Motorola 32 unbekannt 2002 PPC 7455 G4+ IBM 32 unbekannt 2003 PPC 85XX G5 IBM 64 unbekannt 2003 PPC 970 G5 IBM 64 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

http://www.computer-archiv.de/

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

http://www-1.ibm.com/servers/eserver/pseries/hardware/whitepapers/power/ppc_601.html

Um diese Ziele zu erreichen, stellte sich die Gruppe mit dem 601 Design einem aggressiven 12-monatigem 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

1.4 G2 anhand des PPC 604 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

Prozessor-Funktionseinheiten 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

1.5 G3 anhand des PPC 750 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) • Load / Store Unit (LSU) • 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

Prozessor-Funktionseinheiten 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) • Load / Store Unit (LSU) • 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 Hauptspeicher-Controller 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, SOI-Chips 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 ECC-Speichertechnologie (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 PowerPC-Prozessoren 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 G4-Die

Quelle: realworldtech.com 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 Vektor-Befehl 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 VX-

21

Format, das erweiterte Opcode Feld dar (Extended Opcode Field). VSCRN ist das Vector-Status- und-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-PowerPC-Prozessor 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++) { //16 8-Bit-Elemente if(a[i]==b[i]) //Vergleich der Elemente zweier Vektoren r[i]=x[i]; //x: erste Quelle else r[i]=y[i]; //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 Ziel-Adresse durch die Nutzung eines der beiden branch prediction-Konzepte.

2.2.1.1 Branch 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.2 Decode, 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 Instruktions-Abfertigungsbandbreite 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 Hyper- Threading 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-register-Instruktionen 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.1 Rename 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.2 Die 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.3 Load-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-Speicher-Operationen umgeht. Es könnte vermutet werden, dass Vektor LOADs in der einen Load-Store-Einheit 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-Store-Einheiten handhabt und die Vektor STOREs einer der Vektor-Ausführungspipelines überlässt.

2.2.2.4 Floating 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-Point-Instruktionen, 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 Floating-Point 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://www-3.ibm.com/chips/techlib/techlib.nsf/techdocs/A1387A29AC1C2AE087256C5200611780/$file/PPC970_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

http://www-3.ibm.com/chips/techlib/techlib.nsf/techdocs/A1387A29AC1C2AE087256C5200611780/$file/PPC970_MPF2002.pdf



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 Altivec-Einheit 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 (Vektor-Ausfü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-Punkt-Verbindung 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 G5-Prozessors 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 G4- Vorgä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, Machine-Status-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 Architektur-Sichten 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-Point-Register 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-OP-Code, 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 32-Bit 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 addi 31,0,0x3 00010020 3C600001 addis 3,0,0x1 # 0x1234C hi(a) 00010024 93E3234C stw 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 7C0802A6 mfspr 0,LR 00010004 9421FFE8 stwu 1,-24(1) 00010008 93C10010 stw 30,0x10(1) 0001000C 93E10014 stw 31,0x14(1) 00010010 9001001C stw 0,0x1c(1) 00010014 90610008 stw 3,0x8(1) 00010018 9081000C stw 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++) { ... }

while(i <= zahl) { ... i++; }

000100C8 7C032000 cmp 0,0,3,4 000100CC 41810028 bc 0xc,0x1,fakultaet+0x44 #0x000100F4 000100D0 ... ... 000100EC 7C032000 cmp 0,0,3,4 000100F0 4081FFE0 bc 0x4,0x1,fakultaet+0x20 #0x000100D0 000100F4 ... 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 Assembler-Programm 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,Zweikanal-RAM,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

http://www-5.ibm.com/de/pressroom/presseinfos/2003/030624_2.html

http://www.arstechnica.com/cpu/02q2/ppc970/ppc970-1.html

http://www.arstechnica.com/cpu/03q1/ppc970/ppc970-0.html

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.htm Die Geschichte des PowerPC G1-G4: http://www.apple.com/de/ http://www.motorola.com/de/ http://core.de/core/powerpc.html, http://www.fh-wedel.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 www.acceleratedtechnology.com Microtec www.mentor.com/microtec

50

http://page.inf.fu-berlin.de/~vratisla/RA99/altivec.html

http://www.realworldtech.com/page.cfm?AID=RWT101502203725

http://www.intel.com/technology/itj/2002/volume06issue01/art01_hyper/p06_execution_engine.htm

http://www.intel.com/technology/itj/2002/volume06issue01/art01_hyper/p06_execution_engine.htm


http://www.motorola.com/de/

http://core.de/core/powerpc.html



http://www.computer-archiv.de/

http://www-1.ibm.com/servers/eserver/pseries/hardware/whitepapers/power/ppc_601.html

http://www.acceleratedtechnology.com/

http://www.mentor.com/microtec

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 mfspr 0,LR 00010004 9421FFE8 stwu 1,-24(1) 00010008 93C10010 stw 30,0x10(1) 0001000C 93E10014 stw 31,0x14(1) 00010010 9001001C stw 0,0x1c(1) 00010014 90610008 stw 3,0x8(1) 00010018 9081000C stw 4,0xc(1) >>> DEMO\#10 0001001C 3BE00003 addi 31,0,0x3 00010020 3C600001 addis 3,0,0x1 # 0x1234C hi(a) 00010024 93E3234C stw 31,0x234c(3) >>> DEMO\#11 00010028 3BC00004 addi 30,0,0x4 0001002C 3C600001 addis 3,0,0x1 # 0x12348 hi(_edata) 00010030 93C32348 stw 30,0x2348(3) >>> DEMO\#12 00010034 4800003D bl addierenG #0x00010070 >>> DEMO\#13 00010038 38800005 addi 4,0,0x5 0001003C 63C30000 ori 3,30,0x0 00010040 48000051 bl addierenL #0x00010090 00010044 3C800001 addis 4,0,0x1 # 0x124DC hi(summe) 00010048 906424DC stw 3,0x24dc(4) >>> DEMO\#14 0001004C 63E30000 ori 3,31,0x0 00010050 48000061 bl fakultaet #0x000100B0 >>> DEMO\#15 00010054 38600000 addi 3,0,0x0 >>> DEMO\#16 00010058 8001001C lwz 0,0x1c(1) 0001005C 7C0803A6 mtspr LR,0 00010060 83C10010 lwz 30,0x10(1) 00010064 83E10014 lwz 31,0x14(1) 00010068 38210018 addi 1,1,0x18 0001006C 4E800020 bclr 0x14,0x0 >>> DEMO\#17..20 addierenG: 00010070 3C600001 addis 3,0,0x1 # 0x1234C hi(a) 00010074 8063234C lwz 3,0x234c(3) 00010078 3C800001 addis 4,0,0x1 # 0x12348 hi(_edata) 0001007C 80842348 lwz 4,0x2348(4) 00010080 7C632014 addc 3,3,4 00010084 3C800001 addis 4,0,0x1 # 0x124DC hi(summe) 00010088 906424DC stw 3,0x24dc(4) >>> DEMO\#21 0001008C 4E800020 bclr 0x14,0x0 >>> DEMO\#22..24 addierenL: 00010090 9421FFF0 stwu 1,-16(1) 00010094 90610008 stw 3,0x8(1) 00010098 9081000C stw 4,0xc(1) >>> DEMO\#25 0001009C 80610008 lwz 3,0x8(1) 000100A0 8081000C lwz 4,0xc(1) 000100A4 7C632014 addc 3,3,4 >>> DEMO\#26 000100A8 38210010 addi 1,1,0x10 000100AC 4E800020 bclr 0x14,0x0 >>> DEMO\#27..29 fakultaet: 000100B0 9421FFE8 stwu 1,-24(1) 000100B4 90610008 stw 3,0x8(1) >>> DEMO\#30 000100B8 38600001 addi 3,0,0x1 000100BC 9061000C stw 3,0xc(1) >>> DEMO\#31..32 000100C0 90610010 stw 3,0x10(1) 000100C4 80810008 lwz 4,0x8(1)

52

000100C8 7C032000 cmp 0,0,3,4 000100CC 41810028 bc 0xc,0x1,fakultaet+0x44 #0x000100F4 >>> DEMO\#33..34 000100D0 80610010 lwz 3,0x10(1) 000100D4 8081000C lwz 4,0xc(1) 000100D8 7C8321D6 mullw 4,3,4 000100DC 9081000C stw 4,0xc(1) >>> DEMO\#32 000100E0 30630001 addic 3,3,0x1 000100E4 90610010 stw 3,0x10(1) 000100E8 80810008 lwz 4,0x8(1) 000100EC 7C032000 cmp 0,0,3,4 000100F0 4081FFE0 bc 0x4,0x1,fakultaet+0x20 #0x000100D0 >>> DEMO\#35..36 000100F4 38210018 addi 1,1,0x18 000100F8 4E800020 bclr 0x14,0x0

53

powerpc - fbe - titleframe · 2.2.2 powerpc 970 execution core ... der von ibm für deren...

Documents