Prozessor-Datenpfad und Pipelining

Ein Datenpfad hält und verändert die Werte, die ein Befehl benötigt. Das Steuerwerk lenkt diese Werte und gibt Schreibzugriffe frei. Zusammen führen sie Befehle wie add, sub, and, or, ld, sd und beq aus.

Verfolge Werte zwischen Taktflanken

Ein Speicherelement merkt sich einen Wert: Beispiele sind der Befehlszähler, der Registersatz und der Datenspeicher. Ein kombinatorisches Schaltungselement erzeugt aus seinen aktuellen Eingaben eine Ausgabe. Addierer, Multiplexer, die ALU und der Direktoperandengenerator erfüllen diese Aufgabe, ohne das Ergebnis eines Befehls zwischen Zyklen zu speichern.

An der aktiven Taktflanke übernehmen Speicherelemente ihre nächsten Werte. Zwischen den Flanken speisen ihre Ausgänge die kombinatorische Logik. Der PC kann daher während eines Zyklus die aktuelle Adresse liefern und an dessen Ende die nächste Adresse übernehmen. Das Lesen eines Speicherelements überschreibt es nicht.

Befehle holen und auf Register zugreifen

Der Befehlszähler (PC) enthält die Befehlsadresse. Der Befehlsspeicher gibt den 32-Bit-Befehl an dieser Adresse zurück. In diesem Modell wird er während der Programmausführung nur gelesen und ordnet einer Adresse einen Befehl zu. Ein separater Addierer bildet PC + 4, weil die Befehle dieser Teilmenge 4 Bytes belegen.

Der Registersatz enthält x0–x31. Zwei Leseports nehmen die Quellregisternummern rs1 und rs2 entgegen und geben ihre Werte zurück. Ein Schreibport erhält das Zielregister rd, die Schreibdaten und RegWrite. Lesezugriffe erfolgen kombinatorisch; ein freigegebener Schreibzugriff wird an der Taktflanke gespeichert. Aus Register x0 wird immer null gelesen; Schreibzugriffe darauf werden verworfen. RV64-Register enthalten 64 Bit. Eine RV32-Version nutzt 32-Bit-Register und lw/sw mit denselben grundlegenden Verbindungen.

Rechnen, auswählen und auf den Speicher zugreifen

Die arithmetisch-logische Einheit (ALU) addiert, subtrahiert oder führt eine bitweise Operation aus. Ein 4-Bit-Steuercode wählt die Operation. Ihr Zero-Ausgang ist 1, wenn das Ergebnis null ist; durch Subtraktion lässt sich daher prüfen, ob zwei Werte gleich sind.

Der Direktoperandengenerator, ImmGen, setzt den Direktoperanden eines Befehls wieder zusammen und erweitert ihn mit Vorzeichen auf 64 Bit. Das Kopieren des Vorzeichenbits erhält einen negativen Wert. Das 12-Bit-Muster 1111 1111 1000 stellt −8 dar; eine Nullerweiterung würde daraus 4088 machen und eine Speicheroperation an die falsche Adresse lenken.

Ein Multiplexer, kurz Mux, wählt einen Eingang aus. Multiplexer wählen den zweiten ALU-Operanden, die Schreibdaten für den Registersatz und den nächsten PC-Wert. Ein Multiplexer ändert den Weg; eine Schreibfreigabe entscheidet, ob sich ein gespeicherter Wert ändert.

Der Datenspeicher hat Eingänge für Adresse und Schreibdaten, einen Ausgang für Lesedaten und die Steuersignale MemRead und MemWrite. Ein Ladebefehl muss im selben einzelnen Zyklus einen Befehl holen und auf Daten zugreifen. Getrennte Befehls- und Datenspeicher ermöglichen beide Zugriffe. Separate Addierer erlauben außerdem die Berechnung von PC + 4 und des Sprungziels, während die ALU andere Arbeit ausführt.

Nicht verwendete Ausgänge können sich während eines Zyklus trotzdem ändern. Eine korrekte Steuerung sorgt dafür, dass nur die ausgewählten Ausgänge zu freigegebenen Schreibzugriffen auf Speicherelemente gelangen. Ein berechneter Wert auf einer nicht ausgewählten Leitung hat keine Auswirkung auf das Programm.

Beginne mit der Frage, was jeder Befehl lesen und was er ändern muss. Der gemeinsame Datenpfad verbindet diese Wege; überall dort, wo alternative Werte auf einen Eingang treffen, steht ein Multiplexer.

Befehle holen und Felder dekodieren

Beim Holen wird der PC verwendet, um den Befehlsspeicher zu lesen; parallel wird PC + 4 berechnet. Der Operationscode belegt die Bits 6–0. Sofern vorhanden, liegt rd in den Bits 11–7, funct3 in 14–12, rs1 in 19–15 und rs2 in 24–20; funct7 beim R-Typ belegt die Bits 31–25. Da die Positionen der Quellfelder gleich bleiben, können Register gelesen werden, während die Steuerung für den Befehl dekodiert wird. Ein Speicherbefehl oder bedingter Sprung hat kein rd-Feld: Die Bits 11–7 tragen zu seinem Direktoperanden bei.

Vergleiche die Ausführungspfade

Bei einem Ladebefehl ist das ALU-Ergebnis eine effektive Adresse, also die Adresse der zu lesenden Daten. Die Speicherausgabe gelangt dann zurück zum Registersatz. Auch ein Speicherbefehl bildet mit der ALU eine Adresse, aber sein zweiter Quellwert gelangt getrennt zum Schreibdateneingang des Speichers. Wird ein Direktoperand als ALU-Operand ausgewählt, darf dieser Speicherwert nicht verworfen werden. ImmGen setzt den Offset im S-Format aus seinen beiden Bitgruppen wieder zusammen.

Ein bedingter Sprung führt zwei Operationen parallel aus. Die ALU subtrahiert die verglichenen Registerwerte; Zero zeigt an, ob sie übereinstimmen. Der Sprungaddierer addiert den vorzeichenbehafteten Byteoffset zum PC-Wert des Sprungbefehls. Die Kodierung im B-Format lässt das stets null gesetzte niederwertigste Bit aus. ImmGen kann den vollständigen Byteoffset einschließlich dieser Null rekonstruieren; eine Darstellung, die den Offset stattdessen in Halbwort-Einheiten erzeugt, benötigt eine Linksverschiebung um ein Bit. Die Verschiebung gehört genau einmal in den Pfad.

Führe die Pfade mit Multiplexern zusammen

ALUSrc wählt entweder den Wert von rs2 oder den Direktoperanden für den zweiten ALU-Eingang. MemtoReg wählt entweder das ALU-Ergebnis oder die Datenspeicherausgabe für das Zurückschreiben in den Registersatz. PCSrc wählt PC + 4 oder das Sprungziel. Zwei konkurrierende Ergebnisse benötigen einen Auswahlschalter, keine direkte Verbindung ihrer Ausgänge.

