Compiler, Compilation and Optimization
Phase Ordering with ML
Modern compilers include many optimization passes, also known as transforms, accumulated over decades.
Since these transforms are often lossy and irreversible, the order in which they are applied significantly affects performance.
This research uses machine learning models, including LLMs, to determine specialized optimization pass orders, or pipelines, to improve runtime performance.
Although ML-assisted phase ordering can outperform predefined compiler pipelines such as -O3, it is often time-consuming and requires heavy computing infrastructure.
Therefore, this research focuses not only on finding effective optimization pipelines, but also on developing efficient ways to discover them.
Ongoing research investigates methods that combine meta-heuristics with LLMs for compiler phase ordering.
Optimizing Ahead-of-time and Just-in-time Compiler Structure
As dominant workloads and computing environments have changed over time, compilers have evolved accordingly.
New compiler workflows and designs have been proposed to adapt to these continuous changes.
In this context, both the overall design of compilation steps and specialized optimization passes are important for modern workloads.
Current research in this field includes reducing runtime compilation latency in Just-in-Time, or JIT, compilers. Users of JIT compilers must wait for both runtime compilation time and execution time.
Therefore, exposing a range of trade-offs between runtime compilation latency and execution time enables more flexible program execution.
This research adds a configurable knob to the JIT compiler by incorporating cost-effective optimizations using precompiled program bits.
DSL Specialized Problem Solving
Domain-specific languages, or DSLs, are small languages designed for specialized purposes. Therefore, problems in DSL domains should be handled carefully by considering the specific environment of each DSL.
Ongoing research in this area focuses on equivalence comparison between two different DRAM test pattern programs.
Comparing two test pattern programs without executing them is difficult to scale due to complex loop structures and symbolic state updates. This study addresses the scalability problem by:
- Transpiling the given programs into a graph-based, loop-aware intermediate representation, or IR
- Extracting the core behavior in Scalar Evolution, or SCEV, form
- Representing the core program behaviors in the language of polyhedral analysis
- Comparing the behaviors using their hash values
Translation of domain-specific programs (ALPG and PLS ladder)
