Updated speed benchmark to output markdown

Author: cschreib

tests/speed_benchmark.cpp

@@ -1,6 +1,10 @@
 #include "speed_benchmark_common.hpp"
 
+#include <algorithm>
 #include <cmath>
+#include <iomanip>
+#include <unordered_map>
+#include <vector>
 
 template<typename B, typename F>
 auto run_benchmark_for(F&& func) {
@@ -10,8 +14,9 @@ auto run_benchmark_for(F&& func) {
     double                elapsed_square = 0.0;
     double                attempts       = 0.0;
     constexpr std::size_t num_iter       = 1'000'000;
+    constexpr double      min_time       = 0.2;
 
-    while (elapsed * num_iter < 1.0) {
+    while (elapsed * num_iter < min_time) {
         auto prev = timer::now();
 
         for (std::size_t i = 0; i < num_iter; ++i) {
@@ -50,6 +55,54 @@ auto run_benchmark(F&& func) {
     return std::make_pair(result, std::make_pair(ratio, ratio_stddev));
 }
 
+std::unordered_map<std::string, std::unordered_map<std::string, std::vector<double>>> results;
+
+template<typename T>
+struct get_type_name;
+
+template<typename T>
+struct get_type_name<std::shared_ptr<T>> {
+    static constexpr const char* value = "weak/shared";
+};
+
+template<typename T>
+struct get_type_name<oup::observable_unique_ptr<T>> {
+    static constexpr const char* value = "observer/obs_unique";
+};
+
+template<typename T>
+struct get_type_name<oup::observable_sealed_ptr<T>> {
+    static constexpr const char* value = "observer/obs_sealed";
+};
+
+template<typename T, typename R>
+void do_report(const char* name, const R& which) {
+    std::cout << " - " << name << ": " << which.first.first * 1e6 << " +/- "
+              << which.first.second * 1e6 << "us "
+              << "(x" << which.second.first << " +/- " << which.second.second << ")" << std::endl;
+
+    results[name][get_type_name<T>::value].push_back(which.second.first);
+}
+
+double median(std::vector<double> v) {
+    const auto n = v.size() / 2;
+    std::nth_element(v.begin(), v.begin() + n, v.end());
+    return *(v.begin() + n);
+}
+
+std::string round1(double v) {
+    std::ostringstream str;
+    str << std::fixed << std::setprecision(1);
+    str << std::round(v * 10.0) / 10.0;
+
+    auto res = str.str();
+    if (res.find_first_of('.') == std::string::npos) {
+        res += ".0";
+    }
+
+    return res;
+}
+
 template<typename T>
 void do_benchmarks_for_ptr(const char* type_name, const char* ptr_name) {
     using B = benchmark<T>;
@@ -70,11 +123,8 @@ void do_benchmarks_for_ptr(const char* type_name, const char* ptr_name) {
     auto dereference_weak = run_benchmark<B>([](auto& b) { return b.dereference_weak(); });
 
     std::cout << ptr_name << "<" << type_name << ">:" << std::endl;
-#define report(which)                                                                              \
-    std::cout << " - " << #which << ": " << which.first.first * 1e6 << " +/- "                     \
-              << which.first.second * 1e6 << "us "                                                 \
-              << "(x" << which.second.first << " +/- " << which.second.second << ")" << std::endl
 
+#define report(which) do_report<T>(#which, which)
     report(construct_destruct_owner_empty);
     report(construct_destruct_owner);
     report(construct_destruct_owner_factory);
@@ -83,8 +133,8 @@ void do_benchmarks_for_ptr(const char* type_name, const char* ptr_name) {
     report(construct_destruct_weak);
     report(construct_destruct_weak_copy);
     report(dereference_weak);
-
 #undef report
+
     std::cout << std::endl;
 }
 
@@ -100,5 +150,43 @@ int main() {
     do_benchmarks<float>("float");
     do_benchmarks<std::string>("string");
     do_benchmarks<std::array<int, 65'536>>("big_array");
+
+    std::vector<std::pair<std::string, std::string>> rows = {
+        {"Create owner empty", "construct_destruct_owner_empty"},
+        {"Create owner", "construct_destruct_owner"},
+        {"Create owner factory", "construct_destruct_owner_factory"},
+        {"Dereference owner", "dereference_owner"},
+        {"Create observer empty", "construct_destruct_weak_empty"},
+        {"Create observer", "construct_destruct_weak"},
+        {"Create observer copy", "construct_destruct_weak_copy"},
+        {"Dereference observer", "dereference_weak"},
+    };
+
+    std::vector<std::string> cols = {"weak/shared", "observer/obs_unique", "observer/obs_sealed"};
+
+    std::cout << "| Pointer | raw/unique | ";
+    for (const auto& t : cols) {
+        std::cout << t << " | ";
+    }
+    std::cout << std::endl;
+
+    std::cout << "|---|---|";
+    for (const auto& t : cols) {
+        std::cout << "---|";
+    }
+    std::cout << std::endl;
+
+    for (const auto& r : rows) {
+        std::cout << "| " << r.first << " | 1 | ";
+        for (const auto& t : cols) {
+            if (r.second == "construct_destruct_owner" && t == "observer/obs_sealed") {
+                std::cout << "N/A | ";
+            } else {
+                std::cout << round1(median(results[r.second][t])) << " | ";
+            }
+        }
+        std::cout << std::endl;
+    }
+
     return 0;
 }