Datapad en pipelining van een processor

Een datapad bewaart en bewerkt de waarden die een instructie nodig heeft. De besturingseenheid stuurt die waarden en geeft toestemming om te schrijven. Samen voeren ze instructies uit zoals add, sub, and, or, ld, sd en beq.

Volg waarden tussen klokflanken

Een toestandselement onthoudt een waarde: de programmateller, de registerbank en het datageheugen zijn voorbeelden. Een combinatorisch element produceert uitvoer uit zijn huidige invoer. Optellers, multiplexers, de ALU en de generator voor onmiddellijke operanden doen dit werk zonder het resultaat van een instructie tussen cycli op te slaan.

Op de actieve klokflank leggen toestandselementen hun volgende waarden vast. Tussen klokflanken voeden hun uitgangen de combinatorische logica. De PC kan daardoor gedurende een cyclus het huidige adres leveren en aan het einde ervan het volgende adres vastleggen. Het lezen van een toestandselement overschrijft de opgeslagen waarde niet.

Ophalen en toegang tot registers

De programmateller (PC) bevat het instructieadres. Het instructiegeheugen levert de 32-bitsinstructie op dat adres. In dit model wordt het alleen gelezen terwijl het programma draait en zoekt het de instructie bij een adres op. Een afzonderlijke opteller vormt PC + 4 omdat de instructies in deze deelverzameling 4 bytes innemen.

De registerbank bevat x0–x31. Twee leespoorten ontvangen de bronnummers rs1 en rs2 en leveren hun waarden. Eén schrijfpoort ontvangt doelregister rd, te schrijven gegevens en RegWrite. Leesbewerkingen zijn combinatorisch; een vrijgegeven schrijfbewerking wordt op de klokflank opgeslagen. Register x0 levert bij lezen altijd nul op en negeert schrijfbewerkingen. RV64-registers bevatten 64 bits. Een RV32-versie gebruikt 32-bitsregisters en lw/sw, met dezelfde basisverbindingen.

Berekenen, selecteren en het geheugen benaderen

De rekenkundig-logische eenheid (ALU) telt op, trekt af of voert een bitsgewijze bewerking uit. Een 4-bitsbesturingscode selecteert de bewerking. De Zero-uitgang is 1 als het resultaat nul is; aftrekken kan daarom testen of twee waarden gelijk zijn.

De generator voor onmiddellijke operanden, ImmGen, reconstrueert de onmiddellijke operand van een instructie en past tekenuitbreiding toe tot 64 bits. Door de tekenbit te kopiëren blijft een negatieve waarde behouden. Het 12-bitspatroon 1111 1111 1000 stelt −8 voor; nuluitbreiding zou er 4088 van maken en een geheugenbewerking naar het verkeerde adres sturen.

Een multiplexer, of mux, selecteert één invoer. Multiplexers kiezen de tweede ALU-operand, de te schrijven registergegevens en de volgende PC. Een multiplexer verandert de route; een schrijfvrijgavesignaal bepaalt of een opgeslagen waarde verandert.

Het datageheugen heeft ingangen voor adres en te schrijven gegevens, een uitgang voor gelezen gegevens en de besturingssignalen MemRead en MemWrite. Een laadinstructie moet tijdens dezelfde enkele cyclus een instructie ophalen en gegevens benaderen. Afzonderlijke instructie- en datageheugens maken beide toegangen mogelijk. Afzonderlijke optellers laten ook toe dat PC + 4 en het sprongdoeladres worden berekend terwijl de ALU ander werk doet.

Ongebruikte uitgangen kunnen tijdens een cyclus nog steeds veranderen. Correcte besturing houdt in dat alleen de geselecteerde uitgangen terechtkomen bij vrijgegeven schrijfbewerkingen naar toestandselementen. Een berekende waarde op een niet-geselecteerde draad heeft geen effect op het programma.

Begin met wat elke instructie moet lezen en wat ze moet veranderen. Het gedeelde datapad combineert deze routes, met een multiplexer overal waar alternatieve waarden bij één ingang samenkomen.

Haal de instructie op en decodeer de velden

Bij het ophalen wordt de PC gebruikt om het instructiegeheugen te lezen en wordt parallel PC + 4 berekend. De opcode staat in bits 6–0. Waar aanwezig staat rd in bits 11–7, funct3 in 14–12, rs1 in 19–15 en rs2 in 24–20; funct7 van het R-type staat in bits 31–25. Door de vaste posities van de bronvelden kan het lezen van registers beginnen terwijl de besturing van de instructie wordt gedecodeerd. Een opslaginstructie of voorwaardelijke sprong heeft geen rd-veld: bits 11–7 dragen bij aan de onmiddellijke operand.

Vergelijk de uitvoeringsroutes

Bij een laadinstructie is het ALU-resultaat een effectief adres, het adres van de te lezen gegevens. De geheugenuitvoer gaat vervolgens terug naar de registerbank. Een opslaginstructie vormt ook een adres met de ALU, maar haar tweede bronwaarde gaat afzonderlijk naar de ingang voor te schrijven gegevens van het geheugen. Als de onmiddellijke operand als ALU-operand wordt geselecteerd, mag die op te slaan waarde niet verloren gaan. ImmGen reconstrueert de offset van het S-formaat uit de twee groepen bits.

Een voorwaardelijke sprong voert twee bewerkingen parallel uit. De ALU trekt de vergeleken registerwaarden van elkaar af; Zero geeft aan of ze gelijk zijn. De sprongopteller telt de byteoffset met teken op bij de eigen PC van de spronginstructie. De codering van het B-formaat laat de lage bit weg die altijd nul is. ImmGen kan de volledige byteoffset reconstrueren, inclusief die nul; een tekening die in plaats daarvan de offset in eenheden van halve woorden genereert, vereist een verschuiving van één bit naar links. De verschuiving hoort precies één keer in de route thuis.

Voeg de routes samen met multiplexers

ALUSrc selecteert de waarde van rs2 of de onmiddellijke operand voor de tweede ALU-ingang. MemtoReg selecteert het ALU-resultaat of de uitvoer van het datageheugen om naar een register terug te schrijven. PCSrc selecteert PC + 4 of het sprongdoeladres. Twee concurrerende resultaten hebben een selector nodig, geen draad die hun uitgangen rechtstreeks verbindt.

Deze routes verklaren waarom de laadinstructie de langste keten heeft: ophalen, register lezen, adres berekenen, geheugen lezen en register schrijven dragen allemaal bij. Rekenkundige instructies gaan buiten het datageheugen om; een opslaginstructie gaat buiten het terugschrijven naar een register om.

