Paper Evaluations: 04-24-2000

Mon, 24 Apr 2000 20:29:20 -0700 (PDT)

Title: The Structuring of Systems using Upcalls

This paper proposes the structuring of layered operating system using
upcalls. Based on previous experience on the development of network
protocol stacks, the author uses procedure calls to communicate
adjacent layers in a prototype system called Swift. This approach
contrasts with previous works, which use message-passing as the main
mechanism for communication between layers. Because message-based
communication is asynchronous, the flow of data is inefficient in a
layered structured. Moreover, using messages to request a service from
a layer, several times involves the copy of data, what turns out to be
time consuming. In order to provide an efficient passing of data
between layers, Swift was implemented using a single address space.

In this proposed strategy, each layer is defined as a collection of
subroutines, called multi-task module, which live in a different
number of tasks. These subroutines can collaborate, exchanging
information through shared variables. Shared variables, however,
can be a problem if an upcalled module fails and these variables
are not consistent.

Some other drawbacks also come up with this approach. Despite the fact
that procedure calls are more natural, good programmers are necessary
to explore the benefits of this strategy. Another problem is the
cyclic dependency between modules. Several techniques are described to
overcome this problem, but no example is provided in terms of common
system features, as, for example, the cyclic dependency between the
file system and the virtual memory system.

In general, the paper presents interesting ideas and is well
written. In my opinion, however, there are two Swift features which
could be changed. Since the performance is one of the main concerns, a
garbage collector should not be used, because it is inefficient. Also,
Swift is programmed using the language CLU, because it provides strong
type-checking. Nevertheless, we know from previous discussions that it
restricts the use of the system.


Title: On the Duality of Operating System Structures

This paper compares the message-oriented and the procedure-oriented
approaches to design layered operating systems. This comparison is
achieved by defining two canonical models for the approaches. For each
approach, the features usually found in previous works were included
in the model.

In message-oriented systems, the system provides facilities for
passing messages easily and efficiently, and messages are queued
in the destination for asynchronous delivery. In this type of system,
the number of processes and connections between processes is usually
static, and there are multiple address spaces.

On the other hand, in procedure-oriented systems, data is available
globally, usually using a single address space. The processes are
easily created, since there is no need to set up connections. Thus,
the set of processes in the system tends to be dynamic. In this model,
the cooperation among processes is achieved by monitor locks and condition
variables. Other synchronization structures can be used though.

One interesting result presented in this paper is the duality mapping.
This mapping relates statements in the message-oriented model and
statements in the procedure-oriented model. Hence, programs written
using the statements of one model can be mapped for a program appropriate
for the other model. The two models are, therefore, equivalent in terms
of expressiveness.

Besides expressiveness, the authors claim that both models could be
equivalent in terms of performance, if they were implemented carefully
and using the appropriate hardware. For instance, they say that the
process switching can be made equally fast in either system, and for
similar machine architectures. This is hard to believe, since for a
procedure-oriented system, a single address space can be used and the
processes can be lightweight, reducing the amount of information to be
swapped during a context switch. Therefore, the assertions presented in
the paper should be evaluated using real implementations in order to
show that they are correct.

--Flavio Junqueira.

Flavio Paiva Junqueira, PhD Student
Department of Computer Science and Engineering
University of California, San Diego

Office location: AP&M 4349 e-mail: