acceptodds
Under review as a conference paper at ICLR 2027

RELOAD: Packed Future-State Re-Encoding for Low-Latency Exact Speculative Diffusion

Abstract

Exact speculative diffusion preserves a designated discretized target distribution, but autoregressive drafting leaves sequential neural calls on the critical path. Predicting a whole horizon from one anchor removes this rollout yet leaves later predictions without representations of their random future source states. We call this mismatch future-state representation staleness. RELOAD, a two-pass drafter, first constructs causal future sources from parallel coarse predictions. A packed second pass re-encodes these sources, and the scheduler rebuilds proposals from the same anchor and innovations. Rank-eight Role-LoRA specializes this second role with 267,264 trainable parameters. We prove that the resulting proposals retain prefix causality, allowing the unchanged reflection verifier to preserve the target-chain law in exact arithmetic under matched-covariance assumptions. At horizon eight, re-encoding raises mean accepted length from 2.02 to 4.52, and role adaptation further raises it to 4.77 in a one-GPU component study. On 256 paired ImageNet-256 cases, RELOAD reduces mean sampling latency by 10.0% relative to reproduced strict FREE, a 1.111× speedup under the same eight-rank allocation. Eight-way verification yields a 2.286× latency speedup over one-active-rank TARGET.

Primary area:
generative models
Keywords:
speculative diffusion, diffusion models, future-state re-encoding, parallel drafting, inference acceleration, exact sampling

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_2evoOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper investigates the information deficit in parallel speculative diffusion when using anchor representations to predict future states. RELOAD first constructs a rough causal trajectory, then bundles and re-encodes the source states at each step, and uses a shared random innovation to reconstruct candidate trajectories. Role-LoRA adapts only the re-encoding of roles. Under conditions where candidate and target states share the same state-independent Gaussian covariance, as well as item-wise computation and prefix causality, the method preserves the distribution of a specified target sampling chain through acceptance and reflection corrections. Key experiments on DiT-XL/2, ImageNet-256, and DDPM-1000 demonstrate a latency reduction of approximately 10% compared to strict FREE with the same resources.

Critical strengths
  1. Mechanistic evidence is more robust than simple system comparisons. The B0/B1/B2 experiments—which fix weights while varying the source state—directly test the role of future state information. Ablations such as frozen re-encoding, serial/batch execution, and Role-LoRA further distinguish the sources of reception length and latency gains.
  2. The correctness argument addresses key dependencies. Appendix A explains why item-by-item re-encoding preserves prefix testability and argues for acceptance and correction given a history containing previous verification decisions. The paper also clearly distinguishes between distribution preservation under exact arithmetic and checks with finite precision and finite samples.
  3. Key speed conclusions are supported by rigorous paired evidence. Under the same eight-rank configuration, the average latency across 256 paired cases decreased from 6.092 seconds to 5.482 seconds, with 254 cases showing faster performance; paired confidence intervals are reported. The authors also disclose GPU-second costs and some adaptation results showing no significant differences, which aids in accurately understanding the gains.
Critical weaknesses
  1. The generalizability of the empirical findings is limited.** Despite controlling for horizon, CFG, and validation rank, the main experiments were confined to a single model, dataset, and a fixed 1,000-step posterior variance DDPM setup. The target chain also explicitly ignored the model’s learned-variance output. Therefore, the empirical results support improvements specific to this particular random target chain and cannot yet be generalized to arbitrary diffusion samplers. The authors have already explained that ODEs and mismatched covariances require different validation constructs; I do not consider these unaddressed settings to be flaws in correctness. This limitation primarily affects the breadth of the contribution rather than the existence of a valid contribution.

  2. New contributions should be evaluated based on gains relative to a strict FREE baseline with the same resources; the full acceleration relative to sequential TARGET should not be attributed solely to the new drafter. The primary new benefit is a latency reduction of approximately 10%; the 2.286-fold acceleration relative to the single-active-rank TARGET also accounts for the effect of multi-rank validation. Correspondingly, active-rank GPU-seconds increased from 12.535 for TARGET to 43.859 for RELOAD. The paper has disclosed these differences; therefore, the issue is not a lack of cost transparency, but rather that the research value should be framed as a low-latency improvement under specific resource configurations. Appendix C.3’s failure to report total GPU-hours for Stage I also makes it temporarily impossible to quantify the full training amortization when migrating from existing systems. These limitations lead me to lean toward marginal acceptance rather than a higher rating.

