Microsoft speelt met C#-gebaseerde kernel 'Singularity'

In tegenstelling tot wat de meeste mensen denken, is Windows niet het enige besturingssysteem waarin Microsoft zijn tijd en geld investeert. Het softwarebedrijf is met een onderzoeksproject bezig waarmee het inzicht wil verkrijgen in de vraag hoe een besturingssysteem eruitziet dat vandaag de dag wordt gebouwd en als hoofddoel betrouwbaarheid heeft in plaats van prestatie. Hiertoe heeft het bedrijf een besturingssysteem gebouwd, genaamd 'Singularity', waarvan de kernel onlangs met succes werd getest. De interesse van het bedrijf voor de kwestie is terug te voeren op drie zaken met betrekking tot de geschiedenis van Windows. Ten eerste is het pc-platform waarop Windows draait voortgekomen uit een architectuur die hoofdzakelijk uit de jaren zestig en zeventig stamt, en die sindsdien niet fundamenteel is gewijzigd. Ten tweede zijn Microsofts besturingssystemen als het ware 'op elkaar gestapeld' uitgebracht; opeenvolgende versies kunnen steeds in zekere mate als 'patch' van voorgaande versies worden gezien. Ten slotte speelden in de begindagen de problemen van kwaadaardige gebruikers niet, en waren computers niet of nauwelijks via netwerken op elkaar aangesloten.

Singularity is vanaf de grond opgebouwd, waarbij Microsoft ernaar streeft om gebruik te maken van de laatste inzichten op het gebied van sourcecodemanagement, programmeertalen en compilerbouw. De naam van het besturingssysteem slaat op het streven om softwareprocessen zoveel mogelijk geïsoleerd van elkaar te draaien, zodat de een niet onbedoeld de ander beïnvloedt. Hierbij is het niet toegestaan dat processen geheugen delen of hun eigen code wijzigen. Een van de hoofddoelen van Singularity is om tot een besturingssysteem te komen waarbij componenten minder afhankelijk van elkaar zijn. Het OS is geschreven in C# en een afgeleide daarvan genaamd Sing#. De achterliggende gedachte is dat met moderne technieken veiligere code is te genereren dan met oudere technieken, terwijl de snelheid er niet noemenswaardig onder zou lijden. Singularity maakt hiertoe gebruik van een speciaal ontwikkeld compile- en run-time-environment genaamd Bartok. Verder wordt onderzoek gedaan naar tools die op basis van de eigenschappen van componenten betrouwbaar zouden kunnen aangeven in hoeverre het systeem naar behoren draait. Hiertoe is het noodzakelijk dat OS- en softwarecomponenten uitgebreid worden gespecificeerd. Tenslotte moet het besturingssysteem als levend bewijs fungeren dat er op basis van managed code een degelijk OS te realiseren is.

Galen Hunt van Microsoft Research zegt dat de volgende stap in het onderzoekstraject zal bestaan uit het bouwen van componenten bovenop de nu goed werkende kernel. Volgens Hunt heeft het OS geen definitieve commerciële doelstelling. Het zou op den duur als zelfstandig product kunnen worden uitgebracht, of delen ervan zouden als embedded software in apparaten kunnen verschijnen. Maar het is ook mogelijk dat Singularity een onderzoeksstatus houdt, en dat het project slechts wordt gebruikt om van te leren.

Schema van Singularity's architectuur, opgebouwd vanuit de concepten van kernel, geïsoleerde processen en communicatiekanalen

Reacties (62)

[Brainstorm]

Tip: er is ook een video van 50 minuten beschikbaar waarin een paar ontwikkelaar geinterviewd worden. Ik heb hem een tijdje geleden gezien, zeker een aanrader als je meer over het project wilt weten: http://channel9.msdn.com/ShowPost.aspx?PostID=68302

[Verwijderd]

Ik heb het vermoeden dat deze studie eerder voortkomt uit de problemen die Microsoft ondervond toen ze Longhorn aan het ontwikkelen waren, waarbij ze in de problemen kwamen vanwege de veroudere architectuur waardoor de ontwikkeling zolang ging duurde (Denk aan het uitstellen van het paradepaardje WinFS) en zo ingewikkeld werd.

