Page 45 - DCAP403_Operating System

Operating System

Notes most commonly to improve a program’s performance. It also allows programmers to choose
what level of abstraction they want, high, or low.
Exokernels can be seen as an application of the end-to-end principle to operating systems, in that
they do not force an application program to layer its abstractions on top of other abstractions that
were designed with different requirements in mind.

Example: In the MIT Exokernel project, the Cheetah web server stores preformatted
Internet Protocol packets on the disk, the kernel provides safe access to the disk by preventing
unauthorized reading and writing, but how the disk is abstracted is up to the application or the
libraries the application uses.

Operating systems define the interface between applications and physical resources.

Unfortunately, this interface can significantly limit the performance and implementation
freedom of applications. Traditionally, operating systems hide information about machine
resources behind high-level abstractions such as processes, files, address spaces and interprocess

communication. These abstractions define a virtual machine on which applications execute; their
implementation cannot be replaced or modified by untrusted applications.

Hardcoding the implementations of these abstractions is inappropriate for three main reasons:
1. It denies applications the advantages of domain-specifi c optimizations,
2. It discourages changes to the implementations of existing abstractions, and

3. It restricts the flexibility of application builders, since new abstractions can only be added
by awkward emulation on top of existing ones (if they can be added at all).
These problems can be solved through application level resource management in which traditional
operating system abstractions, such as Virtual Memory (VM) and Interprocess Communication
(IPC), are implemented entirely at application level by untrusted software. In this architecture, a
minimal kernel-called an exokernel-securely multiplexes available hardware resources. Library
operating systems, working above the exokernel interface, implement higher-level abstractions.
Application writers select libraries or implement their own. New implementations of library
operating systems are incorporated by simply relinking application executables. Applications
can benefit greatly from having more control over how machine resources are used to implement

higher-level abstractions. The high cost of general-purpose virtual memory primitives reduces
the performance of persistent stores, garbage collectors, and distributed shared memory systems.

Application-level control over file caching can reduce application-running time considerably.

Application-specific virtual memory policies can increase application performance. The

inappropriate file-system implementation decisions can have a dramatic impact on the
performance of databases. The exceptions can be made an order of magnitude faster by deferring
signal handling to applications.
To provide applications control over machine resources, an exokernel defines a low-level

interface. The exokernel architecture is founded on and motivated by a single, simple, and old
observation that the lower the level of a primitive, the more efficiently it can be implemented,

and the more latitude it grants to implementors of higher-level abstractions.
To provide an interface that is as low-level as possible (ideally, just the hardware interface), an
exokernel designer has a single overriding goal of separating protection from management. For
instance, an exokernel should protect framebuffers without understanding windowing systems
and disks without understanding fi le systems.
One approach is to give each application its own virtual machine. Virtual machines can have severe
performance penalties. Therefore, an exokernel uses a different approach - it exports hardware
resources rather than emulating them, which allows an efficient and simple implementation.

38 LOVELY PROFESSIONAL UNIVERSITY