About

Ram Alagappan is an Assistant Professor at the Siebel School of Computing and Data Science at the University of Illinois Urbana-Champaign, starting in 2022. He holds a Ph.D. and M.S. in Computer Science from the University of Wisconsin-Madison, completed in 2019 and 2018 respectively. His research interests include storage systems, distributed systems, and operating systems, with a focus on systems and networking. Alagappan has received numerous honors, including the NSF CAREER Award in 2023, the Best Paper Award at the USENIX Conference on File and Storage Technologies in 2020, and the Best Paper Award at the Symposium on Operating Systems Principles in 2024. He has also been recognized for his teaching, being ranked as excellent by students in courses such as Storage Systems and Operating Systems Design. His work has contributed to advancing storage technology for data centers and he has been involved in research that supports shared logs and other innovations in storage systems.

Research topics

• Computer Science
• Artificial Intelligence
• Parallel computing
• Database
• Information Retrieval
• Programming language
• Algorithm
• Mathematics
• Theoretical computer science
• Computer network
• Distributed computing
• Operating system

Selected publications

• A Logically Disaggregated Cache for Replicated Storage Systems

  2026-04-24

  articleOpen access

  We study if replicated storage systems effectively utilize the caches embedded within each replica. Our study reveals that existing systems manage the embedded caches in each replica in silos, leading to significant cache redundancy across replicas and consequently low performance. To address this problem, we introduce logically disaggregated cache (Ldc), a new approach to managing caches in replicated storage systems. Ldc disaggregates the embedded caches from the replicas to form a single, logical cache. Ldc then allows any replica to access any part of the logical cache, which reduces redundancy caused by reads. Because writes pollute all caches, Ldc quickly demotes written objects to limit redundancy caused by writes. Ldc, however, realizes that reducing redundancy may hurt performance in some cases and thus employs an online analyzer to strike a balance between cache redundancy and coverage. We implement Ldc in three systems: an eventually-consistent KV store, a strongly-consistent KV store, and a production database. Using microbenchmarks, macrobenchmarks, and real-world traces, we show that the Ldc versions perform significantly better than the original systems (e.g., 2.6× to 5.4× higher throughput in the eventually-consistent KV store under YCSB).

  PublisherDOI

• AgileLog: A Forkable Shared Log for Agents on Data Streams

  arXiv (Cornell University) · 2026-04-16

  articleOpen access

  In modern data-streaming systems, alongside traditional programs, a new type of entity has emerged that can interact with streaming data: AI agents. Unlike traditional programs, AI agents use LLM reasoning to accomplish high-level tasks specified in natural language over streaming data. Unfortunately, current streaming systems cannot fully support agents: they lack the fundamental mechanisms to avoid the performance interference caused by agentic tasks and to safely handle agentic writes. We argue that the shared log, the core abstraction underlying streaming data, must support creating forks of itself, and that such a forkable shared log serves as a great substrate for agents acting on streaming data. We propose AgileLog, a new shared log abstraction that provides novel forking primitives for agentic use cases. We design Bolt, an implementation of the AgileLog abstraction, that uses novel techniques to make forks cheap, and provide logical and performance isolation.

  PublisherOA PDF

• AgileLog: A Forkable Shared Log for Agents on Data Streams

  arXiv (Cornell University) · 2026-04-16

  preprintOpen access

  In modern data-streaming systems, alongside traditional programs, a new type of entity has emerged that can interact with streaming data: AI agents. Unlike traditional programs, AI agents use LLM reasoning to accomplish high-level tasks specified in natural language over streaming data. Unfortunately, current streaming systems cannot fully support agents: they lack the fundamental mechanisms to avoid the performance interference caused by agentic tasks and to safely handle agentic writes. We argue that the shared log, the core abstraction underlying streaming data, must support creating forks of itself, and that such a forkable shared log serves as a great substrate for agents acting on streaming data. We propose AgileLog, a new shared log abstraction that provides novel forking primitives for agentic use cases. We design Bolt, an implementation of the AgileLog abstraction, that uses novel techniques to make forks cheap, and provide logical and performance isolation.

  PublisherDOI

• LazyLog: A New Shared Log Abstraction and Design for Modern Low-Latency Applications

  ACM Transactions on Computer Systems · 2025-08-19

  articleOpen access

  Shared logs offer linearizable total order across storage shards. However, they enforce this order eagerly upon ingestion, leading to high latencies. We observe that in many modern shared-log applications, while linearizable ordering is necessary, it is not required eagerly when ingesting data but only later when data is consumed. Further, readers are naturally decoupled in time from writers in these applications. Based on this insight, we propose LazyLog, a novel shared log abstraction. LazyLog lazily binds records (across shards) to linearizable global positions and enforces this before a log position can be read. Such lazy ordering enables low ingestion latencies. Given the time decoupling, LazyLog can establish the order well before reads arrive, minimizing overhead upon reads. We build two LazyLog systems that provide linearizable total order across shards. Our experiments show that LazyLog systems deliver significantly lower latencies than conventional, eager-ordering shared logs.

  PublisherOA PDFDOI

