Updated shootout_hashmaps.cpp. Cleanup/renamed benchmark folders.

12 files changed, 770 insertions, 0 deletions

diff --git a/benchmarks/plotbench/cdeq_benchmark.cpp b/benchmarks/plotbench/cdeq_benchmark.cpp
new file mode 100644
index 00000000..6db167b0
--- /dev/null
+++ b/benchmarks/plotbench/cdeq_benchmark.cpp
@@ -0,0 +1,129 @@
+#include <stdio.h>

+#include <time.h>

+#include <stc/crandom.h>

+

+#ifdef __cplusplus

+#include <deque>

+#include <algorithm>

+#endif

+

+enum {INSERT, ERASE, FIND, ITER, DESTRUCT, N_TESTS};

+const char* operations[] = {"insert", "erase", "find", "iter", "destruct"};

+typedef struct { time_t t1, t2; uint64_t sum; float fac; } Range;

+typedef struct { const char* name; Range test[N_TESTS]; } Sample;

+enum {SAMPLES = 2, N = 100000000, S = 0x3ffc, R = 4};

+uint64_t seed = 1, mask1 = 0xfffffff, mask2 = 0xffff;

+

+static float secs(Range s) { return (float)(s.t2 - s.t1) / CLOCKS_PER_SEC; }

+

+#define i_tag x

+#define i_val size_t

+#include <stc/cdeq.h>

+

+#ifdef __cplusplus

+Sample test_std_deque() {

+    typedef std::deque<size_t> container;

+    Sample s = {"std,deque"};

+    {

+        s.test[INSERT].t1 = clock();

+        container con;

+        stc64_srandom(seed);

+        c_forrange (N/3) con.push_front(stc64_random() & mask1);

+        c_forrange (N/3) {con.push_back(stc64_random() & mask1); con.pop_front();}

+        c_forrange (N/3) con.push_back(stc64_random() & mask1);

+        s.test[INSERT].t2 = clock();

+        s.test[INSERT].sum = con.size();

+        s.test[ERASE].t1 = clock();

+        c_forrange (con.size()/2) { con.pop_front(); con.pop_back(); }

+        s.test[ERASE].t2 = clock();

+        s.test[ERASE].sum = con.size();

+     }{

+        container con;

+        stc64_srandom(seed);

+        c_forrange (N) con.push_back(stc64_random() & mask2);

+        s.test[FIND].t1 = clock();

+        size_t sum = 0;

+        // Iteration - not inherent find - skipping

+        //container::iterator it;

+        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), stc64_random() & mask2)) != con.end()) sum += *it;

+        s.test[FIND].t2 = clock();

+        s.test[FIND].sum = sum;

+        s.test[ITER].t1 = clock();

+        sum = 0;

+        c_forrange (R) c_forrange (i, N) sum += con[i];

+        s.test[ITER].t2 = clock();

+        s.test[ITER].sum = sum;

+        s.test[DESTRUCT].t1 = clock();

+     }

+     s.test[DESTRUCT].t2 = clock();

+     s.test[DESTRUCT].sum = 0;

+     return s;

+}

+#else

+Sample test_std_deque() { Sample s = {"std-deque"}; return s;}

+#endif

+

+

+Sample test_stc_deque() {

+    typedef cdeq_x container;

+    Sample s = {"STC,deque"};

+    {

+        s.test[INSERT].t1 = clock();

+        container con = cdeq_x_init();

+        //cdeq_x_reserve(&con, N);

+        stc64_srandom(seed);

+        c_forrange (N/3) cdeq_x_push_front(&con, stc64_random() & mask1);

+        c_forrange (N/3) {cdeq_x_push_back(&con, stc64_random() & mask1); cdeq_x_pop_front(&con);}

+        c_forrange (N/3) cdeq_x_push_back(&con, stc64_random() & mask1);

+        s.test[INSERT].t2 = clock();

+        s.test[INSERT].sum = cdeq_x_size(con);

+        s.test[ERASE].t1 = clock();

+        c_forrange (cdeq_x_size(con)/2) { cdeq_x_pop_front(&con); cdeq_x_pop_back(&con); }

+        s.test[ERASE].t2 = clock();

+        s.test[ERASE].sum = cdeq_x_size(con);

+        cdeq_x_del(&con);

+     }{

+        stc64_srandom(seed);

+        container con = cdeq_x_init();

+        c_forrange (N) cdeq_x_push_back(&con, stc64_random() & mask2);

+        s.test[FIND].t1 = clock();

+        size_t sum = 0;

+        //cdeq_x_iter it, end = cdeq_x_end(&con);

+        //c_forrange (S) if ((it = cdeq_x_find(&con, stc64_random() & mask2)).ref != end.ref) sum += *it.ref;

+        s.test[FIND].t2 = clock();

+        s.test[FIND].sum = sum;

+        s.test[ITER].t1 = clock();

+        sum = 0;

+        c_forrange (R) c_forrange (i, N) sum += con.data[i];

+        s.test[ITER].t2 = clock();

+        s.test[ITER].sum = sum;

+        s.test[DESTRUCT].t1 = clock();

+        cdeq_x_del(&con);

+     }

+     s.test[DESTRUCT].t2 = clock();

+     s.test[DESTRUCT].sum = 0;

+     return s;

+}

