The ADvanced Systems Laboratory (ADSL)
Projects

The ADvanced Systems Laboratory develops systems software for emerging workloads and hardware. Our current work spans ML systems, AI agents, memory and storage, operating systems, cloud data systems, and distributed systems. We combine careful measurement and analysis with the design and implementation of new systems.

We're especially interested in boundaries that no longer fit cleanly: storage versus communication in large-scale ML training, application versus kernel control in agentic workflows, objects versus pages in memory management, and local versus global coordination in distributed systems. These changing boundaries create opportunities to rethink long-standing systems abstractions for new applications and platforms.

Current and Recent Research

[ML Systems and AI Infrastructure]
[Systems for AI Agents]
[Modern Memory, Storage, and Data Movement]
[Reliable and Extensible Operating Systems]
[Cloud Data Systems and Serverless Computing]
[Distributed Systems, Consensus, and Blockchains]

ML Systems and AI Infrastructure

Training and serving modern machine-learning models place extreme demands on data movement, memory, networking, accelerators, and fault tolerance. We're developing new systems abstractions that make large-scale ML infrastructure more efficient, elastic, and easier to manage.

Our recent work includes TensorHub, a system for scalable and elastic transfer of model weights during LLM reinforcement learning. TensorHub introduces Reference-Oriented Storage, which provides the flexibility of a storage interface without requiring additional copies of model weights. Instead, it locates and transfers weights directly from the GPU workers that already hold them.

We're also working to eliminate unnecessary data movement in modern data-processing and ML pipelines. Kelvin: Approaching Absolute Zero-Copy Data Pipelines enables containers in a data pipeline to share physical memory pages rather than repeatedly copying intermediate data. Kelvin extends our earlier work on Zerrow and zero-copy Arrow pipelines.

Together, these projects explore a broader question: how should storage, communication, and operating-system abstractions change when data objects are enormous, highly replicated, distributed across accelerators, and moved continuously through ML workflows?

Systems for AI Agents

AI agents don't just compute over data; they take actions that modify files, invoke tools, and change persistent system state. Existing operating-system interfaces were designed primarily for human-directed applications, not for autonomous agents that may make mistakes at machine speed.

Our work explores how systems can give agents greater autonomy while preserving safety, transparency, and user control. YoloFS is an agent-native filesystem that stages changes before they're committed, uses snapshots to help agents detect and correct their own mistakes, and provides progressive permissions without requiring constant user approval.

More broadly, we're interested in developing system interfaces that let agents understand the consequences of their actions, recover from mistakes, and interact safely with files, storage, and other shared resources.

Modern Memory, Storage, and Data Movement

Modern systems combine DRAM, accelerators, byte-addressable memory, and multiple forms of persistent storage, each with different performance, capacity, and cost characteristics. Our research examines how data should be organized, placed, cached, shared, and moved across these heterogeneous resources.

OBASE introduces object-based address-space engineering for memory tiering. It reorganizes virtual memory so that frequently accessed objects are grouped into hot pages and less frequently accessed objects into cold pages, allowing existing page-based memory-tiering mechanisms to make better placement decisions.

Other representative work includes Orthus, NyxCache, WiscSort, Symbiosis, MOST, and cache-centric multi-resource allocation.

Reliable and Extensible Operating Systems

We study how to make fundamental operating-system mechanisms more observable, testable, recoverable, and safe to extend. This work spans CPU scheduling, kernel extensions, file-system architecture, and recovery from runtime failures.

kSTEP provides fine-grained, deterministic control over the events that invoke the Linux CPU scheduler. By producing repeatable, noise-free executions, kSTEP makes subtle scheduler behavior easier to characterize and enables automated, coverage-guided testing of the scheduler.

Our work on operating-system and file-system reliability also includes filesystem semi-microkernels, MadFS, Shadow Filesystems, and Ananke. These systems explore per-file virtualization, fault isolation, recovery through alternative execution, and fast, transparent recovery from runtime failures.

We've also studied declarative system calls, application recovery from fsync failures, and the foundations of eBPF-based kernel extensions.

Cloud Data Systems and Serverless Computing

Cloud applications increasingly rely on collections of specialized storage services, disaggregated resources, and short-lived computational tasks. We study how these architectures behave and how they can provide better performance, efficiency, isolation, and cost proportionality.

Our recent work includes Cloudscape, a study of storage services in modern cloud architectures; LiquidCache, which pushes caching into cloud-native data-processing systems; Leopard, which makes serverless execution more closely match a pay-for-use model; and LambdaStore, which explores a data-centric approach to serverless computing.

