Dynamic Dual-Path Fallback (DDPF)

• Dynamic Dual-Path Fallback (DDPF) is a systems pattern that uses two complementary execution paths and a runtime decision signal to choose the optimal route based on task verification or resource availability.
• Implemented in neural decompilation, INT8 Transformer training, automated driving, and edge LLM inference, DDPF tailors its verification criteria to maintain safety, accuracy, and efficiency.
• DDPF leverages asymmetric path designs—optimizing for semantic richness or robustness—to balance performance trade-offs and adapt to different failure modes in real-time.

Searching arXiv for the cited papers to ground the article in current sources. Dynamic Dual-Path Fallback (DDPF) denotes a runtime design in which a system maintains two complementary execution paths and selects between them under task-specific verification or resource signals. In its explicit named form, DDPF is the inference-time mechanism of CoDe-R for neural decompilation, where a rationale-guided semantic path and a rationale-free syntactic path are compared by compilation and assembly-level verification against the original binary (Zhang et al., 14 Apr 2026). Closely related formulations appear in contemporary work on INT8 Transformer training, where blocks dynamically fall back from a fast INT8 representation to a higher-fidelity residual path when outliers are detected (Zhang et al., 11 Mar 2025); in automated driving, where a primary NMPC planner is backed by concurrently available safe fallback trajectories (Emam et al., 4 Oct 2025); and in edge LLM inference, where KV tensors are dynamically assigned to either a page-cache path or an NVMe-direct path according to runtime memory availability (Jeong et al., 29 Apr 2026). This suggests that DDPF is best understood as a systems pattern whose concrete realization depends on the failure modes, observability, and latency budget of a given domain.

1. Structural definition and cross-domain schema

Across the cited systems, DDPF consists of three stable ingredients: two paths with different operating characteristics, a runtime decision signal, and a fallback rule that preserves a desired invariant such as compilability, training fidelity, safety, or bounded latency. The two paths are not arbitrary variants of the same decoder or kernel. They are deliberately asymmetric: one path is optimized for semantic richness, throughput, or task performance, while the other is optimized for robustness, numerical stability, safety, or predictable I/O behavior.

System	Complementary paths	Runtime selection signal
CoDe-R (Zhang et al., 14 Apr 2026)	Semantic-rich rationale-guided generation; syntactic-robust direct generation	Compilation validity and assembly BLEU
INT8 training (Zhang et al., 11 Mar 2025)	Fast INT8 block path; residual fallback path	Block outlier criterion and threshold-controlled fallback rate
Automated vehicles (Emam et al., 4 Oct 2025)	Main NMPC planner; backup safe trajectories including stop OCP	Timeout, infeasibility, and isSafe checks
DUAL-BLADE (Jeong et al., 29 Apr 2026)	Page-cache path; NVMe-direct path	Runtime page-cache budget and per-layer placement

The switching granularity varies materially. In CoDe-R, the decision is per test sample. In fallback quantization, it is per block and per training step. In the vehicle planner, it is per control cycle, with concurrency between main and backup loops. In DUAL-BLADE, it is per layer or KV Placement Unit and is fixed within a generation run after initialization (Zhang et al., 14 Apr 2026, Zhang et al., 11 Mar 2025, Emam et al., 4 Oct 2025, Jeong et al., 29 Apr 2026). A common misconception is therefore to treat DDPF as a single algorithmic primitive; the literature instead presents a family of dual-path control logics with different state spaces and decision horizons.

2. Named formulation in CoDe-R decompilation

In CoDe-R, DDPF is the second stage of a two-stage refinement framework for decompiler-generated pseudo-C. Stage I, Semantic Cognitive Enhancement (SCE), trains the refiner on pseudo-code $x$ together with a latent Functional Rationale $z$, using

$$P(y \mid x) \approx P(z \mid x; \mathcal{M}_{gen}) \cdot P(y \mid x, z; \theta),$$

and

$$\mathcal{L}_{SCE}(\theta) = - \sum_{t=1}^{|y|} \log P(y_t \mid x, z, y_{<t}; \theta).$$

Stage II, DDPF, turns that capability into an inference-time control mechanism by running two paths on the same pseudo-code and selecting the final output by hybrid verification against the original assembly (Zhang et al., 14 Apr 2026).

The two paths are explicitly defined. Path 1 is semantic-rich: the rationale generator predicts

$\hat{z} = \mathcal{M}_{gen}(x, \mathcal{P}_{gen}),$

and the refiner produces

$\hat{y}_{sem} = \mathcal{M}_{ref}(x, \hat{z}).$

Path 2 is syntactic-robust:

$\hat{y}_{syn} = \mathcal{M}_{ref}(x, \emptyset).$

The semantic path mirrors the SCE training distribution and is intended to recover high-level algorithmic intent, control flow, and semantics. The direct path removes the external rationale and behaves more conservatively, closer to the backbone distribution of LLM4Decompile-Ref-1.3B.

Selection is determined by compilation and assembly-level similarity. CoDe-R defines a validity indicator $\mathbb{V}(y)$ for successful compilation and a consistency score

$$\mathbb{S}(y) = \text{BLEU}(\mathcal{C}(y), x_{asm}),$$

where $\mathcal{C}(y)$ is the recompiled assembly of the generated C code and $z$0 is the original assembly. The final decision rule is

$z$1

This rule has no fixed global threshold beyond compilability and pairwise BLEU comparison; the choice is contextual to the two candidates for each sample.

The reported effect is measurable on HumanEval-Decompile. Path 2 only yields an average re-executability of 47.71%, Path 1 only 48.32%, and DDPF combined 50.00%. Compile rate also improves: the baseline average compile rate is 90.24%, Path 1 averages 83.99%, Path 2 averages 89.48%, and CoDe-R with DDPF reaches 90.70% (Zhang et al., 14 Apr 2026). The paper characterizes this as evidence that neither semantic reasoning nor syntactic conservatism is individually sufficient. A plausible implication is that DDPF externalizes a trade-off that static decoding cannot resolve internally, especially for small models subject to rationale noise and syntax instability.

3. Block-level fallback quantization as a numerical DDPF

In "Accurate INT8 Training Through Dynamic Block-Level Fallback," the DDPF pattern appears as mixed-precision GEMM in which each activation block has two possible numerical paths: a standard INT8 block quantization path and a residual fallback path activated for blocks containing large outliers (Zhang et al., 11 Mar 2025). The motivating failure mode is specific to GLU-style Transformers such as LLaMA-3 and Qwen-2.5. The paper attributes the difficulty to much larger activation magnitudes, sparse but very large outliers, and the fact that block scales are dominated by those outliers, causing coarse quantization or underflow for typical values.

The baseline block quantization is symmetric INT8 with

$z$2

For fallback blocks, the residual is formed as

$z$3

then quantized with its own scale $z$4. The effective block representation becomes

$z$5

where the indicator

$z$6

determines whether the fallback path is active. In GEMM terms, the fast path performs the usual INT8$z$7INT8 product, while the fallback path adds an extra INT8$z$8INT8 product for the residual. The paper explicitly emphasizes that this is implemented as “INT16 via two INT8’s” rather than by switching hardware units.

The dynamic component is the Delay Threshold controller, which adjusts the per-layer threshold $z$9 to keep the fallback ratio within a target interval such as $$P(y \mid x) \approx P(z \mid x; \mathcal{M}_{gen}) \cdot P(y \mid x, z; \theta),$$0:

$$P(y \mid x) \approx P(z \mid x; \mathcal{M}_{gen}) \cdot P(y \mid x, z; \theta),$$1

with $$P(y \mid x) \approx P(z \mid x; \mathcal{M}_{gen}) \cdot P(y \mid x, z; \theta),$$2. This converts fallback from a static mixed-precision heuristic into an online control loop over numerical path assignment.

The empirical results connect the dual-path mechanism to both efficiency and accuracy. On RTX4090, the DDPF kernel with $$P(y \mid x) \approx P(z \mid x; \mathcal{M}_{gen}) \cdot P(y \mid x, z; \theta),$$3 blocks reaches 425 TOPS, compared with about 270 TOPS for Jetfire with $$P(y \mid x) \approx P(z \mid x; \mathcal{M}_{gen}) \cdot P(y \mid x, z; \theta),$$4 blocks, and the method reports a 1.57x end-to-end training speedup over BF16 for LLaMA-3.1-8B. The paper also reports that DDPF training loss and validation loss track BF16 extremely closely in a LLaMA-1.5B-style pretraining setting, whereas Jetfire exhibits much worse validation loss (Zhang et al., 11 Mar 2025). This suggests that DDPF can be interpreted as numerical robustness-by-exception: almost all blocks remain on the efficient path, and only outlier-contaminated blocks incur the extra representational cost.

4. Dual-path fallback in safety-oriented path planning

