Waarom Microsoft een nieuwe processorarchitectuur uit zijn hoed tovert

Abonneer je gratis op Techzine!

Microsoft demonstreerde hoe zowel Windows als Linux succesvol draaien op een eigen in het geheim ontwikkelde microarchitectuur die sneller moet zijn dan x86 en ARM. Hoe kan dat, en waar is Microsoft plots mee bezig?

Zowel Windows 10 als Linux draaien succesvol op de splinternieuwe Edge-microarchitectuur, ontwikkeld door Microsoft. Dat weet The Register, en verdient meer dan een woordje uitleg. Eerst en vooral: de Microsoft Edge-browser heeft hier niets mee te maken, edge computing aan de rand van de cloud al evenmin. In deze context staat Edge voor Explicit Data Graph Execution. Edge is een alternatief voor de alom bekende x86-microarchitectuur waarop Intel en AMD processors ontwikkelen, en de ARM-architectuur die we vooral van smartphonechips kennen. Microsoft werkt al jaren in het geheim aan Edge-chips onder de noemer E2, en na een klein decennium zwoegen lijkt er schot in de zaak te komen.

Het belang van E2 valt niet te onderschatten. De architectuur verschilt fundamenteel van de bestaande norm. Hoewel x86 en ARM ook sterk van elkaar verschillen, volgen ze wel dezelfde principes. E2 en Edge doen dat niet. Edge moet op termijn kleine en efficiënte microchips mogelijk maken, die veel meer rekenwerk kunnen verzetten dan vergelijkbare processors met de gevestigde architecturen. Dat Microsoft inzet op een nieuwe architectuur is enigszins verrassend, al toonden de bollebozen uit Redmond met de ‘holografische’ processor in de HoloLens al dat ze niet vies zijn van een transistor of een miljard. Als het project aan de verwachtingen voldoet, kan het de pc- en servermarkt wel eens grondig hertekenen. Vooral Intel, dat intussen werkelijk langs alle kanten bestookt wordt door aspirant-concurrenten, mag zich eens verslikken.

 

Als het project aan de verwachtingen voldoet, kan het de pc- en servermarkt wel eens grondig hertekenen

 

Achter de voordeur van de processor

Om te begrijpen wat er zo verschillend is aan de Edge-architectuur, weet je best hoe x86 en ARM (kort door de bocht) omgaan met softwarecode. Traditionele processorkernen zijn in staat om een handvol instructies tegelijkertijd te verwerken. Die instructies komen min of meer op volgorde toe, en staan vervolgens te wachten in de lobby van de processor. Achter de lobby vind je een handvol gangen die de instructies kunnen inslaan, en waar ze vervolgens verwerkt worden. Het resultaat van een verwerkte instructie gaat naar het geheugen, waar een volgende instructie ermee kan verder rekenen.

Niets doen is uit den boze voor iedere processor. Instructies die staan te wachten in de lobby worden soms in een andere volgorde uitgevoerd dan diegene waarin ze door de voordeur bij de processor arriveerden. Zo kan de cpu steeds op maximale capaciteit werken. Out of order excecution heet dat: een belangrijke functie die desalniettemin aan de basis lag van onder andere de Spectre– en de Meltdown-lekken.

Parallelle beperkingen

De traditionele manier van werken is in staat redelijk vlot parallel rekenwerk uit te voeren, zolang er niet te veel instructies tegelijkertijd worden uitgevoerd. De architectuur is niet geoptimaliseerd om code zomaar te verdelen over tientallen gangen om zo tijdswinst te boeken. Logisch: er zijn limieten aan het out of order uitvoeren van instructies. Hoe meer de processor naar toekomstige instructies grijpt, hoe groter de kans dat die data nodig hebben die afkomstig is van een vorige nog niet verwerkte instructie. Voor succesvol parallel rekenwerk moet een processor instructies analyseren op interdependencies, oftewel: andere instructies waar ze eventueel van afhankelijk zijn. Dat kan, maar wordt exponentieel moeilijker naarmate de parallelle capaciteiten van een chip groeien. x86, maar ook ARM, kent hier in de praktijk zijn grenzen.

Andere aanpak