Questions for authors
  1. Within the specified scope of application, which samplers or architectural conditions are necessary for the causality and verification arguments presented in this paper, and which are merely choices made in the current implementation? Please briefly distinguish between them so that readers can assess the effort required for porting without needing to develop a new verifier.
  2. Appendix C.3 notes that the cost records for Stage I are incomplete. Is there a verifiable total cost or upper/lower bounds that can be provided to supplement this information? If these cannot be recovered, please retain this limitation and avoid drawing conclusions about the payback period for training from scratch or switching systems based on the 1.001 GPU-hours figure from Stage II.
1 comment
AuthorsOpenReview ↗

Author Response to Reviewer 2evo

Thank you for your careful analysis of correctness, paired experiments, resource use, and training cost.

Verifier requirements and portability:

The verifier supports architectures satisfying these transition and causal conditions. DiT, resolution, and step count are implementation choices.

AspectConditions used in our proof and implementation
SamplerGaussian proposal and target transitions share preset, state-independent covariance σ_k²I, with σ_k>0. Variance may vary by timestep; a zero-variance terminal step uses the target update directly.
CausalityProposal means depend on the legal prefix, without current or future candidate innovations. Packing preserves these dependencies; itemwise re-encoding and target scoring prevent mixing across draft positions.
VerificationRecorded densities match actual generation. Innovations and verification randomness satisfy conditional independence given prior verification decisions. Acceptance, reflection correction, suffix discarding, and restarting with fresh randomness are retained.

We choose fixed-posterior DDPM and ignore learned-variance outputs; ImageNet, GPU count, and LoRA rank are also implementation choices. Itemwise computation preserves causality. Shared innovations improve efficiency; Appendix A.1 also permits independent auxiliary coarse randomness under its causal conditions.

Porting requires target means/variances, drafter feature/weight adaptation, and causal packing. State-dependent covariances are outside the current proof and implementation. Extending to them requires separate validation of generating densities and rejection-residual correction, including covariance matching and causality. Mismatched covariances are not covered by the current reflection rule; deterministic ODE steps need a different acceleration interface. Section 3.4 now distinguishes proof assumptions, implementation choices, and porting work.


Training records and resource attribution:

Complete measured cost and verifiable bounds remain unavailable. Six recovered Stage-I runtime windows total 74.647 hours; segment timings and GPU-allocation records remain incomplete. Combining these runtimes with missing segments extrapolated from historical weighted mean update time gives:

MethodUpdatesGPUs × runtime (h)GPU-hours
Strict FREE180,1204 × ≈41.7≈167, estimated
RELOAD Stage I180,1204 × ≈102.2≈409, estimated
Role-LoRA8,0001 × 1.0011.001, measured loop
RELOAD totalTwo stagesAbove≈410, estimated

Both base-training estimates assume continuous four-GPU allocation. Different observed segment speeds give scenarios of 162–167 GPU-hours for FREE and 377–451 for RELOAD; these are not rigorous bounds. The 1.001 GPU-hours covers only the Role-LoRA training loop, not full costs of training from scratch or switching from FREE. Appendix C.3 documents the gaps and estimation, distinguishing Role-LoRA adaptation, switching from FREE, and training from scratch, with associated evaluation costs.

The abstract and Section 4.2 emphasize 10.0% lower latency than strict FREE with the same eight active ranks: 6.092 versus 5.482 s/image, and 48.737 versus 43.859 GPU-seconds/image. TARGET uses one active rank and 12.535 GPU-seconds/image. The 2.286× speedup over TARGET includes drafting and parallel verification.


Scope of the additional experiments:

We added shorter schedules and higher resolution with DiT and fixed-posterior DDPM. At 256 resolution, 250 steps, and B=1, 256 paired cases give 2.753/2.599 s/image for eight-GPU strict FREE/RELOAD: 5.6% lower latency, or 1.059× [1.050, 1.068].

At 512 resolution, we evaluated DiT-XL/2 with DDPM-1000, B=1, L=8, CFG 1.5, and 128 paired cases. All three configurations use eight active GPU ranks:

ConfigurationTime (s/image)AL
One-pass drafting29.9941.250
Frozen re-encoding20.5863.478
Full RELOAD19.5343.798

