Siyuan Brant Qian

Probabilistic programming frameworks automate Bayesian inference, but their performance is limited by a structural mismatch: the code a scientist writes to naturally express a model is often not the code an efficient sampler should execute. In practice, inference is often dominated by expensive computations entirely determined by fixed data and model structure, not by the sampled parameters. Because this structure is not explicit to a general-purpose compiler, the inference computation appears parameter-dependent and is therefore redundantly repeated across iterations. To eliminate this redundancy, we present Impulse, a probabilistic programming system built on MLIR that preserves probabilistic semantics as first-class compiler primitives. We introduce Sample-Invariant Code Motion (SICM), a compiler pass that performs dataflow analysis to understand operation dependencies on sampled parameters, applies algebraic rewrites to factor out invariant computation, and hoists the invariant computation out of the inference process. On standard benchmarks, Impulse achieves a geomean speedup of 1.7x over NumPyro, 6.4x over Stan, and 53x over Turing. SICM enables speedups from 8.5x to 190x on models with sample-invariant structure.

Floating-point numbers are finite-precision approximations to real numbers and are ubiquitous in computer applications in nearly every field. Selecting the right floating-point representation that balances performance and numerical accuracy is a difficult task – one that has become even more critical as hardware trends toward high-performance, low-precision operations. Although the common wisdom around changing floating-point precision implies that accuracy and performance are inversely correlated, more advanced techniques can often circumvent this tradeoff. Applying complex numerical optimizations to real-world code, however, is an arduous engineering task that requires expertise in numerical analysis and performance engineering, and application-specific numerical context. While there is a plethora of existing tools that partially automate this process, they are limited in the scope of optimization techniques or still require substantial human intervention. We present Poseidon, a modular and extensible framework that fully automates floating-point optimizations for real-world applications within a production compiler. Our key insight is that a small surrogate profile often reveals sufficient numerical context to drive effective rewrites. Poseidon operates as a two-phase compiler: the first compilation instruments the program to capture numerical context; the second compilation consumes profiled data, generates and evaluates candidate rewrites, and solves for optimal performance/accuracy tradeoffs. Poseidon’s interoperability with standard compiler analyses and optimizations grants it analysis and optimization advantages unavailable to existing source- and binary-level approaches. On multiple large-scale applications, Poseidon leads to outsized benefits in performance without substantially changing accuracy, and outsized accuracy benefits without diminishing performance. On a quaternion differentiator, Poseidon enables a 1.46x speedup with a relative error of 10e-7. On DOE’s LULESH hydrodynamics application, Poseidon improves program accuracy to exactly match a 512-bit simulation run without substantially reducing performance.