Microsoft Singularity Now "Open" Source

Alex_Ionescu writes "Microsoft's Singularity operating system (covered previously by Slashdot) is now open to the public for download, under a typical Microsoft academic, non-commercial license. Inside is a fully compilable and bootable version of what could be the basis for the future of Windows, or maybe simply an experiment to demonstrate .NET's capabilities. Singularity, if you'll recall, has gained wide interest from researchers and users alike, by claiming to be a fully managed code kernel (with managed code drivers and applications as well), something that would finally revolutionize the operating system research arena. The project is available on CodePlex."

Comments

Software Isolated Processes

[parvenu74]

Singularity, if you'll recall, has gained wide interest from researchers and users alike, by claiming to be a fully managed code kernel (with managed code drivers and applications as well), something that would finally revolutionize the operating system research arena. The impression I got by looking at what was known about the project a year ago is that it was of lesser interest that the OS was written in managed code and it was far more interesting that they had solved some problems of inter-process communication in a micro-kernel OS. As you can read at Wikipedia:

Singularity is a microkernel operating system; however, unlike most historical microkernels, the different components do not run in separate address spaces (processes). Instead, there is only a single address space in which "Software-Isolated Processes" (SIP) reside. Each SIP has its own data and code layout, and is independent from other SIPs. These SIPs behave like normal processes, but do not require the overhead penalty of task-switches. Protection in this system is provided by a set of invariants, such as the memory-invariant which states there will be no cross-references (or memory pointers) between two SIPs. Communication between SIPs occur via higher order communication channels managed by the operating system. These rules are checked during the installation phase of the application, and must be fulfilled in order for Singularity to allow the installation (note: in Singularity, installation is managed by the operating system). The promise of Singularity, as I understood it, was the possibility of constructing an O/S kernel with all of the modularity advantages of a microkernel without all of the process communication issues typical to this kernel type.

Re:Software Isolated Processes

[smallfries]

It sounds like a very interesting project. The idea that screams out from the wiki summary is static analysis and verification. There is a really good rundown in one of the wiki links. The really big difference from previous work is not just the use of managed code, but splitting the entire system into either trusted, or verified code. The trusted component is a tiny core, which they are working on verifying. The design of the rest of the kernel and the SIPs is a good one: instead of doing arbitrary verification, change the language design so that you can only write verifiable code. Then see how much of an O/S you can write. The progress is astounding.

For the IPC they have made some strange choices, receiving is synchronous (as in process calculi) but sending is asynchronous. As they are writing the lowest level parts (such as the schedular) in this code it may be an implementation difficulty with synchronous sends. The cheapness of the IPC seems to be routed in the transfer of ownership that communication implies. In essence you can't alias, you can only pass by value - but the low-level runtime can modify this to pass more efficiently by reference because it can verify there are no dangling references. This would (if it works over a large enough code base) solve the performance issue with IPC in a microkernel. It is (as another reply pointed out) similar to providing the semantics of heavy-weight communication to the programmer in a way that can be implemented with cheap co-routines.

Having done some (well, little) work in this area I'm really impressed by what they've achieved already.

Oh wow!

[AKAImBatman]

Managed code! Look at that! Microsoft has managed to prove...

What OSS developers already proved years ago. :-/

Actually, I'm still pretty happy about this. Regardless of whether Microsoft was first or not, they're going to manage to market the concept far better than a conglomeration of OSS developers ever could. (Sorry, guys!) If everything goes well, perhaps the public impression of managed code being "nothing but an interpreter" can finally get turned around and Computer Science can keep moving forward. :-)

Re:Stability?

[wiggles]

Ars Technica says it all.

This OS doesn't really run any applications at all. It's not intended for commercial use, and will not be the next Windows. All it is, is a test bed for future technologies. Think of it as an IT equivalent of a concept car. It doesn't really run, but it's nifty to look at to get ideas for future projects.

there is a thing called the open source definition