+

+int main(int argc, char* argv[])

+{

+    Sample std_s[SAMPLES + 1], stc_s[SAMPLES + 1];

+    c_forrange (i, int, SAMPLES) {

+        std_s[i] = test_std_deque();

+        stc_s[i] = test_stc_deque();

+        if (i > 0) c_forrange (j, int, N_TESTS) {

+            if (secs(std_s[i].test[j]) < secs(std_s[0].test[j])) std_s[0].test[j] = std_s[i].test[j];

+            if (secs(stc_s[i].test[j]) < secs(stc_s[0].test[j])) stc_s[0].test[j] = stc_s[i].test[j];

+            if (stc_s[i].test[j].sum != stc_s[0].test[j].sum) printf("Error in sum: test %d, sample %d\n", i, j);

+        }

+    }

+    const char* comp = argc > 1 ? argv[1] : "test";

+    bool header = (argc > 2 && argv[2][0] == '1');

+    float std_sum = 0, stc_sum = 0;

+    c_forrange (j, N_TESTS) { std_sum += secs(std_s[0].test[j]); stc_sum += secs(stc_s[0].test[j]); }

+    if (header) printf("Compiler,Library,C,Method,Seconds,Ratio\n");

+    c_forrange (j, N_TESTS) printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, operations[j], secs(std_s[0].test[j]), 1.0f);

+                            printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, "total", std_sum, 1.0f);

+    c_forrange (j, N_TESTS) printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, operations[j], secs(stc_s[0].test[j]), secs(std_s[0].test[j]) ? secs(stc_s[0].test[j])/secs(std_s[0].test[j]) : 1.0f);

+                            printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, "total", stc_sum, stc_sum/std_sum);

+}

diff --git a/benchmarks/plotbench/clist_benchmark.cpp b/benchmarks/plotbench/clist_benchmark.cpp
new file mode 100644
index 00000000..676d31e7
--- /dev/null
+++ b/benchmarks/plotbench/clist_benchmark.cpp
@@ -0,0 +1,126 @@
+#include <stdio.h>

+#include <time.h>

+#include <stc/crandom.h>

+

+#ifdef __cplusplus

+#include <forward_list>

+#include <algorithm>

+#endif

+

+enum {INSERT, ERASE, FIND, ITER, DESTRUCT, N_TESTS};

+const char* operations[] = {"insert", "erase", "find", "iter", "destruct"};

+typedef struct { time_t t1, t2; uint64_t sum; float fac; } Range;

+typedef struct { const char* name; Range test[N_TESTS]; } Sample;

+enum {SAMPLES = 2, N = 50000000, S = 0x3ffc, R = 4};

+uint64_t seed = 1, mask1 = 0xfffffff, mask2 = 0xffff;

+

+static float secs(Range s) { return (float)(s.t2 - s.t1) / CLOCKS_PER_SEC; }

+

+#define i_val size_t

+#define i_tag x

+#include <stc/clist.h>

+

+#ifdef __cplusplus

+Sample test_std_forward_list() {

+    typedef std::forward_list<size_t> container;

+    Sample s = {"std,forward_list"};

+    {

+        s.test[INSERT].t1 = clock();

+        container con;

+        stc64_srandom(seed);

+        c_forrange (N/2) con.push_front(stc64_random() & mask1);

+        c_forrange (N/2) con.push_front(stc64_random() & mask1);

+        s.test[INSERT].t2 = clock();

+        s.test[INSERT].sum = 0;

+        s.test[ERASE].t1 = clock();

+        c_forrange (N) con.pop_front();

+        s.test[ERASE].t2 = clock();

+        s.test[ERASE].sum = 0;

+     }{

+        container con;

+        stc64_srandom(seed);

+        c_forrange (N) con.push_front(stc64_random() & mask2);

+        s.test[FIND].t1 = clock();

+        size_t sum = 0;

+        container::iterator it;

+        // Iteration - not inherent find - skipping

+        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), stc64_random() & mask2)) != con.end()) sum += *it;

+        s.test[FIND].t2 = clock();

+        s.test[FIND].sum = sum;

+        s.test[ITER].t1 = clock();

+        sum = 0;

+        c_forrange (R) for (auto i: con) sum += i;

+        s.test[ITER].t2 = clock();

+        s.test[ITER].sum = sum;

+        s.test[DESTRUCT].t1 = clock();

+     }

+     s.test[DESTRUCT].t2 = clock();

+     s.test[DESTRUCT].sum = 0;

+     return s;

+}

+#else

+Sample test_std_forward_list() { Sample s = {"std-forward_list"}; return s;}

+#endif

+

+

