Simplified benchmark.c

1 files changed, 85 insertions, 86 deletions

diff --git a/examples/benchmark.c b/examples/benchmark.c
index 42eb57ca..c7a6afd8 100644
--- a/examples/benchmark.c
+++ b/examples/benchmark.c
@@ -17,9 +17,8 @@
 static inline uint32_t fibfast_hash(const void* data, size_t len) {

     return (*(const uint64_t *) data) * 11400714819323198485llu;

 }

-

+// cmap, khash implementations

 declare_cmap(ii, int64_t, int64_t, c_default_destroy, c_default_equals, fibfast_hash); // c_default_hash32);

-

 KHASH_MAP_INIT_INT64(ii, uint64_t)

 

 size_t seed;

@@ -30,54 +29,54 @@ crandom_eng64_t rng;
 #define RAND(N) (crandom_i64(&rng) & ((1 << N) - 1))

 

 

-#define CMAP_SETUP(tag, Key, Value) cmap_##tag map = cmap_init \

-                                    ; cmap_##tag##_set_load_factors(&map, max_load_factor, 0.0)

-#define CMAP_PUT(tag, key, val)     cmap_##tag##_put(&map, key, val)->value

-#define CMAP_ERASE(tag, key)        cmap_##tag##_erase(&map, key)

-#define CMAP_FIND(tag, key)         (cmap_##tag##_find(map, key) != NULL)

-#define CMAP_SIZE(tag)              cmap_size(map)

-#define CMAP_BUCKETS(tag)           (map).bucket_count

-#define CMAP_CLEAR(tag)             cmap_##tag##_destroy(&map)

-

-#define KMAP_SETUP(tag, Key, Value) khash_t(ii)* map = kh_init(ii); khiter_t ki; int ret

-#define KMAP_PUT(tag, key, val)     (*(ki = kh_put(ii, map, key, &ret), map->vals[ki] = val, &map->vals[ki]))

-#define KMAP_ERASE(tag, key)        ((ki = kh_get(ii, map, key)) != kh_end(map) ? kh_del(ii, map, ki), 1 : 0)

-#define KMAP_FIND(tag, key)         (kh_get(ii, map, key) != kh_end(map))

-#define KMAP_SIZE(tag)              kh_size(map)

-#define KMAP_BUCKETS(tag)           kh_n_buckets(map)

-#define KMAP_CLEAR(tag)             kh_destroy(ii, map)

-

-#define UMAP_SETUP(tag, Key, Value) std::unordered_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define UMAP_PUT(tag, key, val)     (map[key] = val)

-#define UMAP_FIND(tag, key)         (map.find(key) != map.end())

-#define UMAP_ERASE(tag, key)        map.erase(key)

-#define UMAP_SIZE(tag)              map.size()

-#define UMAP_BUCKETS(tag)           map.bucket_count()

-#define UMAP_CLEAR(tag)             map.clear()

-

-#define BMAP_SETUP(tag, Key, Value) ska::bytell_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define BMAP_PUT(tag, key, val)     (map[key] = val)

-#define BMAP_FIND(tag, key)         (map.find(key) != map.end())

-#define BMAP_ERASE(tag, key)        map.erase(key)

-#define BMAP_SIZE(tag)              map.size()

-#define BMAP_BUCKETS(tag)           map.bucket_count()

-#define BMAP_CLEAR(tag)             map.clear()

-

-#define FMAP_SETUP(tag, Key, Value) ska::flat_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

-#define FMAP_PUT(tag, key, val)     (map[key] = val)

-#define FMAP_FIND(tag, key)         (map.find(key) != map.end())

-#define FMAP_ERASE(tag, key)        map.erase(key)

-#define FMAP_SIZE(tag)              map.size()

-#define FMAP_BUCKETS(tag)           map.bucket_count()

-#define FMAP_CLEAR(tag)             map.clear()

-

-#define RMAP_SETUP(tag, Key, Value) robin_hood::unordered_map<Key, Value> map

-#define RMAP_PUT(tag, key, val)     (map[key] = val)

-#define RMAP_FIND(tag, key)         (map.find(key) != map.end())

-#define RMAP_ERASE(tag, key)        map.erase(key)

-#define RMAP_SIZE(tag)              map.size()

-#define RMAP_BUCKETS(tag)           map.mask()

-#define RMAP_CLEAR(tag)             map.clear()

+#define CMAP_SETUP(Key, Value) cmap_ii map = cmap_init \

+                                    ; cmap_ii_set_load_factors(&map, max_load_factor, 0.0)

