Allow index-less benchmarks via BenchmarkTarget wrapper

Author: leandrolcampos

libc/benchmarks/gpu/CMakeLists.txt

@@ -49,7 +49,6 @@ add_unittest_framework_library(
     libc.src.__support.CPP.string
     libc.src.__support.CPP.string_view
     libc.src.__support.CPP.type_traits
-    libc.src.__support.CPP.functional
     libc.src.__support.CPP.limits
     libc.src.__support.CPP.algorithm
     libc.src.__support.CPP.atomic

libc/benchmarks/gpu/LibcGpuBenchmark.cpp

@@ -1,4 +1,5 @@
 #include "LibcGpuBenchmark.h"
+
 #include "hdr/stdint_proxy.h"
 #include "src/__support/CPP/algorithm.h"
 #include "src/__support/CPP/array.h"
@@ -161,9 +162,8 @@ void Benchmark::run_benchmarks() {
   gpu::sync_threads();
 }
 
-BenchmarkResult
-benchmark(const BenchmarkOptions &options,
-          const cpp::function<uint64_t(uint32_t)> &wrapper_func) {
+BenchmarkResult benchmark(const BenchmarkOptions &options,
+                          const BenchmarkTarget &target) {
   BenchmarkResult result;
   RuntimeEstimationProgression rep;
   uint32_t iterations = options.initial_iterations;
@@ -183,7 +183,7 @@ benchmark(const BenchmarkOptions &options,
 
     const clock_t start = clock();
     while (sample_estimator.get_iterations() < iterations) {
-      auto current_result = wrapper_func(call_index++);
+      auto current_result = target(call_index++);
       max = cpp::max(max, current_result);
       min = cpp::min(min, current_result);
       sample_estimator.update(current_result);

libc/benchmarks/gpu/LibcGpuBenchmark.h

@@ -6,7 +6,6 @@
 #include "hdr/stdint_proxy.h"
 #include "src/__support/CPP/algorithm.h"
 #include "src/__support/CPP/array.h"
-#include "src/__support/CPP/functional.h"
 #include "src/__support/CPP/limits.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/type_traits.h"
@@ -121,21 +120,48 @@ struct BenchmarkResult {
   clock_t total_time = 0;
 };
 
-BenchmarkResult
-benchmark(const BenchmarkOptions &options,
-          const cpp::function<uint64_t(uint32_t)> &wrapper_func);
+struct BenchmarkTarget {
+  using IndexedFnPtr = uint64_t (*)(uint32_t);
+  using IndexlessFnPtr = uint64_t (*)();
+
+  enum class Kind : uint8_t { Indexed, Indexless } kind;
+  union {
+    IndexedFnPtr indexed_fn_ptr;
+    IndexlessFnPtr indexless_fn_ptr;
+  };
+
+  LIBC_INLINE BenchmarkTarget(IndexedFnPtr func)
+      : kind(Kind::Indexed), indexed_fn_ptr(func) {}
+  LIBC_INLINE BenchmarkTarget(IndexlessFnPtr func)
+      : kind(Kind::Indexless), indexless_fn_ptr(func) {}
+
+  LIBC_INLINE uint64_t operator()([[maybe_unused]] uint32_t call_index) const {
+    return kind == Kind::Indexed ? indexed_fn_ptr(call_index)
+                                 : indexless_fn_ptr();
+  }
+};
+
+BenchmarkResult benchmark(const BenchmarkOptions &options,
+                          const BenchmarkTarget &target);
 
 class Benchmark {
-  const cpp::function<uint64_t(uint32_t)> func;
+  const BenchmarkTarget target;
   const cpp::string_view suite_name;
   const cpp::string_view test_name;
   const uint32_t num_threads;
 
 public:
-  Benchmark(cpp::function<uint64_t(uint32_t)> func, char const *suite_name,
+  Benchmark(uint64_t (*f)(), const char *suite, const char *test,
+            uint32_t threads)
+      : target(BenchmarkTarget(f)), suite_name(suite), test_name(test),
+        num_threads(threads) {
+    add_benchmark(this);
+  }
+
+  Benchmark(uint64_t (*f)(uint32_t), char const *suite_name,
             char const *test_name, uint32_t num_threads)
-      : func(func), suite_name(suite_name), test_name(test_name),
-        num_threads(num_threads) {
+      : target(BenchmarkTarget(f)), suite_name(suite_name),
+        test_name(test_name), num_threads(num_threads) {
     add_benchmark(this);
   }
 
@@ -149,7 +175,7 @@ class Benchmark {
 private:
   BenchmarkResult run() {
     BenchmarkOptions options;
-    return benchmark(options, func);
+    return benchmark(options, target);
   }
 };
 

libc/benchmarks/gpu/src/ctype/CMakeLists.txt

@@ -7,7 +7,6 @@ add_benchmark(
   SRCS
     isalnum_benchmark.cpp
   DEPENDS
-    libc.hdr.stdint_proxy
     libc.src.ctype.isalnum
   LOADER_ARGS
     --threads 64
@@ -20,6 +19,5 @@ add_benchmark(
   SRCS
     isalpha_benchmark.cpp
   DEPENDS
-    libc.hdr.stdint_proxy
     libc.src.ctype.isalpha
 )

libc/benchmarks/gpu/src/ctype/isalnum_benchmark.cpp

@@ -1,9 +1,8 @@
 #include "benchmarks/gpu/LibcGpuBenchmark.h"
 
-#include "hdr/stdint_proxy.h"
 #include "src/ctype/isalnum.h"
 
-uint64_t BM_IsAlnum(uint32_t /*call_index*/) {
+uint64_t BM_IsAlnum() {
   char x = 'c';
   return LIBC_NAMESPACE::latency(LIBC_NAMESPACE::isalnum, x);
 }
@@ -13,13 +12,13 @@ SINGLE_THREADED_BENCHMARK(LlvmLibcIsAlNumGpuBenchmark, IsAlnumSingleThread,
 SINGLE_WAVE_BENCHMARK(LlvmLibcIsAlNumGpuBenchmark, IsAlnumSingleWave,
                       BM_IsAlnum);
 
-uint64_t BM_IsAlnumCapital(uint32_t /*call_index*/) {
+uint64_t BM_IsAlnumCapital() {
   char x = 'A';
   return LIBC_NAMESPACE::latency(LIBC_NAMESPACE::isalnum, x);
 }
 BENCHMARK(LlvmLibcIsAlNumGpuBenchmark, IsAlnumCapital, BM_IsAlnumCapital);
 
-uint64_t BM_IsAlnumNotAlnum(uint32_t /*call_index*/) {
+uint64_t BM_IsAlnumNotAlnum() {
   char x = '{';
   return LIBC_NAMESPACE::latency(LIBC_NAMESPACE::isalnum, x);
 }

libc/benchmarks/gpu/src/ctype/isalpha_benchmark.cpp

@@ -1,9 +1,8 @@
 #include "benchmarks/gpu/LibcGpuBenchmark.h"
 
-#include "hdr/stdint_proxy.h"
 #include "src/ctype/isalpha.h"
 
-uint64_t BM_IsAlpha(uint32_t /*call_index*/) {
+uint64_t BM_IsAlpha() {
   char x = 'c';
   return LIBC_NAMESPACE::latency(LIBC_NAMESPACE::isalpha, x);
 }