Dynamic Cache Updating (DCU)

• DCU is a family of adaptive mechanisms that continuously manage what to cache, refresh, evict, or reuse based on evolving system conditions.
• It leverages threshold-based controls and correlation-aware strategies to optimize performance in settings like edge networks, cloud systems, and generative-model inference.
• DCU addresses the trade-off between update costs and penalties from stale data by using metrics such as AoI, popularity drift, and feature dynamics to guide decisions.

Dynamic Cache Updating (DCU) denotes a class of mechanisms that keep cached state useful under time variation. In the literature, the term is applied to evolving content libraries, freshness-constrained edge systems, context-aware IoT platforms, multi-tenant cloud caches, dynamic scientific repositories, processor and LLC adaptation, and inference-time reuse in diffusion models and diffusion LLMs. Across these settings, the common problem is not merely cache placement, but continuous or periodic control of what is cached, what is refreshed, what is evicted, what is reused, and, in some systems, how much cache capacity is exposed at all (Hassanzadeh et al., 2018, Manchanda et al., 25 Apr 2025, Berend et al., 26 Nov 2025, Wu et al., 27 May 2026).

1. Terminological scope and recurring abstractions

A recurrent source of ambiguity is that DCU is not a single standardized algorithm. In some papers it means runtime cache admission, refresh, and eviction based on freshness and demand; in others it means adaptive replacement and cache resizing; in others it means deciding when previously computed features can be reused and how multi-step caches should be combined. The literature is therefore best read as a family of online control problems over cached state rather than as one canonical protocol (Manchanda et al., 25 Apr 2025, Balaji et al., 2017, Berend et al., 26 Nov 2025, Abolhassani et al., 2024).

The main state variables also differ by domain. Communication and CDN papers track content correlation, update rates, Age-of-Version (AoV), Age of Information (AoI), or popularity drift. Platform papers track query logs, quality-of-service attributes, or per-tenant hit-rate predictions. Systems papers track hit/miss feedback, energy, or cache colors. Inference papers track layer-input similarity, feature trajectories, or residual dynamics.

Setting	Observed signal	Primary DCU action
DCMF for context caching	PoA and CF	cache, refresh, or evict
CCache	privatized cache-line state	merge local updates into memory
DynamicAdaptiveClimb	hit/miss feedback, jump, jump′	promote objects and resize cache
Fresh CDN/DCN models	AoV, AoI, popularity, request arrivals	push, pull, refresh, or wait

Despite this heterogeneity, several abstractions recur. First, DCU is usually driven by a small set of measurable state variables. Second, the control law is often threshold-based, either exactly or after relaxation. Third, the main trade-off is between an update cost and a stale-hit, miss, latency, bandwidth, or energy cost. Fourth, many formulations separate a slow control loop for placement or sizing from a fast control loop for delivery or reuse.

2. Correlation-aware delivery and coded multicast updating

In dynamic content distribution, DCU is often formulated as a way to keep caches useful even when exact cache hits disappear. Hassanzadeh, Tulino, Llorca, and Erkip model a cache-aided shared-link broadcast system in which updated versions are generated conditionally as $p(v_1,\dots,v_N \mid w_1,\dots,w_N)$ and the server serves the updated library $\{U_n^F\}$ rather than a fixed static library. Their central observation is that caches can act as repositories of correlated side information, so delivery can jointly compress requested files using cached references instead of relying only on exact reuse (Hassanzadeh et al., 2018).

The framework uses packetization, random fractional caching, and a correlation threshold $\delta$. For a requested packet, its $\delta$-ensemble contains cached or requested packets that are $\delta$-correlated with it. Delivery is organized through an augmented conflict graph: root vertices represent requested packets, virtual vertices represent correlated alternatives, and group coloring chooses whether a multicast codeword should use the root packet itself or a correlated substitute. If a correlated substitute is used, a refinement segment guarantees lossless reconstruction. In the proposed scheme, the total refinement length is

$$L(Y_d^{UM}) = \sum_{k=1}^K H\!\left(U_{d_k}^F \mid Y_d^{CM}, C_k\right),$$

and each user’s refinement is at most $\delta H(W)F$ bits because delivered virtual packets belong to the $\delta$-ensemble. The paper’s dynamic example with two users and two updated files reduces the load from $R=2$ under correlation-unaware delivery to $R=1.5$, i.e. a $\{U_n^F\}$0 reduction (Hassanzadeh et al., 2018).

