Paper Evaluations: 05-04-2000

Flavio P JUNQUEIRA (flavio@cs.ucsd.edu)
Wed, 3 May 2000 23:18:52 -0700 (PDT)

Title: "The Distributed V Kernel and its Performance for Diskless
Workstations"

The distributed V kernel is a message-oriented kernel that provides
uniform local and network interprocess communication. As the Sprite,
this project was motivated by an environment composed by a few
powerful workstations, acting as file servers, and several diskless
clients. Hence, V aims at providing a high-performance interprocess
communication in order to build such an environment.

Processes executing on top of the V kernel communicate exchanging
messages. This communication is always synchronous and it is always
based in a request followed by a response. Each process is identified
globally by a pid, which includes the location of the process. The
kernel handles the messages sent by a process, determining whether the
process is local or global. Furthermore, all remote operations are
implemented directly in the kernel to improve performance. In order to
avoid buffering and queueing of arbitrary sized messages in the
kernel, all messages have a fixed size. In addition, large amounts of
data are transfered using special primitives (moveto, movefrom), in
such a way that data is not buffered in the kernel.

In the case that a message has to be delivered in another host, the
kernel sends an interkernel packet to the destination host. An
important feature of the V kernel is that all interkernel packets use
the raw Ethernet data link. In this way, the overhead of a layered
protocol is avoided. This is similar to the active messages proposal
used in clusters of workstations.

The optimizations proposed in the paper were evaluated using a system
prototype. A result from the data achieved is that the processor is
the main bottleneck, instead of the network. Using a better processor,
the improvement is more significant compared to the increase in the
network bandwidth. In general, the results show that, using the
interprocess communication model, the overhead of remote file access
is small compared to the time to accomplish a local file access.

The results, however, considered only one client. It is important, in
my opinion, to evaluate the system load not only when there are
several clients but also considering several servers, specially
because the network load may influence the performance. As mentioned
in the paper, more experience with the V kernel-based file servers is
required. This is definitely necessary to determine how the system
scales.

----------------------------------------------------------------------------

Title: "The Sprite Network Operating System"

Sprite is a network operating system, developed extending the BSD
Unix. Sprite extends BSD by providing a transparent network file
system, a mechanism for sharing writable memory between processes in a
single workstation, and a mechanism for process migration to idle
machines.

The file system structure seen by the Sprite users is the same in
every workstation connected to the network. The tree structure,
however, is divided in domains. Each domain is a subtree, which is
mounted in a leaf of another domain, and is stored in a server
workstation. Different from previous systems, the server for each
domain is not known when the system is started, and so clients find
the servers by broadcasting requests. Thus, the clients manage a
prefix table, which stores information associating prefixes and
servers. An important consequence of this approach is that it permits
dynamic reconfigurations of the system. In order to decrease the
network traffic, and to increase performance, clients and servers have
caches for file data. It makes the system more scalable.

An interesting feature of Sprite is the mechanism for sharing writable
data between two processes. Processes sharing code and data segments
and also having separate stacks are currently known as threads. In the
paper, the authors mention that the system is multithreaded, referring
to concurrent calls to the kernel, what is important for
multiprocessors. The kernel also provides support for remote procedure
calls, but only for kernel-to-kernel services.

As mentioned before, each client has a cache for file data. Thus, the
main memory is shared by the virtual memory and the file systems. The
space used by each of those is not fixed though. The file cache can
shrink and grow, depending on the current demand. Another
characteristic of the file system is the use of common files for the
backing store. Using common files, process can be easily migrated.

In my opinion, Sprite presents interesting ideas, as the use of file
data caches and a multithreaded kernel. Moreover, the performance
evaluation of the system using file data cache helps the reader to
understand better the benefits of this feature. Sprite, however, is
not concerned with fault-tolerance. In the case of a file server
failure, there is no replica to take over. On the other hand, this
decision makes system management easier.

--Flavio Junqueira

------------------------------------------------------------
Flavio Paiva Junqueira, PhD Student
Department of Computer Science and Engineering
University of California, San Diego

Office location: AP&M 4349 e-mail: flavio@cs.ucsd.edu
------------------------------------------------------------