Frozen re-encoding gives 1.457× [1.446, 1.468] over one-pass drafting. Role-LoRA adds 1.054× [1.046, 1.061] over frozen re-encoding, or 5.11% lower latency. All intervals are paired 95% CIs.

Time constraints prevented strict FREE-512 and non-DiT evaluation. If accepted, we will add FREE-512 under the same target sampler and hardware, and evaluate a non-DiT model satisfying the verifier conditions.

The new 256 experiment uses another A100 80GB server, case set, and evaluator supporting short schedules/batching. Baselines were remeasured; speedups are paired within this experiment. Checkpoints and FP32/TF32 are unchanged. Timing includes communication and excludes loading, warmup, and VAE decoding.

Reviewer_xjAyOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes RELOAD, a two-pass speculative drafter for accelerating diffusion sampling. By first predicting coarse future states and then re-encoding them in parallel, RELOAD aims to mitigate the stale-state issue in existing parallel drafting methods. The paper further introduces Role-LoRA to specialize the rerun process and provides theoretical analysis of target-law preservation.

Critical strengths
  1. The paper identifies a potential limitation of parallel drafting and proposes a reasonable approach to incorporating future-state information.
  2. The authors conducted extensive experiments to evaluate the effectiveness of the proposed method.
Critical weaknesses
  1. Modest performance gains and unclear attribution. RELOAD achieves a consistent but relatively modest end-to-end latency improvement over strict FREE. Although the paper includes extensive component studies, the respective contributions of the two-pass drafting design, Role-LoRA, noise coupling, and packed execution to the overall improvement could be more clearly established.
  2. Training overhead and practical benefits. The proposed method introduces additional training and a second drafter pass. A clearer analysis of the total training cost and its amortization under different inference workloads would help establish the practical value of the reported speedup.
  3. Limited generalization evidence. The evaluation primarily focuses on DiT-XL/2 with a fixed DDPM sampling schedule. It remains unclear whether the proposed approach generalizes to other diffusion architectures and sampling configurations.
  4. Presentation quality. The visual presentation of Figure 1 could be substantially improved in terms of layout, color scheme, and clarity.
Questions for authors
  1. Can the authors provide a more direct breakdown of the proposed schemes?
  2. How do the total training and inference costs of RELOAD compare with those of the baselines under realistic deployment workloads?
  3. Can the authors provide additional evidence of generalization to other diffusion models or sampling configurations?
2 comments
AuthorsOpenReview ↗

Author Response to Reviewer xjAy

Thank you for your positive assessment and suggestions on components, cost, generalization, and presentation.

Component contributions and Figure 1:

Table 2 separates re-encoding, packing, and adaptation using the same base checkpoint, L=8, 256 paired cases, and one GPU per sample:

ConfigurationStrict ALTime (s/image)
One-pass drafting2.015520.3256
Serial frozen re-encoding4.528415.5544
Packed frozen re-encoding4.524013.8242
Packed re-encoding + Main Role-LoRA4.770313.3846

Re-encoding supplies intermediate-state information and accounts for the main AL gain. Packing preserves AL while reducing latency by 11.12%; Role-LoRA further improves AL and reduces latency by 3.18%. Timings include both drafting passes. Separately, fixing Independent Role-LoRA and sharing causal innovations increases AL from 1.6782 to 4.7851 on 128 paired cases.

Figure 1 now distinguishes blue coarse inputs from purple rebuilt candidates. Both lower networks are grouped under “Drafting Stage details”; enlarged labels, clearer arrows, and vector export improve readability.


Training investment and inference cost:

Recovered logs give estimated training costs of 410 GPU-hours for RELOAD and 167 for strict FREE:

MethodUpdatesGPUs × runtime (h)GPU-hours
Strict FREE180,1204 × ≈41.7≈167, estimated
RELOAD Stage I180,1204 × ≈102.2≈409, estimated
Role-LoRA8,0001 × 1.0011.001, measured loop
RELOAD totalTwo stagesAbove≈410, estimated

These estimates retain recovered runtimes and extrapolate missing segments using historical weighted mean time per update, assuming continuous four-GPU base training. Different observed segment speeds give scenarios of 162–167 GPU-hours for FREE and 377–451 for RELOAD, not rigorous bounds. Some training and evaluation overhead is unrecorded.

