cse221: paper evals

Octavian Luca (oluca@cs.ucsd.edu)
Thu, 1 Jun 2000 02:15:30 -0700 (PDT)

A Fast File System for UNIX

This paper discusses an alternative implementation of the UNIX file system
whose goals are improvements in throughput rates for large files while not
wasting large amounts of space for small files. The work is motivated by
the fact that poor file system performance prevents efficient running of
applications requiring simple processing of lots of data. This paper
differs from a previous UNIX file system optimization by providing more
efficient storage utilization through the use of more than one block size
to accomodate both large and small files, parametrization meant to take
into account hardware characteristics, and better layout policies using
parametrization data.

The paper first describes the structure of the old UNIX file system and
the promising performance improvements of increasing the block size from
512 to 1024 bytes. This suggests that even more benefits can be gained
through further optimizations. The researchers then outline the
motivations behind each optimization they introduce such as large block
sizes for reducing the levels of indirection to only 2, parametrization
and layout policies and how their implementation supports those ideas.
Then they support their claims that their optimizations actually yield
improved performance by providing the results of various kinds of
benchmark measurements. Finally they outline some functional
enhancements: long file name support, file locking, symbolic links,
renames, and quotas.

This paper reveals how important optimizations that take into account
hardware characteristics and some algorithmic improvements can be to
system performance. Also it is a good example of how to improve a part of
a system without affecting other parts so that modularity can pay off in
longer system lifetime.

Log-Structured File System

This paper proposes a new way for managing disk storage where thefile
system writes all modifications to disk sequentially in a log-like
structure. The authors claim that this approach improves the speed of
both file writes and crash recovery. This differs from the previous paper
in it's proposal of a new log-like technique rather than making
significant improvements to an existing approach. The importance of the
proposed enhancements is derived from its efficient usage of disk
bandwidth exemplified by a order of magnitude increase in the case of
Sprite LFS.

Of particular interest was the idea behind this paper. The authors first
describe that log-structured file systems are based on the asumption that
files are cached in main memory and that increasing memory sizes will make
the caches increasingly effective leading to disk traffic dominated by
writes. Log-structured FSes buffer a sequence of FS changes in the file
cache and then write all new info to disk sequentially thus increasing
write performance through the elimination of most seeks and increase crash
recovery speed since only latest portion of the log need be analized.
They identify the most difficult challenge in designing the LFS as
ensuring that there are always large areas of free space available for
writing new data. In LFS free space is managed using a combination
between threading and copying. The disk is divided into segments and they
are written sequentially from end to end. All live data must be copied
out of a segment before the segment can be rewritten, and the log is
threaded on a segment by segment basis. The measurements provided towards
the end of the paper exemplify the performance improvements obtained by
this system.

Similar to the previous paper this one aims to improve the efficiency of
disk bandwith usage and succeeds in doing so using an alternative
approach. This kind of research becomes increasingly important as the
disparity between cpu speed and disk speed continues to widen and the
corresponding bottleneck has to be constantly relieved.