+Sample test_stc_forward_list() {

+    typedef clist_x container;

+    Sample s = {"STC,forward_list"};

+    {

+        s.test[INSERT].t1 = clock();

+        container con = clist_x_init();

+        stc64_srandom(seed);

+        c_forrange (N/2) clist_x_push_front(&con, stc64_random() & mask1);

+        c_forrange (N/2) clist_x_push_back(&con, stc64_random() & mask1);

+        s.test[INSERT].t2 = clock();

+        s.test[INSERT].sum = 0;

+        s.test[ERASE].t1 = clock();

+        c_forrange (N) clist_x_pop_front(&con);

+        s.test[ERASE].t2 = clock();

+        s.test[ERASE].sum = 0;

+        clist_x_del(&con);

+     }{

+        stc64_srandom(seed);

+        container con = clist_x_init();

+        c_forrange (N) clist_x_push_front(&con, stc64_random() & mask2);

+        s.test[FIND].t1 = clock();

+        size_t sum = 0;

+        //clist_x_iter it, end = clist_x_end(&con);

+        //c_forrange (S) if ((it = clist_x_find(&con, stc64_random() & mask2)).ref != end.ref) sum += *it.ref;

+        s.test[FIND].t2 = clock();

+        s.test[FIND].sum = sum;

+        s.test[ITER].t1 = clock();

+        sum = 0;

+        c_forrange (R) c_foreach (i, clist_x, con) sum += *i.ref;

+        s.test[ITER].t2 = clock();

+        s.test[ITER].sum = sum;

+        s.test[DESTRUCT].t1 = clock();

+        clist_x_del(&con);

+     }

+     s.test[DESTRUCT].t2 = clock();

+     s.test[DESTRUCT].sum = 0;

+     return s;

+}

+

+int main(int argc, char* argv[])

+{

+    Sample std_s[SAMPLES + 1], stc_s[SAMPLES + 1];

+    c_forrange (i, int, SAMPLES) {

+        std_s[i] = test_std_forward_list();

+        stc_s[i] = test_stc_forward_list();

+        if (i > 0) c_forrange (j, int, N_TESTS) {

+            if (secs(std_s[i].test[j]) < secs(std_s[0].test[j])) std_s[0].test[j] = std_s[i].test[j];

+            if (secs(stc_s[i].test[j]) < secs(stc_s[0].test[j])) stc_s[0].test[j] = stc_s[i].test[j];

+            if (stc_s[i].test[j].sum != stc_s[0].test[j].sum) printf("Error in sum: test %d, sample %d\n", i, j);

+        }

+    }

+    const char* comp = argc > 1 ? argv[1] : "test";

+    bool header = (argc > 2 && argv[2][0] == '1');

+    float std_sum = 0, stc_sum = 0;

+    c_forrange (j, N_TESTS) { std_sum += secs(std_s[0].test[j]); stc_sum += secs(stc_s[0].test[j]); }

+    if (header) printf("Compiler,Library,C,Method,Seconds,Ratio\n");

+    c_forrange (j, N_TESTS) printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, operations[j], secs(std_s[0].test[j]), 1.0f);

+                            printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, "total", std_sum, 1.0f);

+    c_forrange (j, N_TESTS) printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, operations[j], secs(stc_s[0].test[j]), secs(std_s[0].test[j]) ? secs(stc_s[0].test[j])/secs(std_s[0].test[j]) : 1.0f);

+                            printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, "total", stc_sum, stc_sum/std_sum);

+}
\ No newline at end of file
diff --git a/benchmarks/plotbench/cmap_benchmark.cpp b/benchmarks/plotbench/cmap_benchmark.cpp
new file mode 100644
index 00000000..0dbe5a31
--- /dev/null
+++ b/benchmarks/plotbench/cmap_benchmark.cpp
@@ -0,0 +1,134 @@
+#include <stdio.h>

+#include <time.h>

+#include <stc/crandom.h>

+

+#ifdef __cplusplus

+#include <unordered_map>

+#endif

+

+enum {INSERT, ERASE, FIND, ITER, DESTRUCT, N_TESTS};

+const char* operations[] = {"insert", "erase", "find", "iter", "destruct"};

+typedef struct { time_t t1, t2; uint64_t sum; float fac; } Range;

+typedef struct { const char* name; Range test[N_TESTS]; } Sample;

+enum {SAMPLES = 2, N = 8000000, R = 4};

+uint64_t seed = 1, mask1 = 0xffffffff;

+

+static float secs(Range s) { return (float)(s.t2 - s.t1) / CLOCKS_PER_SEC; }

+

+#define i_key size_t

+#define i_val size_t

+#define i_hash c_default_hash64

+#define i_tag x

+#include <stc/cmap.h>

+

+#ifdef __cplusplus

