Merge pull request #87 from jty2/github-jty2.merging.2025-05.postfix

Author: jty2

benchmarks/lockhammer/Makefile

@@ -408,6 +408,39 @@ LOCK_DEPS = $(addprefix $(BUILD_DIR)/,$(addsuffix .d,$(addprefix $(LOCK_BASENAME
 LOCK_I = $(addprefix $(BUILD_DIR)/,$(addsuffix .i,$(addprefix $(LOCK_BASENAME).,$(TEST_TARGETS))))
 
 
+# ---------------------
+# early dependency checking
+
+define no_libjansson_message
+
+
+Jansson (for JSON result output) does not appear to be installed.
+
+To build without JSON output, rerun make with NO_JSON=1, e.g.:
+
+make $(MAKECMDGOALS) NO_JSON=1
+
+Or install Jansson development headers, perhaps using:
+
+sudo apt install libjansson-dev
+
+and then run 'make clean' before trying to rebuild
+endef
+
+# This variable is only for the header existience check.  Modify this and
+# CFLAGS/LDFLAGS if Jansson is installed in another location.
+
+JANSSON_HEADER_FILE=/usr/include/jansson.h
+
+ifneq ($(NO_JSON),1)
+ifeq ($(filter $(ALL_CLEAN_TARGETS),$(MAKECMDGOALS)),)
+ifeq (,$(wildcard $(JANSSON_HEADER_FILE)))
+$(error $(no_libjansson_message))
+endif
+endif
+endif
+
+
 # ---------------------
 # info for debugging make
 

benchmarks/lockhammer/include/perf_timer.h

@@ -52,6 +52,7 @@
 #include <string.h>
 #include <unistd.h>    /* for access() */
 #include <math.h>
+#include <sys/time.h>
 
 #include "atomics.h"
 
@@ -107,7 +108,7 @@ rdtscp(void)
 
     asm volatile("rdtscp" :
              "=a" (tsc.lo_32),
-             "=d" (tsc.hi_32));
+             "=d" (tsc.hi_32) :: "ecx");
 
     return tsc.tsc_64;
 }
@@ -265,68 +266,31 @@ static inline void __attribute__((always_inline))
 timer_init() {
 }
 
+// this function should be implemented in one .c file
+unsigned long estimate_hwclock_freq(size_t n, int verbose, struct timeval target_measurement_duration);
+
 static inline uint64_t __attribute__((always_inline))
 timer_get_timer_freq(void)
 {
     extern unsigned long hwtimer_frequency;
     if (hwtimer_frequency) { return hwtimer_frequency; }
 
-    uint64_t cnt_freq;
 #ifdef __aarch64__
-        __asm__ __volatile__ ("isb; mrs %0, cntfrq_el0" : "=r" (cnt_freq));
+    __asm__ __volatile__ ("isb; mrs %0, cntfrq_el0" : "=r" (hwtimer_frequency));
 #elif __x86_64__
-    // This code attempts to get the TSC frequency.  The assumption made
-    // is TSC frequency equals the CPUFreq cpuinfo_max_freq attribute
-    // value, which is the maximum operating frequency of the processor.
-    // However, this equality is not always true, and less so in newer CPUs.
-    // Also, the actual TSC frequency may not exactly match any nominal
-    // frequency attribute value provided by CPUFreq, so the chances of
-    // this returning the correct frequency have diminished.
 
-    // If the CPUFreq cpuinfo_max_freq attribute is not available, this code
-    // then tries to quickly measure it.
+    // This measures the TSC frequency over a 3 durations of 0.1 seconds.
 
     // Use --timer-frequency flag to override the frequency value.
-    // Use --estimate-timer-frequency to explicitly measure it.
-
-    char buf[100];
-    FILE * f = fopen("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq", "r");
-    if (f == NULL) {
-        printf("Failed to open cpuinfo_max_freq, error %s\n",
-            strerror(errno));
-        uint64_t iterations = 2;
-        uint64_t time = 0;
-        for (uint64_t i = 0; i < iterations; i++) {
-            uint64_t start = rdtscp_start();
-            sleep(1);
-            uint64_t end = rdtscp_end();
-            time += end - start;
-        }
-
-        // round down cycles
-        uint64_t tmp = (time/iterations);
-        unsigned long len = log10(tmp);
-        double div = pow(10, len-2);
-        return floor(tmp/div)*div;
-    }
-    while (! feof(f) && ! ferror(f)) {
-        size_t end = fread(buf, 1, sizeof(buf) - 1, f);
-        buf[end] = 0;
-    }
-    fclose(f);
-
-    /* The ACPI cpufreq driver reports 'base' (aka non-turbo) frequency
-       in cpuinfo_max_freq while the intel_pstate driver reports the
-       turbo frequency. Warn if ACPI cpufreq is not found. */
-    if (access("/sys/devices/system/cpu/cpufreq", F_OK)) {
-        printf("cpuinfo_max_freq is not from ACPI cpufreq driver! TSC frequency is probably turbo frequency.\n");
-    }
-
-    cnt_freq = strtoul(buf, NULL, 0);
-    cnt_freq = ((cnt_freq + 5000) / 10000) * 10000;    /* round to nearest 10000 kHz */
-    cnt_freq *= 1000;    /* convert KHz to Hz */
+    // Use --estimate-timer-frequency to measure over a longer duration.
+
+    const struct timeval measurement_duration = { .tv_sec = 0, .tv_usec = 100000 };
+
+    hwtimer_frequency = estimate_hwclock_freq(1, 0, measurement_duration);
+#else
+#error "ERROR: timer_get_timer_freq() is not implemented for this system!"
 #endif
-    return cnt_freq;
+    return hwtimer_frequency;
 }
 
 #define TOKENS_MAX_HIGH    1000000        /* good for ~41500 cntvct cycles */

benchmarks/lockhammer/src/lockhammer.c

@@ -909,11 +909,11 @@ void disable_itimer (void) {
 
 static unsigned long estimate_hwtimer_freq(long cpu_num) {
 
-    unsigned long n = 10;
-    unsigned long hwtimer_start, hwtimer_stop, hwtimer_diff;
-    unsigned long hwtimer_average = 0;
+    const unsigned long n = 10;
+    const struct timeval duration = { .tv_sec = 1, .tv_usec = 0 };
 
-    printf("Estimating HW timer frequency on CPU %ld for %lu iterations\n", cpu_num, n);
+    printf("Estimating HW timer frequency on CPU %ld for %lu iterations of %lu.%06lu seconds each\n",
+            cpu_num, n, duration.tv_sec, duration.tv_usec);
 
     cpu_set_t cpu_mask;
 
@@ -925,30 +925,7 @@ static unsigned long estimate_hwtimer_freq(long cpu_num) {
         exit(-1);
     }
 
-    for (unsigned long i = 0; i < n; i++) {
-
-        struct timeval ts_a, ts_b, ts_diff;
-
-        hwtimer_start = get_raw_counter();
-        gettimeofday(&ts_a, NULL);
-
-        do {
-            gettimeofday(&ts_b, NULL);
-            timersub(&ts_b, &ts_a, &ts_diff);
-        } while (ts_diff.tv_sec < 1);
-
-        hwtimer_stop = get_raw_counter();
-
-        hwtimer_diff = hwtimer_stop - hwtimer_start;
-
-        printf("hwtimer_diff = %lu\n", hwtimer_diff);
-
-        hwtimer_average += hwtimer_diff;
-    }
-
-    hwtimer_average /= (double) n;
-
-    // printf("hwtimer_average = %lu\n", hwtimer_average);
+    unsigned long hwtimer_average = estimate_hwclock_freq(n, 1, duration);
 
     return hwtimer_average;
 }
@@ -1016,4 +993,82 @@ static int get_next_available_cpu (cpu_set_t * p_avail_cpus, int num_cores, int
 }
 
 
+unsigned long estimate_hwclock_freq(size_t n, int verbose, struct timeval target_measurement_duration) {
+
+    unsigned long hwcounter_start, hwcounter_stop, hwcounter_diff;
+    unsigned long hwcounter_average = 0;
+
+    assert(n != 0); // can't handle only 1 sample
+
+    size_t high_i = 0, low_i = 0;
+
+    unsigned long hwcounter_freq_high = 0;
+    unsigned long hwcounter_freq_low = -1;
+
+    for (size_t i = 0; i < n + 2; i++) {
+
+        struct timeval ts_a, ts_b, ts_target, ts_diff;
+
+        do {
+            hwcounter_start = get_raw_counter();
+            gettimeofday(&ts_a, NULL);
+
+            timeradd(&ts_a, &target_measurement_duration, &ts_target);
+
+            do {
+                gettimeofday(&ts_b, NULL);
+                hwcounter_stop = get_raw_counter();
+            } while (timercmp(&ts_b, &ts_target, < ));
+
+
+            timersub(&ts_b, &ts_target, &ts_diff);
+
+            if (0)  // expect 0.000000
+                printf("ts_diff = %lu.%06lu\n", ts_diff.tv_sec, ts_diff.tv_usec);
+
+        } while (ts_diff.tv_sec > 0 || ts_diff.tv_usec > 100);
+
+        hwcounter_diff = hwcounter_stop - hwcounter_start;
+
+        timersub(&ts_b, &ts_a, &ts_diff);
+
+        unsigned long hwcounter_freq =
+                    hwcounter_diff / (ts_diff.tv_sec + ts_diff.tv_usec * 0.000001);
+
+        if (verbose) {
+            printf("sample %zu, hwcounter_diff = %lu, freq = %lu\n",
+                    i, hwcounter_diff, hwcounter_freq);
+        }
+
+        hwcounter_average += hwcounter_freq;
+
+        if (hwcounter_freq > hwcounter_freq_high) {
+            hwcounter_freq_high = hwcounter_freq;
+            high_i = i;
+        }
+
+        if (hwcounter_freq < hwcounter_freq_low) {
+            hwcounter_freq_low = hwcounter_freq;
+            low_i = i;
+        }
+
+    }
+
+    if (verbose) {
+        printf("dropped sample %zu, hwcounter_freq_low = %lu\n", low_i, hwcounter_freq_low);
+        printf("dropped sample %zu, hwcounter_freq_high = %lu\n", high_i, hwcounter_freq_high);
+    }
+
+    hwcounter_average -= hwcounter_freq_low;
+    hwcounter_average -= hwcounter_freq_high;
+
+    hwcounter_average /= (double) n;
+
+    // printf("hwcounter_average = %lu\n", hwcounter_average);
+
+    return hwcounter_average;
+}
+
+
+
 /* vim: set tabstop=4 shiftwidth=4 softtabstop=4 expandtab: */