BWCache: Accelerating Video Diffusion Transformers through Block-Wise Caching

## Abstract

Abstract Recent advancements in Diffusion Transformers (DiTs) have established them as the state-of-the-art method for video generation. However, their inherently sequential denoising process results in inevitable latency, limiting real-world applicability. Existing acceleration methods either compromise visual quality due to architectural modifications or fail to reuse intermediate features at proper granularity. Our analysis reveals that DiT blocks are the primary contributors to inference latency. Across diffusion timesteps, the feature variations of DiT blocks exhibit a U-shaped pattern with high similarity during intermediate timesteps, which suggests substantial computational redundancy. In this paper, we propose Block-Wise Caching (BWCache), a training-free method to accelerate DiT-based video generation. BWCache dynamically caches and reuses features from DiT blocks across diffusion timesteps. Furthermore, we introduce a similarity indicator that triggers feature reuse only when the differences between block features at adjacent timesteps fall below a threshold, thereby minimizing redundant computations while maintaining visual fidelity. Extensive experiments on several video diffusion models demonstrate that BWCache achieves up to 2.24 × \times speedup with comparable visual quality.

## 1 Introduction

Figure: Figure 2: Overview of the BWCache. An indicator based on adjacent timestep differences in block features determines whether to reuse the cache. If conditions are met, subsequent timesteps reuse cached blocks; otherwise, blocks are recomputed and the cache updated.
Refer to caption: x5.png

Diffusion Models (DMs) Song and Ermon (2019); Ho et al. (2020); Dhariwal and Nichol (2021) have emerged as the predominant technology in Generative AI (GenAI) due to their ability to generate high-fidelity images and videos Rombach et al. (2022). Early DMs primarily adopted the U-Net architecture Ronneberger et al. (2015); Ramesh et al. (2022); Saharia et al. (2022); Blattmann et al. (2023). Recently, the success of Sora Brooks et al. (2024) has spurred the adoption of the Diffusion Transformer (DiT) architecture Peebles and Xie (2023); Bao et al. (2023) for video generation, achieving state-of-the-art performance. Video generation with DiT requires the sequential computation of multiple DiT blocks, specifically Spatial DiT (S-DiT) and Temporal DiT (T-DiT) blocks Ho et al. (2022). However, these blocks must be executed in sequence, which considerably slows down inference. As a result, accelerating DiT inference has become one of the most pressing challenges faced by GenAI.

Traditional acceleration techniques for DMs primarily focus on architectural modifications such as distillation, pruning, and quantization Wang et al. (2024); Chu et al. (2024); Yang et al. (2024); Zhang et al. (2024a); Kang et al. (2024); Zhou et al. (2024). Although these methods reduce model complexity, they also compromise generation quality. More importantly, they require substantial computational resources and extensive training data to fine-tune, which is impractical for large pre-trained DMs. A training-free alternative is to cache the intermediate features of DMs to accelerate inference Ma et al. (2023); Zhang et al. (2024b); Zhao et al. (2024a); Kahatapitiya et al. (2024); Liu et al. (2024). By reusing these intermediate features across timesteps, these approaches eliminate redundant computations and significantly improve generation efficiency.

Despite the proven effectiveness of caching in accelerating DM inference, two critical challenges remain unresolved. First, DiT is a complex structure, considering caching at a coarse granularity (e.g., timesteps) Lv et al. (2024); Liu et al. (2024) may result in the loss of essential information, while considering caching at a fine granularity (e.g., attention) Kahatapitiya et al. (2024); Zhao et al. (2024a); Yuan et al. (2024); Zhang et al. (2025) often fails to deliver significant acceleration. Thus, the first challenge is to identify which features are appropriate for caching. Second, many existing methods assume high similarity between features across adjacent timesteps, sharing features between them to speed up inference Zhao et al. (2024a); Lv et al. (2024); Wimbauer et al. (2024); Selvaraju et al. (2024); Liu et al. (2025a). In reality, however, feature similarity varies greatly depending on the generation task and specific inference process, and naive feature reuse can often degrade output details. Therefore, the second challenge is to determine when cached features should be reused or updated.