+Sample test_std_unordered_map() {

+    typedef std::unordered_map<size_t, size_t> container;

+    Sample s = {"std,unordered_map"};

+    {

+        stc64_srandom(seed);

+        s.test[INSERT].t1 = clock();

+        container con;

+        c_forrange (i, N/2) con.emplace(stc64_random() & mask1, i);

+        c_forrange (i, N/2) con.emplace(i, i);

+        s.test[INSERT].t2 = clock();

+        s.test[INSERT].sum = con.size();

+        stc64_srandom(seed);

+        s.test[ERASE].t1 = clock();

+        c_forrange (N) con.erase(stc64_random() & mask1);

+        s.test[ERASE].t2 = clock();

+        s.test[ERASE].sum = con.size();

+     }{

+        container con;

+        stc64_srandom(seed);

+        c_forrange (i, N/2) con.emplace(stc64_random() & mask1, i);

+        c_forrange (i, N/2) con.emplace(i, i);

+        stc64_srandom(seed);

+        s.test[FIND].t1 = clock();

+        size_t sum = 0;

+        container::iterator it;

+        c_forrange (N) if ((it = con.find(stc64_random() & mask1)) != con.end()) sum += it->second;

+        s.test[FIND].t2 = clock();

+        s.test[FIND].sum = sum;

+        s.test[ITER].t1 = clock();

+        sum = 0;

+        c_forrange (R) for (auto i: con) sum += i.second;

+        s.test[ITER].t2 = clock();

+        s.test[ITER].sum = sum;

+        s.test[DESTRUCT].t1 = clock();

+     }

+     s.test[DESTRUCT].t2 = clock();

+     s.test[DESTRUCT].sum = 0;

+     return s;

+}

+#else

+Sample test_std_unordered_map() { Sample s = {"std-unordered_map"}; return s;}

+#endif

+

+

+Sample test_stc_unordered_map() {

+    typedef cmap_x container;

+    Sample s = {"STC,unordered_map"};

+    {

+        stc64_srandom(seed);

+        s.test[INSERT].t1 = clock();

+        container con = cmap_x_init();

+        c_forrange (i, N/2) cmap_x_emplace(&con, stc64_random() & mask1, i);

+        c_forrange (i, N/2) cmap_x_emplace(&con, i, i);

+        s.test[INSERT].t2 = clock();

+        s.test[INSERT].sum = cmap_x_size(con);

+        stc64_srandom(seed);

+        s.test[ERASE].t1 = clock();

+        c_forrange (N) cmap_x_erase(&con, stc64_random() & mask1);

+        s.test[ERASE].t2 = clock();

+        s.test[ERASE].sum = cmap_x_size(con);

+        cmap_x_del(&con);

+     }{

+        container con = cmap_x_init();

+        stc64_srandom(seed);

+        c_forrange (i, N/2) cmap_x_emplace(&con, stc64_random() & mask1, i);

+        c_forrange (i, N/2) cmap_x_emplace(&con, i, i);

+        stc64_srandom(seed);

+        s.test[FIND].t1 = clock();

+        size_t sum = 0;

+        const cmap_x_value* val;

+        c_forrange (N) 

+            if ((val = cmap_x_get(&con, stc64_random() & mask1)))

+                sum += val->second;

+        s.test[FIND].t2 = clock();

+        s.test[FIND].sum = sum;

+        s.test[ITER].t1 = clock();

+        sum = 0;

+        c_forrange (R) c_foreach (i, cmap_x, con) sum += i.ref->second;

+        s.test[ITER].t2 = clock();

+        s.test[ITER].sum = sum;

+        s.test[DESTRUCT].t1 = clock();

+        cmap_x_del(&con);

+     }

+     s.test[DESTRUCT].t2 = clock();

+     s.test[DESTRUCT].sum = 0;

+     return s;

+}

+

+int main(int argc, char* argv[])

+{

+    Sample std_s[SAMPLES + 1], stc_s[SAMPLES + 1];

+    c_forrange (i, int, SAMPLES) {

+        std_s[i] = test_std_unordered_map();

+        stc_s[i] = test_stc_unordered_map();

+        if (i > 0) c_forrange (j, int, N_TESTS) {

+            if (secs(std_s[i].test[j]) < secs(std_s[0].test[j])) std_s[0].test[j] = std_s[i].test[j];

+            if (secs(stc_s[i].test[j]) < secs(stc_s[0].test[j])) stc_s[0].test[j] = stc_s[i].test[j];

+            if (stc_s[i].test[j].sum != stc_s[0].test[j].sum) printf("Error in sum: test %d, sample %d\n", i, j);

+        }

+    }

+    const char* comp = argc > 1 ? argv[1] : "test";

+    bool header = (argc > 2 && argv[2][0] == '1');

+    float std_sum = 0, stc_sum = 0;

+    c_forrange (j, N_TESTS) { std_sum += secs(std_s[0].test[j]); stc_sum += secs(stc_s[0].test[j]); }

+    if (header) printf("Compiler,Library,C,Method,Seconds,Ratio\n");

+    c_forrange (j, N_TESTS) printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, operations[j], secs(std_s[0].test[j]), 1.0f);

+                            printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, "total", std_sum, 1.0f);

+    c_forrange (j, N_TESTS) printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, operations[j], secs(stc_s[0].test[j]), secs(std_s[0].test[j]) ? secs(stc_s[0].test[j])/secs(std_s[0].test[j]) : 1.0f);

+                            printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, "total", stc_sum, stc_sum/std_sum);

+}
\ No newline at end of file
diff --git a/benchmarks/plotbench/cpque_benchmark.cpp b/benchmarks/plotbench/cpque_benchmark.cpp
new file mode 100644
index 00000000..19a9c701
--- /dev/null
+++ b/benchmarks/plotbench/cpque_benchmark.cpp
@@ -0,0 +1,48 @@
+#include <stdio.h>