Breid de bestaande routes uit

addi x5, x6, 3 hergebruikt de ALU-route met een onmiddellijke operand als invoer en de route voor het terugschrijven van het ALU-resultaat. De instructie heeft passende besturing nodig, maar geen nieuwe eenheid in het datapad. jal heeft een aanvullende eis: de instructie schrijft PC + 4 naar rd en leidt tegelijk de PC om zonder op gelijkheid te testen. De selector voor het terugschrijven heeft daarom een ingang voor PC + 4 nodig en de logica voor de volgende PC moet een onvoorwaardelijke sprong ondersteunen.

Als je een instructie volgt, verbind je de assembleerbewerking met werkelijke waarden op de draden. Onderscheid waarden die tijdens de cyclus worden berekend van waarden die op de afsluitende klokflank worden opgeslagen.

Gebruik een vaste volgorde

1. Haal op vanaf de huidige PC en herken de instructievelden.
2. Lees bronregisters en vorm de onmiddellijke operand met teken.
3. Selecteer de ALU-operanden en bereken het resultaat.
4. Voer de gevraagde toegang tot het datageheugen uit.
5. Selecteer de te schrijven registergegevens en de volgende PC.
6. Vermeld de schrijfbewerkingen naar toestandselementen op de klokflank.

Tel twee registerwaarden op

Op PC 400 heeft add x5, x6, x7 de codering 0x007302B3. De velden zijn opcode 0110011, rd 5, funct3 000, rs1 6, rs2 7 en funct7 0000000. Met x6 = 25 en x7 = −9 leveren de leespoorten 25 en −9. ALUSrc selecteert de tweede registerwaarde en de ALU produceert 16. MemtoReg selecteert 16 om terug te schrijven. Op de klokflank wordt x5 gelijk aan 16 en de PC gelijk aan 404. MemRead en MemWrite zijn beide nul.

Laad een dubbelwoord en sla er daarna een op

Bekijk op PC 404 de instructie ld x5, 16(x6) met x6 = 1000 en het geheugen op 1016 dat 42 bevat. ImmGen levert 16. De ALU berekent het adres 1016 en het datageheugen levert 42. MemtoReg selecteert die geheugenwaarde, zodat x5 op de klokflank gelijk wordt aan 42 en de PC gelijk aan 408. Als je 1016 naar x5 zou schrijven, zou je het adres verwarren met de waarde die daar is opgeslagen.

Op PC 408 leest sd x5, 24(x6) de waarden x5 = 42 en x6 = 1000. De ALU berekent 1024 terwijl de rs2-route 42 aan het geheugen levert. MemWrite geeft toestemming voor de opslag; RegWrite is nul. Op de klokflank wordt het dubbelwoord op 1024 gelijk aan 42 en de PC gelijk aan 412. Het geheugenadres en de op te slaan waarde gaan over verschillende draden.

De offsets worden gemeten in bytes. Aangrenzende RV64-dubbelwoorden beginnen 8 bytes uit elkaar: na het dubbelwoord op 1016 begint het volgende op 1024. Als je één byte opschuift, bereik je het volgende dubbelwoord niet.

Beslis over een sprong

Op PC 412 vergelijkt beq x8, x9, 12 x8 = 7 met x9 = 7. De ALU trekt af en krijgt nul. Branch is 1, dus Branch AND Zero is 1 en PCSrc selecteert het sprongdoeladres. De sprongopteller produceert 424 door 12 bij 412 op te tellen. Alleen de PC verandert.

Als x9 in plaats daarvan 8 is, levert de aftrekking −1 op en is Zero 0. De volgende PC is dan 416. De gecodeerde offset is uitgedrukt in eenheden van 2 bytes, dus de opgeslagen waarde met teken voor deze verplaatsing van 12 bytes is 6; de volledige verplaatsing die de opteller gebruikt, blijft 12.

Lees de toestand voor de volgende instructie

Elke instructie die in één klokcyclus wordt uitgevoerd, voltooit haar werk tussen opeenvolgende klokflanken. De volgende instructie leest de toestand die op de vorige klokflank is opgeslagen. Zo kan de opslaginstructie de nieuwe x5-waarde van de laadinstructie in de volgende cyclus lezen zonder rechtstreekse doorsturing in een pipeline. Elke instructie duurt één klokcyclus, wat een CPI van 1 oplevert voor uitvoering in één cyclus, ongeacht hoeveel hardware-eenheden de route gebruikt.

De hoofdbesturingseenheid vertaalt een opcode naar stuursignalen en schrijftoestemmingen. Het is een combinatorische waarheidstabel die met logische poorten is geïmplementeerd: hardbedrade besturing.

Geef elk signaal een taak

RegWrite geeft toestemming om naar rd te schrijven. ALUSrc selecteert de tweede ALU-invoer: 0 voor rs2, 1 voor een onmiddellijke operand. MemRead en MemWrite vragen de bijbehorende toegang tot het datageheugen aan. MemtoReg selecteert de te schrijven registergegevens: 0 voor het ALU-resultaat, 1 voor geheugengegevens. Branch duidt een voorwaardelijke sprong op basis van gelijkheid aan. De 2-bits-ALUOp geeft de afzonderlijke ALU-besturingseenheid aan welke bewerkingsklasse nodig is.

PCSrc is anders: het hangt af van de instructie en de vergeleken waarden. De hoofdbesturing activeert Branch en de ALU levert Zero. Hun AND vormt PCSrc, zodat een gewoon rekenkundig resultaat van nul op zichzelf geen sprong kan veroorzaken.

Stel de tabel op vanuit de vereiste handelingen

Voor ld heeft de ALU een onmiddellijke offset nodig, dus ALUSrc is 1. De geladen gegevens gaan naar rd, waardoor MemtoReg en RegWrite beide 1 zijn. Het geheugen wordt gelezen, niet beschreven, wat MemRead = 1 en MemWrite = 0 geeft. Branch is 0 en ALUOp = 00 vraagt om optelling voor het adres.

Voor sd telt de ALU ook een offset op, maar het doel is het geheugen. Stel MemWrite = 1 en RegWrite = 0 in. MemRead blijft nul: het geheugen gebruiken betekent niet dat je het leest. Voor beq gebruikt de ALU beide registerwaarden en trekt die van elkaar af, terwijl de enige mogelijke wijziging van de architecturale toestand die van de PC is.

Gebruik onverschillige waarden alleen waar resultaten worden genegeerd