A related but distinct line appears in cache-aided coded multicast with a stateless source. Mahdian, Prakash, Médard, and Yeh consider a DAG multicast network where the source observes a sequence of correlated frames and encodes frame by frame without access to prior frames. Nodes other than the source may cache their previous-round linear outputs. For cached nodes, the next-round output is recovered through multi-source function-update coding using the previous output as side information; this yields per-incoming-edge update transmissions bounded by $\{U_n^F\}$1 symbols under the worst-case sparse-difference model, while the same linear network code designed for the cache-less network is reused in every round (Mahdian et al., 2018). The associated rate allocation and caching problem is posed as a mixed-integer optimization, then relaxed with an $\{U_n^F\}$2 approximation and solved by a primal–dual algorithm that is globally asymptotically stable for the relaxed problem (Mahdian et al., 2018).

These papers share a specific interpretation of DCU: caches are updated not merely to store popular objects, but to preserve linear or statistical structure that will reduce future multicast cost. This directly challenges the misconception that dynamic content renders caches irrelevant; in these models, correlation-aware references remain valuable even when exact reuse is “almost non-existent” (Hassanzadeh et al., 2018).

3. Freshness, popularity drift, and edge/CDN control

A second major meaning of DCU centers on freshness-constrained edge caching. In wireless edge caching with popularity drift, one macro base station serves multiple wireless caching stations (WCSs), each of which refreshes its top-$\{U_n^F\}$3 files as its local ranking evolves. Popularity drift is quantified by Kendall–tau distance between consecutive rankings, and the update problem is recast as index coding over a conflict graph. The proposed “dynamic coloring” algorithm extends index-coding-based schemes from a single-request scenario to a multiple-request scenario by removing edges as side information grows during coloring. Under drift bounded by $\{U_n^F\}$4, the uncoded transmission count satisfies $\{U_n^F\}$5, while dynamic coloring achieves substantial savings; simulations report up to about $\{U_n^F\}$6 reduction in broadcast transmissions relative to uncoded broadcast (Song et al., 2018).

For dynamic CDNs with an origin and an edge cache, freshness is formalized through AoV rather than AoI. AoV is the integer version lag between the database and the cache. Two asymmetric control models are then distinguished. In push-based caching, the back-end observes AoV exactly but does not observe instantaneous demand; in pull-based caching, the edge observes instantaneous requests but not exact AoV, and instead tracks elapsed time since the last refresh. The optimal push policy is threshold-based in version age, while the optimal pull policy is threshold-based in elapsed time and is triggered only on request arrivals. In the pull formulation, the closed-form threshold is

$\{U_n^F\}$7

and the optimal average cost per item is

$\{U_n^F\}$8

The paper further identifies a regime split through the ratio $\{U_n^F\}$9: pull-based caching dominates when this ratio is small, while push-based caching dominates when it is large (Abolhassani et al., 2024).

SwiftCache takes this threshold structure as the basis for model-based learning in distributed front-end caches with unknown popularity and refresh rates. Under Poisson arrivals, updates are again shown to occur solely at request arrivals, and the average occupancy constraint yields a KKT characterization with an item-wise threshold. The model-based policy adapts online by estimating rates and recomputing thresholds, whereas a model-free RL variant is proposed for more general interarrival processes. The paper reports near-optimal cost for Poisson arrivals, and states that the model-based policy performs well when the variance of interarrival times remains moderate, while RL slightly outperforms it as variance increases, at the cost of longer training times and higher computational resource consumption (Abolhassani et al., 2024).

A related AoI-based formulation treats popularity itself as time-varying according to a Markov chain. Here, each file has a popularity mode $\delta$0, expected request count $\delta$1, and age $\delta$2. The original problem imposes a hard per-slot update cap $\delta$3. After a Lagrangian relaxation to an average-bandwidth CMDP, the problem decouples across files and yields a per-mode threshold structure: for each mode, there exists a threshold $\delta$4 above which a file is updated and below which it is not. A practical randomized policy then enforces the original hard per-slot constraint by drawing independent Bernoulli proposals from the relaxed-optimal stationary policy and randomly thinning them to at most $\delta$5 updates. Under common-file-statistics assumptions and fixed $\delta$6, this policy is asymptotically optimal as $\delta$7 (Tang et al., 2020).

Freshness can also be represented directly as a binary indicator rather than a version or age process. In the source–cache–user model of Bastopcu and Ulukus, file $\delta$8 changes at rate $\delta$9, the cache updates it at rate $\delta$0, and the user requests it at rate $\delta$1. The exact average freshness at the user is