+#define CMAP_PUT(key, val)     cmap_ii_put(&map, key, val)->value

+#define CMAP_ERASE(key)        cmap_ii_erase(&map, key)

+#define CMAP_FIND(key)         (cmap_ii_find(map, key) != NULL)

+#define CMAP_SIZE()            cmap_size(map)

+#define CMAP_BUCKETS()         (map).bucket_count

+#define CMAP_CLEAR()           cmap_ii_destroy(&map)

+

+#define KMAP_SETUP(Key, Value) khash_t(ii)* map = kh_init(ii); khiter_t ki; int ret

+#define KMAP_PUT(key, val)     (*(ki = kh_put(ii, map, key, &ret), map->vals[ki] = val, &map->vals[ki]))

+#define KMAP_ERASE(key)        ((ki = kh_get(ii, map, key)) != kh_end(map) ? kh_del(ii, map, ki), 1 : 0)

+#define KMAP_FIND(key)         (kh_get(ii, map, key) != kh_end(map))

+#define KMAP_SIZE()            kh_size(map)

+#define KMAP_BUCKETS()         kh_n_buckets(map)

+#define KMAP_CLEAR()           kh_destroy(ii, map)

+

+#define UMAP_SETUP(Key, Value) std::unordered_map<Key, Value> map; map.max_load_factor(max_load_factor)

+#define UMAP_PUT(key, val)     (map[key] = val)

+#define UMAP_FIND(key)         (map.find(key) != map.end())

+#define UMAP_ERASE(key)        map.erase(key)

+#define UMAP_SIZE()            map.size()

+#define UMAP_BUCKETS()         map.bucket_count()

+#define UMAP_CLEAR()           map.clear()

+

+#define BMAP_SETUP(Key, Value) ska::bytell_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

+#define BMAP_PUT(key, val)     (map[key] = val)

+#define BMAP_FIND(key)         (map.find(key) != map.end())

+#define BMAP_ERASE(key)        map.erase(key)

+#define BMAP_SIZE()            map.size()

+#define BMAP_BUCKETS()         map.bucket_count()

+#define BMAP_CLEAR()           map.clear()

+

+#define FMAP_SETUP(Key, Value) ska::flat_hash_map<Key, Value> map; map.max_load_factor(max_load_factor)

+#define FMAP_PUT(key, val)     (map[key] = val)

+#define FMAP_FIND(key)         (map.find(key) != map.end())

+#define FMAP_ERASE(key)        map.erase(key)

+#define FMAP_SIZE()            map.size()

+#define FMAP_BUCKETS()         map.bucket_count()

+#define FMAP_CLEAR()           map.clear()

+

+#define RMAP_SETUP(Key, Value) robin_hood::unordered_map<Key, Value> map

+#define RMAP_PUT(key, val)     (map[key] = val)

+#define RMAP_FIND(key)         (map.find(key) != map.end())

+#define RMAP_ERASE(key)        map.erase(key)

+#define RMAP_SIZE()            map.size()

+#define RMAP_BUCKETS()         map.mask()

+#define RMAP_CLEAR()           map.clear()

 

 const size_t N1 = 10000000 * 5;

 const size_t N2 = 10000000 * 5;

@@ -86,52 +85,52 @@ const size_t N3 = 10000000 * 10;
 int rr = RR;

 

 

-#define MAP_TEST1(M, tag) \

