Respect ModuleCache max size (#5441)

## Motivation

`ModuleCache::insert()` never incremented `total_size` after inserting a
new entry. It only decremented during
eviction in `reduce_size_to()`. This meant:

- `total_size` was permanently 0
- The eviction check `if self.total_size + bytecode_size >
self.max_size` never triggered
- The cache grew unboundedly despite the 512 MiB limit
- `reduce_size_to()` would underflow on the subtraction `self.total_size
-= bytecode_size`

## Proposal

- Add `self.total_size += bytecode_size` after insertion, only when the
key wasn't already present (to avoid
double-counting on re-insertion of the same bytecode)
- Add an early return when a single bytecode exceeds `max_size`, which
prevents an underflow in the `self.max_size -
bytecode_size` computation passed to `reduce_size_to()`
- Add 4 unit tests covering: size tracking, eviction triggering,
oversized rejection, and duplicate key handling

## Test Plan

- CI + new tests pass

## Release Plan

- These changes should be backported to the latest `testnet` branch,
then
    - be released in a validator hotfix.

Author: ndr-ds

Cargo.lock

@@ -152,7 +152,7 @@ kube = "0.88.1"
 linera-kywasmtime = "0.1.0"
 linked-hash-map = "0.5.6"
 log = "0.4.21"
-lru = "0.12.3"
+lru = "0.15.0"
 mini-moka = "0.10.3"
 nonzero_lit = "0.1.2"
 num-bigint = "0.4.3"

Cargo.toml

@@ -32,6 +32,17 @@ impl<Module> Default for ModuleCache<Module> {
     }
 }
 
+impl<Module> ModuleCache<Module> {
+    #[cfg(test)]
+    fn with_max_size(max_size: u64) -> Self {
+        ModuleCache {
+            modules: LruCache::unbounded(),
+            total_size: 0,
+            max_size,
+        }
+    }
+}
+
 impl<Module: Clone> ModuleCache<Module> {
     /// Returns a `Module` for the requested `bytecode`, creating it with `module_builder` and
     /// adding it to the cache if it doesn't already exist in the cache.
@@ -58,11 +69,20 @@ impl<Module: Clone> ModuleCache<Module> {
     pub fn insert(&mut self, bytecode: Bytecode, module: Module) {
         let bytecode_size = bytecode.as_ref().len() as u64;
 
+        if bytecode_size > self.max_size {
+            return;
+        }
+
+        if self.modules.promote(&bytecode) {
+            return;
+        }
+
         if self.total_size + bytecode_size > self.max_size {
             self.reduce_size_to(self.max_size - bytecode_size);
         }
 
         self.modules.put(bytecode, module);
+        self.total_size += bytecode_size;
     }
 
     /// Evicts entries from the cache so that the total size of cached bytecode files is less than
@@ -79,3 +99,71 @@ impl<Module: Clone> ModuleCache<Module> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn bytecode(size: usize) -> Bytecode {
+        Bytecode::new(vec![0u8; size])
+    }
+
+    fn distinct_bytecode(size: usize, discriminant: u8) -> Bytecode {
+        let mut bytes = vec![0u8; size];
+        bytes[0] = discriminant;
+        Bytecode::new(bytes)
+    }
+
+    #[test]
+    fn total_size_tracks_insertions() {
+        let mut cache = ModuleCache::<u32>::with_max_size(1000);
+        cache.insert(bytecode(100), 1);
+        assert_eq!(cache.total_size, 100);
+        cache.insert(distinct_bytecode(200, 1), 2);
+        assert_eq!(cache.total_size, 300);
+    }
+
+    #[test]
+    fn eviction_triggers_when_full() {
+        let mut cache = ModuleCache::<u32>::with_max_size(250);
+        cache.insert(bytecode(100), 1);
+        cache.insert(distinct_bytecode(100, 1), 2);
+        assert_eq!(cache.total_size, 200);
+        assert_eq!(cache.modules.len(), 2);
+
+        cache.insert(distinct_bytecode(100, 2), 3);
+        assert_eq!(cache.modules.len(), 2);
+        assert!(cache.total_size <= 250);
+    }
+
+    #[test]
+    fn oversized_bytecode_is_rejected() {
+        let mut cache = ModuleCache::<u32>::with_max_size(50);
+        cache.insert(bytecode(100), 1);
+        assert_eq!(cache.total_size, 0);
+        assert_eq!(cache.modules.len(), 0);
+    }
+
+    #[test]
+    fn reinserting_same_key_does_not_double_count() {
+        let mut cache = ModuleCache::<u32>::with_max_size(1000);
+        let bc = bytecode(100);
+        cache.insert(bc.clone(), 1);
+        assert_eq!(cache.total_size, 100);
+        cache.insert(bc, 2);
+        assert_eq!(cache.total_size, 100);
+        assert_eq!(cache.modules.len(), 1);
+    }
+
+    #[test]
+    fn reinserting_existing_key_does_not_evict() {
+        let mut cache = ModuleCache::<u32>::with_max_size(200);
+        cache.insert(bytecode(100), 1);
+        cache.insert(distinct_bytecode(100, 1), 2);
+        assert_eq!(cache.modules.len(), 2);
+
+        cache.insert(bytecode(100), 3);
+        assert_eq!(cache.modules.len(), 2);
+        assert_eq!(cache.total_size, 200);
+    }
+}