Diese Pfade zeigen, warum der Ladebefehl die längste Kette hat: Befehl holen, Register lesen, Adresse berechnen, Speicher lesen und Register schreiben tragen alle dazu bei. Arithmetische Befehle umgehen den Datenspeicher; ein Speicherbefehl umgeht das Zurückschreiben in den Registersatz.

Erweitere die bestehenden Wege

addi x5, x6, 3 nutzt den ALU-Pfad für den Direktoperanden und den Rückschreibpfad für das ALU-Ergebnis erneut. Er benötigt eine passende Steuerung, aber keine neue Datenpfadeinheit. jal hat eine zusätzliche Anforderung: Der Befehl schreibt PC + 4 nach rd und lenkt gleichzeitig den PC ohne Gleichheitsprüfung um. Sein Multiplexer für das Zurückschreiben benötigt daher einen Eingang für PC + 4, und die Logik für den nächsten PC-Wert muss einen unbedingten Sprung unterstützen.

Das Nachverfolgen eines Befehls verbindet die Assembleroperation mit konkreten Leitungswerten. Unterscheide Werte, die während des Zyklus berechnet werden, von Werten, die an der abschließenden Taktflanke gespeichert werden.

Verwende eine einheitliche Reihenfolge

1. Hole den Befehl am aktuellen PC-Wert und bestimme seine Felder.
2. Lies die Quellregister und bilde den vorzeichenbehafteten Direktoperanden.
3. Wähle die ALU-Operanden und berechne das Ergebnis.
4. Führe den angeforderten Datenspeicherzugriff aus.
5. Wähle die Schreibdaten für den Registersatz und den nächsten PC-Wert.
6. Liste die Schreibzugriffe auf Speicherelemente an der Taktflanke auf.

Addiere zwei Registerwerte

Bei PC 400 hat add x5, x6, x7 die Kodierung 0x007302B3. Seine Felder sind Operationscode 0110011, rd 5, funct3 000, rs1 6, rs2 7 und funct7 0000000. Bei x6 = 25 und x7 = −9 geben die Leseports 25 und −9 aus. ALUSrc wählt den zweiten Registerwert, und die ALU erzeugt 16. MemtoReg wählt 16 zum Zurückschreiben. An der Flanke wird x5 zu 16 und der PC zu 404. MemRead und MemWrite sind beide null.

Lade und speichere ein Doppelwort

Betrachte bei PC 404 den Befehl ld x5, 16(x6) mit x6 = 1000 und dem Wert 42 im Speicher an Adresse 1016. ImmGen gibt 16 aus. Die ALU berechnet die Adresse 1016, und der Datenspeicher gibt 42 zurück. MemtoReg wählt diesen Speicherwert, sodass x5 an der Flanke zu 42 und der PC zu 408 wird. Würde 1016 in x5 geschrieben, wäre die Adresse mit dem dort gespeicherten Wert verwechselt worden.

Bei PC 408 liest sd x5, 24(x6) die Werte x5 = 42 und x6 = 1000. Die ALU berechnet 1024, während der rs2-Pfad dem Speicher den Wert 42 liefert. MemWrite gibt das Speichern frei; RegWrite ist null. An der Flanke wird das Doppelwort an Adresse 1024 zu 42 und der PC zu 412. Speicheradresse und Speicherwert laufen über unterschiedliche Leitungen.

Die Offsets werden in Bytes gemessen. Benachbarte RV64-Doppelwörter beginnen im Abstand von 8 Bytes: Nach dem Doppelwort an Adresse 1016 beginnt das nächste bei 1024. Ein Schritt um ein Byte würde nicht zum nächsten Doppelwort führen.

Entscheide einen Sprung

Bei PC 412 vergleicht beq x8, x9, 12 den Wert x8 = 7 mit x9 = 7. Die ALU subtrahiert und erhält null. Branch ist 1, also ist Branch AND Zero gleich 1, und PCSrc wählt das Sprungziel. Der Sprungaddierer erzeugt 424, indem er 12 zu 412 addiert. Nur der PC ändert sich.

Ist x9 stattdessen 8, ergibt die Subtraktion −1 und Zero ist 0. Der nächste PC-Wert ist dann 416. Der kodierte Offset wird in Einheiten von 2 Bytes angegeben, sodass der gespeicherte vorzeichenbehaftete Wert für diesen Versatz von 12 Bytes gleich 6 ist; der vom Addierer verwendete vollständige Versatz ist weiterhin 12.

Lies den Zustand für den nächsten Befehl

Jeder Einzyklusbefehl schließt seine Arbeit zwischen benachbarten Taktflanken ab. Der nächste Befehl liest den Zustand, der an der vorherigen Flanke gespeichert wurde. Somit kann der Speicherbefehl im nächsten Zyklus den neuen x5-Wert des Ladebefehls ohne Datenweiterleitung in einer Pipeline lesen. Jeder Befehl benötigt einen Taktzyklus, was einen Einzyklus-CPI-Wert von 1 ergibt, unabhängig davon, wie viele Hardwareeinheiten sein Pfad nutzt.

Das Hauptsteuerwerk übersetzt einen Operationscode in Auswahlsignale und Schreibfreigaben. Es ist eine kombinatorische Wahrheitstabelle, die mit Logikgattern implementiert wird: ein festverdrahtetes Steuerwerk.

Weise jedem Signal eine Aufgabe zu

RegWrite gibt einen Schreibzugriff auf rd frei. ALUSrc wählt den zweiten ALU-Eingang: 0 für rs2, 1 für einen Direktoperanden. MemRead und MemWrite fordern den entsprechenden Datenspeicherzugriff an. MemtoReg wählt die Schreibdaten für den Registersatz: 0 für das ALU-Ergebnis, 1 für Speicherdaten. Branch kennzeichnet einen Gleichheitssprung. Das 2-Bit-Signal ALUOp teilt der separaten ALU-Steuerung mit, welche Operationsklasse benötigt wird.

PCSrc ist anders: Es hängt vom Befehl und den verglichenen Werten ab. Das Hauptsteuerwerk setzt Branch, und die ALU liefert Zero. Deren AND-Verknüpfung bildet PCSrc, sodass ein gewöhnliches arithmetisches Ergebnis von null allein keinen Sprung auslösen kann.

Erstelle die Tabelle aus den nötigen Aktionen

Bei ld benötigt die ALU einen Offset als Direktoperanden, also ist ALUSrc gleich 1. Die geladenen Daten gelangen nach rd, sodass MemtoReg und RegWrite beide 1 sind. Der Speicher wird gelesen, nicht beschrieben; daraus folgen MemRead = 1 und MemWrite = 0. Branch ist 0, und ALUOp = 00 fordert die Addition zur Adressbildung an.

Bei sd addiert die ALU ebenfalls einen Offset, aber das Ziel ist der Speicher. Setze MemWrite = 1 und RegWrite = 0. MemRead bleibt null: Den Speicher zu nutzen bedeutet nicht, ihn zu lesen. Bei beq nutzt die ALU beide Registerwerte und subtrahiert, während die einzige mögliche Änderung des architektonischen Zustands den PC betrifft.

Verwende Don't-Care-Werte nur bei ignorierten Ergebnissen

