feat: Add `gitoxide.core.defaultPackCacheMemoryLimit` to control memory limits. (#851)

Previously the 64 slot LRU cache didn't have any limit, now one is implemented that defaults to about 96MB.

Sebastian Thiel committed 3 years ago

Commit 020ff4e1 parent 969cc775 files · +33 −7Browse files

Unified · Split

5 files

             lenient_config,
         )?;
         let object_kind_hint = util::disambiguate_hint(&config, lenient_config)?;
-        let (pack_cache_bytes, object_cache_bytes) =
+        let (static_pack_cache_limit_bytes, pack_cache_bytes, object_cache_bytes) =
             util::parse_object_caches(&config, lenient_config, filter_config_section)?;
         // NOTE: When adding a new initial cache, consider adjusting `reread_values_and_clear_caches()` as well.
         Ok(Cache {
             use_multi_pack_index,
             object_hash,
             object_kind_hint,
+            static_pack_cache_limit_bytes,
             pack_cache_bytes,
             object_cache_bytes,
             reflog,
         self.url_rewrite = Default::default();
         self.diff_renames = Default::default();
         self.diff_algorithm = Default::default();
-        (self.pack_cache_bytes, self.object_cache_bytes) =
+        (
-            util::parse_object_caches(config, self.lenient_config, self.filter_config_section)?;
+            self.static_pack_cache_limit_bytes,
+            self.pack_cache_bytes,
+            self.object_cache_bytes,
+        ) = util::parse_object_caches(config, self.lenient_config, self.filter_config_section)?;
         #[cfg(any(feature = "blocking-network-client", feature = "async-network-client"))]
         {
             self.url_scheme = Default::default();

     config: &gix_config::File<'static>,
     lenient: bool,
     mut filter_config_section: fn(&gix_config::file::Metadata) -> bool,
-) -> Result<(Option<usize>, usize), Error> {
+) -> Result<(Option<usize>, Option<usize>, usize), Error> {
+    let static_pack_cache_limit = config
+        .integer_filter_by_key("core.deltaBaseCacheLimit", &mut filter_config_section)
+        .map(|res| gitoxide::Core::DEFAULT_PACK_CACHE_MEMORY_LIMIT.try_into_usize(res))
+        .transpose()
+        .with_leniency(lenient)?;
     let pack_cache_bytes = config
         .integer_filter_by_key("core.deltaBaseCacheLimit", &mut filter_config_section)
         .map(|res| Core::DELTA_BASE_CACHE_LIMIT.try_into_usize(res))
         .transpose()
         .with_leniency(lenient)?
         .unwrap_or_default();
-    Ok((pack_cache_bytes, object_cache_bytes))
+    Ok((static_pack_cache_limit, pack_cache_bytes, object_cache_bytes))
 }
 pub(crate) fn parse_core_abbrev(

     pub(crate) pack_cache_bytes: Option<usize>,
     /// The amount of bytes to use for caching whole objects, or 0 to turn it off entirely.
     pub(crate) object_cache_bytes: usize,
+    /// The amount of bytes we can hold in our static LRU cache. Otherwise, go with the defaults.
+    pub(crate) static_pack_cache_limit_bytes: Option<usize>,
     /// The config section filter from the options used to initialize this instance. Keep these in sync!
     filter_config_section: fn(&gix_config::file::Metadata) -> bool,
     /// The object kind to pick if a prefix is ambiguous.

     pub struct Core;
     impl Core {
+        /// The `gitoxide.core.defaultPackCacheMemoryLimit` key.
+        pub const DEFAULT_PACK_CACHE_MEMORY_LIMIT: keys::UnsignedInteger =
+            keys::UnsignedInteger::new_unsigned_integer("defaultPackCacheMemoryLimit", &Gitoxide::CORE).with_note(
+                "If unset, we default to 96MB memory cap for the default 64 slot LRU cache for object deltas.",
+            );
         /// The `gitoxide.core.useNsec` key.
         pub const USE_NSEC: keys::Boolean = keys::Boolean::new_boolean("useNsec", &Gitoxide::CORE)
             .with_note("A runtime version of the USE_NSEC build flag.");
         }
         fn keys(&self) -> &[&dyn Key] {
-            &[&Self::USE_NSEC, &Self::USE_STDEV, &Self::SHALLOW_FILE]
+            &[
+                &Self::DEFAULT_PACK_CACHE_MEMORY_LIMIT,
+                &Self::USE_NSEC,
+                &Self::USE_STDEV,
+                &Self::SHALLOW_FILE,
+            ]
         }
         fn parent(&self) -> Option<&dyn Section> {

     #[cfg(feature = "max-performance-safe")]
     {
         match config.pack_cache_bytes {
-            None => objects.set_pack_cache(|| Box::<gix_pack::cache::lru::StaticLinkedList<64>>::default()),
+            None => match config.static_pack_cache_limit_bytes {
+                None => objects.set_pack_cache(|| Box::<gix_pack::cache::lru::StaticLinkedList<64>>::default()),
+                Some(limit) => {
+                    objects.set_pack_cache(move || Box::new(gix_pack::cache::lru::StaticLinkedList::<64>::new(limit)))
+                }
+            },
             Some(0) => objects.unset_pack_cache(),
             Some(bytes) => objects.set_pack_cache(move || -> Box<gix_odb::cache::PackCache> {
                 Box::new(gix_pack::cache::lru::MemoryCappedHashmap::new(bytes))