Ramnatthan Alagappan

Ramnatthan Alagappan

Auto-generated profile, based on publicly available information

Ramnatthan Alagappan

University of Illinois Urbana-Champaign, Urbana, IL, USA

Research Focus & Metrics

Academic Career Length

5Years (2022-Present)

(Calculated once Scilit publication data is synced: current year − year of first publication + 1)

Representative Publications

View All Publications
4 November 2024
Verified
Conference Paper
Open access
XLXuhao Luo
Xuhao Luo
SBShreesha G. Bhat
Shreesha G. Bhat
JHJiyu Hu
Jiyu Hu
RARamnatthan Alagappan
Ramnatthan Alagappan
AGAishwarya Ganesan
Aishwarya Ganesan
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.

31 August 2022 in ACM Transactions on Storage
Verified
Journal Article
Open access
AGAishwarya Ganesan
Aishwarya Ganesan
RARamnatthan Alagappan
Ramnatthan Alagappan
ARAnthony Rebello
Anthony Rebello
AAAndrea C. Arpaci-Dusseau
Andrea C. Arpaci-Dusseau
RARemzi Arpaci-Dusseau
Remzi Arpaci-Dusseau
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.


19 August 2025 in ACM Transactions on Computer Systems
Verified
Journal Article
Open access
XLXuhao Luo
Xuhao Luo
SBShreesha Gopalakrishna Bhat
Shreesha Gopalakrishna Bhat
JHJiyu Hu
Jiyu Hu
RARamnatthan Alagappan
Ramnatthan Alagappan
AGAishwarya Ganesan
Aishwarya Ganesan
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.

26 April 2026
Verified
Conference Paper
Open access
KHKiran Hombal
Kiran Hombal
HZHenry Zhu
Henry Zhu
SBShreesha Gopalakrishna Bhat
Shreesha Gopalakrishna Bhat
NKNeil Kaushikkar
Neil Kaushikkar
RARamnatthan Alagappan
Ramnatthan Alagappan
AGAishwarya Ganesan
Aishwarya Ganesan
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).

28 September 2026
Verified
Conference Paper
Open access
SBShreesha G. Bhat
Shreesha G. Bhat
THTony Hong
Tony Hong
MNMichael A Noguera
Michael A Noguera
AGAishwarya Ganesan
Aishwarya Ganesan
RARamnatthan Alagappan
Ramnatthan Alagappan
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.