add --target-duration option

diff --git a/src/harness.cpp b/src/harness.cpp
index e6fbda3f3128e49e4d9f9e350bb9353734d9480a..68d33a1c797d9fe25993f2b1cf8565eb5ce32210 100644 (file)
--- a/src/harness.cpp
+++ b/src/harness.cpp
@@ -289,7 +289,13 @@ std::shared_ptr<BenchmarkResult> BenchHarnessBase::base_run(
             {
                 total_elapsed += i;
             }
             {
                 total_elapsed += i;
             }

-            auto target_average_elapsed = std::chrono::milliseconds(500);
+            std::chrono::duration<double> target_average_elapsed =
+                std::chrono::milliseconds(500);
+            if (config.target_duration)
+            {
+                target_average_elapsed =
+                    std::chrono::duration<double>(*config.target_duration);
+            }

             if (total_elapsed > thread_count * target_average_elapsed ||
                 iteration_count >= (1ULL << 63))
             {
             if (total_elapsed > thread_count * target_average_elapsed ||
                 iteration_count >= (1ULL << 63))
             {

diff --git a/src/harness.h b/src/harness.h
index b9ab39d38709d1ae217f317e009040c781ab1696..9c43cdd7c5bcf5d264aed11e5c4de2a4c107e506 100644 (file)
--- a/src/harness.h
+++ b/src/harness.h
@@ -15,6 +15,7 @@ struct Config final
 {
     std::optional<std::uint32_t> thread_count;
     std::optional<std::uint64_t> iteration_count;
 {
     std::optional<std::uint32_t> thread_count;
     std::optional<std::uint64_t> iteration_count;

+    std::optional<double> target_duration;

     std::uint32_t log2_memory_location_count = 0;
     std::uint32_t log2_stride = 0;
     static constexpr std::uint32_t max_sum_log2_mem_loc_count_and_stride = 28;
     std::uint32_t log2_memory_location_count = 0;
     std::uint32_t log2_stride = 0;
     static constexpr std::uint32_t max_sum_log2_mem_loc_count_and_stride = 28;


@@ -24,6 +25,7 @@ struct Config final
         return JsonValue::Object{
             {"thread_count", thread_count},
             {"iteration_count", iteration_count},
         return JsonValue::Object{
             {"thread_count", thread_count},
             {"iteration_count", iteration_count},

+            {"target_duration", target_duration},

             {"log2_memory_location_count", log2_memory_location_count},
             {"log2_stride", log2_stride},
             {"use_json", use_json},
             {"log2_memory_location_count", log2_memory_location_count},
             {"log2_stride", log2_stride},
             {"use_json", use_json},

diff --git a/src/main.cpp b/src/main.cpp
index f9bde51eea3437d63f615c18096e8a4cae070b39..c49029f427bbef1f5d2b1f57295d4153c94105c3 100644 (file)
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -11,6 +11,7 @@
 #include <map>
 #include <optional>
 #include <ostream>
 #include <map>
 #include <optional>
 #include <ostream>

+#include <sstream>

 #include <string_view>
 #include <system_error>
 #include <type_traits>
 #include <string_view>
 #include <system_error>
 #include <type_traits>


@@ -390,6 +391,35 @@ class OptionsParser final
         i_value.emplace();
         this->parse_int(value, i_value.value(), limits);
     }
         i_value.emplace();
         this->parse_int(value, i_value.value(), limits);
     }

+    template <typename Float>
+    std::enable_if_t<std::is_floating_point_v<Float>, void> parse_float(
+        std::optional<std::string_view> value, Float &f_value)
+    {
+        f_value = Float();
+        if (!value)
+        {
+            help_and_exit("missing value for ", current_option());
+        }
+        auto str = *value;
+        std::istringstream is{std::string(str)};
+        if (!(is >> f_value))
+        {
+            help_and_exit("invalid value for: ", current_option());
+        }
+    }
+    template <typename Float>
+    std::enable_if_t<std::is_floating_point_v<Float>, void> parse_float(
+        std::optional<std::string_view> value, std::optional<Float> &f_value,
+        bool required = true)
+    {
+        if (!required && !value)
+        {
+            f_value = std::nullopt;
+            return;
+        }
+        f_value.emplace();
+        this->parse_float(value, f_value.value());
+    }

 };
 
 inline std::vector<std::string_view> Options::parse(
 };
 
 inline std::vector<std::string_view> Options::parse(


@@ -479,6 +509,23 @@ int main(int, char **argv)
                        config.use_json = true;
                        json_pretty = true;
                    }},
                        config.use_json = true;
                        json_pretty = true;
                    }},

+        Option{.short_name = 'd',
+               .long_name = "target-duration",
+               .description =
+                   "target duration for a single benchmark in seconds",
+               .value_kind = OptionValueKind::Required,
+               .parse_value =
+                   [&](OptionsParser &parser, auto value) {
+                       parser.parse_float(value, config.target_duration);
+                       if (config.target_duration &&
+                           (!std::isfinite(*config.target_duration) ||
+                            *config.target_duration < 0))
+                       {
+                           parser.help_and_exit(
+                               "value out of range: target-duration=",
+                               *config.target_duration);
+                       }
+                   }},

     };
     OptionsParser parser(options, argv);
     auto args = parser.parse();
     };
     OptionsParser parser(options, argv);
     auto args = parser.parse();