Always measure TSC frequency on x86

The TSC frequency is not easy to obtain.  The methods that this patch
replace do not always work.  However, the TSC frequency is used for
blackhole and test durations, so an accurate number is important.

This patch improves the TSC frequency measurement routine to support
sub-second samples.  On every run of the program, the frequency is
measured for 3 samples of 0.1 seconds, dropping the highest and lowest.

Change-Id: Ifc62210b8da586fbaebf0a3f22d72bc2eebda92b
Signed-off-by: jty2 <46021128+jty2@users.noreply.github.com>

Author: jty2

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"
 
@@ -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: */