Adaptive Cache Enhancement (ACE)

• Adaptive Cache Enhancement (ACE) is a family of cache designs that adaptively adjusts admission, eviction, placement, or capacity decisions based on runtime workload history.
• It leverages hybrid strategies—such as combining recency and frequency metrics, feedback-controlled promotion, and programmable policies—to elevate hit ratios and optimize resource usage.
• Emerging implementations, including predictive frameworks like DEAP Cache and test-time adaptations for vision-language models, demonstrate measurable gains in throughput and accuracy.

Adaptive Cache Enhancement (ACE) denotes a family of cache designs that augment conventional caching with adaptive control logic, allowing admission, eviction, placement, or capacity decisions to track workload history rather than remain fixed. In the cited literature, this idea appears in virtual-memory and page-cache replacement, multimedia prefix caching, application-level web caching, programmable multi-tenant caching engines, wireless edge caching, and, in a distinct 2025 usage, as the name of a class-wise adaptive cache framework for test-time adaptation of vision-LLMs (Jayarekha et al., 2010, Zussman et al., 4 Feb 2025, Nguyen et al., 11 Aug 2025).

1. Scope, terminology, and conceptual boundaries

Across these works, ACE is not a single algorithm. It covers low-overhead hybrids of recency and frequency, adaptive placement via decoupled tag and data structures, feedback-controlled promotion distance, runtime cacheability mining, tenant-aware memory reallocation, and class-wise thresholded memory banks. What unifies these systems is that they enhance a baseline cache by replacing static heuristics with runtime adaptation.

Domain	Adaptive object	Representative work
Memory hierarchy and page cache	Replacement, placement, capacity	(Swain et al., 2011, Ahire et al., 4 Feb 2025, Berend et al., 26 Nov 2025, Zussman et al., 4 Feb 2025)
Multimedia and application caching	Prefix retention, cacheability admission	(Jayarekha et al., 2010, Mertz et al., 2020)
Multi-tenant and edge systems	Pool sizing, cluster-aware content placement	(Peixoto et al., 15 Mar 2026, Hajri et al., 2016)
Vision-language TTA	Cache thresholds and prototype memory	(Nguyen et al., 11 Aug 2025)

A recurrent theme is the insufficiency of one-size-fits-all policies. AWRP is motivated by the observation that LRU captures recency but ignores frequency, FIFO ignores access behavior, LFU adapts poorly to changing patterns, and ARC/CAR add bookkeeping overhead (Swain et al., 2011). Similar arguments recur in prefix caching for multimedia servers, in programmable Linux page cache control, and in CacheLib’s multi-tenant setting, where static or slow-to-adapt configurations lead to suboptimal performance, inefficient memory usage, or starvation (Jayarekha et al., 2010, Zussman et al., 4 Feb 2025, Peixoto et al., 15 Mar 2026).

A common source of confusion is that ACE does not always expand to Adaptive Cache Enhancement. In "Arrays of (locality-sensitive) Count Estimators (ACE)" (Luo et al., 2017), ACE is an anomaly-detection estimator requiring less than $4\text{ MB}$ memory and designed so its arrays fit in L3 cache; the paper explicitly states that ACE there does not mean “Adaptive Cache Enhancement” (Luo et al., 2017). Its relevance is architectural and cache-resident, not as a cache-replacement or cache-control policy.

2. Algorithmic foundations in adaptive replacement and placement

A canonical systems-level instance is AWRP, the Adaptive Weight Ranking Policy. AWRP maintains a frequency counter $F_i$, a recency timestamp $R_i$, and a weight $W_i$ for each block; initially $R_i=0$, $F_i=0$, and $W_i=0$. On a hit, $F_i\leftarrow F_i+1$ and $R_i$ is updated to the current clock/access value. On a miss, weights are computed for the blocks in the buffer, the block with the smallest $W_i$ is selected for replacement, and the new block is initialized with $F_i$0 current clock value, $F_i$1, $F_i$2. The paper presents $F_i$3 while also describing ranking by both recency and frequency, and the summary notes that the formula presentation is somewhat informal/inconsistent. In simulation on 1000 memory addresses from a real program trace, using only data-cache addresses, set-associative mapping, and 8 cache sizes, AWRP achieved average improvement of approximately $F_i$4 over LRU, $F_i$5 over FIFO, and $F_i$6 over CAR; its maximum hit ratio was about $F_i$7 at cache size $F_i$8, and its minimum was about $F_i$9 at cache size $R_i$0 (Swain et al., 2011).

