maxmind-db-rust 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c9ce85a0f2ba6a7852b6b3b12ffacc517f2a484f41fb686b131df4e7c7685fb
-  data.tar.gz: 85f03d7a87b5b855cdbe66e00106503692d9ef13270f9f99a2074210f042291a
+  metadata.gz: 854691c99c81b7d9574c780a7e10f80eea69788bb4dc95cce41361e5163d6f28
+  data.tar.gz: '086f7efa6e3620e3fd15d66b87964076647e7510551d58d98e4f484c69400173'
 SHA512:
-  metadata.gz: adadcd0e268b04c7aafa8d9540c62dce31158388c03e4539b9b579890d9572606cba2e83275e7d5f511e7c885c9b9ee0015ed581cc194b93618a5a8b89f1437c
-  data.tar.gz: b6c8eb6ddba493e62d145d2c028db95c13a54b8a64e41aff4d7651604890d77c31aac29f3eb5370c85da46e777369fc3c281d574408d5c0d965cfef3217c3159
+  metadata.gz: f20905fca81e3742ff75da2e5758fbd198d61dd5c7c82b23dd8ed9a731bf7a46dc707c6660590adb895e2c022b6f6d07edb7916eab774d4461faccd2de66ec2e
+  data.tar.gz: 888d4623247bf07a0c8058c669230032ebcef98b0efcc03920f1196cb1695361f2a868250ffeafb6fe3ed7913038b38f4b419d9ef5e3a1d5f3caecd0b1ec1bb0

data/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.4.0] - 2026-04-25
+
+### Performance
+
+- Restored lookup performance with a generic bounded cache of frozen Ruby strings reused across decoded keys and scalar values.
+- Removed hardcoded interned string tables in favor of the generic string cache.
+- Simplified decoding so lookups and iteration use the same `maxminddb` decode path again.
+- Reduced repeated cache-root lookup overhead with a thread-local `OnceCell` for the Ruby-owned string cache roots.
+- Borrowed decoded map keys directly during deserialization to avoid `Cow` overhead in the hot decode path.
+- Upgraded `maxminddb` crate to 0.28.0, which includes several performance
+  improvements.
+
 ## [0.3.0] - 2026-02-22
 
 ### Changed

data/ext/maxmind_db_rust/Cargo.toml

@@ -12,10 +12,10 @@ name = "maxmind_db_rust"
 crate-type = ["cdylib"]
 
 [dependencies]
-arc-swap = "1.8"
+arc-swap = "1.9"
 ipnetwork = "0.21"
 magnus = "0.8"
-maxminddb = { version = "0.27", features = ["unsafe-str-decode"] }
+maxminddb = { version = "0.28", features = ["unsafe-str-decode"] }
 memmap2 = "0.9"
 rustc-hash = "2.1"
 serde = "1.0"

data/ext/maxmind_db_rust/src/lib.rs

@@ -10,13 +10,14 @@ use magnus::{
 };
 use maxminddb_crate::{MaxMindDbError, Reader as MaxMindReader, Within};
 use memmap2::Mmap;
