Paper evaluations for 04/25/00

Michael U. Datuin (
Tue, 25 Apr 2000 08:29:49 -0700

The upcalls paper discussed the problems of designing systems via the layered
approach (e.g., the THE system) whose layers are implemented as processes.
The problems in this approach lie in the asynchronous communication between
the layers and the difficulties when data needs to be communicated from a lower
layer to a higher layer. The authors proposed a new methodology based on
synchronous communications between the layers via the notion of upcalls and
multi-task modules, based on their past experiences in designing network
protocols, and developed the Swift system to test their ideas.

According to the authors, previous systems used layers, where each layer
only communicated in the downward direction and constituted a particular
process of the system protected from other processes (layers) via a
protection boundary. This approach was easy to test and verify, but
difficult to implement.

Their approach to designing systems still used the layered approach, but
each layer consisted of multiple subroutines that lived in different tasks,
yet perform related functions, shares data within the layer using shared memory,
and where each layer communicates via these subroutine calls. Their claim
is that such a system is more easy to implement and efficient. The amount
of messaging between tasks is reduced/eliminated since the data shared
via shared memory contains the necessary information for the tasks to
communicate, and that intertask communication never crosses layer
boundaries and only occur within a layer.

The authors introduced such notions of an "arming call" where a higher layer
informs a lower layer on what to do based on some event, and the ability to "ask
advice" where a lower layer can query the layer above it for information on
how it wants to be serviced
The ideas proposed by the authors must have been considered a radical
change in the design of OSes since most systems of that time were
designed and implemented similarly in their layered approach. But, these new
notions of upcalls and multi-task modules were meant to make design
easier according to the authors. Of course they ran into problems when testing
their ideas on designing a display window-management system for their
Swift system where the results weren't what they expected. But they did
try to improve on the old way of designing systems.


The paper "On the Duality of Operating System Structures" discusses the
two main classes of OSes based on message passing and procedure calling.
They claim that neither class is necessarily better than the other, but that
in designing a system, the main consideration is on the hardware that the
system is going to run on and not the applications the system will execute.

The authors suggest that these two classes are dualities of each other and
that a system based on one class is similar to a system based on the other
system in terms of performance, efficiency, and level of implementation.
They also propose that a system based on one class can be mapped to
a system based on the other class in a straightforward manner.

The interesting aspect in reading the paper was that the authors did
not really have any proof that the two classes are actually dualities of
each other. They found it difficult in reality to transform one system
to another.