X ist ein Don't-Care-Wert: Beide Auswahlwerte führen zum selben Verhalten. MemtoReg darf bei einem Speicherbefehl oder bedingten Sprung X sein, weil RegWrite null ist. Der Schreibdateneingang des Registersatzes wird ignoriert, sodass beim Entwurf der Auswahlwert gewählt werden kann, der die Schaltung vereinfacht.

Eine Schreibfreigabe für ein Speicherelement darf nicht so behandelt werden, wenn ein Schreibzugriff verboten ist. Ein versehentliches MemWrite während eines arithmetischen Befehls kann den Speicher verändern, obwohl der arithmetische Befehl die entsprechende Speicherausgabe sonst nicht benötigt. RegWrite und MemWrite müssen daher für Befehle, die diese Schreibzugriffe nicht ausführen, ausdrücklich null sein.

Ergänze eine Zeile für Arithmetik mit Direktoperand

addi x5, x6, 3 bezieht seinen zweiten Operanden von ImmGen und schreibt die ALU-Summe. Seine Zeile lautet ALUSrc 1, MemtoReg 0, RegWrite 1, MemRead 0, MemWrite 0, Branch 0, ALUOp 00. Sein Operationscode 0010011 unterscheidet sich vom R-Typ-Operationscode 0110011, daher benötigt das Hauptsteuerwerk diese zusätzliche Zeile. Um andi und ori zu unterstützen, müssen auch ihre funct3-Werte dekodiert werden, um die Operation auszuwählen.

Signalnamen hängen vom Entwurf ab. RegWEn, BSel und WBSel in anderen Kursdiagrammen beschreiben verwandte Aufgaben der Schreibfreigabe und Eingangsauswahl. Achte beim Lesen eines neuen Diagramms auf die Definition eines Signals und die Eingänge seines Multiplexers.

Der Operationscode allein kann add nicht von sub unterscheiden: Beide gehören zur R-Typ-Klasse. Die zweistufige Steuerung bestimmt zuerst die Klasse und nutzt dann die Funktionsbits, wo sie relevant sind.

Von ALUOp zur Operation

Das Hauptsteuerwerk liefert neben seinen anderen Ausgaben ein 2-Bit-Signal ALUOp. Die ALU-Steuerung kombiniert es mit funct3 und Bit 30 des Befehls, einem Teil von funct7, und erzeugt vier Operationssteuerbits.

Diese Codes beschreiben diese ALU-Implementierung, keine RISC-V-Befehlskodierungen. Lade- und Speicherbefehle nutzen ALUOp 00, weil sie Basis und Offset addieren. Gleichheitssprünge nutzen ALUOp 01, weil die Subtraktion bei übereinstimmenden Operanden Zero erzeugt. R-Typ-Befehle nutzen ALUOp 10 und benötigen weitere Dekodierung.

Verfolge eine kodierte Subtraktion

sub x5, x6, x7 hat die Kodierung 0x407302B3. Der Operationscode 0110011 bezeichnet den R-Typ und wählt ALUOp 10. Das funct3-Feld ist 000, sodass Addition und Subtraktion möglich bleiben. Bit 30 ist 1, aus funct7 0100000, also gibt die ALU-Steuerung 0110 für die Subtraktion aus.

Wird dieses Funktionsbit auf null geändert, ergibt sich die entsprechende add-Kodierung 0x007302B3 mit funct7 0000000 und ALU-Steuercode 0010. Die Zeile des Hauptsteuerwerks bleibt gleich, weil beide Befehle zwei Registereingaben nutzen, ein ALU-Ergebnis schreiben und nicht auf den Datenspeicher zugreifen.

Verwende den Addierer für die Subtraktion erneut

In der klassischen ALU stehen die Steuerleitungen für Ainvert, Bnegate und einen 2-Bit-Operationsauswahlschalter. Die Subtraktion nutzt den Addierer, nachdem der zweite Operand invertiert und ein Eingangsübertrag von 1 angelegt wurde:

Diese Zweierkomplement-Gleichung ermöglicht es Addition und Subtraktion, Hardware gemeinsam zu nutzen. Der Unterschied bei Bnegate erklärt die Codes 0010 und 0110; er erfordert keinen separaten arithmetischen Pfad für jeden Befehl.

Dekodiere Bits nur im passenden Format

Bei ALUOp 00 oder 01 wählen die Positionen der Funktionsfelder nicht die ALU-Operation aus. Das funct3-Feld 011 eines Ladebefehls beschreibt einen Doppelwortzugriff. Höherwertige Bits von Speicherbefehlen und bedingten Sprüngen enthalten Bits des Direktoperanden. Würden diese Positionen als R-Typ-Funktionsfelder behandelt, würde die Adressbildung mit der arithmetischen Dekodierung verwechselt.

Für eine schnelle R-Typ-Prüfung: ALUOp 10 mit funct3 110 wählt 0001, die OR-Operation. Wird unter demselben Operationscode eine weitere Operation ergänzt, muss unter Umständen nur die ALU-Steuerung geändert werden, sofern die ALU sie bereits unterstützt. Eine neue Befehlsklasse kann auch Änderungen am Hauptsteuerwerk erfordern, wie bei der Arithmetik mit Direktoperand.

Ein Einzyklusprozessor muss seinen langsamsten Befehl vor der nächsten Flanke abschließen. Schnellere Befehle warten trotzdem denselben festen Takt ab. Pipelining ändert, wie viel Arbeit jede Taktperiode enthalten muss.

Bestimme die Grenze des Einzyklusentwurfs

Verwende diese Bauteilverzögerungen und vernachlässige Multiplexer und kleine Addierer: Befehl holen 250 ps, Register lesen 150 ps, ALU 200 ps, Datenspeicher 250 ps und Register schreiben 150 ps.

Der Ladebefehl bildet den kritischen Pfad und legt die Periode auf 1000 ps oder 1 ns fest. Das entspricht einem Takt von 1 GHz. Ein Mix aus 25 % Ladebefehlen, 10 % Speicherbefehlen, 50 % R-Typ-Befehlen und 15 % bedingten Sprüngen hat eine gewichtete Pfadverzögerung von 800 ps. Dennoch erhält jeder Befehl 1000 ps, also das 1,25-Fache dieses Durchschnitts. Eine durchschnittliche Verzögerung kann keinen Takt festlegen, der auch für den längsten Befehl ausreichen muss.

Überlappe fünf Stufen

Die Pipeline teilt die Ausführung in IF (Befehl holen), ID (dekodieren und Register lesen), EX (ausführen oder eine Adresse berechnen), MEM (auf den Datenspeicher zugreifen) und WB (ein Register schreiben). Verschiedene Befehle belegen gleichzeitig verschiedene Stufen.

Der Durchsatz zählt abgeschlossene Befehle pro Zeiteinheit. Die Latenz misst die Zeit, die ein Befehl vom Eintritt bis zum Abschluss benötigt. Ein Fließband kann pro Zeitabschnitt ein Stück fertigstellen, selbst wenn jedes Stück mehrere Abschnitte für den Durchlauf benötigt. Dieselbe Unterscheidung gilt hier.

