Emergent Compiler Behavior: Causal Discovery of Optimization Interactions

Several papers touch on mysterious optimization interactions - Theodoridis and Su's counterintuitive information effects, Gassmann et al.'s findings that standard optimizations don't work well for zkVMs, and the general phase ordering problem. We observe these strange behaviors but don't really understand why they happen. My idea is to treat the compiler as a complex system and use causal discovery algorithms to map out the hidden relationships between optimizations. We'd systematically vary optimization sequences across thousands of programs and use techniques like causal Bayesian networks to infer the direct and indirect effects of each optimization pass. For example, we might discover that "dead code elimination" doesn't directly affect performance, but it changes the program structure in ways that make "loop unrolling" less effective. These causal chains could explain many of the counterintuitive results we see. This goes beyond the correlation-based approaches in current performance modeling work (like Shahedi et al., 2024) to uncover the underlying mechanisms. It could lead to fundamentally new optimization strategies that work with these causal relationships rather than against them. Imagine a compiler that understands "if I apply pass A, I should avoid pass B later because they'll interfere" - that's a level of self-awareness current systems lack.

References:

1. Refined Input, Degraded Output: The Counterintuitive World of Compiler Behavior. Theodoros Theodoridis, Zhendong Su (2024). Proc. ACM Program. Lang..
2. Tracing Optimization for Performance Modeling and Regression Detection. Kaveh Shahedi, Heng Li, Maxime Lamothe, Foutse Khomh (2024). ACM Transactions on Software Engineering and Methodology.
3. Evaluating Compiler Optimization Impacts on zkVM Performance. Thomas Gassmann, Stefanos Chaliasos, Thodoris Sotiropoulos, Zhendong Su (2025). arXiv.org.