+#include <time.h>

+#include <stc/crandom.h>

+

+#define i_val float

+#define i_cmp -c_default_compare

+#define i_tag f

+#include <stc/cpque.h>

+

+int main()

+{

+    uint32_t seed = time(NULL);

+    stc64_t rng;

+    int N = 10000000, M = 10;

+

+    cpque_f pq = cpque_f_init();

+

+    rng = stc64_init(seed);

+    clock_t start = clock();

+    c_forrange (i, int, N)

+        cpque_f_push_back(&pq, (float) stc64_randf(&rng)*100000);

+

+    cpque_f_make_heap(&pq);

+    printf("Built priority queue: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);

+

+    c_forrange (i, int, M) {

+        printf("%g ", *cpque_f_top(&pq));

+        cpque_f_pop(&pq);

+    }

+

+    start = clock();

+    c_forrange (i, int, M, N)

+        cpque_f_pop(&pq);

+    printf("\n\npopped PQ: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);

+

+    start = clock();

+    c_forrange (i, int, N)

+        cpque_f_push(&pq, (float) stc64_randf(&rng)*100000);

+    printf("pushed PQ: %f secs\n", (clock() - start) / (float) CLOCKS_PER_SEC);

+

+    c_forrange (i, int, M) {

+        printf("%g ", *cpque_f_top(&pq));

+        cpque_f_pop(&pq);

+    }

+    puts("");

+

+    cpque_f_del(&pq);

+}

diff --git a/benchmarks/plotbench/csmap_benchmark.cpp b/benchmarks/plotbench/csmap_benchmark.cpp
new file mode 100644
index 00000000..47762791
--- /dev/null
+++ b/benchmarks/plotbench/csmap_benchmark.cpp
@@ -0,0 +1,134 @@
+#include <stdio.h>

+#include <time.h>

+#include <stc/crandom.h>

+

+#ifdef __cplusplus

+#include <map>

+#endif

+

+enum {INSERT, ERASE, FIND, ITER, DESTRUCT, N_TESTS};

+const char* operations[] = {"insert", "erase", "find", "iter", "destruct"};

+typedef struct { time_t t1, t2; uint64_t sum; float fac; } Range;

+typedef struct { const char* name; Range test[N_TESTS]; } Sample;

+enum {SAMPLES = 2, N = 4000000, R = 4};

+uint64_t seed = 1, mask1 = 0xfffffff;

+

+static float secs(Range s) { return (float)(s.t2 - s.t1) / CLOCKS_PER_SEC; }

+

+#define i_key size_t

+#define i_val size_t

+#define i_tag x

+#include <stc/csmap.h>

+

+#ifdef __cplusplus

+Sample test_std_map() {

+    typedef std::map<size_t, size_t> container;

+    Sample s = {"std,map"};

+    {

+        stc64_srandom(seed);

+        s.test[INSERT].t1 = clock();

+        container con;

+        c_forrange (i, N/2) con.emplace(stc64_random() & mask1, i);

+        c_forrange (i, N/2) con.emplace(i, i);

+        s.test[INSERT].t2 = clock();

+        s.test[INSERT].sum = con.size();

+        stc64_srandom(seed);

+        s.test[ERASE].t1 = clock();

+        c_forrange (N) con.erase(stc64_random() & mask1);

+        s.test[ERASE].t2 = clock();

+        s.test[ERASE].sum = con.size();

+     }{

+        container con;

+        stc64_srandom(seed);

+        c_forrange (i, N/2) con.emplace(stc64_random() & mask1, i);

+        c_forrange (i, N/2) con.emplace(i, i);

+        stc64_srandom(seed);

+        s.test[FIND].t1 = clock();

+        size_t sum = 0;

+        container::iterator it;

+        c_forrange (N) if ((it = con.find(stc64_random() & mask1)) != con.end()) sum += it->second;

+        s.test[FIND].t2 = clock();

+        s.test[FIND].sum = sum;

+        s.test[ITER].t1 = clock();

+        sum = 0;

+        c_forrange (R) for (auto i: con) sum += i.second;

+        s.test[ITER].t2 = clock();

+        s.test[ITER].sum = sum;

+        s.test[DESTRUCT].t1 = clock();

+     }

+     s.test[DESTRUCT].t2 = clock();

+     s.test[DESTRUCT].sum = 0;

+     return s;

+}

+#else

+Sample test_std_map() { Sample s = {"std-map"}; return s;}

+#endif

+

+

+

+Sample test_stc_map() {

+    typedef csmap_x container;

+    Sample s = {"STC,map"};

+    {

+        stc64_srandom(seed);

+        s.test[INSERT].t1 = clock();

+        container con = csmap_x_init();

+        c_forrange (i, N/2) csmap_x_emplace(&con, stc64_random() & mask1, i);

+        c_forrange (i, N/2) csmap_x_emplace(&con, i, i);

+        s.test[INSERT].t2 = clock();

+        s.test[INSERT].sum = csmap_x_size(con);

+        stc64_srandom(seed);

+        s.test[ERASE].t1 = clock();

+        c_forrange (N) csmap_x_erase(&con, stc64_random() & mask1);

+        s.test[ERASE].t2 = clock();

+        s.test[ERASE].sum = csmap_x_size(con);

+        csmap_x_del(&con);

+     }{

+        container con = csmap_x_init();

+        stc64_srandom(seed);

+        c_forrange (i, N/2) csmap_x_emplace(&con, stc64_random() & mask1, i);

+        c_forrange (i, N/2) csmap_x_emplace(&con, i, i);

+        stc64_srandom(seed);

+        s.test[FIND].t1 = clock();

+        size_t sum = 0;

+        const csmap_x_value* val;

+        c_forrange (N) 

+            if ((val = csmap_x_get(&con, stc64_random() & mask1)))

+                sum += val->second;

+        s.test[FIND].t2 = clock();

+        s.test[FIND].sum = sum;

+        s.test[ITER].t1 = clock();

+        sum = 0;

+        c_forrange (R) c_foreach (i, csmap_x, con) sum += i.ref->second;

+        s.test[ITER].t2 = clock();

+        s.test[ITER].sum = sum;

+        s.test[DESTRUCT].t1 = clock();

+        csmap_x_del(&con);

+     }

+     s.test[DESTRUCT].t2 = clock();

+     s.test[DESTRUCT].sum = 0;

+     return s;

+}

+

+int main(int argc, char* argv[])

+{

+    Sample std_s[SAMPLES + 1], stc_s[SAMPLES + 1];

+    c_forrange (i, int, SAMPLES) {

+        std_s[i] = test_std_map();

+        stc_s[i] = test_stc_map();

+        if (i > 0) c_forrange (j, int, N_TESTS) {

+            if (secs(std_s[i].test[j]) < secs(std_s[0].test[j])) std_s[0].test[j] = std_s[i].test[j];

+            if (secs(stc_s[i].test[j]) < secs(stc_s[0].test[j])) stc_s[0].test[j] = stc_s[i].test[j];

+            if (stc_s[i].test[j].sum != stc_s[0].test[j].sum) printf("Error in sum: test %d, sample %d\n", i, j);

+        }

+    }

+    const char* comp = argc > 1 ? argv[1] : "test";

+    bool header = (argc > 2 && argv[2][0] == '1');

+    float std_sum = 0, stc_sum = 0;

+    c_forrange (j, N_TESTS) { std_sum += secs(std_s[0].test[j]); stc_sum += secs(stc_s[0].test[j]); }

+    if (header) printf("Compiler,Library,C,Method,Seconds,Ratio\n");

+    c_forrange (j, N_TESTS) printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, operations[j], secs(std_s[0].test[j]), 1.0f);

+                            printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, "total", std_sum, 1.0f);

+    c_forrange (j, N_TESTS) printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, operations[j], secs(stc_s[0].test[j]), secs(std_s[0].test[j]) ? secs(stc_s[0].test[j])/secs(std_s[0].test[j]) : 1.0f);

