From c7c101530daea13888d8c9606364ecfd93cae384 Mon Sep 17 00:00:00 2001 From: Tyge Løvset Date: Sun, 16 Aug 2020 16:25:39 +0200 Subject: Simplified benchmark.c --- examples/benchmark.c | 171 +++++++++++++++++++++++++-------------------------- 1 file 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 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 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 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 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 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 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 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 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 } -- cgit v1.2.3