CSE 221: Paper Evaluations

Renata C TEIXEIRA (teixeira@cs.ucsd.edu)
Mon, 24 Apr 2000 19:03:30 -0700 (PDT)

Title: The Structuring of Systems using Upcalls

This papers describes a methodology to make layered
systems more efficient. In this methodology, the
programmer has the choice to implement an upward flow
by procedure calls (upcalls) or asynchronous signals.
Each layer is viewed as a multi-task module, i.e., a
set of subroutines in different tasks that collaborate
with each other through shared memory.

Upcalls are more efficient than message passing for two
main reasons: a subroutine call is cheaper than an
interprocess signal and it eliminates the buffering
mechanisms to hold information until the next layer
is scheduled.

The implementation of upcalls and multi-task modules
is based on a single shared address space, which can
be a problem due to program bugs. To solve this problem,
the system was programmed in a safe language and implements
garbage collection.

I think that the idea of upcalls is interesting, because
in addition to provide a more flexible implementation of
layered systems, it allows for a more customized service.
A layer can ask for advice to the layer its is serving.
The mechanisms used to ensure security, however, may
restrict the system use. It is difficult to picture an
operating system that have to be programmed in only one
language. Besides, the garbage collection mechanism add
some overhead to the system.


Title: On the Duality of Operating System Structures

This paper identifies two categories of operating systems and
compare them. These categories, namely message-oriented systems
and procedure-oriented systems, were defined regarding the
concepts of process, synchronization, and interprocess communication.

In order to compare those categories, the paper proposes models
to represent them and maps constructs of one model to the other.
Provided the implementation of primitive operations of the two
operating systems are efficient, the paper concludes that a
system of programs built in one model will have the same execution
characteristics as the same programs built in the other model.

I think that the paper address an important issue, because
by knowing that both approaches can represent the same computations,
the designer of the operating system may focus on which approach
is more suitable for the hardware being used. I think, however,
that the models proposed are too high-level and hence not very
expressive. Some comparisons of performance like context switching
and delay for procedure call/send message cannot be evaluated
accurately in these models.

Renata Teixeira