DE19983330B4

DE19983330B4 - Computerprozessor mit einem Wiederholsystem mit einem Stufungsabschnitt zum getakteten Verzögern und Verfahren zum Verarbeiten eines Befehls in einem solchen Prozessor

Info

Publication number: DE19983330B4
Application number: DE19983330T
Authority: DE
Inventors: Amit A. Portland Merchant; David J. Portland Sager; Darrell Aloha BOGGS
Original assignee: Intel Corp
Current assignee: Intel Corp
Priority date: 1998-06-30
Filing date: 1999-06-21
Publication date: 2009-04-09
Anticipated expiration: 2019-06-22
Also published as: TW444180B; GB2354615A; GB0100244D0; US6163838A; CN1126028C; GB2354615B; DE19983330T1; HK1037413A1; WO2000000886A1; CN1307700A

Abstract

Computerprozessor (50; 100) mit
einer Ausführungseinheit (58; 110–118) zum Ausführen von Befehlen,
einem Einplaner (30) zum spekulativen Einplanen von Befehlen und
einem Wiederholsystem (70), das die wiederholte Ausführung nicht korrekt ausgeführter Befehle bewirkt,
wobei ein Multiplexer (56) mit seinem ersten Multiplexereingang mit dem Einplaner (30), mit seinem zweiten Multiplexereingang mit einem Ausgang des Wiederholsystems, an dem zu wiederholende Befehle ausgegeben werden, und mit seinem Multiplexerausgang mit der Ausführungseinheit gekoppelt ist, so daß mit Hilfe des Multiplexers (56) der jeweils an die Ausführungseinheit auszugebende Befehl zwischen einem vom Einplaner (30) ausgegebenen Befehl und einem vom Wiederholsystem (70) ausgegebenen Befehl ausgewählt werden kann,
wobei das Wiederholsystem (70) einen Überprüfer (72) enthält, der überprüft, ob ein Befehl korrekt ausgeführt worden ist, wobei der Überprüfer (72) einen „Wiederhol-Sicher"-Ausgang zum Ausgeben eines korrekt ausgeführten Befehls aufweist, und der Überprüfer den Befehl über den Ausgang des Wiederholsystems (70) an den Multiplexer...

Description

Die vorliegende Erfindung betrifft einen Computerprozessor nach dem Oberbegriff des Anspruchs 1. Ferner bezieht sich die Erfindung auf ein Verfahren zum Verarbeiten eines Befehls in einem solchen Prozessor.
Ein Computerprozessor bzw. ein Verfahren der eingangs genannten Art sind aus der WO 98/21684 A1 bekannt.
Die primäre Funktion der meisten Computerprozessoren besteht darin, Computerbefehle auszuführen. Die meisten Prozessoren führen Befehlen in der programmierten Reihenfolge, in der sie empfangen werden, aus. Jedoch sind einige jüngere Prozessoren, wie beispielsweise der Pentium^®II-Prozessor von der Intel Corp., "Außer-der-Reihe"-Prozessoren. Ein Außer-der-Reihe-Prozessor kann Befehle in einer beliebigen Reihenfolge ausführen, sobald die für einen jeweiligen Befehl erforderlichen Daten und Ausführungseinheiten verfügbar werden. Folglich können bei einem Außer-der-Reihe-Prozessor Ausführungseinheiten in dem Prozessor, die anderenfalls untätig sein könnten, effizienter ausgenutzt werden.
Bei beiden Arten von Prozessoren können Verzögerungen auftreten, wenn "abhängige" Befehle ausgeführt werden. Ein abhängiger Befehl erfordert, um richtig ausgeführt zu werden, einen durch einen anderen Befehl, der korrekt ausgeführt worden ist, erzeugten Wert. Beispielsweise sei der folgende Satz von Befehlen betrachtet:

1) Lade (Load) Speicher-1 → Register-X;
2) Addiere1 (Add1) Register-X Register-Y → Register-Z;
3) Addiere2 (Add2) Register-Y Register-Z → Register-W.