In original Table 1 (256 resolution, 1,000 steps, B=1), both methods use eight active ranks. RELOAD reduces latency from 6.092 to 5.482 s/image (10.0%) and cost from 48.737 to 43.859 GPU-seconds/image. Sequential TARGET uses one active rank and 12.535 GPU-seconds/image. This comparison targets single-request latency.

The saving over FREE is 4.878 GPU-seconds/image. For extra one-time cost ΔC (GPU-hours), break-even N ≈ 3600ΔC/4.878 ≈ 738ΔC. Using training estimates alone:

Deployment starting pointExtra training costBreak-even images
Both trained from scratch410−167 = 243 GPU-hours≈179,000
FREE already available; train RELOAD410 GPU-hours≈303,000

If the RELOAD base already exists, adding Role-LoRA instead compares against frozen re-encoding: the single-GPU experiment saves 0.43969 GPU-seconds/image, giving ≈8188C_Role images, where C_Role includes adaptation and evaluation costs.

Full payback must include evaluation, migration, and other overhead. It assumes comparable training/inference GPU-hours, sustained savings, and reusable or releasable GPU time. The 1.001 GPU-hours is only the Role-LoRA training loop. Complete measured payback remains unknown. Appendix C.3 now gives recovered timings, missing records, estimation, and all three deployment scenarios.


Other sampling settings:

At 256 resolution and 250 steps, strict FREE/RELOAD take 2.753/2.599 s/image: 5.6% lower latency, or 1.059× [1.050, 1.068]. At 1,000 steps, B=2/4 give 1.077× [1.071, 1.084] and 1.032× [1.022, 1.042]. Each setting contains 256 images per method.

At 512 resolution, we evaluated DiT-XL/2 with fixed-posterior DDPM-1000, B=1, L=8, CFG 1.5, and 128 paired cases. TARGET uses one active GPU rank; each drafting configuration uses eight.

ConfigurationTime (s/image)Speedup over TARGETAL
TARGET44.0061.000×—
One-pass drafting29.9941.467×1.250
Frozen re-encoding20.5862.138×3.478
Full RELOAD19.5342.253×3.798

Paired 95% CIs: full RELOAD versus TARGET, [2.238, 2.268]; frozen re-encoding versus one-pass, 1.457× [1.446, 1.468]; Role-LoRA versus frozen, 1.054× [1.046, 1.061] (5.11% lower latency). The latter two comparisons use matched resources.

These experiments still use DiT. Time constraints prevented strict FREE-512 and non-DiT evaluation. If accepted, we will add FREE-512 under the same sampler and hardware, and a non-DiT model supported by the verifier.

New 256 experiments use another A100 80GB server, case set, and evaluator. Baselines were remeasured; comparisons are paired within each setting. FREE/RELOAD share synchronized batching. Checkpoints and FP32/TF32 are unchanged; timing includes communication and excludes loading, warmup, and VAE decoding.

Dear authors,

Thank you for your rebuttal. Most of my concerns have been resolved by the rebuttal. I will keep my original positive score.

Reviewer_uwokOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
1
Soundness
3
Read review
Paper summary

The paper proposes an improved approach to speculative sampling for diffusion models that use stochastic samplers. The authors leverage recent progress in speculative decoding for LLMs and adapt DFlash parallel drafter as their first stage. In the second stage, the authors reuse the drafter prefix and refine it with the LoRA-adapted model. The paper shows a consistent improvement in acceptance length of ~5% that comes from the refinement stage and another ~5% from the improved drafter architecture that requires two forward passes instead of eight. The proposed method improves sampling for a range of block sizes and is robust under CFG.

Critical strengths
  1. The paper tackles an important problem of improving the speed of diffusion sampling. Despite speculative sampling for LLMs being widely researched, its application to diffusion models is lagging. The authors adapt well-known LLM approaches like DFlash and D²SD for diffusion models and show a modest improvement.
Critical weaknesses
  1. The paper is difficult to read and feels too LLM-ish. The method's explanation, in particular, is overloaded and should be described in more natural language. Also, the names like Primary Role7000 and Rank8 that are introduced only in the appendix make the understanding harder.

  2. The experimental scope is narrow and favorable to speculative sampling. All results use one model, one resolution, one sampler, and batch size 1. Speculative sampling benefits from fine discretization, yet no results are given for fewer steps. For reference, the standard DiT evaluation uses 250 DDPM steps, i.e., 250 sequential target calls, fewer than RELOAD's ~315 at 1000 steps.

