Mach (core)

Mach is an operating system design project started at Carnegie Mellon University with the goal of developing a microkernel.

Target

Mach is an operating system kernel developed at Carnegie Mellon University (CMU) to support operating system research, primarily distributed and parallel computing. The project at CMU ran from 1985 to 1994.

Mach was developed on the premise that all modern operating systems share a number of features in common, or are desired if they don't already have them. These include:

• Support for multiple applications using multitasking.
• Hilos, which can be thought of as the parts of an application, or mini-applications when there is multitasking.
• Multi-processor support, on a single machine or on a network.
• Interprocess communications, sending messages directly between applications.
• Memory protection and safety.

History

At the time, in the early mid-'80s, several projects were trying to solve one of these problems. This typically meant taking an existing operating system - often BSD (UNIX) - and modifying parts of it. After each modification the operating system was compiled, the machine rebooted, and the new change was tested. There were a number of problems with this approach, even the most insignificant errors would cause the entire machine to crash.

Mach explores the concept we now refer to as a microkernel. Instead of having all the code for the operating system in a single large program (called the kernel), most of the code would be located in smaller programs known as servers, which would run like any other program. Core work is essentially reduced by "being" the operating system, to maintain the servers and to schedule their access to the hardware.

In theory this means that changes to the OS. they would require nothing more than a reload of that single server program, as opposed to rebuilding the OS and rebooting the machine. Just working on the Mach kernel itself would require a reboot, and in theory that should be an unusual occurrence.

Mach is not an operating system itself, and is pretty much useless without a set of servers (these servers don't exist). So to get a usable and running system, the Mach authors ported the Unix BSD into the Mach kernel quickly and simply: instead of splitting BSD into different parts and building each as a server, they simply compiled the kernel. integer on a server and ran it. The result was known as POE.

With POE running (effectively) between the other applications, performance was abysmal. Each call by a user agent, say to get the time, required the message to be sent to the kernel (a simple operation known as a context switch), which would send the request to the Unix library with another context switch and then repeat. all over again for the answer... However, Mach, even though it wasn't his own fault, was considered very powerful, but incredibly slow.

Over the next decade, work went into improving the performance of these messages several times, to the point that the performance of these Mach-based operating systems was often better than the BSDs on which they were based.. However by that time the academic world had largely lost interest in SSOO research, and Mach's promise remained unfulfilled.

Today

At the end of the 20th century it was thought that Mach would slowly take over the entire universe of operating systems, but this has not happened. Perhaps the biggest reason for Mach's failure may be "laziness": everyone felt it was someone else's job to deliver the OS-based library, and no one did. The biggest effort to date is GNU Hurd, but GNU Hurd is now about a decade behind schedule. Several proprietary operating systems have been more successful, including QNX which seems to deliver on all of Mach's promises.

Work on Mach took place over several years at CMU, eventually falling dormant as many of the developers left academia to work in industry. The Mach was briefly revived at the University of Utah in the mid-1990s and produced the Mach 4 (http://www.cs.utah.edu/flux/mach4/html/Mach4-proj.html) which had significant improvements, before again becoming inactive.

Meanwhile several vendors have taken practical approaches to using Mach. The BSD layer (and others) was executed directly within the kernel (thus avoiding context swaps) which resulted in reasonable performance while still retaining the advantages of multi-threading and an easy-to-use threading model.. However even these advantages have been eroded as much as the fact that various Unix vendors have worked to provide them in their own products.

Relations with Other Operating Systems

Operating systems based on this Mach concept were OSF/1, NeXTSTEP, and IBM OS/2 for RS/6000-based machines – none of which are widely used anymore. Other operating systems wanted to migrate to this kind of system as well, like Apple's Pink, IBM's Workplace OS, and several more.

Apple selected OPENSTEP to be the basis for the successor to its classic Mac OS. It became Cocoa Mac OS X API. OPENSTEP is actually an updated version of NeXTSTEP, which used Mach 2.5. As such, the Mach/BSD amalgamation of OPENSTEP is the basis for Apple's Mac OS X operating system.

The lead developer on the Mach project, Richard F. Rashid, has been with Microsoft since 1991 in various senior-level positions in Microsoft's research division, Microsoft Research. Microsoft's Windows NT, the precursor to Windows XP, began with a microkernel-based model similar to Mach's. Another of Mach's original developers, Avie Tevanian, was previously head of software at NeXT and until May 2006 was director of Apple's Office of Software Technology.