+ fio_clock_source = old_cs;
+ return (c_e - c_s) / elapsed;
+}
+
+#define NR_TIME_ITERS 50
+
+static int calibrate_cpu_clock(void)
+{
+ double delta, mean, S;
+ uint64_t minc, maxc, avg, cycles[NR_TIME_ITERS];
+ int i, samples;
+
+ cycles[0] = get_cycles_per_usec();
+ S = delta = mean = 0.0;
+ for (i = 0; i < NR_TIME_ITERS; i++) {
+ cycles[i] = get_cycles_per_usec();
+ delta = cycles[i] - mean;
+ if (delta) {
+ mean += delta / (i + 1.0);
+ S += delta * (cycles[i] - mean);
+ }
+ }
+
+ /*
+ * The most common platform clock breakage is returning zero
+ * indefinitely. Check for that and return failure.
+ */
+ if (!cycles[0] && !cycles[NR_TIME_ITERS - 1])
+ return 1;
+
+ S = sqrt(S / (NR_TIME_ITERS - 1.0));
+
+ minc = -1ULL;
+ maxc = samples = avg = 0;
+ for (i = 0; i < NR_TIME_ITERS; i++) {
+ double this = cycles[i];
+
+ minc = min(cycles[i], minc);
+ maxc = max(cycles[i], maxc);
+
+ if ((fmax(this, mean) - fmin(this, mean)) > S)
+ continue;
+ samples++;
+ avg += this;
+ }
+
+ S /= (double) NR_TIME_ITERS;
+
+ for (i = 0; i < NR_TIME_ITERS; i++)
+ dprint(FD_TIME, "cycles[%d]=%llu\n", i, (unsigned long long) cycles[i]);
+
+ avg /= samples;
+ dprint(FD_TIME, "avg: %llu\n", (unsigned long long) avg);
+ dprint(FD_TIME, "min=%llu, max=%llu, mean=%f, S=%f\n",
+ (unsigned long long) minc,
+ (unsigned long long) maxc, mean, S);
+
+ cycles_per_usec = avg;
+ inv_cycles_per_usec = 16777216UL / cycles_per_usec;
+ max_cycles_for_mult = ~0ULL / inv_cycles_per_usec;
+ dprint(FD_TIME, "inv_cycles_per_usec=%lu\n", inv_cycles_per_usec);
+#ifdef ARCH_CPU_CLOCK_WRAPS
+ cycles_start = get_cpu_clock();
+ dprint(FD_TIME, "cycles_start=%llu\n", cycles_start);
+#endif
+ return 0;
+}
+#else
+static int calibrate_cpu_clock(void)
+{
+#ifdef ARCH_CPU_CLOCK_CYCLES_PER_USEC
+ return 0;
+#else
+ return 1;
+#endif
+}
+#endif // ARCH_HAVE_CPU_CLOCK
+
+#ifndef CONFIG_TLS_THREAD
+void fio_local_clock_init(int is_thread)
+{
+ struct tv_valid *t;
+
+ t = calloc(1, sizeof(*t));
+ if (pthread_setspecific(tv_tls_key, t)) {
+ log_err("fio: can't set TLS key\n");
+ assert(0);
+ }
+}
+
+static void kill_tv_tls_key(void *data)
+{
+ free(data);
+}
+#else
+void fio_local_clock_init(int is_thread)
+{
+}
+#endif
+
+void fio_clock_init(void)
+{
+ if (fio_clock_source == fio_clock_source_inited)
+ return;
+
+#ifndef CONFIG_TLS_THREAD
+ if (pthread_key_create(&tv_tls_key, kill_tv_tls_key))
+ log_err("fio: can't create TLS key\n");
+#endif
+
+ fio_clock_source_inited = fio_clock_source;
+
+ if (calibrate_cpu_clock())
+ tsc_reliable = 0;
+
+ /*
+ * If the arch sets tsc_reliable != 0, then it must be good enough
+ * to use as THE clock source. For x86 CPUs, this means the TSC
+ * runs at a constant rate and is synced across CPU cores.
+ */
+ if (tsc_reliable) {
+ if (!fio_clock_source_set && !fio_monotonic_clocktest(0))
+ fio_clock_source = CS_CPUCLOCK;
+ } else if (fio_clock_source == CS_CPUCLOCK)
+ log_info("fio: clocksource=cpu may not be reliable\n");
+}
+
+uint64_t utime_since(const struct timeval *s, const struct timeval *e)
+{
+ long sec, usec;
+ uint64_t ret;
+
+ sec = e->tv_sec - s->tv_sec;
+ usec = e->tv_usec - s->tv_usec;
+ if (sec > 0 && usec < 0) {
+ sec--;
+ usec += 1000000;