X is een onverschillige waarde: beide selectiewaarden geven hetzelfde gedrag. MemtoReg mag X zijn voor een opslaginstructie of voorwaardelijke sprong omdat RegWrite nul is. De ingang voor te schrijven gegevens van de registerbank wordt genegeerd, zodat de ontwerper de selectiewaarde mag kiezen die de schakeling vereenvoudigt.

Een vrijgavesignaal voor het schrijven van toestand mag niet zo worden behandeld als schrijven verboden is. Een onbedoelde MemWrite tijdens een rekenkundige instructie kan het geheugen beschadigen, ook al heeft de instructie de uitvoer van dat geheugen verder niet nodig. RegWrite en MemWrite moeten daarom expliciet nul zijn voor instructies die deze schrijfbewerkingen niet uitvoeren.

Voeg een rij toe voor rekenen met een onmiddellijke operand

addi x5, x6, 3 haalt de tweede operand uit ImmGen en schrijft de ALU-som. De rij is ALUSrc 1, MemtoReg 0, RegWrite 1, MemRead 0, MemWrite 0, Branch 0, ALUOp 00. De opcode 0010011 verschilt van de R-type-opcode 0110011, dus de hoofdbesturing heeft deze extra rij nodig. Om andi en ori te ondersteunen, moeten ook hun funct3-waarden worden gedecodeerd om de bewerking te selecteren.

Signaalnamen hangen af van het ontwerp. RegWEn, BSel en WBSel in diagrammen van andere cursussen beschrijven verwante taken voor schrijfvrijgave en invoerselectie. Volg de definitie van een signaal en de multiplexeringangen ervan wanneer je een nieuw diagram leest.

De opcode alleen kan add niet van sub onderscheiden: beide behoren tot de R-type-klasse. Besturing op twee niveaus herkent eerst de klasse en gebruikt daarna de functiebits waar die van belang zijn.

Van ALUOp naar bewerking

De hoofdbesturing levert naast haar andere uitvoer een 2-bits-ALUOp. De ALU-besturing combineert die met funct3 en instructiebit 30, onderdeel van funct7, om vier besturingsbits voor de bewerking te produceren.

Deze codes beschrijven deze ALU-implementatie, geen RISC-V-instructiecoderingen. Laad- en opslaginstructies gebruiken ALUOp 00 omdat ze een basis en een offset optellen. Voorwaardelijke sprongen op basis van gelijkheid gebruiken ALUOp 01 omdat aftrekken Zero oplevert wanneer de operanden gelijk zijn. R-type-instructies gebruiken ALUOp 10 en vereisen verdere decodering.

Volg een gecodeerde aftrekking

sub x5, x6, x7 heeft de codering 0x407302B3. De opcode 0110011 duidt het R-type aan en selecteert ALUOp 10. De funct3 is 000, zodat optellen en aftrekken de mogelijkheden zijn. Bit 30 is 1, afkomstig uit funct7 0100000, dus de ALU-besturing levert 0110 voor aftrekken.

Als je die functiebit in nul verandert, krijg je de bijbehorende add-codering 0x007302B3, met funct7 0000000 en ALU-besturing 0010. De rij van de hoofdbesturing blijft hetzelfde omdat beide instructies twee registeringangen gebruiken, een ALU-resultaat schrijven en het datageheugen niet benaderen.

Hergebruik de opteller voor aftrekken

In de klassieke ALU stellen de besturingslijnen Ainvert, Bnegate en een 2-bitsselector voor de bewerking voor. Aftrekken gebruikt de opteller nadat de tweede operand is geïnverteerd en een inkomende overdracht van 1 is toegevoegd:

Door deze tweecomplementidentiteit kunnen optellen en aftrekken hardware delen. Het verschil in Bnegate verklaart de codes 0010 en 0110; er is geen afzonderlijke rekenkundige route voor elke instructie nodig.

Decodeer bits alleen in het juiste formaat

Bij ALUOp 00 of 01 selecteren de posities van de functievelden de ALU-bewerking niet. De funct3 011 van een laadinstructie beschrijft een toegang tot een dubbelwoord. De hoge bits van opslaginstructies en voorwaardelijke sprongen bevatten bits van een onmiddellijke operand. Als je die posities als R-type-functievelden zou behandelen, zou je adresvorming verwarren met rekenkundige decodering.

Voor een snelle R-type-controle selecteert ALUOp 10 met funct3 110 de code 0001, de OR-bewerking. Om een andere bewerking onder dezelfde opcode toe te voegen, hoeft mogelijk alleen de ALU-besturing te worden aangepast als de ALU die bewerking al ondersteunt. Een nieuwe instructieklasse kan ook wijzigingen in de hoofdbesturing vereisen, zoals bij rekenen met een onmiddellijke operand.

Een processor die elke instructie in één klokcyclus uitvoert, moet zijn langzaamste instructie vóór de volgende klokflank voltooien. Snellere instructies wachten nog steeds op dezelfde vaste klokperiode. Pipelining verandert hoeveel werk elke klokperiode moet bevatten.

Bepaal de grens bij uitvoering in één cyclus

Gebruik deze onderdeelvertragingen, zonder multiplexers en kleine optellers mee te rekenen: ophalen 250 ps, register lezen 150 ps, ALU 200 ps, datageheugen 250 ps en register schrijven 150 ps.

De laadinstructie vormt het kritieke pad en bepaalt de periode op 1000 ps, ofwel 1 ns. Dat is een klokfrequentie van 1 GHz. Een mix van 25% laadinstructies, 10% opslaginstructies, 50% R-type-instructies en 15% voorwaardelijke sprongen heeft een gewogen padvertraging van 800 ps. Toch krijgt elke instructie 1000 ps, wat 1,25 keer dat gemiddelde is. Een gemiddelde vertraging kan geen klokperiode bepalen die ook lang genoeg moet zijn voor de langste instructie.

Laat vijf stappen overlappen

De pipeline verdeelt de uitvoering in IF (ophalen), ID (decoderen en register lezen), EX (uitvoeren of een adres berekenen), MEM (datageheugen benaderen) en WB (een register schrijven). Verschillende instructies bevinden zich gelijktijdig in verschillende stappen.

Doorvoer telt het aantal voltooide instructies per tijdseenheid. Latentie meet de tijd die één instructie vanaf binnenkomst tot voltooiing doorbrengt. Een lopende band kan per interval één product voltooien, ook als elk product meerdere intervallen nodig heeft om erdoorheen te gaan. Hetzelfde onderscheid geldt hier.

