v0.34.0_p1

src/cache/lookup/hot.rs

@@ -18,10 +18,15 @@ impl Cache {
             return None;
         }
         if let Some(storage_key) = matching_hot_key(&store, ticket) {
-            let Some(mut entry) = store.remove(&storage_key) else {
-                return None;
-            };
-            if self.hot_entry_banned(&storage_key, &entry) {
+            // Don't remove and reinsert the entire Entry + variant index on
+            // every HOT hit. A cache hit changes only the LRU sequence, hits
+            // counter, and last-access clock; body/headers remain immutable.
+            let banned = store
+                .entries
+                .get(&storage_key)
+                .is_some_and(|entry| self.hot_entry_banned(&storage_key, entry));
+            if banned {
+                store.remove(&storage_key);
                 if count_miss {
                     self.counters.misses.fetch_add(1, Ordering::Relaxed);
                 }
@@ -29,7 +34,10 @@ impl Cache {
                 release_allocator_memory();
                 return None;
             }
-            let resident_age_seconds = hot_resident_age(&entry).as_secs();
+            let Some(entry) = store.entries.get(&storage_key) else {
+                return None;
+            };
+            let resident_age_seconds = hot_resident_age(entry).as_secs();
             let age = entry
                 .initial_age
                 .saturating_add(entry.received.elapsed())
@@ -44,49 +52,50 @@ impl Cache {
                 &ticket.request_headers,
             );
             if state.servable() {
-                entry.hits = entry.hits.saturating_add(1);
-                entry.last_access = Instant::now();
-                entry.sequence = store.next_sequence();
-                let mut response = Response::new(Body::from(entry.body.clone()));
-                *response.headers_mut() = entry.headers.clone();
-                if entry.transformed {
-                    response
-                        .extensions_mut()
-                        .insert(crate::transform::CachedTransformed);
-                }
-                if entry.skip_compression {
-                    response.extensions_mut().insert(crate::compression::Skip);
-                }
-                response.headers_mut().insert(
-                    "age",
-                    HeaderValue::from_str(&age.to_string()).expect("integer header"),
-                );
-                let result = Hit {
-                    response,
-                    body: entry.body.clone(),
-                    hits: entry.hits,
-                    transformed: entry.transformed,
-                    remaining_ttl: entry.ttl.saturating_sub(age),
-                    resident_age_seconds,
-                    stale: state.stale(),
-                    background_revalidate: state.background_revalidate(),
+                let sequence = store.next_sequence();
+                let (old_sequence, scope, domain, body_bytes, result) = {
+                    let entry = store.entries.get_mut(&storage_key)?;
+                    let old_sequence = entry.sequence;
+                    entry.hits = entry.hits.saturating_add(1);
+                    entry.last_access = Instant::now();
+                    entry.sequence = sequence;
+                    let mut response = Response::new(Body::from(entry.body.clone()));
+                    *response.headers_mut() = entry.headers.clone();
+                    if entry.transformed {
+                        response
+                            .extensions_mut()
+                            .insert(crate::transform::CachedTransformed);
+                    }
+                    if entry.skip_compression {
+                        response.extensions_mut().insert(crate::compression::Skip);
+                    }
+                    response.headers_mut().insert(
+                        "age",
+                        HeaderValue::from_str(&age.to_string()).expect("integer header"),
+                    );
+                    let result = Hit {
+                        response,
+                        body: entry.body.clone(),
+                        hits: entry.hits,
+                        transformed: entry.transformed,
+                        remaining_ttl: entry.ttl.saturating_sub(age),
+                        resident_age_seconds,
+                        stale: state.stale(),
+                        background_revalidate: state.background_revalidate(),
+                    };
+                    (old_sequence, entry.scope.clone(), entry.domain.clone(), entry.body.len(), result)
                 };
-                if let Some(c) = store.domain(&entry.scope, &entry.domain) {
-                    c.saved_body_bytes = c.saved_body_bytes.saturating_add(entry.body.len() as u64);
+                store.lru.remove(&old_sequence);
+                store.lru.insert(sequence, storage_key);
+                // `store.bytes`, `store.logical_bytes` and the Vary schema index
+                // did not change. In particular, this path does not allocate a
+                // replacement variants Vec for every response.
+                if let Some(counter) = store.domain(&scope, &domain) {
+                    counter.saved_body_bytes = counter.saved_body_bytes.saturating_add(body_bytes as u64);
                 }
-                store.bytes = store.bytes.saturating_add(entry.cost);
-                store.logical_bytes = store.logical_bytes.saturating_add(entry.body.len());
-                store.lru.insert(entry.sequence, storage_key);
-                store.index_variant(entry.base_key, storage_key);
-                store.entries.insert(storage_key, entry);
                 self.counters.hits.fetch_add(1, Ordering::Relaxed);
                 return Some(result);
             }
-            store.bytes = store.bytes.saturating_add(entry.cost);
-            store.logical_bytes = store.logical_bytes.saturating_add(entry.body.len());
-            store.lru.insert(entry.sequence, storage_key);
-            store.index_variant(entry.base_key, storage_key);
-            store.entries.insert(storage_key, entry);
         }
         if count_miss {
             self.counters.misses.fetch_add(1, Ordering::Relaxed);