Die langsamste Stufe benötigt 250 ps. Bei 20 ps Pipelineregister-Overhead beträgt die Taktperiode 270 ps, etwa 3,70 GHz. Ein Befehl durchläuft fünf Perioden und benötigt 1350 ps. Das übersteigt seine Einzykluslatenz, aber eine gefüllte Pipeline kann alle 270 ps einen Befehl abschließen.

Berücksichtige Füll- und Abschlusszeit

Ohne Pipeline-Stillstände führt eine k-stufige Pipeline n Befehle in k + n − 1 Zyklen aus. Für fünf Stufen sind das n + 4. Vier Befehle benötigen acht Zyklen und damit 2160 ps, verglichen mit 4000 ps im Einzyklusprozessor. Der Speedup beträgt etwa 1,85.

Für 1.000.000 Befehle benötigt die Pipeline 1.000.004 Zyklen, ungefähr 270,0 μs. Der Einzyklusentwurf benötigt 1000 μs. Der Speedup nähert sich dem Verhältnis 1000/270, etwa 3,70, wenn die festen Kosten für das Füllen und Leeren klein werden.

Ein perfekter fünffacher Speedup würde fünf gleich langsame Stufen zu je 200 ps ohne Register-Overhead oder konfliktbedingte Verzögerungen voraussetzen. Bei ungleichen Stufen warten schnellere Stufen auf die langsamste. Mehr Stufen verursachen außerdem zusätzlichen Overhead und können die Kosten von Konflikten erhöhen.

Die feste Befehlslänge von 32 Bit in dieser Teilmenge vereinfacht das Holen. Gleichbleibende Registerfelder unterstützen ID, und die Beschränkung der Datenspeicherzugriffe auf Lade- und Speicherbefehle passt zur Adressberechnung in EX mit anschließendem MEM-Zugriff. Diese Eigenschaften der Befehlssatzarchitektur machen die Stufengrenzen praktikabel.

Mehrere Befehle teilen sich den Datenpfad gleichzeitig, sodass jede Stufe die Werte ihres eigenen Befehls benötigt. Pipelineregister bewahren diese Werte und ihre Steuersignale an jeder Taktflanke.

Ordne den Inhalt den späteren Aufgaben zu

Jedes Register ist nach seinen benachbarten Stufen benannt. Es übernimmt die Ausgaben der ersten Stufe zur Verwendung in der zweiten. Nach WB gibt es kein zusätzliches Pipelineregister; WB schreibt den architektonischen Zustand. Der PC liefert den Zustand vor dem Holen.

Der obige Inhalt von EX/MEM unterstützt einen Entwurf, der die Sprunginformation in MEM verwendet. Ein Entwurf, der Sprünge in EX entscheidet, gibt diese Information früher an die Holstufe zurück. Die entscheidende Stufe bestimmt die Verzögerung durch den Steuerkonflikt.

Halte Zielregister und Daten zusammen

Ein Ladebefehl wird in ID dekodiert, schreibt rd aber erst drei Zyklen später in WB. Zu diesem Zeitpunkt enthält IF/ID einen jüngeren Befehl. Würde der Schreibport rd dieses jüngeren Befehls verwenden, gelangte der geladene Wert in das falsche Register. Die Zielregisternummer des Ladebefehls muss daher neben seinem Ergebnis durch ID/EX, EX/MEM und MEM/WB weitergegeben werden.

Ein Speicherbefehl führt entsprechend seinen rs2-Wert durch ID/EX und EX/MEM mit. Seine Adresse und seine Daten müssen denselben Speicherbefehl betreffen, wenn sie den Datenspeicher erreichen. Pipelineregister bewahren die Identität eines Befehls durch diese zusammengehörigen Werte, obwohl mehrere andere Befehle gleichzeitig aktiv sind.

Gib die Steuerung mit dem Befehl weiter

Die Steuersignale werden in ID erzeugt. EX nutzt ALUSrc und ALUOp; MEM nutzt Branch, MemRead und MemWrite; WB nutzt MemtoReg und RegWrite. Jede Stufe gibt die später benötigten Steuersignale zusammen mit den Daten weiter.

Wird der ALU-Steuercode in EX dekodiert, muss ID/EX neben ALUOp auch Bit 30 und funct3 mitführen. R-Typ-Operationen haben alle ALUOp 10, sodass dieser Wert allein add, sub, AND und OR nicht unterscheiden kann. Ein anderer gültiger Entwurf dekodiert die vollständige 4-Bit-Operation in ID und führt stattdessen diesen Code mit.

Halte den Stufenablauf einheitlich

Ein R-Typ-Befehl durchläuft MEM, ohne den Datenspeicher zu nutzen. Ein Speicherbefehl durchläuft WB, ohne ein Register zu schreiben. Wenn alle Befehle denselben fünfstufigen Ablauf einhalten, bleibt die Reihenfolge der Registerschreibzugriffe erhalten. Würde ein R-Typ-Befehl MEM überspringen, könnte er im selben Zyklus wie der unmittelbar vorherige Ladebefehl den einzigen Registerschreibport erreichen.

Der Registersatz bedient WB und ID in einem Zyklus, indem er in der ersten Hälfte schreibt und in der zweiten liest. ID kann dann einen Wert sehen, den ein älterer Befehl in diesem Zyklus geschrieben hat. Getrennte Befehls- und Datenspeicher ermöglichen den gleichzeitigen Betrieb von IF und MEM.

Die meisten Informationen bewegen sich in der Pipeline vorwärts. Das Zurückschreiben sendet ein Ergebnis an den Registersatz zurück, und die Sprungsteuerung sendet eine Entscheidung über den nächsten PC-Wert an die Holstufe zurück. Diese langen Rückwege erklären, warum spätere Befehle möglicherweise Unterstützung benötigen, bevor ein älterer Befehl abgeschlossen ist.

Ein Pipelinediagramm macht die Überlappung sichtbar. Die Zeilen zeigen Befehle in Programmreihenfolge, die Spalten zeigen Taktzyklen. Jede Zelle nennt die Stufe, die der betreffende Befehl während des jeweiligen Zyklus belegt.

Zeichne eine Treppe

Trage für fünf unabhängige Befehle IF für I1 in Zyklus 1 ein, danach ID, EX, MEM und WB in den Zyklen 2–5. Beginne I2 einen Zyklus später und wiederhole den Ablauf. Die Stufennamen bilden eine diagonale Treppe.

In Zyklus 5 ist I1 in WB, I2 in MEM, I3 in EX, I4 in ID und I5 in IF. Liest du eine Spalte von oben nach unten, erhältst du eine Momentaufnahme eines Zyklus. Eine Zeile zeigt den Verlauf eines einzelnen Befehls.

Nummeriere die Stufen von IF = 1 bis WB = 5. Ohne Pipeline-Stillstände erreicht Befehl i die Stufe s in Zyklus i + s − 1. I3 erreicht MEM daher in Zyklus 6. Die letzte WB-Zelle gibt den Abschlusszyklus an: Fünf Befehle enden in Zyklus 9.

Ergänze Werte in einer Momentaufnahme

