Ramnatthan Alagappan
Current Organizations / Institutes
The organizations/institutes from the scholar's latest article
Previous Organizations / Institutes
The organizations / institutes from the scholar's other articles in the past ten years
Ramnatthan Alagappan has a total of 13 co-authors. Here are the top co-authors by number of shared publications:
- Aishwarya Ganesan
University of Illinois Urbana-Champaign, Urbana, IL, USA
7 shared publications - Shreesha Gopalakrishna Bhat
University of Illinois Urbana-Champaign, Urbana, IL, USA
4 shared publications - Jiyu Hu
University of Illinois Urbana-Champaign, Urbana, USA
3 shared publications - Xuhao Luo
Computer Sciences, University of Wisconsin--Madison
3 shared publications - Kiran Hombal
University of Illinois Urbana-Champaign, Urbana, USA
2 shared publications - Andrea Arpaci-Dusseau
University of Wisconsin–Madison, Madison, Wisconsin, USA
1 shared publication
Latest Publications
- Open Access
- 28 September 2026
- Published by Association for Computing Machinery (ACM)
- p. 229-246
Disk-Based LSMs: An Unexpectedly Good Index for Partly Coherent CXL Memory
- 28 September 2026
- Published by Association for Computing Machinery (ACM)
- p. 229-246
Open AccessDisk-Based LSMs: An Unexpectedly Good Index for Partly Coherent CXL Memory
- Open Access
- 28 September 2026
- Published by Association for Computing Machinery (ACM)
- p. 412-429
AgileLog: A Forkable Shared Log for Agents on Data Streams
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, a system that implements the AgileLog abstraction. Bolt uses many novel techniques to make forks cheap and to provide logical and performance isolation.
- 28 September 2026
- Published by Association for Computing Machinery (ACM)
- p. 412-429
Open AccessAgileLog: A Forkable Shared Log for Agents on Data Streams
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, a system that implements the AgileLog abstraction. Bolt uses many novel techniques to make forks cheap and to provide logical and performance isolation.
- Open Access
- 26 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 1381-1398
A Logically Disaggregated Cache for Replicated Storage Systems
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).
- 26 April 2026
- Published by Association for Computing Machinery (ACM)
- p. 1381-1398
Open AccessA Logically Disaggregated Cache for Replicated Storage Systems
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).
- Open Access
- 19 August 2025
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Computer Systems
- Vol. 44 (4) , 1-33
LazyLog: A New Shared Log Abstraction and Design for Modern Low-Latency Applications
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.
- 19 August 2025
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Computer Systems
- Vol. 44 (4) , 1-33
Open AccessLazyLog: A New Shared Log Abstraction and Design for Modern Low-Latency Applications
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.
- Open Access
- 4 November 2024
- Published by Association for Computing Machinery (ACM)
- p. 296-312
LazyLog: A New Shared Log Abstraction for Low-Latency Applications | Proceedings of the ACM SIGOPS 30th Symposium on Operating Systems Principles
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.
- 4 November 2024
- Published by Association for Computing Machinery (ACM)
- p. 296-312
Open AccessLazyLog: A New Shared Log Abstraction for Low-Latency Applications | Proceedings of the ACM SIGOPS 30th Symposium on Operating Systems Principles
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.
- Open Access
- 22 April 2024
- Published by Association for Computing Machinery (ACM)
- p. 590-607
SplitFT: Fault Tolerance for Disaggregated Datacenters via Remote Memory Logging
- 22 April 2024
- Published by Association for Computing Machinery (ACM)
- p. 590-607
Open AccessSplitFT: Fault Tolerance for Disaggregated Datacenters via Remote Memory Logging
- Open Access
- 31 August 2022
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Storage
- Vol. 18 (3) , 1-35
Exploiting Nil-external Interfaces for Fast Replicated Storage
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.
- 31 August 2022
- Published by Association for Computing Machinery (ACM) in ACM Transactions on Storage
- Vol. 18 (3) , 1-35
Open AccessExploiting Nil-external Interfaces for Fast Replicated Storage
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.