Use FNV1a hash instead of Murmur3

It's much simpler, and in some cases can even be inlined.

Author: lpereira

src/bin/tools/CMakeLists.txt

@@ -5,7 +5,6 @@ else ()
 	add_executable(mimegen
 		mimegen.c
 		${CMAKE_SOURCE_DIR}/src/lib/hash.c
-		${CMAKE_SOURCE_DIR}/src/lib/murmur3.c
 		${CMAKE_SOURCE_DIR}/src/lib/missing.c
 	)
 	if (LWAN_HAVE_BROTLI)
@@ -37,7 +36,6 @@ else ()
 		${CMAKE_SOURCE_DIR}/src/lib/lwan-strbuf.c
 		${CMAKE_SOURCE_DIR}/src/lib/missing.c
 		${CMAKE_SOURCE_DIR}/src/lib/hash.c
-		${CMAKE_SOURCE_DIR}/src/lib/murmur3.c
 	)
 
 	add_executable(weighttp weighttp.c)

src/lib/CMakeLists.txt

@@ -39,7 +39,6 @@ set(SOURCES
 	missing.c
 	missing-pthread.c
 	missing-epoll.c
-	murmur3.c
 	patterns.c
 	realpathat.c
 	sd-daemon.c

src/lib/hash.c

@@ -34,7 +34,6 @@
 
 #include "lwan-private.h"
 #include "hash.h"
-#include "murmur3.h"
 
 struct hash_bucket {
     void **keys;
@@ -81,11 +80,12 @@ struct hash_entry {
 static_assert((MIN_BUCKETS & (MIN_BUCKETS - 1)) == 0,
               "Bucket size is power of 2");
 
+static inline unsigned int hash_fnv1a_32(const void *keyptr);
 static inline unsigned int hash_int_shift_mult(const void *keyptr);
 static inline unsigned int hash_int64_shift_mult(const void *keyptr);
 
 static unsigned int odd_constant = DEFAULT_ODD_CONSTANT;
-static unsigned (*hash_str)(const void *key) = murmur3_simple;
+static unsigned (*hash_str)(const void *key) = hash_fnv1a_32;
 static unsigned (*hash_int)(const void *key) = hash_int_shift_mult;
 static unsigned (*hash_int64)(const void *key) = hash_int64_shift_mult;
 
@@ -115,28 +115,21 @@ static bool resize_bucket(struct hash_bucket *bucket, unsigned int new_size)
     return false;
 }
 
+static inline unsigned int hash_fnv1a_32(const void *keyptr)
+{
+    return fnv1a_32(keyptr, strlen(keyptr));
+}
+
 static inline unsigned int hash_int_shift_mult(const void *keyptr)
 {
-    /* http://www.concentric.net/~Ttwang/tech/inthash.htm */
     unsigned int key = (unsigned int)(long)keyptr;
-    unsigned int c2 = odd_constant;
-
-    key = (key ^ 61) ^ (key >> 16);
-    key += key << 3;
-    key ^= key >> 4;
-    key *= c2;
-    key ^= key >> 15;
-    return key;
+    return fnv1a_32(&key, sizeof(key));
 }
 
 static inline unsigned int hash_int64_shift_mult(const void *keyptr)
 {
     const uint64_t key = (uint64_t)(uintptr_t)keyptr;
-    uint32_t key_low = (uint32_t)(key & 0xffffffff);
-    uint32_t key_high = (uint32_t)(key >> 32);
-
-    return hash_int_shift_mult((void *)(uintptr_t)key_low) ^
-           hash_int_shift_mult((void *)(uintptr_t)key_high);
+    return fnv1a_32(&key, sizeof(key));
 }
 
 #if defined(LWAN_HAVE_BUILTIN_CPU_INIT) && defined(LWAN_HAVE_BUILTIN_IA32_CRC32)
@@ -200,14 +193,19 @@ static inline unsigned int hash_int64_crc32(const void *keyptr)
 
 #endif
 
+uint64_t fnv1a_64_seed = 0xcbf29ce484222325ull;
+uint32_t fnv1a_32_seed = 0x811c9dc5u;
+
 __attribute__((constructor(65535))) static void initialize_odd_constant(void)
 {
     /* This constant is randomized in order to mitigate the DDoS attack
      * described by Crosby and Wallach in UsenixSec2003.  */
     if (lwan_getentropy(&odd_constant, sizeof(odd_constant), 0) < 0)
         odd_constant = DEFAULT_ODD_CONSTANT;
     odd_constant |= 1;
-    murmur3_set_seed(odd_constant);
+
+    fnv1a_64_seed = fnv1a_64(&odd_constant, sizeof(odd_constant));
+    fnv1a_32_seed = fnv1a_32(&odd_constant, sizeof(odd_constant));
 
 #if defined(LWAN_HAVE_BUILTIN_CPU_INIT) && defined(LWAN_HAVE_BUILTIN_IA32_CRC32)
     __builtin_cpu_init();

src/lib/hash.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <stdint.h>
 #include <stdbool.h>
 #include <sys/types.h>
 
@@ -30,3 +31,30 @@ void hash_iter_init(const struct hash *hash, struct hash_iter *iter);
 bool hash_iter_next(struct hash_iter *iter,
                     const void **key,
                     const void **value);
+
+extern uint64_t fnv1a_64_seed;
+extern uint32_t fnv1a_32_seed;
+
+static inline uint64_t fnv1a_64(const void *buffer, size_t len)
+{
+    const unsigned char *data = (unsigned char *)buffer;
+    uint64_t hash;
+
+    for (hash = fnv1a_64_seed; len--; data++) {
+        hash = (hash ^ *data) * 0x100000001b3ul;
+    }
+
+    return hash;
+}
+
+static inline uint32_t fnv1a_32(const void *buffer, size_t len)
+{
+    const unsigned char *data = (unsigned char *)buffer;
+    uint32_t hash;
+
+    for (hash = fnv1a_32_seed; len--; data++) {
+        hash = (hash ^ *data) * 0x1000193u;
+    }
+
+    return hash;
+}

src/lib/lwan-thread.c

@@ -47,7 +47,6 @@
 #endif
 
 #include "list.h"
-#include "murmur3.h"
 #include "lwan-private.h"
 #include "lwan-tq.h"
 
@@ -124,9 +123,10 @@ static void lwan_random_seed_prng_for_thread(const struct lwan_thread *t)
 {
     if (lwan_getentropy(&lehmer64_state, sizeof(lehmer64_state), 0) < 0) {
         lwan_status_warning("Couldn't get proper entropy for PRNG, using fallback seed");
-        lehmer64_state |= murmur3_fmix64((uint64_t)(uintptr_t)t);
+        uintptr_t ptr = (uintptr_t)t;
+        lehmer64_state |= fnv1a_64(&ptr, sizeof(ptr));
         lehmer64_state <<= 64;
-        lehmer64_state |= murmur3_fmix64((uint64_t)t->epoll_fd);
+        lehmer64_state |= fnv1a_64(&t->epoll_fd, sizeof(t->epoll_fd));
     }
 }