some tuning and more options

Author: Daniel Lemire

benchmarks/CMakeLists.txt

@@ -3,7 +3,6 @@ add_executable(benchmark
 )
 add_library(benchmark_deps INTERFACE)
 add_library(ieeeToString ieeeToString.cpp)
-target_include_directories(ieeeToString PRIVATE ${ryu_SOURCE_DIR})
 target_link_libraries(benchmark_deps INTERFACE ieeeToString)
 include(CheckSourceCompiles)
 check_source_compiles(CXX "

benchmarks/algorithms.h

@@ -82,7 +82,7 @@ struct BenchArgs {
   std::string name{};
   int (*func)(T, std::span<char>&){};
   bool used{};
-  unsigned char testRepeat{100};
+  size_t testRepeat{100};
 };
 
 template<arithmetic_float T>

benchmarks/benchmark.cpp

@@ -26,9 +26,21 @@
 using Benchmarks::arithmetic_float;
 using Benchmarks::BenchArgs;
 
+bool is_matched(const std::string &str, const std::span<std::string> filter) {
+  if (filter.empty()) {
+    return true;
+  }
+  for (const auto &f : filter) {
+    if (str.find(f) != std::string::npos) {
+      return true;
+    }
+  }
+  return false;
+}
+
 template <arithmetic_float T>
 void evaluateProperties(const std::vector<T> &lines,
-                        const std::array<BenchArgs<T>, Benchmarks::COUNT> &args, const std::string& filter = "") {
+                        const std::array<BenchArgs<T>, Benchmarks::COUNT> &args, const std::span<std::string> filter = {}) {
   constexpr auto precision = std::numeric_limits<T>::digits10;
   fmt::println("{:20} {:20}", "Algorithm", "Valid round-trip");
 
@@ -38,7 +50,7 @@ void evaluateProperties(const std::vector<T> &lines,
       continue;
     }
     // Apply filter if provided
-    if (!filter.empty() && std::string(filter).find(algo.name) == std::string::npos) {
+    if (!is_matched(algo.name, filter)) {
       std::cout << "# filtered out " << algo.name << std::endl;
       continue;
     }
@@ -73,14 +85,14 @@ void evaluateProperties(const std::vector<T> &lines,
 
 template <arithmetic_float T>
 void process(const std::vector<T> &lines,
-             const std::array<BenchArgs<T>, Benchmarks::COUNT> &args, const std::string& filter = "") {
+             const std::array<BenchArgs<T>, Benchmarks::COUNT> &args, const std::span<std::string> filter = {}) {
   for (const auto &algo : args) {
     if (!algo.used) {
       std::cout << "# skipping " << algo.name << std::endl;
       continue;
     }
     // Apply filter if provided
-    if (!filter.empty() && std::string(filter).find(algo.name) == std::string::npos) {
+    if (!is_matched(algo.name, filter)) {
       std::cout << "# filtered out " << algo.name << std::endl;
       continue;
     }
@@ -155,18 +167,20 @@ int main(int argc, char **argv) {
         cxxopts::value<bool>()->default_value("false"))
         ("e,errol", "Enable errol3 (current impl. returns invalid values, e.g., for 0).",
         cxxopts::value<bool>()->default_value("false"))
-        ("a,algo-filter", "Filter algorithms by name substring.",
-          cxxopts::value<std::string>()->default_value(""))
+        ("a,algo-filter", "Filter algorithms by name substring: you can use multiple filters separated by commas.",
+        cxxopts::value<std::vector<std::string>>()->default_value(""))
+        ("r,repeat", "Force a number of repetitions.",
+        cxxopts::value<size_t>()->default_value("0"))
         ("h,help", "Print usage.");
     const auto result = options.parse(argc, argv);
 
     if (result["help"].as<bool>()) {
       std::cout << options.help() << std::endl;
       return EXIT_SUCCESS;
     }
-
+    const size_t repeat = result["repeat"].as<size_t>();
     const bool single = result["single"].as<bool>();
-    const std::string filter = result["algo-filter"].as<std::string>();
+    std::vector<std::string> filter = result["algo-filter"].as<std::vector<std::string>>();
     std::cout << "number type: binary"
               << (single ? "32 (float)" : "64 (double)") << std::endl;
 
@@ -198,6 +212,14 @@ int main(int argc, char **argv) {
     else
       algorithms = Benchmarks::initArgs<double>(errol);
 
+    if(repeat > 0) {
+      std::cout << "# forcing repeat count to " << repeat << std::endl;
+      std::visit([repeat](auto &args) {
+        for (auto &arg : args)
+          arg.testRepeat = repeat;
+      }, algorithms);
+    }
+
     const bool test = result["test"].as<bool>();
     std::visit([test,&filter](const auto &lines, const auto &args) {
       using T1 = typename std::decay_t<decltype(lines)>::value_type;

benchmarks/exhaustivefloat32.cpp

@@ -8,6 +8,7 @@
 #include <iostream>
 #include <string_view>
 #include <charconv>
+#include <vector>
 
 #include "algorithms.h"
 #include "cxxopts.hpp"
@@ -59,7 +60,7 @@ std::optional<float> parse_float(std::string_view sv) {
   return std::nullopt;
 }
 
-void run_exhaustive32(bool errol) {
+void run_exhaustive32(bool errol, const std::vector<std::string>& algo_filter = {}) {
   constexpr auto precision = std::numeric_limits<float>::digits10;
   fmt::println("{:20} {:20}", "Algorithm", "Valid shortest serialization");
 
@@ -75,6 +76,22 @@ void run_exhaustive32(bool errol) {
       fmt::print("# skipping {} because it is the reference.\n", algo.name);
       continue;
     }
+    
+    // Apply filter if provided
+    if (!algo_filter.empty()) {
+      bool matched = false;
+      for (const auto &f : algo_filter) {
+        if (algo.name.find(f) != std::string::npos) {
+          matched = true;
+          break;
+        }
+      }
+      if (!matched) {
+        fmt::print("# filtered out {}\n", algo.name);
+        continue;
+      }
+    }
+    
     bool incorrect = false;
     char buf1[100], buf2[100];
     std::span<char> bufRef(buf1, sizeof(buf1)), bufAlgo(buf2, sizeof(buf2));
@@ -149,15 +166,21 @@ int main(int argc, char **argv) {
     options.add_options()(
         "e,errol",
         "Enable errol3 (current impl. returns invalid values, e.g., for 0).",
-        cxxopts::value<bool>()->default_value("false"))("h,help",
-                                                        "Print usage.");
+        cxxopts::value<bool>()->default_value("false"))(
+        "a,algorithm",
+        "Specify which algorithm(s) to test (comma-separated).",
+        cxxopts::value<std::vector<std::string>>()->default_value({}))(
+        "h,help",
+        "Print usage.");
     const auto result = options.parse(argc, argv);
 
     if (result["help"].as<bool>()) {
       fmt::print("{}\n", options.help());
       return EXIT_SUCCESS;
     }
-    run_exhaustive32(result["errol"].as<bool>());
+
+    auto algo_filter = result["algorithm"].as<std::vector<std::string>>();
+    run_exhaustive32(result["errol"].as<bool>(), algo_filter);
   } catch (const std::exception &e) {
     fmt::print("error parsing options: {}\n", e.what());
     return EXIT_FAILURE;