A low-bandwidth network file system

This paper describes a simple distributed mechanism for caching files among a networked collection of workstations. We have implemented it as part of Sprite, a new operating system being implemented at the University of California at Berkeley. A preliminary version of Sprite is currently running on Sun-2 and Sun-3 workstations, which have about 1-2 MIPS processing power and 4-16 Mbytes of main memory. The system is targeted for workstations like these and newer models likely to become available in the near future; we expect the future machines to have at least five to ten times the processing power and main memory of our current machines, as well as small degrees of multiprocessing. We hope that Sprite will be suitable for networks of up to a few hundred of these workstations. Because of economic and environmental factors, most workstations will not have local disks; instead, large fast disks will be concentrated on a few server machines.

This paper presents Kosha, a peer-to-peer (p2p) enhancement for the widely-used Network File System (NFS). Kosha harvests redundant storage space on cluster nodes and user desktops to provide a reliable, shared file system that acts as a large storage with normal NFS semantics. P2p storage systems provide location transparency, mobility transparency, load balancing, and file replication - features that are not available in NFS. On the other hand, NFS provides hierarchical file organization, directory listings, and file permissions, which are missing from p2p storage systems. By blending the strengths of NFS and p2p storage systems, Kosha provides a low overhead storage solution. Our experiments show that compared to unmodified NFS, Kosha introduces a 4.1% fixed overhead and 1.5% additional overhead as nodes are increased from one to eight. For larger number of nodes, the additional overhead increases slowly. Kosha achieves load balancing in distributed directories, and guarantees 99.99% or better file availability.

In this paper, we propose a new paradigm for network file system design, serverless network file systems. While traditional network file systems rely on a central server machine, a serverless system utilizes workstations cooperating as peers to provide all file system services. Any machine in the system can store, cache, or control any block of data. Our approach uses this location independence, in combination with fast local area networks, to provide better performance and scalability than traditional file systems. Further, because any machine in the system can assume the responsibilities of a failed component, our serverless design also provides high availability via redundant data storage. To demonstrate our approach, we have implemented a prototype serverless network file system called xFS. Preliminary performance measurements suggest that our architecture achieves its goal of scalability. For instance, in a 32-node xFS system with 32 active clients, each client receives nearly as much read or write throughput as it would see if it were the only active client.

Peer-to-peer (P2P) systems are, in contrast to client-server (C/S) systems, fault-tolerant, robust, and scalable. While C/S distributed file systems, such as NFS (network file system) or SMB (server message block), do not scale with respect to the number of clients and exhibit a single point of failure, P2P file systems have the potential to cope with an increasing number of participants. Thus, this paper presents DRFS (distributed reliable file system), a P2P file system for cooperative environments. DRFS uses random, content-independent identifiers for data storage, while maintaining high performance and low overhead with many concurrent reads and writes. A dynamic replication mechanism ensures data availability, even under high churn. The application scenario considers an office environment, where DRFS is installed on employees' machines, who store and request files. DRFS has been implemented using the Filesystem in Userspace (FUSE) interface, in order to provide users with transparent read and write operations. Experiments show the benefits of such a peer-to-peer architecture, when a small number of peers reads or writes in parallel: DRFS performs better than NFS, as soon as 6 peers read or write in parallel a 32 MB file. For unpopular files, it is also more reliable than IgorFS.

The ubiquitous wireless networks make it become possible for people to access a variety of services anytime and anywhere through mobile devices such as smartphone and tablet. However, due to the diversity and complexity of services, the requirement for storage and computing capacity for mobile devices is becoming higher and higher. Mobile transparent computing is a fit for this scenario. In mobile transparent computing, the client terminal is rather simple and light-weighted, and the operating systems, applications and user data are all regarded as software resources and stored in the server. The resources required in the user services are dynamically scheduled from the server to run on the client terminal in a streaming-block way via wireless network. In mobile transparent computing, we use the NFS (Network File System) protocol to realize the dynamic scheduling of resources. However, the wireless network environment is complex and unstable, and the wireless packet loss rate is high and the retransmission interval of lost packet is long in mobile transparent computing. In order to improve the scheduling efficiency of users' resources and the NFS performance, we analyze the factors that affect the NFS performance, including NFS read/write block size, wireless bandwidth and so on. We study the effect of bandwidth for the NFS performance when several mobile terminals schedule their resources at the same time. Finally, we improve the NFS performance by setting the optimal block size for read/write, and use TCP as our NFS transmission protocol in mobile transparent computing.