A related but domain-specific formulation appears in multicast-aware prefix caching for multimedia servers. That method organizes the cache into $R_i$1, $R_i$2, $R_i$3, and $R_i$4: $R_i$5 contains prefixes requested once recently, $R_i$6 contains prefixes requested at least twice recently, and the ghost lists $R_i$7 and $R_i$8 retain only metadata for recently evicted entries. Its replacement logic balances LRU and LFU online, uses timestamp, frequency count, and online/offline status, and evicts the page with the least score value in $R_i$9. When a prefix becomes offline, its frequency is reduced by $W_i$0, and the inflation factor can be applied again if it remains unrequested for a long interval. The reported outcome is higher hit ratio than pure LRU, fewer replacements, better bandwidth utilization, and reduced waiting time in the multicast VoD setting (Jayarekha et al., 2010).

RAC, the Random Adaptive Cache Placement Policy, shifts the focus from victim selection to adaptive placement. It uses a 16-way set-associative cache with 2048 sets, a tag directory with 32 ways, and a data cache block with 16 ways, with forward and reverse pointers linking tag and data entries. Its adaptive behavior is defined by four cases: normal insertion when both tag and data structures have space; LRU when the tag table is full; random eviction when the data table is full but the tag directory has space; and LRU on tags plus random eviction on data when both are full. In ChampSim on four benchmark traces, the best reported hit rate was $W_i$1 on 473.astar, while 444.namd reached $W_i$2; the paper also states that IPC improvements were modest, despite substantial hit-rate improvement (Ahire et al., 4 Feb 2025).

AdaptiveClimb and DynamicAdaptiveClimb replace per-item statistics with a single feedback-controlled scalar, jump. AdaptiveClimb initializes $W_i$3, decrements jump on a cache hit, increments it on a miss, and uses the current value as the promotion distance. DynamicAdaptiveClimb adds a second counter, jump', and changes cache size as well as promotion aggressiveness: the cache grows when $W_i$4, and shrinks when $W_i$5 and $W_i$6. Evaluated with libCacheSim on 1067 real-world traces from 6 datasets, the method achieved up to a $W_i$7 improvement in hit ratio over FIFO, outperformed the next-best contenders AdaptiveClimb and SIEVE by about $W_i$8 to $W_i$9, and reached around $R_i=0$0 at 16 threads on Meta KV and Twitter traces (Berend et al., 26 Nov 2025).

3. Prediction-driven and learned adaptive cache enhancement

DEAP Cache extends ACE from replacement alone to coordinated control of prefetching, admission, and eviction. Its offline stage learns specialized byte embeddings for addresses and PCs, an LSTM prefetcher over miss sequences, a KDE-based distribution estimator, and a multi-task decoder for future frequency and reuse distance; the online stage uses these components for admission, prefetching every $R_i=0$1 timesteps, and eviction through a modified LeCaR-style regret-minimization policy. The paper explicitly models eviction as a choice between evicting the line with least predicted future frequency and evicting the line with highest predicted future reuse distance, and it admits an item when $R_i=0$2 or $R_i=0$3. Its multi-task objective is

$R_i=0$4

On the proxy dataset used in the study, the reported mean hit rates were LRU $R_i=0$5, LFU $R_i=0$6, FIFO $R_i=0$7, LIFO $R_i=0$8, BELADY (Oracle) $R_i=0$9, and DEAP Cache $F_i=0$0 (Mangal et al., 2020).

This design marks a transition from heuristic ACE to predictive ACE. Instead of combining past recency and frequency directly, DEAP Cache predicts future usefulness and reuses that signal consistently for admission and eviction. The paper is explicit that this is a “proof of concept,” that it uses a proxy dataset derived from a UCSD course webpage dataset with five files of sequence length ranging from 180000 to 500000, and that evaluation on SPEC CPU2000 is future work (Mangal et al., 2020). This suggests a broader distinction within ACE between lightweight feedback controllers such as AdaptiveClimb and model-based controllers that attempt to infer future utility explicitly.

4. Programmable, application-specific, and networked ACE

