{"id":{"repo_id":"calpoly","oai_identifier":"oai:digitalcommons.calpoly.edu:theses-5039"},"canonical_url":"https://search.ndltd.org/etd/calpoly/oai:digitalcommons.calpoly.edu:theses-5039","repository":{"repo_id":"calpoly","name":"Cal Poly","base_url":"https://digitalcommons.calpoly.edu/do/oai/"},"display":{"title":"Preserving Structural Alias Information Across the MLIR-to-LLVM Lowering Boundary","abstract":"Machine learning training and inference workloads run at massive scale, where the efficiency of generated machine code directly affects throughput and energy consumption. The compilers that lower model specifications to hardware instructions rely on optimization passes that can only exploit information visible in the representations they operate on. MLIR, the intermediate representation framework underlying production machine learning compilers such as IREE and Triton, is designed so that each abstraction level can encode semantics that lower levels cannot represent. One example is memref.subview, which partitions a buffer into typed regions with explicit offsets and sizes, making structural non-overlap provable from the IR. Standard MLIR-to-LLVM lowering discards this structure, reducing subviews to pointer arithmetic that LLVM alias analysis cannot distinguish from potentially overlapping accesses. This loss blocks optimizations such as loop-invariant code motion, redundancy elimination, and vectorization, even when accesses are provably disjoint at the MLIR level. This thesis presents an out-of-tree MLIR pass pipeline that identifies provably disjoint buffer regions before lowering and preserves the structural proof as LLVM !alias.scope and !noalias metadata. Rather than introducing a new alias analysis, the approach communicates existing information in a form LLVM optimization passes already understand. Across six case-study kernels, the pipeline eliminates all 32 alias-related optimization misses. It achieves a 3.76x speedup on Apple M4 under -force-vector-width=4 by enabling NEON SIMD vectorization. On benchmark-derived kernels from PolyBench/C, IMEX, and IREE, speedups reach 1.51x across platforms and exceed 2x on out-of-order ARM cores, while neutral and regressing cases establish the practical limits of the approach.","abstract_html":"Machine learning training and inference workloads run at massive scale, where the efficiency of generated machine code directly affects throughput and energy consumption. The compilers that lower model specifications to hardware instructions rely on optimization passes that can only exploit information visible in the representations they operate on. MLIR, the intermediate representation framework underlying production machine learning compilers such as IREE and Triton, is designed so that each abstraction level can encode semantics that lower levels cannot represent. One example is memref.subview, which partitions a buffer into typed regions with explicit offsets and sizes, making structural non-overlap provable from the IR. Standard MLIR-to-LLVM lowering discards this structure, reducing subviews to pointer arithmetic that LLVM alias analysis cannot distinguish from potentially overlapping accesses. This loss blocks optimizations such as loop-invariant code motion, redundancy elimination, and vectorization, even when accesses are provably disjoint at the MLIR level. This thesis presents an out-of-tree MLIR pass pipeline that identifies provably disjoint buffer regions before lowering and preserves the structural proof as LLVM !alias.scope and !noalias metadata. Rather than introducing a new alias analysis, the approach communicates existing information in a form LLVM optimization passes already understand. Across six case-study kernels, the pipeline eliminates all 32 alias-related optimization misses. It achieves a 3.76x speedup on Apple M4 under -force-vector-width=4 by enabling NEON SIMD vectorization. On benchmark-derived kernels from PolyBench/C, IMEX, and IREE, speedups reach 1.51x across platforms and exceed 2x on out-of-order ARM cores, while neutral and regressing cases establish the practical limits of the approach.","abstract_has_math":false,"creators":["Sheth, Shravan"],"institution":null,"degree_name":"MS in Computer Science","degree_level":null,"degree_discipline":"Computer Science","degree_department":null,"school":null,"contributors":["Stephen Beard","Computer Science","College of Engineering"],"advisors":[],"committee_chairs":[],"committee_members":[],"year":null,"date_issued":"","date_published":null,"updated_at":"2026-11-19T07:12:58Z","subjects":["Compiler","LLVM","MLIR","optimization","alias metadata","Computer and Systems Architecture"],"languages":[],"rights":[],"rights_urls":[],"identifier_entries":[],"person_identifier_entries":[]},"links":{"outbound_url":"https://digitalcommons.calpoly.edu/theses/3356","outbound_label":"Repository record","outbound_source":"dc:identifier","record_url":"https://digitalcommons.calpoly.edu/theses/3356","record_label":"Repository record","record_kind":"record","record_source":"dc:identifier","download_url":null,"download_label":null,"download_source":null,"access_status":null,"embargo_until":null,"access_note":null},"source_record":{"url":"https://digitalcommons.calpoly.edu/do/oai/?verb=GetRecord&metadataPrefix=oai_etdms&identifier=oai%3Adigitalcommons.calpoly.edu%3Atheses-5039","prefix":"oai_etdms"},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:contributor","label":"Contributor","values":["Stephen Beard","Computer Science","College of Engineering"]},{"key":"dc:creator","label":"Author","values":["Sheth, Shravan"]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date.available","label":"Dc Date Available","values":["2026-06-12T07:00:00Z"]},{"key":"dc:date.created","label":"Dc Date Created","values":["2026-06-01T07:00:00Z"]},{"key":"thesis:degree_discipline","label":"Discipline","values":["Computer Science"]},{"key":"thesis:degree_name","label":"Degree Name","values":["MS in Computer Science"]}]},{"id":"subjects_keywords","label":"Subjects and Keywords","entries":[{"key":"dc:subject","label":"Dc Subject","values":["Compiler","LLVM","MLIR","optimization","alias metadata","Computer and Systems Architecture"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier","label":"Identifier","values":["https://digitalcommons.calpoly.edu/theses/3356"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"dc:description.abstract","label":"Abstract","values":["Machine learning training and inference workloads run at massive scale, where the efficiency of generated machine code directly affects throughput and energy consumption. The compilers that lower model specifications to hardware instructions rely on optimization passes that can only exploit information visible in the representations they operate on. MLIR, the intermediate representation framework underlying production machine learning compilers such as IREE and Triton, is designed so that each abstraction level can encode semantics that lower levels cannot represent. One example is memref.subview, which partitions a buffer into typed regions with explicit offsets and sizes, making structural non-overlap provable from the IR. Standard MLIR-to-LLVM lowering discards this structure, reducing subviews to pointer arithmetic that LLVM alias analysis cannot distinguish from potentially overlapping accesses. This loss blocks optimizations such as loop-invariant code motion, redundancy elimination, and vectorization, even when accesses are provably disjoint at the MLIR level. This thesis presents an out-of-tree MLIR pass pipeline that identifies provably disjoint buffer regions before lowering and preserves the structural proof as LLVM !alias.scope and !noalias metadata. Rather than introducing a new alias analysis, the approach communicates existing information in a form LLVM optimization passes already understand. Across six case-study kernels, the pipeline eliminates all 32 alias-related optimization misses. It achieves a 3.76x speedup on Apple M4 under -force-vector-width=4 by enabling NEON SIMD vectorization. On benchmark-derived kernels from PolyBench/C, IMEX, and IREE, speedups reach 1.51x across platforms and exceed 2x on out-of-order ARM cores, while neutral and regressing cases establish the practical limits of the approach."]},{"key":"dc:title","label":"Title","values":["Preserving Structural Alias Information Across the MLIR-to-LLVM Lowering Boundary"]}]}],"canonical_facts":{"dc:contributor":["Stephen Beard","Computer Science","College of Engineering"],"dc:creator":["Sheth, Shravan"],"dc:date.available":["2026-06-12T07:00:00Z"],"dc:date.created":["2026-06-01T07:00:00Z"],"dc:description.abstract":["Machine learning training and inference workloads run at massive scale, where the efficiency of generated machine code directly affects throughput and energy consumption. The compilers that lower model specifications to hardware instructions rely on optimization passes that can only exploit information visible in the representations they operate on. MLIR, the intermediate representation framework underlying production machine learning compilers such as IREE and Triton, is designed so that each abstraction level can encode semantics that lower levels cannot represent. One example is memref.subview, which partitions a buffer into typed regions with explicit offsets and sizes, making structural non-overlap provable from the IR. Standard MLIR-to-LLVM lowering discards this structure, reducing subviews to pointer arithmetic that LLVM alias analysis cannot distinguish from potentially overlapping accesses. This loss blocks optimizations such as loop-invariant code motion, redundancy elimination, and vectorization, even when accesses are provably disjoint at the MLIR level. This thesis presents an out-of-tree MLIR pass pipeline that identifies provably disjoint buffer regions before lowering and preserves the structural proof as LLVM !alias.scope and !noalias metadata. Rather than introducing a new alias analysis, the approach communicates existing information in a form LLVM optimization passes already understand. Across six case-study kernels, the pipeline eliminates all 32 alias-related optimization misses. It achieves a 3.76x speedup on Apple M4 under -force-vector-width=4 by enabling NEON SIMD vectorization. On benchmark-derived kernels from PolyBench/C, IMEX, and IREE, speedups reach 1.51x across platforms and exceed 2x on out-of-order ARM cores, while neutral and regressing cases establish the practical limits of the approach."],"dc:identifier":["https://digitalcommons.calpoly.edu/theses/3356"],"dc:subject":["Compiler","LLVM","MLIR","optimization","alias metadata","Computer and Systems Architecture"],"dc:title":["Preserving Structural Alias Information Across the MLIR-to-LLVM Lowering Boundary"],"thesis:degree_discipline":["Computer Science"],"thesis:degree_name":["MS in Computer Science"]},"updated_at":"2026-11-19T07:12:58Z"}