De langzaamste stap duurt 250 ps. Met 20 ps tijdsoverhead van het pipelineregister is de klokperiode 270 ps, ongeveer 3,70 GHz. Eén instructie doorloopt vijf perioden en duurt 1350 ps. Dat is langer dan haar latentie bij uitvoering in één cyclus, maar een volle pipeline kan elke 270 ps een instructie voltooien.

Neem de vul- en voltooiingstijd mee

Zonder wachtcycli voert een pipeline met k stappen n instructies uit in k + n − 1 cycli. Voor vijf stappen is dit n + 4. Vier instructies hebben acht cycli nodig en duren 2160 ps, tegenover 4000 ps in de processor die elke instructie in één klokcyclus uitvoert. De versnellingsfactor is ongeveer 1,85.

Voor 1.000.000 instructies heeft de pipeline 1.000.004 cycli nodig, ongeveer 270,0 μs. Het ontwerp dat elke instructie in één klokcyclus uitvoert, heeft 1000 μs nodig. De versnellingsfactor benadert de verhouding 1000/270, ongeveer 3,70, naarmate de vaste kosten van het vullen en leeglopen klein worden.

Een perfecte vijfvoudige versnelling zou vijf even langzame stappen van 200 ps vereisen zonder registeroverhead of vertragingen door conflicten. Bij ongelijke stappen wachten snellere stappen op de langzaamste. Meer stappen voegen ook overhead toe en kunnen de kosten van conflicten verhogen.

Vaste 32-bitsinstructies in deze deelverzameling vereenvoudigen het ophalen. Vaste registervelden helpen ID en de beperking van toegang tot het datageheugen tot laad- en opslaginstructies past bij adresberekening in EX gevolgd door MEM. Deze eigenschappen van de instructiesetarchitectuur maken de stapgrenzen praktisch.

Meerdere instructies delen het datapad tegelijk, dus elke stap heeft de waarden van zijn eigen instructie nodig. Pipelineregisters bewaren die waarden en hun besturingssignalen op elke klokflank.

Stem de inhoud af op later werk

Elk register is genoemd naar de aangrenzende stappen. Het legt de uitvoer van de eerste stap vast voor gebruik in de tweede. Na WB is er geen extra pipelineregister; WB schrijft de architecturale toestand. De PC levert de toestand aan het begin van het ophalen.

De bovenstaande inhoud van EX/MEM ondersteunt een ontwerp dat de spronginformatie in MEM gebruikt. Een ontwerp dat in EX bepaalt of de sprong wordt genomen, stuurt die informatie eerder terug naar het ophalen. De stap waarin de sprong wordt afgehandeld, bepaalt het aantal extra cycli door het besturingsconflict.

Houd doelregister en gegevens bij elkaar

Een laadinstructie wordt in ID gedecodeerd maar schrijft rd drie cycli later in WB. Op dat moment bevat IF/ID een latere instructie. Als de schrijfpoort rd van die latere instructie zou gebruiken, zou de geladen waarde naar het verkeerde register gaan. Het nummer van het doelregister van de laadinstructie moet daarom naast het resultaat door ID/EX, EX/MEM en MEM/WB worden meegevoerd.

Een opslaginstructie voert op dezelfde manier haar rs2-waarde mee door ID/EX en EX/MEM. Het adres en de gegevens moeten bij dezelfde opslaginstructie horen wanneer ze het datageheugen bereiken. Pipelineregisters bewaren via deze gekoppelde waarden de identiteit van een instructie, ook al zijn er tegelijk meerdere andere instructies actief.

Laat de besturing met de instructie meegaan

De besturing wordt in ID gegenereerd. EX gebruikt ALUSrc en ALUOp; MEM gebruikt Branch, MemRead en MemWrite; WB gebruikt MemtoReg en RegWrite. Elke stap geeft de besturingssignalen die later nodig zijn samen met de gegevens door.

Als de ALU-besturing in EX wordt gedecodeerd, moet ID/EX zowel bit 30 en funct3 als ALUOp meevoeren. R-type-bewerkingen delen ALUOp 10, dus die waarde alleen kan add, sub, AND en OR niet onderscheiden. Een ander geldig ontwerp decodeert de volledige 4-bitsbewerking in ID en voert in plaats daarvan die code mee.

Houd het stappenschema regelmatig

Een R-type-instructie doorloopt MEM zonder het datageheugen te gebruiken. Een opslaginstructie doorloopt WB zonder een register te schrijven. Doordat alle instructies hetzelfde schema met vijf stappen volgen, blijft de volgorde van registerschrijfbewerkingen behouden. Als een R-type-instructie MEM zou overslaan, zou die in dezelfde cyclus als de laadinstructie direct ervoor de enkele schrijfpoort van de registerbank kunnen bereiken.

De registerbank bedient WB en ID in één cyclus door in de eerste helft te schrijven en in de tweede helft te lezen. ID kan dan een waarde zien die een eerdere instructie in die cyclus heeft geschreven. Afzonderlijke instructie- en datageheugens laten IF en MEM gelijktijdig werken.

De meeste informatie gaat vooruit door de pipeline. Bij terugschrijven gaat een resultaat terug naar de registerbank en de sprongbesturing stuurt een beslissing over de volgende PC terug naar het ophalen. Deze lange terugwaartse routes verklaren waarom latere instructies mogelijk hulp nodig hebben voordat een eerdere instructie klaar is.

Een pipelinediagram maakt overlap zichtbaar. Rijen tonen instructies in programmavolgorde en kolommen tonen klokcycli. Elke cel noemt de stap waarin de instructie zich tijdens die cyclus bevindt.

Bouw een trap

Vul voor vijf onafhankelijke instructies IF in voor I1 in cyclus 1, gevolgd door ID, EX, MEM en WB in cycli 2–5. Start I2 één cyclus later en herhaal dit. De namen van de stappen vormen een diagonale trap.

In cyclus 5 zit I1 in WB, I2 in MEM, I3 in EX, I4 in ID en I5 in IF. Als je een kolom van boven naar beneden leest, krijg je een momentopname van één cyclus. Een rij volgen geeft de geschiedenis van één instructie.

Nummer de stappen van IF = 1 tot en met WB = 5. Zonder wachtcycli bereikt instructie i stap s in cyclus i + s − 1. I3 bereikt MEM dus in cyclus 6. De laatste WB-cel geeft de voltooiingscyclus: vijf instructies zijn klaar in cyclus 9.

Vul een momentopname met waarden

