🤖 AI Summary
This work addresses the loss of dimensional semantics in traditional compilation, where type systems discard such information prior to code generation, leading to ad hoc numerical representations and memory management that struggle to balance efficiency, determinism, and verifiability. To overcome this, the paper introduces a Dimensional Type System (DTS) that propagates dimensional annotations as compile-time metadata throughout MLIR’s multi-stage lowering pipeline. DTS enables joint optimization of representation selection and deterministic memory management within a unified semantic graph. Grounded in finitely generated Abelian group constraints, the system supports polynomial-time decidable, complete, and principal type inference. A coeffect system unifies escape analysis and memory allocation, while also revealing the closure of dimensional algebra under automatic differentiation. Experiments demonstrate that DTS enables design-time verifiable memory strategies, representation fidelity, cache locality estimation, and coeffect-based AD verification, significantly enhancing compilation reliability and performance in resource-constrained settings.
📝 Abstract
We present a compilation framework in which dimensional type annotations persist through multi-stage MLIR lowering, enabling the compiler to jointly resolve numeric representation selection and deterministic memory management as coeffect properties of a single program semantic graph (PSG). Dimensional inference determines value ranges; value ranges determine representation selection; representation selection determines word width and memory footprint; and memory footprint, combined with escape classification, determines allocation strategy and cross-target transfer fidelity. The Dimensional Type System (DTS) extends Hindley-Milner unification with constraints drawn from finitely generated abelian groups, yielding inference that is decidable in polynomial time, complete, and principal. Where conventional systems erase dimensional annotations before code generation, DTS carries them as compilation metadata through each lowering stage, making them available where representation and memory placement decisions occur. Deterministic Memory Management (DMM), formalized as a coeffect discipline within the same graph, unifies escape analysis and memory placement with the dimensional framework. Escape analysis classifies value lifetimes into four categories (stack-scoped, closure-captured, return-escaping, byref-escaping), each mapping to a verified allocation strategy. We identify implications for auto-differentiation: the dimensional algebra is closed under the chain rule, and forward-mode gradient computation exhibits a coeffect signature that the framework can verify. The practical consequence is a development environment where escape diagnostics, allocation strategy, representation fidelity, and cache locality estimation are design-time views over the compilation graph.