The University of Arizona, Computer Science Department
Current Research Projects

The Swarm Scalable Storage System

Project Overview

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 and predictability.

Current Work

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.

Caching Infrastructure

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.

Related Projects



Recent Talks


Swarm is supported by the National Science Foundation and  the Defense Advanced Research Projects Agency. 
Back to CS Department home page.
Maintained by John H. Hartman.