Questions for authors
  1. Have you tried to expand the evaluation beyond the 1000-step ImageNet setup?
3 comments
AuthorsOpenReview ↗

Author Response to Reviewer uwok

Thank you for your careful review and suggestions on experimental coverage, method explanation, and naming.

250 steps and batch sampling:

We added 250-step experiments and B=2/4 experiments at 1,000 steps. At 250 steps, RELOAD reduces latency by 5.6% versus strict FREE under matched resources. Each setting uses DiT-XL/2-256 and 256 images per method. Times are per batch. TARGET uses one active A100 80GB rank; each speculative method uses eight.

StepsBatchTARGET (s)Strict FREE (s)RELOAD (s)Speedup over FREE [paired 95% CI]
25013.8272.7532.5991.059× [1.050, 1.068]
1000115.1007.6716.9361.106× [1.101, 1.111]
1000218.68010.4999.7441.077× [1.071, 1.084]
1000431.47319.34018.7371.032× [1.022, 1.042]

On the same 250-step target chain, RELOAD averages 118.57 logical target invocations, 52.6% fewer than TARGET's 250.00. The chain still contains 250 sampling steps.

At 250 steps, RELOAD's strict accepted length (AL) is 2.258 versus FREE's 2.407. Lower time per round offsets this decrease: a full FREE block requires eight sequential drafting forwards, whereas RELOAD uses a coarse pass and a packed re-encoding pass. Mean rounds rise from 58.19 to 59.04 (+1.47%), but amortized time per round falls from 47.31 to 44.02 ms (−6.95%). This is total sampling time divided by total rounds.

Both methods use synchronized batching: the earliest rejection determines the shared accepted prefix, so one image's rejection limits the whole batch. B=2/4 contain 128/64 paired batches. This coupling helps explain the smaller gain at B=4.

We remeasured all three methods after changing the A100 80GB server, fixed case set, and evaluation program to support short schedules and batching. Original Table 1 reports TARGET/FREE/RELOAD times of 12.535/6.092/5.482 s; the original and new 1,000-step latency reductions over FREE are 10.0% and 9.6%. Platform, cases, and procedure can affect absolute timings and relative gains. Section 4.5 and Appendix E.8.6 report the new results; Appendix C.5 documents measurement differences.

Within each schedule, methods use the same fixed-posterior DDPM chain. Checkpoints, L=8, CFG 1.5, FP32/TF32, and timing scope are unchanged. CUDA-synchronized timings include communication and exclude loading, warmup, and VAE decoding. Each new 32-case shard uses two warmups per method, versus one originally.


512 resolution:

We completed 128 paired cases at 512×512, where full RELOAD achieves 2.253× speedup over TARGET, with paired 95% CI [2.238, 2.268]. Settings are DiT-XL/2, fixed-posterior DDPM-1000, B=1, L=8, and CFG 1.5; rank allocation is as above.

MethodTime (s/image)Speedup over TARGETAL
TARGET44.0061.000×—
Full RELOAD19.5342.253×3.798

The architecture remains DiT. We could not complete strict FREE-512 or non-DiT evaluations within the rebuttal period. If accepted, we will add FREE-512 under the same target sampler and hardware, and evaluate a non-DiT model with sampling settings supported by the verifier.


Method explanation and checkpoint names:

The second drafting pass supplies intermediate-state information missing from predictions based solely on the current state's features. We rewrote the method around four steps: construct a coarse trajectory; independently re-encode its source states in one packed forward; rebuild candidates from the same anchor using updated predictions and the same per-step innovations; then verify candidates and apply reflection correction at the first rejection. Coarse states are re-encoder inputs; rebuilt states are the candidates actually verified.

Figure 1 now distinguishes blue coarse states from purple rebuilt proposals. Both lower network panels are grouped under “Drafting Stage details,” and internal labels have been enlarged.

“Primary Role7000” and “Follow-up Rank8” are now “Main Role-LoRA” and “Independent Role-LoRA.” We explain their separate training runs at first use and retain the checkpoint-to-experiment mapping.

