Lifetime-optimal Speculative PRE

• LOSPRE is a compiler optimization that eliminates partial redundancies by speculatively inserting computations while minimizing both insertion and lifetime costs.
• It leverages series-parallel-loop decompositions and dynamic programming to achieve linear-time optimality on structured control-flow graphs.
• The method outperforms traditional techniques by reducing runtime overhead and providing a unified framework for redundancy elimination in modern compilers.

Lifetime-optimal Speculative Partial Redundancy Elimination (LOSPRE) is a compiler optimization that locates and eliminates partially redundant computations with full speculation, while simultaneously minimizing both the number (or aggregated cost) of inserted computations and the total aggregate “lifetime” (liveness) cost of temporaries. LOSPRE subsumes classical approaches such as common subexpression elimination, global common subexpression elimination, and loop-invariant code motion, offering an optimal strategy for code motion and computation insertion on structured control-flow graphs (CFGs). The contemporary practical relevance of LOSPRE is due to advances in exact, linear-time algorithms for structured CFGs, derived from series-parallel-loop (SPL) decompositions.

1. Formal Statement and Cost Model

LOSPRE operates on a single fixed expression $e$ and its occurrences in a program's control-flow graph $G = (V, E)$. Three sets are defined:

• Use set $U \subseteq V$: Points where $e$ must appear as a value.
• Invalidation set $I \subseteq V$: Points where $e$ is potentially overwritten or made stale (e.g., assignments or memory operations affecting $e$). Conventionally, the entry and exits are included in $I$.
• Life set $L \subseteq V$: Points where a temporary holding the latest $e$ value is kept live.

Two cost functions over an ordered abelian monoid $K$ (e.g., $\mathbb{Z}^2$, lex order) encode trade-offs:

• $c: E \rightarrow K$: Cost for inserting a computation of $e$ on an edge.
• $l: V \rightarrow K$: Cost for keeping the temporary live at a node.

The set of edges requiring new computations given a life set $L$ is

$$C(U, L, I) = \{ (x, y) \in E \mid x \notin L \setminus I \text{ and } y \in U \cup L \}$$

The optimization objective is:

$$\min_{L \subseteq V} \sum_{e \in C(U, L, I)} c(e) + \sum_{v \in L} l(v)$$

This forms a classical partial constraint satisfaction problem (PCSP) with unary constraints (liveness costs and forced live/dead at $U$ or $I$), and binary constraints (evaluation insertion on edges) (Cai, 22 Jul 2025, Krause, 2020, Cai et al., 3 Feb 2026).

2. Series-Parallel-Loop (SPL) Decomposition of CFGs

Structured (reducible, goto-free) programs' CFGs correspond directly to SPL graphs, generated by a grammar that mirrors standard program constructs:

• Atomic fragments: $A_\epsilon$, $A_{\text{break}}$, $A_{\text{continue}}$, each on four special ports $\{S, T, B, C\}$.
• Series: Sequential composition.
• Parallel: Branching (if-then-else, etc.).
• Loop: While loops with explicit handling of breaks and continues.

Transformation from program parse tree to SPL decomposition is linear-time; each CFG edge is uniquely represented, preserving underlying structural sparsity and facilitating dynamic programming approaches without overcounting or introducing incorrect redundancy patterns (Cai et al., 7 Feb 2026, Cai, 22 Jul 2025).

SPL Grammar Node	Corresponding Program Construct
Atomic	Empty, break, continue statements
Series	Sequence (;)
Parallel	If-then-else
Loop	While, do-while

3. Linear-Time SPL-DP Algorithm for LOSPRE

At each SPL node $u$, a DP table

$$\text{dp}[u, X] = \min_{L_u \subseteq V_u,\, L_u \cap \Gamma_u = X} \text{Cost}(G_u, U \cap V_u, I \cap V_u, L_u)$$

is built, where $\Gamma_u$ are the four interface ports. $X \subseteq \Gamma_u$ specifies the liveness of temporaries at the boundary.

• Leaf (atomic): For each $X \subseteq \Gamma_u$, cost is sum over live points for the selected $X$ and a computation insertion cost if the conditions for required computation are triggered.
• Series/Parallel: For compatible boundary assignments, combine sub-DPs, subtracting duplicative port liveness costs.
• Loop: Account for new edges formed by the loop, enforcing proper port assignments; combine sub-DPs with computational and liveness costs on newly introduced boundary interactions.

