The University of Arizona, Computer Science Department
Current Research Projects
The Swarm Scalable Storage System
The days of building special-purpose hardware to solve large compute and
storage problems are drawing to a close. Experience teaches us that such
systems are expensive to build, difficult to program, and unable to track
rapid improvements in the underlying technologies. At the same time, clusters
of desk-top computers connected by high-speed local-area networks (LANs)
are gaining acceptance as a viable architecture for implementing high performance
applications. This is for good reason: desk-top computers are affordable,
ubiquitous, and track rapid improvements in microprocessor technology;
LAN performance is becoming competitive with special-purpose multiprocessor
interconnects; and clusters are easy to grow incrementally.
The goal of the Swarm project is to design and implement a scalable
network storage system based on a cluster of personal computers. Swarm
is scalable because its performance is a function of the size of the cluster
-- the more nodes in the cluster, the higher the system performance. This
performance improvement is not merely an increase in aggregate performance,
either; clients whose I/O performance is limited by the storage system
will see an improvement in individual I/O operations if more storage
servers are added. This decoupling of I/O performance from storage server
performance allows the nodes of the cluster to be chosen to optimize cost-performance,
rather than absolute performance -- the desired performance of the overall
system is attained by aggregating enough nodes.
Swarm is a storage service, rather than a file service,
because it can be configured to provide a variety of storage abstractions
and access protocols. For example, a single Swarm cluster could simultaneously
support Sun's Network File System (NFS), a parallel file system, HTTP,
and a specialized Swarm interface. Current network file systems are designed
to work well with only a single storage abstraction and access protocol
(e.g. the Unix file abstraction and the NFS access protocol). Swarm, on
the other hand, decouples these two facets of storage service, allowing
for a more flexible storage system. The research challenge is to develop
techniques for allocating Swarm's resources so that the storage abstractions
and access protocols are configurable, without sacrificing performance
Swarm Server Design and Implementation
We are currently designing and implementing the individual nodes of the
Swarm system. The interface is based on that used in the Zebra striped
network file system. The current prototype runs on a Pentium-based personal
computer running the Linux operating system. The disk subsystem is managed
using the Logical Disk software developed at MIT. This prototype will be
ported to the Scout operating system as soon as it is available.
A communication-oriented operating system such as Scout is well-suited
for use in Swarm because of its focus on communication and resource management,
but the current Scout path abstraction lacks support for efficient data
caching. We are working on extending the Scout path abstraction to support
caching, and to come up with a general caching model that can be applied
to operating systems in general. The hope is to develop an infrastructure
for caching that simplifies the task of adding a cache to a data path.
Distributed Cache Management
Cache coherency is a well-known problem that must be handled in network
file systems, and Swarm is no exception in this regard. To this end we
are investigating several cache coherency algorithms that do not require
a centralized controller, as do current network file systems. Our intent
is to integrate this decentralized coherence algorithm with a decentralized
cache management algorithm that will allow clients to share the contents
of their caches (cooperative caching), allowing accesses to be off-loaded
from the server when the data can be found in another client.
Support for Parallel Applications
The design of current network file systems assumes that the clients act
independently, i.e. there is very little, if any, coordination of file
accesses. For example, most network file systems assume that concurrent
write-sharing is a rare event and thus it is acceptable to either not handle
it at all or do so in an expensive fashion. This assumption does not hold
for parallel applications running on a cluster of computers; the behavior
of each node in the cluster is coordinated with the other nodes. This means
that file accesses are no longer independent and that concurrent write
sharing may no longer be rare. To combat this problem we are designing
a parallel file system API (as part of the ARPA SIO project) for use in
Swarm and designing the system as a whole to support parallel applications.
Ian Murdock and John H. Hartman.
"Swarm: A Log-Structured Storage System for Linux."
In Proceedings of the FREENIX Track: 2000 USENIX Annual Technical Conference,
John H. Hartman, Ian Murdock, and Tammo Spalink.
"The Swarm Scalable Storage System."
In Proceedings of the 19th IEEE International
Conference on Distributed Computing Systems (ICDCS '99),
June 1999. Also available as Technical Report TR99-06,
Department of Computer Science, University of Arizona, March
The Swarm Scalable Storage System, SNIA/NASD meeting, March 4-5, 1998.
Swarm is supported by the National Science Foundation and the Defense
Advanced Research Projects Agency.
Back to CS Department
Maintained by John H. Hartman.