Update sso_bench.cpp benchmark, and some internal improvements.

1 files changed, 79 insertions, 51 deletions

diff --git a/benchmarks/misc/sso_bench.cpp b/benchmarks/misc/sso_bench.cpp
index bcc43ba0..7742700a 100644
--- a/benchmarks/misc/sso_bench.cpp
+++ b/benchmarks/misc/sso_bench.cpp
@@ -1,107 +1,135 @@
 #include <string>
 #include <iostream>
-#include <vector>
-#include <unordered_set>
 #include <chrono>
-#define i_static
+
 #include <stc/crandom.h>
-#define i_static
 #include <stc/cstr.h>
 
-#define i_type stccon
+#define i_type StcVec
+#define i_val_str
+#include <stc/cstack.h>
+
+#define i_type StcSet
 #define i_val_str
-#include <stc/cvec.h>
+#include <stc/csset.h>
+
+#include <vector>
+using StdVec = std::vector<std::string>;
+#include <set>
+using StdSet = std::set<std::string>;
 
-using stdcon = std::vector<std::string>;
 
-static const int BENCHMARK_SIZE = 5000000;
-static const int MAX_STRING_LENGTH = 40;
+static const int BENCHMARK_SIZE = 4000000;
+static const int MAX_STRING_SIZE = 50;
 static const char CHARS[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz=+-";
 using time_point = std::chrono::high_resolution_clock::time_point;
 
 
-void addRandomString_STD(stdcon& con, int length) {
-    std::string s(length, 0);
+static inline std::string randomString_STD(int strsize) {
+    std::string s(strsize, 0);
     char* p = &s[0];
     union { uint64_t u8; uint8_t b[8]; } r;
-    for (int i = 0; i < length; ++i) {
+    for (int i = 0; i < strsize; ++i) {
         if ((i & 7) == 0) r.u8 = crandom() & 0x3f3f3f3f3f3f3f3f;
         p[i] = CHARS[r.b[i & 7]];
     }
-    con.push_back(std::move(s));
+    return s;
 }
 
-void addRandomString_STC(stccon& con, int length) {
-    cstr s = cstr_with_size(length, 0);
+static inline cstr randomString_STC(int strsize) {
+    cstr s = cstr_with_size(strsize, 0);
     char* p = cstr_data(&s);
     union { uint64_t u8; uint8_t b[8]; } r;
-    for (int i = 0; i < length; ++i) {
+    for (int i = 0; i < strsize; ++i) {
         if ((i & 7) == 0) r.u8 = crandom() & 0x3f3f3f3f3f3f3f3f;
         p[i] = CHARS[r.b[i & 7]];
     }
-    stccon_push_back(&con, s);
+    return s;
+}
+
+
+void addRandomString(StdVec& vec, int strsize) {
+    vec.push_back(std::move(randomString_STD(strsize)));
+}
+
+void addRandomString(StcVec& vec, int strsize) {
+    StcVec_push(&vec, randomString_STC(strsize));
+}
+
+void addRandomString(StdSet& set, int strsize) {
+    set.insert(std::move(randomString_STD(strsize)));
+}
+
+void addRandomString(StcSet& set, int strsize) {
+    StcSet_insert(&set, randomString_STC(strsize));
 }
 
-template <class L, typename R>
-int benchmark(L& con, const int length, R addRandomString) {
+
+template <class C>
+int benchmark(C& container, const int n, const int strsize) {
     time_point t1 = std::chrono::high_resolution_clock::now();
 
-    if (length == 0)
-        for (int i = 0; i < BENCHMARK_SIZE; i++)
-            addRandomString(con, (crandom() & 63) + 1);
-    else
-        for (int i = 0; i < BENCHMARK_SIZE; i++)
-            addRandomString(con, length);
+    for (int i = 0; i < n; i++)
+        addRandomString(container, strsize);
 
     time_point t2 = std::chrono::high_resolution_clock::now();
     const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(t2 - t1).count();
-    std::cerr << (length ? length : 32) << "\t" << duration;
+    std::cerr << (strsize ? strsize : 32) << "\t" << duration;
     return (int)duration;
 }
 
 
 int main() {
     uint64_t seed = 4321;
-    csrandom(seed);
     int sum, n;
-    std::cerr << "length\ttime\tstd::string\n";
-    for (int k = 0; k < 4; k++) {
-        stdcon con; con.reserve(BENCHMARK_SIZE);
-        benchmark(con, 0, addRandomString_STD);
-        std::cout << '\t' << *con.begin() << '\n';
+
+    // VECTOR WITH STRINGS
+
+    csrandom(seed);
+    sum = 0, n = 0;
+    std::cerr << "\nstrsize\tmsecs\tstd::vector<std::string>, size=" << BENCHMARK_SIZE << "\n";
+    for (int strsize = 1; strsize <= MAX_STRING_SIZE; strsize += 2) {
+        StdVec vec; vec.reserve(BENCHMARK_SIZE);
+        sum += benchmark(vec, BENCHMARK_SIZE, strsize), ++n;
+        std::cout << '\t' << vec.front() << '\n';
     }
+    std::cout << "Avg:\t" << sum/n << '\n';
 
     csrandom(seed);
-    std::cerr << "\nlength\ttime\tSTC string\n";
-    for (int k = 0; k < 4; k++) {
-        stccon con = stccon_with_capacity(BENCHMARK_SIZE);
-        benchmark(con, 0, addRandomString_STC);
-        std::cout << '\t' << cstr_str(stccon_begin(&con).ref) << '\n';
-        stccon_drop(&con);
+    sum = 0, n = 0;
+    std::cerr << "\nstrsize\tmsecs\tcvec<cstr>, size=" << BENCHMARK_SIZE << "\n";
+    for (int strsize = 1; strsize <= MAX_STRING_SIZE; strsize += 2) {
+        StcVec vec = StcVec_with_capacity(BENCHMARK_SIZE);
+        sum += benchmark(vec, BENCHMARK_SIZE, strsize), ++n;
+        std::cout << '\t' << cstr_str(&vec.data[0]) << '\n';
+        StcVec_drop(&vec);
     }
+    std::cout << "Avg:\t" << sum/n << '\n';
 
+    // SORTED SET WITH STRINGS
+    
     csrandom(seed);
     sum = 0, n = 0;
-    std::cerr << "\nlength\ttime\tstd::string\n";
-    for (int length = 1; length <= MAX_STRING_LENGTH; length += 2) {
-        stdcon con; con.reserve(BENCHMARK_SIZE);
-        sum += benchmark(con, length, addRandomString_STD), ++n;
-        std::cout << '\t' << *con.begin() << '\n';
+    std::cerr << "\nstrsize\tmsecs\tstd::set<std::string>, size=" << BENCHMARK_SIZE/16 << "\n";
+    for (int strsize = 1; strsize <= MAX_STRING_SIZE; strsize += 2) {
+        StdSet set;
+        sum += benchmark(set, BENCHMARK_SIZE/16, strsize), ++n;
+        std::cout << '\t' << *set.begin() << '\n';
     }
     std::cout << "Avg:\t" << sum/n << '\n';
 
     csrandom(seed);
     sum = 0, n = 0;
-    std::cerr << "\nlength\ttime\tSTC string\n";
-    for (int length = 1; length <= MAX_STRING_LENGTH; length += 2) {
-        stccon con = stccon_with_capacity(BENCHMARK_SIZE);
-        sum += benchmark(con, length, addRandomString_STC), ++n;
-        std::cout << '\t' << cstr_str(stccon_begin(&con).ref) << '\n';
-        stccon_drop(&con);
+    std::cerr << "\nstrsize\tmsecs\tcset<cstr>, size=" << BENCHMARK_SIZE/16 << "\n";
+    for (int strsize = 1; strsize <= MAX_STRING_SIZE; strsize += 2) {
+        StcSet set = StcSet_with_capacity(BENCHMARK_SIZE/16);
+        sum += benchmark(set, BENCHMARK_SIZE/16, strsize), ++n;
+        std::cout << '\t' << cstr_str(StcSet_front(&set)) << '\n';
+        StcSet_drop(&set);
     }
     std::cout << "Avg:\t" << sum/n << '\n';
 
-    std::cerr << "sizeof std::string : " << sizeof(std::string) << std::endl
-              << "sizeof STC string  : " << sizeof(cstr) << std::endl;
+    std::cerr << "sizeof(std::string) : " << sizeof(std::string) << std::endl
+              << "sizeof(cstr)        : " << sizeof(cstr) << std::endl;
     return 0;
 }