Reduce work in cache

Author: ijl

Cargo.lock

@@ -60,7 +60,7 @@ ryu = { version = "1" }
 serde = { version = "1", default_features = false }
 serde_json = { path = "./json", default_features = false, features = ["std"] }
 smallvec = { version = "1", default_features = false, features = ["const_generics", "union", "specialization", "write"] }
-wyhash = { version = "0.4" }
+wy = { version = "1" }
 
 [target.'cfg(not(any(target_arch = "x86_64", target_arch = "aarch64", target_arch = "i686", target_arch = "armv7")))'.dependencies]
 encoding_rs = { path = "./encoding_rs", default_features = false }

Cargo.toml

@@ -590,7 +590,7 @@ The input must be valid UTF-8.
 
 orjson maintains a cache of map keys for the duration of the process. This
 causes a net reduction in memory usage by avoiding duplicate strings. The
-keys must be at most 64 chars to be cached and 512 entries are stored.
+keys must be at most 64 bytes to be cached and 512 entries are stored.
 
 It raises `JSONDecodeError` if given an invalid type or invalid
 JSON. This includes if the input contains `NaN`, `Infinity`, or `-Infinity`,

README.md

@@ -5,27 +5,25 @@ use associative_cache::*;
 use once_cell::unsync::OnceCell;
 use std::os::raw::c_void;
 
-#[derive(Clone)]
+#[repr(transparent)]
 pub struct CachedKey {
     ptr: *mut c_void,
-    hash: pyo3::ffi::Py_hash_t,
 }
 
 unsafe impl Send for CachedKey {}
 unsafe impl Sync for CachedKey {}
 
 impl CachedKey {
-    pub fn new(ptr: *mut pyo3::ffi::PyObject, hash: pyo3::ffi::Py_hash_t) -> CachedKey {
+    pub fn new(ptr: *mut pyo3::ffi::PyObject) -> CachedKey {
         CachedKey {
             ptr: ptr as *mut c_void,
-            hash: hash,
         }
     }
 
-    pub fn get(&mut self) -> (*mut pyo3::ffi::PyObject, pyo3::ffi::Py_hash_t) {
+    pub fn get(&mut self) -> *mut pyo3::ffi::PyObject {
         let ptr = self.ptr as *mut pyo3::ffi::PyObject;
         ffi!(Py_INCREF(ptr));
-        (ptr, self.hash)
+        ptr
     }
 }
 
@@ -36,6 +34,6 @@ impl Drop for CachedKey {
 }
 
 pub type KeyMap =
-    AssociativeCache<u64, CachedKey, Capacity512, HashDirectMapped, RoundRobinReplacement>;
+    AssociativeCache<u32, CachedKey, Capacity512, HashDirectMapped, RoundRobinReplacement>;
 
 pub static mut KEY_MAP: OnceCell<KeyMap> = OnceCell::new();

src/deserialize/cache.rs

@@ -10,7 +10,7 @@ use smallvec::SmallVec;
 use std::borrow::Cow;
 use std::fmt;
 use std::ptr::NonNull;
-use wyhash::wyhash;
+use wy::hash32;
 
 pub fn deserialize(
     ptr: *mut pyo3::ffi::PyObject,
@@ -167,8 +167,9 @@ impl<'de> Visitor<'de> for JsonValue {
         while let Some(key) = map.next_key::<Cow<str>>()? {
             let pykey: *mut pyo3::ffi::PyObject;
             let pyhash: pyo3::ffi::Py_hash_t;
+            let value = map.next_value_seed(self)?;
             if likely!(key.len() <= 64) {
-                let hash = unsafe { wyhash(key.as_bytes(), HASH_SEED) };
+                let hash = unsafe { hash32(key.as_bytes(), HASH_SEED) };
                 {
                     let map = unsafe {
                         KEY_MAP
@@ -179,18 +180,17 @@ impl<'de> Visitor<'de> for JsonValue {
                         || hash,
                         || {
                             let pyob = unicode_from_str(&key);
-                            CachedKey::new(pyob, hash_str(pyob))
+                            hash_str(pyob);
+                            CachedKey::new(pyob)
                         },
                     );
-                    let tmp = entry.get();
-                    pykey = tmp.0;
-                    pyhash = tmp.1;
+                    pykey = entry.get();
+                    pyhash = unsafe { (*pykey.cast::<PyASCIIObject>()).hash }
                 }
             } else {
                 pykey = unicode_from_str(&key);
                 pyhash = hash_str(pykey);
             }
-            let value = map.next_value_seed(self)?;
             let _ = ffi!(_PyDict_SetItem_KnownHash(
                 dict_ptr,
                 pykey,

src/deserialize/decode.rs

@@ -17,7 +17,7 @@ pub struct NumpyTypes {
     pub uint32: *mut PyTypeObject,
     pub uint8: *mut PyTypeObject,
 }
-pub static mut HASH_SEED: u64 = 0;
+pub static mut HASH_SEED: u32 = 0;
 
 pub static mut NONE: *mut PyObject = 0 as *mut PyObject;
 pub static mut TRUE: *mut PyObject = 0 as *mut PyObject;
@@ -102,7 +102,7 @@ pub fn init_typerefs() {
         ARRAY_STRUCT_STR =
             pyo3::ffi::PyUnicode_InternFromString("__array_struct__\0".as_ptr() as *const c_char);
         VALUE_STR = pyo3::ffi::PyUnicode_InternFromString("value\0".as_ptr() as *const c_char);
-        HASH_SEED = (VALUE_STR as u64).wrapping_mul(DICT_TYPE as u64);
+        HASH_SEED = ((VALUE_STR as u64).wrapping_mul(DICT_TYPE as u64)) as u32;
         DEFAULT = PyUnicode_InternFromString("default\0".as_ptr() as *const c_char);
         OPTION = PyUnicode_InternFromString("option\0".as_ptr() as *const c_char);
         JsonEncodeError = pyo3::ffi::PyExc_TypeError;