+                            printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, "total", stc_sum, stc_sum/std_sum);

+}

diff --git a/benchmarks/plotbench/cvec_benchmark.cpp b/benchmarks/plotbench/cvec_benchmark.cpp
new file mode 100644
index 00000000..c4648e34
--- /dev/null
+++ b/benchmarks/plotbench/cvec_benchmark.cpp
@@ -0,0 +1,125 @@
+#include <stdio.h>

+#include <time.h>

+#include <stc/crandom.h>

+

+#ifdef __cplusplus

+#include <vector>

+#include <algorithm>

+#endif

+

+enum {INSERT, ERASE, FIND, ITER, DESTRUCT, N_TESTS};

+const char* operations[] = {"insert", "erase", "find", "iter", "destruct"};

+typedef struct { time_t t1, t2; uint64_t sum; float fac; } Range;

+typedef struct { const char* name; Range test[N_TESTS]; } Sample;

+enum {SAMPLES = 2, N = 150000000, S = 0x3ffc, R = 4};

+uint64_t seed = 1, mask1 = 0xfffffff, mask2 = 0xffff;

+

+static float secs(Range s) { return (float)(s.t2 - s.t1) / CLOCKS_PER_SEC; }

+

+#define i_val size_t

+#define i_tag x

+#include <stc/cvec.h>

+

+#ifdef __cplusplus