I1 sei ld x5, 16(x6) mit x6 = 1000 und dem Wert 42 im Speicher an Adresse 1016. I2 sei eine unabhängige Addition, I3 eine unabhängige Subtraktion und I4 eine unabhängige OR-Operation. In Zyklus 4 liest der Ladebefehl den Speicher an Adresse 1016, I2 nutzt die ALU, I3 liest Register und I4 wird geholt. In Zyklus 5 schreibt der Ladebefehl 42 in x5. Eine Spalte enthält Arbeit mehrerer Befehle, nicht mehrere Stufen des Ladebefehls.

Zeige einen Stillstand, ohne ältere Arbeit anzuhalten

Verwende nun ld x10, 0(x20) gefolgt von add x11, x10, x12 und danach einem unabhängigen Befehl. Auch mit Datenweiterleitung benötigt der unmittelbar verbrauchende Befehl einen Stillstandszyklus:

• Der Ladebefehl belegt IF 1, ID 2, EX 3, MEM 4, WB 5.
• Der add-Befehl belegt IF 2, ID 3, erneut ID 4, EX 5, MEM 6, WB 7.
• Der dritte Befehl belegt IF 3, erneut IF 4, ID 5, EX 6, MEM 7, WB 8.

Der add-Befehl wartet in ID, während eine Pipelineblase EX durchläuft. Der Ladebefehl läuft normal weiter; würde er angehalten, käme gerade der Wert später an, den add benötigt. Jeder jüngere Befehl wird zusammen mit add verzögert.

Zähle die Befehlsfolge einmal

Eine fünfstufige Pipeline benötigt ohne Stillstände n + 4 Zyklen. Jeder eingefügte Stillstandszyklus kommt hinzu. Wenn keine weiteren Verluste auftreten, ergibt das n + 4 + Stillstandszyklen. Das Beispiel mit drei Befehlen endet in Zyklus 8: drei Befehle, vier zusätzliche Stufenintervalle und ein Stillstandszyklus.

In den ersten vier Zyklen wird die Pipeline gefüllt, in den letzten vier geleert. Das sind zwei Sichtweisen auf denselben Ablauf mit n + 4 Zyklen, nicht zwei getrennte Zuschläge von je vier Zyklen. Bei einer langen Folge ist ihr fester Beitrag klein; bei einer kurzen Folge kann er den Speedup maßgeblich bestimmen.

Ein Konflikt verhindert, dass der nächste Befehl in seinem geplanten Zyklus ausgeführt wird. Um ihn zu untersuchen, bestimme die benötigte Ressource oder den benötigten Wert, den Zyklus, in dem sie oder er gebraucht wird, und den Zyklus, in dem sie oder er verfügbar wird.

Unterscheide drei Konfliktarten

Getrennte Befehls- und Datenspeicher beseitigen den IF/MEM-Strukturkonflikt. Wird der Registersatz in der ersten Hälfte eines Zyklus beschrieben und in der zweiten gelesen, können auch WB und ID ihn gemeinsam nutzen. Durch diese Maßnahmen gibt es in diesem fünfstufigen Modell keinen Strukturkonflikt.

Bestimme den tatsächlichen Erzeuger

Eine echte Datenabhängigkeit (RAW) liegt vor, wenn ein späterer Befehl einen Wert liest, den ein früherer schreibt. Bei add x1, x2, x3 gefolgt von sub x4, x1, x5 erzeugt der add-Befehl x1 und der sub-Befehl verbraucht den Wert. Ohne weitere Maßnahmen liest sub x1 in ID während Zyklus 3, bevor add den Wert in WB während Zyklus 5 schreibt.

Eine Gegenabhängigkeit (WAR) verwendet ein Register erneut, nachdem ein älterer Befehl es gelesen hat. Bei einer Ausgabeabhängigkeit (WAW) haben zwei Befehle dasselbe Zielregister. Diese Namensabhängigkeiten verursachen im fünfstufigen Entwurf mit Ausführung in Programmreihenfolge keine Konflikte: Lesezugriffe erfolgen in ID und Schreibzugriffe in WB, jeweils in Programmreihenfolge. Sie sind wichtig, wenn entschieden wird, ob Software Befehle umordnen darf.

Verfolge eine Folge mit wiederholten Zielregistern

Betrachte:

ld  x5, 0(x10)
add x6, x5, x7
sub x5, x8, x9
or  x9, x6, x5

Die RAW-Abhängigkeiten sind Ladebefehl → add über x5, add → OR über x6 und Subtraktion → OR über x5. OR benötigt den neuen x5-Wert der Subtraktion, nicht den älteren geladenen Wert. Wer nur nach gleichen Registernamen sucht, kann diesen Wechsel des Erzeugers übersehen.

Die Subtraktion schreibt x5, nachdem add x5 gelesen hat: eine WAR-Abhängigkeit. Ladebefehl und Subtraktion haben außerdem eine WAW-Abhängigkeit bezüglich x5. OR schreibt x9, nachdem die Subtraktion es gelesen hat: eine weitere WAR-Abhängigkeit. Keine davon erzeugt in dieser Pipeline mit geordneter Ausführung einen WAR- oder WAW-Hardwarekonflikt.

Zähle Wartezyklen ohne Datenweiterleitung

Steht nur der Registersatz mit Schreiben vor Lesen zur Verfügung, benötigt ein unmittelbar verbrauchender Befehl zwei Stillstandszyklen. Er muss seinen ID-Lesezugriff von Zyklus 3 auf Zyklus 5 verschieben. Ein unabhängiger Befehl zwischen Erzeuger und Verbraucher verringert dies auf einen Stillstandszyklus. Mit zwei unabhängigen Befehlen erreicht der Verbraucher ID im WB-Zyklus des Erzeugers und benötigt keinen Stillstand.

Eine Abhängigkeit ist eine Eigenschaft des Programms; ob sie einen Stillstand verursacht, hängt vom zeitlichen Ablauf und den verfügbaren Pfaden ab. Eine zeitlich entfernte RAW-Abhängigkeit kann ohne Maßnahmen auskommen. Register x0 liefert nie ein ausstehendes Ergebnis, weil daraus immer null gelesen wird und Schreibzugriffe ignoriert werden.

Software kann nop-Befehle einfügen oder unabhängige Arbeit in Warteintervalle verschieben. Hardware kann Ergebnisse weiterleiten oder automatisch Stillstände einfügen. Beide Ansätze müssen sicherstellen, dass jeder verbrauchende Befehl den Wert erhält, den sein in Programmreihenfolge zugehöriger Erzeuger schreibt.

Ein ALU-Ergebnis liegt bereits vor, bevor es in ein Register zurückgeschrieben wird. Die Datenweiterleitung, auch Bypassing genannt, leitet dieses Ergebnis direkt an den Eingang eines späteren Befehls und vermeidet so das Warten auf den Registersatz.

Wähle die Quelle für jeden Operanden

Zwei Multiplexer speisen die Ausführungspfade. ForwardA bedient rs1 und ForwardB bedient rs2. Jeder Operand wird unabhängig geprüft.

