4/25 - Evaluations

Pavana Yalamanchili (pavanay@hotmail.com)
Tue, 25 Apr 2000 07:28:41 PDT

On The Duality Of Operating System Structures

The two categories in which many operating system designs can be categorized
· Message oriented system - characterized by facilities for passing messages
easily and efficiently among processes and for queuing messages at
destination processes until they can be acted upon.
· Procedure oriented system - characterized by a protection and addressing
mechanism oriented toward procedures and efficient procedure call
facilities, which can take a process very rapidly from one context to
another. Cooperation among processes achieved through some synchronizing
data structure like locks, semaphores or monitors.
The goal of this paper was to demonstrate that these two categories are
duals of each other and that a system that is constructed according to one
model has a direct counterpart in the other. The paper concludes that
neither model is inherently preferable and that the main consideration for
choosing between them is the nature of the machine architecture upon which
the system is being built and not the application which the system is going
to ultimately support. Also the factors and design decisions of the system
upon which the process and synchronization facilities are built are the
things that make one or the other style more attractive or more tedious. The
authors’ observations are based on informal arguments about the models and
not on formal, rigorous proofs.
This paper was pretty well written and the authors are open to their
analysis being controversial. In fact they leave it on time to decide if
they are correct or not!

The Structuring Of Systems Using Upcalls

This paper proposes an implementation methodology that permits synchronous
procedure calls between layers. This methodology was proposed because past
experience suggested that asynchronous communication between layers leads to
serious performance problems and the authors were greatly influenced by
their earlier research in the implementation of network protocols. This
paper describes and motivates this methodology (upcalls and multi-task
modules), and discusses the operating system, Swift, which they built to
explore it.
The goal was that procedure flow should map on to the natural flow of
control in the program irrespective of whether it is up, down or sideways.
Upcalls is a feature in this methodology where the system is organized such
that the programmer has the choice whether an upward flow is implemented by
procedure calls or asynchronous signals. In this methodology a layer was
organized as a collection of subroutines that live in a number of tasks,
each subroutine callable as appropriate from above or below. Subroutines in
different task that make up a layer constitute a multi-task module.
This paper demonstrates the benefits of upcalls and shows how to avoid their
problems. The two related aspects of the Swift system, memory management and
task scheduling are also discussed. Swift was implemented in a single
address space.
Swift shows that implementing a layer, as a process can be a very bad idea,
that organizing a layer as a multi-task module is an effective system
organization technique.
As the authors say, this methodology is suitable for many operating system
functions, including network and input/output support but irrelevant for
many large applications such as compilers.

Get Your Private, Free E-mail from MSN Hotmail at http://www.hotmail.com