In automated driving, the DDPF pattern is realized as a bi-level control framework consisting of a main NMPC loop and an independent backup loop running concurrently (Emam et al., 4 Oct 2025). The main path solves a multi-objective optimal control problem over a horizon $$P(y \mid x) \approx P(z \mid x; \mathcal{M}_{gen}) \cdot P(y \mid x, z; \theta),$$5 with $$P(y \mid x) \approx P(z \mid x; \mathcal{M}_{gen}) \cdot P(y \mid x, z; \theta),$$6 discretization steps and $$P(y \mid x) \approx P(z \mid x; \mathcal{M}_{gen}) \cdot P(y \mid x, z; \theta),$$7, using augmented road boundaries derived from predicted obstacle motion and homotopy-based constraint relaxation to improve solvability. The backup side supplies safe fallback trajectories when the main loop cannot compute an acceptable solution within a critical time frame.

The vehicle state is expressed in a Frenet frame as $$P(y \mid x) \approx P(z \mid x; \mathcal{M}_{gen}) \cdot P(y \mid x, z; \theta),$$8, with control $$P(y \mid x) \approx P(z \mid x; \mathcal{M}_{gen}) \cdot P(y \mid x, z; \theta),$$9. Dynamic obstacles are projected into time-dependent in-lane protrusions, which are then converted into augmented boundary splines. Homotopy interpolates between base boundaries and obstacle-augmented boundaries, and similarly between a base speed profile and a blockade-aware decelerating speed profile. The main planner is thus the performance-oriented path: it maximizes progress and minimizes lateral deviation, heading error, and control effort under dynamic constraints.

Fallback is not a single procedure but a hierarchy of three strategies. The first is to use the latest safe homotopy trajectory if the solver has progressed only to some $$\mathcal{L}_{SCE}(\theta) = - \sum_{t=1}^{|y|} \log P(y_t \mid x, z, y_{<t}; \theta).$$0. The second is to reuse a shifted excerpt of the previous iteration’s solution, updated through sensitivities, if the current state remains close enough for the update to be valid. The third is to solve a stop OCP, $$\mathcal{L}_{SCE}(\theta) = - \sum_{t=1}^{|y|} \log P(y_t \mid x, z, y_{<t}; \theta).$$1, which removes the progress incentive by setting $$\mathcal{L}_{SCE}(\theta) = - \sum_{t=1}^{|y|} \log P(y_t \mid x, z, y_{<t}; \theta).$$2 and adds a speed penalty term so that $$\mathcal{L}_{SCE}(\theta) = - \sum_{t=1}^{|y|} \log P(y_t \mid x, z, y_{<t}; \theta).$$3. The safety gate is explicit: isSafe(z_{n,N}, g) checks constraint satisfaction within tolerances and enforces monotonic path progress $$\mathcal{L}_{SCE}(\theta) = - \sum_{t=1}^{|y|} \log P(y_t \mid x, z, y_{<t}; \theta).$$4.

The trigger conditions are likewise explicit. The main path is treated as unavailable under timeout or iteration-limit failure, hard infeasibility, or safety verification failure. The controller restricts the number of solver iterations to 30 to imitate wall-clock deadlines. Reported average solution times in the static-obstacle scenario are 24.4 ms for homotopy-based MPC, 44.7 ms for MPC with stop fallback, and 20.1 ms for $$\mathcal{L}_{SCE}(\theta) = - \sum_{t=1}^{|y|} \log P(y_t \mid x, z, y_{<t}; \theta).$$5; in the dynamic overtaking scenario, all controllers succeed, with 35.8 ms for homotopy-based MPC, 23.9 ms for MPC with stop fallback, and 23.1 ms for $$\mathcal{L}_{SCE}(\theta) = - \sum_{t=1}^{|y|} \log P(y_t \mid x, z, y_{<t}; \theta).$$6 (Emam et al., 4 Oct 2025). The framework does not provide a formal proof of safety invariance. The paper instead argues safety through conservative constraints, explicit isSafe checks, and the availability of an independent stopping controller. A common misconception is that a fallback path in planning is merely an emergency brake; here the fallback set includes softer homotopy solutions and sensitivity-updated trajectory reuse before the stop OCP is invoked.

5. Dual-path residency in KV-cache offloading

In DUAL-BLADE, DDPF appears as a dual-path KV residency framework for edge LLM inference under tight memory budgets (Jeong et al., 29 Apr 2026). Every per-layer KV pair $$\mathcal{L}_{SCE}(\theta) = - \sum_{t=1}^{|y|} \log P(y_t \mid x, z, y_{<t}; \theta).$$7 is treated as a KV Placement Unit. The planner partitions these units into Group 1, which uses regular files and the Linux page cache, and Group 2, which uses an NVMe-direct path via io_uring_cmd and contiguous logical block address regions. The framework proceeds through Plan, Bind, and Materialize phases.

The decision signal is the effective safe page-cache budget

