cse221: paper evals

Octavian Luca (oluca@cs.ucsd.edu)
Thu, 11 May 2000 02:20:17 -0700 (PDT)


This paper describes and motivates monitors as a method of structuring
operating systems. This approach is important because it provides an easy
abstraction upon which designers can construct scheduling algorithms for
resources of various kinds. It seems to be different from previous
research in it's focus on methods of structuring operating systems rather
than describing high level designs.

The researchers first describe the concept of monitors and their
advantages. Then they show that monitors are equivalent to semaphores as
one abstraction can be implemented by the other and vice versa. Then, by
implementing some important examples of operating system primitives using
monitors they reveal some important insights into monitor based design
issues. Based on this they refine their designs and add features meant to
further facilitate design using this new feature.

The paper concludes that that an appropriate structure for a module of an
operating system, which schedules resources for parallel processes is
similar to that of data representation used by sequential programs. They
do leave some issues unresolved like whether the signal should always be
the last operation of a monitor procedure is still open. The paper
concludes with somee principles that the researchers believe should be
observed in order to avoid undesirable interactions between different
scheduling algorithms such as using preemptive techniques wherever
possible instead of non-preemptive ones. I thought that in general the
paper argued the merits of it's idea pretty well and describes it's merits
and nature to a sufficient extent for an introductory work.

Monitors in Medusa

This paper discusses the problems that arise from the use of monitors in
real systems and how they are addressed by Mesa facilities for handling
concurrent programming. This is an important problem because monitor
implementations can create system instabilities if appropriate facilities
are not provided. The Mesa language provides these facilities, and
because Pilot is tightly coupled with it it takes advantage of them.

The purpose of these new facilities are local concurrent programming,
global resource sharing, and replacing interrupts. The issues not clearly
resolved in other works on monitors which these new facilities are meant
to handle are program structure, creating processes, creating monitors,
wait in nested monitor calls, exception, scheduling, input/output. The
paper then goes on to demonstrate how the facilities address these

The authors conclude that the set of language features they developed
possess sufficient power to serve as the only software concurrency
echanism on their testing platform, and handles i/o, cooperative resource
sharing. Their success proves that monitors are a viable method for
process synchronization even though their complexity requires
consideration of various problems likely to arise in various situations.