Der erste Befehl lädt den Inhalt des Speicher-1 in das Register-X. Der zweite Befehl addiert den Inhalt des Registers-X zu dem Inhalt des Register-Y und speichert das Ergebnis im Register-Z. Der dritte Befehl addiert den Inhalt des Registers-Y zu dem Inhalt des Registers-Z und speichert das Ergebnis im Register-W. Bei diesem Satz von Befehlen sind die Befehle 2 und 3 abhängige Befehle, die von dem Befehl 1 abhängig sind (Befehl 3 ist darüber hinaus vom Befehl 2 abhängig). Mit anderen Worten, wenn Register-X nicht mit dem richtigen Wert im Befehl 1 geladen wird, bevor Befehle 2 und 3 ausgeführt werden, erzeugen die Befehle 2 und 3 wahrscheinlich falsche Ergebnisse. Abhängige Befehle können bei bekannten Prozessoren eine Verzögerung bewirken, da die meisten bekannten Prozessoren üblicherweise einen abhängigen Befehl nicht einplanen (schedule), bis sie wissen, daß der Befehl, von dem der abhängige Befehl abhängig ist, das richtige Ergebnis erzeugt.
Es wird jetzt im Detail auf die Zeichnungen Bezug genommen, in denen gleiche Teile durchgängig mit gleichen Bezugszeichen gekennzeichnet sind. 1 ist eine Blockdarstellung einer Prozessorpipeline und eines Zeitdiagramms, das die durch abhängige Befehle bei den meisten bekannten Prozessoren verursachte Verzögerung veranschaulicht. In 1 plant ein Einplaner (Scheduler) 10 Befehle ein. Die Befehle Planzen sich durch eine Ausführungseinheitspipeline fort, die die Pipelinestufen 12, 14, 16, 18, 20, 22 und 24 enthält. Während jeder Pipelinestufe wird ein Verarbeitungsschritt ausgeführt. Beispielsweise wird an der Pipelinestufe 12 der Befehl abgefertigt (dispatched). An der Stufe 14 wird der Befehl decodiert, und die Quellregister werden gelesen. An der Stufe 16 wird eine Speicheradresse erzeugt (für einen Speicherbefehl), oder es wird eine Operation einer arithmetisch-logischen Einheit ("ALU") ausgeführt (bei einem arithmetischen oder logischen Befehl). Bei Stufe 18 werden Cache-Daten gelesen, und es wird ein Nachschlagen in den Übersetzungsnachschlagepuffer ("TLB") durchgeführt. Bei Stufe 20 wird der Cache-Tag gelesen. Bei Stufe 22 wird im Ergebnis des Tag-Lesens ein Treffer/Fehlversuch-Signal erzeugt. Das Treffer/Fehlversuch-Signal zeigt an, ob die gewünschten Daten in dem Cache gefunden wurden (d. h., ob die aus dem Cache in der Stufe 18 gelesenen Daten die richtigen Daten waren). Wie es in 1 gezeigt ist, wird das Treffer/Fehlversuch-Signal typischerweise erzeugt, nachdem die Daten bei Stufe 18 gelesen sind, da das Erzeugen des Treffer/Fehlversuch-Signals die zusätzlichen Schritte des TLB-Nachschlagens und des Tag-Lesens erfordert.
Das Zeitdiagramm gemäß 1 veranschaulicht den Pipelinefluß zweier Befehle: eines Speicherladebefehls ("Ld") und eines Additionsbefehls ("Add"). Der Speicherladebefehl ist ein Zwei-Zyklus-Befehl, der Additionsbefehl ist ein Ein-Zyklus-Befehl, und der Additionsbefehl ist von dem Ladebefehl abhängig. Zum Zeitpunkt 0 (d. h. des ersten Taktzyklus) wird Ld eingeplant und abgefertigt (Pipelinestufe 12). Zu Zeitpunkt 1, Zeitpunkt 2 und Zeitpunkt 3 bewegt sich Ld durch die Pipelinestufen 14, 16 bzw. 18. Zum Zeitpunkt 4 befindet sich Ld an der Pipelinestufe 20. Zum Zeitpunkt 5 ist Ld an der Stufe 22, und das Treffer/Fehlerversuch-Signal wird erzeugt. Der Einplaner 10 empfängt dieses Signal. Unter der Annahme, daß ein Treffer-Signal empfangen wird, das anzeigt, daß die Daten die richtig waren, plant schließlich zum Zeitpunkt 6 der Einplaner 10 Add in die Stufe 12 ein, während Ld zur Stufe 24 fortfährt, welche eine zusätzliche Pipelinestufe ist. Die Additionsoperation wird schließlich ausgeführt, wenn sich Add an der Stufe 16 befindet. Wenn jedoch zum Zeitpunkt 6 ein Fehlversuch-Signal empfangen wird, wartet der Einplaner 10 eine unbestimmte Anzahl von Taktzyklen, bis die Daten durch Zugriff auf die nächsten Ebenen der Cache-Hierarchie empfangen werden.
Wie es bei dem Zeitdiagramm gemäß 1 gezeigt ist, kann Add, da es von Ld abhängig ist, nicht vor dem Zeitpunkt 6 als frühesten Zeitpunkt eingeplant werden. Eine Verzögerung eines Befehls kann als die Zeitdauer von dem Zeitpunkt, zu dem seine Eingabeoperanden für seine Ausführung bereitstehen müssen, bis zu dem Zeitpunkt, zu dem sein Ergebnis bereit ist, von einem weiteren Befehl verwendet zu werden, definiert werden. Folglich ist die Verzögerung von Ld bei dem Beispiel gemäß 1 gleich 6. Darüber hinaus kann, wie es in 1 gezeigt ist, der Einplaner 10 Add nicht einplanen, bis er das Treffer/Fehlversuch-Signal empfängt. Folglich bleibt selbst dann, wenn die zum Lesen der Daten aus einem Cache erforderliche Zeit bei einer verbesserten Cache-Technologie sinkt, die Verzögerung von Ld bei 6, da sie von dem Treffer/Fehlversuch-Signal abhängig ist.
Die Verringerung der Verzögerungen (Latenzen) von Befehlen in einem Prozessor ist manchmal erforderlich, um die Operationsgeschwindigkeit eines Prozessors zu erhöhen. Beispielsweise sei angenommen, daß ein Teil eines Programms eine Sequenz von N Befehlen, I₁, I₂, I₃, .., I_N, enthält. Es sei angenommen, daß I_n+1 als Teil seiner Eingaben das Ergebnis von I_n für sämtliche n von 1 bis N-1 erfordert. Dieser Teil des Programms kann darüber hinaus irgendwelche weiteren Befehle enthalten. Das Programm kann nicht in einer geringeren Zeit als T = L₁ + L₂ + L₃ + ... + L_N ausgeführt werden, wobei L_n die Verzögerung (Latenz) des Befehls I_n für sämtliche n von 1 bis N ist. Tatsächlich bleibt selbst dann, wenn der Prozessor in der Lage wäre, eine sehr große Anzahl von Befehlen parallel auszuführen, T eine untere Grenze für die Zeitdauer zum Ausführen dieses Teils dieses Programms. Um somit dieses Programm schneller auszuführen, ist es schließlich wesentlich, die Verzögerungen der Befehle abzukürzen.
Aufgrund dieser vorgenannten Umstände besteht ein Erfordernis nach einem Computerprozessor, der Befehle, insbesondere abhängige Befehle, schneller als bekannte Prozessoren einplanen kann und folglich die Verzögerungen der Befehle reduziert. Der Erfindung liegt die Aufgabe zugrunde, die aus der eingangs genannten Veröffentlichung WO 98/21684 A1 bekannte Lösung zu verbessern, insbesondere die jeweils einzuführende Verzögerung des Befehls im Wiederholsystem auf einfache Weise einstellbar zu machen, so daß eine Optimierung des Zeitpunkts des Wieder-Eingebens des Befehls in die Ausführungseinheit ermöglicht wird.
Diese Aufgabe wird erfindungsgemäß durch einen Computerprozessor mit den Merkmalen des Anspruchs 1 bzw. ein Verfahren mit den Merkmalen des Anspruchs 8 gelöst.
Vorteilhafte und/oder bevorzugte Weiterbildungen der Erfindung sind in den Unteransprüchen gekennzeichnet.
1 ist eine Blockdarstellung einer bekannten Prozessorpipeline und eines Zeitdiagramms, das die durch abhängige Befehle bei den meisten bekannten Prozessoren verursachte Verzögerung veranschaulicht.
2 ist eine Blockdarstellung einer Prozessorpipeline und eines Zeitdiagramms gemäß einem Ausführungsbeispiel der vorliegenden Erfindung.
3 ist ein Blockschaltbild eines Prozessors gemäß einem Ausführungsbeispiel der vorliegenden Erfindung.
4 ist eine Blockdarstellung, die die Stufen einer Ausführungseinheit und die parallelen Stufen eines Wiederholsystems gemäß einem Ausführungsbeispiel der vorliegenden Erfindung veranschaulicht.
5 ist ein Blockschaltbild eines Prozessors gemäß einem weiteren Ausführungsbeispiel der vorliegenden Erfindung.
6 ist eine Blockdarstellung einer Speicherladeeinheitspipeline und eines Speichersubsystems des Prozessors und der parallelen Stufen des Wiederholsystems und einer ALU-Einheit gemäß einem Ausführungsbeispiel der vorliegenden Erfindung.
DETAILLIERTE BESCHREIBUNG
Ein Ausführungsbeispiel der vorliegenden Erfindung ist ein Prozessor, der spekulativ Befehle einplant und der ein Wiederholsystem enthält. Das Wiederholsystem (replay system) wiederholt Befehle, die nicht richtig ausgeführt wurden, nachdem sie anfänglich an eine Ausführungseinheit abgefertigt wurden. Darüber hinaus bewahrt das Wiederholsystem die ursprünglich eingeplante Reihenfolge der Befehle.
2 ist eine Blockdarstellung einer Prozessorpipeline und eines Zeitdiagramms gemäß einem Ausführungsbeispiel der vorliegenden Erfindung. Gemäß 2 plant ein Einplaner 30 Befehle zu den Pipelinestufen 12, 14, 16, 18, 20, 22 und 24 ein, welche in ihrer Funktion identisch den in 1 gezeigten Stufen sind. Das Zeitdiagramm von 2 veranschaulicht ein Zwei-Zyklus-Ld gefolgt von einem Ein-Zyklus-Add. Der Einplaner 30 plant Add spekulativ ein, ohne auf ein Treffer/Fehlversuch-Signal von Ld zu warten. Folglich wird Add zum Zeitpunkt 2 eingeplant, so daß ein Zwei-Stufen-Abstand zu Ld aufrechterhalten wird, da Ld ein Zwei-Zyklus-Befehl ist. Add wird schließlich zum Zeitpunkt 4 ausgeführt, wenn es bei der Stufe 16 eintrifft, was einen Zyklus nach dem Ausführen des Cache-Lesens durch Ld bei der Stufe 18 ist.
Durch spekulatives Einplanen von Add unterstellt der Einplaner 30, daß Ld richtig ausgeführt wird (d. h., daß die richtigen Daten aus dem Cache bei der Stufe 18 gelesen werden). Ein Vergleich von 2 mit 1 veranschaulicht die Vorteile der spekulativen Einplanung von Add. Insbesondere wurde bei 1 der Add-Befehl nicht bis zum Zeitpunkt 6 eingeplant, so daß Ld eine Verzögerung (Latenz) von 6 hatte. Im Gegensatz dazu wurde bei 2 der Add-Befehl zum Zeitpunkt 2 eingeplant, womit Ld eine Verzögerung von nur 2 hatte, d. h. eine um 4 geringere Verzögerung als die von Ld bei 1. Darüber hinaus weist der Einplaner 30 in 2 Zeitschlitze (slots) auf, die zum Einplanen zusätz licher Befehle zwischen den Zeitpunkten 3 und 6 verfügbar sind, während der Einplaner 10 bei 1 nur in der Lage war, einen Additionsbefehl zum Zeitpunkt 6 einzuplanen. Folglich verringert die vorliegende Erfindung durch spekulatives Einplanen die Verzögerung (Latenz) von Befehlen und ist in der Lage, mehr Befehle einzuplanen und zu verarbeiten als der Stand der Technik.
Jedoch muß die vorliegende Erfindung die Situation berücksichtigen, wenn ein Befehl unter Annahme, daß er richtig ausgeführt wird, spekulativ eingeplant wurde, aber schließlich nicht korrekt ausgeführt wird (z. B. in dem Falle eines Cache-Fehlversuchs). Die vorliegende Erfindung löst dieses Problem, indem sie ein Wiederholsystem aufweist. Das Wiederholsystem wiederholt sämtliche Befehle, die falsch ausgeführt wurden.
3 ist ein Blockschaltbild eines Computerprozessors gemäß einem Ausführungsbeispiel der vorliegenden Erfindung. Der Prozessor 50 ist in einem Computersystem 99 enthalten. Der Prozessor 50 ist mit weiteren Komponenten des Computers 99 gekoppelt, wie beispielsweise einer (nicht gezeigten) Speichereinrichtung über einen Systembus 98.
Der Prozessor 50 enthält eine Befehlswarteschlange 52. Die Befehlswarteschlange 52 speist Befehle in den Einplaner 30 ein. Bei einem Ausführungsbeispiel sind die Befehle "Mikrooperationen". Mikrooperationen werden durch Übersetzung komplexer Befehle in einfache Befehle fester Länge aus Gründen der Vereinfachung der Ausführung erzeugt.
Der Einplaner 30 fertigt einen aus der Befehlswarteschlange 52 empfangenen Befehl ab, wenn die Ressourcen verfügbar sind, um den Befehl auszuführen, und wenn für die durch den Befehl benötigten Quellen angezeigt wird, daß sie bereit sind. Der Einplaner 30 ist mit einer Anzeigetafel (scoreboard) 54 gekoppelt. Die Anzeigetafel 54 zeigt die Bereitschaft jeder Quelle (d. h. jedes Registers) in dem Prozessor 50 an.
Bei einem Ausführungsbeispiel weist die Anzeigetafel 54 ein Bit für jedes Register zu, und sofern das Bit eine "1" ist, ist das Register als bereit angezeigt. Der Einplaner 30 plant die Befehle auf der Grundlage des Status der Register gemäß der Anzeigetafel ein. Beispielsweise sei angenommen, daß ein Befehl "Ld X → Reg-3" (d. h. das Laden des Werts im Speicherplatz "X" in das Register 3) von einem Befehl "Add Reg-3 → Reg-4" (d. h. das Addieren des Werts im Register 3 zu dem Wert im Register 4 und sein Speichern im Register 4) gefolgt wird. Der Add-Befehl ist von dem Ld-Befehl abhängig, weil Reg-3 bereit sein muß, bevor der Add-Befehl ausgeführt wird. Der Einplaner 30 wird zunächst den Ld-Befehl einplanen, welcher ein Zwei-Zyklus-Befehl ist. Der Einplaner 30 wird dann die Anzeigetafel 54 bei jedem Zyklus überprüfen, um zu bestimmen, ob Reg-3 bereit ist. Die Anzeigetafel 54 wird bis zum zweiten Zyklus nicht anzeigen, daß Reg-3 bereit ist, weil Ld ein Zwei-Zyklus-Befehl ist. Auf dem zweiten Zyklus überprüft der Einplaner 30 die Anzeigetafel 54 erneut, sieht die Anzeige, daß Reg-3 jetzt bereit ist, und plant den Add-Befehl auf diesem Zyklus ein. Folglich ist der Einplaner 30 über die Verwendung der Anzeigetafel 54 in der Lage, Befehle in der richtigen Reihenfolge mit einer richtigen Beabstandung einzuplanen.
Der Einplaner 30 plant Befehle spekulativ ein, da die Befehle eingeplant werden, wenn eine Quelle von der Anzeigetafel 54 als bereit angezeigt wird. Jedoch bestimmt der Einplaner 30 nicht, ob eine Quelle tatsächlich bereit ist, bevor er einen Befehl, der die Quelle benötigt, einplant. Beispielsweise kann ein Lade-Befehl ein Zwei-Zyklus-Befehl sein. Dies kann bedeuten, daß die richtigen Daten in ein Register in zwei Zyklen (nicht gezählt die Abfertigungs- und Decodierstufe) geladen wird, sofern die richtigen Daten in einer ersten Ebene des Speichers gefunden werden (beispielsweise durch einen Treffer eines primären Cache). Die Anzeigetafel 54 zeigt an, daß die Quelle nach zwei Zy klen bereit ist. Wenn jedoch die richtigen Daten nicht in der ersten Ebene des Speichers gefunden wurden (beispielsweise ein Fehlversuch des primären Cache auftritt), ist die Quelle tatsächlich nicht nach zwei Zyklen bereit. Jedoch wird der Einplaner 30 auf der Grundlage der Anzeigetafel 54 den Befehl dennoch spekulativ einplanen.
Der Einplaner 30 gibt den Befehl an einen Wiederhol-Multiplexer 56 aus. Der Ausgang des Multiplexers 56 ist mit einer Ausführungseinheit 58 gekoppelt. Die Ausführungseinheit 58 führt die empfangenen Befehle aus. Die Ausführungseinheit 58 kann eine arithmetisch-logische Einheit (ALU), eine Gleitkomma-ALU, eine Speichereinheit, etc. sein. Die Ausführungseinheit 58 ist mit den Registern 60 gekoppelt, welches die Register des Prozessors 50 sind. Die Ausführungseinheit 58 lädt und speichert Daten in den Registern 60, wenn sie Befehle ausführt.
Der Prozessor 50 enthält ferner ein Wiederholsystem 70. Das Wiederholsystem 70 wiederholt Befehle, die nicht richtig ausgeführt wurden, nachdem sie von dem Einplaner 30 eingeplant worden sind. Das Wiederholsystem 70 empfängt wie auch die Ausführungseinheit 58 von dem Wiederhol-Multiplexer 58 ausgegebene Befehle. Das Wiederholsystem 70 enthält zwei Stufungsabschnitte (staging sections). Ein Stufungsabschnitt enthält eine Mehrzahl von Stufen 80–83. Der andere Stufungsabschnitt enthält die Stufen 84 und 85. Folglich werden Befehle parallel zu der stufenweisen Durchleitung durch die Ausführungseinheit 58 stufenweise durch das Wiederholsystem 70 hindurch geleitet. Die Anzahl der Stufen 80–85 variiert in Abhängigkeit von der in jedem Ausführungskanal gewünschten Anzahl von Stufen.
Das Wiederholsystem 70 enthält ferner einen Überprüfer (checker) 72. Der Überprüfer 72 empfängt die Befehle aus der Stufe 83 und bestimmt, ob der jeweilige Befehl richtig ausgeführt worden ist. Sofern der Befehl richtig ausgeführt worden ist, deklariert der Überprüfer 72 den Befehl als "Wiederhol-Sicher", und der Befehl wird an eine Abschlußeinheit (retirement unit) 62 weitergeleitet, wo er abgeschlossen wird. Da Abschließen (retiring) von Befehlen ist für den Prozessor 50 vorteilhaft, da es Prozessorressourcen freisetzt und es weiteren Befehlen ermöglicht, die Ausführung zu beginnen. Sofern der Befehl nicht korrekt ausgeführt worden ist, wiederholt der Überprüfer 72 den Befehl oder führt ihn erneut aus, indem er dem Befehl an den Wiederhol-Multiplexer 56 über die Stufen 84 und 85 sendet.
In Verbindung mit dem Senden des wiederholten Befehls an den Wiederhol-Multiplexer 56 sendet der Überprüfer 72 ein "Stoppe-Einplaner"-Signal 75 an den Einplaner 30. Das Stoppe-Einplaner-Signal 75 wird wenigstens einen Taktzyklus, bevor der wiederholte Befehl bei dem Wiederhol-Multiplexer 56 eintrifft, gesendet. Bei einem Ausführungsbeispiel teilt das Stoppe-Einplaner-Signal 75 dem Einplaner 30 mit, daß dieser auf dem nächsten Taktzyklus keinen Befehl einplanen soll. Bei anderen Ausführungsbeispielen teilt das Stoppe-Einplaner-Signal 75 dem Einplaner 30 mit, bei dem Taktzyklus nach dem nächsten Taktzyklus, oder dem Taktzyklus danach, etc., keinen Befehl einzuplanen, was davon abhängig ist, wie weit vor dem wiederholten Befehl im voraus der Einplaner 72 das Stoppe-Einplaner-Signal 75 sendet. Dies erzeugt einen offenen Zeitschlitz (slot) für den wiederholten Befehl, der aus dem Wiederhol-Multiplexer 56 ausgegeben wird, und vermeidet, daß dem Wiederhol-Multiplexer 56 zwei Befehle auf dem gleichen Taktzyklus eingegeben werden.
Es gibt viele Gründe, weshalb ein Befehl möglicherweise nicht korrekt ausgeführt wird. Die üblichsten Gründe sind die Quellenabhängigkeit oder eine externe Wiederholbedingung. Eine Quellenabhängigkeit kann auftreten, wenn eine Befehlsquelle vom Ergebnis eines anderen Befehls abhängig ist. Beispiele einer externen Wiederholbedingung umfassen einen Cache-Fehlversuch, das fehlerhafte Weiterleiten von Daten (z. B. aus einem Speicherpuffer zu einem Laden), ver steckte Speicherabhängigkeiten, ein Rückschreibkonflikt, unbekannte Daten, eine unbekannte Adresse und die Serialisierung von Befehlen.
Der Überprüfer 72 kann auf der Grundlage eines externen Signals (Wiederholsignal 78) feststellen, daß ein Befehl wiederholt werden sollte. Die Ausführungseinheit 58 sendet das Wiederholsignal 78 an den Überprüfer 72. Das Wiederholsignal 78 zeigt an, ob ein Befehl richtig ausgeführt worden ist oder nicht. Das Wiederholsignal 78 wird so stufenweise weitergeleitet, daß es bei dem Überprüfer 72 zu demselben Zeitpunkt eintrifft, zu dem der fragliche Befehl an dem Überprüfer 72 eintrifft. Wenn beispielsweise der fragliche Befehl ein Ld ist, ist das Wiederholsignal 78 ein Treffer/Fehlversuch-Signal. Der Ld-Befehl wird in dem Wiederholsystem 70 derart gestuft weitergeleitet, daß er bei dem Überprüfer 72 zu dem gleichen Zeitpunkt eintrifft, zu dem das Treffer/Fehlversuch-Signal für diesen Ld-Befehl von der Ausführungseinheit 58 erzeugt wird. Folglich kann der Überprüfer 72 auf der Grundlage des empfangenen Treffer/Fehlversuch-Signals feststellen, ob der Ld-Befehl wiederholt werden soll.
Der Überprüfer 72 ist darüber hinaus mit einer Anzeigetafel 74 gekoppelt, welche wie die Anzeigetafel 54 anzeigt, welche Register gültige Daten haben. Unter Verwendung der Anzeigetafel 74 kann der Überprüfer 72 bestimmen, daß ein Befehl nicht korrekt ausgeführt worden ist, weil die Daten in dem erforderlichen Register nicht gültig sind. Wenn beispielsweise ein Ld-Befehl ein Fehlversuch war und der nächste durch den Überprüfer 72 empfangene Befehl ein Add-Befehl ist, der von dem Ld-Befehl abhängig ist, stellt der Überprüfer 72 unter Verwendung der Anzeigetafel 74 fest, daß der Add-Befehl nicht korrekt ausgeführt wurde, weil die von dem Add-Befehl benötigten Daten in dem Register nicht gültig sind.
Bei einem Ausführungsbeispiel ist der Prozessor 50 ein Mehr-Kanal-Prozessor. Jeder Kanal enthält sämtliche der in 3 gezeigten Komponenten. Jedoch unterscheidet sich die Ausführungseinheit 58 für jeden Kanal. Beispielsweise ist die Ausführungseinheit 58 für einen Kanal eine Speichereinheit, die Ausführungseinheit 58 für einen weiteren Kanal eine arithmetische Einheit, etc. Jeder Kanal enthält sein eigenes Wiederholsystem 70.
Bei einem Ausführungsbeispiel ist der Prozessor 50 ein Multi-Threaded-Prozessor. Bei diesem Ausführungsbeispiel bewirkt der Überprüfer 72, daß einige der Threads abgeschlossen (retired) werden, während andere wiederholt werden. Folglich ermöglicht es der Überprüfer 72, daß die Ausführungseinheit 58 effektiver durch viele Threads verwendet wird.
4 ist eine Blockdarstellung, die die Stufen der Ausführungseinheit 58 und die parallelen Stufen des Wiederholsystems 70 gemäß einem Ausführungsbeispiel der vorliegenden Erfindung veranschaulicht. Beispielsweise ist ein Befehl an der Decodierstufe 14 der Ausführungseinheit 58 parallel an der Stufe A (d. h. Stufe 80) des Wiederholsystems 70. Darüber hinaus ist ein Befehl an der Treffer/Fehlversuch-Stufe 22 der Ausführungseinheit 58 parallel an dem Überprüfer 72 des Wiederholsystems 70. Zu Zwecken der Vereinfachung enthält das Wiederholsystem, dessen Stufen in 4 gezeigt sind, keine Stufen E und F (d. h. Stufen 84 und 85) des Wiederholsystems 70 gemäß 3. Folglich werden die Befehle, die von dem Überprüfer 72 wiederholt werden, bei dem Wiederhol-Multiplexer 56 auf dem nächsten Taktzyklus neu abgefertigt, ohne gestuft weitergeleitet zu werden.
4 veranschaulicht darüber hinaus ein Zeitdiagramm des folgenden Satzes von Befehlen mit den folgenden Abhängigkeiten:

Programmreihenfolge Abhängigkeiten

Ld1

Add1 von Ld1

Add2 von Add1

Add3 von Add2

Add4 von Add3

Ld2

Add5 von Add4

Add6 von Add5
Die Ladebefehle ("Ld") sind Zwei-Zyklus-Befehle und die Additionsbefehle ("Add") sind Ein-Zyklus-Befehle. Wie es gezeigt ist, ist Add1 abhängig von Ld1, Add2 abhängig von Add1, etc.
Gemäß dem Zeitdiagramm der 4 wird zum Zeitpunkt 0 Ld1 abgefertigt. Zum Zeitpunkt 1 bewegt sich Ld1 zur Decodierstufe 14 der Ausführungseinheit 58 und zur Stufe A des Wiederholsystems 70. Zum Zeitpunkt 2 wird Add1 eingeplant, da Ld1 ein Zwei-Zyklus-Befehl ist. In ähnlicher Weise werden zum Zeitpunkt 3 und 4 Add2 bzw. Add3 eingeplant. Zum Zeitpunkt 5 ist Ld1 an der Treffer/Fehlversuch-Stufe 22 und am Überprüfer 72 des Wiederholsystems. Es sei angenommen, daß ein Fehlversuch-Signal zum Zeitpunkt 5 empfangen wird. Das Fehlversuch-Signal (welches das Wiederholsignal 78 gemäß 3 ist) wird von dem Überprüfer 72 empfangen. Der Überprüfer 72 bestimmt auf der Grundlage des Fehlversuch-Signals, daß Ld1 falsch ausgeführt worden ist, und wiederholt Ld1 zum Zeitpunkt 5. Ebenfalls zum Zeitpunkt 5 sendet der Überprüfer 72 ein Stoppe-Einplaner-Signal 75 an den Einplaner 30, welches dem Einplaner 30 signalisiert, daß dieser keinen Befehl beim nächsten Zyklus (d. h. zum Zeitpunkt 6) einplanen soll.
Zum Zeitpunkt 6 kehrt Ld1 zur Abfertigungsstufe 12 zurück. Man beachte, daß der Einplaner 30 zum Zeitpunkt 6 keinen Befehl einplante, so daß Ld1 in der Lage war, den vakanten Zeitschlitz zu belegen. Zum Zeitpunkt 7 wird Add5 eingeplant und Add1 befindet sich am Überprüfer 72. Der Überprüfer 72 bestimmt unter Verwendung der Anzeigetafel 74, daß Add1 falsch ausgeführt worden ist, weil Add1 von Ld1 abhängig war. Da Ld1 falsch ausgeführt wurde, zeigt die Anzeigetafel 74 an, daß die von Add1 benötigten Daten in dem Register ungültig sind. Folglich wiederholt der Überprüfer 72 Add1 zum Zeitpunkt 7, während ein weiteres Stoppe-Einplaner-Signal 75 an den Einplaner 30 gesendet wird. In ähnlicher Weise wiederholt der Überprüfer 72 zum Zeitpunkt 8 Add2, zum Zeitpunkt 9 wiederholt der Überprüfer 72 Add3, und zum Zeitpunkt 10 wiederholt der Überprüfer 72 Add4.
Zum Zeitpunkt 11 ist Ld1 erneut beim Überprüfer 72. Diesmal empfängt der Überprüfer 72 ein Treffer-Signal, welches anzeigt, daß Ld1 richtig ausgeführt worden ist. Folglich kann zum Zeitpunkt 12, da keine Befehle von dem Überprüfer 72 zum Zeitpunkt 11 wiederholt würden, der Einplaner 30 schließlich Ld2 einplanen (mehrere Ladeoperationen können gleichzeitig in der Pipeline sein). Mittlerweile bewegt sich Ld1 zur Abschlußeinheit (retirement unit) 62. Darüber hinaus stellt der Überprüfer 72 zum Zeitpunkt 12 fest, daß Add5 falsch ausgeführt worden ist, weil Add5 von Ld1 abhängig ist. Folglich wiederholt der Überprüfer 72 Add5 zum Zeitpunkt 12.
Zum Zeitpunkt 13 kehrt Add5 zur Abfertigung 12 zurück und Add1 ist beim Überprüfer 72. Diesmal stellt der Überprüfer 72 fest, daß Add1 richtig ausgeführt worden ist, da die Anzeigetafel 74 anzeigt, daß das Register gültige Daten aufweist. Zum Zeitpunkt 14 wird Add6 abgefertigt und Add1 wird abgeschlossen (retired). Von Zeitpunkt 15 bis zum Zeitpunkt 20 werden die verbleibenden Befehle in der Pipeline richtig ausgeführt und schließlich sämtlich abgeschlossen.
Wie es in 4 gezeigt ist, wird die eingeplante Reihenfolge der Befehle stets von dem Wiederholsystem 70 bewahrt. Beispielsweise werden Add1, Add2 und Add3 stets nach Ld1 ausgeführt und Add1 bleibt stets zwei Stufen hinter Ld1. Darüber hinaus fügt das Wiederholsystem 70 über das Stoppe-Einplaner-Signal 75 wiederholte Befehle in leere Zeitschlitze ein, in denen der Einplaner 30 keinen Befehl einplant.
5 ist ein Blockschaltbild eines Prozessors 100 gemäß einem weiteren Ausführungsbeispiel der Erfindung. 5 veranschaulicht ein Ausführungsbeispiel, bei welchem die Ausführungseinheit 58 gemäß 3 eine Speicherladeeinheit ist, und jede Stufe der Speicherladeeinheit ist gezeigt. Darüber hinaus veranschaulicht 5 einige Komponenten eines Speichersubsystems, das von der Speicherladeeinheit benötigt wird.
Wenn ein Speicherladebefehl von dem Einplaner 30 in 5 eingeplant oder abgefertigt wird, wird der Befehl von dem Wiederhol-Multiplexer 56 ausgegeben und parallel zu der Speicherladeeinheit und dem Wiederholsystem 70 gesendet. In der Speicherladeeinheit wird der Befehl zunächst decodiert und die Quellenregister werden in einer Decodiereinheit 110 gelesen. Eine Speicheradresse wird von der Adreßerzeugungseinheit 112 erzeugt. Die erzeugt Adresse wird an eine TLB-Einheit 114 gesendet, welche ein Nachschlagen des TLB ausführt und eine physikalische Tag-Adresse erzeugt. Die erzeugte Adresse wird darüber hinaus an den L0-Cache 128 gesendet. Der L0-Cache 128 ist der primäre Cache des Prozessors 100 und liefert folglich den schnellsten Zugriff. Bei einem Ausführungsbeispiel ist der L0-Cache 128 auf dem gleichen Chip wie der Prozessor 100. Die aus dem L0-Cache 128 auf der Grundlage der erzeugten Adresse wiedergewonnenen (gelesenen) Daten werden an das in dem Ladebefehl spezifizierte Register in den Registern 60 gesendet.
Die von der TLB-Einheit 114 erzeugte physikalische Adresse wird an den Tag-Speicher 116 gesendet. Das aus dem Tag-Speicher 116 gelesene Cache-Tag wird an die Treffer/Fehlversuch-Logik 118 gesendet, welche feststellt, ob es einen Treffer oder einen Fehlversuch des L0-Cache 128 gibt. Die Bestimmung des Treffers bzw. Fehlversuchs wird an den Überprüfer 72 auf Leitung 78 gesendet, welche als Wiederholsignal an den Überprüfer 72 fungiert. Wenn darüber hinaus es einen Fehlversuch des L0-Cache 128 gab, bestimmt die Treffer/Fehlversuch-Logik 118, ob es einen Treffer oder Fehlversuch eines L1-Cache 124 für die physikalische Adresse gibt. Der L1-Cache 124 ist ein sekundärer Cache des Prozessors 100 und benötigt für einen Zugriff üblicherweise 4–16 mal so lange wie der L0-Cache 128. Bei einem Ausführungsbeispiel befindet sich der L1-Cache 124 auf dem gleichen Chip wie der Prozessor 100. Daten werden aus dem L1-Cache 124 wiedergewonnen und auf einem Wiederauffüllpfad in einen Auffüllpuffer 126 gesendet und dann in dem L0-Cache 128 gespeichert.
Wenn es einen Fehlversuch des L1-Cache 124 gab, fordert ein Anforderungspuffer die Daten aus der nächsten Ebene des Speichers, dem L2-Cache 122 an. Der L2-Cache 122 befindet sich außerhalb des Prozessors 100 und erfordert eine Zugriff auf einen externen Bus. Im Falle eines Fehlversuchs des L2-Cache 122 werden die Daten aus einem anderen externen Speicher 124 gewonnen, welcher den Hauptspeicher, Plattenlaufwerke und sämtliche anderen Speicher außerhalb des Prozessors 100 einschließt. Ein Zugreifen auf die Daten aus dem L2-Cache 122 oder aus anderen externen Speichereinheiten 124 benötigt im Vergleich zu einem L1-Cache 124 wenigstens 4–16 mal so lange. Die aus dem L2-Cache 122 oder aus einem anderen externen Speicher 124 wiedergewonnenen Daten füllen den L1-Cache 124 und den L0-Cache 128 über einen Wiederauffüllpfad, der in 5 nicht gezeigt ist, erneut.
Bei einem Ausführungsbeispiel des Prozessors 100 leiten die Stufen 80–85 die Befehle durch das Wiederholsystem 70 stufenweise weiter, so daß es für einen Speicherladebefehl optimiert wird. Insbesondere empfangen bei diesem Ausführungsbeispiel die meisten Speicherladebefehle (etwa 90%) einen Treffer des L0-Cache 128, und folglich wird der Spei cherladebefehl nicht wiederholt. Von den Speicherladebefehlen, die einen Fehlversuch des L0-Cache 128 erhalten, werden die meisten dieser Befehle (etwa 70% der 10% verbleibenden Befehle) einen Treffer des L1-Cache 124 empfangen. Folglich ist das Wiederholsystem 70 für einen L0-Cache-Fehlversuch und einen L1-Cache-Treffer optimiert.
Die Wirkung dieser Optimierung ist in 6 veranschaulicht. 6 ist eine Blockdarstellung der Speicherladeeinheitspipeline und des Speichersubsystems des Prozessors 100 und der parallelen Stufen des Wiederholsystems 70 und einer ALU-Einheit. Beispielsweise ist ein Speicherladebefehl an der Adreßerzeugungsstufe 112 der Speicherladepipeline, während parallel der Befehl sich an der Stufe B (d. h. der Stufungswarteschlange 81) des Wiederholsystems 70 befindet. Zusätzlich zu den in 4 gezeigten Pipelinestufen enthält die Speicherladeeinheitspipeline gemäß 6 die Stufen der L1-Cache-Anforderung 120, des L1-Cache-Lesens 124, der L1-Treffer/Fehlversuch-Anzeige 118, der L1-Rückgabe 126 (d. h., die Daten werden aus dem L1-Cache 124 zurückgegeben, um den Puffer 126 neu aufzufüllen) und des L0-Cache-Neuauffüllens 128. Die Bezugszeichen in der Pipeline entsprechen den Komponenten gemäß 5, die die Stufenfunktion implementieren.
6 veranschaulicht darüber hinaus ein Zeitdiagramm eines Zwei-Zyklus-Ladebefehls ("Ld"), der von einem abhängigen Additionsbefehl ("Add") gefolgt wird, für die übliche Situation eines Fehlversuchs des L0-Caches 128 und eines Treffers bei dem L1-Cache 124. Zum Zeitpunkt 0 wird Ld von dem Einplaner 30 abgefertigt. Zum Zeitpunkt 1 ist Ld am Decodierer 110 der Speicherladeeinheit und an der Stufe A (d. h. der Stufungswarteschlange 80) des Wiederholsystems 70. Zum Zeitpunkt 2 wird Add abgefertigt. Zum Zeitpunkt 3 und 4 schreiten Ld und Add in ihren jeweiligen Pipelines voran. Zum Zeitpunkt 5 befindet sich Ld am Überprüfer 72. Der Überprüfer 72 empfängt ein Fehlversuch-Signal zum Zeitpunkt 5 (wegen des Fehlversuchs bei dem L0-Cache 128) und wiederholt folglich Ld.
Zum Zeitpunkt 7 ist Ld an der Stufe E (d. h. in der Stufungswarteschlange 84) des Wiederholsystems 70 und am Anforderungspuffer 120 der Speicherladeeinheit, die eine Anforderung des L1-Cache 124 durchführt, weil es einen Fehlversuch bei dem L0-Cache 128 gab. Zum Zeitpunkt 7 wird Add vom Überprüfer 72 wiederholt und Ld ist an der Stufe F (d. h. der Stufungswarteschlange 85), und das Speichersubsystem führt ein L1-Lesen 124 durch. Zum Zeitpunkt 8 wird Ld erneut abgefertigt, und das Speicherladesystem führt einen L1-Cache-Treffer/Fehlversuch 118 durch. Ebenfalls zum Zeitpunkt 8 wird ein L1-Cache-Treffer empfangen. Zum Zeitpunkt 9 ist das wiederholte Ld berim Decodieren 110 und an der Stufe A. Mittlerweile wird in dem Speichersubsystem ein L1-Rückgeben 126 ebenfalls zum Zeitpunkt 9 durchgeführt. Zum Zeitpunkt 10 wird Add erneut abgefertigt, und es wird von dem Speichersubsystem ein L0-Neuauffüllen 128 durchgeführt. Zum Zeitpunkt 11 ist Ld beim Lesen des L0-Cache 128. Selbstverständlich werden jetzt, da das Auffüllen L0-Cache 128 bei dem vorhergehenden Zyklus (zum Zeitpunkt 10) durchgeführt wurde, die richtigen Daten aus dem L0-Cache 128 gelesen und in dem Register gespeichert. Folglich wird zum Zeitpunkt 13 ein Treffer des L0-Cache 128 von dem Überprüfer 72 empfangen, und das Ld ist jetzt wiederhol-sicher (replay safe). Zu den Zeitpunkten 14, 15 und 16 werden Ld und Add aufeinanderfolgend abgeschlossen (retired).
Wie es in 6 gezeigt ist, verzögern die Stufen E und F das Wiederabfertigen von Ld um zwei Zyklen. Dies ermöglicht, daß das Neuauffüllen des L0-Cache gerade rechtzeitig auftritt, so daß für den Ld ein L0-Cache-Lesen beim zweiten Durchlauf ausgeführt wird. Ld erhält dann einen L0-Cache-Treffer und braucht nicht erneut wiederholt zu werden. Sofern das Wiederholsystem 70 nicht optimiert würde, kann es sein, daß Ld ein L0-Cache-Lesen durchführt, bevor der L0- Cache erneut aufgefüllt ist. Ld würde dann erneut wiederholt werden, was die richtige Ausführung von Ld verzögert und andere Threads am Verwenden der Ressourcen hindert. Somit wird das Wiederholsystem 70 für die häufigste Wiederholsituation optimiert, nämlich einen L0-Cache-Fehlversuch und einem L1-Cache-Treffer, so daß Ld nur einmal wiederholt zu werden braucht.
Wie beschrieben, enthält der Prozessor gemäß einem Ausführungsbeispiel der vorliegenden Erfindung ein Wiederholsystem 70, das Befehle wiederholt. Das Wiederholsystem 70 signalisiert dem Einplaner 30, daß dieser keinen Befehl einplanen soll, so daß ein Zeitschlitz für das Einfügen eines wiederholten Befehls erzeugt wird. Somit wird die ursprünglich eingeplante Reihenfolge der Befehle bewahrt. Darüber hinaus ist das Wiederholsystem 70 derart optimiert, daß dann, wenn die häufigste Speicherladebefehlwiederholsituation auftritt (d. h. ein Fehlversuch des L0-Cache 128 und eine Treffer des L1-Cache 124), der Befehl höchstens einmal wiederholt wird.
Verschiedene Ausführungsbeispiele der vorliegenden Erfindung sind hier speziell veranschaulicht und/oder beschrieben. Jedoch ist es klar, daß Modifikationen oder Variationen der vorliegenden Erfindung von den obigen Lehren abgedeckt werden und innerhalb des Umfangs der anhängigen Ansprüche liegen, ohne vom Geist und beabsichtigten Umfang der Erfindung abzuweichen.