Der EX/MEM-Pfad erreicht den unmittelbar folgenden Befehl. Der MEM/WB-Pfad erreicht einen um zwei Positionen späteren Befehl und kann entweder ein ALU-Ergebnis oder geladene Daten übertragen. ForwardB speist außerdem den Pfad für die zu speichernden Daten, bevor ALUSrc zwischen diesem Wert und einem Direktoperanden wählt.

Prüfe Freigabe, Zielregister und Übereinstimmung

Für ForwardA = 10 muss der Befehl in EX/MEM RegWrite = 1 und ein von null verschiedenes rd haben, und rd muss gleich ID/EX.rs1 sein. Ersetze für die ForwardB-Prüfung rs1 durch rs2. Ein Speicherbefehl oder bedingter Sprung darf nicht als Erzeuger behandelt werden, nur weil seine Befehlsbits zufällig einer Zielregisternummer ähneln. Auch Schreibzugriffe auf x0 dürfen nicht zu weitergeleiteten Werten werden.

Für ForwardA = 01 führe die entsprechenden Prüfungen auf RegWrite, ein von null verschiedenes rd und übereinstimmende Registernummern für MEM/WB durch. Nutze dieses ältere Ergebnis nur, wenn EX/MEM den benötigten Operanden nicht bereits liefert. ForwardB folgt unabhängig derselben Prioritätsregel.

Verfolge ein Ergebnis zu späteren Verbrauchern

Beginne mit add x1, x2, x3, wobei x2 = 10 und x3 = 5 gilt. Der Befehl erzeugt am Ende von EX in Zyklus 3 den Wert 15.

• Der nächste Befehl, sub x4, x1, x5, erreicht EX in Zyklus 4. Bei x5 = 3 liefert ForwardA = 10 den Wert 15 und die Subtraktion ergibt 12.
• and x6, x7, x1 erreicht EX in Zyklus 5. ForwardB = 01 übernimmt x1 aus MEM/WB.
• or x8, x1, x9 liest Register in ID während Zyklus 5, nach dem Schreibzugriff von add in der ersten Zyklushälfte. In EX benötigt der Befehl keine Datenweiterleitung.

Für diese Abhängigkeiten von ALU-Ergebnissen ist kein Pipeline-Stillstand nötig. Der verbrauchende Befehl erhält den Wert, wenn er die ALU nutzt, selbst wenn sein früherer ID-Lesezugriff einen veralteten Wert geliefert hat.

Löse zwei übereinstimmende Schreibzugriffe auf

Bei drei aufeinanderfolgenden Befehlen add x1, x1, x2, add x1, x1, x3 und add x1, x1, x4 stimmen sowohl EX/MEM als auch MEM/WB mit rs1 des dritten Befehls überein. EX/MEM enthält das Ergebnis des zweiten add-Befehls, den neuesten x1-Wert. MEM/WB enthält das Ergebnis des ersten add-Befehls und muss zurückstehen.

Dieselben Pfade ermöglichen es add x5, x6, x7, den Wert ohne Pipeline-Stillstand an sd x5, 0(x8) zu liefern. Der weitergeleitete x5-Wert erreicht den Schreibdatenpfad des Speichers, während die ALU des Speicherbefehls den Offset als Direktoperanden nutzt.

Datenweiterleitung kann keine Daten liefern, bevor sie vorliegen. EX/MEM enthält bei einem Ladebefehl dessen Adresse, nicht den geladenen Wert. Der unmittelbar verbrauchende Befehl muss warten, bis der Ladebefehl MEM abgeschlossen hat; würde die Adresse weitergeleitet, würde unbemerkt mit der falschen Größe gerechnet.

Ein Ladebefehl erzeugt Daten am Ende von MEM. Der unmittelbar folgende Befehl würde diese Daten im selben Zyklus zu Beginn von EX benötigen. Ein Stillstandszyklus verschiebt die EX-Stufe des verbrauchenden Befehls in den nächsten Zyklus, wenn MEM/WB den Wert liefern kann.

Erkenne den fehlenden Wert in ID

Die Konflikterkennungseinheit untersucht den Befehl in EX und den Befehl, der gerade dekodiert wird. Der grundlegende Test prüft ID/EX.MemRead = 1 und eine Übereinstimmung zwischen ID/EX.rd und einem der beiden Quellnummernfelder in IF/ID. Ein verfeinerter Test schließt rd = x0 aus und prüft, welche Quellfelder der dekodierte Befehl tatsächlich liest.

Diese letzte Prüfung vermeidet einen unnötigen Stillstand bei einem I-Typ-Befehl, dessen Direktoperandenbits die übliche rs2-Position belegen. Der Vergleich der bloßen Feldpositionen ist sicher, kann aber einen Befehl verzögern, der das Register gar nicht liest.

Halte jüngere Arbeit an und führe den Ladebefehl weiter

Der Pipeline-Stillstand führt drei aufeinander abgestimmte Aktionen aus:

1. Setze die nach ID/EX eingehenden Steuersignale auf null und füge so eine Pipelineblase ein.
2. Setze PCWrite = 0, damit die Adresse zum Holen unverändert bleibt.
3. Setze IF/IDWrite = 0, damit der in ID wartende Befehl erhalten bleibt.

Der Ladebefehl und ältere Befehle laufen weiter. Die Pipelineblase durchläuft spätere Stufen, ohne Register oder Speicher zu beschreiben. Würde ID/EX angehalten, während der Ladebefehl noch darin steht, würde der Ladebefehl wiederholt, statt eine leere Operation einzufügen.

Bei ld x10, 0(x20) gefolgt von add x11, x10, x12 ist der Ladebefehl in Zyklus 3 in EX und der add-Befehl in ID. In Zyklus 4 ist der Ladebefehl in MEM, die Pipelineblase in EX und der add-Befehl weiterhin in ID. In Zyklus 5 ist der Ladebefehl in WB und add erreicht EX mit ForwardA = 01.

Plane unabhängige Befehle ein

Betrachte:

ld  x10, 0(x20)
ld  x11, 8(x20)
add x12, x10, x11
sd  x12, 24(x20)
ld  x13, 16(x20)
add x14, x10, x13
sd  x14, 32(x20)

Die Verwendungen von x11 und x13 folgen unmittelbar auf ihre Ladebefehle. Auch mit Datenweiterleitung verursachen sie zwei Stillstandszyklen, was 7 + 4 + 2 = 13 Zyklen ergibt. Verschiebe ld x13, 16(x20) an die dritte Stelle vor den ersten add-Befehl. Dadurch wird der Ladebefehl für x11 von seinem Verbraucher getrennt und der Ladebefehl für x13 ausreichend weit vor seinen Verbraucher gesetzt. Die Folge benötigt nun 7 + 4 = 11 Zyklen.

Die Verschiebung ist zulässig, weil der Ladebefehl x20 liest, das die übersprungenen Befehle nicht ändern. Sein Zielregister x13 beeinflusst diese Befehle nicht. Seine Adresse x20 + 16 unterscheidet sich von x20 + 24 des übersprungenen Speicherbefehls. Ein Ladebefehl darf nicht über einen Speicherbefehl hinweg verschoben werden, der möglicherweise die Bytes schreibt, die er liest. Die Umordnung muss RAW-, WAR-, WAW- und Speicherabhängigkeiten erhalten.

