Stencil-Lifting: Semantic DSL Extraction

• Stencil-Lifting is a framework that automatically extracts semantic summaries from nested-loop stencil kernels in legacy code to produce equivalent DSL implementations.
• It employs SSA-based multilevel graphs and invariant subgraph techniques to capture loop dependencies and compute predicate-based summaries, ensuring internal verification.
• Empirical results demonstrate significant speedups in both lifting time and generated code performance, highlighting its scalability compared to prior approaches.

Searching arXiv for the primary paper and closely related lifting/DSL work. arXiv search query: (Li et al., 12 Sep 2025) Stencil-Lifting is a system for automatically converting stencil kernels written in low-level languages in legacy code into semantically equivalent Domain-Specific Language implementations. In the formulation of "Stencil-Lifting: Hierarchical Recursive Lifting System for Extracting Summary of Stencil Kernel in Legacy Codes," the system targets nested-loop stencil kernels, represents them through invariant subgraphs derived from SSA-based multilevel graphs, and derives predicate-based summaries through a hierarchical recursive process that is provably terminating and complete under stated assumptions (Li et al., 12 Sep 2025). In this usage, the term denotes semantic lifting of legacy stencil code rather than frequency-domain acceleration of stencil evolution or fabrication-oriented stencil lift-off processes (Ahmad et al., 2021, Hanna et al., 22 Jul 2025).

1. Formal object of lifting

A stencil kernel is formalized as a composition of nested loops performing fixed-pattern updates on one or more multi-dimensional arrays. The core program object is a $K$-level nested loop

$L \;:\; \mathrm{Loop}(Init,\;Cond,\;Step,\;Body),$

where a 1-level loop has no inner loops in its body, and a $(K+1)$-level loop has at least one $K$-level loop in its body. The components have the following roles: $Init$ initializes scalars and arrays, $Cond$ is the loop-exit condition, $Step$ updates the indices, and $Body$ is a sequence of assignments, arithmetic operations, conditionals, or function calls. In practice, the target class is a $K$-level nested loop whose innermost loop updates an output array $B$ by reading a fixed neighborhood in an input array $L \;:\; \mathrm{Loop}(Init,\;Cond,\;Step,\;Body),$0 (Li et al., 12 Sep 2025).

To capture dependencies, Stencil-Lifting converts the loop nest into SSA form and builds an SSA-based multilevel graph. Each SSA definition or use at loop level $L \;:\; \mathrm{Loop}(Init,\;Cond,\;Step,\;Body),$1 and iteration context $L \;:\; \mathrm{Loop}(Init,\;Cond,\;Step,\;Body),$2 becomes a vertex

$L \;:\; \mathrm{Loop}(Init,\;Cond,\;Step,\;Body),$3

and a directed edge $L \;:\; \mathrm{Loop}(Init,\;Cond,\;Step,\;Body),$4 is introduced whenever $L \;:\; \mathrm{Loop}(Init,\;Cond,\;Step,\;Body),$5 depends on $L \;:\; \mathrm{Loop}(Init,\;Cond,\;Step,\;Body),$6. Each vertex is annotated with its loop depth $L \;:\; \mathrm{Loop}(Init,\;Cond,\;Step,\;Body),$7, its outer-call count and intra-loop index $L \;:\; \mathrm{Loop}(Init,\;Cond,\;Step,\;Body),$8, and its data-type and operation attributes. For each loop level $L \;:\; \mathrm{Loop}(Init,\;Cond,\;Step,\;Body),$9, the induced subgraph is $(K+1)$0, consisting of all vertices with $(K+1)$1.

This representation is designed to capture both intra- and inter-iteration dependencies. A plausible implication is that the lifting target is not merely syntax-preserving translation, but recovery of loop-level computational semantics in a form suitable for verified abstraction and later DSL code generation.

2. Invariant subgraphs and predicate-based summaries

The central theoretical object is the invariant subgraph. The motivating observation is that stencil loops execute almost the same body in each iteration, except for a negligible number of boundary cases. Such loops are termed regular. Formally, if $(K+1)$2 is the number of times $(K+1)$3 is invoked, $(K+1)$4 is the number of iterations per invocation, and $(K+1)$5 is the set of statements executed in the $(K+1)$6th iteration of the $(K+1)$7th call, then $(K+1)$8 is regular if there is a set $(K+1)$9 such that