De Edge-architectuur is gebouwd om een antwoord te bieden op die grenzen. Code voor Edge wordt niet instructie per instructie uitgevoerd, maar wel in blokken. In die blokken zitten instructies samen die van elkaar afhankelijk zijn. Ze zijn samengesteld op basis van de ‘data flow’. Voor Edge worden instructies dus gebundeld rekening houdend met de data die ze nodig hebben. Een voorbeeld:

Instructie 1 berekent X + Y, met als resultaat waarde Z

Instructie 2 stelt dat Y x 2 = A

Instructie 3 vraagt of Z =< A

Bovenstaande instructies zitten samen in een blok. Bij aanvang van dat blok worden de waardes voor X en Y vanuit het algemene geheugenregister naar een tijdelijk register voor het blok geschreven. Vervolgens verwerkt de Edge-processor alle instructies binnen het blok met de hulp van dat tijdelijke register. Pas na de verwerking van het hele blok worden de waardes in het tijdelijke register terug naar het algemene register geschreven, zodat andere blokken er mee aan de slag kunnen.

Vergelijk die manier van werken met x86, waar de out of order uitvoering van instructie 3 onmogelijk is zolang instructie 1 en 2 niet zijn uitgevoerd.

De slimme opdeling in blokken opent de deur voor veel meer parallel rekenwerk. Zolang de blokken juist verdeeld zijn volgens de flow van de data, kan een Edge-processor er zonder probleem heel veel tegelijk verwerken. Een Edge-systeem heeft dan ook geen 4 of 8 pipelines, maar wel 32, 64 of zelfs meer.

Coderen voor Edge

De totaal andere manier van werken impliceert dat bestaande software niet zomaar op Microsofts E2-processors kan draaien. Logisch, als je weet dat ARM-software niet op x86 draait en omgekeerd. Om Windows 10 te laten werken op ARM-systemen, moest Microsoft de code van het besturingssysteem immers ook opnieuw compilen om ze compatibel te maken. Specifiek moet software gecompiled voor Edge de data flow in het achterhoofd houden, zodat de processor blokken efficiënt parallel kan verwerken. De data staan dus centraal in de instructie-architectuur. Vandaar de naam: explicit data graph execution.

Hoe groot het potentieel van Edge ook is, zonder enthousiasme van ontwikkelaars en bijhorende toepassingen is E2 een doodgeboren kind. Dat weet Microsoft ook. Daarom houden Nadella en de zijnen het niet op een demonstratie van Windows 10 en Linux op een (gesimuleerde) E2-chip, maar introduceren ze ook tal van gekende ontwikkelaarstools voor de nieuwe architectuur. Denk aan de C, C++ en .Net-bibliotheken, of ook nog de command line tools voor Visual C++. Dat betekent heel concreet dat ontwikkelaars bestaande applicaties eenvoudig kunnen hercompileren naar E2.

Nieuwe vriendschappen

Officieel vertelt Microsoft nog steeds niet al te veel over zijn project. Het basisprincipe voor Edge werd tien jaar geleden al bedacht aan de universiteit van Texas, als onderdeel van het Polymorphous Computing Architectures-programma van de Amerikaanse defensiedenktank DARPA. Dat project leverde een prototype af, waarna het afliep en zowat het voltallige team de overstap maakte naar Microsofts R&D-divisie. De ambitie was destijds om de architectuur in 2018 klaar te hebben, maar het ziet er naar uit dat die deadline te optimistisch was.

Een E2-server hoef je alleszins nog niet meteen in de rekken te verwachten. Momenteel zit het hele project nog volledig in de R&D-fase, maar het is duidelijk dat Microsoft zijn schaakstukken in stelling brengt voor een grootse zet.

De Windowsbouwer schiet zo misschien wel onder de duiven van partner Intel, maar dat wil niet zeggen dat Microsoft alleen staat. Qualcomm werd al aan boord gehaald als partner en zou samen met Microsoft twee incarnaties van het E2-ontwerp onderzoeken. Die samenwerking, gecombineerd met de onthulling van Windows en Linux op E2, illustreert dat we hier niet over een project in de marge spreken. Integendeel: het lijkt erop dat we een glimp mogen opvangen van wat wel eens de toekomst van het processorlandschap kan zijn.