Een van de grootste minpunten, die vaak genoeg aangesneden worden in Windows, is toch wel de stabiliteit en betrouwbaarheid van de kernels. Iedereen kent wel de schitterende BSOD's met al die schitterende info waar je geen moer mee kunt. Tegenwoordig kan de hardware van een desktop computer al het verlies in prestatie opvangen. En de gemiddelde consument heeft liever een iets trager stabiel systeem, dan elke 10 minuten een blauw scherm.

Ik ben zeer benieuwd hoe dit uitpakt. Een compleet nieuwe architectuur voor de komende Windows versies is zeker positief, mits hij compatible blijft met bestaande onderdelen en standaarden. Daarnaast lijkt het erop dat MS eindelijk eens al bij de kernel aan de veiligheid gaat denken! Hebben ze misschien iets geleerd uit het verleden? Ik ben benieuwd

@SuppleX: Ik denk dat het iets te vroeg is om te zeggen of het een concurrent en of de architectuur gebruikt zal worden voor de desktop/server zakelijke/prive markt, maar gezien het feit dat het van MS komt, zullen ze het wel voor allemaal uitbrengen.

[Verwijderd]

Een compleet nieuwe architectuur voor de komende Windows versies is zeker positief, mits hij compatible blijft met bestaande onderdelen en standaarden.

Ik vind nergens letterlijk dat de volgende Windows hierop gebasseerd zal zijn.

Maar enfin, je hebt gelijk, dergelijke structuur zou veel interessanter zijn. Maar compatibiliteit met oudere windowsversies lijkt mij dan nog (té!?) moeilijk(er). Alles werkt anders, heeft een andere structuur, etc...

Mooi dat ze in deze richting ontwikkelen. Die nieuwspost over longhorn/vista ivm de structuur en ontwikkeling etc. deed mij al een beetje meer hoop geven. ( nieuws: Jim Allchin: 'Ontwikkeling Vista in 2004 compleet herzien' )

[Verwijderd]

Maar enfin, je hebt gelijk, dergelijke structuur zou veel interessanter zijn. Maar compatibiliteit met oudere windowsversies lijkt mij dan nog (té!?) moeilijk(er). Alles werkt anders, heeft een andere structuur, etc...

Men zou een emulator kunnen voorzien. Sinds Singularity zodanig opgebouwt is dat ieder programma appart kan draaien zonder in elkaars vaarwater, zou men gerust een emulator layer kunnen starten per win32/win64 programma's van de oude kernel.

Voor programma's zal dat totaal geen erg kunnen. Enkel games zal je mogen vergeten. De CPU kracht is er tegenwoordig voor emulator layer te hebben.

En als je dan full speed wilt, moet je maar een Singularity gebasseerde update kopen.

Ik zie hier persoonlijk veel meer graat in, dan constant upgrade op upgrade van winos. Ik was er gisteren ook nog aan het denken aan. Ik zag de berichten van linux kernel support voor nog meer fat's, dat ik me afvroeg, daim, dat is toch overkill aan het worden ( hoeveel support het al, een dozijn of zo? ).

Een echt nieuwe versie van Windows gebasserde op de Singularity core zou wel een wonderen kunnen doen voor de speed ( hoop oude crap weg ), en vooral security.

[MadEgg]

Ik zag de berichten van linux kernel support voor nog meer fat's, dat ik me afvroeg, daim, dat is toch overkill aan het worden ( hoeveel support het al, een dozijn of zo? ).

Waar heb je het in godsnaam over? Er zit alleen nog steeds maar de noodzakelijke ondersteuning in voor FAT16/FAT32 in Linux, ik weet niet hoe je op een dozijn komt.

Eerlijk gezegd zet ik mijn vraagtekens bij het ontwikkelen van een kernel in zo'n hoge order programmeertaal als C#. Je zit dan niet alleen met het risico van bugs door programmeerfouten zelf, maar ook met het risico van bugs die geintroduceerd worden door fouten in de vertaalslag naar machinecode. IMO is OO niet geschikt voor zulke essentiële onderdelen van het systeem en zouden ze beter C(geen C++ dus) kunnen gebruiken.

