CSE 221: Paper evaluations

Renata C TEIXEIRA (teixeira@cs.ucsd.edu)
Thu, 20 Apr 2000 02:00:16 -0700 (PDT)

Title: StarOS, a Multiprocessor Operating System for the Support of Task Forces

This paper presents a multiprocessor objected-oriented operating system.
The main idea is to explore the potentials of parallel machines. To do that
the paper defines task force as a computation composed by many small
cooperating processes that together accomplish a function.

The operating system is divided in a nucleus, which is replicated in
every processor and in Kmaps, and the rest are asynchronous functions,
allowing the process to continue parallel to the execution of the
function. Process can communicate through messages that are implemented
by a mailbox object.

Scheduling of processes is handled by multiplexors in each processor,
and schedulers, which are responsible to assign processes to queues in
the processors.

There are some disadvantages in the StarOS system. First, all system
calls have to be handled by the Kmap and then if needed returned to
the nucleus in the processor that called it. This is how the system
implements the switching of modes. Second, processors may execute
code that is on the memory of other processors, which is not
efficient.

On the other hand, the system provides a good protection mechanism
based on capabilities. In addition, the bailout relation is an
interesting way to handle failures. Overall, exploiting parallelism
leads to a more robust and efficient system.

----------------------------------------------------------------------
Title: Medusa: An Experiment in Distributed Operating System Structure

Medusa is a distributed operating system developed to explore a
multiprocessor computer. The operating system is divided into
disjoint unities. A processor is permitted to execute code for
a utility only if it can do so locally. Therefore, a program's
flow of control can switch processors when it invokes utility
functions. Cross-processor function invocations done by
exchanging messages through pipes.

The system is distributed into a small replicated portion (kernel + kmap)
and a largest portion distributed among utilities. The protection
mechanism implemented by the kernel is simple to maintain the code
small. There is a utility bit identifying a task force as a utility.
Utilities have unlimited access, even if it is not necessary.
Access to objects are obtained through descriptors. There is a
private descriptor list, exclusive to each activity, and a
shared descriptor list, shared by all activities of a task force.

The paper defines that a task force is coscheduled if all of its
runnable activities are simultaneously scheduled for execution
on their respective processors. Medusa adopts simple algorithms
for task force allocation and scheduling to maximize coscheduling.

One advantage of Medusa is that task forces can adapt to the workload,
thereby providing a more efficient system. Having replicated activities
are also important to ensure reliability. Another feature that helps
increase inefficiency is that processors can only execute locally.
The protection mechanism, however, does not allow different rights to
different activities.

Renata Teixeira