-use rustc_hash::FxHashMap;
+use rustc_hash::FxHasher;
 use serde::de::{self, Deserialize, DeserializeSeed, Deserializer, MapAccess, SeqAccess, Visitor};
 use std::{
-    cell::RefCell,
+    cell::{OnceCell, RefCell},
     collections::BTreeMap,
     fmt,
     fs::File,
+    hash::{Hash, Hasher},
     io::Read as IoRead,
     net::IpAddr,
     path::Path,
@@ -31,57 +32,94 @@ use std::{
 const ERR_CLOSED_DB: &str = "Attempt to read from a closed MaxMind DB.";
 const ERR_BAD_DATA: &str =
     "The MaxMind DB file's data section contains bad data (unknown data type or corrupt data)";
+const STRING_CACHE_ROOTS_CONST: &str = "__STRING_CACHE_ROOTS__";
+const MAP_KEY_ROOTS_CONST: &str = "__MAP_KEY_ROOTS__";
+const STRING_CACHE_MAX: usize = 4096;
+const STRING_CACHE_MIN_LEN: usize = 2;
+const STRING_CACHE_MAX_LEN: usize = 64;
+
+#[derive(Default)]
+struct StringCacheEntry {
+    hash: u64,
+    value: String,
+}
 
-thread_local! {
-    static MAP_KEY_CACHE: RefCell<MapKeyCache> = RefCell::new(MapKeyCache::new());
+struct StringCache {
+    entries: Box<[StringCacheEntry]>,
 }
 
-const MAP_KEY_CACHE_MAX: usize = 256;
-const MAP_KEY_ROOTS_CONST: &str = "__MAP_KEY_ROOTS__";
+impl StringCache {
+    fn new() -> Self {
+        let entries = (0..STRING_CACHE_MAX)
+            .map(|_| StringCacheEntry::default())
+            .collect::<Vec<_>>()
+            .into_boxed_slice();
+        Self { entries }
+    }
+}
 
-struct MapKeyCache {
-    key_to_index: FxHashMap<String, usize>,
+thread_local! {
+    static STRING_CACHE: RefCell<StringCache> = RefCell::new(StringCache::new());
+    static STRING_CACHE_ROOTS: OnceCell<RArray> = const { OnceCell::new() };
 }
 
-impl MapKeyCache {
-    #[inline]
-    fn new() -> Self {
-        Self {
-            key_to_index: FxHashMap::default(),
-        }
+#[inline]
+fn string_cache_roots_owner(ruby: &magnus::Ruby) -> RArray {
+    let value = rust_module(ruby)
+        .const_get::<_, Value>(STRING_CACHE_ROOTS_CONST)
+        .expect("string cache roots constant should exist");
+    RArray::from_value(value).expect("string cache roots constant should be an array")
+}
+
+#[inline]
+fn init_thread_string_cache_roots(ruby: &magnus::Ruby) -> RArray {
+    let roots = ruby.ary_new_capa(STRING_CACHE_MAX);
+    for _ in 0..STRING_CACHE_MAX {
+        roots
+            .push(ruby.qnil().as_value())
+            .expect("string cache roots initialization should succeed");
     }
+    string_cache_roots_owner(ruby)
+        .push(roots.as_value())
+        .expect("string cache roots owner should retain per-thread roots");
+    roots
 }
 
 #[inline]
-fn map_key_roots_array(ruby: &magnus::Ruby) -> RArray {
-    let rust = rust_module(ruby);
-    let roots = rust
-        .const_get::<_, Value>(MAP_KEY_ROOTS_CONST)
-        .expect("map key roots constant should exist");
-    RArray::from_value(roots).expect("map key roots constant should be an array")
+fn string_cache_roots(ruby: &magnus::Ruby) -> RArray {
+    STRING_CACHE_ROOTS.with(|roots| *roots.get_or_init(|| init_thread_string_cache_roots(ruby)))
 }
 
 #[inline]
-fn cached_map_key(ruby: &magnus::Ruby, key: &str) -> Value {
-    MAP_KEY_CACHE.with(|cache| {
-        let mut cache = cache.borrow_mut();
-        let roots = map_key_roots_array(ruby);
-        if let Some(index) = cache.key_to_index.get(key) {
-            return roots
-                .entry::<Value>(*index as isize)
-                .expect("cached map key index should be valid");
-        }
+fn cached_string(ruby: &magnus::Ruby, value: &str) -> Value {
+    if !(STRING_CACHE_MIN_LEN..=STRING_CACHE_MAX_LEN).contains(&value.len()) {
+        return ruby.str_new(value).into_value_with(ruby);
+    }
 
-        let interned = ruby.str_new(key).to_interned_str();
-        let value = interned.as_value();
-        if cache.key_to_index.len() < MAP_KEY_CACHE_MAX {
-            let index = roots.len();
-            roots
-                .push(value)
-                .expect("map key roots array push should succeed");
-            cache.key_to_index.insert(key.to_owned(), index);
+    let mut hasher = FxHasher::default();
+    value.hash(&mut hasher);
+    let hash = hasher.finish();
+    let slot = (hash as usize) & (STRING_CACHE_MAX - 1);
+
+    STRING_CACHE.with(|cache_cell| {
+        let mut cache = cache_cell.borrow_mut();
+        let entry = &mut cache.entries[slot];
+        if entry.hash == hash && entry.value == value {
+            return string_cache_roots(ruby)
+                .entry::<Value>(slot as isize)
+                .expect("string cache roots lookup should succeed");
         }
-        value
+
+        let string = ruby.str_new(value);
+        string.freeze();
+        let cached = string.as_value();
+        string_cache_roots(ruby)
+            .store(slot as isize, cached)
+            .expect("string cache roots update should succeed");
+        entry.hash = hash;
+        entry.value.clear();
+        entry.value.push_str(value);
+        cached
     })
 }
 
@@ -214,18 +252,14 @@ impl<'de, 'ruby> Visitor<'de> for RubyValueVisitor<'ruby> {
     where
         E: de::Error,
     {
-        Ok(RubyDecodedValue::new(
-            self.ruby.str_new(value).into_value_with(self.ruby),
-        ))
+        Ok(RubyDecodedValue::new(cached_string(self.ruby, value)))
     }
 
     fn visit_string<E>(self, value: String) -> Result<Self::Value, E>
     where
         E: de::Error,
     {
-        Ok(RubyDecodedValue::new(
-            self.ruby.str_new(&value).into_value_with(self.ruby),
-        ))
+        Ok(RubyDecodedValue::new(cached_string(self.ruby, &value)))
     }
 
     fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
@@ -270,8 +304,8 @@ impl<'de, 'ruby> Visitor<'de> for RubyValueVisitor<'ruby> {
             None => self.ruby.hash_new(),
         };
         while let Some(key) = map.next_key::<&'de str>()? {
-            let key_val = cached_map_key(self.ruby, key);
             let value = map.next_value_seed(RubyValueSeed { ruby: self.ruby })?;
+            let key_val = cached_string(self.ruby, key);
             hash.aset(key_val, value.into_value())
                 .map_err(|e| de::Error::custom(e.to_string()))?;
         }
@@ -302,10 +336,19 @@ impl ReaderSource {
         &self,
         ip: IpAddr,
     ) -> Result<(Option<RubyDecodedValue>, usize), maxminddb_crate::MaxMindDbError> {
-        match self {
-            ReaderSource::Mmap(reader) => lookup_prefix_for_reader(reader, ip),
-            ReaderSource::Memory(reader) => lookup_prefix_for_reader(reader, ip),
-        }
+        let (result, prefix_len) = match self {
+            ReaderSource::Mmap(reader) => {
+                let result = reader.lookup(ip)?;
+                let network = result.network()?;
+                (result.decode()?, prefix_len_for_ip_network(ip, network))
+            }
+            ReaderSource::Memory(reader) => {
+                let result = reader.lookup(ip)?;
+                let network = result.network()?;
+                (result.decode()?, prefix_len_for_ip_network(ip, network))
+            }
+        };
+        Ok((result, prefix_len))
     }
 
     #[inline]
@@ -321,15 +364,12 @@ impl ReaderSource {
         match self {
             ReaderSource::Mmap(reader) => {
                 let iter = reader.within(network, Default::default())?;
-                // SAFETY: the iterator holds a reference into `reader`. We'll store an Arc guard
-                // alongside it so the reader outlives the transmuted iterator.
                 Ok(ReaderWithin::Mmap(unsafe {
                     std::mem::transmute::<Within<'_, Mmap>, Within<'static, Mmap>>(iter)
                 }))
             }
             ReaderSource::Memory(reader) => {
                 let iter = reader.within(network, Default::default())?;
-                // SAFETY: same as above, the Arc guard keeps the reader alive.
                 Ok(ReaderWithin::Memory(unsafe {
                     std::mem::transmute::<Within<'_, Vec<u8>>, Within<'static, Vec<u8>>>(iter)
                 }))
@@ -353,17 +393,6 @@ impl ReaderWithin {
     }
 }
 
-#[inline]
-fn lookup_prefix_for_reader<S: AsRef<[u8]>>(
-    reader: &MaxMindReader<S>,
-    ip: IpAddr,
-) -> Result<(Option<RubyDecodedValue>, usize), maxminddb_crate::MaxMindDbError> {
-    let result = reader.lookup(ip)?;
-    let network = result.network()?;
-    let prefix_len = prefix_len_for_ip_network(ip, network);
-    Ok((result.decode()?, prefix_len))
-}
-
 #[inline]
 // prefix_len_for_ip_network uses 0 as a sentinel for ip.is_ipv4() && network.is_ipv6().
 // In this case, 0 is not a real prefix length; it signals an IPv4-in-IPv6 mapping path,
@@ -725,7 +754,6 @@ impl Reader {
                 format!("Failed to iterate: {}", e),
             )
         })?;
-
         // Get IPAddr class
         let ipaddr_class = ruby.class_object().const_get::<_, RClass>("IPAddr")?;
 
@@ -869,7 +897,6 @@ fn open_database_mmap(path: &str) -> Result<Reader, Error> {
             format!("Failed to memory-map database file: {}", e),
         )
     })?;
-
     let reader = MaxMindReader::from_source(mmap).map_err(|_| {
         Error::new(
             ExceptionClass::from_value(invalid_database_error().as_value())
@@ -1004,8 +1031,15 @@ fn init(ruby: &magnus::Ruby) -> Result<(), Error> {
         }
     };
 
-    if rust.const_get::<_, Value>(MAP_KEY_ROOTS_CONST).is_err() {
-        rust.const_set(MAP_KEY_ROOTS_CONST, ruby.ary_new_capa(MAP_KEY_CACHE_MAX))?;
+    if rust
+        .const_get::<_, Value>(STRING_CACHE_ROOTS_CONST)
+        .is_err()
+    {
+        rust.const_set(STRING_CACHE_ROOTS_CONST, ruby.ary_new())?;
+    }
+
+    if rust.const_get::<_, Value>(MAP_KEY_ROOTS_CONST).is_ok() {
+        let _ = rust.funcall::<_, _, Value>("send", ("remove_const", MAP_KEY_ROOTS_CONST))?;
     }
 
     // The extension can be loaded more than once from different paths.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: maxmind-db-rust
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Gregory Oschwald
@@ -191,7 +191,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Unofficial high-performance Rust-based MaxMind DB reader for Ruby
 test_files: []