+Sample test_std_vector() {

+    typedef std::vector<size_t> container;

+    Sample s = {"std,vector"};

+    {

+        s.test[INSERT].t1 = clock();

+        container con;

+        stc64_srandom(seed);

+        c_forrange (N) con.push_back(stc64_random() & mask1);

+        s.test[INSERT].t2 = clock();

+        s.test[INSERT].sum = con.size();

+        s.test[ERASE].t1 = clock();

+        c_forrange (N) con.pop_back();

+        s.test[ERASE].t2 = clock();

+        s.test[ERASE].sum = con.size();

+     }{

+        container con;

+        stc64_srandom(seed);

+        c_forrange (N) con.push_back(stc64_random() & mask2);

+        s.test[FIND].t1 = clock();

+        size_t sum = 0;

+        container::iterator it;

+        // Iteration - not inherent find - skipping

+        //c_forrange (S) if ((it = std::find(con.begin(), con.end(), stc64_random() & mask2)) != con.end()) sum += *it;

+        s.test[FIND].t2 = clock();

+        s.test[FIND].sum = sum;

+        s.test[ITER].t1 = clock();

+        sum = 0;

+        c_forrange (R) c_forrange (i, N) sum += con[i];

+        s.test[ITER].t2 = clock();

+        s.test[ITER].sum = sum;

+        s.test[DESTRUCT].t1 = clock();

+     }

+     s.test[DESTRUCT].t2 = clock();

+     s.test[DESTRUCT].sum = 0;

+     return s;

+}

+#else

+Sample test_std_vector() { Sample s = {"std-vector"}; return s;}

+#endif

+

+

+

+Sample test_stc_vector() {

+    typedef cvec_x container;

+    Sample s = {"STC,vector"};

+    {

+        s.test[INSERT].t1 = clock();

+        container con = cvec_x_init();

+        stc64_srandom(seed);

+        c_forrange (N) cvec_x_push_back(&con, stc64_random() & mask1);

+        s.test[INSERT].t2 = clock();

+        s.test[INSERT].sum = cvec_x_size(con);

+        s.test[ERASE].t1 = clock();

+        c_forrange (N) { cvec_x_pop_back(&con); }

+        s.test[ERASE].t2 = clock();

+        s.test[ERASE].sum = cvec_x_size(con);

+        cvec_x_del(&con);

+     }{

+        stc64_srandom(seed);

+        container con = cvec_x_init();

+        c_forrange (N) cvec_x_push_back(&con, stc64_random() & mask2);

+        s.test[FIND].t1 = clock();

+        size_t sum = 0;

+        //cvec_x_iter it, end = cvec_x_end(&con);

+        //c_forrange (S) if ((it = cvec_x_find(&con, stc64_random() & mask2)).ref != end.ref) sum += *it.ref;

+        s.test[FIND].t2 = clock();

+        s.test[FIND].sum = sum;

+        s.test[ITER].t1 = clock();

+        sum = 0;

+        c_forrange (R) c_forrange (i, N) sum += con.data[i];

+        s.test[ITER].t2 = clock();

+        s.test[ITER].sum = sum;

+        s.test[DESTRUCT].t1 = clock();

+        cvec_x_del(&con);

+     }

+     s.test[DESTRUCT].t2 = clock();

+     s.test[DESTRUCT].sum = 0;

+     return s;

+}

+

+int main(int argc, char* argv[])

+{

+    Sample std_s[SAMPLES + 1] = {0}, stc_s[SAMPLES + 1] = {0};

+    c_forrange (i, int, SAMPLES) {

+        std_s[i] = test_std_vector();

+        stc_s[i] = test_stc_vector();

+        if (i > 0) c_forrange (j, int, N_TESTS) {

+            if (secs(std_s[i].test[j]) < secs(std_s[0].test[j])) std_s[0].test[j] = std_s[i].test[j];

+            if (secs(stc_s[i].test[j]) < secs(stc_s[0].test[j])) stc_s[0].test[j] = stc_s[i].test[j];

+            if (stc_s[i].test[j].sum != stc_s[0].test[j].sum) printf("Error in sum: test %d, sample %d\n", i, j);

+        }

+    }

+    const char* comp = argc > 1 ? argv[1] : "test";

+    bool header = (argc > 2 && argv[2][0] == '1');

+    float std_sum = 0, stc_sum = 0;

+    c_forrange (j, N_TESTS) { std_sum += secs(std_s[0].test[j]); stc_sum += secs(stc_s[0].test[j]); }

+    if (header) printf("Compiler,Library,C,Method,Seconds,Ratio\n");

+    c_forrange (j, N_TESTS) printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, operations[j], secs(std_s[0].test[j]), 1.0f);

+                            printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, std_s[0].name, N, "total", std_sum, 1.0f);

+    c_forrange (j, N_TESTS) printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, operations[j], secs(stc_s[0].test[j]), secs(std_s[0].test[j]) ? secs(stc_s[0].test[j])/secs(std_s[0].test[j]) : 1.0f);

+                            printf("%s,%s n:%d,%s,%.3f,%.3f\n", comp, stc_s[0].name, N, "total", stc_sum, stc_sum/std_sum);

+}

diff --git a/benchmarks/plotbench/plot.py b/benchmarks/plotbench/plot.py
new file mode 100644
index 00000000..ea3871f4
--- /dev/null
+++ b/benchmarks/plotbench/plot.py
@@ -0,0 +1,24 @@
+import sys

+import seaborn as sns

+import pandas as pd

+import matplotlib.pyplot as plt

+#sns.set_theme(style="whitegrid")

+

+comp = ['All compilers', 'Mingw-g++-10.30', 'Win-Clang-12', 'VC-19.28']

+n = int(sys.argv[1]) if len(sys.argv) > 1 else 0

