More refactoring

benchmarks/comparisons/hashtable/Makefile

@@ -0,0 +1,18 @@
+INCLUDE=-I ../../../src
+CFLAGS=-O3 -Wall -DCOUNT=20000000 -DCMC_NO_CALLBACKS
+
+# Install hyperfine
+# https://github.com/sharkdp/hyperfine
+
+run: build
+	hyperfine --warmup 2 --runs 5 './hashmap.exe'
+	hyperfine --warmup 2 --runs 5 './hashmultimap.exe'
+	hyperfine --warmup 2 --runs 5 './unorderedmap.exe'
+
+build:
+	gcc hashmap.c -o hashmap.exe $(INCLUDE) $(CFLAGS)
+	gcc hashmultimap.c -o hashmultimap.exe $(INCLUDE) $(CFLAGS)
+	g++ unorderedmap.cpp $(INCLUDE) -o unorderedmap.exe $(CFLAGS)
+
+clean:
+	rm *.exe

benchmarks/comparisons/hashtable/hashmap.c

@@ -0,0 +1,55 @@
+#ifndef COUNT
+#error "Please define COUNT"
+#endif
+
+#include "murmurhash.h"
+
+#include "../../util/twister.c"
+
+#define K uint64_t
+#define V uint64_t
+#define PFX hm
+#define SNAME hashmap
+#include "cmc/hashmap.h"
+
+int cmp(uint64_t a, uint64_t b)
+{
+    return (a > b) - (a < b);
+}
+
+// size_t hash(uint64_t a)
+// {
+//     size_t x = (size_t)a;
+//     x = ((x >> 16) ^ x) * 0x45d9f3b;
+//     x = ((x >> 16) ^ x) * 0x45d9f3b;
+//     x = (x >> 16) ^ x;
+//     return x;
+// }
+
+size_t hash(uint64_t k)
+{
+    static size_t seed = 211106232532969;
+    return MurMurHash(&k, sizeof(k), seed);
+}
+
+struct hashmap_fkey *fkey = &(struct hashmap_fkey){ .cmp = cmp, .hash = hash, NULL };
+
+struct hashmap_fval *fval = &(struct hashmap_fval){ .cmp = cmp, .hash = hash, NULL };
+
+int main(void)
+{
+    mt_state tw;
+    twist_init(&tw, 50331653);
+
+    struct hashmap *map = hm_new(COUNT, 0.6, fkey, fval);
+
+    for (uint64_t i = 0; i < COUNT; i++)
+    {
+        uint64_t v = twist_uint64(&tw);
+        hm_insert(map, v, v);
+    }
+
+    hm_free(map);
+
+    return 0;
+}

benchmarks/comparisons/hashtable/hashmultimap.c

@@ -0,0 +1,55 @@
+#ifndef COUNT
+#error "Please define COUNT"
+#endif
+
+#include "murmurhash.h"
+
+#include "../../util/twister.c"
+
+#define K uint64_t
+#define V uint64_t
+#define PFX hmm
+#define SNAME hashmultimap
+#include "cmc/hashmultimap.h"
+
+int cmp(uint64_t a, uint64_t b)
+{
+    return (a > b) - (a < b);
+}
+
+// size_t hash(uint64_t a)
+// {
+//     size_t x = (size_t)a;
+//     x = ((x >> 16) ^ x) * 0x45d9f3b;
+//     x = ((x >> 16) ^ x) * 0x45d9f3b;
+//     x = (x >> 16) ^ x;
+//     return x;
+// }
+
+size_t hash(uint64_t k)
+{
+    static size_t seed = 211106232532969;
+    return MurMurHash(&k, sizeof(k), seed);
+}
+
+struct hashmultimap_fkey *fkey = &(struct hashmultimap_fkey){ .cmp = cmp, .hash = hash, NULL };
+
+struct hashmultimap_fval *fval = &(struct hashmultimap_fval){ .cmp = cmp, .hash = hash, NULL };
+
+int main(void)
+{
+    mt_state tw;
+    twist_init(&tw, 50331653);
+
+    struct hashmultimap *map = hmm_new(COUNT, 0.6, fkey, fval);
+
+    for (uint64_t i = 0; i < COUNT; i++)
+    {
+        uint64_t v = twist_uint64(&tw);
+        hmm_insert(map, v, v);
+    }
+
+    hmm_free(map);
+
+    return 0;
+}

benchmarks/comparisons/hashtable/murmurhash.h

@@ -0,0 +1,58 @@
+// https://github.com/gcc-mirror/gcc/blob/master/libstdc%2B%2B-v3/libsupc%2B%2B/hash_bytes.cc
+
+#ifndef MURMURHASH
+#define MURMURHASH
+
+#include <string.h>
+
+inline size_t unaligned_load(const char *p)
+{
+    size_t result;
+    memcpy(&result, p, sizeof(result));
+    return result;
+}
+
+inline size_t load_bytes(const char *p, int n)
+{
+    size_t result = 0;
+    --n;
+    do
+    {
+        result = (result << 8) + (unsigned char)(p[n]);
+    } while (--n >= 0);
+    return result;
+}
+
+inline size_t shift_mix(size_t v)
+{
+    return v ^ (v >> 47);
+}
+
+size_t MurMurHash(const void *ptr, size_t len, size_t seed)
+{
+    static const size_t mul = (((size_t)0xc6a4a793UL) << 32UL) + (size_t)0x5bd1e995UL;
+    const char *const buf = (const char *)(ptr);
+
+    // Remove the bytes not divisible by the sizeof(size_t).  This
+    // allows the main loop to process the data as 64-bit integers.
+    const size_t len_aligned = len & ~(size_t)0x7;
+    const char *const end = buf + len_aligned;
+    size_t hash = seed ^ (len * mul);
+    for (const char *p = buf; p != end; p += 8)
+    {
+        const size_t data = shift_mix(unaligned_load(p) * mul) * mul;
+        hash ^= data;
+        hash *= mul;
+    }
+    if ((len & 0x7) != 0)
+    {
+        const size_t data = load_bytes(end, len & 0x7);
+        hash ^= data;
+        hash *= mul;
+    }
+    hash = shift_mix(hash) * mul;
+    hash = shift_mix(hash);
+    return hash;
+}
+
+#endif /* MURMURHASH */

benchmarks/comparisons/hashtable/unorderedmap.cpp

@@ -0,0 +1,34 @@
+#ifndef COUNT
+#error "Please define COUNT"
+#endif
+
+#include "murmurhash.h"
+
+#include <unordered_map>
+
+#include "../../util/twister.c"
+
+struct IntHasher
+{
+    std::size_t operator()(const uint64_t &k) const
+    {
+        static size_t seed = 211106232532969;
+        return MurMurHash(&k, sizeof(k), seed);
+    }
+};
+
+int main(void)
+{
+    mt_state tw;
+    twist_init(&tw, 50331653);
+
+    std::unordered_map<uint64_t, uint64_t, IntHasher> map(COUNT);
+
+    for (uint64_t i = 0; i < COUNT; i++)
+    {
+        uint64_t v = twist_uint64(&tw);
+        map.insert({ v, v });
+    }
+
+    return 0;
+}