$K$0

The regularity assumption is therefore structural: the overwhelming majority of iterations must share a common execution pattern (Li et al., 12 Sep 2025).

Given the level-$K$1 SMG subgraph $K$2 and the loop slice $K$3 for iteration $K$4, an invariant subgraph $K$5 admits bijections

$K$6

that preserve edges and merge boundary handling via an extended SSA $K$7-function. The global invariant graph is

$K$8

This construction abstracts away per-iteration duplication while retaining the dependency structure needed for semantic reconstruction.

Each vertex $K$9 is associated with a predicate-based summary $Init$0, which encodes how the SSA-defined variable is produced. Summaries are branch-guarded by conditions over loop indices: $Init$1 where $Init$2 denotes index tuples. At each level, a special $Init$3-vertex captures the loop invariant and postcondition. This makes the summary language explicitly semantic rather than merely operational: branch conditions, index ranges, and recurrence structure are represented directly in the lifted result.

3. Self-consistency, loop invariants, and hierarchical correctness

Stencil-Lifting defines correctness through self-consistency of summary configurations. If the vertices of $Init$4 are $Init$5, each vertex $Init$6 has a summary rule $Init$7, chosen from seven rule classes: input, bound, arithmetic, get, set, $Init$8, and inner-loop calls. A summary configuration

$Init$9

is self-consistent if, for every vertex $Cond$0 with predecessors $Cond$1,

$Cond$2

The semantic content of a vertex is therefore determined compositionally from the semantics of its predecessors (Li et al., 12 Sep 2025).

The main theorem at a single loop level is the loop-invariant generation theorem. If $Cond$3 is self-consistent on $Cond$4, then the summary at the $Cond$5-vertex $Cond$6 yields valid loop invariants and postconditions satisfying the Hoare-logic verification conditions

$Cond$7

The multilevel result is the hierarchical consistency theorem: if each level-$Cond$8 configuration is self-consistent and each Loopcall summary at level $Cond$9 matches the level $Step$0 postcondition under index renumbering, then the top-level $Step$1-vertex summary is the overall stencil postcondition.

These statements identify the system’s verification strategy. Rather than depend on an external verifier, Stencil-Lifting enforces semantic coherence internally across summaries. This suggests that verification is embedded into the lifting formalism itself through the self-consistency constraints.

4. Hierarchical recursive lifting algorithm

The algorithm proceeds from the innermost loop outward and uses divide-and-conquer on strongly connected components of each invariant subgraph. For a level-$Step$2 invariant graph $Step$3, the procedure first builds the SCC graph $Step$4 and topologically orders its SCCs. It initializes summaries of input vertices, recursively resolves any Loopcall vertices by solving the corresponding lower-level subgraph, and then applies iterative semantic extraction within each SCC until self-consistency is reached (Li et al., 12 Sep 2025).

The high-level procedure is specified as

$Step$5

Within an SCC, iterative semantic extraction repeatedly picks a start vertex with known external inputs, performs a forward sweep using summary rules, generalizes the resulting summary over index ranges, shifts by one iteration, sweeps again, and checks for convergence.

The termination argument is based on finiteness of SCCs and bounded growth of summary branching: each SCC has a finite number of vertices, and each summary’s branching cannot grow unbounded because each array update reads at most $Step$6 neighbors. Generalized summaries become iteration-independent after a finite number of refinements. Under the assumptions that the invariant graph is correctly constructed and all loops are regular, the completeness theorem states that the recursive algorithm always derives a self-consistent configuration and hence the correct postcondition of the stencil.

A central methodological consequence is the elimination of search-based synthesis from the lifting loop. The abstract specifically characterizes the algorithm as avoiding the inefficiencies of search-based synthesis, and the detailed summary states that it replaces expensive CEGIS-based synthesis with a provably terminating, complete, hierarchical fixed-point extraction process (Li et al., 12 Sep 2025).

5. Empirical results and generated-code performance

