Een processor voert instructies uit. Tot en met de 80486 processor werd iedere instructie in exact 1 kloktik uitgevoerd, vanaf de Pentium is men overgestapt op een zgn. "superscalar" architectuur waarbij instructies opgesplitst worden in kleinere stukjes.
Ieder van die kleinere stukjes wordt dan in 1 kloktik uitgevoerd (in een eigen pipeline stage van de CPU); het resultaat van de instructie is pas gekend nadat alle deelinstructies doorlopen zijn. Op zich lijkt dit langzamer dan de architectuur van de 80486, maar nadat een eerste deel van één instructie verwerkt is, kan meteen aan het eerste deel van een volgende instructie gewerkt worden.
De maximaal haalbare kloksnelheid van een superscalar CPU wordt bepaald door de langzaamste deelinstructie. Om de kloksnelheid verder te kunnen opvoeren kiezen fabrikanten vaak om die ene deelinstructie verder op te splitsen.
Met de Pentium4 heeft Intel het pad gewandeld van een zo hoog mogelijke kloksnelheid door de deelinstructies zo kort mogelijk te houden (en er meer te creëren indien nodig).
Jammer genoeg heeft een superscalar architectuur ook nadelen. Zo worden instructies niet zomaar in het wilde weg uitgevoerd. Programma's bevatten o.m. selecties waarbij de uit te voeren instructies afhankelijk zijn van het resultaat van een vorige instructie: we noemen dit "branching". De volgende instructies kunnen dan niet uitgevoerd worden vóór het resultaat van de vorige gekend is. Heb je een pipeline met 20 stappen, dan duurt het 20 kloktikken eer je dat resultaat kent. Die hele tijd lang kan je niet weten welke instructies moeten worden uitgevoerd. Je verliest in dit geval 19 kloktikken CPU-tijd. Een CPU met slechts 10 pipeline stages verliest in datzelfde geval slechts 9 kloktikken.
Mocht het verhaal hier eindigen, dan zou geen enkele fabrikant kiezen voor een lange pipeline: branches komen namelijk heel vaak voor in programma's en de CPU zou daardoor een groot deel van de tijd met de vingers draaien.
CPU's "gokken" wat de uitkomst van een selectie zal zijn en voeren de daarbijhorende instructies uit. Mocht achteraf blijken dat er juist gegokt werd, dan zijn de volgende instructies meteen uitgevoerd en win je performance. Werd er verkeerd gegokt, dan moeten de correcte instructies alsnog uitgevoerd worden. Het duurt nu een aantal kloktikken eer deze instructies afgewerkt worden (het aantal kloktikken is gelijk aan het aantal pipeline stages). Hoe langer de pipeline is, hoe meer performance er verloren gaat bij een verkeerde gok.
Een langere pipeline kan winnen van een kortere wanneer die een voldoende veel hogere kloksnelheid kan halen dan de kortere pipeline. Het nadeel van verkeerde gokken wordt dan teniet gedaan door het feit dat iedere stap sneller uitegevoerd wordt.
De fouten waarover de spreker het heeft zijn die "gokfouten".
Bij 2 CPU's die enkel verschillen in aantal pipeline stages zal de CPU met de kortere pipeline de performantste zijn. De reden van bestaan van langere pipelines is immers het halen van een hogere kloksnelheid. Haal je die niet, dan heeft het geen zin. De kloksnelheid is echter niet enkel afhankelijk van de het aantal pipeline stages. Het is ook afhankelijk van de fysieke beperkingen (warmte, elektronenmigratie, ...). Dat is IMHO waar Intel zich aan mispakt heeft met de Pentium4...
Lees hieromtrent ook
dit artikel dat ik een tijdje geleden postte...