• LazyLog: A New Shared Log Abstraction for Low-Latency Applications

  2024-11-04 · 6 citations

  articleOpen access

  Shared logs offer linearizable total order across storage shards. However, they enforce this order eagerly upon ingestion, leading to high latencies. We observe that in many modern shared-log applications, while linearizable ordering is necessary, it is not required eagerly when ingesting data but only later when data is consumed. Further, readers are naturally decoupled in time from writers in these applications. Based on this insight, we propose LazyLog, a novel shared log abstraction. LazyLog lazily binds records (across shards) to linearizable global positions and enforces this before a log position can be read. Such lazy ordering enables low ingestion latencies. Given the time decoupling, LazyLog can establish the order well before reads arrive, minimizing overhead upon reads. We build two LazyLog systems that provide linearizable total order across shards. Our experiments show that LazyLog systems deliver significantly lower latencies than conventional, eager-ordering shared logs.

  PublisherOA PDFDOI

• SplitFT: Fault Tolerance for Disaggregated Datacenters via Remote Memory Logging

  2024-04-18 · 2 citations

  article

  We introduce SplitFt, a new fault-tolerance approach for storage-centric applications in disaggregated data centers. SplitFt uses a novel split architecture, where large writes are directly performed on the underlying disaggregated storage system, while small writes are made fault-tolerant within the compute layer. The split architecture enables applications to achieve strong durability guarantees without compromising performance. SplitFt makes small writes fault-tolerant using a new abstraction called near-compute logs or Ncl, which leverages underutilized memory on remote nodes to log small writes in a fast, cheap, and transparent manner. We port three POSIX applications (RocksDB, Redis, and SQLite) to SplitFt and show that they offer strong guarantees compared to weak versions of the applications that can lose data; SplitFt applications do so while approximating weak versions' performance (only 0.1%-10% overhead under YCSB). Compared to strong versions, SplitFt improves performance significantly (2.5× to 27× under write-heavy workloads).

  PublisherDOI

• Crash Consistency

  Queue · 2022-08-31

  articleOpen access1st authorCorresponding

  Keeping data safe in the presence of crashes is a fundamental problem in storage systems. Although the high-level ideas for crash consistency are relatively well understood, realizing them in practice is surprisingly complex and full of challenges. The systems research community is actively working on solving this challenge, and the papers examined here offer three solutions.

  PublisherOA PDFDOI

• Exploiting Nil-external Interfaces for Fast Replicated Storage

  ACM Transactions on Storage · 2022-06-06 · 3 citations

  article

  Do some storage interfaces enable higher performance than others? Can one identify and exploit such interfaces to realize high performance in storage systems? This article answers these questions in the affirmative by identifying nil-externality , a property of storage interfaces. A nil-externalizing (nilext) interface may modify state within a storage system but does not externalize its effects or system state immediately to the outside world. As a result, a storage system can apply nilext operations lazily, improving performance. In this article, we take advantage of nilext interfaces to build high-performance replicated storage. We implement Skyros , a nilext-aware replication protocol that offers high performance by deferring ordering and executing operations until their effects are externalized. We show that exploiting nil-externality offers significant benefit: For many workloads, Skyros provides higher performance than standard consensus-based replication. For example, Skyros offers 3× lower latency while providing the same high throughput offered by throughput-optimized Paxos.

  PublisherDOI

• Research for Practice

  Communications of the ACM · 2022-12-20

  article1st authorCorresponding

  Keeping data safe in the presence of crashes is a fundamental problem.

  PublisherDOI

• Skyros Traces

  Zenodo (CERN European Organization for Nuclear Research) · 2021-09-21

  datasetOpen access

  Traces for reproducing the results in our SOSP '21 paper: Exploiting Nil-Externality for Fast Replicated Storage.

  PublisherDOI

Frequent coauthors

• Remzi H. Arpaci-Dusseau

  27 shared

• Andrea C. Arpaci-Dusseau

  University of Wisconsin–Madison

  26 shared

• Aishwarya Ganesan

  University of Illinois Urbana-Champaign

  20 shared

• Vijay Chidambaram

  10 shared

• Thanumalayan Sankaranarayana Pillai

  8 shared

• Aws Albarghouthi

  4 shared

• Yifan Dai

  3 shared

• Brian Kroth

  3 shared

Awards & honors

• Best Paper Award, USENIX Conference on File and Storage Tech…
• Honorable Mention - Graduate Student Research Award, Compute…
• Best Paper Award, USENIX Conference on File and Storage Tech…
• Nominee, Best Paper Award, USENIX Conference on File and Sto…
• Research Honors Best Paper Award, Symposium on Operating Sys…