Neem I1 als ld x5, 16(x6), met x6 = 1000 en het geheugen op 1016 dat 42 bevat. Neem I2 als een onafhankelijke optelinstructie, I3 als een onafhankelijke aftrekinstructie en I4 als een onafhankelijke OR-instructie. In cyclus 4 leest de laadinstructie het geheugen op 1016, gebruikt I2 de ALU, leest I3 registers en wordt I4 opgehaald. In cyclus 5 schrijft de laadinstructie 42 naar x5. Een kolom bevat werk van meerdere instructies, niet meerdere stappen van de laadinstructie.

Toon een wachtcyclus zonder eerder werk te stoppen

Gebruik nu ld x10, 0(x20) gevolgd door add x11, x10, x12, en daarna een onafhankelijke instructie. Met rechtstreeks doorsturen heeft de direct volgende verbruikende instructie nog steeds één wachtcyclus nodig:

• De laadinstructie zit in IF 1, ID 2, EX 3, MEM 4, WB 5.
• De optelinstructie zit in IF 2, ID 3, opnieuw ID 4, EX 5, MEM 6, WB 7.
• De derde instructie zit in IF 3, opnieuw IF 4, ID 5, EX 6, MEM 7, WB 8.

De optelinstructie wacht in ID terwijl een lege pipelineplaats door EX gaat. De laadinstructie gaat normaal verder; als je die zou stilzetten, zou de waarde die de optelinstructie nodig heeft juist later beschikbaar komen. Elke latere instructie wordt samen met de optelinstructie vertraagd.

Tel de reeks één keer

Een pipeline met vijf stappen heeft zonder wachtcycli n + 4 cycli nodig. Elke ingevoegde wachtcyclus voegt één cyclus toe, wat n + 4 + wachtcycli geeft als er geen andere verliezen zijn. Het voorbeeld met drie instructies eindigt in cyclus 8: drie instructies, vier extra stapintervallen en één wachtcyclus.

De eerste vier cycli vullen de pipeline en de laatste vier laten die leeglopen. Dit zijn twee manieren om naar hetzelfde schema van n + 4 te kijken, geen twee afzonderlijke toeslagen van vier cycli. Bij een lange reeks is hun vaste bijdrage klein; bij een korte reeks kan die de versnellingsfactor overheersen.

Een conflict verhindert dat de volgende instructie in de geplande cyclus wordt uitgevoerd. Om een conflict te analyseren, bepaal je welke voorziening of waarde nodig is, in welke cyclus die nodig is en in welke cyclus die beschikbaar komt.

Onderscheid drie soorten conflicten

Afzonderlijke instructie- en datageheugens nemen het structuurconflict tussen IF en MEM weg. Door de registerbank in de eerste helft van een cyclus te schrijven en in de tweede helft te lezen, kunnen ook WB en ID die delen. Met deze inrichting blijft er in dit model met vijf stappen geen structuurconflict over.

Bepaal de werkelijke producerende instructie

Een lees-na-schrijfafhankelijkheid (RAW) bestaat wanneer een latere instructie een waarde leest die door een eerdere instructie is geschreven. In add x1, x2, x3 gevolgd door sub x4, x1, x5 produceert de optelinstructie x1 en gebruikt de aftrekinstructie die waarde. Zonder hulp leest de aftrekinstructie x1 in ID tijdens cyclus 3, voordat de optelinstructie die in WB tijdens cyclus 5 schrijft.

Een schrijf-na-leesafhankelijkheid (WAR) gebruikt een register opnieuw nadat een eerdere instructie het heeft gelezen. Een schrijf-na-schrijfafhankelijkheid (WAW) geeft twee instructies hetzelfde doelregister. Deze naamafhankelijkheden veroorzaken geen conflicten in het ontwerp met vijf stappen dat instructies in volgorde uitvoert: leesbewerkingen gebeuren in ID en schrijfbewerkingen in WB, in programmavolgorde. Ze zijn wel van belang bij de beslissing of software instructies mag herschikken.

Volg een reeks met herhaalde doelregisters

Bekijk:

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

De RAW-verbanden zijn laden → optellen via x5, optellen → OR via x6 en aftrekken → OR via x5. De OR-instructie heeft de nieuwe x5 van de aftrekinstructie nodig, niet de oudere geladen waarde. Als je alleen naar gelijke registernamen kijkt, kun je deze verandering van producerende instructie missen.

De aftrekinstructie schrijft x5 nadat de optelinstructie x5 leest: een WAR-afhankelijkheid. De laad- en aftrekinstructie hebben ook een WAW-afhankelijkheid op x5. De OR-instructie schrijft x9 nadat de aftrekinstructie die leest: nog een WAR-afhankelijkheid. Geen van deze afhankelijkheden veroorzaakt een WAR- of WAW-hardwareconflict in deze pipeline die instructies in volgorde uitvoert.

Tel wachtcycli zonder rechtstreeks doorsturen

Met alleen de registerbank waarin eerst wordt geschreven en daarna gelezen, heeft een direct volgende verbruikende instructie twee wachtcycli nodig. Die moet haar leesbewerking in ID uitstellen van cyclus 3 naar cyclus 5. Eén onafhankelijke instructie tussen de producerende en verbruikende instructie vermindert dit tot één wachtcyclus. Door twee onafhankelijke instructies bereikt de verbruikende instructie ID in de WB-cyclus van de producerende instructie en is er geen wachtcyclus nodig.

Een afhankelijkheid is een eigenschap van het programma; of die een wachtcyclus veroorzaakt, hangt af van de timing en de beschikbare routes. Een RAW-afhankelijkheid over grotere afstand vereist mogelijk geen actie. Register x0 levert nooit een nog te schrijven resultaat, omdat het bij lezen altijd nul oplevert en schrijfbewerkingen negeert.

Software kan nop-instructies invoegen of onafhankelijk werk naar wachtintervallen verplaatsen. Hardware kan resultaten rechtstreeks doorsturen of automatisch wachtcycli invoegen. Beide aanpakken moeten ervoor zorgen dat elke verbruikende instructie de waarde krijgt die haar producerende instructie in programmavolgorde schrijft.

Een ALU-resultaat bestaat voordat het wordt teruggeschreven naar een register. Rechtstreeks doorsturen leidt dat resultaat direct naar de ingang van een latere instructie, zodat niet op de registerbank hoeft te worden gewacht.

Selecteer de bron voor elke operand

Twee multiplexers voeden de uitvoeringsroutes. ForwardA bedient rs1 en ForwardB bedient rs2. Elke operand wordt afzonderlijk gecontroleerd.

