publications by categories in reversed chronological order.
PDFs linked below are the author's version of each work, provided for personal, non-commercial use only and not for redistribution. Please refer to the DOI link for the version of record.
Conferences
2026
Splyce: SIMD Vectorization of Sparse Coiteration
Kabilan Mahathevan, Poorna Gunathilaka, and Kirshanthan Sundararajah
In Proceedings of the 35th ACM International Conference on Parallel Processing Techniques and Applications (PACT 2026), 2026
Sparse tensor contractions are bottlenecked by sparse-sparse coiteration loops that resist standard loop vectorization. We present Splyce, an auto-vectorization framework in MLIR that overcomes this through a dual-path execution model. By decoupling coordinate intersection from pointer management via selective predication, Splyce inherently eliminates data-dependent branches as a side effect, allowing modern superscalar engines to maximize instruction-level parallelism and hide memory latency. Beyond simple branch elimination, our transformation exposes independent computation that can be executed concurrently, increasing functional-unit utilization that would otherwise be constrained by sequential dependencies. Evaluation across foundational sparse tensor kernels demonstrates performance ranging from 1.96x to 2.86x on synthetic inputs, with consistent speedups sustained across a vast majority of irregular real-world datasets from the SuiteSparse collection. Ultimately, Splyce demonstrates that by converting unpredictable control-flow into a predictable data stream, compiler-driven speculation can effectively reconcile the memory efficiency of compressed storage with the execution-unit throughput of modern superscalar architectures.
Dialect-Agnostic SQL Parsing via LLM-Based Segmentation
Junwen An, Kabilan Mahathevan, and Manuel Rigger
In Proceedings of the 45th ACM SIGMOD Symposium on Principles of Database Systems (PODS 2026), 2026
SQL is a widely adopted language for querying data, which has led to the development of various SQL analysis and rewriting tools. However, due to the diversity of SQL dialects, such tools often fail when encountering unrecognized dialect-specific syntax. While Large Language Models (LLMs) have shown promise in understanding SQL queries, their inherent limitations in handling hierarchical structures and hallucination risks limit their direct applicability in parsing. To address these limitations, we propose SQLFlex, a novel query rewriting framework that integrates grammar-based parsing with LLM-based segmentation to parse diverse SQL dialects robustly. Our core idea is to decompose hierarchical parsing to sequential segmentation tasks, which better aligns with the strength of LLMs and improves output reliability through validation checks. Specifically, SQLFlex uses clause-level segmentation and expression-level segmentation as two strategies that decompose elements on different levels of a query. We extensively evaluated SQLFlex on both real-world use cases as well as in a standalone evaluation. In SQL linting, SQLFlex outperforms SQLFluff in ANSI mode by 63.68% in F1 score while matching its dialect-specific mode performance. In test case reduction, SQLFlex outperforms SQLess by up to 10 times in simplification rate. In the standalone evaluation, it parses 91.55% to 100% of queries across eight distinct dialects, outperforming all baseline parsers. We believe SQLFlex can serve as a foundation for many query analysis and rewriting use cases.
Sparse Tensor Compilers (STCs) have emerged as critical infrastructure for optimizing high-dimensional data analytics and machine learning workloads. The STCs must synthesize complex, irregular control flow for various compressed storage formats directly from high-level declarative specifications, thereby making them highly susceptible to subtle correctness defects. Existing testing frameworks, which rely on mutating computation graphs restricted to a standard vocabulary of operators, fail to exercise the arbitrary loop synthesis capabilities of these compilers. Furthermore, generic grammar-based fuzzers struggle to generate valid inputs due to the strict rules governing how indices are reused across multiple tensors.
In this paper, we present TENSURE, the first extensible black-box fuzzing framework specifically designed for the testing of STCs. TENSURE leverages Einstein Summation (Einsum) notation as a general input abstraction, enabling the generation of complex, unconventional tensor contractions that expose corner cases in the code-generation phases of STCs. We propose a novel constraint-based generation algorithm that guarantees 100% semantic validity of synthesized kernels, significantly outperforming the 3.3% validity rate of baseline grammar fuzzers. To enable metamorphic testing without a trusted reference, we introduce a set of semantic-preserving mutation operators that exploit algebraic commutativity and heterogeneity in storage formats. Our evaluation on two state-of-the-art systems, TACO and Finch, reveals widespread fragility, particularly in TACO, where TENSURE exposed crashes or silent miscompilations in a majority of generated test cases. These findings underscore the critical need for specialized testing tools in the sparse compilation ecosystem.
In the contemporary technological landscape, the widespread adoption of cloud systems and distributed resources has highlighted the need to overcome inherent limitations in achieving complete system dependability. This presents both significant opportunities and challenges in automating bug detection, bug fixing, and verification efforts in complex distributed systems, such as cloud infrastructure management tools like Kubernetes and Twine. Despite the importance of these efforts, there is a notable lack of data that can be used to study and analyze the types of challenges faced in developing and supporting these systems, as well as in building test automation and bug detection tools. To address this gap, we conducted an in-depth investigation into one of the most popular ecosystems: Kubernetes. We manually analyzed reported bugs and curated a comprehensive dataset comprising 311 developer-confirmed bugs. This dataset includes detailed information on bug categories, severity, affected versions, and reproducible steps when available. Through our analysis, we identified an emerging bug type in these systems, referred to as reconciliation bugs. To assist developers and researchers in creating new testing strategies for these platforms, we developed a bug-reproducing script that can reproduce 52 reconciliation bugs out of the 311 total bugs in Kubernetes. This tool provides valuable insights into these issues, facilitating the development of more robust testing and maintenance strategies. The dataset is publicly available and can be accessed at: https:/Igithub.com/EmInReLab/BugsInKube
Talk Abstracts
2026
Vectorizing Sparse Coiteration for Two-finger Loop Structure (Extended Abstract)
Kabilan Mahathevan, and Kirshanthan Sundararajah
In ARRAY Workshop 2026, co-located with PLDI 2026, 2026
Sparse tensor compilers struggle to vectorize the data-dependent scf.while co-iteration loops inherent to compressed format intersections. Because standard heuristics assume masked gather operations will negate SIMD throughput gains without high data reuse, existing vectorization efforts largely avoid pure sparse-sparse co-iteration. We challenge this assumption by proposing a novel MLIR optimization pass featuring a dual-path execution model. By natively operating on compressed hierarchies, our pass prepends a predicated, vectorized fast lane governed by dynamic runtime bounds checking, retaining the original scalar loop as a slow lane epilogue. Contrary to the assumption that such techniques require high-arithmetic-intensity workloads (high-order tensor contractions) to be profitable, our empirical evaluation demonstrates massive speedups on foundational, low-intensity kernels (SpGEMM, SpMV, MTTKRP). This proves that modern SIMD throughput can effectively overcome indirect memory latencies, unlocking generalized vectorization for dynamic sparse computations.
TENSURE: Fuzzing Sparse Tensor Compilers (Registered Report)In Fuzzing Workshop (FUZZING) 2026, Network and Distributed System Security (NDSS). More Information can be found here , 2026