Kombiniere Stillstände und Datenweiterleitung

Bei ld x5, 0(x10), add x6, x5, x7, sub x5, x8, x9 und or x9, x6, x5 verursacht nur das unmittelbare Load-Use-Paar einen Stillstand. Wenn OR EX erreicht, liefert ForwardA = 01 den x6-Wert von add und ForwardB = 10 den x5-Wert von sub. Insgesamt sind es 4 + 4 + 1 = 9 Zyklen.

Die Holstufe benötigt in jedem Zyklus eine neue Adresse. Ein bedingter Sprung liefert die richtige Auswahl erst nach seinem Vergleich und der Zielberechnung. Diese Lücke erzeugt einen Steuerkonflikt.

Setze Entscheidungsstufe und Verzögerung in Beziehung

In einer fünfstufigen Pipeline, bei der nach der entscheidenden Stufe umgelenkt wird, geht bei einer Fehlvorhersage ein Holplatz verloren, wenn das Ergebnis am Ende von ID bekannt ist. Eine Entscheidung am Ende von EX kostet zwei, am Ende von MEM drei Plätze. Jüngere Befehle sind während dieser Plätze bereits in die Pipeline eingetreten.

Eine Strategie hält das Holen an, bis jeder Sprung entschieden ist. Sie ist einfach, aber genommene und nicht genommene Sprünge verursachen beide die volle Wartezeit. Die Vorhersage „Sprung nicht genommen“ fährt stattdessen bei PC + 4 fort. Eine richtige Vorhersage erfordert keine Korrektur. Ein genommener Sprung lenkt das Holen um und verwirft die jüngeren Befehle des sequenziellen Pfads.

Verfolge einen genommenen Sprung

Hole beq x1, x2, 16 an Adresse 100 in Zyklus 1 und entscheide den Sprung am Ende von EX in Zyklus 3. Die Vorhersage „nicht genommen“ holt die Adressen 104 und 108 in den Zyklen 2 und 3. Wird der Sprung genommen, liegen beide Befehle auf dem falschen Pfad. Nach einer Verzögerung von zwei Zyklen beginnt das Holen in Zyklus 4 bei 116.

Ein Pipeline-Flush verhindert, dass diese jüngeren Einträge den architektonischen Zustand ändern oder Ausnahmen auslösen. Die Implementierung kann Einträge für ungültig erklären oder ihre Steuersignale und Ausnahmeeffekte unterdrücken. Ein Speicherbefehl auf dem falschen Pfad darf niemals einen wirksamen Schreibzugriff auf den Speicher ausführen.

Eine Pipelineblase ist nicht dasselbe wie ein RISC-V-Befehl, dessen Bits alle null sind. Die Kodierung aus lauter Nullen ist ungültig. Wird eine echte Befehlskodierung eingefügt, ist der kanonische nop addi x0, x0, 0, kodiert als 0x00000013. Ein verworfener Pipelineeintrag steht dagegen für keinen ausgeführten Befehl.

Entscheide früher, aber beschaffe Operanden früher

Werden der Vergleicher und der Sprungzieladdierer nach ID verlegt, sinkt die Umlenkungsverzögerung auf einen Zyklus. Der Vergleich benötigt seine Quellwerte nun in ID, sodass die übliche Datenweiterleitung nach EX allein nicht ausreicht. Mit geeigneter Datenweiterleitung nach ID wartet ein Sprung unmittelbar nach seinem erzeugenden ALU-Befehl einen Zyklus. Unmittelbar nach einem erzeugenden Ladebefehl wartet er zwei Zyklen. Die frühere Entscheidung tauscht weniger verlorene Holplätze gegen höhere Anforderungen an die Bereitstellung der Operanden.

Die statische Sprungvorhersage legt eine Regel im Voraus fest. Übliche Regeln sind immer nicht genommen, immer genommen und rückwärts genommen/vorwärts nicht genommen. Ein Rückwärtssprung am Ende einer Schleife wiederholt oft die Schleife, sodass seine Richtung ein nützlicher Hinweis ist.

RISC-V hat keinen Branch Delay Slot. Wird ein Sprung genommen, wird sein sequenzieller Nachfolger nicht allein deshalb ausgeführt, weil er geholt wurde. Einige ältere MIPS-Entwürfe führten diesen Nachfolger als definierten Befehl im Delay Slot aus; das ist eine andere Regel der Befehlssatzarchitektur.

Bewahre eine präzise Ausnahmegrenze

Ein ungültiger Befehl oder ecall überträgt die Steuerung an eine Behandlungsroutine. Ältere Befehle werden abgeschlossen; der fehlerauslösende Befehl und jüngere Befehle übernehmen ihre normalen Auswirkungen nicht in den architektonischen Zustand. Der Prozessor speichert den PC-Wert des auslösenden Befehls und die Ursache, etwa in den Registern sepc/scause im Supervisormodus oder mepc/mcause im Maschinenmodus, und holt dann Befehle von der Behandlungsroutine. Diese präzise Ausnahme zeigt den Zustand als Grenze zwischen abgeschlossenen älteren Befehlen und nicht abgeschlossener späterer Arbeit.

Die dynamische Sprungvorhersage lernt aus Ergebnissen, die während der Programmausführung beobachtet werden. Eine Sprungverlaufstabelle (BHT) speichert kleine Zustandseinträge, die anhand von Bits einer Sprungadresse ausgewählt werden. Sage zuerst voraus, vergleiche später mit dem tatsächlichen Ergebnis und aktualisiere dann den Eintrag.

Sieh, warum ein Bit bei einer Schleife zweimal falschliegt

Ein 1-Bit-Prädiktor speichert das vorherige Ergebnis. Wurde der letzte Sprung genommen, sagt er für das nächste Mal „genommen“ voraus; andernfalls sagt er „nicht genommen“ voraus. Bei einer wiederholt aufgerufenen Schleife, deren Sprung neunmal genommen und dann einmal nicht genommen wird, bleibt das Bit beim Verlassen auf „nicht genommen“ stehen.

Beim nächsten Aufruf wird der erste genommene Sprung falsch vorhergesagt. Die dazwischenliegenden genommenen Sprünge stellen das Bit auf „genommen“, sodass auch das abschließende Verlassen mit „nicht genommen“ falsch vorhergesagt wird. Im eingeschwungenen Zustand sind das zwei Fehler bei zehn Ergebnissen oder 80 % Genauigkeit.

Ergänze ein zweites Bit für Beständigkeit

Ein 2-Bit-Sättigungszähler hat die Zustände 0 bis 3. Die Zustände 0 und 1 sagen „nicht genommen“ voraus; 2 und 3 sagen „genommen“ voraus. Ein genommenes Ergebnis erhöht den Zähler um eins, ein nicht genommenes verringert ihn um eins. Bei 0 und 3 bleiben die Werte stehen.