De EX/MEM-route bereikt de direct volgende instructie. De MEM/WB-route bereikt een instructie twee plaatsen verder en kan een ALU-resultaat of geladen gegevens doorgeven. ForwardB voedt ook de route voor op te slaan gegevens voordat ALUSrc tussen die waarde en een onmiddellijke operand kiest.

Controleer toestemming, doelregister en overeenkomst

Voor ForwardA = 10 moet de instructie in EX/MEM RegWrite = 1 hebben, een rd ongelijk aan nul en een rd die gelijk is aan ID/EX.rs1. Vervang rs1 door rs2 voor de ForwardB-controle. Een opslaginstructie of voorwaardelijke sprong mag niet als producerende instructie worden behandeld alleen omdat haar instructiebits toevallig op een doelregisternummer lijken. Schrijfbewerkingen naar x0 mogen ook geen doorgestuurde waarden worden.

Controleer voor ForwardA = 01 op dezelfde manier RegWrite, rd ongelijk aan nul en de overeenkomst van registernummers voor MEM/WB. Gebruik dit oudere resultaat alleen wanneer EX/MEM de vereiste operand nog niet levert. ForwardB volgt onafhankelijk dezelfde voorrangsregel.

Volg één resultaat naar latere verbruikende instructies

Begin met add x1, x2, x3, waarbij x2 = 10 en x3 = 5. De instructie produceert 15 aan het einde van EX in cyclus 3.

• De volgende instructie, sub x4, x1, x5, bereikt EX in cyclus 4. Met x5 = 3 levert ForwardA = 10 de waarde 15 en geeft de aftrekking 12.
• and x6, x7, x1 bereikt EX in cyclus 5. ForwardB = 01 haalt x1 uit MEM/WB.
• or x8, x1, x9 leest registers in ID tijdens cyclus 5, na de schrijfbewerking van de add-instructie in de eerste helft. Er is geen rechtstreekse doorsturing in EX nodig.

Voor deze afhankelijkheden van ALU-resultaten is geen wachtcyclus nodig. De verbruikende instructie ontvangt de waarde wanneer ze de ALU gebruikt, ook als haar eerdere leesbewerking in ID een verouderde waarde opleverde.

Los twee overeenkomende schrijvende instructies op

In drie opeenvolgende instructies add x1, x1, x2, add x1, x1, x3 en add x1, x1, x4 komen zowel EX/MEM als MEM/WB overeen met rs1 van de derde instructie. EX/MEM bevat het resultaat van de tweede add-instructie, de nieuwste x1. MEM/WB bevat het resultaat van de eerste add-instructie en krijgt geen voorrang.

Via dezelfde routes kan add x5, x6, x7 de instructie sd x5, 0(x8) zonder wachtcyclus van gegevens voorzien. De doorgestuurde x5 bereikt de route voor te schrijven geheugengegevens terwijl de ALU van de opslaginstructie de onmiddellijke offset gebruikt.

Rechtstreeks doorsturen kan geen gegevens leveren voordat ze bestaan. EX/MEM bevat bij een laadinstructie haar adres, niet de geladen waarde. De direct volgende verbruikende instructie moet wachten totdat de laadinstructie MEM heeft voltooid; als je het adres zou doorsturen, zou de instructie ongemerkt met de verkeerde grootheid rekenen.

Een laadinstructie produceert gegevens aan het einde van MEM. De direct volgende instructie zou die gegevens aan het begin van EX in dezelfde cyclus nodig hebben. Eén wachtcyclus verplaatst de EX-stap van de verbruikende instructie naar de volgende cyclus, wanneer MEM/WB de waarde kan leveren.

Detecteer de ontbrekende waarde in ID

De conflictdetectie-eenheid onderzoekt de instructie in EX en de instructie die wordt gedecodeerd. De basiscontrole is ID/EX.MemRead = 1 en een overeenkomst tussen ID/EX.rd en een van beide bronnummer­velden in IF/ID. Een verfijnde controle sluit rd = x0 uit en controleert welke bronvelden de gedecodeerde instructie werkelijk leest.

Deze laatste controle voorkomt een onnodige wachtcyclus bij een I-type-instructie waarvan de bits van de onmiddellijke operand op de gebruikelijke rs2-positie staan. Ruwe veldposities vergelijken is veilig, maar kan een instructie vertragen die het register niet werkelijk leest.

Houd later werk tegen en laat de laadinstructie doorgaan

De wachtcyclus voert drie samenhangende handelingen uit:

1. Zet de besturingssignalen die ID/EX ingaan op nul en voeg zo een lege pipelineplaats in.
2. Stel PCWrite = 0 in om het ophaaladres ongewijzigd te houden.
3. Stel IF/IDWrite = 0 in om de instructie te behouden die in ID wacht.

De laadinstructie en eerdere instructies gaan verder. De lege pipelineplaats gaat door latere stappen zonder registers of geheugen te schrijven. Als je ID/EX zou stilzetten terwijl de laadinstructie er nog in zit, zou die worden herhaald in plaats van een lege bewerking in te voegen.

Bij ld x10, 0(x20) gevolgd door add x11, x10, x12 zit de laadinstructie in EX en de optelinstructie in ID tijdens cyclus 3. In cyclus 4 zit de laadinstructie in MEM, de lege pipelineplaats in EX en de optelinstructie nog steeds in ID. In cyclus 5 zit de laadinstructie in WB en bereikt de optelinstructie EX met ForwardA = 01.

Plan onafhankelijke instructies

Bekijk:

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)

Het gebruik van x11 en x13 volgt direct op de bijbehorende laadinstructies. Met rechtstreeks doorsturen veroorzaakt dit twee wachtcycli, wat 7 + 4 + 2 = 13 cycli oplevert. Verplaats ld x13, 16(x20) naar de derde plaats, vóór de eerste optelinstructie. Daarmee komt er ruimte tussen de laadinstructie voor x11 en de verbruikende instructie en staat x13 ver genoeg vóór de verbruikende instructie. De reeks duurt nu 7 + 4 = 11 cycli.

De verplaatsing is geldig omdat de laadinstructie x20 leest en de instructies waarover ze wordt verplaatst dat register niet veranderen. Het doelregister x13 beïnvloedt die instructies niet. Het adres x20 + 16 verschilt van x20 + 24 van de opslaginstructie waarover ze wordt verplaatst. Een laadinstructie mag niet over een opslaginstructie worden verplaatst die mogelijk de bytes schrijft die zij leest. Herschikking moet RAW-, WAR-, WAW- en geheugenafhankelijkheden behouden.

