En pipeline är för en kärna vad löpande bandet är i en fabrik. Det är inte ett sätt att parallellt exekvera flera trådar samtidigt, utan ett sätt att seriellt exekvera flera instruktioner samtidigt på en kärna.
Av en rad olika anledningar så vill man inte utföra exekveringen av en instruktion på en klockcykel för processorn. Dels skulle en sån processor bli väldigt långsam, men skulle också bli svår att designa och felsöka.
Så vad man gör är att man delar upp exekveringen av en instruktion i flera mindre delar, och tar de en i taget. Detta har inget med CISCs uppdelning av stora instruktioner till flera mindre instruktioner att göra, där dagens moderna CISC-processorer (x86) i princip "emuleras" på RISC-processorer. Utan även extremt enkla RISC-instruktioner delas upp i flera mindre steg.
(Du kan här läsa mer om exempel på hur stegen kan delas upp för en instruktion, med hämtning, avkodning, beräkning, och att skriva tillbaka resultatet till något minne)
Hur många steg instruktionerna delas upp i motsvarar längden på pipelinen.
Och för att få upp prestandan så kan man seriellt exekvera flera instruktioner samtidigt i en och samma kärna, där för varje klockcykel så utförs varje steg i pipelinen för alla instruktioner i den.
Ungefär som en fabrik som monterar ihop säg bilar, så för varje klockcykel så hoppar varje halvfärdig bil över till nästa station där nästa steg av monteringen utförs.
I extremt simpla processorer där man inte bryr sig om prestanda så kan man välja att inte exekvera mer än en instruktion i taget, men man delar fortfarande upp den i flera steg. Så att processorn tar en instruktion i taget över flera klockcykler. Det är väldigt simpelt, och man förlorar inte någon riktig prestanda på uppdelningen, då man kan höja frekvensen tack vare mindre jobb per cykel.
Så processorn (om det inte är en väldigt simpel sådan) klarar av att exekvera en full instruktion per klockcykel, men gör det inte för en hel instruktion i taget, utan för små delar av många instruktioner samtidigt. Så en full exekvering av en instruktion tar många klockcykler.
Precis som att en fabrik bygger många bilar per dag, men de bygger flera bilar samtidigt seriellt i olika steg, och det tar mer än en dag att bygga en bil från grunden till helt färdigt (gissar jag).
Att seriellt exekvera flera instruktioner samtidigt får ju dock ett antal nackdelar till följd om exekveringen av nästa instruktion bygger på resultatet från den tidigare instruktionen. Det går till viss del att kompensera för det med fler transistorer, där man tillåter resultat hoppa bakåt i löpande bandet en bit, utan att först skrivas till registret och sedan läsas av nästa instruktion.
Men i slutändan hamnar man ändå i att en lång pipeline blir dålig på att hantera relaterade instruktioner.
Men en lång pipeline klarar av högre frekvenser (dock fortfarande med högre strömförbrukning till följd). Så det är lite av en balansgång vad som är bäst, mellan en kort eller en lång pipeline.
