ahash compile-time-rng

Cargo.toml

@@ -45,7 +45,7 @@ no-panic = [
 yyjson = []
 
 [dependencies]
-ahash = { version = "=0.8.6", default_features = false }
+ahash = { version = "=0.8.6", default_features = false, features = ["compile-time-rng"] }
 arrayvec = { version = "0.7", default_features = false, features = ["std", "serde"] }
 associative-cache = { version = "2", default_features = false }
 beef = { version = "0.5", default_features = false, features = ["impl_serde"] }

src/deserialize/cache.rs

@@ -1,10 +1,8 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
-use crate::typeref::HASH_BUILDER;
 use associative_cache::replacement::RoundRobinReplacement;
 use associative_cache::*;
 use once_cell::unsync::OnceCell;
-use std::hash::BuildHasher;
 use std::hash::Hasher;
 use std::os::raw::c_void;
 
@@ -42,12 +40,13 @@ pub type KeyMap =
 pub static mut KEY_MAP: OnceCell<KeyMap> = OnceCell::new();
 
 pub fn cache_hash(key: &[u8]) -> u64 {
+    // try to omit code for >64 path in ahash
+    debug_assert!(key.len() <= 64);
     #[cfg(feature = "intrinsics")]
     unsafe {
-        std::intrinsics::assume(!key.is_empty());
         std::intrinsics::assume(key.len() <= 64);
-    }
-    let mut hasher = unsafe { HASH_BUILDER.get().unwrap().build_hasher() };
+    };
+    let mut hasher = ahash::AHasher::default();
     hasher.write(key);
     hasher.finish()
 }

src/deserialize/pyobject.rs

@@ -2,34 +2,39 @@
 
 use crate::deserialize::cache::*;
 use crate::str::{hash_str, unicode_from_str};
-use crate::typeref::{EMPTY_UNICODE, FALSE, NONE, TRUE};
+use crate::typeref::{FALSE, NONE, TRUE};
 use std::ptr::NonNull;
 
 pub fn get_unicode_key(key_str: &str) -> *mut pyo3_ffi::PyObject {
-    let pykey: *mut pyo3_ffi::PyObject;
-    if unlikely!(key_str.len() > 64) {
-        pykey = unicode_from_str(key_str);
-        hash_str(pykey);
-    } else if unlikely!(key_str.is_empty()) {
-        pykey = use_immortal!(EMPTY_UNICODE);
+    let pykey = if unlikely!(key_str.len() > 64) {
+        create_str_impl(key_str)
     } else {
-        let hash = cache_hash(key_str.as_bytes());
-        let map = unsafe { KEY_MAP.get_mut().unwrap_or_else(|| unreachable!()) };
-        let entry = map.entry(&hash).or_insert_with(
-            || hash,
-            || {
-                let pyob = unicode_from_str(key_str);
-                hash_str(pyob);
-                CachedKey::new(pyob)
-            },
-        );
-        pykey = entry.get();
-    }
+        get_unicode_key_impl(key_str)
+    };
     debug_assert!(ffi!(Py_REFCNT(pykey)) >= 1);
     debug_assert!(unsafe { (*pykey.cast::<pyo3_ffi::PyASCIIObject>()).hash != -1 });
     pykey
 }
 
+fn get_unicode_key_impl(key_str: &str) -> *mut pyo3_ffi::PyObject {
+    let hash = cache_hash(key_str.as_bytes());
+    let map = unsafe { KEY_MAP.get_mut().unwrap_or_else(|| unreachable!()) };
+    let entry = map.entry(&hash).or_insert_with(
+        || hash,
+        || {
+            let pyob = create_str_impl(key_str);
+            CachedKey::new(pyob)
+        },
+    );
+    entry.get()
+}
+
+fn create_str_impl(key_str: &str) -> *mut pyo3_ffi::PyObject {
+    let pyob = unicode_from_str(key_str);
+    hash_str(pyob);
+    pyob
+}
+
 #[allow(dead_code)]
 #[inline(always)]
 pub fn parse_bool(val: bool) -> NonNull<pyo3_ffi::PyObject> {

src/typeref.rs

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
 use crate::ffi::orjson_fragmenttype_new;
-use ahash::RandomState;
 use once_cell::race::{OnceBool, OnceBox};
 use pyo3_ffi::*;
 #[cfg(feature = "yyjson")]
@@ -76,23 +75,6 @@ pub static mut DESCR_STR: *mut PyObject = null_mut();
 pub static mut VALUE_STR: *mut PyObject = null_mut();
 pub static mut INT_ATTR_STR: *mut PyObject = null_mut();
 
-pub static mut HASH_BUILDER: OnceBox<ahash::RandomState> = OnceBox::new();
-
-pub fn ahash_init() -> Box<ahash::RandomState> {
-    unsafe {
-        debug_assert!(!VALUE_STR.is_null());
-        debug_assert!(!DICT_TYPE.is_null());
-        debug_assert!(!STR_TYPE.is_null());
-        debug_assert!(!BYTES_TYPE.is_null());
-        Box::new(RandomState::with_seeds(
-            VALUE_STR as u64,
-            DICT_TYPE as u64,
-            STR_TYPE as u64,
-            BYTES_TYPE as u64,
-        ))
-    }
-}
-
 #[cfg(feature = "yyjson")]
 pub const YYJSON_BUFFER_SIZE: usize = 1024 * 1024 * 8;
 
@@ -214,9 +196,6 @@ fn _init_typerefs_impl() -> bool {
         JsonEncodeError = pyo3_ffi::PyExc_TypeError;
         Py_INCREF(JsonEncodeError);
         JsonDecodeError = look_up_json_exc();
-
-        // after all type lookups
-        HASH_BUILDER.get_or_init(ahash_init);
     };
     true
 }