added more benchmark code.

1 files changed, 94 insertions, 79 deletions

diff --git a/benchmarks/cdeq_benchmark.cpp b/benchmarks/cdeq_benchmark.cpp
index 6211afa5..2f49e1b6 100644
--- a/benchmarks/cdeq_benchmark.cpp
+++ b/benchmarks/cdeq_benchmark.cpp
@@ -1,98 +1,113 @@
 #include <stdio.h>

 #include <time.h>

-#include <deque>

-#include <vector>

-#include <stc/cdeq.h>

 #include <stc/crandom.h>

+#include <stc/cdeq.h>

+

+#ifdef __cplusplus

+#include <deque>

+#endif

 

-static float secs(time_t t1, time_t t2) { return (float)(t2 - t1) / CLOCKS_PER_SEC; }

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

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

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

+enum {SAMPLES = 3, N = 100000000};

 

+uint64_t seed = 1, mask1 = 0xfffffff;

 

-enum {N = 1000000000, M = 12345, P = 5000, R = 2000};

-using_cdeq(i, int);

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

 

-void test1() {

-    clock_t t1 = clock(), t2, t3;

-    stc64_t rng = stc64_init(0);

+using_cdeq(x, size_t);

+

+#ifdef __cplusplus

+Sample test_std_deque() {

+    typedef std::deque<size_t> container;

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

     {

-        std::deque<int> deq;

-        for (size_t i = 1; i < N; i++) {

-            deq.push_front(stc64_rand(&rng));

-            if (i % M == 0)

-                for (int j = 5; j < M; j++)

-                    deq.pop_back();

-        }

-        size_t n = deq.size();

-        t2 = clock();

-        printf("std pushf/popb  : %5.2f sec, sz=%zu\n", (float)(t2 - t1) / CLOCKS_PER_SEC, n);

-        fflush(stdout);

-        size_t sum = 0;

-        c_forrange (R) c_forrange (i, n)

-            sum += deq[i];

-        t3 = clock();

-        printf("std access      : %5.2f sec, sum=%zu\n", (float)(t3 - t2) / CLOCKS_PER_SEC, sum);

+        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_back(stc64_random() & mask1); con.pop_front(); }

+        c_forrange (N/2) 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/2) { con.pop_front(); con.pop_back(); }

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

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

      }{

-        std::deque<int> deq;

-        for (size_t i = 1; i < N/10; i++) {

-            if (i & 1) deq.push_front(stc64_rand(&rng));

-            else deq.push_back(stc64_rand(&rng));

-        }

-        t2 = clock();

-        printf("std pushf/pushb : %5.2f sec\n", (float)(t2 - t3) / CLOCKS_PER_SEC);

-    }{

-        std::deque<int> deq;

-        for (size_t i = 1; i < N/2; i++) {

-            deq.push_back(stc64_rand(&rng));

-        }

-        t3 = clock();

-        printf("std pushb       : %5.2f sec\n", (float)(t3 - t2) / CLOCKS_PER_SEC);

-    }    

+        container con;

+        stc64_srandom(seed);

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

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

+        size_t sum = 0;

+        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;

 }

+#endif

 

 

-void test2() {

-    clock_t t1 = clock(), t2, t3;

-    stc64_t rng = stc64_init(0);

+Sample test_stc_deque() {

+    typedef cdeq_x container;

+    Sample s = {"stc-deque"};

     {

-        cdeq_i deq = cdeq_i_init();

-        for (size_t i = 1; i < N; i++) {

-            cdeq_i_push_front(&deq, stc64_rand(&rng));

-            if (i % M == 0)

-                for (int j = 5; j < M; j++)

-                    cdeq_i_pop_back(&deq);

-        }

-        size_t n = cdeq_i_size(deq);

-        t2 = clock();

-        printf("stc pushf/popb  : %5.2f sec, sz=%zu\n", (float)(t2 - t1) / CLOCKS_PER_SEC, n);

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

+        container con = cdeq_x_init();

+        cdeq_x_reserve(&con, N);

+        stc64_srandom(seed);

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

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

+        c_forrange (N/2) 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 (N/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() & mask1);

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

         size_t sum = 0;

-        c_forrange (R) c_forrange (i, n)

-            sum += deq.data[i];

-        t3 = clock();

-        printf("stc access      : %5.2f sec, sum=%zu\n", (float)(t3 - t2) / CLOCKS_PER_SEC, sum);

-        cdeq_i_del(&deq);

-    }{

-        cdeq_i deq = cdeq_i_init();

-        for (size_t i = 1; i < N/10; i++) {

-            if (i & 1) cdeq_i_push_front(&deq, stc64_rand(&rng));

-            else cdeq_i_push_back(&deq, stc64_rand(&rng));

-        }

-        t2 = clock();

-        printf("stc pushf/pushb : %5.2f sec\n", (float)(t2 - t3) / CLOCKS_PER_SEC);

-        cdeq_i_del(&deq);

-    }{

-        cdeq_i deq = cdeq_i_init();

-        for (size_t i = 1; i < N/2; i++) {

-            cdeq_i_push_back(&deq, stc64_rand(&rng));

-        }

-        t3 = clock();

-        printf("stc pushb       : %5.2f sec\n", (float)(t3 - t2) / CLOCKS_PER_SEC);

-        cdeq_i_del(&deq);

-    }

+        c_forrange (i, N) sum += *cdeq_x_at(&con, 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()

 {

-    test1();

-    puts("");

-    test2();

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

+    c_forrange (i, int, SAMPLES) {

+        printf("deque benchmark sample %d\n", i);

+        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);

+        }

+    }

+    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]); }

+    printf("Test-name, Insert, Erase, Find, Iter, Destruct, Total, Ratio\n");

+

+    printf("%s", std_s[0].name); c_forrange (j, N_TESTS) printf(", %.3f", secs(std_s[0].test[j]));

+    printf(", %.3f, 1.000\n", std_sum);

+

+    printf("%s", stc_s[0].name); c_forrange (j, N_TESTS) printf(", %.3f", secs(stc_s[0].test[j]));

+    printf(", %.3f, %.3f\n", stc_sum, std_sum/stc_sum);

 }