Aus Zustand 3 führt ein einmaliges Verlassen mit „nicht genommen“ in Zustand 2, der weiterhin „genommen“ vorhersagt. Der nächste Schleifeneintritt wird daher richtig vorhergesagt. Dieselbe Schleife mit zehn Ergebnissen hat im eingeschwungenen Zustand einen Fehler pro Aufruf oder 90 % Genauigkeit. Ausgehend von einem starken Zustand sind zwei aufeinanderfolgende entgegengesetzte Ergebnisse nötig, um die Vorhersage umzukehren.

Verfolge erst die Vorhersage, dann die Aktualisierung

Beginne in Zustand 1 und beobachte genommen, genommen, nicht genommen, genommen:

1. Zustand 1 sagt „nicht genommen“ voraus: falsch. Erhöhe auf 2.
2. Zustand 2 sagt „genommen“ voraus: richtig. Erhöhe auf 3.
3. Zustand 3 sagt „genommen“ voraus: falsch. Verringere auf 2.
4. Zustand 2 sagt „genommen“ voraus: richtig. Erhöhe auf 3.

Es gibt zwei Fehler und der Endzustand ist 3. Würde vor der Vorhersage aktualisiert, hätte der Prädiktor fälschlich Zugriff auf das Ergebnis, das er vorhersagen soll.

Unterscheide Richtung, Ziel und gegenseitige Störung

Zwei Sprungadressen können denselben BHT-Eintrag indizieren. Durch dieses Aliasing können sich ihre Ergebnisse gegenseitig stören. Eine Fehlvorhersage kostet Zyklen, aber bei der Korrektur wird das tatsächliche Ergebnis geprüft und die Korrektheit gewahrt.

Ein Sprungzielpuffer (BTB) liefert eine Adresse, nicht nur ein Richtungsbit. Wird er während IF mit dem PC abgefragt, kann er vor der Dekodierung das vorhergesagte Ziel eines genommenen Sprungs für den nächsten Holzyklus liefern. Die Richtungsvorhersage entscheidet, ob dieses Ziel verwendet wird.

Ein einfacher Verlauf hat Grenzen. Bei einem streng zwischen genommen und nicht genommen wechselnden Muster liegt ein 1-Bit-Prädiktor durchgehend falsch, nachdem er sich auf das Muster eingestellt hat. Ein 2-Bit-Zähler liegt höchstens in der Hälfte der Fälle richtig; beginnt er vor einem genommenen Ergebnis in Zustand 1, liegt er jedes Mal falsch. Korrelierende Prädiktoren berücksichtigen zusätzlich den jüngsten Sprungverlauf, Turnierprädiktoren wählen zwischen Prädiktoren, und ein Rückadressstapel sagt Ziele von Prozedurrücksprüngen voraus. Tiefere Pipelines machen die Korrektur teurer, weil sich vor der Entscheidung mehr jüngere Arbeit ansammelt.

Die Geschwindigkeit einer Pipeline hängt sowohl von der Taktperiode als auch von den Zyklen ab, die durch Warten oder Korrekturen anfallen. Der effektive CPI-Wert misst diese zusätzlichen Zyklen im Durchschnitt über die Befehlsfolge.

Gewichte jede Verzögerung nach den betroffenen Befehlen

Beginne für eine lange Folge mit Einfachausgabe beim idealen CPI-Wert 1. Addiere jede einzelne, nicht überlappende Ursache verlorener Zyklen als Anteil betroffener Befehle mal verlorene Zyklen pro Ereignis. Bei einer bedingten Rate brauchst du auch den Anteil der übergeordneten Gruppe.

Angenommen, 25 % der Befehle sind Ladebefehle, und auf 40 % dieser Ladebefehle folgt ein unmittelbarer Verbraucher. Jedes solche Paar verursacht einen Stillstandszyklus, sodass der Load-Use-Beitrag 0,25 × 0,40 × 1 = 0,10 Zyklen pro Befehl beträgt. Angenommen, 15 % sind bedingte Sprünge, 10 % davon werden falsch vorhergesagt und die Korrektur kostet zwei Zyklen. Der Sprungbeitrag beträgt 0,15 × 0,10 × 2 = 0,03.

Die Addition der unabhängigen Beiträge ergibt CPI-Wert = 1 + 0,10 + 0,03 = 1,13. Würde jedem Ladebefehl ein Stillstandszyklus angelastet, ergäbe das 0,25 statt 0,10. Würde die Sprungfehlerrate von 10 % auf jeden Befehl angewandt, würde ebenfalls zu viel gezählt.

Berücksichtige Taktperiode und Befehlsanzahl

Die Ausführungszeit entspricht Befehlsanzahl × CPI-Wert × Taktperiode. Ein Takt von 4 GHz hat eine Periode von 0,25 ns. Für 10⁹ Befehle bei einem CPI-Wert von 1,13 benötigt die Ausführung 10⁹ × 1,13 × 0,25 ns = 0,2825 s. Die durchschnittliche Zeit pro Befehl beträgt 0,2825 ns.

Zähle bei einer kurzen Folge die Zyklen für Füllen, Leeren und Konflikte ausdrücklich. Der ideale Basis-CPI-Wert von 1 beschreibt den stetigen Durchsatz; bei einer fünfstufigen Pipeline, die nur wenige Befehle ausführt, kommt auch der Beitrag von vier Zyklen für das Füllen und den Abschluss hinzu.

Vergleiche Sprungstrategien unter gleichen Bedingungen

Behalte die Load-Use-Kosten von 0,10, den Sprunganteil von 0,15 und die Verzögerung von zwei Zyklen bei:

Bei gleicher Taktperiode und Befehlsanzahl ist die dynamische Vorhersage etwa 1,24-mal so schnell wie das Warten, denn 1,40/1,13 ≈ 1,24.

Vergleiche bei unterschiedlichen Prozessoren CPI-Wert × Periode. Ein Einzyklusentwurf mit 1000 ps benötigt 1000 ps pro Befehl. Eine Pipeline mit 270 ps und einem CPI-Wert von 1,13 benötigt 305,1 ps pro Befehl, ein Speedup von etwa 3,28. Ein Vergleich allein anhand des CPI-Werts würde den Einzyklus-CPI-Wert von 1 bevorzugen und zum falschen Schluss führen.

Verstehe den nächsten Zielkonflikt beim Entwurf

Mehr Pipelinestufen können die kombinatorische Arbeit pro Zyklus verkürzen. Sie verursachen aber auch Register-Overhead und können die Verzögerungen durch Load-Use-Konflikte und Fehlvorhersagen erhöhen. Die Taktfrequenz allein kann nicht entscheiden, ob der tiefere Entwurf gewinnt.

Mehrfachausgabe startet mehrere Befehle pro Zyklus und ermöglicht einen CPI-Wert unter 1 und mehr als 1 Befehl pro Taktzyklus (IPC). Statische Ausgabegruppen wählt der Compiler; bei dynamischer Ausgabe, der superskalaren Ausführung, entscheidet die Hardware und nutzt häufig Spekulation und Ausführung außerhalb der Programmreihenfolge. Datenabhängigkeiten und Sprungvorhersage begrenzen weiterhin die nutzbare Überlappung.