Instruktionspipelining i CPU: Så fungerar pipeline-arkitektur

Fördelar med pipelining:

1. Processorns cykeltid minskas, vilket ökar genomströmningen av instruktioner. Pipelining minskar inte den tid det tar att slutföra en instruktion, utan ökar antalet instruktioner som kan behandlas samtidigt ("på en gång") och minskar fördröjningen mellan avslutade instruktioner (kallas "genomströmning").
   Ju fler pipeline-steg en processor har, desto fler instruktioner kan den bearbeta "samtidigt" och desto mindre är fördröjningen mellan avslutade instruktioner. Varje vanlig mikroprocessor för
   allmänt bruk som tillverkas idag använder minst två pipeline-steg och upp till 30 eller 40 steg.
2. Om pipelining används kan CPU:s aritmetiska logikenhet utformas snabbare, men den blir mer komplex.
3. Pipelining ökar i teorin prestandan jämfört med en kärnan utan pipelining med en faktor som motsvarar antalet steg (om man antar att klockfrekvensen ökar med samma faktor) och koden är idealisk för pipeline-utförande.
4. Processorer med pipeliner arbetar i allmänhet med en högre klockfrekvens än RAM-frekvensen (från och med 2008 års teknik arbetar RAM med låga frekvenser jämfört med CPU-frekvenser), vilket ökar datorns totala prestanda.

Nackdelar med pipelining:

Pipelining har många nackdelar, även om det finns många tekniker som används av processor- och kompilatorkonstruktörer för att övervinna de flesta av dem; nedan följer en lista över vanliga nackdelar:

1. En icke-pipelinerad processor är enklare och billigare att tillverka, eftersom den endast utför en enda instruktion åt gången. Detta förhindrar fördröjning av förgreningar (i Pipelining fördröjs varje förgrening) och problem när seriella instruktioner utförs samtidigt.
2. I en pipelinerad processor ökar instruktionsfördröjningen genom att flipflops sätts in mellan modulerna jämfört med en icke-pipelinerad processor.
3. En icke-pipelinerad processor kommer att ha en definierad instruktionsgenomströmning. Prestandan hos en pipelinerad processor är mycket svårare att förutsäga och kan variera kraftigt för olika program.
4. Många konstruktioner innehåller pipelines som är så långa som 7, 10, 20, 31 eller ännu fler steg; en nackdel med en lång pipeline är att när ett program förgrenar sig måste hela pipelinen spolas (rensas). Den högre genomströmningen hos pipelines blir inte tillräcklig när den exekverade koden innehåller många förgreningar: processorn kan inte veta i förväg var nästa instruktion ska läsas och måste vänta på att förgreningsinstruktionen avslutas, vilket gör att pipelinen bakom den blir tom. Denna nackdel kan minskas genom att förutsäga om en villkorlig greninstruktion kommer att grena baserat på tidigare aktivitet. Efter att förgreningen är avklarad måste nästa instruktion resa hela vägen genom pipeline innan dess resultat blir tillgängligt och processorn fortsätter att "arbeta" igen. I sådana extrema fall kan prestandan hos en pipelineprocessor vara sämre än hos en icke-pipelineprocessor.
5. Tyvärr är inte alla instruktioner oberoende. I en enkel pipeline kan det krävas fem steg för att slutföra en instruktion. För att kunna arbeta med full prestanda måste denna pipeline köra fyra efterföljande oberoende instruktioner medan den första avslutas. Någon av dessa fyra instruktioner kan vara beroende av den första instruktionens resultat, vilket gör att pipelinekontrolllogiken måste vänta och lägga in ett stopp eller en bortkastad klockcykel i pipelinen tills beroendet har lösts. Lyckligtvis kan tekniker som forwarding avsevärt minska antalet fall där det krävs fördröjning.
6. Självmodifierande program kan misslyckas med att exekvera korrekt på en pipelined-arkitektur när instruktionerna som modifieras ligger nära de instruktioner som utförs. Detta kan orsakas av att instruktionerna kanske redan finns i Prefetch Input Queue, så att ändringen kanske inte får effekt för den kommande exekveringen av instruktionerna. Instruktionscacher gör problemet ännu värre.
7. Faror: När en programmerare (eller kompilator) skriver assemblerkod utgår de i allmänhet från att varje instruktion utförs innan nästa instruktion utförs. När detta antagande inte bekräftas genom pipelining leder det till att ett program beter sig felaktigt. Det finns
   olika tekniker för att lösa faror eller för att kringgå dem, t.ex. forwarding och fördröjning (genom att lägga in ett stopp eller en bortkastad klockcykel).

