X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=gettime.c;h=5ceb809de3ae9247a5cc7d3e2557b062541fc73f;hp=87abca0ff883f59c4850f191ae8d744128552bee;hb=aad918e47d119eb2043311f1a2a45ce109c047d1;hpb=02dcf81c05b90bf50c062545a4b1158bca75950b diff --git a/gettime.c b/gettime.c index 87abca0f..5ceb809d 100644 --- a/gettime.c +++ b/gettime.c @@ -16,6 +16,8 @@ #if defined(ARCH_HAVE_CPU_CLOCK) && !defined(ARCH_CPU_CLOCK_CYCLES_PER_USEC) static unsigned long cycles_per_usec; static unsigned long inv_cycles_per_usec; +static uint64_t max_cycles_for_mult; +static unsigned long long cycles_start, cycles_wrap; #endif int tsc_reliable = 0; @@ -24,11 +26,13 @@ struct tv_valid { int last_tv_valid; int warned; }; +#ifdef ARCH_HAVE_CPU_CLOCK #ifdef CONFIG_TLS_THREAD static __thread struct tv_valid static_tv_valid; #else static pthread_key_t tv_tls_key; #endif +#endif enum fio_cs fio_clock_source = FIO_PREFERRED_CLOCK_SOURCE; int fio_clock_source_set = 0; @@ -64,7 +68,7 @@ static struct gtod_log *find_hash(void *caller) return NULL; } -static struct gtod_log *find_log(void *caller) +static void inc_caller(void *caller) { struct gtod_log *log = find_hash(caller); @@ -80,16 +84,13 @@ static struct gtod_log *find_log(void *caller) flist_add_tail(&log->list, &hash[h]); } - return log; + log->calls++; } static void gtod_log_caller(void *caller) { - if (gtod_inited) { - struct gtod_log *log = find_log(caller); - - log->calls++; - } + if (gtod_inited) + inc_caller(caller); } static void fio_exit fio_dump_gtod(void) @@ -138,14 +139,6 @@ static int fill_clock_gettime(struct timespec *ts) static void __fio_gettime(struct timeval *tp) { - struct tv_valid *tv; - -#ifdef CONFIG_TLS_THREAD - tv = &static_tv_valid; -#else - tv = pthread_getspecific(tv_tls_key); -#endif - switch (fio_clock_source) { #ifdef CONFIG_GETTIMEOFDAY case CS_GTOD: @@ -169,20 +162,32 @@ static void __fio_gettime(struct timeval *tp) #ifdef ARCH_HAVE_CPU_CLOCK case CS_CPUCLOCK: { uint64_t usecs, t; + struct tv_valid *tv; + +#ifdef CONFIG_TLS_THREAD + tv = &static_tv_valid; +#else + tv = pthread_getspecific(tv_tls_key); +#endif t = get_cpu_clock(); - if (t < tv->last_cycles && tv->last_tv_valid && - !tv->warned) { - log_err("fio: CPU clock going back in time\n"); + if (t < cycles_start && !cycles_wrap) + cycles_wrap = 1; + else if (cycles_wrap && t >= cycles_start && !tv->warned) { + log_err("fio: double CPU clock wrap\n"); tv->warned = 1; } + t -= cycles_start; tv->last_cycles = t; tv->last_tv_valid = 1; #ifdef ARCH_CPU_CLOCK_CYCLES_PER_USEC usecs = t / ARCH_CPU_CLOCK_CYCLES_PER_USEC; #else - usecs = (t * inv_cycles_per_usec) / 16777216UL; + if (t < max_cycles_for_mult) + usecs = (t * inv_cycles_per_usec) / 16777216UL; + else + usecs = t / cycles_per_usec; #endif tp->tv_sec = usecs / 1000000; tp->tv_usec = usecs % 1000000; @@ -207,10 +212,8 @@ void fio_gettime(struct timeval *tp, void fio_unused *caller) gtod_log_caller(caller); #endif - if (fio_unlikely(fio_tv)) { - memcpy(tp, fio_tv, sizeof(*tp)); + if (fio_unlikely(fio_gettime_offload(tp))) return; - } __fio_gettime(tp); } @@ -298,7 +301,10 @@ static int calibrate_cpu_clock(void) 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); + cycles_start = get_cpu_clock(); + dprint(FD_TIME, "cycles_start=%llu\n", cycles_start); return 0; } #else @@ -355,7 +361,7 @@ void fio_clock_init(void) * runs at a constant rate and is synced across CPU cores. */ if (tsc_reliable) { - if (!fio_clock_source_set) + 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"); @@ -430,7 +436,8 @@ uint64_t time_since_now(const struct timeval *s) #if defined(FIO_HAVE_CPU_AFFINITY) && defined(ARCH_HAVE_CPU_CLOCK) && \ defined(CONFIG_SFAA) -#define CLOCK_ENTRIES 100000 +#define CLOCK_ENTRIES_DEBUG 100000 +#define CLOCK_ENTRIES_TEST 10000 struct clock_entry { uint32_t seq; @@ -441,8 +448,10 @@ struct clock_entry { struct clock_thread { pthread_t thread; int cpu; + int debug; pthread_mutex_t lock; pthread_mutex_t started; + unsigned long nr_entries; uint32_t *seq; struct clock_entry *entries; }; @@ -473,7 +482,7 @@ static void *clock_thread_fn(void *data) last_seq = 0; c = &t->entries[0]; - for (i = 0; i < CLOCK_ENTRIES; i++, c++) { + for (i = 0; i < t->nr_entries; i++, c++) { uint32_t seq; uint64_t tsc; @@ -489,8 +498,12 @@ static void *clock_thread_fn(void *data) c->tsc = tsc; } - log_info("cs: cpu%3d: %llu clocks seen\n", t->cpu, - (unsigned long long) t->entries[i - 1].tsc - t->entries[0].tsc); + if (t->debug) { + unsigned long long clocks; + + clocks = t->entries[i - 1].tsc - t->entries[0].tsc; + log_info("cs: cpu%3d: %llu clocks seen\n", t->cpu, clocks); + } /* * The most common platform clock breakage is returning zero @@ -513,38 +526,49 @@ static int clock_cmp(const void *p1, const void *p2) return c1->seq - c2->seq; } -int fio_monotonic_clocktest(void) +int fio_monotonic_clocktest(int debug) { struct clock_thread *cthreads; unsigned int nr_cpus = cpus_online(); struct clock_entry *entries; - unsigned long tentries, failed = 0; + unsigned long nr_entries, tentries, failed = 0; struct clock_entry *prev, *this; uint32_t seq = 0; unsigned int i; - log_info("cs: reliable_tsc: %s\n", tsc_reliable ? "yes" : "no"); + if (debug) { + log_info("cs: reliable_tsc: %s\n", tsc_reliable ? "yes" : "no"); #ifdef FIO_INC_DEBUG - fio_debug |= 1U << FD_TIME; + fio_debug |= 1U << FD_TIME; #endif + nr_entries = CLOCK_ENTRIES_DEBUG; + } else + nr_entries = CLOCK_ENTRIES_TEST; + calibrate_cpu_clock(); + + if (debug) { #ifdef FIO_INC_DEBUG - fio_debug &= ~(1U << FD_TIME); + fio_debug &= ~(1U << FD_TIME); #endif + } cthreads = malloc(nr_cpus * sizeof(struct clock_thread)); - tentries = CLOCK_ENTRIES * nr_cpus; + tentries = nr_entries * nr_cpus; entries = malloc(tentries * sizeof(struct clock_entry)); - log_info("cs: Testing %u CPUs\n", nr_cpus); + if (debug) + log_info("cs: Testing %u CPUs\n", nr_cpus); for (i = 0; i < nr_cpus; i++) { struct clock_thread *t = &cthreads[i]; t->cpu = i; + t->debug = debug; t->seq = &seq; - t->entries = &entries[i * CLOCK_ENTRIES]; + t->nr_entries = nr_entries; + t->entries = &entries[i * nr_entries]; pthread_mutex_init(&t->lock, NULL); pthread_mutex_init(&t->started, NULL); pthread_mutex_lock(&t->lock); @@ -578,7 +602,8 @@ int fio_monotonic_clocktest(void) free(cthreads); if (failed) { - log_err("Clocksource test: %lu threads failed\n", failed); + if (debug) + log_err("Clocksource test: %lu threads failed\n", failed); goto err; } @@ -595,6 +620,11 @@ int fio_monotonic_clocktest(void) if (prev->tsc > this->tsc) { uint64_t diff = prev->tsc - this->tsc; + if (!debug) { + failed++; + break; + } + log_info("cs: CPU clock mismatch (diff=%llu):\n", (unsigned long long) diff); log_info("\t CPU%3u: TSC=%llu, SEQ=%u\n", prev->cpu, (unsigned long long) prev->tsc, prev->seq); @@ -605,11 +635,12 @@ int fio_monotonic_clocktest(void) prev = this; } - if (failed) - log_info("cs: Failed: %lu\n", failed); - else - log_info("cs: Pass!\n"); - + if (debug) { + if (failed) + log_info("cs: Failed: %lu\n", failed); + else + log_info("cs: Pass!\n"); + } err: free(entries); return !!failed; @@ -617,10 +648,11 @@ err: #else /* defined(FIO_HAVE_CPU_AFFINITY) && defined(ARCH_HAVE_CPU_CLOCK) */ -int fio_monotonic_clocktest(void) +int fio_monotonic_clocktest(int debug) { - log_info("cs: current platform does not support CPU clocks\n"); - return 0; + if (debug) + log_info("cs: current platform does not support CPU clocks\n"); + return 1; } #endif