Across these projects, we're exploring how cloud systems can avoid unnecessary data movement, make better use of memory and storage, and provide efficient execution for increasingly data-intensive applications.

Distributed Systems, Consensus, and Blockchains

Distributed systems must provide strong guarantees despite failures, concurrency, changing network conditions, and geographically distributed clients. Our work develops new consistency and durability models, more efficient consensus and logging mechanisms, and tools for studying distributed systems at scale.

Bodega extends consensus systems so that linearizable reads can be served locally from selected replicas. Its roster-lease abstraction generalizes traditional leader and quorum leases, enabling systems to move read service closer to clients while preserving strong consistency.

Other recent projects include XLL cross-layer logging, Chain-in-the-Box, Consistency-Aware Durability, nil-externality for replicated storage, and cloud consensus protocols with optimistic connectivity.

For a complete list of publications, dissertations, software, slides, and other research materials, see our publications page.

Foundational and Earlier Research

Our group's current work builds on a long history of research in file and storage systems. Earlier contributions include measurement-driven systems research, gray-box systems, semantically smart disks, storage interfaces, flash-based SSDs, performance isolation, crash consistency, failure analysis, and distributed-storage reliability.

The sections below describe these foundational research directions and their influence on our subsequent work.

[Improving Performance in File and Storage Systems]
[Analysis and Benchmarking] [Storage Interfaces] [Flash-based SSDs] [Performance Isolation] [Containers] [Scientific Workloads]

[Improving the Robustness of File and Storage Systems]
[Failure Analysis] [Handling Failures] [Crash Consistency] [Distributed Storage]

[Gray-box Systems]
[Gray-box OS] [Semantically-Smart Disks] [VMMs]

1) Improving Performance in File and Storage Systems

Performance Analysis and Benchmarking (2000-Present)

One theme that underlies our work is measurement-driven systems research. We strongly believe that carefully measuring and understanding the current state of the art serves as an excellent catalyst for research and educational innovation. We have developed an array of techniques to bring out surprisingly detailed characterizations of the system under test, showing that even subtle behaviors can be teased out through careful experimentation. Specifically, we have developed new techniques to understand RAID arrays, journaling file systems, distributed storage systems (EMC Centera), Apple Desktop Applications, Facebook Messages, and tail latencies within local file systems.
More details here.
PhD Students: Tim Denehy, Vijayan Prabhakaran, Haryadi Gunawi, Tyler Harter, Jun He, Nitin Agarawal, Leo Arulraj, Zev Weiss

Storage Interfaces (2002-Present)

Our performance studies led us to the realization that oftentimes the existing layering of a system prevents the implementation of useful performance optimizations. We have explored how to break through such layering limitations. For example, we have co-designed the file system to better interact with RAID, expose new disk interfaces, and even push the entire file system into the storage device.
More details here.
PhD Students and Postdocs: Tim Denehy, Florentina Popovici, Sudarsun Kannan

Flash-based SSDs (2012-Present)

For many years, hard drives dominated the storage landscape; however, the past decade has seen the introduction and proliferation of Flash-based solid-state devices (SSDs). We have investigated ways to improve an SSD-based storage stack and have defined the unwritten contract for how SSDs should be used for the highest performance and longest lifetime. Using our detailed understanding of the performance characteristics of SSDs, we developed an optimized key-value store (WiscKey) and search engine.
More details here.
PhD Students: Lanyue Lu, Thanu Pillai, Yupu Zhang, Leo Arulraj, Yiying Zhang, Swami Sundararaman, Sriram Subramanian, Zev Weiss, Jun He, Kan Wu

Performance Isolation (2014-Present)

We have investigated performance isolation in storage systems: can the system ensure that the performance of one application is not affected by the I/O patterns of others? We introduce three pioneering approaches to ensure such isolation, both within a single machine and in a distributed storage setting.
More details here.
PhD Students and Postdocs: Lanyue Lu, Yupu Zhang, Thanh Do, Samer Al-Kiswany, Suli Yang, Jing Liu, Yuvraj Patel

Containers (2016-Present)

One of our recent performance-oriented sub-area of research focuses on new container technologies arising in the cloud, and the resulting new models of execution that are possible. We've shown how to integrate snapshot-based file storage into a Docker code repository. We also introduced OpenLambda, one of the first open-source lambda execution environments available, and present its key facets.
More details here.
PhD Students: Tyler Harter

