Carnevali $ilvio (csmede@hotmail.com)
Mon, 24 Apr 2000 18:12:18 PDT

Duality of OS Structures

This is a purely theoretical paper that is not concerned with the
implementation of a new OS but rather with the
comparison of two existing structure categories grouping all existing
systems. This approach is unique as it
makes a summary of previous experience with OS design.

There are two groups of Operating Systems:
1.) Message-Oriented
2.) Procedure-Oriented
The authors claim that all good Systems fall in either one of these
categories; a combination of the two would lead
to failure.
A Message-Oriented OS is composed of a small number of relatively static
processes; creation or deletion of a
process is not an easy task, thus interprocess communication is handled
through messages. A few large processes
are needed to carry out the computations.
A Procedure-Oriented OS instead is composed of a large number of small
dynamic processes; communication is
handled through asynchronous mechanisms like semaphores, or procedure calls
(direct or via the fork mechanism).
The number of processes carrying out a computation is variable and in
constant evolution.
The execution time of a program is obviously the same for both systems;
furthermore, the computational overhead
due to system operations is similar (same time complexity), which means that
sharing resources has about the same
overhead for both systems. As a conclusion, overall performance in
Thus, the choice of the OS structure does not depend on the nature of the
applications it will support, but rather on
the physical architecture of the Computer System it will run on.

This paper was a good overview of the main threads in OS design. I think it
summarizes very well the organization
of an OS at the beginning of the 80's. There is no future work suggested, as
the purpose of the paper is reducing
the degrees of freedom when designing a system, rather than setting the
bases for a "perfect" OS.

The Structuring of Systems Using Upcalls

This paper deals with the optimization of OS that implement network
protocols. In order to achieve this, the
notion of upcall is introduced, which is fundamentally a new concept in the
late 70's

In existing systems the notion of layer was designed to provide services to
a client layer above it, but there
is no facility for bottom up requests of services. Now in Systems with
strong networking support there is a
need for such requests, which may be initiated by the network from below.
Upcalls were specifically designed
to meet thos needs as well as to ease overall task managment and
The system is organized in layers grouping different subroutines. A Task is
a collection of Subroutines not
necesseraly belonging to the same layer. Thus, the invocation of a
subroutine in a Task may occur either from
a lower layer to a higher one (Upcall) or viceversa. The main advantage is
that upward control flow can be done
through a subroutine call, which is always faster than messaging or other
asynchronous communication methods.
Another advantage is that information from different layers can be easily
combined in a single packet, which
reduces the weight of the overhead for sending a packet over the network.
This leads to a higher-performance
Nevertheless, the main problems of the System arise when a subroutine fails
or in case of infinite loops. The
paper proposes some theoretical solutions but nothing pratical has been done
in that direction. I think there
is still a lot of work to do, as proved by the difficulties that arised in
the practical implementation of the
system. For that reason the conclusion is quite open and leaves room for
