PDL photos from Retreat - March 2026
Emerging applications such as quantum computing and large language model (LLM) serving depend on compilers and runtime systems to execute efficiently, yet the inputs to their optimization decisions are rarely uniform. Quantum devices support different gate sets and exhibit unequal communication costs, concurrent LLM requests carry different latency service-level objectives (SLOs), and model operators differ in their resource demands and in how well they match available GPUs.
This thesis argues that representing such heterogeneity explicitly in optimization decisions enables substantially more efficient execution, provided that the resulting search and coordination costs are kept tractable. Three completed projects support this claim. Quarl uses reinforcement learning to optimize quantum circuits across gate sets, reducing CNOT count by 21.3% on average on the IBM gate set, compared with 7.7% for the best existing optimizers. QBX compiles 2-local Hamiltonian simulation for quantum chiplets by exploiting Hamiltonian structure and nonuniform chiplet communication, reducing circuit depth on average by 2.57× over Qiskit and 10.35× over tket.
AdaServe customizes speculative decoding to individual request latency objectives, reducing SLO violations by up to 4.3× and improving goodput by up to 1.9×. The proposed work will jointly choose operator boundaries and deployment configurations for LLM serving on heterogeneous GPUs, and will characterize when operator disaggregation reduces serving cost and when its overheads outweigh the benefits.
LLMs have become a major GPU workload, and a moving one: serving strategies, batch shapes and expert routing, operators, and GPU architectures all keep changing. Today's stacks turn each change into a re-engineering effort because their interfaces are too rigid to program against. This thesis argues that adaptation should become programming, with an abstraction designed for whoever programs it. LLM microserving gives developers composable sub-request APIs for orchestrating serving; Event Tensor gives the compiler a dependency IR for scheduling dynamic megakernels; and TIRx Harness gives AI agents not a higher-level language but a deliberately minimal, hardware-close IR with verifiable feedback, on which they write kernels competitive with, and often faster than, expert references. As proposed work, I will extend this design to a new GPU architecture, such as NVIDIA Rubin, where the analyses must model new hardware primitives and agents must learn to exploit new hardware features.
Accelerators and I/O devices perform much of today's computation. Accelerators are now commonplace, and even long-established I/O devices such as network cards (NICs) and disks have gained their own compute. Yet devices today communicate using specialized interfaces better suited to an era when each device performed a single, fixed function under the CPU's control. Specialized interfaces limit devices in two ways. First, interfaces are specialized to a particular data format, unable to adapt to new capabilities as devices gain them. Second, interfaces are specialized to a particular pair of endpoints: the device and the CPU. As a result, devices that would benefit from interacting directly must rely on vendor-specific solutions.
A general-purpose interface could address both limits. What stands in the way is the long-held assumption that generality costs performance. This dissertation disproves that assumption, showing that devices can adopt a general-purpose interface without compromising performance—in fact, generality can even improve performance by reducing the CPU's involvement in communication. We pursue generality along two axes: "what" devices communicate and with "whom."
To generalize "what" devices communicate, we introduce Ensō, a streaming abstraction between devices and the CPU. Instead of specializing to the data's format and size, Ensō delivers arbitrary data over a stream. This allows devices to extend their capabilities without shoehorning data into legacy formats. Streaming makes the interface format-agnostic and eliminates the overheads of fixed-size buffers, letting applications achieve up to 6× the throughput of a specialized NIC.
To generalize with "whom" devices can communicate, we introduce DCP, a general-purpose peer-to-peer Device Communication Protocol. Although interconnects such as PCIe support peer-to-peer communication, device interfaces are asymmetric, designed for talking to the CPU. DCP instead provides a symmetric interface that works the same way regardless of devices' capabilities, without relying on the CPU for coordination. As a result, DCP cuts latency by 83% compared to CPU-mediated communication.
Together, Ensō and DCP show that devices need not remain workers behind restricted interfaces, but can instead act as peers—enabling a future in which a computer looks less like a hub-and-spoke and more like a distributed system of composable accelerators.
Current techniques for rate control in computer networks are not aligned with the policies and considerations of both endpoints in a connection. Historically, fine-grained rate control has been the sender's responsibility through the Transmission Control Protocol (TCP) and its congestion control algorithm (CCA). However, the receiver, either due to conflicting priorities or greater visibility into congestion, would often be better served by a different rate allocation than the sender. A simple example is a many-flow incast in a data-center network: each sender independently seeks to transmit as quickly as possible, while the receiver can observe that each flow should converge to a small fraction of the last-hop link rate. Likewise, on the Internet, each service provider balances between its customers, whereas a user may desire fairness across services.
To bridge the gap between endpoint objectives, we argue for a dual-endpoint approach to congestion control that incorporates the receiver into the rate decision by providing lightweight hints to senders about the rate regime in which they should operate. We use these techniques to build expressive receiver-assisted policies based on application traffic patterns, observed network congestion, and receiver resource constraints. Dual-endpoint congestion control differs from fully receiver-based techniques because the sender, with its own inherent observations and objectives, maintains control over the packet stream. To implement receiver assistance, we revisit the well-known technique of TCP flow control and show it to be a powerful primitive that does not require modifications to TCP, the sender's CCA, or applications.
This dissertation explores two environments with differing endpoint objectives to show that dual-endpoint congestion control gives both endpoints a stake in bandwidth allocation decisions. First, we consider datacenter incast bursts, where the receiver's observability into the traffic pattern enables dual-endpoint control to schedule hundreds or thousands flows into a healthy regime that both improves network utilization and reduces receiver packet processing overheads. Second, we turn to the Internet at large and show the expressivity of dual-endpoint control by resolving common challenges that arise due to conflicting receiver policies regarding rate control granularity, algorithm, and optimization metric.
Modern datacenter computing faces a critical memory bottleneck driven by memory-intensive applications, terabyte-scale memory capacities, and slowing DRAM technology improvements. The memory bottleneck manifests in multiple dimensions including access performance, hardware costs, and power consumption.
First, the virtual memory abstraction is under increasing strain, where stagnant Translation Lookaside Buffer sizes relative to growing memory capacity cause severe and escalating virtual address translation overheads. Second, the hardware costs and power consumption of memory hardware have skyrocketed as DRAM now accounts for nearly 25% of rack power consumption and 50% of a server’s Total Cost of Ownership. This thesis addresses these challenges through the co-design of OS and architectures.
To reduce the overhead of virtual memory, my research targets the virtual address translation overhead with two works. Contiguitas groups unmovable allocations in the OS and introduces hardware extensions to migrate device I/O pages. By creating abundant physical memory contiguity, it allocates more huge pages, yielding up to an 18% performance improvement for Meta’s production workloads. Learned Virtual Memory replaces rigid radix page tables with learned page tables tailored to application virtual address spaces. LVM balances the size, depth, and accuracy of learned index, reducing page walk overheads by an average of 44% and achieving a 2-27% execution speedup. To reduce memory cost and power, my research enables the practical deployment of tiered CXL memory in datacenters with two works. Pensieve is a three-tier memory system (DRAM, CXL, and SSD) that transparently manages data placement via a single-input single-output control loop. It leverages CXL memory as an intermediate tier to safely offload 33% of memory while keeping performance degradation under 5%. Equilibria addresses multi-tenant challenges by ensuring fair sharing of tiered memory and mitigating noisy-neighbor effects. It provides automatic fair-share determination and thrashing mitigation, boosting performance over the state-of-the-art Linux solution by up to 52% for Meta’s workloads and 1.7x for DCPerf, a representative benchmark for datacenter workloads.
Together, these works significantly optimize datacenter memory efficiency through a comprehensive set of architectural and operating system techniques and lay the foundation for sustainable memory scaling for years to come.
Large language models have become central infrastructure for modern AI applications, but running them efficiently remains a major systems challenge. Larger and more capable models require more GPU computation, GPUs remain expensive, and sophisticated applications such as agents require low latency and predictable service-level objectives to be practically usable. At the same time, inference optimization increasingly depends on deep specialized expertise in scheduling, memory management, and GPU kernel engineering. This expertise is difficult to scale because model architectures and accelerator platforms evolve rapidly, introducing new operators, precision formats, parallelization patterns, and hardware-specific optimization requirements.
This thesis develops systems that use model-driven and agentic techniques to automate parts of this optimization process. SpecInfer uses smaller language models to speculate on the outputs of larger models, converting otherwise serial autoregressive decoding into parallel verification. SuffixDecoding extends this idea to agentic workloads by caching and reusing prior generation patterns to speculate with minimal GPU overhead. FlexLLM automates fine-grained resource allocation between latency-critical inference and throughput-oriented finetuning, allowing both services to share GPUs while preserving inference service-level objectives. The remaining work moves from optimizing inference systems with AI techniques to using AI agents to optimize the systems themselves. FastKernels provides a production-faithful benchmark for LLM-based GPU kernel agents, and the proposed kernel agent will use compiler feedback, correctness tests, runtime measurements, and hardware feedback to generate optimized kernels for rapidly evolving operators such as linear attention, state-space models, mixture-of-experts routing, quantized inference, and multimodal fusion.
Exascale storage systems are under increasing pressure to store more data while providing greater performance per byte. Historically, hyperscale storage systems have relied on a two-tiered hierarchy: hard-disk drives store most bytes, while smaller flash tiers absorb requests for hot and performance-critical data. This design is becoming increasingly difficult to sustain. Datacenter data is getting warmer with the proliferation of AI/ML and analytics-heavy workloads, while storage devices are becoming denser without proportional improvements in per-byte performance or endurance. As a result, enabling denser storage devices at exascale requires improving both the software storage system and the hardware provisioning strategies for modern datacenter workloads.
This thesis shows that exascale storage systems can enable denser storage options by jointly reducing internal IO and improving data placement/hardware provisioning decisions. The first part of this thesis, Morph, reduces IO associated with lifetime redundancy transitions. Morph introduces a novel hybrid redundancy scheme for early-life data and a system designed around a new erasure-code for late-life, reducing ingest and transcode overheads. The second part of this thesis develops a total-cost-of-ownership (TCO) model and optimizer for exascale storage provisioning. This model determines the minimum-cost set of hardware necessary to serve datacenter workloads and shows how heterogeneous configurations can cost-effectively enable dense devices in modern datacenters.
We propose work that connects these two directions by modeling storage workloads from the bottom up, using fine-grained lifetime and temperature transition behavior to reason about provisioning and placement decisions. By understanding how data cools and survives throughout its lifetime, this work aims to produce a more precise framework that co-optimizes the heterogeneous storage mixture and the placement of data across the storage tiers. Together, these contributions show how storage systems can cost-effectively service contemporary storage workloads with denser media and enable the massive growth in data demand.
Optimizing and simulating quantum circuits at scale are critical bottlenecks in quantum computing. This thesis delivers a suite of tools to improve them.
For quantum circuit optimization, we first automate the discovery and verification of transformation rules by introducing Equivalence Circuit Class (ECC) sets and an efficient generation algorithm for arbitrary gate sets. We then utilize the generated rules in the superoptimizer Quartz, which optimizes circuits using a cost-based backtracking search. Compared to previous rule-based methods, Quartz successfully escapes local minima through exhaustive search. To further improve efficiency and avoid the exponential runtime penalties of pure search, we introduce QALM. This hybrid optimizer combines exhaustive search with rule-based rewriting. By interleaving bounded search-based exploration with greedy rule-based exploitation, QALM escapes local minima dynamically. It outperforms existing search-based optimizers in optimization quality and matches reinforcement learning methods without the training overhead.
While the prior two approaches aim for global optimization, this problem is intrinsically QMA-hard, creating a bottleneck for large programs. To circumvent this issue and scale up, we introduce OAC, a cut-and-meld circuit optimization algorithm. OAC cuts a circuit into subcircuits, applies an existing oracle optimizer independently, and seamlessly melds the results. This approach operates with a linear number of oracle calls while attaining local optimality. Empirical evaluation shows that OAC improves the efficiency of state-of-the-art optimizers by over an order of magnitude while enhancing overall quality.
Beyond physical execution, the scalable simulation of quantum circuits on classical hardware presents another major challenge. We present Atlas, a distributed GPU-based simulator that hierarchically partitions circuits to exploit data parallelism while minimizing communication. By using integer linear programming to allocate structurally related gates to nearby GPUs and dynamic programming for kernel scheduling, Atlas runs over 2x faster than prior state-of-the-art GPU simulators.
Together, these frameworks provide a robust toolchain, improving both the execution of quantum circuits on physical devices and their scalable classical simulation.
The bulk-synchronous parallel (BSP) paradigm—powering large-scale scientific simulations and distributed ML training—poses unique efficiency challenges. These workloads impose periodic global synchronization across 10,000s of ranks, which compounds small inefficiencies into cluster-wide bottlenecks. Many arise from conditions unknowable before runtime, such as load imbalance and performance pathologies, and can only be addressed through adaptation. Efficiency in production therefore hinges on adaptation latency: how quickly conditions can be observed, characterized, and responded to. This thesis argues that general-purpose infrastructure for adaptive feedback loops is the missing piece in today's BSP systems.
We develop this claim through two studies that instantiate the same primitive—a feedback loop over application state—with starkly different outcomes. On the data path, CARP implements an online loop for range-query-optimized data ingestion: it periodically materializes a view of global key distributions via in-situ reduction and uses it to recompute load-balanced range partitions as distributions evolve, matching the query performance of a full sort with up to 4.9× faster ingestion. On the compute path, we study placement in adaptive mesh refinement codes, where apparent load imbalance is confounded by faulty hardware, execution variability, and tuning artifacts. Here the loop comprised multiple time-consuming cycles of bulk trace collection, offline analyses, reconfiguration, and re-execution. Isolating true placement effects consumed months even though individual mitigations typically took days. With reliable telemetry established, we design CPLX, a tunable placement policy that achieves up to 21.6% runtime improvement. CARP demonstrates that online feedback loops are effective when they exist. The AMR study demonstrates the cost when they do not.
Because these effects are intrinsically unpredictable, production BSP systems need an always-on, programmable loop for observing and responding to runtime behavior. Coarse views surface deviations, and the loop enables both steering into narrower views for localization and triggering online interventions where viable. We call this paradigm steerable observability. ORCA realizes this via a BSP-aware tree-based overlay that materializes runtime views through in-situ reduction and provides a timestep-consistent control plane for coordinated interventions. On a real AMR code at 4,096 ranks, ORCA collects detailed traces at 1–2% overhead versus conventional HPC tracers at 56–81% and eliminates 98.5–99.999% of telemetry at source for evaluated queries. In an evaluation of its closed-loop capabilities using an LLM agent, a performance anomaly that took months to diagnose manually is localized in 27 minutes.
Modern database management systems (DBMSs) have evolved to support increasingly sophisticated data-intensive applications, at the cost of substantial complexity to configure them for two reasons. First, DBMSs expose a vast configuration space with trillions of possibilities that encompass system knobs, physical design (e.g., indexes), and query options, amongst others. Second, these applications are constantly evolving with changes in data access patterns, query types, load intensities, hardware, and data distributions that necessitate continuous re-optimization.
To address these challenges, decades of autonomous DBMS optimization research have produced specialized tuning tools to assist human operators. Deploying these tools involves a complex multi-step workflow where an operator (1) observes the DBMS’s behavior, (2) selects tools based on the objectives and their expertise, (3) configures them with an isolated environment, (4) orchestrates their execution to obtain recommendations, and (5) reviews those recommendations before deployment. This cumbersome process results in suboptimal configurations and slow adaptation to evolving applications’ workloads due to isolated specialized tools, inefficient reuse of prior tuning knowledge, and the fallible human factor.
In this dissertation, we present techniques for addressing those limitations with similarity to enable holistic database optimization. First, we present a holistic tuning tool that optimizes multiple DBMS aspects simultaneously by using action similarity to organize actions into neighborhoods conducive to exploration. We then present a framework that assists tuners in adapting to environment changes by leveraging workload and configuration similarity to re-mix historical knowledge. Lastly, we present a system that transforms the human-centric tuning workflow into an agentic process by using scenario similarity to link the deployment context with semantic tool interfaces to optimize the deployment.
The techniques and associated similarity definitions presented in this dissertation enable agentic holistic DBMS optimization over a deployment’s lifetime, improving the deployment’s performance and reducing time taken to adapt to changes in upstream user applications.
After decades of research, analytical database management systems (DBMSs) have become remarkably effective at optimizing and executing SQL queries. However, many users write queries that are not written entirely in SQL. Instead, these queries invoke user-defined functions (UDFs), external functions written in non-SQL programming languages such as Python or PL/SQL. UDFs provide software engineering benefits by enabling code reuse and by extending the DBMS’s capabilities to include those of the UDF language. However, UDFs are inherently non-relational, which makes them challenging for DBMSs to reason about and execute efficiently. Effective optimization is also challenging because UDF languages are Turing-complete, allowing UDFs to be arbitrarily complex. Although general-purpose optimization techniques can improve UDF performance (e.g., compilation and batching), they target arbitrary UDF code and therefore have limited effectiveness. We observe that the most beneficial UDF optimizations (e.g., memorization and inlining) leverage key optimization-enabling properties of UDFs (i.e., how users actually use them in practice).
In this proposal, we present multiple techniques that leverage optimization-enabling properties of UDFs to improve database query execution performance. First, we observe that inlining only the relevant pieces of a UDF improves performance, and leverage UDF decomposability to break UDFs into pieces and hide irrelevant pieces through outlining. Next, we observe that processing all unique UDF inputs simultaneously improves parallelism, and leverage UDF redundancy to build lightweight indexes during query processing to avoid repeated UDF invocations.
We propose extending our preliminary work by observing that enabling inter-tuple parallelism of UDFs improves query execution performance. We plan to leverage UDF pipelining, the observation that UDFs operate as a pipeline of data transformations over their inputs, to enable fusion and auto-vectorization of pipeline stages. Collectively, the techniques presented in this dissertation will enable an analytical database system to execute queries that contain UDF calls efficiently.
Recent advancements in large language models have shown promising results in diverse downstream tasks by training and test time scaling. However, the fast-paced development of large models has posed significant challenges to their energy cost and efficient deployment.
To achieve this, my thesis topic is centered around bridging the gap between the algorithm-system co-design space for better large model deployment. More specifically, through:
For algorithmic improvements, I will present two lines of research projects on Speculative Decoding (SpecInfer, RaLMSpec) and Sparse Attention (TidalDecode, LessisMore).
For system optimizations, I will present one project on LLM deployment with MegaKernel (MPK) and one ongoing project that is focusing on generalizing the megakernel runtime to support multi-LLM deployment.
Benefiting from the algorithm-system co-optimizations, the proposed thesis topic is expected to provide an effective solution for reducing the energy cost and improving the efficiency of LLM deployment in the real world.
The proliferation of memory-intensive applications, the rapid expansion of memory capacity to terabyte scales, and the slowing of DRAM cost scaling have established memory as the critical bottleneck in modern datacenter computing. This inefficiency manifests in two dimensions: the cycle efficiency lost to the virtual memory abstraction and the escalating financial cost of memory.
First, the virtual memory abstraction is under increasing strain. As memory capacity grows while Translation Lookaside Buffer sizes remain stagnant, address translation overhead becomes severe; internal profiling at hyperscalers reveals that approximately 20% of CPU cycles are stalled on TLB misses. This overhead is bound to worsen due to inherent TLB scaling limits, the introduction of additional page table levels, vast heterogeneous memory capacity, and the page-level security checks required by confidential computing. Second, the financial cost of memory has skyrocketed. Memory now accounts for nearly a quarter of rack power consumption and half of the Total Cost of Ownership of a typical datacenter server. In this proposal, I address these challenges through a set of operating system and architectural designs.
To improve cycle efficiency, I present two completed works. Contiguitas creates abundant physical memory contiguity by grouping unmovable allocations in the OS and introducing hardware extensions to migrate pages previously locked for device I/O. This contiguity is leveraged to allocate huge pages, reducing translation overhead and yielding up to 18% performance improvement for production workloads. Learned Virtual Memory (LVM) replaces rigid radix page tables with learned indexes tailored to the application's virtual address space. By leveraging address space regularity, LVM reduces page walk overhead by an average of 44% and achieves a 2–27% speedup in execution.
To improve cost efficiency, I present two ongoing works. Multi-Tier dynamically manages pages across DRAM, CXL memory, and SSDs to maximize financial savings by utilizing cheaper tiers within a defined performance loss limit. Equilibria addresses the challenges of multi-tenant tiering, ensuring fair memory sharing and mitigating noisy-neighbor interference through flexible placement policies and thrashing mitigation.
Together, these works provide a comprehensive solution to improving memory efficiency in datacenters from the perspectives of both cycle overhead and financial cost.
Query optimizers are critical components in database management systems (DBMSs) that turn a query that might otherwise take hours to run into one that completes in seconds. However, modern data stacks allow applications to generate data files (e.g., Parquet) outside the DBMS’s purview that lack statistical summaries. Without information about data distribution, optimizers fall back to ungrounded guesses when computing cardinality and cost estimates needed to select the best plan from an exponential number of candidates. This thesis investigates the design of an adaptive query optimization strategy that leverages query feedback to improve planning for future queries. We first study how an optimizer should memorize query plans during optimization so that it can associate past traces with future queries. To facilitate this investigation, we built a Cascades-style transformational search engine with a memo table that organizes equivalent sub-plans and detects duplicates. We measured the amount of reuse when maintaining the optimization state across queries. Our results showed that future queries can reuse the cached optimization information from previous queries when they exhibit similar subplan patterns. We then analyze runtime feedback collection methods, focusing on integration strategies and the resulting artifacts. Our study reveals a tension between the query coverage provided by runtime artifacts and the collection overhead they entail. Although most DBMSs can provide runtime row-count profiles at the operator level, the optimizer can only use this information for future queries that match the exact predicates. To address this limitation, we present a method that measures the true selectivity of each prefix in the conjunctive predicate during execution, which the optimizer can then leverage to improve planning for a broader range of queries. We implemented this method in PostgreSQL and measured the runtime performance overhead. Our experiments show that fine-grained instrumentation incurs a constant overhead regardless of the number of conjuncts. We conclude the thesis by discussing the design choices and trade-offs of integrating an extensible query optimizer service with existing DBMSs.
Database management systems (DBMSs) are the foundation of modern data-intensive applications. But as more features are developed to support new workloads, they become increasingly complex and difficult to configure. Thus, researchers have invested decades of effort into autonomous DBMS configuration. Recent advances in machine learning (ML) have produced tools that outperform unassisted experts in real-world deployments. However, these tools are advisory and require human expertise for deployment into database tuning pipelines.
Using these tools involves a multi-step process where a human operator (1) determines an optimization objective, (2) selects a suitable tool, (3) sets up the DBMS, (4) runs a workload to collect telemetry, (5) uses the telemetry to calibrate the tool, and (6) operates the tool to obtain recommendations, which the operator must then review and apply. These ad-hoc pipelines require significant human effort to set up, extend, and deploy. Moreover, interface differences make tools difficult to compose and interchange. Thus, despite the demonstrated ability of database tuning tools to improve performance and lower costs, the expertise required to operate them limits their adoption.
This dissertation presents the database gym, an integrated framework that systematizes and automates the DBMS configuration pipeline. Unlike prior research that focused on improving tool effectiveness with ML, the gym targets deployment and operational challenges by providing reusable, interoperable, and interchangeable components that simplify tool development and integration.
The gym’s design reflects the observation that the bottleneck in database tuning has shifted from developing better algorithms for tools to acquiring the training data needed to operate them. We demonstrate how the gym's architecture accelerates and adapts tool-based database tuning pipelines through the systematic generation and utilization of training data, enabling the augmentation and orchestration of tools with end-to-end knowledge. For example, it reduces step-level overhead by skipping redundant computation during telemetry generation, thus reducing the tuning pipeline's latency. It also eliminates pipeline-level repetition by reusing training data to adapt a tool's calibrated models across new software versions and hardware environments. Such optimizations are enabled by the gym’s holistic control over the entire tuning process.