X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=gettime.c;h=c0f26382721d0be7e01d413b8a33bcca6ac04921;hp=cc9dcb7bea7ab28215e09304b3c32688be8d8f25;hb=d22e2fc8834280e5ee789e2a1e2b23ebbbeabb7e;hpb=ba458c2f1d12c54fb4cfd4918a4e4d72d84b55a4 diff --git a/gettime.c b/gettime.c index cc9dcb7b..c0f26382 100644 --- a/gettime.c +++ b/gettime.c @@ -2,37 +2,42 @@ * Clock functions */ -#include #include -#include -#include #include "fio.h" -#include "smalloc.h" - -#include "hash.h" #include "os/os.h" -#ifdef ARCH_HAVE_CPU_CLOCK -static unsigned long cycles_per_usec; -static unsigned long inv_cycles_per_usec; +#if defined(ARCH_HAVE_CPU_CLOCK) +#ifndef ARCH_CPU_CLOCK_CYCLES_PER_USEC +static unsigned long long cycles_per_msec; +static unsigned long long cycles_start; +static unsigned long long clock_mult; +static unsigned long long max_cycles_mask; +static unsigned long long nsecs_for_max_cycles; +static unsigned int clock_shift; +static unsigned int max_cycles_shift; +#define MAX_CLOCK_SEC 60*60 +#endif +#ifdef ARCH_CPU_CLOCK_WRAPS +static unsigned int cycles_wrap; +#endif #endif -int tsc_reliable = 0; +bool tsc_reliable = false; struct tv_valid { - struct timeval last_tv; - uint64_t last_cycles; - int last_tv_valid; + int warned; }; +#ifdef ARCH_HAVE_CPU_CLOCK #ifdef CONFIG_TLS_THREAD -static struct tv_valid __thread static_tv_valid; +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; -enum fio_cs fio_clock_source_inited = CS_INVAL; +static enum fio_cs fio_clock_source_inited = CS_INVAL; #ifdef FIO_DEBUG_TIME @@ -64,7 +69,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 +85,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) @@ -128,7 +130,9 @@ static void fio_init gtod_init(void) #ifdef CONFIG_CLOCK_GETTIME static int fill_clock_gettime(struct timespec *ts) { -#ifdef CONFIG_CLOCK_MONOTONIC +#if defined(CONFIG_CLOCK_MONOTONIC_RAW) + return clock_gettime(CLOCK_MONOTONIC_RAW, ts); +#elif defined(CONFIG_CLOCK_MONOTONIC) return clock_gettime(CLOCK_MONOTONIC, ts); #else return clock_gettime(CLOCK_REALTIME, ts); @@ -136,50 +140,58 @@ static int fill_clock_gettime(struct timespec *ts) } #endif -static void *__fio_gettime(struct timeval *tp) +static void __fio_gettime(struct timespec *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: - gettimeofday(tp, NULL); + case CS_GTOD: { + struct timeval tv; + gettimeofday(&tv, NULL); + + tp->tv_sec = tv.tv_sec; + tp->tv_nsec = tv.tv_usec * 1000; break; + } #endif #ifdef CONFIG_CLOCK_GETTIME case CS_CGETTIME: { - struct timespec ts; - - if (fill_clock_gettime(&ts) < 0) { + if (fill_clock_gettime(tp) < 0) { log_err("fio: clock_gettime fails\n"); assert(0); } - - tp->tv_sec = ts.tv_sec; - tp->tv_usec = ts.tv_nsec / 1000; break; } #endif #ifdef ARCH_HAVE_CPU_CLOCK case CS_CPUCLOCK: { - uint64_t usecs, t; + uint64_t nsecs, t, multiples; + 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 (tv && t < tv->last_cycles) { - dprint(FD_TIME, "CPU clock going back in time\n"); - t = tv->last_cycles; - } else if (tv) - tv->last_cycles = t; - - usecs = (t * inv_cycles_per_usec) / 16777216UL; - tp->tv_sec = usecs / 1000000; - tp->tv_usec = usecs % 1000000; +#ifdef ARCH_CPU_CLOCK_WRAPS + 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; + } +#endif +#ifdef ARCH_CPU_CLOCK_CYCLES_PER_USEC + nsecs = t / ARCH_CPU_CLOCK_CYCLES_PER_USEC * 1000; +#else + t -= cycles_start; + multiples = t >> max_cycles_shift; + nsecs = multiples * nsecs_for_max_cycles; + nsecs += ((t & max_cycles_mask) * clock_mult) >> clock_shift; +#endif + tp->tv_sec = nsecs / 1000000000ULL; + tp->tv_nsec = nsecs % 1000000000ULL; break; } #endif @@ -187,54 +199,33 @@ static void *__fio_gettime(struct timeval *tp) log_err("fio: invalid clock source %d\n", fio_clock_source); break; } - - return tv; } #ifdef FIO_DEBUG_TIME -void fio_gettime(struct timeval *tp, void *caller) +void fio_gettime(struct timespec *tp, void *caller) #else -void fio_gettime(struct timeval *tp, void fio_unused *caller) +void fio_gettime(struct timespec *tp, void fio_unused *caller) #endif { - struct tv_valid *tv; - #ifdef FIO_DEBUG_TIME if (!caller) caller = __builtin_return_address(0); gtod_log_caller(caller); #endif - if (fio_tv) { - memcpy(tp, fio_tv, sizeof(*tp)); + if (fio_unlikely(fio_gettime_offload(tp))) return; - } - - tv = __fio_gettime(tp); - /* - * If Linux is using the tsc clock on non-synced processors, - * sometimes time can appear to drift backwards. Fix that up. - */ - if (tv) { - if (tv->last_tv_valid) { - if (tp->tv_sec < tv->last_tv.tv_sec) - tp->tv_sec = tv->last_tv.tv_sec; - else if (tv->last_tv.tv_sec == tp->tv_sec && - tp->tv_usec < tv->last_tv.tv_usec) - tp->tv_usec = tv->last_tv.tv_usec; - } - tv->last_tv_valid = 1; - memcpy(&tv->last_tv, tp, sizeof(*tp)); - } + __fio_gettime(tp); } -#ifdef ARCH_HAVE_CPU_CLOCK -static unsigned long get_cycles_per_usec(void) +#if defined(ARCH_HAVE_CPU_CLOCK) && !defined(ARCH_CPU_CLOCK_CYCLES_PER_USEC) +static unsigned long get_cycles_per_msec(void) { - struct timeval s, e; + struct timespec s, e; uint64_t c_s, c_e; enum fio_cs old_cs = fio_clock_source; + uint64_t elapsed; #ifdef CONFIG_CLOCK_GETTIME fio_clock_source = CS_CGETTIME; @@ -245,8 +236,6 @@ static unsigned long get_cycles_per_usec(void) c_s = get_cpu_clock(); do { - uint64_t elapsed; - __fio_gettime(&e); elapsed = utime_since(&s, &e); @@ -257,21 +246,22 @@ static unsigned long get_cycles_per_usec(void) } while (1); fio_clock_source = old_cs; - return (c_e - c_s + 127) >> 7; + return (c_e - c_s) * 1000 / elapsed; } #define NR_TIME_ITERS 50 -static void calibrate_cpu_clock(void) +static int calibrate_cpu_clock(void) { double delta, mean, S; - uint64_t avg, cycles[NR_TIME_ITERS]; - int i, samples; + uint64_t minc, maxc, avg, cycles[NR_TIME_ITERS]; + int i, samples, sft = 0; + unsigned long long tmp, max_ticks, max_mult; - cycles[0] = get_cycles_per_usec(); + cycles[0] = get_cycles_per_msec(); S = delta = mean = 0.0; for (i = 0; i < NR_TIME_ITERS; i++) { - cycles[i] = get_cycles_per_usec(); + cycles[i] = get_cycles_per_msec(); delta = cycles[i] - mean; if (delta) { mean += delta / (i + 1.0); @@ -279,12 +269,23 @@ static void calibrate_cpu_clock(void) } } + /* + * 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)); - samples = avg = 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++; @@ -292,34 +293,95 @@ static void calibrate_cpu_clock(void) } S /= (double) NR_TIME_ITERS; - mean /= 10.0; for (i = 0; i < NR_TIME_ITERS; i++) - dprint(FD_TIME, "cycles[%d]=%lu\n", i, cycles[i] / 10); + dprint(FD_TIME, "cycles[%d]=%llu\n", i, (unsigned long long) cycles[i]); avg /= samples; - avg = (avg + 5) / 10; - dprint(FD_TIME, "avg: %lu\n", avg); - dprint(FD_TIME, "mean=%f, S=%f\n", mean, S); + cycles_per_msec = avg; + 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); + + max_ticks = MAX_CLOCK_SEC * cycles_per_msec * 1000ULL; + max_mult = ULLONG_MAX / max_ticks; + dprint(FD_TIME, "\n\nmax_ticks=%llu, __builtin_clzll=%d, " + "max_mult=%llu\n", max_ticks, + __builtin_clzll(max_ticks), max_mult); + + /* + * Find the largest shift count that will produce + * a multiplier that does not exceed max_mult + */ + tmp = max_mult * cycles_per_msec / 1000000; + while (tmp > 1) { + tmp >>= 1; + sft++; + dprint(FD_TIME, "tmp=%llu, sft=%u\n", tmp, sft); + } + + clock_shift = sft; + clock_mult = (1ULL << sft) * 1000000 / cycles_per_msec; + dprint(FD_TIME, "clock_shift=%u, clock_mult=%llu\n", clock_shift, + clock_mult); + + /* + * Find the greatest power of 2 clock ticks that is less than the + * ticks in MAX_CLOCK_SEC_2STAGE + */ + max_cycles_shift = max_cycles_mask = 0; + tmp = MAX_CLOCK_SEC * 1000ULL * cycles_per_msec; + dprint(FD_TIME, "tmp=%llu, max_cycles_shift=%u\n", tmp, + max_cycles_shift); + while (tmp > 1) { + tmp >>= 1; + max_cycles_shift++; + dprint(FD_TIME, "tmp=%llu, max_cycles_shift=%u\n", tmp, max_cycles_shift); + } + /* + * if use use (1ULL << max_cycles_shift) * 1000 / cycles_per_msec + * here we will have a discontinuity every + * (1ULL << max_cycles_shift) cycles + */ + nsecs_for_max_cycles = ((1ULL << max_cycles_shift) * clock_mult) + >> clock_shift; - cycles_per_usec = avg; - inv_cycles_per_usec = 16777216UL / cycles_per_usec; - dprint(FD_TIME, "inv_cycles_per_usec=%lu\n", inv_cycles_per_usec); + /* Use a bitmask to calculate ticks % (1ULL << max_cycles_shift) */ + for (tmp = 0; tmp < max_cycles_shift; tmp++) + max_cycles_mask |= 1ULL << tmp; + + dprint(FD_TIME, "max_cycles_shift=%u, 2^max_cycles_shift=%llu, " + "nsecs_for_max_cycles=%llu, " + "max_cycles_mask=%016llx\n", + max_cycles_shift, (1ULL << max_cycles_shift), + nsecs_for_max_cycles, max_cycles_mask); + + cycles_start = get_cpu_clock(); + dprint(FD_TIME, "cycles_start=%llu\n", cycles_start); + return 0; } #else -static void calibrate_cpu_clock(void) +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) +void fio_local_clock_init(void) { struct tv_valid *t; - t = calloc(sizeof(*t), 1); - if (pthread_setspecific(tv_tls_key, 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) @@ -327,7 +389,7 @@ static void kill_tv_tls_key(void *data) free(data); } #else -void fio_local_clock_init(int is_thread) +void fio_local_clock_init(void) { } #endif @@ -343,7 +405,9 @@ void fio_clock_init(void) #endif fio_clock_source_inited = fio_clock_source; - calibrate_cpu_clock(); + + if (calibrate_cpu_clock()) + tsc_reliable = false; /* * If the arch sets tsc_reliable != 0, then it must be good enough @@ -351,19 +415,47 @@ 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"); + dprint(FD_TIME, "gettime: clocksource=%d\n", (int) fio_clock_source); } -uint64_t utime_since(struct timeval *s, struct timeval *e) +uint64_t ntime_since(const struct timespec *s, const struct timespec *e) { - long sec, usec; - uint64_t ret; + int64_t sec, nsec; + + sec = e->tv_sec - s->tv_sec; + nsec = e->tv_nsec - s->tv_nsec; + if (sec > 0 && nsec < 0) { + sec--; + nsec += 1000000000LL; + } + + /* + * time warp bug on some kernels? + */ + if (sec < 0 || (sec == 0 && nsec < 0)) + return 0; + + return nsec + (sec * 1000000000LL); +} + +uint64_t ntime_since_now(const struct timespec *s) +{ + struct timespec now; + + fio_gettime(&now, NULL); + return ntime_since(s, &now); +} + +uint64_t utime_since(const struct timespec *s, const struct timespec *e) +{ + int64_t sec, usec; sec = e->tv_sec - s->tv_sec; - usec = e->tv_usec - s->tv_usec; + usec = (e->tv_nsec - s->tv_nsec) / 1000; if (sec > 0 && usec < 0) { sec--; usec += 1000000; @@ -375,25 +467,29 @@ uint64_t utime_since(struct timeval *s, struct timeval *e) if (sec < 0 || (sec == 0 && usec < 0)) return 0; - ret = sec * 1000000ULL + usec; - - return ret; + return usec + (sec * 1000000); } -uint64_t utime_since_now(struct timeval *s) +uint64_t utime_since_now(const struct timespec *s) { - struct timeval t; + struct timespec t; +#ifdef FIO_DEBUG_TIME + void *p = __builtin_return_address(0); + fio_gettime(&t, p); +#else fio_gettime(&t, NULL); +#endif + return utime_since(s, &t); } -uint64_t mtime_since(struct timeval *s, struct timeval *e) +uint64_t mtime_since_tv(const struct timeval *s, const struct timeval *e) { - long sec, usec, ret; + int64_t sec, usec; sec = e->tv_sec - s->tv_sec; - usec = e->tv_usec - s->tv_usec; + usec = (e->tv_usec - s->tv_usec); if (sec > 0 && usec < 0) { sec--; usec += 1000000; @@ -402,50 +498,75 @@ uint64_t mtime_since(struct timeval *s, struct timeval *e) if (sec < 0 || (sec == 0 && usec < 0)) return 0; - sec *= 1000UL; - usec /= 1000UL; - ret = sec + usec; - - return ret; + sec *= 1000; + usec /= 1000; + return sec + usec; } -uint64_t mtime_since_now(struct timeval *s) +uint64_t mtime_since_now(const struct timespec *s) { - struct timeval t; + struct timespec t; +#ifdef FIO_DEBUG_TIME void *p = __builtin_return_address(0); fio_gettime(&t, p); +#else + fio_gettime(&t, NULL); +#endif + return mtime_since(s, &t); } -uint64_t time_since_now(struct timeval *s) +uint64_t mtime_since(const struct timespec *s, const struct timespec *e) +{ + int64_t sec, usec; + + sec = e->tv_sec - s->tv_sec; + usec = (e->tv_nsec - s->tv_nsec) / 1000; + if (sec > 0 && usec < 0) { + sec--; + usec += 1000000; + } + + if (sec < 0 || (sec == 0 && usec < 0)) + return 0; + + sec *= 1000; + usec /= 1000; + return sec + usec; +} + +uint64_t time_since_now(const struct timespec *s) { return mtime_since_now(s) / 1000; } #if defined(FIO_HAVE_CPU_AFFINITY) && defined(ARCH_HAVE_CPU_CLOCK) && \ - defined(CONFIG_SFAA) + defined(CONFIG_SYNC_SYNC) && defined(CONFIG_CMP_SWAP) -#define CLOCK_ENTRIES 100000 +#define CLOCK_ENTRIES_DEBUG 100000 +#define CLOCK_ENTRIES_TEST 1000 struct clock_entry { - uint64_t seq; + uint32_t seq; + uint32_t cpu; uint64_t tsc; - uint64_t cpu; }; struct clock_thread { pthread_t thread; int cpu; - pthread_mutex_t lock; - pthread_mutex_t started; - uint64_t *seq; + int debug; + struct fio_sem lock; + unsigned long nr_entries; + uint32_t *seq; struct clock_entry *entries; }; -static inline uint64_t atomic64_inc_return(uint64_t *seq) +static inline uint32_t atomic32_compare_and_swap(uint32_t *ptr, uint32_t old, + uint32_t new) { - return 1 + __sync_fetch_and_add(seq, 1); + return __sync_val_compare_and_swap(ptr, old, new); } static void *clock_thread_fn(void *data) @@ -453,35 +574,70 @@ static void *clock_thread_fn(void *data) struct clock_thread *t = data; struct clock_entry *c; os_cpu_mask_t cpu_mask; + unsigned long long first; int i; - memset(&cpu_mask, 0, sizeof(cpu_mask)); + if (fio_cpuset_init(&cpu_mask)) { + int __err = errno; + + log_err("clock cpuset init failed: %s\n", strerror(__err)); + goto err_out; + } + fio_cpu_set(&cpu_mask, t->cpu); if (fio_setaffinity(gettid(), cpu_mask) == -1) { - log_err("clock setaffinity failed\n"); - return (void *) 1; + int __err = errno; + + log_err("clock setaffinity failed: %s\n", strerror(__err)); + goto err; } - pthread_mutex_lock(&t->lock); - pthread_mutex_unlock(&t->started); + fio_sem_down(&t->lock); + first = get_cpu_clock(); c = &t->entries[0]; - for (i = 0; i < CLOCK_ENTRIES; i++, c++) { - uint64_t seq, tsc; + for (i = 0; i < t->nr_entries; i++, c++) { + uint32_t seq; + uint64_t tsc; c->cpu = t->cpu; do { - seq = atomic64_inc_return(t->seq); + seq = *t->seq; + if (seq == UINT_MAX) + break; + __sync_synchronize(); tsc = get_cpu_clock(); - } while (seq != *t->seq); + } while (seq != atomic32_compare_and_swap(t->seq, seq, seq + 1)); + + if (seq == UINT_MAX) + break; c->seq = seq; c->tsc = tsc; } - log_info("cs: cpu%3d: %lu clocks seen\n", t->cpu, t->entries[CLOCK_ENTRIES - 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, first %llu\n", t->cpu, + clocks, first); + } + + /* + * The most common platform clock breakage is returning zero + * indefinitely. Check for that and return failure. + */ + if (i > 1 && !t->entries[i - 1].tsc && !t->entries[0].tsc) + goto err; + + fio_cpuset_exit(&cpu_mask); return NULL; +err: + fio_cpuset_exit(&cpu_mask); +err_out: + return (void *) 1; } static int clock_cmp(const void *p1, const void *p2) @@ -495,70 +651,86 @@ 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 *threads; + struct clock_thread *cthreads; unsigned int nr_cpus = cpus_online(); struct clock_entry *entries; - unsigned long tentries, failed; - uint64_t seq = 0; - int i; + 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; +#endif + nr_entries = CLOCK_ENTRIES_DEBUG; + } else + nr_entries = CLOCK_ENTRIES_TEST; - fio_debug |= 1U << FD_TIME; calibrate_cpu_clock(); - fio_debug &= ~(1U << FD_TIME); - threads = malloc(nr_cpus * sizeof(struct clock_thread)); - tentries = CLOCK_ENTRIES * nr_cpus; + if (debug) { +#ifdef FIO_INC_DEBUG + fio_debug &= ~(1U << FD_TIME); +#endif + } + + cthreads = malloc(nr_cpus * sizeof(struct clock_thread)); + 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 = &threads[i]; + struct clock_thread *t = &cthreads[i]; t->cpu = i; + t->debug = debug; t->seq = &seq; - t->entries = &entries[i * CLOCK_ENTRIES]; - pthread_mutex_init(&t->lock, NULL); - pthread_mutex_init(&t->started, NULL); - pthread_mutex_lock(&t->lock); - pthread_create(&t->thread, NULL, clock_thread_fn, t); + t->nr_entries = nr_entries; + t->entries = &entries[i * nr_entries]; + __fio_sem_init(&t->lock, FIO_SEM_LOCKED); + if (pthread_create(&t->thread, NULL, clock_thread_fn, t)) { + failed++; + nr_cpus = i; + break; + } } for (i = 0; i < nr_cpus; i++) { - struct clock_thread *t = &threads[i]; + struct clock_thread *t = &cthreads[i]; - pthread_mutex_lock(&t->started); + fio_sem_up(&t->lock); } for (i = 0; i < nr_cpus; i++) { - struct clock_thread *t = &threads[i]; - - pthread_mutex_unlock(&t->lock); - } - - for (failed = i = 0; i < nr_cpus; i++) { - struct clock_thread *t = &threads[i]; + struct clock_thread *t = &cthreads[i]; void *ret; pthread_join(t->thread, &ret); if (ret) failed++; + __fio_sem_remove(&t->lock); } - free(threads); + free(cthreads); if (failed) { - log_err("Clocksource test: %u threads failed\n", failed); + if (debug) + log_err("Clocksource test: %lu threads failed\n", failed); goto err; } qsort(entries, tentries, sizeof(struct clock_entry), clock_cmp); + /* silence silly gcc */ + prev = NULL; for (failed = i = 0; i < tentries; i++) { - struct clock_entry *prev, *this = &entries[i]; + this = &entries[i]; if (!i) { prev = this; @@ -568,20 +740,27 @@ int fio_monotonic_clocktest(void) if (prev->tsc > this->tsc) { uint64_t diff = prev->tsc - this->tsc; - log_info("cs: CPU clock mismatch (diff=%lu):\n", diff); - log_info("\t CPU%3lu: TSC=%lu, SEQ=%lu\n", prev->cpu, prev->tsc, prev->seq); - log_info("\t CPU%3lu: TSC=%lu, SEQ=%lu\n", this->cpu, this->tsc, this->seq); + 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); + log_info("\t CPU%3u: TSC=%llu, SEQ=%u\n", this->cpu, (unsigned long long) this->tsc, this->seq); failed++; } 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; @@ -589,10 +768,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