$\delta$2

with aggregate freshness $\delta$3. Maximizing this quantity under $\delta$4 and $\delta$5 yields threshold policies: for fixed $\delta$6, the optimal $\delta$7 is positive only when a normalized marginal-gain coefficient exceeds the cache-budget shadow price, and the same structure holds symmetrically for $\delta$8 (Bastopcu et al., 2020). The paper explicitly notes that the optimal update rates for rapidly changing files at the source may be equal to zero (Bastopcu et al., 2020).

An important corrective to freshness-based DCU appears in adversarial timestomping. In that model, a cache-to-user adversary can alter timestamps on forwarded packets so that an old cached packet appears fresh. The resulting online problem is analyzed through competitive ratio. The proposed deterministic policy partitions the horizon into blocks, places source-to-user transmissions at the end of each block, and source-to-cache transmissions at the beginning of the next block. This interleaving reduces intervals in which the cache is older than the user, thereby reducing the leverage of timestomping. The paper gives both a Yao-based lower bound on the competitive ratio and an explicit upper bound for the deterministic algorithm (Banerjee et al., 2023).

4. Platform-level DCU in IoT, clouds, repositories, and dynamic documents

In context-aware IoT systems, DCU is cast as a runtime mechanism for deciding whether each context item should be cached, refreshed, or evicted. DCMF decomposes the problem into a Context Evaluation Engine (CEE) and a Context Management Module (CMM). The CEE computes a Probability of Access (PoA) from historical and recent demand,

$\delta$9

and combines it with MAUT utility into a priority score. The CMM tracks Context Freshness,

$\delta$0

maps PoA and CF into Dempster–Shafer mass functions, combines them, and applies thresholds $\delta$1 and $\delta$2 to decide whether to keep, refresh, or evict a context item. On real-world smart-city roadwork and traffic data, DCMF reports CHR values around $\delta$3 in a high-CF scenario versus $\delta$4 for m-CAC, and a reduction in cache expiry ratio by up to $\delta$5 compared to state-of-the-art methods (Manchanda et al., 25 Apr 2025).

In multi-tenant cloud caching, DCU becomes dynamic cache management under per-tenant QoS constraints. The workflow is estimate access-pattern distribution, predict hit rate as a function of allocated cache size, and then increase, decrease, or retain each tenant’s cache quota. The paper evaluates KS-test-based distribution fitting across Uniform, Gaussian, Exponential, and Zipf families, and uses a fully connected neural network to predict hit rate from cache size, data size, and distribution parameter. Reallocation follows thresholded rules such as increasing cache when the predicted hit rate falls below the required QoS minus a safety margin and decreasing it when the tenant has sustained surplus above the QoS target. In experiments with synthetic traces and YCSB, the method restores hit rates to at least $\delta$6 after resizing events while reducing response time substantially (Choi et al., 2019).

For rapidly growing scientific repositories, Delta formulates DCU as adaptive decoupling between query shipping, update shipping, and object loading. Queries reference object sets $\delta$7 and freshness windows $\delta$8; outstanding updates and queries define a bipartite interaction graph in which an edge links update $\delta$9 to query $$L(Y_d^{UM}) = \sum_{k=1}^K H\!\left(U_{d_k}^F \mid Y_d^{CM}, C_k\right),$$0 when the query depends on that update. Choosing whether to ship the query or the update becomes a min-weight vertex cover problem, which is solved via an equivalent minimum $$L(Y_d^{UM}) = \sum_{k=1}^K H\!\left(U_{d_k}^F \mid Y_d^{CM}, C_k\right),$$1–$$L(Y_d^{UM}) = \sum_{k=1}^K H\!\left(U_{d_k}^F \mid Y_d^{CM}, C_k\right),$$2 cut. Objects not yet cached are handled by a separate load manager that compares expected saved query-shipping cost against load cost. On real astronomy traces, Delta cuts network traffic by about half with modest cache sizes and outperforms the smoothing-based Benefit heuristic by $$L(Y_d^{UM}) = \sum_{k=1}^K H\!\left(U_{d_k}^F \mid Y_d^{CM}, C_k\right),$$3–$$L(Y_d^{UM}) = \sum_{k=1}^K H\!\left(U_{d_k}^F \mid Y_d^{CM}, C_k\right),$$4 (Malik et al., 2010).