In operating systems, ACE increasingly appears as programmability rather than a single fixed policy. The $F_i=0$1 framework makes the Linux page cache programmable through in-kernel eBPF, exposing policy hooks such as policy_init, evict_folios, folio_added, folio_accessed, and folio_removed. It preserves the shared page cache, allows different cgroups to run different policies, and demonstrates MRU, approximate LFU, S3-FIFO, LHD, and an application-informed GET-SCAN policy. The evaluation reports that a userspace-offload design caused up to $F_i=0$2 degradation, that cachebpf MRU is almost $F_i=0$3 faster than baseline Linux and MGLRU on file search, that cachebpf LFU delivers up to $F_i=0$4 higher throughput and up to $F_i=0$5 lower P99 read latency on skewed workloads, and that customized policies can achieve up to $F_i=0$6 higher throughput and $F_i=0$7 lower tail latency, with CPU overhead at most $F_i=0$8 and memory overhead $F_i=0$9–$W_i=0$0 (Zussman et al., 4 Feb 2025).

The empirical study of CacheLib shows why programmable interfaces alone do not guarantee effective ACE. CacheLib exposes pool rebalancer, pool resizer, and pool optimizer, but the paper finds rigid configurations, limited runtime adaptability, lack of quality-of-service support and coordination, and tenant starvation under dynamic workloads. In the reported four-tenant setup, each tenant has 20 million unique items of $W_i=0$1, the total dataset is about $W_i=0$2, and the cache is $W_i=0$3. Under static uniform allocation, tenant T1 reaches about $W_i=0$4, which is $W_i=0$5 faster than T2, $W_i=0$6 faster than T3, and $W_i=0$7 faster than T4. A custom allocation that assigns $W_i=0$8 of cache to T1 improves overall throughput up to $W_i=0$9 over baseline and drives T1 to about $F_i\leftarrow F_i+1$0; the optimizer eventually reaches about $F_i\leftarrow F_i+1$1 after about 500 seconds but reallocates T1 from $F_i\leftarrow F_i+1$2 to $F_i\leftarrow F_i+1$3, starving other tenants. In the dynamic experiment, the custom policy peaks at about $F_i\leftarrow F_i+1$4, which is $F_i\leftarrow F_i+1$5 better than the optimizer (Peixoto et al., 15 Mar 2026).

At the application layer, APLCache moves ACE from cache replacement to cacheability inference. It records method calls as $F_i\leftarrow F_i+1$6, where $F_i\leftarrow F_i+1$7 is the method signature, $F_i\leftarrow F_i+1$8 is the parameter list, $F_i\leftarrow F_i+1$9 is the return value, $R_i$0 is the cost, and $R_i$1 is the user session. It mines runtime traces using staticity, changeability, frequency, shareability, and expensiveness, then admits results if $R_i$2, with TTL for consistency and reclamation. In Java web applications, the reported throughput improvements range from $R_i$3 to $R_i$4, and APLCache identifies $R_i$5–$R_i$6 more cacheable methods than developers (Mertz et al., 2020).

In wireless edge caching, adaptation is expressed as content-placement diversity. The adaptive user-clustering method groups users by content popularity vectors, estimates the number of clusters using the Akaike Information Criterion,

$R_i$7

caches the top-$R_i$8 files of each cluster across different SBS groups, and optimizes the SBS fractions $R_i$9 to maximize hit probability. The paper derives a closed-form cache-hit expression and reports that the clustering-based method can even triple hit probability at $W_i$0 km relative to caching only globally popular content (Hajri et al., 2016).

5. ACE as a named framework for test-time adaptation of vision-LLMs

In "Adaptive Cache Enhancement for Test-Time Adaptation of Vision-LLMs" (Nguyen et al., 11 Aug 2025), ACE is the formal name of a specific cache-based TTA framework. The setting is zero-shot VLM inference under distribution shift, with image embeddings $W_i$1, class text embeddings $W_i$2, and CLIP predictions derived from cosine-similarity logits. The paper identifies two failure modes of prior cache-based TTA methods: unreliable confidence or entropy under strong shift, and rigid global decision boundaries. ACE addresses both by constructing a priority-queue cache of image embeddings per class, accepting a sample only if its confidence or entropy passes a class-specific adaptive threshold $W_i$3, initializing $W_i$4 from zero-shot statistics, updating thresholds with an EMA

$W_i$5

