Om precies te zijn is de rek in het verhogen van de kloksnelheid er wel zo'n beetje uit (zonder het energieverbruik te laten exploderen) en zit de research
juist in het verhogen van het aantal instructies per clock tick.
Even heel kort:
Eerst verhoogden we de clocksnelheid door pipelining. Leuk idee, maar om nou je adders te splitsen over twee stages... Hoe korter de stages, hoe meer buffers je nodig hebt, dus dat houdt vroeg of laat op (een paar jaar geleden om precies te zijn). Zoek de ontwikkeling van kloksnelheden maar eens op, dat groeide lekker snel van 66 MHz naar een GHz, maar sindsdien groeit het veel minder snel (let op dat je naar de echte kloksnelheid kijkt; een Athlon 4800+ draait op 2,4 of 2,5 GHz (afhankelijk van de stepping),
niet op 4,8 HGz!).
Tegelijk daaraan bedachten ze bij Intel out-of-order executie. Stel je hebt drie instructies, C := A + B, E := C + D en Z := X + Y. Dan kun je ze wel op volgorde uitvoeren, maar vanwege dat pipelinen moet je wachten tot C := A + B helemaal klaar is voordat je met E := C + D kunt beginnen. Het is dan sneller om eerst even Z := X + Y de pipeline in te sturen terwijl je wacht totdat je kunt beginnen met E := C + D. Het (in hardware) uitzoeken van geldige volgordes is echter een nogal lastig verhaal en kost tegenwoordig net zoveel ruimte op je chip als de ALU zelf. [Sommige nieuwe architecturen, zoals Larrabee en Cell, gebruiken geen OOO, juist omdat ze de transistoren die dat kost liever gebruiken voor een extra ALU.]
Als je het aantal clocks-per-seconde niet verder omhoog kunt gooien dan moet je dus het aantal instructies-per-clock opschroeven. Ooit leek het ideaal om zo dicht mogelijk bij de 1 te komen (elke clock een instructie uitvoeren), maar toen bedacht iemand dat je je helemaal niet door die magische grens tegen hoeft te laten houden, je gooit gewoon meerdere executie eenheden op een chip (als ik me goed herinner heeft bijvoorbeeld de Athlon 64 er 3). Zeker in combinatie met OOO kun je dan best meerdere instructies per clock uitvoeren. Het nadeel is echter vergelijkbaar: veel management-overhead.
Let erop dat tot hier er nog steeds maar één thread per keer kan worden behandeld. Dus bijvoorbeeld OOO herordent de instructies van een enkele thread (zorgen dat dat allemaal goed gaat zodra het OS opeens van thread wil wisselen levert nog meer overhead op). Hierna kwam het idee van hyperthreading; zelfs met OOO komt het vaak zat voor dat je zit te wachten totdat vorige instructies klaar zijn of (nog veel erger) dat trage geheugen eindelijk eens een keer zijn data aanlevert (nee, ik wil niet eens denken aan het inlezen van een memory page vanuit virtueel geheugen (harde schijf) naar fysiek geheugen, dat duurt helemaal een eeuwigheid). Dan is het fijn als je een andere thread (die in principe immers volkomen onafhankelijk is) bij de hand hebt, want daar zitten waarschijnlijk wel instructies in die vast de pipeline in kunnen. Om heel eerlijk te zijn weet ik niet precies wat hier de nadelen van zijn, maar ze moeten er zijn want Intel heeft het na een tijdje eruit gegooid (al komt het nu weer terug) en AMD heeft het nooit gebruikt.
Om
nog meer instructies tegelijk te kunnen verwerken kwamen daarna de multi-cores. Tot op zekere hoogte is dit vergelijkbaar met een combinatie van meerdere execute units en hyperthreading: meer hardware die daadwerkelijk aan het rekenen is (in plaats van overhead) en meer onafhankelijke instructie-stromen (threads) die verwerkt kunnen worden. Het verschil tussen een dual core zonder hyper threading en een single core met hyper threading is natuurlijk dat een dual core niet over kan schakelen naar de andere thread (die draait immers op een andere core) als er even niks te doen is.
Het probleem waar multicores tegenaan lopen is dat threads de vervelende neiging hebben om met elkaar te willen communiceren (expliciet via IPC, of impliciet via het gebruik van hetzelfde geheugen). Hoe meer cores je hebt, hoe meer communicatie bandbreedte er nodig is. Dat wil Intel nu oplossen via optische interconnects, met een hoge bandbreedte en (vermoedelijk) minder ruimte op de chip.
Huiswerk: zoek een plaatje op van een moderne processor (bijvoorbeeld via
deze pagina) en zoek de volgende onderdelen op: integer alu, fp alu, integer register file en fp register file. Hoeveel procent van de ruimte nemen deze ongeveer in? Toch zijn dit zo ongeveer de enige eenheden die daadwerkelijk werk verzetten, alle andere zooi die er omheen gebouwd zit (OOO-unit, branch prediction unit, instruction fetch / decode units, memory management unit, TLB en alle caches) dient alleen maar om te zorgen dat die ALUs zo efficiënt mogelijk aan het werk gehouden worden.
edit:
Ehm, dat was een iets langere post dan ik had verwacht...
[Reactie gewijzigd door robvanwijk op 29 juli 2024 14:32]