A still earlier web-oriented interpretation appears in Vcache, which addresses dynamic documents by decomposing them into cacheable templates and non-cacheable bindings. Templates contain <gap> and <loop> markers; bindings carry per-request values and can recursively reference other templates through <temp ref="...">. The client reconstructs a page instance through three operators: GenerateList, FetchList, and Plug. Here DCU is not formulated as a control-theoretic optimization, but as repeated delivery of fresh bindings over a stable template hierarchy, so that only the per-request volatile part changes while the structural HTML remains cached (Goyal et al., 2010).

5. Architectural and system-level cache adaptation

In processor and storage systems, DCU frequently refers to adaptive replacement, resizing, or reconfiguration rather than freshness. DynamicAdaptiveClimb maintains a single ordered stack of $$L(Y_d^{UM}) = \sum_{k=1}^K H\!\left(U_{d_k}^F \mid Y_d^{CM}, C_k\right),$$5 cached objects and updates a global promotion distance jump from immediate hit/miss feedback. Hits decrement jump, making the policy more CLIMB-like; misses increment it, making the policy more LRU-like. DynamicAdaptiveClimb adds a second counter jump′ and permits dynamic resizing of $$L(Y_d^{UM}) = \sum_{k=1}^K H\!\left(U_{d_k}^F \mid Y_d^{CM}, C_k\right),$$6: when jump reaches $$L(Y_d^{UM}) = \sum_{k=1}^K H\!\left(U_{d_k}^F \mid Y_d^{CM}, C_k\right),$$7, the cache doubles; when jump==-K/2 and jump′==-K/2\cdot \epsilon, the cache halves. Across 1067 traces from six datasets, the paper reports up to a $$L(Y_d^{UM}) = \sum_{k=1}^K H\!\left(U_{d_k}^F \mid Y_d^{CM}, C_k\right),$$8 improvement in hit ratio over FIFO and approximately $$L(Y_d^{UM}) = \sum_{k=1}^K H\!\left(U_{d_k}^F \mid Y_d^{CM}, C_k\right),$$9 to $\delta H(W)F$0 over AdaptiveClimb and SIEVE in environments with fluctuating working-set sizes (Berend et al., 26 Nov 2025).

At LLC scale, Mittal’s work on dynamic cache reconfiguration treats DCU as runtime, software-controlled, hardware-assisted adaptation of cache capacity and power state to reduce leakage energy subject to performance or QoS constraints. The mechanisms include EnCache, Palette, CASHIER, MASTER, and MANAGER. Common ingredients are tag-only profiling structures such as the Reconfigurable Cache Emulator, cache coloring or bank/way masking, gated $\delta H(W)F$1 to turn off idle capacity, and periodic optimization over a candidate neighborhood. The energy objective is system-wide,

$\delta H(W)F$2

and stall cycles are predicted through relations such as

$\delta H(W)F$3

Reported savings include about $\delta H(W)F$4 memory-subsystem energy savings for EnCache on a $\delta H(W)F$5MB L2 and about $\delta H(W)F$6 average energy savings for MASTER in a 2-core shared-LLC setting while keeping weighted and fair speedup near $\delta H(W)F$7 (Mittal, 2013).

CCache gives yet another interpretation: dynamic cache updating as on-demand cache-level privatization for commutative updates. A core uses CRead and CWrite to manipulate a private copy of a cache line, stores the original line in a source buffer, and later merges the updated line back into shared memory through a software-defined merge function. The final memory state after all merges is equivalent to

$\delta H(W)F$8

with commutativity guaranteeing order-independence. CCache changes neither the coherence protocol nor the memory footprint in the way static privatization does; it instead adds per-line metadata, a small source buffer, merge registers, and new ISA primitives. On workloads including key–value store, clustering, BFS, and PageRank, the paper reports speedups up to $\delta H(W)F$9 over fine-grained locking and up to $\delta$0 over static duplication, with normalized memory footprint fixed at $\delta$1 by design (Balaji et al., 2017).

These architectural uses show that DCU can target locality, energy, or synchronization overhead rather than content freshness. The unifying feature is still online modification of cache state in response to changing workload signals.

6. Dynamic cache updating in generative-model inference

Recent work extends DCU to inference-time acceleration of diffusion models. In DiCache, DCU comprises two coupled decisions: when to reuse cached features and how to combine multi-step cached features to approximate current features. The Online Probe Profiling Scheme (OPPS) uses shallow-layer probe features $\delta$2 and their relative $\delta$3 differences to estimate the ideal caching error,

$\delta$4