In this paper, we propose Block-Wise Caching (BWCache), a training-free method to accelerate DiT-based video generation.
This method can be seamlessly integrated into most DiT-based models as a plug-and-play component during the inference phase. The core idea is to cache the features from all DiT blocks at certain diffusion timesteps and reuse them across several subsequent steps. Specifically, as shown in Figure [2](https://arxiv.org/html/2509.13789v2#S1.F2), DiT-based video generation typically involves providing a text prompt and initializing latent noise, which is then refined through multiple iterative denoising steps, and finally reconstructed into video frames using a VAE decoder. To determine when to reuse cached features, we introduce a similarity indicator based on the differences between block features from adjacent timesteps. Periodic recomputation is applied to mitigate potential latent drift. This approach significantly reduces inference time and resource consumption while preserving output quality. We evaluate BWCache across several video diffusion models, including Open-Sora Zheng et al. (2024), Open-Sora-Plan Lin et al. (2024), and Latte Ma et al. (2025). As shown in Figure [1](https://arxiv.org/html/2509.13789v2#S0.F1), BWCache achieves superior performance at comparable computational costs to TeaCache Liu et al. (2024). The main contributions are summarized as follows.

- •
We analyze the components of DiT-based models during the denoising process, revealing the dynamics within DiT blocks under different generation tasks and highlighting their similarities across specific diffusion timesteps.
- •
We propose BWCache, a training-free method compatible with DiT-based models that caches DiT block features and reuses them across multiple diffusion timesteps, thereby accelerating video generation inference.
- •
Experiments demonstrate that our method outperforms existing baselines in terms of inference speed and video generation quality, justified through both ablation studies and qualitative comparisons.

Figure: (a) Prompt 1
Refer to caption: x6.png

## 2 Related Work

### 2.1 Diffusion Model

Early video generation models, such as Variational Autoencoders (VAEs) Kingma et al. (2013) and Generative Adversarial Networks (GANs) Goodfellow et al. (2014), face several challenges, including blurry outputs, training instability, and limited text-video alignment. The emergence of DMs Ho et al. (2020); Dhariwal and Nichol (2021) addresses these limitations by achieving high-quality and diverse video generation through a gradual denoising process. Initially, these models employed U-Net architectures, which demonstrated impressive results in both image and video generation tasks Ramesh et al. (2022); Chen et al. (2024a); Wei et al. (2024). More recently, advancements in DiT-based architectures Peebles and Xie (2023); Bao et al. (2023) have further improved scalability and generalization over traditional U-Net-based DMs. The success of the Sora model Brooks et al. (2024), which utilizes the DiT architecture for long-form video generation, has led to a growing body of research adopting DiT as the noise estimation network Hatamizadeh et al. (2024); Wang et al. (2025); Li et al. (2025).

### 2.2 Diffusion Model Acceleration

Despite the remarkable performance of DMs, their high inference costs limit their applicability in real-world applications. Existing acceleration techniques for DMs can generally be categorized into two groups. The first category relies on architectural changes, such as distillation simplifies networks Kang et al. (2024); Zhou et al. (2024); Salimans et al. (2024), pruning removes redundant parameters Yang et al. (2024); Zhang et al. (2024a); Castells et al. (2024), quantization reduces precision Wang et al. (2024); Chu et al. (2024); Huang et al. (2024a), and others. However, these approaches often require additional resources for fine-tuning or optimization. The second group consists of training-free methods that accelerate inference by caching intermediate features of diffusion models. DeepCache Ma et al. (2023) accelerates diffusion models by caching high-level features from sequential denoising timesteps. T-GATE Zhang et al. (2024b) enhances image generation efficiency by caching attention outputs. PAB Zhao et al. (2024a) leverages a U-shaped attention redundancy pattern to significantly accelerate the diffusion process. AdaCache Kahatapitiya et al. (2024) accelerates video generation by selectively caching computations based on video content. TeaCache Liu et al. (2024) utilizes timestep embeddings to dynamically determine which computations to cache to accelerate inference. Although these training-free methods enhance diffusion efficiency, they still face significant challenges in balancing generation quality with computational cost.

## 3 Methodology

### 3.1 Preliminaries

Denoising Diffusion Models. Consider the data $\mathbf{x}_{0}\sim q(\mathbf{x})$ sampled from a real distribution. The forward diffusion process incrementally adds Gaussian noise over $T$ steps, producing a sequence $\mathbf{x}_{1},\dots,\mathbf{x}_{T}$. As $t$ increases, $\mathbf{x}_{t}$ progressively loses distinguishable features, asymptotically approaching an isotropic Gaussian distribution when $T\to\infty$. With the Markov chain assumption, it is expressed as:

$$ $\displaystyle q(\mathbf{x}_{t}\!\mid\!\mathbf{x}_{t-1})$ $\displaystyle=\mathcal{N}(\mathbf{x}_{t};\,\sqrt{1-\beta_{t}}\,\mathbf{x}_{t-1},\,\beta_{t}I),$ (1) $$

where $q(\mathbf{x}_{t}|\mathbf{x}_{t-1})$ is the posterior probability. The step sizes are controlled by a noise schedule $\mathbf{\beta}_{1},\dots,\mathbf{\beta}_{T}$. The reverse process samples from $q(\mathbf{x}_{t-1}|\mathbf{x}_{t})$ to reconstruct data from noise $\mathbf{x}_{T}\sim\mathcal{N}(\mathbf{0},\mathbf{I})$. Similarly, the backward diffusion process can be written as:

$$ $\displaystyle p_{\theta}(\mathbf{x}_{t-1}\!\mid\!\mathbf{x}_{t})$ $\displaystyle=\mathcal{N}(\mathbf{x}_{t-1};\,\mu_{\theta}(\mathbf{x}_{t},t),\,\Sigma_{\theta}(\mathbf{x}_{t},t)),$ (2) $$

where $\mu_{\theta}$ and $\Sigma_{\theta}$ are learned parameters defining the mean and covariance, and $p_{\theta}(.)$ denotes the probability of observing $\mathbf{x}_{t-1}$ given $\mathbf{x}_{t}$.

DiT Block. The Spatial-Temporal DiT (ST-DiT) block Ho et al. (2022) follows the two-stage Transformer design to modulate the dynamics of diffusion features across both space and time. Each denoising step involves sequential processing through $N$ consecutive DiT blocks. For the $i$-th DiT block ($i\in[1,N]$) in timestep $t$, given an input hidden state $h_{i}$, the block first performs Adaptive Layer Normalization (AdaLN) Xu et al. (2019) followed by multi-head self-attention:

$$ $\displaystyle h^{\prime}_{t,i}=\mathrm{Attention}(\mathrm{AdaLN}(h_{t,i}))+h_{t,i},$ (3) $$

where the residual connection preserves input information. A subsequent AdaLN-modulated MLP enhances feature expression:

$$ $\displaystyle h^{\prime\prime}_{t,i}=\mathrm{MLP}(\mathrm{AdaLN}(h^{\prime}_{t,i}))+h^{\prime}_{t,i}.$ (4) $$

The output hidden state $h^{\prime\prime}_{t,i}$ then becomes the input to the next DiT block (e.g., $h_{t,i+1}=h^{\prime\prime}_{t,i}$).

### 3.2 Analysis

Costs of Diffusion Models.
The video generation process using DMs comprises multiple computational components, including the DiT blocks, timestep and text embeddings, VAE, and others. Figure [3](https://arxiv.org/html/2509.13789v2#S1.F3)([3(f)](https://arxiv.org/html/2509.13789v2#S1.F3.sf6)) shows the time distribution for each part of the video generation process. As illustrated, the DiT blocks require considerably more computation time than the other components. Furthermore, this proportion increases further as the video length and resolution grow, posing a substantial challenge to the efficiency of video generation.

Block Feature Variation.
To better understand the internal behavior of DiT blocks during video generation, we introduce the relative L1 distance Liu et al. (2024) to measure the feature variations of each block between adjacent timesteps. For the $i$-th block at the $t$-th step, the block-wise relative L1 distance is calculated as follows:

$$ $\displaystyle\mathrm{L1}_{\mathrm{rel}}(h_{i},t)=\frac{\lVert h_{t,i}-h_{t+1,i}\rVert_{1}}{\lVert h_{t+1,i}\rVert_{1}}.$ (5) $$

A smaller $\mathrm{L1}_{\mathrm{rel}}$ value indicates minimal feature variation within the block between adjacent timesteps, while a larger value shows significant changes. In Figures [3](https://arxiv.org/html/2509.13789v2#S1.F3)([3(b)](https://arxiv.org/html/2509.13789v2#S1.F3.sf2)) and ([3(b)](https://arxiv.org/html/2509.13789v2#S1.F3.sf2)), we present two videos generated from different prompts. The video generated with Prompt 1 depicts a relatively static scene, whereas the video generated with Prompt 2 exhibits more dynamic content (e.g., a bus moving closer from a distance). To quantify the changes in block features during the generation process for both videos, we employ heatmaps, as shown in Figures [3](https://arxiv.org/html/2509.13789v2#S1.F3)([3(d)](https://arxiv.org/html/2509.13789v2#S1.F3.sf4)) and ([3(d)](https://arxiv.org/html/2509.13789v2#S1.F3.sf4)).
In these heatmaps, the color intensity reflects the relative degree of blokc feature variation at different timesteps, with darker regions indicating greater differences. From the figures, we observe two key insights: 1) the colors are darker in the initial and final timesteps, indicating that block features change across timesteps; 2) compared to Figure [3](https://arxiv.org/html/2509.13789v2#S1.F3)([3(d)](https://arxiv.org/html/2509.13789v2#S1.F3.sf4)), the darker regions in Figure [3](https://arxiv.org/html/2509.13789v2#S1.F3)([3(d)](https://arxiv.org/html/2509.13789v2#S1.F3.sf4)) occupy a smaller proportion, suggesting that different prompts exert varying influences on the features of the blocks.

Similarity and Diversity.
To gain a more intuitive understanding of the changes in block feature at different timesteps, we aggregate the block-level feature differences within each timestep and define the aggregated relative L1 distance. The equation is as follows:

$$ $\displaystyle\mathrm{ARL1}(t)=\sum_{n=1}^{N}\mathrm{L1}_{\mathrm{rel}}(h_{i},t),$ (6) $$

where $N$ is the total number of DiT blocks. $\mathrm{ARL1}(t)$ quantifies the feature change at a given diffusion step $t$ by summing the relative L1 distances across all blocks.

Figure [3](https://arxiv.org/html/2509.13789v2#S1.F3)([3(f)](https://arxiv.org/html/2509.13789v2#S1.F3.sf6)) illustrates the aggregated relative L1 distance for two prompts. Generally, the differences in block features between adjacent diffusion timesteps exhibit a U-shaped pattern. In the early timesteps, the L1 distance is high, indicating rapid changes in noise predictions. The middle timesteps gradually stabilize, showing considerable redundancy in block calculations. While in the final timesteps, the aggregated L1 distance increases, suggesting a transition from structured noise to high-fidelity video. Notably, for simpler or more static scenes, the feature variations among blocks stay minimal, explaining why Prompt 1 exhibits a longer duration of stable timesteps compared to Prompt 2.

### 3.3 BWCache

As illustrated in Figure [3](https://arxiv.org/html/2509.13789v2#S1.F3), intermediate stages of video generation frequently exhibit redundant block computations. To minimize computational redundancy and accelerate inference, we propose Block-Wise Caching (BWCache). Instead of computing each DiT block at every timestep, we selectively reuse block features cached from the previous timestep. We employ the average of the accumulated relative L1 distance as a similarity indicator to determine when to reuse the cached blocks:

$$ $\displaystyle\sum_{n=1}^{N}\mathrm{L1}_{\mathrm{rel}}(h_{i},t)/N<\delta,$ (7) $$

where $\mathrm{L1}_{\mathrm{rel}}$ is defined in Eq.([5](https://arxiv.org/html/2509.13789v2#S3.E5)), and $\delta$ is the similarity threshold. Specifically, at each timestep, we calculate the relative L1 distance between each DiT block and its counterpart from the preceding timestep. After each timestep, we cache all block features and calculate the arithmetic mean of their relative L1 distances. If this mean is less than the indicator threshold $\delta$, block computations can be skipped for subsequent timesteps starting from $t-1$, allowing the reuse of cached features; otherwise, the block will be recomputed. A smaller threshold $\delta$ reduces cache reuse, while a larger threshold speeds up video generation, but may adversely affect video quality. The appropriate threshold $\delta$ should be chosen to optimize inference speed without compromising visual quality.

Reusing DiT blocks in the final diffusion timesteps significantly degrades visual fidelity, as these timesteps represent the critical phase where the latent space transitions from structured noise to a high-quality video.
Once BWCache is triggered at the $k$-th step, caching reuse is restricted to the first half of the remaining steps, while the second half is explicitly computed. Therefore, the last $k/2$ steps are always recomputed, ensuring thorough refinement during the most sensitive stage of generation.

**Table 1: Comparison of visual quality and efficiency on a single GPU. Video generation specifications: Open-Sora (51 frames, 480P), Open-Sora-Plan (65 frames, 512$\times$512), Latte (16 frames, 512$\times$512). LPIPS, SSIM, and PSNR are calculated against the original model results.**
| Model | Method | Visual Quality | Efficiency |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| VBench$\uparrow$ | LPIPS$\downarrow$ | SSIM$\uparrow$ | PSNR$\uparrow$ | FLOPs (P)$\downarrow$ | Speedup$\uparrow$ | Latency(s)$\downarrow$ |  |  |
| Open-Sora | Original | 80.33% | - | - | - | 3.15 | 1$\times$ | 44.56 |
| $\Delta$-DiT | 78.21% | 0.5692 | 0.4811 | 11.91 | 3.09 | 1.03$\times$ | 43.26 |  |
| T-GATE | 77.61% | 0.3495 | 0.6760 | 15.50 | 2.75 | 1.19$\times$ | 37.45 |  |
| PAB | 78.10% | 0.2134 | 0.7798 | 22.02 | 2.55 | 1.38$\times$ | 32.38 |  |
| TeaCache | 79.16% | 0.1496 | 0.8104 | 22.39 | 2.40 | 1.50$\times$ | 29.64 |  |
| BWCache | 80.03% | 0.0879 | 0.8854 | 27.05 | 2.32 | 1.61$\times$ | 27.68 |  |
| Open-Sora-<br>Plan | Original | 80.88% | - | - | - | 11.75 | 1$\times$ | 99.65 |
| $\Delta$-DiT | 77.55% | 0.5388 | 0.3736 | 13.85 | 11.74 | 1.01$\times$ | 98.66 |  |
| T-GATE | 80.15% | 0.3066 | 0.6219 | 18.80 | 9.88 | 1.18$\times$ | 84.45 |  |
| PAB | 80.30% | 0.2781 | 0.6627 | 19.49 | 8.69 | 1.36$\times$ | 73.41 |  |
| TeaCache | 80.32% | 0.1965 | 0.7502 | 21.50 | 3.13 | 4.41$\times$ | 22.62 |  |
| BWCache | 80.82% | 0.1001 | 0.8435 | 25.87 | 6.30 | 2.24$\times$ | 44.49 |  |
| Latte | Original | 78.95% | - | - | - | 3.36 | 1$\times$ | 26.90 |
| $\Delta$-DiT | 52.00% | 0.8513 | 0.1078 | 8.65 | 3.36 | 1.02$\times$ | 26.37 |  |
| T-GATE | 75.42% | 0.2612 | 0.6927 | 19.55 | 2.99 | 1.13$\times$ | 23.81 |  |
| PAB | 76.32% | 0.4625 | 0.5964 | 17.03 | 2.70 | 1.21$\times$ | 22.16 |  |
| TeaCache | 77.40% | 0.1969 | 0.7606 | 22.19 | 1.86 | 1.86 $\times$ | 14.46 |  |
| BWCache | 78.28% | 0.1399 | 0.8181 | 26.46 | 1.77 | 1.90$\times$ | 14.16 |  |

Figure: Figure 4: Comparison of visual quality and efficiency (denoted by latency) with the compared method. BWCache outperforms PAB and TeaCache in both visual quality and efficiency.
Refer to caption: x12.png

### 3.4 Periodic Cache Recomputation

Continuously reusing the same block may result in latent drift and gradually erase fine-grained details Liu et al. (2025b). To prevent this cache stagnation, we adopt the progressive computation strategy from PAB Zhao et al. (2024a): within the caching interval, each DiT block is periodically recomputed at a defined reuse interval $R$. Specifically, after computing the block at time step $t$, its features are cached and reused for the subsequent $R$ steps (i.e., $[t-1,t-R]$), and the block is then updated at step $t-R-1$. This process is formalized as:

$$ $\displaystyle\mathcal{O}_{H}=\{\ldots,\underbrace{h^{\prime\prime}_{t},}_{\text{cached}}\underbrace{h^{\prime\prime}_{t},\ldots,h^{\prime\prime}_{t},}_{\text{reuse }R\text{ steps}}\underbrace{h^{\prime\prime}_{t-R-1},}_{\text{cached}}\ldots\},$ (8) $$

where $\mathcal{O}_{H}$ denotes the output of the DiT block across all steps, and $h^{\prime\prime}_{t}$ represents the DiT block output calculated at step $t$, which can be determined using Eq.([4](https://arxiv.org/html/2509.13789v2#S3.E4)).

## 4 Experimental Results

### 4.1 Experiment Setup

Base Models and Compared Methods.
We apply the proposed acceleration techniques to various video generation diffusion models, including Open-Sora Zheng et al. (2024), Open-Sora-Plan Lin et al. (2024), and Latte Ma et al. (2025). We compare our method with recent effective video generation techniques such as PAB Zhao et al. (2024a), T-GATE Zhang et al. (2024b), $\Delta$-DiT Chen et al. (2024b), and TeaCache Liu et al. (2024) to highlight our advantages.
The inference config of base models in Appendix 1.

Evaluation Metrics and Datasets.
To evaluate the performance of video generation acceleration methods, we primarily focus on two aspects: visual quality and inference efficiency. We utilize VBench Huang et al. (2024b), LPIPS Zhang et al. (2018), PSNR, and SSIM Wang and Bovik (2002) for visual quality assessment. VBench is a comprehensive benchmarking suite for video generation models. LPIPS, PSNR, and SSIM measure the similarity between videos generated by the accelerated methods and the original models. Several evaluation metrics are detailed in Appendix 2. To assess inference efficiency, we use Floating Point Operations (FLOPs) and inference latency as metrics. In our main experiments, we generate over 1,000 videos for each model under each baseline using prompts sourced from Open-Sora gallery Lin et al. (2024), VBench benchmark Huang et al. (2024b), and T2V-CompBench Sun et al. (2024).

Implementation Details.
All experiments are conducted on NVIDIA A800 80GB GPUs using PyTorch. FlashAttention Dao et al. (2022) is enabled by default across all experiments. Unless otherwise specified, ablation studies and qualitative analyses generate 51 frames, 480P videos in 30 steps. $\delta$ is set to 0.15 and reuse interval $R$ is set to 10% of total timesteps by default.

Figure: (a) 51 frames, 480P
Refer to caption: x13.png

Figure: Figure 6: Visualization for the block reuse rate at each step.
Refer to caption: x19.png

### 4.2 Main Results

Quantitative Comparison.
The experimental results in Table [1](https://arxiv.org/html/2509.13789v2#S3.T1) demonstrate the effectiveness of BWCache across multiple DiT-based video generation models. Our proposed BWCache outperforms existing optimization methods in both visual quality and efficiency. For instance, on Open-Sora, BWCache achieves advanced visual metrics while reducing latency by 1.61$\times$ compared to the original model. Notably, BWCache surpasses the training-free TeaCache method and maintains competitive acceleration performance. The block-wise method of BWCache leverages DiT block redundancies more effectively without sacrificing visual details. The timestep-level caching of TeaCache is less adaptive to intra-timestep variations, leading to higher quality degradation. It is worth noting that TeaCache achieves faster acceleration than BWCache on the Open-Sora-Plan model. This is because there is significant variation in block features during the early inference stages of the Open-Sora-Plan model, and TeaCache focuses solely on input features while neglecting this variation. This aggressive acceleration strategy results in its generation quality lagging far behind that of BWCache. More experiments can be found in Appendix 3.

Visual Quality Comparison.
As shown in Figure [4](https://arxiv.org/html/2509.13789v2#S3.F4), we visualize the videos generated by our method compared to the original model, PAB, and TeaCache. The results demonstrate that BWCache outperforms other methods in visual quality with lower latency. More visual results are illustrated in Appendix 4.

### 4.3 Scaling Abilities

Scaling to Multiple GPUs.
Table [2](https://arxiv.org/html/2509.13789v2#S4.T2) summarizes the inference efficiency of various methods when scaled across multiple GPUs using Dynamic Sequence Parallelism (DSP) Zhao et al. (2024b). The experiments, conducted using several models, reveal that BWCache consistently outperforms both the original model and PAB in terms of latency reduction across all tested scenarios. Specifically, BWCache achieves the lowest latencies, demonstrating significant speed-ups as the number of GPUs increases. These results validate BWCache as a universally effective acceleration method for DiT-based models under multi-GPU deployments.

**Table 2: Inference efficiency when scaling to multiple GPUs with DSP.**
| Method | 1 $\times$ A800 | 2 $\times$ A800 | 4 $\times$ A800 | 8 $\times$ A800 |
| --- | --- | --- | --- | --- |
| Open-Sora (204 frames, 480P) |  |  |  |  |
| original | 190.2(1$\times$) | 71.3(2.7$\times$) | 37.7(5.1$\times$) | 24.1(7.9$\times$) |
| PAB | 150.7(1.2$\times$) | 55.3(3.3$\times$) | 29.8(6.1$\times$) | 19.8(9.1$\times$) |
| Ours | 78.1(2.4$\times$) | 30.3(6.3$\times$) | 16.9(11.3$\times$) | 11.1(17.2$\times$) |
| Open-Sora-Plan (221 frames, 512$\times$512) |  |  |  |  |
| original | 284.3(1$\times$) | 154.3(1.8$\times$) | 81.2(3.5$\times$) | 47.1(6.0$\times$) |
| PAB | 211.4(1.3$\times$) | 112.5(2.5$\times$) | 60.0(4.7$\times$) | 34.9(8.1$\times$) |
| Ours | 109.1(2.6$\times$) | 60.0(4.7$\times$) | 32.8(8.7$\times$) | 21.4(13.3$\times$) |
| Latte (16 frames, 512$\times$512) |  |  |  |  |
| original | 25.9(1$\times$) | 15.1(1.7$\times$) | 9.3(2.8$\times$) | 8.9(2.9$\times$) |
| PAB | 21.0(1.2$\times$) | 12.2(2.1$\times$) | 8.3(3.1$\times$) | 7.9(4.0$\times$) |
| Ours | 14.4(1.8$\times$) | 7.3(3.6$\times$) | 4.5(5.8$\times$) | 4.0(6.5$\times$) |

Performance at Different Length and Resolution.
Figure [5](https://arxiv.org/html/2509.13789v2#S4.F5) demonstrates the inference efficiency of BWCache across various video lengths and resolutions using the Open-Sora model. The results show that latency increases significantly as the length and resolution of the video increased, but BWCache consistently performs better than the original model in all configurations. BWCache exhibits particularly notable acceleration advantages in processing high-resolution long videos. For example, with eight GPUs, BWCache attains a latency of just 11.08 seconds for the Open-Sora model with 204 frames at 480P, representing a remarkable 17.16$\times$ speed-up compared to the base model. This trend is also reflected in other configurations, where BWCache consistently provides substantial improvements in efficiency. Overall, these results validate its capability to improve inference speeds across various video lengths and resolutions, making it an efficient solution for real-time video generation.

### 4.4 Ablation Studies

Quality-Efficiency Trade-Off.
Figure [1](https://arxiv.org/html/2509.13789v2#S0.F1) compares the quality-latency trade-off of BWCache, PAB, and TeaCache. The indicator threshold $\delta$ in Eq.([7](https://arxiv.org/html/2509.13789v2#S3.E7)) is 0.15, 0.20, and 0.25. The results clearly demonstrate that BWCache outperforms PAB and TeaCache in visual quality across all evaluated metrics, indicating a notable improvement in the fidelity of video generation. For each metric, BWCache not only achieves higher quality scores but also does so while maintaining lower latency, which reflects its efficient processing capabilities. Overall, BWCache achieves improved visual quality at lower latency than PAB and TeaCache.

**Table 3: Impact of different reuse rates.**
| Threshold | Reuse Rate | VBench$\uparrow$ | LPIPS$\downarrow$ | SSIM$\uparrow$ | PSNR$\uparrow$ |
| --- | --- | --- | --- | --- | --- |
| 0.25(Fast) | 59.00% | 79.03% | 0.1935 | 0.7829 | 21.39 |
| 0.20(Mid) | 53.05% | 79.42% | 0.1486 | 0.8267 | 23.45 |
| 0.15(Slow) | 41.38% | 80.03% | 0.0879 | 0.8854 | 27.05 |

Reuse Rate.
Table [3](https://arxiv.org/html/2509.13789v2#S4.T3) illustrates how varying the reuse rates affects performance. It reveals that the “Fast" configuration achieves the highest reuse rate at 59.00%, resulting in the lowest latency of 19.16 seconds. The “Slow" configuration only had a reuse rate of 41.38%, but the visual quality is the highest among all configurations.

Visualized results in Figure [6](https://arxiv.org/html/2509.13789v2#S4.F6) complement these findings by providing the reuse rates of blocks across each timestep for various thresholds. This figure illustrates the dynamic nature of block reuse at different timesteps, with evident fluctuations that suggest varying block reuse efficiency at different stages of video generation. In general, the block features in the middle stage of the generation change less, and a high reuse rate is obtained, which is consistent with our previous analysis.

**Table 4: Impact of different reuse intervals.**
| Interval | Latency(s)$\downarrow$ | VBench$\uparrow$ | LPIPS$\downarrow$ | SSIM$\uparrow$ | PSNR$\uparrow$ |
| --- | --- | --- | --- | --- | --- |
| 5% | 34.70 | 80.28% | 0.0451 | 0.9250 | 30.72 |
| 10% | 27.68 | 80.03% | 0.0879 | 0.8854 | 27.05 |
| 15% | 27.33 | 79.84% | 0.1065 | 0.8709 | 26.13 |
| 20% | 25.97 | 79.48% | 0.1415 | 0.8465 | 24.82 |
| 25% | 25.76 | 79.31% | 0.1567 | 0.8360 | 24.32 |

Reuse Interval. Table [4](https://arxiv.org/html/2509.13789v2#S4.T4) outlines various reuse intervals, ranging from 5% to 25% of all timesteps, and details their corresponding latency and quality metrics. As the reuse interval increases, the latency decreases, indicating enhanced generating efficiency. Conversely, while the latency improves with increased reuse interval, there is a slight degradation in quality metrics. For instance, VBench scores range from 80.28% at 5% to 79.31% at 25%, indicating a gradual decline in fidelity. This demonstrates a trade-off between latency and visual quality, where longer reuse intervals can effectively accelerate generation but may destroy the details in the output.

## 5 Conclusion

In this paper, we introduced BWCache, a novel caching method designed to accelerate video Diffusion Transformers. By analyzing feature dynamics in Spatial-Temporal DiT blocks, we established that block features across timesteps had significant computational redundancy. BWCache addressed this by employing dynamic block-wise caching and a similarity indicator, which selectively reused block features when their differences fell below a predefined threshold. Periodic recomputation was employed to mitigate potential latent drift. Extensive experiments demonstrated that BWCache achieved robust efficiency and visual quality across diverse generation models, sampling schedules, and video parameters. These results highlighted its potential for real-world applications. The current indicator threshold was preset, and future work will dynamically adjust the threshold according to different generation tasks.

## References

- Song and Ermon [2019]
Yang Song and Stefano Ermon.
Generative modeling by estimating gradients of the data distribution.
In *Advances in Neural Information Processing Systems
(NeurIPS)*, volume 32, 2019.
- Ho et al. [2020]
Jonathan Ho, Ajay Jain, and Pieter Abbeel.
Denoising diffusion probabilistic models.
In *Advances in Neural Information Processing Systems
(NeurIPS)*, volume 33, pages 6840–6851, 2020.
- Dhariwal and Nichol [2021]
Prafulla Dhariwal and Alexander Nichol.
Diffusion models beat gans on image synthesis.
In *Advances in Neural Information Processing Systems
(NeurIPS)*, volume 34, pages 8780–8794, 2021.
- Rombach et al. [2022]
Robin Rombach, Andreas Blattmann, Dominik Lorenz, Patrick Esser, and Björn
Ommer.
High-resolution image synthesis with latent diffusion models.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition (CVPR)*, pages 10684–10695, 2022.
- Ronneberger et al. [2015]
Olaf Ronneberger, Philipp Fischer, and Thomas Brox.
U-net: Convolutional networks for biomedical image segmentation.
In *International Conference on Medical image computing and
computer-assisted intervention*, pages 234–241. Springer, 2015.
- Ramesh et al. [2022]
Aditya Ramesh, Prafulla Dhariwal, Alex Nichol, Casey Chu, and Mark Chen.
Hierarchical text-conditional image generation with clip latents.
*arXiv preprint arXiv:2204.06125*, 1(2):3,
2022.
- Saharia et al. [2022]
Chitwan Saharia, William Chan, Saurabh Saxena, Lala Li, Jay Whang, Emily L
Denton, Kamyar Ghasemipour, Raphael Gontijo Lopes, Burcu Karagol Ayan, Tim
Salimans, et al.
Photorealistic text-to-image diffusion models with deep language
understanding.
In *Advances in Neural Information Processing Systems
(NeurIPS)*, volume 35, pages 36479–36494, 2022.
- Blattmann et al. [2023]
Andreas Blattmann, Tim Dockhorn, Sumith Kulal, Daniel Mendelevitch, Maciej
Kilian, Dominik Lorenz, Yam Levi, Zion English, Vikram Voleti, Adam Letts,
et al.
Stable video diffusion: Scaling latent video diffusion models to
large datasets.
*arXiv preprint arXiv:2311.15127*, 2023.
- Brooks et al. [2024]
Tim Brooks, Bill Peebles, Connor Holmes, Will DePue, Yufei Guo, Li Jing, David
Schnurr, Joe Taylor, Troy Luhman, Eric Luhman, Clarence Ng, Ricky Wang, and
Aditya Ramesh.
Video generation models as world simulators, 2024.
- Peebles and Xie [2023]
William Peebles and Saining Xie.
Scalable diffusion models with transformers.
In *Proceedings of the IEEE/CVF International Conference on
Computer Vision (ICCV)*, pages 4195–4205, 2023.
- Bao et al. [2023]
Fan Bao, Shen Nie, Kaiwen Xue, Yue Cao, Chongxuan Li, Hang Su, and Jun Zhu.
All are worth words: A vit backbone for diffusion models.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition (CVPR)*, pages 22669–22679, 2023.
- Ho et al. [2022]
Jonathan Ho, Tim Salimans, Alexey Gritsenko, William Chan, Mohammad Norouzi,
and David J Fleet.
Video diffusion models.
In *Advances in Neural Information Processing Systems
(NeurIPS)*, volume 35, pages 8633–8646, 2022.
- Wang et al. [2024]
Changyuan Wang, Ziwei Wang, Xiuwei Xu, Yansong Tang, Jie Zhou, and Jiwen Lu.
Towards accurate post-training quantization for diffusion models.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition (CVPR)*, pages 16026–16035, 2024.
- Chu et al. [2024]
Huanpeng Chu, Wei Wu, Chengjie Zang, and Kun Yuan.
Qncd: Quantization noise correction for diffusion models.
In *Proceedings of the ACM International Conference on
Multimedia (ACM MM)*, pages 10995–11003, 2024.
- Yang et al. [2024]
Tianyun Yang, Juan Cao, and Chang Xu.
Pruning for robust concept erasing in diffusion models.
*arXiv preprint arXiv:2405.16534*, 2024.
- Zhang et al. [2024a]
Dingkun Zhang, Sijia Li, Chen Chen, Qingsong Xie, and Haonan Lu.
Laptop-diff: Layer pruning and normalized distillation for
compressing diffusion models.
*arXiv preprint arXiv:2404.11098*, 2024a.
- Kang et al. [2024]
Minguk Kang, Richard Zhang, Connelly Barnes, Sylvain Paris, Suha Kwak, Jaesik
Park, Eli Shechtman, Jun-Yan Zhu, and Taesung Park.
Distilling diffusion models into conditional gans.
In *Proceedings of the European Conference on Computer Vision
(ECCV)*, pages 428–447, 2024.
- Zhou et al. [2024]
Zhenyu Zhou, Defang Chen, Can Wang, Chun Chen, and Siwei Lyu.
Simple and fast distillation of diffusion models.
In *Advances in Neural Information Processing Systems
(NeurIPS)*, volume 37, pages 40831–40860, 2024.
- Ma et al. [2023]
Xinyin Ma, Gongfan Fang, and Xinchao Wang.
Deepcache: Accelerating diffusion models for free.
*arXiv preprint arXiv:2312.00858*, 2023.
- Zhang et al. [2024b]
Wentian Zhang, Haozhe Liu, Jinheng Xie, Francesco Faccio, Mike Zheng Shou, and
Jürgen Schmidhuber.
Cross-attention makes inference cumbersome in text-to-image diffusion
models.
*arXiv preprint arXiv:2404.02747v1*, 2024b.
- Zhao et al. [2024a]
Xuanlei Zhao, Xiaolong Jin, Kai Wang, and Yang You.
Real-time video generation with pyramid attention broadcast.
*arXiv preprint arXiv:2408.12588*, 2024a.
- Kahatapitiya et al. [2024]
Kumara Kahatapitiya, Haozhe Liu, Sen He, Ding Liu, Menglin Jia, Chenyang Zhang,
Michael S. Ryoo, and Tian Xie.
Adaptive caching for faster video generation with diffusion
transformers.
*arXiv preprint arXiv:2411.02397*, 2024.
- Liu et al. [2024]
Feng Liu, Shiwei Zhang, Xiaofeng Wang, Yujie Wei, Haonan Qiu, Yuzhong Zhao,
Yingya Zhang, Qixiang Ye, and Fang Wan.
Timestep embedding tells: It’s time to cache for video diffusion
model.
*arXiv preprint arXiv:2411.19108*, 2024.
- Lv et al. [2024]
Zhengyao Lv, Chenyang Si, Junhao Song, Zhenyu Yang, Yu Qiao, Ziwei Liu, and
Kwan-Yee K Wong.
Fastercache: Training-free video diffusion model acceleration with
high quality.
*arXiv preprint arXiv:2410.19355*, 2024.
- Yuan et al. [2024]
Zhihang Yuan, Hanling Zhang, Lu Pu, Xuefei Ning, Linfeng Zhang, Tianchen Zhao,
Shengen Yan, Guohao Dai, and Yu Wang.
Ditfastattn: Attention compression for diffusion transformer models.
In *Advances in Neural Information Processing Systems
(NeurIPS)*, volume 37, pages 1196–1219, 2024.
- Zhang et al. [2025]
Hanling Zhang, Rundong Su, Zhihang Yuan, Pengtao Chen, Mingzhu Shen Yibo Fan,
Shengen Yan, Guohao Dai, and Yu Wang.
Ditfastattnv2: Head-wise attention compression for multi-modality
diffusion transformers.
*arXiv preprint arXiv:2503.22796*, 2025.
- Wimbauer et al. [2024]
Felix Wimbauer, Bichen Wu, Edgar Schoenfeld, Xiaoliang Dai, Ji Hou, Zijian He,
Artsiom Sanakoyeu, Peizhao Zhang, Sam Tsai, Jonas Kohler, et al.
Cache me if you can: Accelerating diffusion models through block
caching.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition (CVPR)*, pages 6211–6220, 2024.
- Selvaraju et al. [2024]
Pratheba Selvaraju, Tianyu Ding, Tianyi Chen, Ilya Zharkov, and Luming Liang.
Fora: Fast-forward caching in diffusion transformer acceleration.
*arXiv preprint arXiv:2407.01425*, 2024.
- Liu et al. [2025a]
Joseph Liu, Joshua Geddes, Ziyu Guo, Haomiao Jiang, and Mahesh Kumar Nandwana.
Smoothcache: A universal inference acceleration technique for
diffusion transformers.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition (CVPR)*, pages 3229–3238, 2025a.
- Zheng et al. [2024]
Zangwei Zheng, Xiangyu Peng, Tianji Yang, Chenhui Shen, Shenggui Li, Hongxin
Liu, Yukun Zhou, Tianyi Li, and Yang You.
Open-sora: Democratizing efficient video production for all.
*arXiv preprint arXiv:2412.20404*, 2024.
- Lin et al. [2024]
Bin Lin, Yunyang Ge, Xinhua Cheng, Zongjian Li, Bin Zhu, Shaodong Wang, Xianyi
He, Yang Ye, Shenghai Yuan, Liuhan Chen, et al.
Open-sora plan: Open-source large video generation model.
*arXiv preprint arXiv:2412.00131*, 2024.
- Ma et al. [2025]
Xin Ma, Yaohui Wang, Xinyuan Chen, Gengyun Jia, Ziwei Liu, Yuan-Fang Li,
Cunjian Chen, and Yu Qiao.
Latte: Latent diffusion transformer for video generation.
*Transactions on Machine Learning Research*, 2025.
- Kingma et al. [2013]
Diederik P Kingma, Max Welling, et al.
*Auto-encoding variational bayes*.
Banff, Canada, 2013.
- Goodfellow et al. [2014]
Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley,
Sherjil Ozair, Aaron Courville, and Yoshua Bengio.
Generative adversarial nets.
In *Advances in Neural Information Processing Systems
(NeurIPS)*, volume 27, 2014.
- Chen et al. [2024a]
Haoxin Chen, Yong Zhang, Xiaodong Cun, Menghan Xia, Xintao Wang, Chao Weng, and
Ying Shan.
Videocrafter2: Overcoming data limitations for high-quality video
diffusion models.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition (CVPR)*, pages 7310–7320, 2024a.
- Wei et al. [2024]
Yujie Wei, Shiwei Zhang, Zhiwu Qing, Hangjie Yuan, Zhiheng Liu, Yu Liu, Yingya
Zhang, Jingren Zhou, and Hongming Shan.
Dreamvideo: Composing your dream videos with customized subject and
motion.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition (CVPR)*, pages 6537–6549, 2024.
- Hatamizadeh et al. [2024]
Ali Hatamizadeh, Jiaming Song, Guilin Liu, Jan Kautz, and Arash Vahdat.
Diffit: Diffusion vision transformers for image generation.
In *Proceedings of the European Conference on Computer Vision
(ECCV)*, pages 37–55. Springer, 2024.
- Wang et al. [2025]
Yaohui Wang, Xinyuan Chen, Xin Ma, Shangchen Zhou, Ziqi Huang, Yi Wang, Ceyuan
Yang, Yinan He, Jiashuo Yu, Peiqing Yang, et al.
Lavie: High-quality video generation with cascaded latent diffusion
models.
*International Journal of Computer Vision*, 133:3059–3078, 2025.
- Li et al. [2025]
Zijie Li, Henry Li, Yichun Shi, Amir Barati Farimani, Yuval Kluger, Linjie
Yang, and Peng Wang.
Dual diffusion for unified image generation and understanding.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition (CVPR)*, pages 2779–2790, 2025.
- Salimans et al. [2024]
Tim Salimans, Thomas Mensink, Jonathan Heek, and Emiel Hoogeboom.
Multistep distillation of diffusion models via moment matching.
In *Advances in Neural Information Processing Systems
(NeurIPS)*, volume 37, pages 36046–36070, 2024.
- Castells et al. [2024]
Thibault Castells, Hyoung-Kyu Song, Bo-Kyeong Kim, and Shinkook Choi.
Ld-pruner: Efficient pruning of latent diffusion models using
task-agnostic insights.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition (CVPR)*, pages 821–830, 2024.
- Huang et al. [2024a]
Yushi Huang, Ruihao Gong, Jing Liu, Tianlong Chen, and Xianglong Liu.
Tfmq-dm: Temporal feature maintenance quantization for diffusion
models.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition (CVPR)*, pages 7362–7371, 2024a.
- Xu et al. [2019]
Jingjing Xu, Xu Sun, Zhiyuan Zhang, Guangxiang Zhao, and Junyang Lin.
Understanding and improving layer normalization.
In *Advances in Neural Information Processing Systems
(NeurIPS)*, volume 32, 2019.
- Liu et al. [2025b]
Dong Liu, Jiayi Zhang, Yifan Li, Yanxuan Yu, Ben Lengerich, and Ying Nian Wu.
Fastcache: Fast caching for diffusion transformer through learnable
linear approximation.
*arXiv preprint arXiv:2505.20353*, 2025b.
- Chen et al. [2024b]
Pengtao Chen, Mingzhu Shen, Peng Ye, Jianjian Cao, Chongjun Tu, Christos-Savvas
Bouganis, Yiren Zhao, and Tao Chen.
$delta$-dit: A training-free acceleration method tailored for
diffusion transformers.
*arXiv preprint arXiv:2406.01125*, 2024b.
- Huang et al. [2024b]
Ziqi Huang, Yinan He, Jiashuo Yu, Fan Zhang, Chenyang Si, Yuming Jiang, Yuanhan
Zhang, Tianxing Wu, Qingyang Jin, Nattapol Chanpaisit, Yaohui Wang, Xinyuan
Chen, Limin Wang, Dahua Lin, Yu Qiao, and Ziwei Liu.
VBench: Comprehensive benchmark suite for video generative models.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition (CVPR)*, 2024b.
- Zhang et al. [2018]
Richard Zhang, Phillip Isola, Alexei A Efros, Eli Shechtman, and Oliver Wang.
The unreasonable effectiveness of deep features as a perceptual
metric.
In *Proceedings of the IEEE/CVF Conference on Computer Vision
and Pattern Recognition (CVPR)*, 2018.
- Wang and Bovik [2002]
Zhou Wang and Alan C Bovik.
A universal image quality index.
*IEEE signal processing letters*, 9(3):81–84, 2002.
- Sun et al. [2024]
Kaiyue Sun, Kaiyi Huang, Xian Liu, Yue Wu, Zihan Xu, Zhenguo Li, and Xihui Liu.
T2v-compbench: A comprehensive benchmark for compositional
text-to-video generation.
*arXiv preprint arXiv:2407.14505*, 2024.
- Dao et al. [2022]
Tri Dao, Daniel Y. Fu, Stefano Ermon, Atri Rudra, and Christopher Ré.
FlashAttention: Fast and memory-efficient exact attention with
IO-awareness.
In *Advances in Neural Information Processing Systems
(NeurIPS)*, 2022.
- Zhao et al. [2024b]
Xuanlei Zhao, Shenggan Cheng, Chang Chen, Zangwei Zheng, Ziming Liu, Zheming
Yang, and Yang You.
Dsp: Dynamic sequence parallelism for multi-dimensional transformers.
*arXiv preprint arXiv:2403.10266*, 2024b.

## Appendix A Experimental Settings

Base Model. This paper focuses on DiT-based video generation, evaluating three state-of-the-art open-source models: Open-Sora Zheng et al. [2024], Open-Sora-Plan Lin et al. [2024], and Latte Ma et al. [2025]. Open-Sora employs Spatial-Temporal DiT Ho et al. [2022], allowing for the creation of videos up to 16 seconds long at 720p resolution. Open-Sora Plan focuses on generating high-resolution videos with extended durations based on diverse user inputs, featuring components like a Wavelet-Flow Variational Autoencoder and specialized denoisers. Latte effectively extracts spatio-temporal tokens from videos and utilizes DiT blocks to model the token distribution in a latent space. The inference configs of three models are shown in Table [5](https://arxiv.org/html/2509.13789v2#A1.T5), which strictly follow the official settings.

**Table 5: The inference config of base models.**
| Model | Scheduler | Steps | Text Encoder |
| --- | --- | --- | --- |
| Open-Sora | RFLOW | 30 | T5 |
| Open-Sora-Plan | PNDM | 150 | T5 |
| Latte | DDIM | 50 | T5 |

## Appendix B Metrics

Peak Signal-to-Noise Ratio (PSNR).
PSNR is a common metric used to measure the quality of reconstruction in lossy compression and signal processing. It compares the maximum possible power of a signal to the power of corrupting noise. Higher PSNR values indicate better quality. The PSNR is calculated as follows:

$$ $\displaystyle\mathrm{PSNR}=0\cdot\log_{10}\!\left(\frac{R^{2}}{\mathrm{MSE}}\right)$ (9) $$

where $R$ is the maximum possible pixel value of the image and MSE denotes the Mean Squared Error between the reference image and the reconstructed image.

Learned Perceptual Image Patch Similarity (LPIPS).
LPIPS Zhang et al. [2018] is a modern perceptual similarity metric that is based on deep learning. It quantifies the similarity between two images by comparing their features at different layers of a neural network. This metric is believed to better correlate with human visual perception than traditional metrics by capturing perceptually important features. The LPIPS score between two images $I$ and $K$ is typically computed as:

$$ $\displaystyle\text{LPIPS}(I,K)=\frac{1}{L}\sum_{l=1}^{L}\|\phi_{l}(I)-\phi_{l}(K)\|^{2}$ (10) $$

where $L$ is the number of layers in the pretrained neural network, and $\phi_{l}$ denotes the feature extraction at layer $l$. For video evaluation, LPIPS is calculated for each frame of the video and averaged across all frames to produce a final score.

Structural Similarity Index Measure (SSIM).
SSIM Wang and Bovik [2002] is a perceptual metric that assesses the visual impact of three characteristics: luminance, contrast, and structure. Instead of measuring pixel-wise differences, SSIM compares the structural information in the images, making it a more relevant measure of perceived quality. The SSIM index is calculated as follows:

$$ $\displaystyle SSIM(I,K)=\frac{(2\mu_{I}\mu_{K}+C_{1})(2\sigma_{IK}+C_{2})}{(\mu_{I}^{2}+\mu_{K}^{2}+C_{1})(\sigma_{I}^{2}+\sigma_{K}^{2}+C_{2})}$ (11) $$

where $\mu_{I}$ and $\mu_{K}$ are the average luminance of $I$ and $K$, $\sigma_{I}^{2}$ and $\sigma_{K}^{2}$ are the variances of $I$ and $K$, $\sigma_{IK}$ is the covariance between $I$ and $K$, $C_{1}$ and $C_{2}$ are constants used to stabilize the division with weak denominator. For video evaluation, SSIM is calculated for each frame and then averaged over all frames to provide an overall similarity measure.

**Table 6: VBench evaluation results per dimension.**
| Models | Subject<br>Consistency | Background<br>Consistency | Temporal<br>Flickering | Motion<br>Smoothness | Dynamic<br>Degree | Aesthetic<br>Quality | Imaging<br>Quality | Object<br>Class |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Original | 95.08% | 96.86% | 99.41% | 98.80% | 42.00% | 59.53% | 62.60% | 95.87% |
| PAB | 95.15% | 96.70% | 99.38% | 99.09% | 28.00% | 56.32% | 59.63% | 96.37% |
| TeaCache | 95.33% | 96.83% | 99.44% | 98.94% | 36.00% | 58.50% | 59.79% | 96.00% |
| BWCache | 95.91% | 96.76% | 99.43% | 98.97% | 38.00% | 59.26% | 61.29% | 98.25% |
| Empirical Min | 14.62% | 26.15% | 62.93% | 70.60% | 0.00% | 0.00% | 0.00% | 0.00% |
| Empirical Max | 100.00% | 100.00% | 100.00% | 99.75% | 100.00% | 100.00% | 100.00% | 100.00% |
| Models | Multiple<br>Objects | Human<br>Action | Color | Spatial<br>Relationship | Scene | Appearance<br>Style | Temporal<br>Style | Overall<br>Consistency |
| Original | 36.00% | 84.00% | 81.25% | 85.75% | 59.62% | 25.40% | 23.03% | 27.90% |
| PAB | 38.50% | 68.00% | 85.64% | 77.22% | 57.37% | 25.06% | 22.20% | 26.70% |
| TeaCache | 31.50% | 82.00% | 81.61% | 85.75% | 56.13% | 24.93% | 22.73% | 27.24% |
| BWCache | 36.25% | 84.00% | 82.58% | 86.52% | 59.25% | 25.27% | 22.74% | 27.91% |
| Empirical Min | 0.00% | 0.00% | 0.00% | 0.00% | 0.00% | 0.00% | 0.00% | 0.00% |
| Empirical Max | 100.00% | 100.00% | 100.00% | 100.00% | 82.22% | 28.55% | 36.40% | 36.40% |

Figure: Figure 7: Accelerate video generation by reducing inference steps and using caching respectively.
Refer to caption: x20.png

## Appendix C Additional Experimental Results

### C.1 Full Vbench Results.

VBench Huang et al. [2024b] is a comprehensive benchmark suite designed for evaluating video generative models. It provides a standardized framework that includes diverse evaluation metrics, datasets, and protocols to facilitate in-depth comparisons of model performance across various tasks. This systematic approach ensures reliable assessments of generated videos in terms of quality, efficiency, and robustness. Table [6](https://arxiv.org/html/2509.13789v2#A2.T6) compares the performance of four video generation methods across each of the 16 VBench dimensions. A higher score indicates relatively better performance for a particular dimension. We also provide two specially built baselines, i.e., Empirical Min and Max (the approximated achievable min and max scores for each dimension), as references.

**Table 7: Impact of different last steps.**
| Last Step | Latency(s)$\downarrow$ | Vbench$\uparrow$ | LPIPS$\downarrow$ | SSIM$\uparrow$ | PSNR$\uparrow$ |
| --- | --- | --- | --- | --- | --- |
| 1/3$k$ | 29.10 | 79.95% | 0.0922 | 0.8823 | 26.95 |
| 1/2$k$ | 27.68 | 80.03% | 0.0879 | 0.8854 | 27.05 |
| 2/3$k$ | 25.98 | 80.09% | 0.0853 | 0.8874 | 27.16 |
| 5 | 31.47 | 80.13% | 0.0877 | 0.8866 | 27.10 |
| 8 | 28.62 | 80.00% | 0.0862 | 0.8896 | 27.01 |

### C.2 Last Step

In the final stage of the DiT model for video generation, that is, during the last stage of denoising, the reuse of cached block features can introduce unnecessary biases and lead to a degradation in the generated video. Therefore, assuming that cache reuse is triggered at the $k$-th step during the denoising process, we default that the last 1/2$k$ steps do not involve cache and reuse operations. Meanwhile, we have statistically analyzed the results for the last 1/3$k$ and 2/3$k$ steps, as well as fixed 5 and 8 steps, as shown in Table [7](https://arxiv.org/html/2509.13789v2#A3.T7). It can be seen that the choice of the last steps has a significant impact on latency and video generation quality. Specifically, as the number of last steps increases, latency tends to decrease, while metrics exhibit fluctuations to some extent. In general, our default setting 1/2$k$ balances the generation quality and latency.

**Table 8: Caching mechanism v.s. inference steps.**
| Method | Latency(s)$\downarrow$ | LPIPS$\downarrow$ | SSIM$\uparrow$ | PSNR$\uparrow$ |
| --- | --- | --- | --- | --- |
| original, 19 steps | 29.20 | 0.3139 | 0.6922 | 16.39 |
| BWCache, 30 steps | 27.68 | 0.0879 | 0.8856 | 27.08 |

Figure: Figure 8: More visual results on Open-Sora (51 frames, 480P).
Refer to caption: x21.png

Figure: Figure 9: More visual results on Open-Sora-Plan (65 frames, 512$\times$512).
Refer to caption: x22.png

Figure: Figure 10: More visual results on Latte (16 frames, 512$\times$512).
Refer to caption: x23.png

**Table 9: Statistical comparison of the BWCache with compared methods.**
| Model | Method | Metrics | Mean | Standard Deviation | P-Value | Confidence Interval |
| --- | --- | --- | --- | --- | --- | --- |
| Open-Sora | PAB | LPIPS | 0.2134 | 0.1026 | 9.90e-111 | [0.2048, 0.2220] |
| SSIM | 0.7798 | 0.1084 | 8.99e-73 | [0.7707, 0.7888] |  |  |
| PSNR | 22.0191 | 2.8325 | 2.8e-135 | [21.7819, 22.2564] |  |  |
| TeaCache | LPIPS | 0.1496 | 0.0780 | 1.07e-46 | [0.1430, 0.1561] |  |
| SSIM | 0.8104 | 0.1034 | 1.09e-42 | [0.8017, 0.8190] |  |  |
| PSNR | 22.3929 | 4.3654 | 2.8e-80 | [22.0273, 22.7586] |  |  |
| BWCache | LPIPS | 0.0879 | 0.0561 | - | [0.0832, 0.0926] |  |
| SSIM | 0.8854 | 0.0665 | - | [0.8798, 0.8909] |  |  |
| PSNR | 27.0510 | 2.9898 | - | [26.8006, 27.3014] |  |  |
| Open-Sora-<br>Plan | PAB | LPIPS | 0.2781 | 0.1177 | 7.69e-51 | [0.2602, 0.2961] |
| SSIM | 0.6627 | 0.1449 | 7.16e-37 | [0.6407, 0.6848] |  |  |
| PSNR | 19.4968 | 3.6949 | 6.76e-42 | [18.9340, 20.0596] |  |  |
| TeaCache | LPIPS | 0.1965 | 0.0928 | 6.64e-27 | [0.1824, 0.2106] |  |
| SSIM | 0.7502 | 0.1090 | 4.95e-18 | [0.7336, 0.7668] |  |  |
| PSNR | 21.5010 | 3.5785 | 6.25e-24 | [20.9559, 22.0461] |  |  |
| BWCache | LPIPS | 0.1001 | 0.0520 | - | [0.0922, 0.1080] |  |
| SSIM | 0.8435 | 0.0743 | - | [0.8322, 0.8548] |  |  |
| PSNR | 25.8734 | 3.7611 | - | [25.3006, 26.4463] |  |  |
| Latte | PAB | LPIPS | 0.4625 | 0.1481 | 3.84e-218 | [0.4501, 0.4750] |
| SSIM | 0.5964 | 0.1631 | 3.88e-106 | [0.5827, 0.6100] |  |  |
| PSNR | 17.0299 | 2.2196 | 2.67e-189 | [16.8440, 17.2158] |  |  |
| TeaCache | LPIPS | 0.1969 | 0.1058 | 5.32e-17 | [0.1880, 0.2058] |  |
| SSIM | 0.7606 | 0.1329 | 2.39e-12 | [0.7495, 0.7718] |  |  |
| PSNR | 22.1947 | 4.3783 | 1.02e-40 | [21.8280, 22.5614] |  |  |
| BWCache | LPIPS | 0.1399 | 0.1160 | - | [0.1301, 0.1496] |  |
| SSIM | 0.8181 | 0.1357 | - | [0.8067, 0.8294] |  |  |
| PSNR | 26.4620 | 5.6981 | - | [25.9847, 26.9392] |  |  |

### C.3 Reducing Inference Steps

When generating videos using the DiT model, the impact of the inference steps must be considered. Although increasing the inference steps can enhance video quality, it clearly requires higher GPU usage and increases the generation latency. In this paper, the default setting for the inference steps in Open-Sora is 30. To accelerate video generation, the number of inference steps can be reduced. We compare the performance of the original model with reduced inference steps and BWCache in terms of visual quality and latency. The results show that, while producing similar latencies, BWCache maintains excellent visual quality, as shown in Figure [7](https://arxiv.org/html/2509.13789v2#A2.F7). Specific data on visual quality and efficiency is detailed in Table [8](https://arxiv.org/html/2509.13789v2#A3.T8). Overall, when the number of inference steps is reduced, sampling trajectories deviate from the theoretical optimal path, which amplifies accumulated errors in the noise estimation network. This results in issues such as blurred video details and reduced color saturation. BWCache maintains a high-fidelity video by caching and reusing intermediate stages of inference and their similar DiT block features, thus significantly reducing latency while accurately reconstructing the original inference process.

### C.4 Statistical Analysis

TABLE [9](https://arxiv.org/html/2509.13789v2#A3.T9) shows the statistical results of the paired t-test that determine the significance level of the BWCache compared with other methods regarding LPIPS, SSIM, and PSNR. Specifically, the table provides the mean and standard deviation of PAB Zhao et al. [2024a] and TeaCache Liu et al. [2024], alongside the p-value and corresponding confidence interval. Our null hypothesis is: “There is no significant difference in the performance between the BWCache and other methods". The table shows a meaningful difference between the BWCache and other methods, while the p-value is lower than 0.05 in all cases. There is statistically significant evidence at the 5% significance level to suggest that the BWCache performs better than PAB and TeaCache. Thus, the null hypothesis is rejected, which proves that differences are significant.

## Appendix D More visual results

The additional visual comparison results for Open-Sora, Open-Sora-Plan, and Latte are presented in Fig. [8](https://arxiv.org/html/2509.13789v2#A3.F8), Fig. [9](https://arxiv.org/html/2509.13789v2#A3.F9), and Fig. [10](https://arxiv.org/html/2509.13789v2#A3.F10). All prompts sourced from the Open-Sora gallery Lin et al. [2024], VBench benchmark Huang et al. [2024b], and T2V-CompBench Sun et al. [2024], which collectively offer diverse and representative scenarios for comprehensive evaluation. Our method demonstrates consistent fidelity across diverse models, styles, and content types in video generation while maintaining computational efficiency.

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 4
presentation: 3
questions: The paper's validation is limited exclusively to text-to-video generation. Have you explore the core "U-shaped" ARL1 pattern holds in other settings, like class-conditional generation, image generation?
soundness: 3
strengths: - High Practicality and Scalability. As a training-free method, it can be integrated into existing DiT pipelines without costly fine-tuning. 
- The BWCache design is well-motivated by a clear empirical analysis of DiT block behavior. The Aggregated Relative L1 analysis in Figure 4 provides a strong justification for the caching strategy.
- The method achieves a superior balance between inference speed and visual quality. It delivers speedups while maintaining comparable or even superior visual fidelity.
summary: The paper proposes BWCache, a training-free acceleration technique for Diffusion Transformer video generation. It starts with the observation that DiT blocks dominate latency and many intermediate timesteps present redundant computation. BWCache caches block outputs across timesteps and reuses them based on a similarity indicator. It also incorporates periodic recomputation to prevent latent drift. Experiments across multiple backbone models show up to 2.6× speedup while maintaining competitive quality.
weaknesses: - The paper's claim to be the first method to exploit block-wise temporal stability in DiTs appears to be overstated. There is some highly relevant prior work which also investigates temporal redundancy in DiTs but not discussed in the paper. The authors must situate their work relative to it, differentiate their contribution, and (if possible) provide a comparative analysis.
1. Towards Stabilized and Efficient Diffusion Transformers through Long-Skip-Connections with Spectral Constraints

- In Table 1, TeaCache achieves a 4.41x speedup on Open-Sora-Plan. The authors attribute it to "significant variation in block features during the early inference stages," but provide no data or analysis to support this claim. Why does the block-wise indicator in Eq. 7 fail in this specific scenario while TeaCache's simpler timestep-level caching succeeds? 
-  The entire caching mechanism depends on a manually-set similarity threshold in Eq. 7, which appears empirical. The paper provides no theoretical grounding for this choice, nor does it analyze its stability or the risk of error accumulation from repeated cache reuse. The ablation in Table 4 shows a predictable quality/speed trade-off but fails to explain how a user should set $\delta$ for a new model or task.
- The computational cost of the cache indicator is not considered. BWCache requires calculating the L1 distance for all blocks at every step to decide whether to cache. This overhead is never measured. While this cost may be negligible on large models, it could substantially diminish on smaller models, in edge-computing scenarios, or on hardware with lower memory bandwidth.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: What is the underlying theoretical explanation for the observed U-shaped pattern in DiT block feature variations? Is this pattern consistent across different architectures and training methodologies, and how does it relate to the diffusion process dynamics? I would appreciate it if the authors could discuss this with previous related works (e.g., [1])

[1] Ma, Xuran, et al. "Model Reveals What to Cache: Profiling-Based Feature Reuse for Video Diffusion Models." Proceedings of the IEEE/CVF International Conference on Computer Vision (2025).
soundness: 3
strengths: 1. The paper is built on a clear, insightful, and well-visualized analysis (Figure 4). The identification of the U-shaped variation pattern in DiT blocks is a strong finding that provides a direct and logical justification for the entire method's design.
2. The method is more sophisticated than several competitors. It correctly identifies a suitable *granularity* (DiT blocks) and, more importantly, implements a dynamic *trigger* (the similarity indicator) for caching. This, combined with the fidelity-preserving strategies (final-step recomputation), allows it to effectively balance acceleration and quality.
3. The experimental validation is thorough. Testing on five different, large-scale video DiTs and comparing against multiple relevant baselines demonstrates the method's general applicability. The scalability tests (multi-GPU, video length) and the direct ablation against naive step reduction (Table 3) make the performance claims very convincing.
summary: This paper presents BWCache, a training-free inference acceleration method for DiT-based video generation. The work is motivated by an empirical analysis showing that DiT block computations are the main latency bottleneck and exhibit a U-shaped variation pattern, implying high redundancy in intermediate steps. BWCache exploits this by dynamically caching and reusing features at the block level. A similarity indicator (average relative L1 distance) determines when to reuse features, while safeguards like periodic recomputation and forced computation in the final steps ensure high visual fidelity. The method is validated across five state-of-the-art models, demonstrating significant speedups while consistently outperforming other acceleration baselines in preserving video quality.
weaknesses: 1. Notably, the trade-off of speed for memory is a weakness. By caching DiT block features, the method's GPU memory footprint increases, as acknowledged in the appendix (Appendix D.4). For very large models that already push the limits of high-end GPUs (e.g., Wan 2.1 using ~74GB), this additional overhead (to ~81GB) could make the method unusable on memory-constrained hardware.
2. The method's effectiveness depends on manually tuning two key hyperparameters: the similarity threshold $\delta$ and the recomputation interval $R$. The ablation studies show that these values control a sensitive trade-off between speed and quality. While the authors provide default values, these may not be optimal for all models or use cases, and the paper does not offer a strategy for setting them automatically.
3. A critical implementation detail is hidden in the appendix (D.4). For memory-heavy models (Wan 2.1, HunyuanVideo), the similarity indicator is not calculated using *all* blocks; instead, a *subset* (e.g., 50%) is used to save memory. The main paper does not mention this, and the appendix does not specify *how* this subset is chosen (e.g., first 50%, random, etc.), making the indicator's true behavior and robustness on these models unclear.
4. The fidelity safeguards are static: always recompute the *last $k/2$ steps* and reuse for a *fixed interval $R$*. The "U-shape" analysis suggests that the transition from stable to variable features (the right side of the "U") is gradual. A more dynamic approach, perhaps by monitoring the L1 distance to decide when to *stop* caching (rather than a fixed $k/2$ rule), might offer an even better trade-off.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. Are spatial and temporal DiT blocks cached jointly or independently, and did you observe temporal drift in high-motion clips
2. Can you provide results on highly dynamic or compositional scenes (human motion, fast parallax) to test stability
soundness: 3
strengths: BWCache demonstrates outstanding performance in **redundancy granularity**, **cross-scenario adaptability**, and **quality–efficiency balance**, providing a precise and general acceleration framework tailored for redundant computation in DiT-based video generation models.

1. **Focusing on Module-Level Redundancy, Breaking the Granularity Limitation of Traditional Caching**  
   Existing caching methods (e.g., TeaCache, PAB) typically operate at the *timestep level* or *attention-head level*: the former risks losing critical timestep information, while the latter incurs high computational overhead and limited acceleration:
   - **Key discovery of module-level redundancy:** By analyzing DiT model computation time distribution, the authors find that DiT modules account for over 70% of total inference latency, and that module features exhibit a *U-shaped variation pattern* across diffusion timesteps — large differences in early (high-noise) and late (low-noise) stages (requiring computation), but small differences in mid-stages (moderate noise, high redundancy, suitable for caching).  
   - **Relative L1 distance as a quantitative criterion:** They define the *relative L1 distance* between module features and aggregate it into  
     $ \text{ARL1}(t) $ — the sum of all module-wise relative L1 values — as the redundancy measure. When  
     $ \text{ARL1}(t)/N < \delta $ (δ = threshold), cached features are reused, ensuring that computation is skipped *only* when true redundancy exists, preventing blind reuse and quality degradation.  
   This design focuses on the *most time-consuming components* (modules), guaranteeing both substantial acceleration and controlled quality degradation — the key to BWCache’s superior performance.

2. **Consistent Cross-Model Acceleration with Negligible Quality Loss**  
   Across five mainstream video generation models (Open-Sora, Open-Sora-Plan, Latte, Wan 2.1, and HunyuanVideo), BWCache achieves a strong balance between *speed* and *quality*, without requiring retraining:  
   - **Single-GPU scenarios:**  
     - On *HunyuanVideo* (129 frames, 544 P), BWCache achieves 2.6× speed-up (latency 1122 s → 433 s), with VBench 82.48% (higher than baseline 82.29%), LPIPS 0.0794 (better than PAB 0.1045 and TeaCache 0.1630), and PSNR 29.91.  
     - On *Open-Sora*, at 1.61× acceleration, LPIPS 0.0879 (close to the original), SSIM 0.8854, and PSNR 27.05 — all significantly outperforming baselines like Δ-DiT and T-GATE.  
   - **Multi-GPU scaling:**  
     With *Dynamic Sequence Parallelism (DSP)*, BWCache reaches 17.2× acceleration on 8 A800 GPUs for Open-Sora (204 frames, 480 P) (latency 11.1 s vs 190.2 s original), with near-linear scaling, enabling large-scale deployment.  
   - **High-resolution / long-video adaptability:**  
     On *Wan 2.1* (720 P), BWCache delivers 2× speed-up (latency 912 s → 457 s) with VBench 81.99% (only 0.18% lower than original), while TeaCache at 1.41× acceleration shows more noticeable quality loss.
summary: This paper proposes BWCache, a training-free acceleration framework for Diffusion Transformer (DiT)–based video diffusion models. Instead of modifying the model architecture, BWCache reuses intermediate block-level features across diffusion timesteps when the change between adjacent blocks is below a similarity threshold δ. A periodic recomputation strategy mitigates latent drift.

Comprehensive experiments across five representative video diffusion models show that BWCache achieves up to 2.6× speed-up while maintaining comparable or slightly better perceptual quality compared to TeaCache and PAB. Statistical analyses and ablations (threshold $\delta$, reuse interval, GPU scaling) reinforce the empirical soundness.

While the acceleration results are impressive, the approach incurs non-negligible memory overhead due to feature caching, and its stability across architectures and motion intensities remains insufficiently explored. Nevertheless, the work offers a practical plug-and-play contribution that meaningfully advances inference-time efficiency for large-scale DiT-based video generation.
weaknesses: Despite its impressive performance, BWCache still has room for improvement in **memory overhead** and **adaptability to dynamic scenes**.

1. **Module Caching Increases Memory Consumption — Limited for Single-GPU High-Resolution Scenarios**  
   BWCache caches the *output features of each DiT module*, leading to noticeable GPU memory growth, especially for large models and high-resolution videos:  
   - Appendix D.4 reports that on Wan 2.1 (81 frames, 720 P), BWCache uses 80 607 MiB vs 73 955 MiB for the baseline (+9%), and on HunyuanVideo (129 frames, 720 P) +8%.  
   - To reduce memory pressure, the authors compute caching metrics on “50% module sampling”, which lowers memory cost but slightly reduces redundancy detection accuracy (e.g., 10% sampling yields LPIPS 0.7901 vs 0.0782 for 50% sampling).  
   This limits BWCache’s applicability for single-GPU, memory-constrained environments (e.g., edge devices or high-resolution video generation).

2. **Insufficient Redundancy Detection Accuracy in Highly Dynamic Scenes**  
   The “U-shaped feature variation” assumption holds well for static scenes (e.g., “beach sunset”) but weakens in highly dynamic cases (e.g., “car chase,” “crowded street”):  
   - In dynamic scenes (Prompt 2: “bus approaching traffic light”), module-level differences remain larger, with mid-stage redundant steps 30–40% fewer than in static scenes, leading to lower acceleration (e.g., on Open-Sora-Plan, TeaCache achieves 4.41× while BWCache only 2.24×, Table 1).  
   - No dynamic-aware adaptation is proposed: the method lacks an *adaptive threshold $\delta$* based on scene dynamics (e.g., using smaller δ for fast-changing content), resulting in suboptimal speed-quality trade-offs in dynamic video generation.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 2
questions: See Weakness
soundness: 2
strengths: 1. The mechanism is training-free, compatible with a range of DiT video generators, and easy to integrate at inference time.

2. The use of a block-wise mean relative L1 indicator to decide reuse is principled and aligns with the observed per-timestep dynamics.

3. Results span multiple DiT-based models and include comparisons to ∆-DiT, T-GATE, PAB, and TeaCache, plus scaling behavior with DSP and ablations over threshold δ and reuse interval R.

4. The paper gives quantitative and qualitative evidence that BWCache sustains visual fidelity at meaningful acceleration levels.
summary: The paper proposes BWCache, a training-free acceleration method for DiT-based video diffusion. It caches and reuses block-level features across timesteps and triggers reuse with a similarity indicator computed from the mean relative L1 distance between adjacent-timestep block features. To avoid latent drift, it adds periodic recomputation with a reuse interval. Experiments on Open-Sora, Open-Sora-Plan, Latte, Wan 2.1, and HunyuanVideo report up to 2.6× speedup with comparable visual quality, along with scaling results under multi-GPU DSP and ablations on the indicator threshold and reuse interval.
weaknesses: 1. The comparison with related work in Table 1 is not sufficiently comprehensive. Several recent and relevant caching-based acceleration methods, such as FasterCache and TaylorSeer, are missing from the comparison.

2. The appendix shows that the proposed method increases memory consumption compared with the original base model. It should also include the memory usage of other representative cache-based methods to demonstrate the superiority of the proposed approach.


Decision: Accept (Poster)