JOSS - Remarks

.clangd

@@ -2,3 +2,9 @@ CompileFlags:
   CompilationDatabase: build/
 Diagnostics:
   UnusedIncludes: Strict
+  ClangTidy:
+    Add:
+      - 'bugprone-*'
+      - 'readability-*'
+      - 'clang-analyzer-core.*'
+      - 'clang-analyzer-security.*'

CMakeLists.txt

@@ -3,10 +3,6 @@ project(ctbench VERSION 1.1.1)
 
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 
-if(${CTBENCH_ENABLE_CLANG_TIDY})
-  set(CMAKE_CXX_CLANG_TIDY clang-tidy -checks=-*,readability-*)
-endif()
-
 include(cmake/dependencies.cmake)
 include(cmake/ctbench-compile-opts.cmake)
 

CMakePresets.json

@@ -16,8 +16,7 @@
         "CMAKE_EXPORT_COMPILE_COMMANDS": "ON",
         "CMAKE_BUILD_TYPE": "Debug",
         "CMAKE_CXX_COMPILER": "clang++",
-        "CMAKE_C_COMPILER": "clang",
-        "CMAKE_CXX_CLANG_TIDY": "clang-tidy;-checks=-*,readability-*"
+        "CMAKE_C_COMPILER": "clang"
       }
     },
     {

cmake/options.cmake

@@ -11,7 +11,3 @@ set(CTBENCH_ENABLE_TESTS
 set(CTBENCH_ENABLE_TRACY
     OFF
     CACHE BOOL "ctbench option: Enable Tracy profiler")
-
-set(CTBENCH_ENABLE_CLANG_TIDY
-    OFF
-    CACHE BOOL "ctbench option: Enable clang tidy")

example/CMakeLists.txt

@@ -0,0 +1,48 @@
+# Simple standalone project for compile-time benchmarking using ctbench
+
+# Usage:
+
+# ```sh
+# cmake --preset release
+# cmake --build --preset release
+# ```
+
+# CMake presets use clang/clang++ by default with time-trace enabled.
+
+cmake_minimum_required(VERSION 3.25)
+project(example-project)
+
+set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
+set(CMAKE_CXX_STANDARD 20)
+
+find_package(ctbench REQUIRED)
+
+add_compile_options(
+  -Wall
+  -Wextra
+  -Werror
+  -Wnull-dereference
+  -Wold-style-cast
+  -Wdouble-promotion
+  -Wshadow)
+
+if(ENABLE_TIME_TRACE)
+  add_compile_options(-ftime-trace -ftime-trace-granularity=1
+                      -fconstexpr-steps=2147483647 -fbracket-depth=2147483647)
+endif()
+
+set(BENCHMARK_START 0 CACHE STRING "Benchmark size minimum")
+set(BENCHMARK_STOP 64 CACHE STRING "Benchmark size maximum")
+set(BENCHMARK_STEP 1 CACHE STRING "Benchmark size step")
+set(BENCHMARK_ITERATIONS 10 CACHE STRING "Number of samples per size")
+
+ctbench_add_benchmark(
+  variadic_sum.expansion variadic_sum/expansion.cpp ${BENCHMARK_START}
+  ${BENCHMARK_STOP} ${BENCHMARK_STEP} ${BENCHMARK_ITERATIONS})
+
+ctbench_add_benchmark(
+  variadic_sum.recursive variadic_sum/recursive.cpp ${BENCHMARK_START}
+  ${BENCHMARK_STOP} ${BENCHMARK_STEP} ${BENCHMARK_ITERATIONS})
+
+ctbench_add_graph(variadic_sum-compare-graph compare-all.json
+                  variadic_sum.expansion variadic_sum.recursive)

example/CMakePresets.json

@@ -0,0 +1,65 @@
+{
+  "version" : 4,
+  "cmakeMinimumRequired" : {
+    "major" : 3,
+    "minor" : 25,
+    "patch" : 0
+  },
+  "configurePresets" : [
+    {
+      "name" : "dev",
+      "displayName" : "Dev build",
+      "description" : "Provides a compile_commands.json file",
+      "generator" : "Ninja",
+      "binaryDir" : "${sourceDir}/build",
+      "cacheVariables" : {
+        "ENABLE_TIME_TRACE" : "ON",
+        "CMAKE_CXX_COMPILER" : "clang++",
+        "CMAKE_C_COMPILER" : "clang",
+        "CMAKE_EXPORT_COMPILE_COMMANDS" : "ON",
+        "CMAKE_BUILD_TYPE" : "RelWithDebInfo"
+      }
+    },
+    {
+      "name" : "release",
+      "displayName" : "Release",
+      "description" : "Release",
+      "generator" : "Ninja",
+      "binaryDir" : "${sourceDir}/build/release",
+      "cacheVariables" : {
+        "ENABLE_TIME_TRACE" : "ON",
+        "CMAKE_CXX_COMPILER" : "clang++",
+        "CMAKE_C_COMPILER" : "clang",
+        "CMAKE_EXPORT_COMPILE_COMMANDS" : "ON",
+        "CMAKE_BUILD_TYPE" : "RelWithDebInfo"
+      }
+    },
+    {
+      "name" : "debug",
+      "inherits" : "release",
+      "displayName" : "Debug",
+      "description" : "Debug",
+      "binaryDir" : "${sourceDir}/build/debug",
+      "cacheVariables" : {
+        "CMAKE_BUILD_TYPE" : "Debug"
+      }
+    }
+  ],
+  "buildPresets" : [
+    {
+      "name" : "release",
+      "configurePreset" : "release",
+      "nativeToolOptions" : [
+        "-j1"
+      ],
+      "targets" : [
+        "ctbench-graph-all"
+      ]
+    },
+    {
+      "name" : "debug",
+      "inherits" : "release",
+      "configurePreset" : "debug"
+    }
+  ]
+}

example/compare-all.json

@@ -0,0 +1,14 @@
+{
+  "plotter": "compare_by",
+  "legend_title": "Timings",
+  "x_label": "Benchmark size factor",
+  "y_label": "Time (µs)",
+  "draw_average": true,
+  "demangle": false,
+  "draw_points": false,
+  "width": 800,
+  "height": 400,
+  "key_ptrs": ["/name", "/args/detail"],
+  "value_ptr": "/dur",
+  "plot_file_extensions": [".svg"]
+}

example/variadic_sum/expansion.cpp

@@ -0,0 +1,27 @@
+#include <utility>
+
+/// Compile-time std::size_t
+template <std::size_t N> struct ct_uint_t {
+  static constexpr std::size_t value = N;
+};
+
+/// Expansion compile-time sum implementation
+template<typename ... Ts> constexpr auto sum();
+
+template <> constexpr auto sum() { return ct_uint_t<0>{}; }
+
+template <typename... Ts> constexpr auto sum(Ts const &...) {
+  return ct_uint_t<(Ts::value + ... + 0)>{};
+}
+
+// Driver code
+
+template <typename = void> constexpr auto foo() {
+  return []<std::size_t... Is>(std::index_sequence<Is...>) {
+    return sum(ct_uint_t<Is>{}...);
+  }
+  (std::make_index_sequence<BENCHMARK_SIZE>{});
+}
+
+[[maybe_unused]] constexpr std::size_t result =
+    decltype(foo())::value;

example/variadic_sum/recursive.cpp

@@ -0,0 +1,29 @@
+#include <utility>
+
+/// Compile-time std::size_t
+template <std::size_t N> struct ct_uint_t {
+  static constexpr std::size_t value = N;
+};
+
+/// Recursive compile-time sum implementation
+template<typename ... Ts> constexpr auto sum();
+
+template <> constexpr auto sum() { return ct_uint_t<0>{}; }
+template <typename T> constexpr auto sum(T const &) { return T{}; }
+
+template <typename T, typename... Ts>
+constexpr auto sum(T const &, Ts const &...tl) {
+  return ct_uint_t<T::value + decltype(sum(tl...))::value>{};
+}
+
+// Driver code
+
+template <typename = void> constexpr auto foo() {
+  return []<std::size_t... Is>(std::index_sequence<Is...>) {
+    return sum(ct_uint_t<Is>{}...);
+  }
+  (std::make_index_sequence<BENCHMARK_SIZE>{});
+}
+
+[[maybe_unused]] constexpr std::size_t result =
+    decltype(foo())::value;

grapher/include/grapher/core.hpp

@@ -26,6 +26,9 @@ using multimap_t =
 /// Alias type for JSON objects.
 using json_t = nlohmann::basic_json<boost::container::flat_map>;
 
+/// Default type to represent scalar values from benchmark data.
+using value_t = unsigned long;
+
 // `time cmake --build --preset bench` results using different containers
 // (poacher/brainfuck project, pre-built benchmark targets):
 // - boost::container::flat_map -> 78.05 secs

grapher/include/grapher/utils/json.hpp

@@ -19,9 +19,10 @@ namespace grapher {
 
 /// For each instance in entry, returns the sum of the values pointed by
 /// value_jptr in the events matching the descriptor's predicates.
-std::vector<double> get_values(benchmark_instance_t const &instance,
-                               std::vector<predicate_t> const &predicates,
-                               grapher::json_t::json_pointer value_jptr);
+std::vector<grapher::value_t>
+get_values(benchmark_instance_t const &instance,
+           std::vector<predicate_t> const &predicates,
+           grapher::json_t::json_pointer value_jptr);
 
 /// Generic conversion of a JSON field location to a std::string
 template <typename T>
@@ -172,7 +173,7 @@ grapher::json_t::array_t
 write_descriptors(std::vector<group_descriptor_t> const &descriptors);
 
 /// Reads a single descriptor.
-group_descriptor_t read_descriptor(grapher::json_t const &j);
+group_descriptor_t read_descriptor(grapher::json_t const &descriptor_json);
 
 /// Reads descriptors from a predicate list.
 std::vector<group_descriptor_t>

grapher/lib/grapher/plotters/compare.cpp

@@ -59,19 +59,19 @@ void plotter_compare_t::plot(benchmark_set_t const &bset,
     std::vector<predicate_t> predicates = get_predicates(descriptor);
 
     for (benchmark_case_t const &bench : bset) {
-      std::vector<double> x_points;
-      std::vector<double> y_points;
+      std::vector<grapher::value_t> x_points;
+      std::vector<grapher::value_t> y_points;
 
-      std::vector<double> x_average;
-      std::vector<double> y_average;
+      std::vector<grapher::value_t> x_average;
+      std::vector<grapher::value_t> y_average;
 
       for (benchmark_instance_t const &instance : bench.instances) {
         check(!instance.repetitions.empty(),
               fmt::format("No data in benchmark {} for instance size {}.",
                           bench.name, instance.size),
               error_level_t::warning_v);
 
-        std::vector<double> const values =
+        std::vector<grapher::value_t> const values =
             get_values(instance, predicates, value_json_pointer);
 
         check(!values.empty(),
@@ -82,7 +82,7 @@ void plotter_compare_t::plot(benchmark_set_t const &bset,
 
         // Drawing points
         if (draw_points) {
-          for (double value : values) {
+          for (grapher::value_t value : values) {
             x_points.push_back(instance.size);
             y_points.push_back(value);
           }