ahash instead of wyhash

Author: ijl

Cargo.lock

@@ -51,6 +51,7 @@ classifier = [
 ]
 
 [dependencies]
+ahash = { version = "0.7", default_features = false }
 associative-cache = { version = "1" }
 bytecount = { version = "^0.6.2", default_features = false, features = ["generic-simd", "runtime-dispatch-simd"] }
 encoding_rs = { version = "0.8", default_features = false }
@@ -62,7 +63,6 @@ ryu = { version = "1" }
 serde = { version = "1", default_features = false }
 serde_json = { path = "./json", default_features = false, features = ["std"] }
 smallvec = { version = "^1.6", default_features = false, features = ["const_generics", "union", "specialization", "write"] }
-wyhash = { version = "0.5" }
 
 [target.'cfg(any(target_arch = "x86_64", target_arch = "aarch64", target_arch = "i686", target_arch = "armv7"))'.dependencies]
 encoding_rs = { version = "0.8", default_features = false, features = ["simd-accel"] }

Cargo.toml

@@ -1,5 +1,7 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
+use crate::typeref::*;
+use ahash::CallHasher;
 use associative_cache::replacement::RoundRobinReplacement;
 use associative_cache::*;
 use once_cell::unsync::OnceCell;
@@ -37,3 +39,7 @@ pub type KeyMap =
     AssociativeCache<u64, CachedKey, Capacity512, HashDirectMapped, RoundRobinReplacement>;
 
 pub static mut KEY_MAP: OnceCell<KeyMap> = OnceCell::new();
+
+pub fn cache_hash(key: &[u8]) -> u64 {
+    <[u8]>::get_hash(&key, unsafe { &*HASH_BUILDER })
+}

src/deserialize/cache.rs

@@ -11,7 +11,6 @@ use std::borrow::Cow;
 use std::fmt;
 use std::os::raw::c_char;
 use std::ptr::NonNull;
-use wyhash::wyhash;
 
 pub fn deserialize(
     ptr: *mut pyo3::ffi::PyObject,
@@ -173,11 +172,11 @@ impl<'de> Visitor<'de> for JsonValue {
     {
         let dict_ptr = ffi!(PyDict_New());
         while let Some(key) = map.next_key::<Cow<str>>()? {
+            let value = map.next_value_seed(self)?;
             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 = cache_hash(key.as_bytes());
                 {
                     let map = unsafe {
                         KEY_MAP

src/deserialize/deserializer.rs

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: (Apache-2.0 OR MIT)
 
+use ahash::RandomState;
 use once_cell::unsync::Lazy;
 use pyo3::ffi::*;
 use std::os::raw::c_char;
@@ -17,7 +18,6 @@ pub struct NumpyTypes {
     pub uint32: *mut PyTypeObject,
     pub uint8: *mut PyTypeObject,
 }
-pub static mut HASH_SEED: u64 = 0;
 
 pub static mut NONE: *mut PyObject = 0 as *mut PyObject;
 pub static mut TRUE: *mut PyObject = 0 as *mut PyObject;
@@ -57,6 +57,14 @@ pub static mut VALUE_STR: *mut PyObject = 0 as *mut PyObject;
 pub static mut STR_HASH_FUNCTION: Option<hashfunc> = None;
 pub static mut DEFAULT: *mut PyObject = 0 as *mut PyObject;
 pub static mut OPTION: *mut PyObject = 0 as *mut PyObject;
+pub static mut HASH_BUILDER: Lazy<ahash::RandomState> = Lazy::new(|| unsafe {
+    RandomState::with_seeds(
+        VALUE_STR as u64,
+        DICT_TYPE as u64,
+        STR_TYPE as u64,
+        BYTES_TYPE as u64,
+    )
+});
 
 #[allow(non_upper_case_globals)]
 pub static mut JsonEncodeError: *mut PyObject = 0 as *mut PyObject;
@@ -114,7 +122,6 @@ 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);
         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;