Combineer wachtcycli en rechtstreeks doorsturen

Bij ld x5, 0(x10), add x6, x5, x7, sub x5, x8, x9 en or x9, x6, x5 veroorzaakt alleen het direct opeenvolgende laad-gebruikpaar een wachtcyclus. Wanneer OR EX bereikt, levert ForwardA = 01 de x6 van de optelinstructie en ForwardB = 10 de x5 van de aftrekinstructie. Het totaal is 4 + 4 + 1 = 9 cycli.

Het ophalen heeft elke cyclus een nieuw adres nodig. Een voorwaardelijke sprong levert de juiste keuze pas na de vergelijking en de berekening van het doeladres. Dit tijdsverschil veroorzaakt een besturingsconflict.

Koppel de beslissingsstap aan de vertraging

In een pipeline met vijf stappen waarin na de beslissingsstap wordt omgeleid, gaat bij een verkeerde voorspelling één ophaalplaats verloren als de uitkomst aan het einde van ID bekend is. Een beslissing aan het einde van EX kost er twee; aan het einde van MEM drie. Tijdens die plaatsen zijn al latere instructies binnengekomen.

Eén strategie laat het ophalen wachten totdat over elke sprong is beslist. Dat is eenvoudig, maar zowel genomen als niet-genomen sprongen kosten de volledige wachttijd. Bij voorspellen dat de sprong niet wordt genomen gaat het ophalen daarentegen verder vanaf PC + 4. Een juiste voorspelling vereist geen herstel. Een genomen sprong leidt het ophalen om en gooit de latere instructies op de opeenvolgende route weg.

Volg een genomen sprong

Haal beq x1, x2, 16 op adres 100 op in cyclus 1 en beslis aan het einde van EX in cyclus 3 of de sprong wordt genomen. De voorspelling dat de sprong niet wordt genomen, haalt de adressen 104 en 108 op in cycli 2 en 3. Als de sprong wordt genomen, zijn beide instructies van de verkeerde route. Het ophalen begint in cyclus 4 op 116, na een vertraging van twee cycli.

Door pipeline-instructies ongeldig te maken kunnen die latere instructies de architecturale toestand niet veranderen of uitzonderingen veroorzaken. De implementatie kan pipelineplaatsen ongeldig maken of hun besturingssignalen en gevolgen van uitzonderingen onderdrukken. Een opslaginstructie op de verkeerde route mag nooit daadwerkelijk naar het geheugen schrijven.

Een lege pipelineplaats is niet hetzelfde als een RISC-V-instructie met alleen nullen. De codering met alleen nullen is ongeldig. Als een echte instructiecodering wordt ingevoegd, is de standaard-nop gelijk aan addi x0, x0, 0, gecodeerd als 0x00000013. Een ongeldig gemaakte pipelineplaats stelt daarentegen geen uitgevoerde instructie voor.

Beslis eerder, maar zorg eerder voor operanden

Door de vergelijker en de opteller voor het sprongdoeladres naar ID te verplaatsen, daalt de vertraging door omleiding tot één cyclus. De vergelijking heeft nu bronwaarden in ID nodig, dus alleen de gebruikelijke rechtstreekse doorsturing naar EX is onvoldoende. Met geschikte rechtstreekse doorsturing naar ID wacht een sprong direct na de producerende ALU-instructie één cyclus. Direct na een producerende laadinstructie wacht die twee cycli. Eerder beslissen ruilt minder verloren ophaalplaatsen in voor hogere eisen aan de levering van operanden.

Statische sprongvoorspelling legt vooraf een regel vast. Gebruikelijke regels zijn altijd niet genomen, altijd genomen en achterwaarts genomen/voorwaarts niet genomen. Een achterwaartse sprong onderaan een lus herhaalt de lus vaak, waardoor die richting een nuttige aanwijzing is.

RISC-V heeft geen vertragingsplaats na een sprong. Als een sprong wordt genomen, wordt de opeenvolgende instructie erna niet uitgevoerd alleen omdat die is opgehaald. Sommige oudere MIPS-ontwerpen lieten die volgende instructie uitvoeren als een gedefinieerde instructie op een vertragingsplaats; dat is een andere regel van de instructiesetarchitectuur.

Behoud een precieze uitzonderingsgrens

Een ongeldige instructie of ecall draagt de besturing over aan een afhandelingsroutine. Eerdere instructies worden voltooid; de instructie die de uitzondering veroorzaakt en latere instructies leggen hun normale effecten niet vast. De processor registreert de PC van de betreffende instructie en de oorzaak, met registers zoals sepc/scause in supervisorstand of mepc/mcause in machinestand, en haalt daarna instructies op vanaf de afhandelingsroutine. Deze precieze uitzondering toont de toestand als een grens tussen voltooid eerder werk en niet-voltooid later werk.

Dynamische sprongvoorspelling leert van uitkomsten die worden waargenomen terwijl een programma draait. Een spronggeschiedenistabel bewaart kleine toestandsitems die worden geselecteerd met bits uit een sprongadres. Voorspel eerst, vergelijk later met de werkelijke uitkomst en werk daarna het item bij.

Bekijk waarom één bit tweemaal mist bij een lus

Een 1-bitsvoorspeller bewaart de vorige uitkomst. Als de laatste sprong werd genomen, voorspelt de voorspeller dat die de volgende keer wordt genomen; anders voorspelt die dat de sprong niet wordt genomen. Bij een herhaaldelijk uitgevoerde lus waarvan de sprong negen keer wordt genomen en daarna één keer niet, blijft de bit na het verlaten van de lus op niet genomen staan.

Bij de volgende uitvoering wordt de eerste genomen sprong verkeerd voorspeld. De tussenliggende genomen sprongen trainen de bit op genomen, zodat ook het uiteindelijke verlaten van de lus met een niet-genomen sprong verkeerd wordt voorspeld. In de stabiele toestand zijn dat twee fouten in tien uitkomsten, ofwel 80% nauwkeurigheid.

Voeg een tweede bit toe voor meer bestendigheid

Een 2-bits-verzadigende teller heeft toestanden 0 tot en met 3. Toestanden 0 en 1 voorspellen niet genomen; 2 en 3 voorspellen genomen. Een genomen uitkomst verhoogt de teller en een niet-genomen uitkomst verlaagt die. De waarden stoppen bij 0 en 3.

