Added output all in picobenchmark + allow to have multiple baselines in one suite.

Updated latest robin_hood.hpp

1 files changed, 88 insertions, 75 deletions

diff --git a/benchmarks/cmap_benchmark2.cpp b/benchmarks/cmap_benchmark2.cpp
index 7904effa..39dd61b8 100644
--- a/benchmarks/cmap_benchmark2.cpp
+++ b/benchmarks/cmap_benchmark2.cpp
@@ -13,39 +13,44 @@
 #include "picobench.hpp"

 

 PICOBENCH_SUITE("Map");

-enum {N1 = 5000000};

-uint64_t seed = 123456;

+enum {N1 = 5000000, S1 = 1, MaxLoadFactor100 = 80};

+uint64_t seed = time(NULL);

 

-static inline uint32_t fibonacci_hash(const void* data, size_t len) {

-    return (uint32_t) (((*(const uint32_t *) data) * 11400714819323198485llu) >> 24);

+static inline uint32_t hash32(const void* data, size_t len) {

+    return (uint32_t) ((*(const uint32_t *) data) * 2654435769u);

+}

+static inline uint32_t hash64(const void* data, size_t len) {

+    return (uint32_t) (((*(const uint64_t *) data) * 11400714819323198485ull) >> 24);

 }

 template <class K, class V> using umap = std::unordered_map<K, V>;

 template <class K, class V> using bmap = ska::bytell_hash_map<K, V>;

 template <class K, class V> using fmap = ska::flat_hash_map<K, V>;

 template <class K, class V> using hmap = tsl::hopscotch_map<K, V>;

 template <class K, class V> using smap = spp::sparse_hash_map<K, V>;

-template <class K, class V> using rmap = robin_hood::unordered_flat_map<K, V>;

-

-using_cmap(i, int, int, c_default_del, c_default_clone, c_default_equals, fibonacci_hash);

+template <class K, class V> using rmap = robin_hood::unordered_flat_map<K, V, robin_hood::hash<K>,

+                                                                        std::equal_to<K>, MaxLoadFactor100>;

+#define DEFMAP(map, ...) \

+    using u##map = umap __VA_ARGS__; \

+    using b##map = bmap __VA_ARGS__; \

+    using f##map = fmap __VA_ARGS__; \

+    using h##map = hmap __VA_ARGS__; \

+    using s##map = smap __VA_ARGS__; \

+    using r##map = rmap __VA_ARGS__

+

+DEFMAP(map_i, <int, int>);

+DEFMAP(map_x, <uint64_t, uint64_t>);

+DEFMAP(map_s, <std::string, std::string>);

+

+using_cmap(i, int, int, c_default_del, c_default_clone, c_default_equals, hash32);

+using_cmap(x, uint64_t, uint64_t, c_default_del, c_default_clone, c_default_equals, hash64);

 using_cmap_strkey(s, cstr, cstr_del, cstr_clone);

-using umap_i = umap<int, int>;

-using umap_s = umap<std::string, std::string>;

-using bmap_i = bmap<int, int>;

-using bmap_s = bmap<std::string, std::string>;

-using fmap_i = fmap<int, int>;

-using fmap_s = fmap<std::string, std::string>;

-using hmap_i = hmap<int, int>;

-using hmap_s = hmap<std::string, std::string>;

-using smap_i = smap<int, int>;

-using smap_s = smap<std::string, std::string>;

-using rmap_i = rmap<int, int>;

-using rmap_s = rmap<std::string, std::string>;

 

 template <class MapInt>

-static void ctor_and_ins_one(picobench::state& s)

+static void ctor_and_ins_one_i(picobench::state& s)

 {

-    picobench::scope scope(s);

     size_t result = 0;

+

+    picobench::scope scope(s);

     c_forrange (n, s.iterations()) {

         MapInt map;

         map[n];

@@ -54,10 +59,11 @@ static void ctor_and_ins_one(picobench::state& s)
     s.set_result(result);

 }

 

-static void ctor_and_ins_one_cmap_i_(picobench::state& s)

+static void ctor_and_ins_one_cmap_i(picobench::state& s)

 {

-    picobench::scope scope(s);

     size_t result = 0;

+

+    picobench::scope scope(s);

     c_forrange (n, s.iterations()) {

         cmap_i map = cmap_inits;

         cmap_i_emplace(&map, n, 0);

@@ -67,24 +73,26 @@ static void ctor_and_ins_one_cmap_i_(picobench::state& s)
     s.set_result(result);

 }

 

-#define P samples(2).iterations({N1})

-PICOBENCH(ctor_and_ins_one<umap_i>).P.baseline();

-PICOBENCH(ctor_and_ins_one<bmap_i>).P;

-PICOBENCH(ctor_and_ins_one<fmap_i>).P;

-PICOBENCH(ctor_and_ins_one<hmap_i>).P;

-PICOBENCH(ctor_and_ins_one<smap_i>).P;

-PICOBENCH(ctor_and_ins_one<rmap_i>).P;

-PICOBENCH(ctor_and_ins_one_cmap_i_).P;

+#define P samples(S1).iterations({N1})

+PICOBENCH(ctor_and_ins_one_i<umap_i>).P.baseline();

+PICOBENCH(ctor_and_ins_one_i<bmap_i>).P;

+PICOBENCH(ctor_and_ins_one_i<fmap_i>).P;

+PICOBENCH(ctor_and_ins_one_i<hmap_i>).P;

+PICOBENCH(ctor_and_ins_one_i<smap_i>).P;

+PICOBENCH(ctor_and_ins_one_i<rmap_i>).P;

+PICOBENCH(ctor_and_ins_one_cmap_i).P;

 #undef P

 

 

 template <class MapInt>

-static void ins_and_erase(picobench::state& s)

+static void ins_and_erase_i(picobench::state& s)

 {

-    stc64_srandom(seed);

-    picobench::scope scope(s);

     size_t result = 0;

     MapInt map;

+    map.max_load_factor(MaxLoadFactor100 / 100.0);

+    stc64_srandom(seed);

+

+    picobench::scope scope(s);

     c_forrange (s.iterations())

         map[stc64_random()];

     map.clear();

@@ -97,12 +105,13 @@ static void ins_and_erase(picobench::state& s)
     s.set_result(map.size());

 }

 

-static void ins_and_erase_cmap_i_(picobench::state& s)

+static void ins_and_erase_cmap_i(picobench::state& s)

 {

+    cmap_i map = cmap_inits;

+    cmap_i_set_load_factors(&map, 0.0, MaxLoadFactor100 / 100.0);

     stc64_srandom(seed);

+

     picobench::scope scope(s);

-    cmap_i map = cmap_inits;

-    cmap_i_set_load_factors(&map, 0.0, 0.80);

     c_forrange (s.iterations())

         cmap_i_emplace(&map, stc64_random(), 0);

     cmap_i_clear(&map);

@@ -116,52 +125,55 @@ static void ins_and_erase_cmap_i_(picobench::state& s)
     s.set_result(cmap_i_size(map));

 }

 

-#define P samples(2).iterations({N1/4})

-PICOBENCH(ins_and_erase<umap_i>).P.baseline();

-PICOBENCH(ins_and_erase<bmap_i>).P;

-PICOBENCH(ins_and_erase<fmap_i>).P;

-PICOBENCH(ins_and_erase<hmap_i>).P;

-PICOBENCH(ins_and_erase<smap_i>).P;

-PICOBENCH(ins_and_erase<rmap_i>).P;

-PICOBENCH(ins_and_erase_cmap_i_).P;

+#define P samples(S1).iterations({N1/4})

+PICOBENCH(ins_and_erase_i<umap_i>).P.baseline();

+PICOBENCH(ins_and_erase_i<bmap_i>).P;

+PICOBENCH(ins_and_erase_i<fmap_i>).P;

+PICOBENCH(ins_and_erase_i<hmap_i>).P;

+PICOBENCH(ins_and_erase_i<smap_i>).P;

+PICOBENCH(ins_and_erase_i<rmap_i>).P;

+PICOBENCH(ins_and_erase_cmap_i).P;

 #undef P

 

 

 template <class MapInt>

-static void ins_and_access(picobench::state& s)

+static void ins_and_access_i(picobench::state& s)

 {

-    stc64_srandom(seed);

-    uint64_t filter = (1ull << s.user_data()) - 1;

-    picobench::scope scope(s);

+    uint64_t mask = (1ull << s.user_data()) - 1;

     size_t result = 0;

     MapInt map;

+    map.max_load_factor(MaxLoadFactor100 / 100.0);

+    stc64_srandom(seed);

+

+    picobench::scope scope(s);

     c_forrange (N1)

-        result += ++map[stc64_random() & filter];

+        result += ++map[stc64_random() & mask];

     s.set_result(result);

 }

 

-static void ins_and_access_cmap_i_(picobench::state& s)

+static void ins_and_access_cmap_i(picobench::state& s)

 {

-    stc64_srandom(seed);

-    uint64_t filter = (1ull << s.user_data()) - 1;

-    picobench::scope scope(s);

+    uint64_t mask = (1ull << s.user_data()) - 1;

     size_t result = 0;

     cmap_i map = cmap_inits;

-    cmap_i_set_load_factors(&map, 0.0, 0.80);

+    cmap_i_set_load_factors(&map, 0.0, MaxLoadFactor100 / 100.0);

+    stc64_srandom(seed);

+

+    picobench::scope scope(s);

     c_forrange (N1)

-        result += ++cmap_i_emplace(&map, stc64_random() & filter, 0).first->second;

+        result += ++cmap_i_emplace(&map, stc64_random() & mask, 0).first->second;

     s.set_result(result);

     cmap_i_del(&map);

 }

 

-#define P samples(2).iterations({N1, N1, N1, N1}).user_data({18, 23, 25, 31})

-PICOBENCH(ins_and_access<umap_i>).P.baseline();

-PICOBENCH(ins_and_access<bmap_i>).P;

-PICOBENCH(ins_and_access<fmap_i>).P;

-PICOBENCH(ins_and_access<hmap_i>).P;

-PICOBENCH(ins_and_access<smap_i>).P;

-PICOBENCH(ins_and_access<rmap_i>).P;

-PICOBENCH(ins_and_access_cmap_i_).P;

+#define P samples(S1).iterations({N1, N1, N1, N1}).user_data({18, 23, 25, 31})

+PICOBENCH(ins_and_access_i<umap_i>).P.baseline();

+PICOBENCH(ins_and_access_i<bmap_i>).P;

+PICOBENCH(ins_and_access_i<fmap_i>).P;

+PICOBENCH(ins_and_access_i<hmap_i>).P;

+PICOBENCH(ins_and_access_i<smap_i>).P;

+PICOBENCH(ins_and_access_i<rmap_i>).P;

+PICOBENCH(ins_and_access_cmap_i).P;

 #undef P

 

 

@@ -174,12 +186,13 @@ static void randomize(char* str, size_t len) {
 template <class MapStr>

 static void ins_and_access_s(picobench::state& s)

 {

-    stc64_srandom(seed);

     std::string str(s.user_data(), 'x');

-    randomize(&str[0], str.size());

-    picobench::scope scope(s);

     size_t result = 0;

     MapStr map;

+    map.max_load_factor(MaxLoadFactor100 / 100.0);

+    stc64_srandom(seed);

+

+    picobench::scope scope(s);

     c_forrange (s.iterations()) {

         randomize(&str[0], str.size());

         map[str] = str;

@@ -193,15 +206,15 @@ static void ins_and_access_s(picobench::state& s)
     s.set_result(result);

 }

 

-static void ins_and_access_s_cmap_s_(picobench::state& s)

+static void ins_and_access_cmap_s(picobench::state& s)

 {

-    stc64_srandom(seed);

     cstr str = cstr_with_size(s.user_data(), 'x');

-    randomize(str.str, cstr_size(str));

-    picobench::scope scope(s);

     size_t result = 0;

     cmap_s map = cmap_inits;

-    cmap_s_set_load_factors(&map, 0.0, 0.80);

+    cmap_s_set_load_factors(&map, 0.0, MaxLoadFactor100 / 100.0);

+    stc64_srandom(seed);

+

+    picobench::scope scope(s);

     c_forrange (s.iterations()) {

         randomize(str.str, cstr_size(str));

         cmap_s_put(&map, str.str, cstr_clone(str));

@@ -217,12 +230,12 @@ static void ins_and_access_s_cmap_s_(picobench::state& s)
     cmap_s_del(&map);

 }

 

-#define P samples(2).iterations({N1/5, N1/5, N1/5, N1/10, N1/40}).user_data({7, 8, 13, 100, 1000})

+#define P samples(S1).iterations({N1/5, N1/5, N1/5, N1/10, N1/40}).user_data({13, 7, 8, 100, 1000})

 PICOBENCH(ins_and_access_s<umap_s>).P.baseline();

 PICOBENCH(ins_and_access_s<bmap_s>).P;

 PICOBENCH(ins_and_access_s<fmap_s>).P;

 PICOBENCH(ins_and_access_s<hmap_s>).P;

 PICOBENCH(ins_and_access_s<smap_s>).P;

 PICOBENCH(ins_and_access_s<rmap_s>).P;

-PICOBENCH(ins_and_access_s_cmap_s_).P;

-#undef P
\ No newline at end of file
+PICOBENCH(ins_and_access_cmap_s).P;

+#undef P