bench: replace wall-clock timers with cpu-timers where possible

This commit improves the reliability of benchmarks by removing some of the influence of other background running processes. This is achieved by using CPU bound clocks that aren't influenced by interrupts, sleeps, blocked I/O, etc.

Author: Raimo33

src/CMakeLists.txt

@@ -124,13 +124,23 @@ elseif(CMAKE_SYSTEM_NAME STREQUAL "Windows")
 endif()
 unset(${PROJECT_NAME}_soversion)
 
+if(SECP256K1_BUILD_BENCHMARK OR SECP256K1_BUILD_TESTS)
+  if(WIN32)
+    add_library(clock_interface INTERFACE)  # It is empty on Windows.
+  else()
+    find_package(ClockGettime REQUIRED)
+    add_library(clock_interface ALIAS POSIX::clock_gettime)
+  endif()
+endif()
+
+
 if(SECP256K1_BUILD_BENCHMARK)
   add_executable(bench bench.c)
-  target_link_libraries(bench secp256k1)
+  target_link_libraries(bench secp256k1 clock_interface)
   add_executable(bench_internal bench_internal.c)
-  target_link_libraries(bench_internal secp256k1_precomputed secp256k1_asm)
+  target_link_libraries(bench_internal secp256k1_precomputed secp256k1_asm clock_interface)
   add_executable(bench_ecmult bench_ecmult.c)
-  target_link_libraries(bench_ecmult secp256k1_precomputed secp256k1_asm)
+  target_link_libraries(bench_ecmult secp256k1_precomputed secp256k1_asm clock_interface)
 endif()
 
 if(SECP256K1_BUILD_TESTS)
@@ -145,13 +155,13 @@ if(SECP256K1_BUILD_TESTS)
   endif()
 
   add_executable(noverify_tests tests.c)
-  target_link_libraries(noverify_tests secp256k1_precomputed secp256k1_asm)
+  target_link_libraries(noverify_tests secp256k1_precomputed secp256k1_asm clock_interface)
   target_compile_definitions(noverify_tests PRIVATE ${TEST_DEFINITIONS})
   add_test(NAME secp256k1_noverify_tests COMMAND noverify_tests)
   if(NOT CMAKE_BUILD_TYPE STREQUAL "Coverage")
     add_executable(tests tests.c)
     target_compile_definitions(tests PRIVATE VERIFY ${TEST_DEFINITIONS})
-    target_link_libraries(tests secp256k1_precomputed secp256k1_asm)
+    target_link_libraries(tests secp256k1_precomputed secp256k1_asm clock_interface)
     add_test(NAME secp256k1_tests COMMAND tests)
   endif()
   unset(TEST_DEFINITIONS)

src/bench.h

@@ -85,9 +85,9 @@ static void run_benchmark(char *name, void (*benchmark)(void*, int), void (*setu
         if (setup != NULL) {
             setup(data);
         }
-        begin = gettime_i64();
+        begin = gettime_us();
         benchmark(data, iter);
-        total = gettime_i64() - begin;
+        total = gettime_us() - begin;
         if (teardown != NULL) {
             teardown(data, iter);
         }

src/tests_common.h

@@ -17,25 +17,38 @@
 
 #include <stdint.h>
 
-#if (defined(_MSC_VER) && _MSC_VER >= 1900)
-#  include <time.h>
-#else
-#  include <sys/time.h>
+#if defined(_WIN32)
+# include <windows.h>
+#else /* POSIX */
+# include <time.h>
 #endif
 
-static int64_t gettime_i64(void) {
-#if (defined(_MSC_VER) && _MSC_VER >= 1900)
-    /* C11 way to get wallclock time */
-    struct timespec tv;
-    if (!timespec_get(&tv, TIME_UTC)) {
-        fputs("timespec_get failed!", stderr);
-        exit(EXIT_FAILURE);
-    }
-    return (int64_t)tv.tv_nsec / 1000 + (int64_t)tv.tv_sec * 1000000LL;
-#else
-    struct timeval tv;
-    gettimeofday(&tv, NULL);
-    return (int64_t)tv.tv_usec + (int64_t)tv.tv_sec * 1000000LL;
+static int64_t gettime_us(void) {
+#if defined(_WIN32)
+
+    LARGE_INTEGER freq, counter;
+    QueryPerformanceFrequency(&freq);
+    QueryPerformanceCounter(&counter);
+    return (int64_t)(counter.QuadPart * 1000000 / freq.QuadPart);
+
+#else /* POSIX */
+
+# if defined(CLOCK_PROCESS_CPUTIME_ID)
+    /* In theory, CLOCK_PROCESS_CPUTIME_ID is only useful if the process is locked to a core,
+     * see `man clock_gettime` on Linux. In practice, modern CPUs have synchronized TSCs which
+     * address this issue, see https://docs.amd.com/r/en-US/ug1586-onload-user/Timer-TSC-Stability . */
+    const clockid_t clock_type = CLOCK_PROCESS_CPUTIME_ID;
+# elif defined(CLOCK_MONOTONIC)
+    /* fallback to global timer */
+    const clockid_t clock_type = CLOCK_MONOTONIC;
+# else
+    /* fallback to wall-clock timer */
+    const clockid_t clock_type = CLOCK_REALTIME;
+# endif
+
+    struct timespec ts;
+    clock_gettime(clock_type, &ts);
+    return (int64_t)ts.tv_sec * 1000000 + ts.tv_nsec / 1000;
 #endif
 }
 

src/unit_test.c

@@ -260,10 +260,10 @@ static int read_args(int argc, char** argv, int start, struct tf_framework* tf)
 }
 
 static void run_test_log(const struct tf_test_entry* t) {
-    int64_t start_time = gettime_i64();
+    int64_t start_time = gettime_us();
     printf("Running %s..\n", t->name);
     t->func();
-    printf("Test %s PASSED (%.3f sec)\n", t->name, (double)(gettime_i64() - start_time) / 1000000);
+    printf("Test %s PASSED (%.3f sec)\n", t->name, (double)(gettime_us() - start_time) / 1000000);
 }
 
 static void run_test(const struct tf_test_entry* t) { t->func(); }
@@ -416,7 +416,7 @@ static int tf_run(struct tf_framework* tf) {
     /* Loop iterator */
     int it;
     /* Initial test time */
-    int64_t start_time = gettime_i64();
+    int64_t start_time = gettime_us();
     /* Verify 'tf_init' has been called */
     if (!tf->fn_run_test) {
         fprintf(stderr, "Error: No test runner set. You must call 'tf_init' first to initialize the framework "
@@ -472,7 +472,7 @@ static int tf_run(struct tf_framework* tf) {
     }
 
     /* Print accumulated time */
-    printf("Total execution time: %.3f seconds\n", (double)(gettime_i64() - start_time) / 1000000);
+    printf("Total execution time: %.3f seconds\n", (double)(gettime_us() - start_time) / 1000000);
     if (tf->fn_teardown && tf->fn_teardown() != 0) return EXIT_FAILURE;
 
     return status;