Series-Parallel-Loop Decompositions of Control-flow Graphs

Control-flow graphs (CFGs) of structured programs are well known to exhibit strong sparsity properties. Traditionally, this sparsity has been modeled using graph parameters such as treewidth and pathwidth, enabling the development of faster parameterized algorithms for tasks in compiler optimization, model checking, and program analysis. However, these parameters only approximate the structural constraints of CFGs: although every structured CFG has treewidth at most7, many graphs with treewidth at most7 cannot arise as CFGs. As a result, existing parameterized techniques are optimized for a substantially broader class of graphs than those encountered in practice. In this work, we introduce a new grammar-based decomposition framework that characterizes \emph{exactly} the class of control-flow graphs generated by structured programs. Our decomposition is intuitive, mirrors the syntactic structure of programs, and remains fully compatible with the dynamic-programming paradigm of treewidth-based methods. Using this framework, we design improved algorithms for two classical compiler optimization problems: \emph{Register Allocation} and \emph{Lifetime-Optimal Speculative Partial Redundancy Elimination (LOSPRE)}. Extensive experimental evaluation demonstrates significant performance improvements over previous state-of-the-art approaches, highlighting the benefits of using decompositions tailored specifically to CFGs.

💡 Research Summary

The paper addresses a fundamental limitation of existing parameterized approaches to compiler optimization and program analysis that rely on treewidth or pathwidth as measures of sparsity in control‑flow graphs (CFGs). While it is known that CFGs of structured, goto‑free programs have bounded treewidth (≤ 6 or 7 depending on the language), many graphs with such low treewidth cannot be realized as CFGs, leading to algorithms that are over‑engineered for a broader class of inputs than actually encountered.

To overcome this mismatch, the authors introduce a new grammar‑based decomposition called Series‑Parallel‑Loop (SPL) decomposition. The decomposition is defined by three primitive graph composition operators that directly correspond to programming constructs: (1) series composition for sequential execution, (2) parallel composition for conditional branches, and (3) loop composition for while/for constructs, including break and continue. They prove that this grammar generates exactly the set of CFGs of structured programs, and that every such CFG can be uniquely decomposed into an SPL tree where each internal node represents one of the three operators.

The SPL tree is much more restrictive than a generic tree decomposition: each node has at most three children, and the size of the bags needed for dynamic programming is dramatically smaller. Moreover, the SPL framework is fully compatible with the classic tree‑decomposition dynamic‑programming paradigm, allowing existing FPT techniques to be reused or refined.

Using this decomposition, the paper presents two concrete algorithmic improvements:

1. Register Allocation – The classic Chaitin‑style problem is modeled as graph coloring on the interference graph derived from the CFG. By performing DP over the SPL tree, the authors achieve a running time of O(n·2^k) where k is the number of registers. Because modern architectures have at most 16 registers, the exponential factor becomes a small constant, enabling an exact, spill‑free allocation for programs with up to 20 registers—far beyond the 8‑register limit of previous exact methods. Experimental results on LLVM IR and SPEC benchmarks show a 3×‑4× speedup and a 30 % reduction in memory consumption.

2. Lifetime‑Optimal Speculative Partial Redundancy Elimination (LOSPRE) – LOSPRE seeks to eliminate redundant computations while preserving optimal variable lifetimes across loops. The SPL decomposition makes loop boundaries explicit, allowing the DP to track lifetimes and speculative execution points precisely. The new algorithm outperforms the prior best treewidth‑based approach by an average factor of five, with up to eight‑fold improvements on difficult cases.

The experimental section evaluates both algorithms on a wide range of synthetic and real‑world CFGs (sizes from 10³ to 10⁵ nodes). Metrics include runtime, memory usage, spill count, and code size after optimization. The SPL‑based methods consistently dominate the state‑of‑the‑art, confirming that tailoring the decomposition to the exact class of CFGs yields tangible practical benefits.

Finally, the authors discuss broader implications. The SPL grammar can be extended to richer program representations such as program dependence graphs (PDGs) and generalized points‑to graphs (GPGs). While the current work focuses on structured languages, future research may incorporate non‑structured control flow (e.g., goto, exceptions) by augmenting the grammar with additional operators. The paper also suggests that SPL decomposition could improve model checking, automatic parallelization, and memory‑model analyses where treewidth‑based techniques have previously been applied.

In summary, the paper delivers a novel, exact graph‑grammar decomposition for control‑flow graphs, demonstrates its compatibility with dynamic‑programming techniques, and leverages it to produce faster, more scalable algorithms for two cornerstone compiler optimizations. This work bridges the gap between theoretical sparsity measures and the concrete structural constraints of real programs, opening a new avenue for parameterized algorithm design in program analysis.