then accumulates this estimate until a threshold $\delta$5 is exceeded. Recompute is triggered when the accumulated error crosses $\delta$6, and because the shallow probe has already been computed, the full forward pass can resume from $\delta$7 rather than from the input. The Dynamic Cache Trajectory Alignment (DCTA) stage then combines the two most recent cached residuals using a probe-derived interpolation coefficient

$\delta$8

Empirically, OPPS relies on a Spearman correlation of about $\delta$9 between shallow-layer differences and final-output differences for $R=2$0. With default $R=2$1, the method reports $R=2$2 speedup on WAN 2.1, $R=2$3 on HunyuanVideo, and $R=2$4 on Flux.1.0-dev while maintaining stronger LPIPS/SSIM/PSNR trade-offs than fixed or heuristic baselines (Bu et al., 24 Aug 2025).

A parallel development for diffusion LLMs is Dynamic-dLLM. Here DCU dynamically allocates a cache-update budget across layers according to layer-wise token dynamics. For token $R=2$5 at layer $R=2$6 and step $R=2$7, the change metric is

$R=2$8

and the aggregate per-layer dynamism score is

$R=2$9

A normalized budget

$R=1.5$0

is then distributed across layers, and the highest-dynamics tokens are refreshed subject to this budget. A mandatory local window around the previously unmasked “key token” is always refreshed to avoid the “stuck-in-the-mud” failure mode. With default $R=1.5$1 and $R=1.5$2, DCU alone yields average speedups around $R=1.5$3 on LLaDA-8B-Instruct and LLaDA-1.5, and when combined with Adaptive Parallel Decoding the overall framework reports average speedups exceeding $R=1.5$4 while maintaining performance (Wu et al., 27 May 2026).

These inference-oriented formulations reinterpret caching as reuse of internal activations rather than storage of external content. The same core questions remain—what to refresh, when to refresh, and how to exploit older cached state without unacceptable error—but the control signal is feature dynamics rather than request or update arrival.

7. Conceptual boundaries, limitations, and open problems

Taken together, these works indicate that DCU is best understood as a family of adaptive cache-control mechanisms rather than a uniquely defined technique. A common misconception is that DCU is synonymous with replacement policy tuning; in fact, the literature includes correlation-aware multicast coding, freshness scheduling, probabilistic context refresh, cache resizing, architectural privatization, and activation reuse in generative inference (Hassanzadeh et al., 2018, Berend et al., 26 Nov 2025, Balaji et al., 2017, Wu et al., 27 May 2026).

Several limitations recur. Correlation-aware network schemes often assume known or estimable correlation structure, homogeneous cache sizes, shared-link broadcast topologies, or i.i.d. demands; tight converses remain open outside small special cases (Hassanzadeh et al., 2018). Context-management systems rely on workload-specific calibration of $R=1.5$5, $R=1.5$6, $R=1.5$7, $R=1.5$8, and AHP weights, and incur continuous monitoring overhead (Manchanda et al., 25 Apr 2025). Energy-oriented architectural schemes assume sufficiently accurate stall-per-miss models and amortization over long control intervals (Mittal, 2013). Inference-time methods require that shallow-feature or layer-input dynamics remain informative proxies for deeper activations; when those correlations weaken, schedule quality can degrade (Bu et al., 24 Aug 2025, Wu et al., 27 May 2026).

Security and trust assumptions also matter. In freshness-driven systems, timestamp or freshness metadata may itself be adversarially manipulated, as the timestomping model makes explicit; here a cache update can be actively harmful unless source-authenticated timing information or structurally safe schedules are used (Banerjee et al., 2023). This suggests that DCU is not only a control problem but also, in some deployments, an information-integrity problem.

Open directions stated in the surveyed work include multi-hop and topology-aware correlation-exploiting caching, online learning of correlation and freshness parameters, scalable algorithms with guarantees beyond greedy or heuristic graph coloring, loss-distortion formulations for dynamic content, distributed implementations of mixed-timescale edge optimization, richer non-Poisson freshness models, adaptive probe depth in generative inference, and stronger robustness against nonstationarity or adversarial manipulation (Hassanzadeh et al., 2018, Abolhassani et al., 2024, Tang et al., 2020, Bu et al., 24 Aug 2025, Wu et al., 27 May 2026).

The literature therefore supports a broad but technically coherent view: DCU is the online management of cached state under evolving uncertainty, where the cached object may be a file, a context item, a page fragment, a cache line, a linear codeword, or a neural feature tensor, and where optimal control is typically governed by thresholds, graph structures, dual variables, or adaptive budgets rather than by static reuse rules alone.