Scientific Workflows (2002-2004)

We have studied I/O workloads and necessary systems support in scientific (HPC) workloads; this led to both performance studies and new systems to better support HPC applications.
More details here.
PhD Students: John Bent

2) Developing Robust Storage Systems

Single Node and Device Failure Analysis (2005-2013)

Another emphasis in our work is in analyzing and handing failures in file and strorage systems. Our empirical approach to understanding how systems react to failure has led to numerous new techniques and insights on how such systems operate under faults, and has significantly improved the reliability of existing systems, for both local and distributed file systems.
PhD Students: Vijayan Prabhakaran, Lakshmi Bairavasundaram, Nitin Agrawal, Haryadi Gunawi, Lanyue Lu, Yupu Zhang

Handling Failures (2007-2011)

We have also created numerous new mechanisms to handle failures in storage systems, including an I/O shepherd within the file system, a framework for n-version file systems, restartable file systems, and failure-free memory allocation on I/O paths.
PhD Students: Lakshmi Bairavasundaram, Swami Sundararaman, Haradi Gunawi, Vijayan Prabhakaran, Sriram Subramanian, Yupu Zhang

Crash Consistency (2008-Present)

One sub-area we have studied in great detail is file system crash consistency. Many earlier works ignored this important topic, but due to our contributions, it is now a standard part of file system evaluation and discussion. Some of our work has focused on building file system checkers, either using a declarative approach as in SQCK, or simply making them faster, as in ffsck. We have explored how disks lie about which writes have been persisted to disk and how file systems can get around this misbehavior: either by forcing the disk to evict items from its cache or redesigning the file system so that it can still provide consistency even if writes are reordered by the disk. We also performed the first study of file system crash consistency behaviors and showed that different data-intensive applications (databases, key-value stores, version control software) are incorrect given the behavior of modern file systems. Finally, we developed two different file systems (OptFS and CCFS) that are able to improve performance dramatically by reducing the number of fsyncs that must be performed, yet still deliver correct performance to applications. As part of this work, we articulated the differences between providing ordering and durability for file system data.
PhD Students and Postdocs: Vijay Chidambaram, Thanu Pillai, Haradi Gunawi, Ram Alagappan, Lanyue Lu, Samer Al-Kiswany

Distributed Storage (2011-Present)

Our last and most recent series of contributions focus on the robustness of distributed storage systems. Here, we both introduce new methods to test such systems, and then show how to build more reliable storage under the presence of common failure scenarios.
PhD Students: Ram Alagappan, Aishwarya Ganesan

3) Graybox Systems

One of our earliest ideas was that of building gray-box systems. The driving force behind this idea is that in some scenarios it is challenging to change an existing system to have the exact functionality desired; surprisingly, however, in many cases it is still possible to realize the desired functionality without any change to said system, through a combination of measurement of the system plus knowledge (perhaps imperfect) of how the system operates.

Graybox Systems: OS (2000-2004)

We have shown how graybox techniques can be used to add functionality to the OS, including the buffer cache, file layout, I/O scheduling, and TCP extensions.
More details here.
PhD Students: Nathan Burnett, Timothy Denehy, Haradi Gunawi, Florentina Popovici, John Bent

Semantically-Smart Disk Systems (2003-2005)

One rich off-shoot of the gray-box work occurred when we had the following insight. The disk and RAID industry, for years, had been hampered for years by limited information: at the block level, all a device sees are reads and writes, with no knowledge as to the contents of each block, its importance, and other relevant characteristics. If a ``dumb'' disk could just know more about how such blocks are utilized, it could implement a surprising range of features to improve performance and reliability of the I/O system. As our work demonstrates, gray-box techniques enable such knowledge. By assuming certain details about the client of the disk (e.g., that it is a file system of a particular type), a semantically-smart disk can learn how it is being used and thus implement features previously unattainable at block level.
More details here.
PhD Students: Lakshmi Bairavasundaram, Muthian Sivathanu, Timothy Denehy, Florentina Popovici, Vijayan Prabhakaran

Introspective Virtual Machine Monitors (2006-2017)

Virtual machine monitors (VMMs) are a natural target environment for graybox techniques. In traditional VMM settings, the VMM has little knowledge of what the OS above is doing, and thus is limited in what types of functionality it can realize itself. With gray-box knowledge, we show that novel and interesting services can be realized inside VMMs.
More details here.
PhD Students: Stephen Jones, Leo Arulraj

The ADvanced Systems Laboratory (ADSL) Projects