Nemesis is a new OS kernel developed as part of the Pegasus project. The project's goal is to support high-performance applications, like multimedia applications, by providing Quality of Service (QoS) guarantees. An important difference between Nemesis and other similar developments is that Nemesis is implemented with no backward compatibility constraints whatsoever, in an effort to optimize the outcome for current application needs.
Nemesis is claimed to be an extremely light-weight kernel, with most OS functions being implemented in user domain. From this aspect, Nemesis could be categorized as a microkernel, similar to Mach. Nemesis provides a single virtual address space (SVAS) to the higher level applications. In contrast, all applications in a UNIX system, for example, have the same virtual address space, as if they were executing each one alone. In Nemesis, applications are allocated only parts of the SVAS. Protection between applications is left to hardware protection mechanisms.
Nemesis uses a variation of the process abstraction, named Domain. Each domain consists of an address space, a number of threads and a user-level thread scheduler. Domains defer from typical processes in the level of control they have over themselves. Domains can determine the point within them where control goes to on activation. Also, as thread scheduling is done in user level, a domain has total control over its time slice and there is no need for complicated thread management from the central system scheduler (Domain manager). Domains can also communicate with each other through an event mechanism. Events are managed from the kernel, through a light-weight provided functionality. Nemesis provides a fast inter-domain communication mechanism through the use of events and shared memory as buffer for messages. The data are not copied into and out of the kernel, with obvious advantages in speed and flexibility.
Another important feature is device stubs. These are pieces of code that run in supervisor mode and implement an abstraction layer over devices. They allow creating a clean device interface and tailoring devices for specific needs. Device stubs act as an extra level of interrupt handlers. Every time a device creates an interrupt, the corresponding device stub is engaged and decides whether and how to propagate the interrupt to the main scheduler and the rest of the system.
The most important feature of Nemesis is its QoS Manager. The QoS manager is a system server that implements the admission control process for applications that have QoS demands. An interesting feature is that the QoS manager accepts high-level QoS requests and translates them into low-level parameters that are passed to the domain manager to guide it into scheduling the various applications.
Nemesis provides virtual address space areas that can be distributed over different machines. To support contiguous areas of the SVAS (its implementors use the term `stretch' for such areas), distributed or not, Nemesis is equipped with an entity called Stretch driver. Each machine has a unique stretch driver, which generally supports the stretches in that machine. Through it, processes can attach stretches in other machines and access them. Stretch drivers mainly exist to support such distributed stretches.
A visit at Nemesis web page establishes the fact that this report is outdated. The more recent documentation on Nemesis puts forward the idea of moving as much functionality as possible into application domain instead of server domain. Noting that servers in user space over microkernels are as much of a bottleneck as traditional kernels, Nemesis's implementors propose a direct low-level multiplexing of resources between applications. This is something not clearly described in this early report. Also, I couldn't find any further documentation on supporting distributed SVAS between different machines, which may have been abandoned. Nemesis's performance results indicate that it can support high-performance applications with QoS demands in a robust way, but this report does not support such a claim in a persuasive way.