Improve the capacity recommender

Author: jedisct1

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sieve-cache"
-version = "1.1.3"
+version = "1.1.4"
 edition = "2021"
 description = "SIEVE cache replacement policy with thread-safe wrappers"
 homepage = "https://github.com/jedisct1/rust-sieve-cache"

src/lib.rs

@@ -945,24 +945,20 @@ impl<K: Eq + Hash + Clone, V> SieveCache<K, V> {
         // Calculate the utilization ratio (visited entries / total entries)
         let utilization_ratio = visited_count as f64 / self.nodes.len() as f64;
 
-        // Calculate a fill ratio (how full the cache is)
-        let fill_ratio = self.nodes.len() as f64 / self.capacity as f64;
-
         // Determine scaling factor based on utilization
         let scaling_factor = if utilization_ratio >= high_threshold {
             // High utilization - recommend increasing the capacity
             // Scale between 1.0 and max_factor based on utilization above the high threshold
             let utilization_above_threshold =
                 (utilization_ratio - high_threshold) / (1.0 - high_threshold);
             1.0 + (max_factor - 1.0) * utilization_above_threshold
-        } else if utilization_ratio <= low_threshold && fill_ratio > 0.8 {
-            // Lower the fill ratio threshold for tests
-            // Low utilization and cache is reasonably full - recommend decreasing capacity
+        } else if utilization_ratio <= low_threshold {
+            // Low utilization - recommend decreasing capacity regardless of fill ratio
             // Scale between min_factor and 1.0 based on how far below the low threshold
             let utilization_below_threshold = (low_threshold - utilization_ratio) / low_threshold;
             1.0 - (1.0 - min_factor) * utilization_below_threshold
         } else {
-            // Normal utilization or cache isn't full enough - keep current capacity
+            // Normal utilization - keep current capacity
             1.0
         };
 
@@ -1133,7 +1129,14 @@ fn test_recommended_capacity() {
             cache.get(&i.to_string());
         }
     }
-    // With 50% utilization (between thresholds), should keep capacity the same
+    // With 50% utilization (between thresholds), capacity should be fairly stable
     let recommended = cache.recommended_capacity(0.5, 2.0, 0.3, 0.7);
-    assert_eq!(recommended, 100);
+    assert!(
+        recommended >= 95,
+        "With normal utilization, capacity should be close to original"
+    );
+    assert!(
+        recommended <= 100,
+        "With normal utilization, capacity should not exceed original"
+    );
 }

src/sharded.rs

@@ -1107,8 +1107,13 @@ where
             total_recommended += shard_recommended;
         }
 
-        // Ensure we return at least the number of shards (minimum 1 capacity per shard)
-        std::cmp::max(self.num_shards, total_recommended)
+        // Ensure we return at least the original capacity for an empty cache
+        // and at least the number of shards otherwise
+        if self.is_empty() {
+            self.capacity()
+        } else {
+            std::cmp::max(self.num_shards, total_recommended)
+        }
     }
 }
 
@@ -1552,9 +1557,16 @@ mod tests {
                 cache.get(&i.to_string());
             }
         }
-        // With 50% utilization (between thresholds), should keep capacity the same
+        // With 50% utilization (between thresholds), capacity should be fairly stable
         let recommended = cache.recommended_capacity(0.5, 2.0, 0.3, 0.7);
-        assert_eq!(recommended, 100);
+        assert!(
+            recommended >= 95,
+            "With normal utilization, capacity should be close to original"
+        );
+        assert!(
+            recommended <= 100,
+            "With normal utilization, capacity should not exceed original"
+        );
     }
 
     #[test]

src/sync.rs

@@ -1204,9 +1204,16 @@ mod tests {
                 cache.get(&i.to_string());
             }
         }
-        // With 50% utilization (between thresholds), should keep capacity the same
+        // With 50% utilization (between thresholds), capacity should be fairly stable
         let recommended = cache.recommended_capacity(0.5, 2.0, 0.3, 0.7);
-        assert_eq!(recommended, 100);
+        assert!(
+            recommended >= 95,
+            "With normal utilization, capacity should be close to original"
+        );
+        assert!(
+            recommended <= 100,
+            "With normal utilization, capacity should not exceed original"
+        );
     }
 
     #[test]