Slimmer omgaan met instructies
Een van de nieuwe eigenschappen van de Core architectuur was de komst van macrofusion. Om het nut hiervan te begrijpen, is enige kennis van de werking van een processor benodigd. PC processors worden aangestuurd met zogenaamde x86-instructies. Deze instructies, die in jargon macro-operations ofwel macro-ops worden genoemd, kunnen relatief simpel, maar ook zeer compex zijn. Vandaar dat een processor vóór verwerking deze macro-ops omzet naar één of meerdere, simpele micro-ops. Deze micro-ops kunnen door de executions units eenvoudig worden uitgevoerd. Het omzetten van macro-ops in micro-ops gebeurt in de instructie decoder, die we in het schema op de vorige pagina hebben gezien. Simpele macro-ops resulteren eveneens in één micro-op, sommige complexere macro-ops vergen bijvoorbeeld twee of drie micro-ops.
Processors zijn de laatste jaren echter steeds krachtiger geworden en zodoende is het soms mogelijk om twee instructies te combineren en in één keer uit te voeren. Dat is exact wat er gebeurt bij macrofusion: twee relatief simpele macro-ops die binnenkomen worden samengevoegd tot één micro-op en daardoor dus op dubbelle snelheid uitgevoerd. Zo kan de core architectuur bijvoordeeld een compare en branch instructie laten samensmelten, iets wat in veel gevallen voor een aardige prestatiewinst kan zorgen.
Bij de komst van Nehalem komt er ineens een groot nadeel van de macrofusion in de Core architectuur van de Conroe en Penryn processors bovendrijven; deze blijkt immers alleen maar te werken als de processor in 32-bit modus werkt. Vandaar dat sommige software zodra je overstapt op 64-bit Windows op bestaande Intel processors ineens een aantal procenten langzamer kan werken. Bij Nehalem werkt de marcofusion echter ook probleemloos in 64-bit modus.
Een andere flinke verbetering ten opzicht evan de Core architectuur zit hem in de zogenaamde Loop Stream Detector. Ook dit is een technologie die bij de Core architectuur voor het eerst werd geïntroduceerd. De courante Intel processors kunnen loops in programmacode van maximaal 18 instructies herkennen. Zodra zo'n loop is gedetecteerd, worden de instructies niet telkens opnieuw uit de cache of geheugen opgehaald, maar worden ze direct van een loop buffer aan de decoder doorgevoerd, zoals te zien in onderstaande slide.
Bij Nehalem zit die loop detector een stuk slimmer in elkaar. Hij heeft immers een plek áchter de instructiedecoder gekregen. Loops worden zodoende nu dus herkend op micro-op niveau. Dat betekent dus dat zodra een processor met een programmaloop bezig is, de instructies niet telkens opnieuw hoeven te worden gedecodeerd, wat heel wat overhead weghaalt en daardoor voor een aardige prestatiewinst kan zorgen. Daarnaast herkent de nieuwe loop detector series tot maximaal 28 micro-ops. Aangezien in de praktijk in de meeste gevallen iedere macro-op wordt omgezet naar één micro-op, mag je met een schuin oog dit getal vergelijken met het aantal van de core architectuur. Ofwel; de nieuwe loop detecter haalt niet alleen een extra stuk overhead weg, maar werkt ook met langere stukken code.
