- AboutThis should describe the systems research collaboration, and present the overall research goals of the new group.
- PeopleHere are the different labs in the SRC…
- PublicationsA page where you will find categorized publications!
- ProjectsA page where you will find our projects
- ResourcesVarious resources for prospective students, current students, alumni. Maybe put something here about life in NYC and at Columbia…
Proceedings of the 2001 USENIX Annual Technical Conference, June 2001
Stackable file systems can provide extensible file sys- tem functionality with minimal performance overhead and development cost. However, previous approaches provide only limited functionality. In particular, they do not sup- port size-changing algorithms (SCAs), which are important and useful for many applications such as compression and encryption. We propose fast indexing, a technique for effi- cient support of SCAs in stackable file systems. Fast index- ing provides a page mapping between file system layers in a way that can be used with any SCA. We use index files to store this mapping. Index files are designed to be recover- able if lost and add less than 0.1% disk space overhead. We have implemented fast indexing using portable stackable templates, and we have used this system to build several ex- ample file systems with SCAs. We demonstrate that fast in- dex files have low overhead for typical user workloads such as large compilations, only 2.3% over other stacked file systems and 4.7% over non-stackable file systems. Our sys- tem can deliver better performance with SCAs than user- level applications, as much as five times faster.
Ph.D. Thesis, Department of Computer Science, Columbia University, May 2001
File systems often need to evolve and require many changes to support new features. Traditional file-system development is difficult because most of the work is done in the kernelâ€”a hostile development environment where progress is slow, debugging is difficult, and simple mistakes can crash systems. Kernel work also requires deep understanding of system internals, resulting in developers spending a lot of time becoming familiar with the systemâ€™s details. Furthermore, any file system written for one system requires significant effort to port to another system. Stackable file systems promise to ease the development of file systems by offering a mechanism for incremental development building on existing file systems. Unfortunately, existing stacking methods often require writing complex low-level kernel code that is specific to a single operating system platform and also difficult to port. We propose a new language, FiST, to describe stackable file systems. FiST uses operations common to file-system interfaces and familiar to user-level developers: creating a directory, reading a file, removing a file, listing the contents of a directory, etc. From a single description, FiSTâ€™s compiler produces file-system modules for multiple platforms. FiST does that with the assistance of platform-specific stackable templates. The templates handle many of the internal details of operating systems, and free developers from dealing with these internals. The templates support many features: data copying and file name copying useful for applications that want to modify them; size-changing file systems such as compression; fan-out for access to multiple file systems from one layer; and more. The FiST language compiler uses the templates as a basis for producing code for a new file system, by inserting, removing, or modifying code in the templates. This dissertation describes the design, implementation, and evaluation of FiST. Our thesis is that it is possible to extend file system functionality in a portable way without changing existing kernels. This is possible because the FiST language uses file-system functions that are common across many systems, while the templates execute in-kernel operating systems specific functions unchanged. We built several file systems using FiST on Solaris, FreeBSD, and Linux. Our experiences with these file systems show the following benefits: average code size is reduced ten times as compared to writing code given another null-layer stackable file system; average development time is reduced seven times compared to writing using another null-layer stackable file system; performance overhead of stacking is only 1â€“2% per layer.
NMADS-3: NYC Metro Area Distributed Systems, April 2001
Internet2 Network Research Workshop Spring 2001, April 2001
Department of Computer Science, Columbia University Technical Report , CUCS-022-00, November 2000
Thin-client computing offers the promise of easier-to-maintain computational services with reduced total cost of ownership. The recent and growing popularity of thin-client systems makes it important to develop techniques for analyzing and comparing their performance, to assess the general feasibility of the thin-client computing model, and to determine the factors that govern the performance of these architectures. To assess the viability of the thin-client computing model, we measured the performance of five popular thin-client platforms running over a wide range of network access bandwidths. Our results show that current thin-client solutions generally work well in a LAN environment, but their performance degrades significantly when they are used in todayâ€™s broadband environments. We also find that the efficiency of the thin-client protocols varies widely. In some cases, the efficiency of the thin client protocol for web applications is within a factor of two of standard web protocols, while others are 30 times more inefficient. We analyze the differences in the various approaches and explain the impact of the underlying remote display protocols on overall performance
Technical Report CUCS-023-00, November 2000
Dr. Dobb's Journal, August 2000
In this article, we'll present a different perspective by discussing our experiences teaching operating-systems courses at Columbia University (http://www.cs.columbia.edu/~nieh/teaching/w4118). Using Linux and VMware, we were able to give students a flexible virtual kernel-level development environment in which operating systems can be developed, debugged, and rebooted in a shared computing lab environment without affecting other application users.
Proceedings of the 2000 USENIX Annual Technical Conference, June 2000
Traditional file system development is difficult. Stack- able file systems promise to ease the development of file systems by offering a mechanism for incremental develop- ment. Unfortunately, existing methods often require writ- ing complex low-level kernel code that is specific to a sin- gle operating system platform and also difficult to port. We propose a new language, FiST, to describe stackable file systems. FiST uses operations common to file system interfaces. From a single description, FiSTâ€™s compiler pro- duces file system modules for multiple platforms. The gen- erated code handles many kernel details, freeing developers to concentrate on the main issues of their file systems. This paper describes the design, implementation, and evaluation of FiST. We extended file system functionality in a portable way without changing existing kernels. We built several file systems using FiST on Solaris, FreeBSD, and Linux. Our experiences with these examples shows the following benefits of FiST: average code size over other stackable file systems is reduced ten times; average devel- opment time is reduced seven times; performance overhead of stacking is 1â€“2%.
Proceedings of the 10th International Workshop on Network and Operating System Support for Digital Audio and Video, June 2000
The server-based computing (SBC) model is becoming an increasingly popular approach for delivering computa- tional services with reduced administrative costs and better resource utilization. In this paper, we examine how effec- tively SBC architectures support multimedia applications. We focus on the effectiveness of the remote display proto- col used in three popular SBC platforms for supporting video applications, Citrix Metaframe, Windows Terminal Server, and AT&T VNC. Our results show that SBC can be a viable approach for delivering VCR-quality video in LAN environments, but that existing solutions are inade- quate at network access bandwidths found in broadband environments. Our results also show that SBC can deliver video with comparable network efficiency as streaming media solutions. We show that there is wide variation in the performance of the remote display technologies and discuss the factors that influence their performance.