paper evaluations for lecture on 04/17

Alejandro Hevia (
Tue, 18 Apr 2000 00:49:16 -0700 (PDT)

Evaluation of paper
"Pilot: An Operating System for a Personal Computer"
by D.D. Redell et al.

The paper describes an operating system with elaborated communication capabilities
oriented to personal computing machines. This system provides a single-user,
single-language environment (with support for concurrent programming, though)
based on the idea of exploiting the current trend of users accessing personal
computers instead of time-sharing machines.

The proposed operating system is highly coupled to Mesa, a specific programming
language, which determines several aspects of the structure of the system (like
the concept of system accessing through interfaces). Pilot implements a virtual
memory system with single virtual space, a paging system intertwined with a flat
(not hierarchical) filesystem, a runtime support for concurrent programming
and powerful communication subsystem.

Nevertheless, Pilot system does not try to provide all the functionality of
bigger, and more complex systems but, instead, tries to give the user a set
of useful kernel services. It strongly relies on higher-level software to
implement further functionalities (as improved filesystem, crash recovery
applications, or user shell) but, in return, allows a high level of interaction
between kernel and application (including application "advising" about memory page's
usage). Regarding communication features, the system includes an impressive
library of services intended to be used over a fairly complete concept of "Pilot"
networks (strongly based/similar on UDP and IP protocols).

One interesting aspect of the paper is that shows that a fairly complete
"user-oriented" computing system can be implemented based on simple concepts:
single-language driven design, and simple and modular (yet robust and
removable-media oriented) file system. It is also remarkable to find fairly
elaborated thread implementation and communication facilities in such a
simple design.

Some of the drawbacks of the system design are its dependency of higher-level
software to make it usable by users in practice. Also, the need of using
an specific programming language when implementing any application seems
quite restrictive; a more flexible approach might have be to provide a generic
interface accessible from (potentially) any language.


Evaluation of paper
"Sharing and Protection in a Single Address Space Operating System"
by J.S. Chase et al.

The paper describes an operating system that provides a single (global)
address space environment as a flexible and efficient scheme to facilitate
data sharing among lightweight processes (threads). The system implements
protection using a capability-based control scheme based on memory segments.
This memory sharing scheme is claimed very flexible and customizable, and
includes persistent memory support.

Much of the motivation of this paper is based on the underlying
data sharing inefficiency found on (heavyweight) process can be avoided
by using the memory address space that 64-bit machines can provide
as a single memory space. This space is large enough for any set of typical
applications that there is no need of isolated virtual spaces or costly
context switching. Obviously, this change requires decoupling the concepts
of protection and Unix process. Consequently, the authors also discuss
more elaborated protection mechanisms based on "protection domains"
(associated to threads) and capabilities (associated to basic memory units:

The approach proposed in this paper is evaluated using experimental runtime
data and supported by a case-by-case comparison with previous system's
design philosophies.

This paper is very enlightening in the sense that unveils a source of
inefficiency when supporting data sharing programming in current (Unix-process
based) operating systems. Nevertheless, there are some aspects that remain
to be seen, namely the overall efficiency obtained by the system when
used in very dynamic environments (where "processes" created and eliminated
very frequently). In those environments, copying of data and code every
time a process is created seems unavoidable and a clear source of inefficiency.