[Dennis]

Maar enfin, je hebt gelijk, dergelijke structuur zou veel interessanter zijn. Maar compatibiliteit met oudere windowsversies lijkt mij dan nog (té!?) moeilijk(er). Alles werkt anders, heeft een andere structuur, etc...

Ik denk dat programma's die in .NET (C#) zijn geschreven best wel eens heel gemakkelijk op Singularity zullen werken.

[Xenan]

Iedereen kent wel de schitterende BSOD's met al die schitterende info waar je geen moer mee kunt. [...] En de gemiddelde consument heeft liever een iets trager stabiel systeem, dan elke 10 minuten een blauw scherm.

Dat vind ik zwaar overdreven. Die overdaad aan BSOD's zijn verleden tijd, uit het pre NT 4.0 SP4 tijdperk. Tegenwoordig zie ik *zelden* een BSOD, en dat is dan eigenlijk bijna altijd veroorzaakt door een hardwarestoring.

Neemt niet weg dat het een interessant onderzoek is van MS

[WinL]

Volledig mee eens:

aanvulling (@3x1st4nz3):

Bij een BSOD kan een kerneldump gemaakt worden, dan kun je gemakkelijk nagaan wat fout is gegaan. Daarbij is het redelijk logisch dat Windows het systeem stopzet als een .sys driver de fout in gaat... doordat een .sys driver in vreemd geheugen kan gaan zitten schrijven, is het voor Windows niet mogelijk het te herstellen (stabiliteit en veiligheid komen dan in het geding), een totale stop is dan idd beter.

BSOD: slechte drivers en hardware. Praktisch is het nooit de schuld van het OS zelf.

[dasiro]

Een compleet nieuwe architectuur voor de komende Windows versies is zeker positief, mits hij compatible blijft met bestaande onderdelen en standaarden

1. het zal zeker NIET in een windows gegoten worden
2. compatibiliteit is een enorme hold-back en legt enkel maar beperkingen op.

[Verwijderd]

Ach, ik zie compatible blijven ook als een pre, maar de meeste willen alle programma's en games kunnen blijven gebruiken. daar ben ik het niet mee eens. de enige compatibeliteit die ik wil zien is: het gebruik van standaarden (html, tcp/ip enz. enz.) en de mogelijkheid om oude bestanden (documenten, mp3's enz) te kunnen openen. als dat in een nieuw programma is vind ik dat best, dat maakt niet uit, als het maar werkt. oude prog's vergeten, docs omzetten naar nieuwe systeem en fluitend verder gaan

[J.J.J. Bokma]

Als je elke 10 minuten een BSOD hebt zou ik eens kijken naar hardware uit een betere stal. BSODs die ik gezien heb onder XP kwamen allemaal voort uit een rotte driver.

[foppe-jan]

mja.. even licht OT: winFS zoals ze het nu aan het ontwikkelen zijn vind ik om te janken.. het vreet CPU, het eet ram, en het is zo lomp als wat sinds ze hebben besloten het als schil boven NTFS te plakken.. absoluut onbruikbaar op tragere pc's, en zelfs op huidige systemen zou ik het niet graag gebruiken zonder dat daar een grondige reden voor is [einde OT]

voor de rest grappig dat ze inderdaad zo bezig zijn.. lijkt me een stuk interessanter om aan te werken dan aan Vista ofzo

[TinusH777]

Ik vermoed dat ze dit als laboratoriom gebruiken om verschillende architectuurconcepten te testen.
In C# kun je namelijk veel dit namelijk veel sneller ontwikkelen dan in C++.

Mocht uit een concept interessante resultaten boeken, dan kunnen ze het implementeren in de 'echte' Windows-OS.

Vroeger op de Amiga deed ik hetzelfde: eerste een algoritme uittesten in BASIC. Daarna implementeren in assembler.

[Sgreehder]

Hehe, eindelijk. Betrouwbaarheid boven prestatie; daar kun je tenminste wat mee.

Doet me overigens wel een beetje aan OS X denken, die opbouw

[BezurK]