Generisk pipeline

Till höger visas en generisk pipeline med fyra steg:

1. Hämta
2. Avkoda
3. Utför
4. Återskrivning

Den övre grå rutan är listan över instruktioner som väntar på att utföras, den nedre grå rutan är listan över instruktioner som har slutförts och den mittersta vita rutan är pipelinen.

Utförandet sker på följande sätt:

Bubbla

När en "hicka" (avbrott) i utförandet inträffar skapas en "bubbla" i pipelinen där inget användbart händer. I cykel 2 försenas hämtningen av den lila instruktionen och avkodningssteget i cykel 3 innehåller nu en bubbla. Allt som ligger bakom den lila instruktionen försenas också, men allt som ligger framför den lila instruktionen fortsätter att utföras.

Jämfört med utförandet ovan ger bubblan en sammanlagd utföringstid på 8 klockticks i stället för 7.

Bubblor är som en fördröjning, där inget användbart händer under hämtning, avkodning, exekvering och återskrivning. Det är som en NOP-kod (förkortning för No OPeration).

Exempel 1

En typisk instruktion för att addera två tal kan vara ADD A, B, C, som adderar värdena i minnesplatserna A och B och sedan placerar resultatet i minnesplats C. I en pipelineprocessor skulle pipelinecontrollern dela upp detta i en serie uppgifter som liknar följande:

Platserna "R1" och "R2" är register i CPU:n. De värden som finns lagrade på minnesplatserna "A" och "B" laddas (kopieras) till dessa register, adderas sedan och resultatet lagras på minnesplatsen "C".

I det här exemplet består pipelinen av tre steg: ladda, utföra och lagra. Varje steg kallas pipeline-steg.

På en icke-pipelinerad processor kan endast ett steg arbeta åt gången, så hela instruktionen måste slutföras innan nästa instruktion kan påbörjas. På en pipelined-processor kan alla steg arbeta samtidigt med olika instruktioner. Så när denna instruktion är i utförandestadiet kommer en andra instruktion att vara i avkodningsstadiet och en tredje instruktion kommer att vara i hämtarstadiet.

Exempel 2

För att bättre förstå konceptet kan vi titta på en teoretisk pipeline i tre steg:

och en pseudokod som ska exekveras:

Så här skulle det genomföras:

LOAD-instruktionen hämtas från minnet.

LOAD-instruktionen utförs medan MOVE-instruktionen hämtas från minnet.

LOAD-instruktionen befinner sig i Store-stadiet, där dess resultat (siffran 40) kommer att lagras i register A. Under tiden utförs MOVE-instruktionen. Eftersom den måste flytta innehållet i A till B måste den vänta på att LOAD-instruktionen avslutas.

STORE-instruktionen laddas, medan MOVE-instruktionen avslutas och ADD beräknas.

Och så vidare. Observera att en instruktion ibland är beroende av resultatet av en annan instruktion (som i vårt exempel MOVE). När mer än en instruktion hänvisar till en viss plats för en operand, antingen genom att läsa den (som en ingång) eller skriva den (som en utgång), kan utförandet av dessa instruktioner i en ordning som skiljer sig från den ursprungliga programordningen leda till den ovan nämnda riskfyllda situationen.

• Pipeline (databehandling)
• Parallell beräkning
• Parallellism på instruktionsnivå