[erlehmann]

http://opensource.org/docs/osd

also, repost is repost

Re:!free

[peragrin]

your right. Now compare Minix and Linux. One has a license for you too look at the source code and the other one allows you to actually use the source code and ideas in it.

It's not Open Source until you can use it. BSD, MIT, Apache, GPL, allow you to actually use the code.

Re:!free

[zotz]

"open source = source code is made available"

http://www.opensource.org/

They may have coinded tghe term, they certainly promoted it and made it polular. They disagree.

all the best,

drew

http://zotzbro.blogspot.com/

Re:It's open source because...

[Ctrl-Z]

Have you ever seen an obfuscator? Run your code through one of those and see how easily reversible it is.

Re:!free

[alan_dershowitz]

Why should anyone spend any time learning and working with this tool if their efforts cannot be used commercially? Two reasons: Because it is, allegedly, a highly modern kernel design that (I've read) implements a next-generation security model that is conceptually too different to be bolted on conventional modular monolithic kernels. With an academic, noncommercial license you can use it to to learn about kernels. If you're not interested in or learning about kernels, only potentially using them, then yeah, I concede your point. However, secondly, an academic noncommercial license to the source doesn't preclude Microsoft selling an OS based on that kernel commercially, in which case having the source does have practical value for programmers even if it cannot be modified.

Re:!free

[Timothy Brownawell]

My understanding is that the security model is actually pretty old, and has been around since at least 1979.

Re:!free

[rapierian]

I would point out that there are a couple other microkernels out there that have reached that point. The main one I'm familiar with is BeOS, which is currently being reborn in Haiku.

No spin required: it's kernel Erlang

[Morgaine]

Singularity also introduces a software-isolated process (SIP) mechanism, which makes it possible for lightweight processes to coexist safely with their own sealed code environments in the same memory space. All communication between SIPs is conducted through channels. The use of SIPs effectively eliminates the overhead traditionally incurred by context-switching in conventional microkernels.

In other words, Microsoft finally discovers Erlang.

While I wouldn't go so far as to say that the guys at Redmond lost the habit of inventing anything new a long time ago, the above concepts have been in industrial use in Erlang-powered PTT exchanges since the dawn of time.

Re:Why are people excited about this?

[shutdown -p now]

With verifiable managed code (i.e. the one that doesn't use pointers and such), it is possible to statically prove that it will never access the address space of another process. Once you've done that, you don't need to isolate such processes from each other. This property is already used in .NET with something that MS has called "AppDomains", which allow you to isolate different parts of a single managed process from each other. I would imagine that it can also be useful in a kernel.

Re:It's open source because...

[clintp]

Is there a difference between "managed code" and "interpreted code"? They seem like two words for the same thing.

IANA Microsoft Language Lawyer, but this is what I think the distinctions are:

Managed Code is code intended for a virtual machine (like MS's CLR or Sun's JVM) that abstracts the hardware instructions away. Instead, the instruction set for the virtual machine is used. The Virtual Machine will provide "devices" and "memory" in a (hopefully) safe and portable way and take care of all of the dirty hardware business itself. Some VM's will actually take the VM instruction and turn it into actual hardware instructions as it's being executed (JIT) for speed, but that's not necessary.

Which isn't to say that Managed Code is a new thing: The USCD-Pascal p-code machine is remembered fondly by many, and the Zork games ran on a Z-Machine.

Interpreted code is a little stickier because it's been around a lot longer and has picked up some additional meanings. It can mean anything from the "Managed Code" described above to parsing (and possibly re-parsing) text lines of BASIC as they're run to process them in a giant state machine which "runs" the program.

Usually, interpreted code implies that there's no abstracted fully virtual machine underneath running the code, but possibly just a big jump-table pointing at native assembly-language (hand-coded or compiled) routines. Perl and Microsoft BASIC (basis of many of the old 8-bit BASICs) are two examples of interpreted code.