and lowering thresholds for never-seen classes $W_i$6 and rarely seen classes $W_i$7 using an exploration rate $W_i$8. The implementation uses CLIP + DPE, $W_i$9 augmented views per test image, AdamW with learning rate $F_i$00, $F_i$01, $F_i$02, $F_i$03, $F_i$04, and cache size $F_i$05 (Nguyen et al., 11 Aug 2025).

The reported evaluation spans 15 datasets. On ImageNet-style natural distribution shift, the best OOD averages are ACE-Entropy $F_i$06 on ResNet-50 and $F_i$07 on ViT-B/16, compared with DPE at $F_i$08 and $F_i$09, and TDA at $F_i$10 and $F_i$11. On cross-dataset generalization, ACE-Probability reaches $F_i$12 on CLIP-ResNet-50 and $F_i$13 on CLIP-ViT-B/16, while ACE-Entropy reaches $F_i$14 and $F_i$15; the corresponding DPE values are $F_i$16 and $F_i$17. The paper states that ACE improves average accuracy by $F_i$18 on CLIP-ResNet-50 and $F_i$19 on CLIP-ViT-B/16 over the best prior method, and ablations show that zero-shot cache initialization improves ViT-B/16 cross-dataset performance from $F_i$20 to $F_i$21 in the probability-based variant and from $F_i$22 to $F_i$23 in the entropy-based variant (Nguyen et al., 11 Aug 2025).

This VLM formulation broadens the meaning of cache in ACE. The cache is no longer a hardware or OS data structure, but a dynamic memory of pseudo-labeled feature embeddings whose selection policy reshapes decision boundaries at inference time. A plausible implication is that ACE has become a transferable design pattern: adaptive cache control can be applied wherever historical state is retained and reused under non-stationary conditions.

6. Limitations, misconceptions, and open directions

A central conclusion of the literature is that ACE does not remove workload dependence; it relocates it into the adaptation mechanism. RAC shows strong workload sensitivity and only modest IPC gains despite improved hit rates (Ahire et al., 4 Feb 2025). The cachebpf evaluation on Twitter traces reports that LHD wins on some clusters, LFU on others, MGLRU on some, and default Linux on some, directly supporting the claim that no single cache policy is best for all workloads (Zussman et al., 4 Feb 2025). AWRP’s evaluation is limited to one trace set and a small simulation study, and its formula presentation is noted as less rigorous than more mature replacement-policy literature (Swain et al., 2011).

Another recurring limitation is that adaptive behavior can introduce new state, control loops, or fairness problems. CacheLib demonstrates that global-efficiency-first adaptation can improve throughput while reallocating nearly the entire cache to one tenant and causing other tenants’ throughput to collapse (Peixoto et al., 15 Mar 2026). APLCache assumes that method output depends only on inputs, uses TTL-based weak consistency, and was evaluated on only three Java applications (Mertz et al., 2020). DEAP Cache is explicitly a proof of concept using a proxy dataset rather than standard large-scale hardware benchmarks (Mangal et al., 2020). In the VLM setting, ACE still relies on pseudo-labels and is therefore affected by poor zero-shot predictions and hyperparameter choices such as $F_i$24, $F_i$25, and $F_i$26 (Nguyen et al., 11 Aug 2025).

Several misconceptions are corrected by these studies. Improving hit ratio does not necessarily translate into proportionally large execution-speed gains; RAC states this explicitly for IPC (Ahire et al., 4 Feb 2025). Programmability does not by itself guarantee effective adaptation; the CacheLib study argues for faster workload prediction, QoS-aware and priority-aware memory management, inter-instance coordination, and better handling of volatile tenant arrivals and departures, and specifically points to Miss-Ratio Curves as a useful primitive (Peixoto et al., 15 Mar 2026). The programmable page-cache work similarly identifies future work on writeback, prefetching, and ML-based policies rather than eviction alone (Zussman et al., 4 Feb 2025).

Taken together, these works suggest that ACE is best understood as an architectural principle rather than a fixed replacement heuristic. Its mature forms combine four elements: a retained memory state, an online signal for updating that state, a mechanism for translating the state into concrete cache actions, and guardrails against instability, pollution, or starvation. Whether the cache stores memory pages, video prefixes, method results, user-cluster content sets, or VLM embeddings, the research record consistently treats adaptation as the decisive ingredient.