(no subject)

Brian TAM (btam@cs.ucsd.edu)
Thu, 1 Jun 2000 08:02:52 -0700 (PDT)

"A Fast File System for UNIX"

This paper describes changes to the UNIX file system
to make it perform more efficiently, as well as to
the programmer's interface. Better performance of an
extant operating system is the goal. One change was to
increase the size of data blocks so as to reduce access
overhead through increased throughput, as well as to
introduce fragmentation so as to optimize memory
allocation without undue waste on incompletely filled
blocks. Another approach was to increase locality of
reference to minimize seek latency, at the same time as
spreading out unrelated data. Other enhancements
included making it possible for file names to be
arbitrarily long, introducing file locks for concurrent
manipulation by more than one process, and imposing
quotas on resources.

The authors gave transfer rates as performance
measures for increased block size and new layout
policies. Reads and writes are demonstrably faster in
the new system than with the old, lending weight to
the strategies taken. One measurement they report but
do not comment on much is the increased "% CPU" with
the new system over the old. One would like to be
convinced that the increase in CPU usage does not
affect overall system performance, a question the
authors do not answer in this paper at least.

The authors suggest further improvements they did
not implement because of limited gains for what amounted
to an overhaul of the system. An example was to transfer
data from disk buffers in the system address space to
buffers in user address space without copying. Perhaps
there are other strategies for accomplishing the same
thing without requiring fundamental changes in the basic

"The Design and Implementation of a Log-Structured File System"

While the Unix FFS system shows better performance
over the old Unix system, there's always room for
improvement, especially in light of improving technologies.
This paper proposes a technique that cuts
down on file system overhead even further with a disk-
storage management structure called a log. The basic
idea is to buffer file system changes in the file cache
before writing them to disk in a single operation,
thereby reducing the I/O necessary to backup for crash
recovery. In order to maintain large free areas on
disk for fast writing, the log is divided into segments,
and a segment cleaner is used to compress live information
from heavily fragmented segments. The approach has been
implemented in the Sprite LFS using a cleaning policy
based on cost and benefit. Crash recovery is carried out
using checkpoints and roll-forward. Performance was
assessed using file-intensive benchmarks against the
SunOS, whose file system is based on Unix FFS. In most
cases Sprite LFS did better than or as good as the Unix
FFS model.

This paper seems to be well-presented. The role of
relevant technologies is explained in the introduction,
as well as a survey of limitations of current systems.
The principles of log-structured systems are outlined
and an implementation with performance measures
described. Although the use of micro-benchmarks is not
ideal, it seems reasonable given the limited experience
with a novel system. The use of simulations rather
than fully implemented systems to assess different
cleaning policies is also understandable from a
practical point of view.