+#define MAP_TEST1(M) \

 { \

-    M##_SETUP(tag, int64_t, int64_t); \

+    M##_SETUP(int64_t, int64_t); \

     uint64_t checksum = 0, erased = 0; \

     SEED(seed); \

     clock_t difference, before = clock(); \

     for (size_t i = 0; i < N1; ++i) { \

-        checksum += ++ M##_PUT(tag, RAND(rr), i); \

-        erased += M##_ERASE(tag, RAND(rr)); \

+        checksum += ++ M##_PUT(RAND(rr), i); \

+        erased += M##_ERASE(RAND(rr)); \

     } \

     difference = clock() - before; \

     printf(#M ": size: %zu, buckets: %8zu, time: %5.02f, sum: %zu, erased %zu\n", \

-           (size_t) M##_SIZE(tag), (size_t) M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, checksum, erased); \

-    M##_CLEAR(tag); \

+           (size_t) M##_SIZE(), (size_t) M##_BUCKETS(), (float) difference / CLOCKS_PER_SEC, checksum, erased); \

+    M##_CLEAR(); \

 }

 

-#define MAP_TEST2(M, tag) \

+#define MAP_TEST2(M) \

 { \

-    M##_SETUP(tag, int64_t, int64_t); \

+    M##_SETUP(int64_t, int64_t); \

     size_t erased = 0; \

     clock_t difference, before = clock(); \

     for (size_t i = 0; i < N2; ++i) \

-        M##_PUT(tag, i, i); \

+        M##_PUT(i, i); \

     for (size_t i = 0; i < N2; ++i) \

-        erased += M##_ERASE(tag, i); \

+        erased += M##_ERASE(i); \

     difference = clock() - before; \

     printf(#M ": size: %zu, buckets: %8zu, time: %5.02f, erased %zu\n", \

-           (size_t) M##_SIZE(tag), (size_t) M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, erased); \

-    M##_CLEAR(tag); \

+           (size_t) M##_SIZE(), (size_t) M##_BUCKETS(), (float) difference / CLOCKS_PER_SEC, erased); \

+    M##_CLEAR(); \

 }

 

-#define MAP_TEST3(M, tag) \

+#define MAP_TEST3(M) \

 { \

-    M##_SETUP(tag, int64_t, int64_t); \

+    M##_SETUP(int64_t, int64_t); \

     size_t erased = 0; \

     clock_t difference, before = clock(); \

     SEED(seed); \

     for (size_t i = 0; i < N3; ++i) \

-        M##_PUT(tag, RAND(rr), i); \

+        M##_PUT(RAND(rr), i); \

     SEED(seed); \

     for (size_t i = 0; i < N3; ++i) \

-        erased += M##_ERASE(tag, RAND(rr)); \

+        erased += M##_ERASE(RAND(rr)); \

     difference = clock() - before; \

     printf(#M ": size: %zu, buckets: %8zu, time: %5.02f, erased %zu\n", \

-           (size_t) M##_SIZE(tag), (size_t) M##_BUCKETS(tag), (float) difference / CLOCKS_PER_SEC, erased); \

-    M##_CLEAR(tag); \

+           (size_t) M##_SIZE(), (size_t) M##_BUCKETS(), (float) difference / CLOCKS_PER_SEC, erased); \

+    M##_CLEAR(); \

 }

 

 

@@ -141,32 +140,32 @@ int main(int argc, char* argv[])
     seed = time(NULL);

     printf("\nRandom keys are in range [0, 2^%d), seed = %zu:\n",  rr, seed);

     printf("\nUnordered maps: %zu repeats of Insert random key + try to remove a random key:\n", N1);

-    MAP_TEST1(CMAP, ii)

-    MAP_TEST1(KMAP, ii)

+    MAP_TEST1(CMAP)

+    MAP_TEST1(KMAP)

 #ifdef __cplusplus

-    MAP_TEST1(UMAP, ii)

-    MAP_TEST1(BMAP, ii)

-    MAP_TEST1(FMAP, ii)

-    MAP_TEST1(RMAP, ii)

+    MAP_TEST1(UMAP)

+    MAP_TEST1(BMAP)

+    MAP_TEST1(FMAP)

+    MAP_TEST1(RMAP)

 #endif

 

     printf("\nUnordered maps: Insert %zu index keys, then remove them in same order:\n", N2);

-    MAP_TEST2(CMAP, ii)

-    MAP_TEST2(KMAP, ii)

+    MAP_TEST2(CMAP)

+    MAP_TEST2(KMAP)

 #ifdef __cplusplus

-    MAP_TEST2(UMAP, ii)

-    MAP_TEST2(BMAP, ii)

-    MAP_TEST2(FMAP, ii)

-    MAP_TEST2(RMAP, ii)

+    MAP_TEST2(UMAP)

+    MAP_TEST2(BMAP)

+    MAP_TEST2(FMAP)

+    MAP_TEST2(RMAP)

 #endif

 

     printf("\nUnordered maps: Insert %zu random keys, then remove them in same order:\n", N3);

-    MAP_TEST3(CMAP, ii)

-    MAP_TEST3(KMAP, ii)

+    MAP_TEST3(CMAP)

+    MAP_TEST3(KMAP)

 #ifdef __cplusplus

-    MAP_TEST3(UMAP, ii)

-    MAP_TEST3(BMAP, ii)

-    MAP_TEST3(FMAP, ii)

-    MAP_TEST3(RMAP, ii)

+    MAP_TEST3(UMAP)

+    MAP_TEST3(BMAP)

+    MAP_TEST3(FMAP)

+    MAP_TEST3(RMAP)

 #endif

 }