CSE221 Duality and Upcalls

Andreas Anagnostatos (aanagnos@cs.ucsd.edu)
Tue, 25 Apr 2000 02:17:21 -0700

H. C. Lauer and R. M. Needham, "On the Duality of Operating System
Structures," Proc. Second International Symposium on Operating Systems,
IRIA, Oct. 1978 (reprinted in Operating Systems Review, Vol. 13, No. 2,
April 1979, pp. 3-19).

The paper compares two operating system design categories. One is the
message-oriented, where relatively few processes communicate and
synchronize with each other using messages, and the other is the
procedure-oriented, in which a large number of small processes
communicate using shared memory. The paper claims that the two designs
are duals of each other with the differences being only in syntax rather
than in design logic. Also they argue that, given the right
implementation and the same scheduling policies, the two systems would
exhibit the same performance.

I am not convinced about the "identical performance" argument. The
author mentions that creation of processes is expensive in a
message-oriented system and sharing data is inefficient. So, if for
instance an application is similar to a web server where each request is
serviced by a separate process (or thread) and all processes need access
to some shared data (i.e. for access statistics), it seems that the
procedure-oriented design would be favorable because it provides low
overhead for the creation and deletion of processes and natively
supports data sharing.

D. D. Clark, "The Structuring of Systems using Upcalls," Proc. Tenth
Symposium on Operating Systems Principles, Operating Systems Review, 19,
5, pp. 171-180, December 1985.

The paper presents a scheme in which the most basic characteristic of a
layer-based system is violated. Layers lower in the hierarchy may call
layers above them. The author uses as an example a network system in
order to demonstrate the benefits gained by the use of upcalls, function
calls belonging to a higher layer. Of course, this approach carries some
problems, some of which are quite important, so the paper spends a lot
of time identifying them and proposing potential solutions. The last
part talks about how task scheduling and address space management may
affect (either positively or negatively) the performance and reliability
of the Swift operating system.

Unlike the previous paper, Clark is convinced that a messaging scheme
leads to inefficiency and that procedure calls is the way to go.
Couldn't one implement the same synchronous behavior using messages? For
example having a SendMessage followed by a WaitforReply?