The evaluation covers diverse stencil benchmarks from two different suites and four real-world applications. The principal metric at the lifting stage is summary-lifting time. Stencil-Lifting reports geometric-mean speedups of $Step$7 over STNG and $Step$8 over Dexter while maintaining full semantic equivalence (Li et al., 12 Sep 2025).

The lifted summaries are translated to Halide and autotuned. Against original Fortran, the generated code achieves average CPU speedup of $Step$9, and against STNG’s Halide code it achieves $Body$0. On GPU, the generated code achieves $Body$1 against Fortran and $Body$2 against STNG’s GPU code. As stencil complexity grows in points times neighbors, the lifting time scales nearly linearly, whereas STNG’s lifting time grows super-linearly and often times out on large kernels.

Measure	Comparison	Result
Summary-lifting time	vs STNG	$Body$3
Summary-lifting time	vs Dexter	$Body$4
Generated CPU code	vs legacy Fortran	$Body$5
Generated CPU code	vs STNG’s Halide code	$Body$6
Generated GPU code	vs Fortran	$Body$7
Generated GPU code	vs STNG’s GPU code	$Body$8

These results separate two performance questions. First, lifting efficiency concerns the cost of extracting correct summaries from legacy code. Second, generated-code efficiency concerns the runtime quality of the downstream DSL implementation. The reported data indicate gains on both axes. A plausible implication is that the system addresses a longstanding translation bottleneck between legacy optimized stencil kernels and DSL-based optimization pipelines.

6. Assumptions, scope, and terminological boundaries

The theory assumes regular loops: each loop must execute a mostly invariant body. Highly irregular or data-dependent nested branches may break the invariant-subgraph abstraction. The current scope is fixed-pattern stencils; loops that change their neighbor sets dynamically, such as adaptive meshes, are not yet supported. The detailed discussion also lists potential extensions: relaxing regularity via data-driven pattern mining and speculative summaries, integrating loop-tiling and fusion transformations into graph construction to handle highly optimized legacy codes, and extending beyond pure stencils to streaming-oriented computations or irregular mesh kernels by combining with polyhedral or inspector-executor frameworks (Li et al., 12 Sep 2025).

The term itself can be a source of confusion because related arXiv literature uses “lifting” or “stencil” in different technical senses. In "Fast Stencil Computations using Fast Fourier Transforms," stencil evolution is “lifted” to frequency space by diagonalizing a circulant stencil operator with the DFT and exponentiating eigenvalues to compute $Body$9 in one shot; that work concerns direct solvers for linear stencil computations rather than semantic lifting of legacy code (Ahmad et al., 2021). In "On-chip stencil lithography for superconducting qubits," stencil mask lift-off denotes removal of an inorganic SiO$K$0/Si$K$1N$K$2 stencil after double-angle Al evaporation; that usage belongs to superconducting-device fabrication and is unrelated to program analysis or DSL translation (Hanna et al., 22 Jul 2025).

This distinction matters conceptually. Stencil-Lifting in the legacy-code sense is a verified abstraction framework for recovering postconditions and DSL realizations from nested-loop programs. It is neither a numerical acceleration method for repeated stencil timestepping nor a microfabrication lift-off process, even though all three literatures employ the words “stencil” and “lifting.”

7. Position within stencil compilation research

Stencil-Lifting is positioned as a bridge between legacy optimization techniques and modern DSL-based paradigms. Its direct output is a semantically equivalent DSL implementation, and the reported translation path is to Halide with autotuning (Li et al., 12 Sep 2025). The system therefore sits at the intersection of verified lifting, dependence-graph abstraction, loop-invariant inference, and stencil compilation.

Its distinguishing features are the invariant-subgraph representation, predicate-based summaries, self-consistency as the core semantic criterion, and hierarchical recursive lifting over SCCs. Under the regularity assumptions, these components support a workflow in which the top-level $K$3-vertex summary becomes the overall postcondition of the stencil kernel. The abstract formulation emphasizes scalability, semantic equivalence, and elimination of external verification for nested-loop stencil lifting (Li et al., 12 Sep 2025).

In that sense, Stencil-Lifting is best understood as a formal and algorithmic framework for extracting the summary semantics of legacy stencil kernels and re-expressing them in DSL form with guaranteed correctness under explicit structural assumptions.