Each node is considered for all $2^4$ (i.e., 16) possible port configurations. Due to interface size constancy, and effective compatibility pruning, the algorithm is strictly linear-time for fixed-size domain $D$ (with $|D|=2$ in LOSPRE) (Cai et al., 7 Feb 2026, Cai, 22 Jul 2025, Cai et al., 3 Feb 2026).

The algorithm’s global minimum is recovered by minimizing over root port assignments, followed by standard backtracking to construct the optimal $L$.

4. Correctness, Complexity, and Comparison with Previous Techniques

Correctness follows by induction on the SPL decomposition tree: each DP table entry matches the cost-minimization over all valid assignments adhering to boundary liveness, with series/parallel/loop composition ensuring proper cost accounting and compatibility.

Complexity is $O(|V| + |E|)$ for structured CFGs: each SPL node processes a constant-sized table; the total number of nodes is linear in CFG size.

Previous treewidth-based algorithms (e.g., DP over tree decompositions, or MC-PRE/MC-SSAPRE via minimum-cut reduction) have $O(n^{2.5})$ or higher deterministic complexity even for bounded treewidth (Krause, 2020). The SPL-DP method not only removes dependence on higher treewidth constants but also yields a tight asymptotic improvement in both theoretical and empirical settings (Cai et al., 7 Feb 2026, Cai, 22 Jul 2025).

Method	Theoretical Complexity	Practical Constants
MC-PRE/SSAPRE	$O(n^{2.5})$	High (from flow algorithms)
Treewidth-DP	$O(n)$ (for low $t$)	Up to $2^{t+1}$ per bag
SPL-DP	$O(n)$	Small (interface size = 4)

5. Implementation and Empirical Performance

The SPL-DP algorithm has been integrated into the SDCC compiler. Benchmarks on suites such as the SDCC HC08 regression set (15,000+ functions) show:

• Average runtime per LOSPRE instance: 222 μs (SPL-DP)
• Previous state-of-art (treewidth-DP): 1,349 μs
• Worst-case: 21,524 μs (SPL-DP) vs 32,284 μs (treewidth-DP)
• Treewidth-based tool exceeded 10 ms in 277 cases; SPL-DP did so in only 19 cases

Redundancy elimination and live-range reduction results were equivalent for both techniques, consistent with their shared optimality. Compile-time overhead attributed to LOSPRE was empirically modest (1.75% of total compile time in prior results, the majority from the DP phase) (Krause, 2020, Cai et al., 7 Feb 2026, Cai, 22 Jul 2025).

6. Limitations, Extensions, and Future Directions

• Goto-free/structuredness: The SPL paradigm and its guarantees strictly apply to reducible, structured CFGs. Extending LOSPRE to handle irreducible flow graphs would necessitate structuring transformations (node-splitting, edge-adding) or alternative decomposition schemes (Cai, 22 Jul 2025).
• Interprocedural extension: Current algorithms are intraprocedural. A plausible implication is that extending SPL decompositions to model few-special-port call/return interfaces could support interprocedural LOSPRE.
• General PCSP framework: The SPL-DP method generalizes to any binary PCSP (register allocation, bank selection). A plausible implication is future compilers unifying several optimizations under SPL-PCSP engines (Cai, 22 Jul 2025, Cai et al., 3 Feb 2026).
• Parallelization/incrementality: Since DP tables at each SPL node depend only on children, parallel execution is straightforward. Incremental updates in response to local CFG changes are possible.
• Flow-sensitive pointer/alias analysis: The present LOSPRE implementations treat all pointer reads as potentially invalidating unless proven otherwise. Incorporating finer-grained pointer analysis may further reduce invalidation sets and expose additional redundancy (Krause, 2020).

7. Significance and Outlook

Lifetime-optimal speculative PRE via SPL-DP represents an asymptotically optimal, highly practical solution for broad classes of redundancy elimination and code motion tasks in modern compilers. Its exploitation of intrinsic CFG structure yields both theoretical and empirical efficiency, formally subsumes previous approaches, and offers a general blueprint for other graph-optimization passes. Current limitations center on handling arbitrary control flow and extending interprocedurally, which are active areas of future research (Krause, 2020, Cai et al., 7 Feb 2026, Cai, 22 Jul 2025, Cai et al., 3 Feb 2026).