Claims

Computerprozessor (50; 100) mit einer Ausführungseinheit (58; 110–118) zum Ausführen von Befehlen, einem Einplaner (30) zum spekulativen Einplanen von Befehlen und einem Wiederholsystem (70), das die wiederholte Ausführung nicht korrekt ausgeführter Befehle bewirkt, wobei ein Multiplexer (56) mit seinem ersten Multiplexereingang mit dem Einplaner (30), mit seinem zweiten Multiplexereingang mit einem Ausgang des Wiederholsystems, an dem zu wiederholende Befehle ausgegeben werden, und mit seinem Multiplexerausgang mit der Ausführungseinheit gekoppelt ist, so daß mit Hilfe des Multiplexers (56) der jeweils an die Ausführungseinheit auszugebende Befehl zwischen einem vom Einplaner (30) ausgegebenen Befehl und einem vom Wiederholsystem (70) ausgegebenen Befehl ausgewählt werden kann, wobei das Wiederholsystem (70) einen Überprüfer (72) enthält, der überprüft, ob ein Befehl korrekt ausgeführt worden ist, wobei der Überprüfer (72) einen „Wiederhol-Sicher"-Ausgang zum Ausgeben eines korrekt ausgeführten Befehls aufweist, und der Überprüfer den Befehl über den Ausgang des Wiederholsystems (70) an den Multiplexer (56) ausgibt, wenn der Befehl nicht korrekt ausgeführt worden ist, dadurch gekennzeichnet, daß das Wiederholsystem einem mehrere Stufen (80–83) aufweisenden Stufungsabschnitt zum getakteten Verzögern aufweist, die zwischen dem Ausgang des Multiplexers (56) und dem Eingang des Überprüfers (72) so eingekoppelt sind, daß die an die Ausführungseinheit ausgegebenen Befehle parallel und verzögert an den Überprüfer (72) weitergeleitet werden, wobei die Anzahl und Taktung der Stufen (80–83) des Stufungsabschnitts und die Anzahl und die Taktung der Stufen (110, 112, 114, 116) der Ausführungseinheit ermöglichen, daß die Befehle zu einem Zeitpunkt bei dem Überprüfer (72) eintreffen, zu dem auch die korrekte Ausführung anzeigende Signale (78) aus der entsprechenden Stufe (118) der Ausführungseinheit bei dem Überprüfer (72) eintreffen, und daß der Überprüfer (72) dann, wenn ein zu wiederholender Befehl ausgegeben wird, ein Stoppe-Einplaner-Signal (75) erzeugt und an den Einplaner (30) sendet, damit dieser einen offenen Slot für den zu wiederholenden Befehl erzeugt, in dem der zu wiederholende Befehl von dem Multiplexer (56) an die Ausführungseinheit ausgegeben wird.
Computerprozessor nach Anspruch 1, dadurch gekennzeichnet, daß die Ausführungseinheit eine Speicherladeeinheit zum Ausführen eines Speicherladebefehls ist und daß zwischen dem Ausgang des Überprüfers (72) und dem Eingang des Multiplexers (56) ein weiterer Stufungsabschnitt mit mehreren Stufen (84, 85) eingekoppelt ist, wobei die Anzahl und Taktung der Stufen des weiteren Stufungsabschnitts so gewählt ist, daß ein über die Stufen des weiteren Stufungsabschnitts zurückgeführter Ladebefehl, der aufgrund eines Fehlversuchs in einem L0-Cache des Prozessors zu wiederholen ist, dann bei seiner Wiederholung so in die Stufen der Ausführungseinheit zurückgeführt wird, daß er zu einem Zeitpunkt auf den L0-Cache zugreift, zu dem dieser mit den benötigten Daten nach einem Treffer in einem nachfolgenden Cache oder Speicher der Speicherhierarchie gefüllt worden ist.
Computerprozessor nach Anspruch 1 oder 2, gekennzeichnet durch eine mit dem "Wiederhol-Sicher"-Ausgang gekoppelte Retirement-Einheit (62).
Computerprozessor nach einem der Ansprüche 1 bis 3, dadurch gekennzeichnet, daß der Prozessor eine Mehrzahl von Registern aufweist, wobei das Wiederholsystem (70) eine Anzeigetafel (74) aufweist, die einen Status der Mehrzahl der Register anzeigt.
Computerprozessor nach einem der Ansprüche 1 bis 4, dadurch gekennzeichnet, daß der Überprüfer (72) so ausgebildet ist, daß er ein Wiederhol-Signal (78) von der Ausführungseinheit (58) empfängt.
Computerprozessor nach einem der Ansprüche 1 bis 5, dadurch gekennzeichnet, daß das Wiederholsystem eine Mehrzahl von Befehlen wiederholt und eine ursprünglich eingeplante Reihenfolge der Mehrzahl von Befehlen bewahrt, indem es eine gleiche Anzahl Pipelinestufen wie die Ausführungseinheit aufweist.
Computerprozessor nach einem der Ansprüche 1 bis 6, gekennzeichnet durch einen ersten Kanal und einen zweiten Kanal; wobei der erste Kanal den Multiplexer, den Einplaner, die Ausführungseinheit und das Wiederholsystem aufweist; und wobei der zweite Kanal einen zweiten Multiplexer, einen zweiten Einplaner, eine zweite Ausführungseinheit und ein zweites Wiederholsystem aufweist.
Verfahren zum Verarbeiten eines Befehls in einem Prozessor (100), wobei: a) der Befehl von einem Einplaner (30) abgefertigt und parallel von einer Ausführungseinheit (58; 110–118) und einem Wiederholsystem (70) empfangen wird, b) der Befehl durch mehrere Stufen der Ausführungseinheit getaktet wird, c) der Befehl parallel zum Schritt b) durch mehrere Stufen eines Stufungsabschnitts (80–83) des Wiederholsystems (70) getaktet wird, bis er bei einem Überprüfer (72) des Wiederholsystems (70) eintrifft, wobei die Anzahl der Stufen (80–83) des Stufungsabschnitts der Anzahl der Stufen (14–20; 110–116) der Ausführungseinheit (58; 110–118) entspricht, so daß der Befehl zu einem Zeitpunkt bei dem Überprüfer (72) eintrifft, zu dem auch ein die korrekte Ausführung des Befehls anzeigendes Signal (78) aus der Ausführungseinheit (58; 110–118) bei dem Überprüfer (72) eintrifft, und dann, d1) wenn das Signal (78) die korrekte Ausführung anzeigt, der Befehl an eine Retirement-Einheit (62) ausgegeben wird, oder d2) wenn das Signal (78) keine korrekte Ausführung anzeigt, von dem Überprüfer (72) ein Stoppe-Einplaner-Signal an den Einplaner (30) ausgegeben wird, woraufhin dieser einen offenen Slot für den zu wiederholenden Befehl erzeugt, und der zu wiederholende Befehl erneut parallel an die Ausführungseinheit (58; 110–118) und das Wiederholsystem (70) ausgegeben wird.
Verfahren nach Anspruch 8, dadurch gekennzeichnet, daß der Prozessor einen primären Cache-Speicher (128) aufweist, der Befehl ein Speicherladebefehl ist, die Ausführungseinheit eine Speicherladeeinheit ist, die Stufen der Speicherladeeinheit (110–118) eine Treffer/Fehlversuch-Logik (118) umfassen, und das die korrekte Ausführung des Speicherladebefehls anzeigende Signal (78) ein Treffer/Fehlversuch-Signal aus der Treffer/Fehlversuch-Logik (118) ist, wobei im Schritt c) der Speicherladebefehl zu einem Zeitpunkt bei dem Überprüfer (72) eintrifft, zu dem auch das Treffer/Fehlversuch-Signal (78) aus der Treffer/Fehlversuch-Logik (118) bei dem Überprüfer (72) eintrifft.
Verfahren nach Anspruch 9, dadurch gekennzeichnet, daß der Prozessor einen sekundären Cache-Speicher (124) aufweist, aus dem der primäre Cache-Speicher (128) im Falle eines Fehlversuchs wieder aufgefüllt wird, sofern ein Treffer im sekundären Cache-Speicher (124) auftritt, wobei der zu wiederholende Speicherladebefehl im Schritt d2) von dem Überprüfer (72) durch einen zweiten Stufungsabschnitt (84, 85) des Wiederholsystems (70) hindurch getaktet wird, bevor er erneut parallel an die Ausführungseinheit (58; 110–118) und das Wiederholsystem (70) ausgegeben wird, wobei die Verzögerung durch den zweiten Stufungsabschnitt (84, 85) so gewählt ist, daß der primäre Cache-Speicher (128) aus dem sekundären Cache-Speicher (124) wieder aufgefüllt ist, bevor der wiederholte Speicherladebefehl die Daten aus dem primären Cache-Speicher (128) liest.