Deliverable 1
Deliverable 1
Deliverable 1
Abstract
A microkernel operating system provides a small set of basic abstractions typically including primitives for
memory management, interprocess communication, and task management, that provide all necessary hardware
functionality. The rest of the operating system such as the file system, drivers, and daemons / servers are executed
in user land. This paper attempts to inform the reader about the strengths of the microkernel approach, providing a
brief overview of the history and influence of the Mach and L4 kernels, and then looking to the future by presenting
two research operating systems that utilize microkernels: MINIX 3 and Singularity.
I. I NTRODUCTION
It is a commonly held belief that the design of current operating systems have not kept pace with the
evolution of hardware and software. Since the operating system is the foundation of the software stack,
so inadequacies in OS design cascade. Influencing the design of the rest of the software that is run on
it problems with the OS design hinder usability of any software running on it. Historically, maximizing
the speed of linear programs was a primary objective of operating systems design. Monolithic kernels
traditional met this requirement by avoiding the overhead involved with communication between the kernel
and user mode programs. However, this kind of design is not well suited to the needs of evolving modern
technologies. Since microkernels offer a simple set of abstractions to user mode programs, they enable
great flexibility and organization that help careful design of the higher level services and programs. Much
current operating systems research, for example Microsoft’s Singularity Project, and Tenenbaum’s MINIX
3 continue a redesign operating systems using microkernels to support the ever changing ways computers
are used.
Microkernels suffered major setbacks in the late 1980s and early 1990s due to the weak performance of
Mach [3]. However, this problem was partially solved in the creation of the L4 kernel [8] which is much
more efficient than Mach and the dramatic increase in the speed of hardware has made the overhead from
a microkernel more acceptable for many applications. The advantages of Microkernels include simplicity,
extensibility, and security. Their simple design means that bugs are less likely to occur in kernel mode
and that it can be possible to understand the interactions between different components of the system.
Because a microkernel provides only a small set of basic primitives, one microkernel may support a
variety of different approaches to design of the higher levels of abstraction in user land. This extensibility
means that one microkernel, for example L4 can serve both as a virtulization layer in high performance
applications and as a kernel for embedded devices. The modular design of microkernels makes it easier
to isolate processes and resources in the interest of security. Since the microkernel concept supports these
goals of operating systems research, it is natural that cutting edge research projects use them.
Computer users expect their computers to work. MINIX 3 is focused on applications on consumer
machines such as desktops, notebooks, and portable devices. The overhead that comes with reliability
and self healing is too great for high performance applications [5]. Fortunately, consumers have few high
performance needs, instead they use web services and their expensive computation is performed in the
cloud. The goal of MINIX 3 is to achieve a mean time to failure so long that few users would ever
experience a crash. MINIX 3 is built around a microkernel and uses a sophisticated system of daemons
to offer services to programs in user land. The kernel is only 5000 lines of code, compared to 5 millions
lines in the windows XP kernel or 2.5 million lines in the Linux kernel. As the name suggests, MINIX
3 supports a UNIX environment.
Microsoft’s Singularity system is more experimental than MINIX 3, and while their philosophies of
design are similar, their objectives are different [7]. While MINIX 3 accepts the overhead associated with
a microkernel’s use of message passing between many processes, Singularity focuses at performance of
parallel programming and inter-process communication while sacrificing performance of other components.
Most of the Singulariy kernel is written in the Sign# language (an extension of C# created for Singularity)
which is type-safe, and garbage collected. Both systems emphasize a simple design to reduce the likelihood
of bugs.