+file = sys.argv[2] if len(sys.argv) > 2 else 'plot_win.csv'

+df = pd.read_csv(file)

+df = df[df.Method != 'total']

+if n > 0:

+    df = df[df.Compiler == comp[n]]

+

+g = sns.catplot(data=df, x='Method', y='Seconds', hue='Library', col='C', kind='bar',

+                 ci=68, legend=False, col_wrap=2, sharex=False, aspect=1.4, height=3.1)

+g.set_xlabels('')

+

+g.add_legend(bbox_to_anchor=(0.75, 0.2), borderaxespad=0.)

+

+g.fig.subplots_adjust(top=0.90, left=0.06, bottom=0.07)

+g.fig.suptitle('Benchmark STC vs c++ std containers: %s' % comp[n], fontsize=15, y=0.98)

+

+plt.show()

diff --git a/benchmarks/plotbench/run_all.bat b/benchmarks/plotbench/run_all.bat
new file mode 100644
index 00000000..2edd0a1e
--- /dev/null
+++ b/benchmarks/plotbench/run_all.bat
@@ -0,0 +1,5 @@
+set out=plot_win.csv
+echo Compiler,Library,C,Method,Seconds,Ratio> %out%
+sh run_gcc.sh >> %out%
+sh run_clang.sh >> %out%
+call run_vc.bat >> %out%
diff --git a/benchmarks/plotbench/run_all.sh b/benchmarks/plotbench/run_all.sh
new file mode 100644
index 00000000..f15a5881
--- /dev/null
+++ b/benchmarks/plotbench/run_all.sh
@@ -0,0 +1,4 @@
+out="plot_linux.csv"
+echo "Compiler,Library,C,Method,Seconds,Ratio"> $out
+sh run_gcc.sh >> $out
+sh run_clang.sh >> $out
diff --git a/benchmarks/plotbench/run_clang.sh b/benchmarks/plotbench/run_clang.sh
new file mode 100644
index 00000000..ae19486e
--- /dev/null
+++ b/benchmarks/plotbench/run_clang.sh
@@ -0,0 +1,14 @@
+exe=''
+if [ "$OS" = "Windows_NT" ] ; then exe=".exe" ; fi
+clang++ -I../include -O3 -o cdeq_benchmark$exe   cdeq_benchmark.cpp
+clang++ -I../include -O3 -o clist_benchmark$exe  clist_benchmark.cpp
+clang++ -I../include -O3 -o cmap_benchmark$exe   cmap_benchmark.cpp
+clang++ -I../include -O3 -o csmap_benchmark$exe  csmap_benchmark.cpp
+clang++ -I../include -O3 -o cvec_benchmark$exe   cvec_benchmark.cpp
+
+c='Win-Clang-12'
+./cdeq_benchmark$exe $c
+./clist_benchmark$exe $c
+./cmap_benchmark$exe $c
+./csmap_benchmark$exe $c
+./cvec_benchmark$exe $c
diff --git a/benchmarks/plotbench/run_gcc.sh b/benchmarks/plotbench/run_gcc.sh
new file mode 100644
index 00000000..6a6472c0
--- /dev/null
+++ b/benchmarks/plotbench/run_gcc.sh
@@ -0,0 +1,12 @@
+g++ -I../include -O3 -o cdeq_benchmark   cdeq_benchmark.cpp
+g++ -I../include -O3 -o clist_benchmark  clist_benchmark.cpp
+g++ -I../include -O3 -o cmap_benchmark   cmap_benchmark.cpp
+g++ -I../include -O3 -o csmap_benchmark  csmap_benchmark.cpp
+g++ -I../include -O3 -o cvec_benchmark   cvec_benchmark.cpp
+
+c='Mingw-g++-10.30'
+./cdeq_benchmark $c
+./clist_benchmark $c
+./cmap_benchmark $c
+./csmap_benchmark $c
+./cvec_benchmark $c
\ No newline at end of file
diff --git a/benchmarks/plotbench/run_vc.bat b/benchmarks/plotbench/run_vc.bat
new file mode 100644
index 00000000..3dca925b
--- /dev/null
+++ b/benchmarks/plotbench/run_vc.bat
@@ -0,0 +1,15 @@
+@echo off
+if "%VSINSTALLDIR%"=="" call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat" >nul
+cl.exe -nologo -EHsc -std:c++latest -I../include -O2 cdeq_benchmark.cpp >nul
+cl.exe -nologo -EHsc -std:c++latest -I../include -O2 clist_benchmark.cpp >nul
+cl.exe -nologo -EHsc -std:c++latest -I../include -O2 cmap_benchmark.cpp >nul
+cl.exe -nologo -EHsc -std:c++latest -I../include -O2 csmap_benchmark.cpp >nul
+cl.exe -nologo -EHsc -std:c++latest -I../include -O2 cvec_benchmark.cpp >nul
+del *.obj >nul
+
+set c=VC-19.28
+cdeq_benchmark.exe %c%
+clist_benchmark.exe %c%
+cmap_benchmark.exe %c%
+csmap_benchmark.exe %c%
+cvec_benchmark.exe %c%
\ No newline at end of file