$$\mathcal{L}_{SCE}(\theta) = - \sum_{t=1}^{|y|} \log P(y_t \mid x, z, y_{<t}; \theta).$$8

$$\mathcal{L}_{SCE}(\theta) = - \sum_{t=1}^{|y|} \log P(y_t \mid x, z, y_{<t}; \theta).$$9

which accounts for current memory availability, memory limits, anonymous and shared memory usage, and pinned DRAM reserved for GPU DMA. Given a policy variable $\hat{z} = \mathcal{M}_{gen}(x, \mathcal{P}_{gen}),$0, the planner assigns the first

$\hat{z} = \mathcal{M}_{gen}(x, \mathcal{P}_{gen}),$1

layers to the page-cache path and routes the remaining layers to NVMe-direct. For a given run, this mapping is fixed after initialization; the paper explicitly states that there is no per-token re-evaluation.

The fallback path is optimized for sequentiality and low software overhead. For Group 2, tensors are mapped to contiguous NVMe namespace extents using an index-to-LBA map

$\hat{z} = \mathcal{M}_{gen}(x, \mathcal{P}_{gen}),$2

with subsequent extents laid out sequentially. Large requests are chunked according to MDTS, and the resulting LBA stream is strictly increasing. This bypasses VFS, the filesystem, and the kernel page cache, while reusing the same pinned buffers for both GPU DMA and NVMe DMA.

The reported gains are substantial. Across 2–11 GB memory limits, Dual-Blade reduces prefill latency by up to 33.1% on SSD A and 25.4% on SSD B, and decode latency by 8.2–42.4% on SSD A and 11.7–57.8% on SSD B relative to the baseline. Under a strict 2 GB memory limit, a 128 MB prefill write shows 44.79% NVMe busy time for the baseline and 100% for Dual-Blade, while a 128–135 MB decode read shows 54.58% versus 98.45%; the paper describes this as up to 2.2x SSD utilization (Jeong et al., 29 Apr 2026). The system further adds adaptive pipeline parallelism, comparing Overlap-Intra and Overlap-Cross modes during early decode iterations and fixing the better strategy for the remainder. This suggests that DDPF in storage systems is not merely about overflow placement; it is also about preserving the performance characteristics of the fallback path so that “fallback” does not become synonymous with uncontrolled degradation.

6. Limitations, misconceptions, and research directions

The literature places clear bounds on what DDPF does and does not guarantee. In CoDe-R, DDPF is single-shot: two paths, one verification-and-selection step, with no iterative repair loop. It doubles refiner decoding, requires rationale generation, and adds compilation plus BLEU computation for both candidates; the paper explicitly identifies inference overhead and C/C++ plus GCC specificity as limitations (Zhang et al., 14 Apr 2026). In low-bit training, the benefits depend on GPUs with fast INT8 TensorCores and on activation distributions with sparse yet extreme outliers; if fallback rates rise too far, speedup is reduced (Zhang et al., 11 Mar 2025). In automated driving, the framework relies on lane-based tunnel representations and obstacle-prediction accuracy, and the authors do not claim a formal proof of safety invariance (Emam et al., 4 Oct 2025). In DUAL-BLADE, mapping is computed at initialization, there is no fine-grained online migration during a query, and the implementation assumptions are centered on a single or small number of GPUs and a single NVMe device (Jeong et al., 29 Apr 2026).

Several misconceptions follow from collapsing these systems into a single slogan. DDPF is not synonymous with constrained decoding: CoDe-R performs post-hoc filtering by recompilation and assembly BLEU rather than decoding-time constraints. It is not necessarily iterative self-refinement: the decompilation and KV-offload versions are explicitly non-iterative at decision time. It is not always a binary success-versus-failure trigger: the quantization and storage papers use continuous statistics and budget control to determine how much traffic is routed to each path. Nor does fallback always mean “lower quality”: CoDe-R’s semantic path is preferred when it is both compilable and more assembly-consistent, and DUAL-BLADE’s NVMe-direct path can outperform the conventional page-cache path under memory pressure.

A plausible synthesis is that DDPF is most useful when three conditions hold simultaneously: the primary path and fallback path have complementary error modes, the system has an external or derived signal that can discriminate between them at runtime, and the cost of evaluating or maintaining both paths is lower than the cost of committing to a single brittle regime. The cited papers instantiate that principle with hybrid compile-plus-BLEU verification, block outlier detection plus threshold control, isSafe-gated backup planning, and runtime memory-budgeted residency assignment. In that sense, DDPF is less a fixed method than a recurring control architecture for systems that must remain functional when optimality, precision, or resource availability is unstable.