Improve secondary hashing

Author: IvanoBilenchi

bench/src/uhash_bench.c

@@ -7,10 +7,10 @@
 
 #include "khashl.h"
 #include "ulib.h"
+#include <stdint.h>
 
-#define klib_hash_int(x) ((khint_t)(x))
-UHASH_INIT(uint, ulib_uint, UHASH_VAL_IGNORE, ulib_hash_int, ulib_eq)
-KHASHL_SET_INIT(KH_LOCAL, kh_uint_t, kh_uint, ulib_uint, klib_hash_int, ulib_eq)
+UHASH_INIT(uint, uint32_t, UHASH_VAL_IGNORE, ulib_hash_int32, ulib_eq)
+KHASHL_SET_INIT(KH_LOCAL, kh_uint_t, kh_uint, uint32_t, kh_hash_uint32, ulib_eq)
 
 enum {
     SEED = 31,
@@ -26,9 +26,9 @@ typedef struct HashTable {
     char const *name;
     void *(*init)(void);
     void (*deinit)(void *);
-    bool (*insert)(void *, ulib_uint);
-    bool (*contains)(void *, ulib_uint);
-    bool (*remove)(void *, ulib_uint);
+    bool (*insert)(void *, uint32_t);
+    bool (*contains)(void *, uint32_t);
+    bool (*remove)(void *, uint32_t);
 } HashTable;
 
 // UHash
@@ -44,15 +44,15 @@ static void bench_uhash_deinit(void *h) {
     ulib_free(h);
 }
 
-static bool bench_uhash_insert(void *h, ulib_uint key) {
+static bool bench_uhash_insert(void *h, uint32_t key) {
     return uhset_insert(uint, h, key);
 }
 
-static bool bench_uhash_contains(void *h, ulib_uint key) {
+static bool bench_uhash_contains(void *h, uint32_t key) {
     return uhash_contains(uint, h, key);
 }
 
-static bool bench_uhash_remove(void *h, ulib_uint key) {
+static bool bench_uhash_remove(void *h, uint32_t key) {
     return uhset_remove(uint, h, key);
 }
 
@@ -77,18 +77,18 @@ static void bench_khashl_deinit(void *h) {
     kh_uint_destroy(h);
 }
 
-static bool bench_khashl_insert(void *h, ulib_uint key) {
+static bool bench_khashl_insert(void *h, uint32_t key) {
     int ret;
     kh_uint_put(h, key, &ret);
     return !!ret;
 }
 
-static bool bench_khashl_contains(void *h, ulib_uint key) {
+static bool bench_khashl_contains(void *h, uint32_t key) {
     kh_uint_t *ht = h;
     return kh_uint_get(ht, key) != kh_end(ht);
 }
 
-static bool bench_khashl_remove(void *h, ulib_uint key) {
+static bool bench_khashl_remove(void *h, uint32_t key) {
     kh_uint_t *ht = h;
     khint_t i = kh_uint_get(ht, key);
     if (i != kh_end(ht)) {
@@ -120,7 +120,7 @@ static void bench_hash(HashTable *table, ulib_uint size) {
     ulib_uint count = 0;
     ulog_perf("insert") {
         for (ulib_uint i = 0; i < size; ++i) {
-            ulib_uint key = urand_range(0, size >> 1);
+            uint32_t key = (uint32_t)urand_range(0, size >> 1);
             if (table->insert(h, key)) count++;
         }
     }
@@ -129,15 +129,15 @@ static void bench_hash(HashTable *table, ulib_uint size) {
     count = 0;
     ulog_perf("get") {
         for (ulib_uint i = 0; i < size; ++i) {
-            ulib_uint key = urand_range(0, size >> 1);
+            uint32_t key = (uint32_t)urand_range(0, size >> 1);
             if (table->contains(h, key)) count++;
         }
     }
     ulog_debug("Found: %" ULIB_UINT_FMT, count);
 
     ulog_perf("remove") {
         for (ulib_uint i = 0; i < size; ++i) {
-            ulib_uint key = urand_range(0, size >> 1);
+            uint32_t key = (uint32_t)urand_range(0, size >> 1);
             if (table->remove(h, key)) count++;
         }
     }

include/uhash.h

@@ -23,6 +23,7 @@
 #include "unumber.h"
 #include "uutils.h"
 #include "uwarning.h"
+#include <limits.h>
 #include <string.h>
 
 ULIB_BEGIN_DECLS
@@ -158,17 +159,21 @@ ULIB_CONST ULIB_INLINE ulib_uint p_uhash_upper_bound_default(ulib_uint buckets)
 #if defined(ULIB_TINY)
 ULIB_CONST ULIB_INLINE ulib_uint p_uhash_fib(ulib_uint hash, ulib_byte bits) {
     ulib_assert(bits);
-    return (ulib_uint)((unsigned)hash * 40503U) >> (16U - bits);
+    unsigned h = (unsigned)hash;
+    unsigned const shift = 16U - bits;
+    return (ulib_uint)((h ^ (h >> shift)) * 40503U) >> shift;
 }
 #elif defined(ULIB_HUGE)
 ULIB_CONST ULIB_INLINE ulib_uint p_uhash_fib(ulib_uint hash, ulib_byte bits) {
     ulib_assert(bits);
-    return hash * (ulib_uint)11400714819323198485LLU >> (64U - bits);
+    ulib_uint const shift = 64U - bits;
+    return (hash ^ (hash >> shift)) * (ulib_uint)11400714819323198485LLU >> shift;
 }
 #else
 ULIB_CONST ULIB_INLINE ulib_uint p_uhash_fib(ulib_uint hash, ulib_byte bits) {
     ulib_assert(bits);
-    return hash * (ulib_uint)2654435769LU >> (32U - bits);
+    ulib_uint const shift = 32U - bits;
+    return (hash ^ (hash >> shift)) * (ulib_uint)2654435769LU >> shift;
 }
 #endif
 

include/uhash_func.h

@@ -79,16 +79,16 @@ ULIB_BEGIN_DECLS
 ULIB_CONST
 ULIB_INLINE
 ulib_uint p_ulib_hash_int32(uint32_t key) {
-    return (ulib_uint)(key >> 17U ^ key ^ key << 6U);
+    return (ulib_uint)key ^ (ulib_uint)(key >> 16U);
 }
 
 #define ulib_hash_int32(key) p_ulib_hash_int32((uint32_t)(key))
 
 ULIB_CONST
 ULIB_INLINE
 ulib_uint p_ulib_hash_int64(uint64_t key) {
-    return (ulib_uint)(key >> 49U ^ key >> 33U ^ key >> 17U ^ key ^ key << 6U ^ key << 23U ^
-                       key << 39U);
+    return (ulib_uint)key ^ (ulib_uint)(key >> 16U) ^ (ulib_uint)(key >> 32U) ^
+           (ulib_uint)(key >> 48U);
 }
 
 #define ulib_hash_int64(key) p_ulib_hash_int64((uint32_t)(key))
@@ -105,7 +105,7 @@ ulib_uint p_ulib_hash_int64(uint64_t key) {
 ULIB_CONST
 ULIB_INLINE
 ulib_uint p_ulib_hash_int64(uint64_t key) {
-    return (ulib_uint)(key >> 33U ^ key ^ key << 11U);
+    return (ulib_uint)key ^ (ulib_uint)(key >> 32U);
 }
 
 #define ulib_hash_int64(key) p_ulib_hash_int64((uint64_t)(key))