This paper presents LBFS, a network file system designed for low bandwidth networks. LBFS exploits similarities between files or versions of the same file to save bandwidth. It avoids sending data over the network when the same data can already be found in the server's file system or the client's cache. Using this technique, LBFS achieves up to two orders of magnitude reduction in bandwidth utilization on common workloads, compared to traditional network file systems

Motivated by the prospect of readily available Content Addressable Storage (CAS), we introduce the concept of file recipes. A file's recipe is a first-class file system object listing content hashes that describe the data blocks composing the file. File recipes provide applications with instructions for reconstructing the original file from available CAS data blocks. We describe one such application of recipes, the CASPER distributed file system. A CASPER client opportunistically fetches blocks from nearby CAS providers to improve its performance when the connection to a file server traverses a low-bandwidth path. We use measurements of our prototype to evaluate its performance under varying network conditions. Our results demonstrate significant improvements in execution times of applications that use a network file system. We conclude by describing fuzzy block matching, a promising technique for using approximately matching blocks on CAS providers to reconstitute the exact desired contents of a file at a client.

Benchmarking is critical when evaluating performance, but is especially difficult for file and storage systems. Complex interactions between I/O devices, caches, kernel daemons, and other OS components result in behavior that is rather difficult to analyze. Moreover, systems have different features and optimizations, so no single benchmark is always suitable. The large variety of workloads that these systems experience in the real world also adds to this difficulty. In this article we survey 415 file system and storage benchmarks from 106 recent papers. We found that most popular benchmarks are flawed and many research papers do not provide a clear indication of true performance. We provide guidelines that we hope will improve future performance evaluations. To show how some widely used benchmarks can conceal or overemphasize overheads, we conducted a set of experiments. As a specific example, slowing down read operations on ext2 by a factor of 32 resulted in only a 2–5 % wall-clock slowdown in a popular compile benchmark. Finally, we discuss future work to improve file system and storage benchmarking.

Rights to individual papers remain with the author or the author's employer. Permission is granted for noncommercial reproduction of the work for educational or research purposes. This copyright notice must be included in the reproduced paper. USENIX acknowledges all trademarks herein.

This paper addresses a bottleneck problem in mobile file systems: the propagation of updated large files from a weakly-connected client to its servers. It proposes an efficient mechanism called operation shipping or operation-based update propagation.In the new mechanism, the client ships the user operation that updated the large files, rather than the files themselves, across the weak network. (In contrast, existing file systems use value shipping and ship the files.) The user operation is sent to a surrogate client that is strongly connected to the servers. The surrogate replays the user operation, regenerates the files, checks whether they are identical to the originals, and, if so, sends the files to the servers on behalf of the client. Care has been taken such that the new mechanism does not compromise correctness or server scalability. For example, we show how forward error correction (FEC) can restore minor reexecution discrepancies and, thus, make operation shipping work with more applications. Operation shipping can be further classified into two types: application-transparent and application-aware. Their feasibilities and benefits have been demonstrated by the design, implementation, and evaluation of a prototype extension to the Coda File System. In our controlled experiments, operation shipping achieved substantial performance improvements---network traffic reductions from 12 times to nearly 400 times and speedups in the range of 1.4 times to nearly 50 times.

In mobile Internet applications, data can be transcoded, updated, and transferred across heterogenous clients. The problem then arises where updates made in the context of an initial transcoding results in content too stringently transcoded for subsequent clients, thereby causing loss of semantic value. We solve this problem by suggesting that the updates themselves can be transformed so that they can be applied directly to the original data instead of to the transcoded data; this approach allows the data to preserve as much semantic value as possible across all heterogeneous clients without unnecessary transcoding artifacts. We define reconciliation rules that can govern the interaction between client updates and transcoding, demonstrate a complete middleware architecture that supports our methodology, and provide two case studies using content-transferring applications. We show that our resulting middleware system executes our reconciliation approach with acceptable latency (under 5 seconds for 200 kbytes of layered content), good scalability, and well-organised modularity.

Disconnection is one of the popular techniques for operating in mobile environments and is here to stay, until long-range wireless connectivity becomes a reality. However, disconnection requires periodic hoarding and reintegration of data, which raises performance issues especially during weak connection. A common hoarding and reintegration mechanism involves complete transfer of contents. In order to hoard and reintegrate efficiently, an incremental approach is being introduced to do data transfers based on the delta between changes.

Mobile devices are increasingly relied on but are used in contexts that put them at risk of physical damage, loss or theft. We consider a fault-tolerance approach that exploits spontaneous interactions to implement a collaborative backup service. We define the constraints implied by the mobile environment,analyze how they translate into the storage layer of such a backup system and examine various design options. The paper concludes with a presentation of our prototype implementation of the storage layer, an evaluation of the impact of several compression methods,and directions for future work. 1.

Even though database management as well as workflow management systems have significant advantages, spreadsheets exchanged by e-mail are still in widespread use for many processes within an enterprise, causing problems such as poor data-quality and lack of process monitoring. This paper analyzes reasons for office-document based workflows (ODBWf) and presents an alternative solution that combines the advantages of DBMS and WfMS with the flexibility and simplicity of office documents. This paper introduces an autonomous mobile document-management-system based on a ‘smart’ file. This file is executable and contains a managed resource part where files can be stored. Any read/write access to its resource part is managed by the file itself; it controls who can do what and automatically synchronizes changes to other systems such as process-monitoring or business intelligence tools. Proven concepts from DBMS, such as triggers, integrity constraints and multi-user support are utilized to improve ODBWfs without restraining their flexibility.

In this paper, we explore some of the new opportunities for distributed collaborative applications that emerge from the use of XML as a data specification language. We present two different approaches: the first one transparently adds asynchronous collaboration to applications whose persistent state is in XML format, while the second one helps build synchronous collaborative applications starting with an XML schema specification. Although the two approaches start with different assumptions, they both lead to the same problem—the need for a generic one-to-one conversion between objects and XML constructs. Using object properties, we define two variants of a conversion scheme for the two approaches.