Wanneer u uw eerste zelfgebouwde CPU ontwerpt, bent u waarschijnlijk blij als deze werkt en hoeft u zich niet zoveel zorgen te maken over de prestaties. Maar uiteindelijk zul je gaan nadenken over hoe je dingen sneller kunt laten verlopen. Voor een enkele CPU is de standaardstrategie het tegelijkertijd uitvoeren van meerdere instructies. Dit is mogelijk omdat u verschillende delen van de instructies tegelijkertijd kunt uitvoeren. Maar zoals de meeste oplossingen brengt ook deze een nieuwe reeks problemen met zich mee. Japanse onderzoekers stellen in een current artikel over een techniek een nieuwe manier voor om een ​​aantal van deze problemen te omzeilen ze noemen Clockhands.

Stel dat u een reeks instructies als deze heeft:

LAAD A, 10
LADING B, 20
SUB A, B
LADING B, 30
JMPZ KLAAR
INC B

Als je dit één voor één doet, heb je geen probleem. Maar als je ze allemaal samen probeert uit te voeren, zijn er verschillende problemen. Eerst moet de aftrekking wachten tot A en B de juiste waarden bevatten. Ook kan de INC B wel of niet worden uitgevoerd, en tenzij we de waarden van A en B van tevoren kennen (wat we hier natuurlijk doen), kunnen we dit pas tijdens de uitvoering weten. Maar het grootste probleem is dat de aftrekking B moet gebruiken voordat B 30 bevat, en de optelling moet het daarna gebruiken. Als alles goed loopt, kan het moeilijk zijn om recht te blijven.

De normale manier om dit te doen is het hernoemen van het register. In plaats van A en B als registers te gebruiken, gebruikt de CPU fysieke registers die hij naar eigen goeddunken A of B (of iets anders) kan noemen. De aftrekking zal dus niet echt SUB A,B zijn, maar – intern – zoiets als SUB R004,R009. De LOAD-instructie voor 30 schrijft naar B, maar dat gebeurt niet echt. Het wijst feitelijk een momenteel ongebruikt register toe aan B en laadt er 30 in (bijvoorbeeld LOAD R001,30). Nu zal de SUB-instructie nog steeds 20 gebruiken (in R009) wanneer deze wordt uitgevoerd.

Dit is een beetje overdreven vereenvoudiging, maar het punt is dat er voldoende circuits in een moderne CPU zitten die nadenken over welke registers in gebruik zijn en welke overeenkomt met een logisch register voor deze specifieke instructie. Eén voorgestelde manier om dit te doen is door niet langer rechtstreeks naar registers te verwijzen, maar in plaats daarvan ernaar te verwijzen op foundation van de afstand waarin ze zich in de code bevinden (bijvoorbeeld SUB A-2, B-1). Dit kan gemakkelijker zijn voor de {hardware}, maar moeilijker voor de compiler.

Waar Clockhands anders is, verwijst het naar het aantal schrijfbewerkingen naar het register, niet naar het aantal instructies. Het lijkt een beetje op het gebruik van een stapel voor elk register en het toestaan ​​dat de instructies verwijzen naar een specifieke waarde op de stapel. De {hardware} wordt eenvoudiger, de compiler hoeft minder te doen. Dit zou mogelijk ook het stroomverbruik kunnen verminderen.

Verward? Lees de krant als je meer wilt weten. Sommige achtergrond van Wikipedia zou ook kunnen helpen. Het deed ons denken aan een CPU-architectuur die vroeger werd genoemd De molen (dode hyperlink binnen, maar er is altijd een kopie). Als u niet wist dat uw CPU-registers niet zijn wat u denkt dat ze zijn, is het gelijk erger dan je denkt.