I thank the authors for the additional experiments. In my view, they confirm the main concern:

  1. In the 250-step setup, RELOAD’s AL is lower than FREE’s, which suggests that the two-step drafting loses some of its advantage in the practical setup.

  2. The results suggest that plain 250-step DDPM on one GPU (3.827 s) is faster than RELOAD at 1000 steps (6.936 s). It is not clear whether there is a difference in quality between 250- and 1000-step generation that can justify an almost x2 slowdown. Could you measure FID@50k in those two regimes?

  3. The proposed method requires almost 2.5x more GPU-hours than FREE at the same number of updates. The difference in compute makes the comparison unfair and it is unclear how much of the AL gain at 1000 steps comes from the additional budget. Notably, at 250 steps, RELOAD’s AL is lower despite this larger budget. Could you provide the results under matched compute (RELOAD with the earlier checkpoint)?

  4. The 512x512 results lack the FREE baseline, so the gain over the relevant baseline is unknown.

I remain unchanged in my overall assessment.

AuthorsOpenReview ↗

Follow-up: Latency at Comparable Training Cost and FID@50k Results

Thank you for suggesting an earlier checkpoint to account for the difference in training cost. With approximately matched training budgets and eight GPUs per method at inference, early RELOAD reduced single-request sampling latency relative to strict FREE by 3.05% at 250 steps and 7.23% at 1,000 steps.

1. Approximately matched training budgets

We compared strict FREE at 180,120 training updates with RELOAD at 84,056 Stage I updates, using a Role-LoRA adapter trained from that earlier checkpoint for 7,000 updates. The estimated cumulative training costs were 166.70 GPU-hours for FREE and 170.46 for RELOAD, a difference of 2.26%.

Both methods ran on eight A100 80GB GPUs at inference. We measured sampling latency on DiT-XL/2-256 with 128 paired cases per schedule.

ScheduleStrict FREE (s/image)Early RELOAD (s/image)Speedup (paired 95% CI)
1,000 steps7.7767.2141.078× [1.070, 1.086]
250 steps2.7642.6801.031× [1.020, 1.044]

At 1,000 steps, mean acceptance length (AL) was 4.533 for FREE and 4.579 for early RELOAD. The paired 95% CI for the RELOAD/FREE AL ratio was [0.998, 1.022]. At 250 steps, RELOAD had a lower AL (2.134 vs. 2.397 for FREE), but its lower average time per round (44.10 vs. 47.40 ms) offset the additional rounds.

2. Image quality and sampling latency

The original FREE paper evaluated sampling speed on a 1,000-step DDPM chain with fixed posterior variance. We used that setup in our main experiments to compare RELOAD and strict FREE directly on the same target chain.

We completed the FID@50k evaluation you suggested. We generated 50,000 images each with TARGET-250 and full RELOAD-1000. Both used the same reference set of 50,000 real ImageNet training images, with 50 fixed images per class.

SettingFID@50k ↓Mean KID ↓Previously measured latency (s/image)
TARGET-2502.874440.000764783.827 (one active GPU)
Full RELOAD-10002.821810.000699156.936 (eight GPUs)

In this 50K evaluation, full RELOAD-1000 scored slightly better than TARGET-250 on both FID and KID, with an FID difference of 0.05263 in its favor.

For users who prioritize latency, RELOAD can accelerate the 250-step target chain directly. Across 256 paired cases, sequential TARGET-250 took 3.827 s per image on one active GPU, and full RELOAD-250 took 2.599 s on eight GPUs, a 32.1% reduction in single-request latency. With eight GPUs for both methods, strict FREE-250 took 2.753 s per image, giving RELOAD 5.6% lower latency.

3. The strict FREE baseline at 512×512

We agree that the latency advantage over strict FREE at 512×512 remains unknown. At this resolution, RELOAD achieved a 2.253× speedup over sequential TARGET, using eight active GPUs for RELOAD and one for TARGET. This measures the reduction in single-request latency relative to TARGET. Given the time available during this rebuttal, we could not complete a direct comparison with strict FREE on the same hardware and target chain.

Thank you for prompting us to test the earlier checkpoint and to examine the quality and latency of the shorter schedule.

Comments on the paper

1 comment

Dear Reviewers,

As we are approaching the end of reviewer-author discussions, please go through authors' responses and raise questions that you would like authors to reply.

Thanks,

AC

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.