Vanuit toestand 3 brengt één niet-genomen sprong bij het verlaten van de lus de toestand naar 2, die nog steeds genomen voorspelt. De eerste sprong bij de volgende uitvoering van de lus wordt daarom correct voorspeld. Dezelfde lus met tien uitkomsten heeft in de stabiele toestand één fout per uitvoering, ofwel 90% nauwkeurigheid. Vanuit een sterke toestand zijn twee opeenvolgende tegengestelde uitkomsten nodig om een voorspelling om te keren.

Volg eerst de voorspelling en werk daarna bij

Begin in toestand 1 en observeer genomen, genomen, niet genomen, genomen:

1. Toestand 1 voorspelt niet genomen: fout. Verhoog naar 2.
2. Toestand 2 voorspelt genomen: goed. Verhoog naar 3.
3. Toestand 3 voorspelt genomen: fout. Verlaag naar 2.
4. Toestand 2 voorspelt genomen: goed. Verhoog naar 3.

Er zijn twee fouten en de eindtoestand is 3. Als je vóór het voorspellen zou bijwerken, zou de voorspeller ten onrechte toegang krijgen tot de uitkomst die hij moet voorspellen.

Onderscheid richting, doeladres en verstoring

Twee sprongadressen kunnen hetzelfde item in de spronggeschiedenistabel indexeren. Door deze aliasing kunnen hun uitkomsten elkaar verstoren. Een verkeerde voorspelling kost cycli, maar bij het herstel wordt de werkelijke uitkomst gecontroleerd en blijft de correctheid behouden.

Een sprongdoelbuffer levert een adres, niet alleen een richtingsbit. De buffer wordt tijdens IF met de PC geraadpleegd en kan vóór de decodering het voorspelde doeladres van een genomen sprong leveren voor de volgende ophaalcyclus. De richtingsvoorspelling bepaalt of dat doeladres wordt gebruikt.

Eenvoudige geschiedenis heeft grenzen. Bij een strikt afwisselend patroon van genomen/niet genomen blijft een 1-bitsvoorspeller verkeerd voorspellen zodra die het patroon volgt. Een 2-bitsteller heeft het hoogstens de helft van de keren goed; als die vóór een genomen uitkomst in toestand 1 begint, zit die er elke keer naast. Correlerende sprongvoorspellers voegen recente spronggeschiedenis toe, toernooivoorspellers kiezen tussen voorspellers en een terugkeeradresstack voorspelt doeladressen van terugkerende procedures. Diepere pipelines maken herstel duurder omdat zich vóór de beslissing meer later werk ophoopt.

De snelheid van een pipeline hangt af van zowel de klokperiode als de cycli die aan wachten of herstel worden besteed. Effectieve CPI meet die extra cycli gemiddeld over de instructiestroom.

Weeg elke kostenpost naar de getroffen instructies

Begin voor een lange reeks waarbij maximaal één instructie per cyclus wordt uitgegeven met de ideale CPI 1. Tel elke afzonderlijke, niet-overlappende oorzaak van verloren cycli erbij op als fractie getroffen instructies maal verloren cycli per gebeurtenis. Een voorwaardelijke fractie heeft ook de bovenliggende fractie nodig.

Stel dat 25% van de instructies laadinstructies zijn en 40% van die laadinstructies een direct volgende verbruikende instructie heeft. Elk zo'n paar veroorzaakt één wachtcyclus, dus de bijdrage van laad-gebruikconflicten is 0,25 × 0,40 × 1 = 0,10 cycli per instructie. Stel dat 15% voorwaardelijke sprongen zijn, 10% daarvan verkeerd wordt voorspeld en herstel twee cycli kost. De bijdrage van sprongen is 0,15 × 0,10 × 2 = 0,03.

Als je de onafhankelijke kosten optelt, krijg je CPI = 1 + 0,10 + 0,03 = 1,13. Als je elke laadinstructie één wachtcyclus zou aanrekenen, zou dat 0,25 in plaats van 0,10 opleveren. Als je de 10% verkeerd voorspelde sprongen op elke instructie zou toepassen, zou je op dezelfde manier te veel tellen.

Neem klokperiode en aantal instructies mee

Uitvoeringstijd is gelijk aan aantal uitgevoerde instructies × CPI × klokperiode. Een klokfrequentie van 4 GHz heeft een periode van 0,25 ns. Voor 10⁹ instructies met CPI 1,13 duurt de uitvoering 10⁹ × 1,13 × 0,25 ns = 0,2825 s. De gemiddelde tijd per instructie is 0,2825 ns.

Tel voor een korte reeks de cycli voor vullen, leeglopen en conflicten expliciet. De ideale basis-CPI van 1 beschrijft de stabiele doorvoer; een pipeline met vijf stappen die maar enkele instructies uitvoert, heeft ook een bijdrage van vier cycli voor vullen en voltooien.

Vergelijk sprongstrategieën onder gelijke voorwaarden

Houd de kosten van laad-gebruikconflicten op 0,10, de sprongfractie op 0,15 en de vertraging op twee cycli:

Bij dezelfde klokperiode en hetzelfde aantal instructies is dynamische voorspelling ongeveer 1,24 keer zo snel als wachten, omdat 1,40/1,13 ≈ 1,24.

Vergelijk verschillende processors met CPI × periode. Een ontwerp dat elke instructie in één klokcyclus van 1000 ps uitvoert, kost 1000 ps per instructie. Een pipeline met 270 ps en CPI 1,13 kost 305,1 ps per instructie, een versnellingsfactor van ongeveer 3,28. Een vergelijking op basis van alleen CPI zou de CPI van 1 bij uitvoering in één cyclus bevoordelen en tot de verkeerde conclusie leiden.

Begrijp de volgende ontwerpafweging

Meer pipelinestappen kunnen het combinatorische werk per cyclus verkorten. Ze voegen ook registeroverhead toe en kunnen de extra cycli door laad-gebruikconflicten en verkeerde voorspellingen verhogen. De klokfrequentie alleen kan niet bepalen of het diepere ontwerp wint.

Meervoudige instructie-uitgifte start meerdere instructies per cyclus, waardoor een CPI onder 1 en meer dan 1 instructie per cyclus (IPC) mogelijk zijn. De compiler kiest groepen voor statische uitgifte; de hardware kiest bij dynamische uitgifte, of superscalaire uitvoering, en gebruikt daarbij vaak speculatie en uitvoering buiten programmavolgorde. Gegevensafhankelijkheden en sprongvoorspelling begrenzen nog steeds de bruikbare overlap.