In welk opzicht? Omdat zowel OS X als dit nieuwe project een microkernel architectuur hebben? Dat is eigenlijk het enige wat ik zo kan bedenken hoor

[WaarAnders]

Hoe lang (manuren) zou het duren om een compleet nieuw OS te ontwikkelen? Dit met het oog op het waarom MS dit doet. Zou het zijn omdat ze met vista tegen problemen aanliepen? Dit antwoord zou gegeven kunnen worden met de manuren vraag (wat was eerder in ontwikkeling, vista of dit?)

[Wouter Tinus]

Microsoft heeft naar eigen zeggen op dit moment geen enkele intentie om hier een volledig OS van te maken. Dat zou de backwards compatibiliteit volledig breken; alle drivers en vrijwel alle applicaties zouden opnieuw geschreven moeten worden om de concepten die in deze kernel worden gebruikt om te kunnen gaan.

Maar als het toch per se wil weten: Longhorn is al veel langer in ontwikkeling, minstens twee jaar eerder dan dit. Bovendien wordt aan Longhorn met duizenden mensen gewerkt, terwijl dit door een klein groepje is gebouwd. Je moet dit soort projecten min of meer zien als een 'hobbywerk' binnen Microsoft, waarmee ze (radicale) nieuwe ideeën uitproberen. Sommige zijn goed en bruikbaar en komen later echt in producten terecht, anderen hoor je nooit meer iets van.

[Verwijderd]

Tja... misschien wordt het eens tijd om van Windows af te stappen. Het begint een beetje verjaard te worden

[xbassiex]

Weet je ook meteen waarom Windows zo k*t werkt...
Uit de jaren 60 en 70 gewoon

[Wolfboy]

Ik vind Unix anders prima werken hoor, en dat stamt uit 1960-1970, Windows kwam "pas" in 1985

[catfish]

net niet, de windows waar we nu mee werken is gebaseerd op NT en die stamt van 1993 (ze zijn uiteraard wel vroeger begonnen), vrij jong dus (ivm Unix)

er is ondertussen natuurlijk wel veel veranderd, men is OO beginnen werken, modulair en nu ook managed

ik denk dat daar ook de kracht van Unix/Linux in zit, dat is eigenlijk ontworpen voor servers met meerdere users, dus netwerken en beveiliging zat er altijd al in
MS heeft z'n best goed windows architectuur proberen aanpassen om dit ook te kunnen, maar dit is natuurlijk moeilijker dan dat je er direct mee had rekening gehouden

[Wolfboy]

De eerste unix versies van AT&T waren anders ook niet zo op beveiliging hoor, de root account kreeg een mooi wachtwoordje maar de backup account (met dezelfde rechten) had geen wachtwoord.
Maar dat is tegenwoordig gelukkig allemaal wel verbeterd gelukkig, maar ook microsoft is hard bezig aan de beveiliging.

Het is en blijft een goed initiatief van ze, ik denk ook niet dat ze zonder een volledig nieuw os te maken (of alle backwards compatibility te verliezen) een veel veiliger systeem kunnen maken van NT.

[dancingdoorman]

Opmerkelijk dat er een met managed taal als C# een OS te bouwen is.
Dit is volgens mij meer een showcase voor C# dan een stuk research voor een volgende Windows versie.

Maar evenzo, het blijft cool!

[Verwijderd]

Je kunt in .NET ook unmanaged code schrijven. Door sommigen geprezen en door sommigen vervloekt

[Verwijderd]

[off topic]
Je kunt zelfs managed en unmanaged code combineren. Vooral interessant als er voor bepaalde hardwarefunctionaliteit wel een unmanaged API is maar geen managed interface. Dus hoewel unmanaged code minder prettig werkt als managed code is het nog steeds onmisbaar. Vervloeken is dan ook een teken van zwakte
[/off topic]

[Verwijderd]

Ik dank MS dat je ook unmanaged code kunt gebruiken in C#. Af en toe heb je dat gewoon nodig.

[Verwijderd]

Zeer interessant om met zo'n hoog niveau programmeertaal een compleet OS te implementeren. Ik vraag me af hoe ze eventuele performanceproblemen die dit ongetwijfeld met zich meebrengt oplossen. Deze zin:

De achterliggende gedachte is dat moderne programmeertalen veiligere code genereren dan oudere technieken die veelal JIT-compilatie toepassen om snelheid te winnen.

is een beetje krom. Ten eerste is het juist C# compiler/runtime environment die JITted code genereert, niet de oudere C/C++ compilers die nu over het algemeen gebruikt worden om low-level OS componenten mee te compilen. Beetje flauw: programmeertalen die code genereren klopt natuurlijk ook niet, dat doen compilers.

[ColdSTone|IA]

Er wordt gebruik gemaakt van de Sing# extensie op C# om low-level dingen te kunnen doen.

Sing# extends this language with support for channels and low-level constructs
necessary for system code.

[kidde]

Zeer interessant om met zo'n hoog niveau programmeertaal een compleet OS te implementeren.

Ooit van Multics gehoord? De 'voorloper' (qua ideeën vooral) van Unix (met gelijke tot zelfs meer mogelijkheden dan Unix) werd ook in een high-level language (PL/I) geprogrammeerd, in de jaren 60 notabene!

[Verwijderd]

De snelheids testen zien er veelbelovend uit:

Cost (CPU Cycles) - Singularity - FreeBSD - Linux - Windows
Read cycle counter - 8 - 6 - 6 - 2
ABI call - 87 - 878 - 437 - 627
Thread yield - 394 - 911 - 906 - 753
2 thread wait-set ping pong - 1,207 - 4,707 - 4,041 - 1,658
2 message ping pong - 1,452 - 13,304 - 5,797 - 6,344
Create and start process - 300,000 - 1,032,000 - 719,000 - 5,376,000

We used FreeBSD 5.3, Red Hat Fedora Core 4 (kernel version 2.6.11-1.1369_FC4), and Windows XP (SP2). Singularity ran with a concurrent mark-sweep collector in
the kernel, a non-concurrent mark-sweep collector in processes (including drivers), and a minimal round-robin scheduler.

[Verwijderd]

worst-case? best-case? average? Ik kan het in het artikel niet vinden. Niet om afbreuk te doen aan het idee van singularity, want er lijkt flink over nagedacht te zijn, maar dit soort tests zijn redelijk makkelijk te beinvloeden. Voor de message ping pong is bijvoorbeeld onder de unix varianten een socket gebruikt en onder de windows varianten een named-pipe en een 'channel', waar is die keuze op gebaseerd?
Singularity heeft natuurlijk wel het voordeel dat er niet geswitched hoeft te worden van user-space naar kernel space en terug voor system calls, waardoor een goede performance geloofwaardig wordt.

[Milt]

Microsoft zou hier wel eens de basis kunnen leggen voor een nieuwe Windows CE. In tegenstelling tot bijv. Windows XP, is Windows CE (en afgeleiden daarvan zoals Windows Mobile for Pocket PC en Windows Mobile for Smartphone) nog steeds grotendeels gebaseerd op de oude Windows NT kernel. Daar boven op heeft Windows CE enige erg vervelende beperkingen (zoals de limiet van max. 32 running processes).

De JIT compiler zou in de hardware opgenomen kunnen worden in de vorm van een dedicated processor naast de normale processor. Daarmee heeft men dan ook gelijk de problemen met alle verschillende typen processoren de wereld uitgeholpen. Omdat de JIT compiler in hardware zit en dus perfect kan aansluiten bij de processor, kan het OS in managed code worden geschreven en is dus processor onafhankelijk.

[Verwijderd]

Kan je mij eens wat links geven waaronder duidelijk en technisch onderbouwt staat dat XP *NIET* een zoveelste borduursel is van de NT kernel ?

Want dat is het namelijk wel.

[Milt]

Uiteraard is de XP kernel gebaseerd op de NT kernel maar er is in de lopen der jaren wel heel veel aan verbertert en verandert. Dit in tegenstelling tot de kernel van Windows CE die nog steeds grotendeels gelijk is aan de (uitgeklede) Windows NT kernel. Dat is eigenlijk wat ik wilde aangeven.