Analysis of NGS (Next Generation Sequencing) data is a computationally demanding task requiring large amounts of CPU, memory, and disk space. There is also a requirement for high performance data storage systems, resilient to hardware failure, to be connected directly to the computing infrastructure (typically a multi-node cluster) to store large quantities of NGS data reliably. Traditional shared file systems such as NFS (Network File System) do not offer the performance, scalability or cache coherence required by modern NGS data analysis, so alternatives including GlusterFS, Ceph, and Lustre have been developed. However, there is a trade-off between data safety on replicated local storage and degradation of performance across distributed storage. Resilience to hardware failure is typically provided by RAID (Redundant Array of Independent Disks) and redundant storage nodes. Here we describe the evaluation of an alternative file system, RozoFS ( https://github.com/rozofs/rozofs ) for use with demanding NGS data analysis workloads. We used a synthetic data set (DREAM-TCGA data set 3) to run a complete tumor-normal analysis pipeline (“bcbio”, https://github.com/chapmanb/bcbio-nextgen ), including base quality recalibration, local indel realignment, somatic variant calling, and structural variants as a benchmark to compare RozoFS with a traditional shared file system (NFS) on two different HPC (High Performance Computing; Cloud4CaRE project) clusters. Our results show high reliability and good performance of RozoFS compared to NFS, in particular, during heavy I/O workloads. These findings indicate that the reliability and robustness of RozoFS's make it a good candidate for demanding NGS analysis workloads.

Network File System is a widely used distributed file system that allows the user to access and manipulate storage on remote computers, as if they were a part of the local machine. Network File System is notoriously slow in its default configuration and if more clients connects to the NFS environment, it merely accentuates the delay. When configured to deliver faster speeds, the system suffers from higher risk of data corruption and loss. This study proposes a number of modifications to the Network File System, enabling it to provide elevated system performance, while containing the risk of data loss and corruption. Further, the proposed system behaves better in congested networks by consuming less bandwidth, ensuring decent speeds, even during periods of heavy network traffic.

CHAPTER 2 - Managing Filesystems

Traditionally, network storage systems have mainly been dominated by two IP-based storage technologies, i.e., Network Attached Storage (NAS) and Storage Area Network (SAN). In recent years, cloud based storage (e.g., Amazon S3) has gained growing popularity for its high flexibility and cross-platform compatibility. Many enterprises are considering to replace traditional storage systems with cloud-based systems. Evaluating such a transition demands a systematic study on understanding the performance behaviours of the emerging cloud storage. To fill in this gap, in this paper, we conduct a comprehensive study on the three storage systems with realistic network conditions. Specifically, we select one representative from each category for comparison, i.e., Network File System (NFS) from NAS, Internet Small Computer System Interface (iSCSI) from SAN, and OpenStack Swift from cloud storage. We build a testbed and develop a suite of micro-benchmarks to study the impact of network complexities. Through a set of experiments and detailed analysis, we make several key observations: (1) iSCSI excels under good network conditions, e.g., in local area networks (LANs) where network delay and packet loss are trivial, (2) NFS and Swift are more suitable for complex networks such as wireless networks and Internet environment, (3) Swift is a viable replacement for NFS in all scenarios we investigate, and (4) system configuration on the client side impacts storage performance significantly and deserves adequate attention. We hope our findings can not only shed light on storage service design and optimizations, but also encourage more research on emerging storage technologies.

The performance of a network based computing system that consists of a number of clients and a server, interconnected by a local area network, is studied. Each client represents a diskless or swapful workstation, or an X terminal, and generates application workload using either a conventional UNIX file system or the Network File System (NFS). To characterize the application workload and the effect of the protocol (login, rlogin, NFS), the user interface (workstation, X terminal) and its configuration (memory size, disk storage), a series of measurement experiments was performed in a controlled environment. During each experiment the traffic on the network and the activity on the various system resources were monitored. The measurements obtained are used to parameterize a queuing network model of the system, which is then used to project the performance of the system under various load conditions, to identify system bottlenecks, and to compare design alternatives. >

Building a Portable File System for Heterogeneous Clusters

A variety of workloads on wide-area networks (WAN) can benefit from parallel data streams. Whether between public and private clouds or between high-performance computing centres, high bandwidth-delay-product (BDP) networks with even small amounts of packet loss (e.g., due to congestion) can suffer reduced TCP/IP throughput. Therefore, we design, implement, and evaluate the open-source Parallel Data Streams (PDS) user-level tool. PDS makes trade-offs (e.g., TCP fairness) for specific workloads, when performance is the key goal. Unlike the well-known GridFTP, PDS also supports tools such as rsync, git, Virtual Network Computing (VNC), and the Network File System (NFS). We also quantify and contribute a performance evaluation of PDS, using a combination of emulated and real WANs. We establish that PDS achieves comparable performance to GridFTP for file transfer, but additional functionality via other tools. For example, PDS can transfer a 14 GB file on a WAN between Alberta and Quebec (maximum 1 Gbps; over 3,100 km) at 861 Mbps, using rsync and 8 parallel, cleartext, TCP streams. In comparison, rsync over a single SSH stream achieves 274 Mbps.

Chapter 18 - File Systems

We develop a holistic framework for adaptively scheduling asynchronous requests in distributed file systems. The system is holistic in that it manages all resources, including network bandwidth, server I/O, server CPU, and client and server memory utilization. It accelerates, defers, or cancels asynchronous requests in order to improve application-perceived performance directly. We employ congestion pricing via online auctions to coordinate the use of system resources by the file system clients so that they can detect shortages and adapt their resource usage. We implement our modifications in the Congestion-Aware Network File System (CA-NFS), an extension to the ubiquitous network file system (NFS). Our experimental result shows that CA-NFS results in a 20% improvement in execution times when compared with NFS for a variety of workloads.

The issues that must be considered in structuring file storage for very large distributed systems are discussed. The authors describe the distributed file system they are developing, which is called FACE (file system for ACE). The first prototype of FACE consists of a series of enhancements to Sun's network file system (NFS) in order to add a stashing capability. User processes interact with the system call interface to perform file and stashing operations. These operations may be invoked directly by user processes or by the FACE user-level routines. The FACE user-level routines implement diverse facilities to allow users to select the files that will be stashed (or dropped from the stash). The first FACE prototype is being implemented on a Sun 3/50 computer running Suri's Unix 4.2 release 3.3. >