From: Jens Axboe Date: Mon, 17 Dec 2012 11:03:29 +0000 (+0100) Subject: cpu clock: add independent test for monotonic/sane TSC X-Git-Tag: fio-2.0.12~8 X-Git-Url: https://git.kernel.dk/?p=fio.git;a=commitdiff_plain;h=7d11f87148b8ec0f5627c701c934c752bf774029 cpu clock: add independent test for monotonic/sane TSC Fire up all threads on the system, checking the clock 100,000 times on each. Then collect and compare results, to ensure we never have a clock that goes backwards. Signed-off-by: Jens Axboe --- diff --git a/gettime.c b/gettime.c index 9f23e3ff..bf35c716 100644 --- a/gettime.c +++ b/gettime.c @@ -11,6 +11,7 @@ #include "smalloc.h" #include "hash.h" +#include "os/os.h" #ifdef ARCH_HAVE_CPU_CLOCK static unsigned long cycles_per_usec; @@ -347,3 +348,167 @@ unsigned long time_since_now(struct timeval *s) { return mtime_since_now(s) / 1000; } + +#if defined(FIO_HAVE_CPU_AFFINITY) && defined(ARCH_HAVE_CPU_CLOCK) + +#define CLOCK_ENTRIES 100000 + +struct clock_entry { + unsigned long seq; + unsigned long tsc; + unsigned long cpu; +}; + +struct clock_thread { + pthread_t thread; + int cpu; + pthread_mutex_t lock; + pthread_mutex_t started; + uint64_t *seq; + struct clock_entry *entries; +}; + +static inline uint64_t atomic64_inc_return(uint64_t *seq) +{ + return 1 + __sync_fetch_and_add(seq, 1); +} + +static void *clock_thread_fn(void *data) +{ + struct clock_thread *t = data; + struct clock_entry *c; + os_cpu_mask_t cpu_mask; + int i; + + memset(&cpu_mask, 0, sizeof(cpu_mask)); + fio_cpu_set(&cpu_mask, t->cpu); + + if (fio_setaffinity(gettid(), cpu_mask) == -1) { + log_err("clock setaffinity failed\n"); + return (void *) 1; + } + + pthread_mutex_unlock(&t->started); + pthread_mutex_lock(&t->lock); + + c = &t->entries[0]; + for (i = 0; i < CLOCK_ENTRIES; i++, c++) { + uint64_t seq, tsc; + + c->cpu = t->cpu; + do { + seq = atomic64_inc_return(t->seq); + tsc = get_cpu_clock(); + } while (seq != *t->seq); + + 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); + return NULL; +} + +static int clock_cmp(const void *p1, const void *p2) +{ + const struct clock_entry *c1 = p1; + const struct clock_entry *c2 = p2; + + return c1->seq - c2->seq; +} + +int fio_monotonic_clocktest(void) +{ + struct clock_thread *threads; + unsigned int nr_cpus = cpus_online(); + struct clock_entry *entries; + unsigned long tentries, failed; + uint64_t seq = 0; + int i; + + threads = malloc(nr_cpus * sizeof(struct clock_thread)); + tentries = CLOCK_ENTRIES * nr_cpus; + entries = malloc(tentries * sizeof(struct clock_entry)); + + log_info("cs: Testing %u CPUs\n", nr_cpus); + + for (i = 0; i < nr_cpus; i++) { + struct clock_thread *t = &threads[i]; + + t->cpu = i; + 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); + } + + for (i = 0; i < nr_cpus; i++) { + struct clock_thread *t = &threads[i]; + + pthread_mutex_lock(&t->started); + } + + 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]; + void *ret; + + pthread_join(t->thread, &ret); + if (ret) + failed++; + } + free(threads); + + if (failed) { + log_err("Clocksource test: %u threads failed\n", failed); + goto err; + } + + qsort(entries, tentries, sizeof(struct clock_entry), clock_cmp); + + for (failed = i = 0; i < tentries; i++) { + struct clock_entry *prev, *this = &entries[i]; + + if (!i) { + prev = this; + continue; + } + + 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); + failed++; + } + + prev = this; + } + + if (failed) + log_info("cs: Failed: %lu\n", failed); + else + log_info("cs: Pass!\n"); + +err: + free(entries); + return !!failed; +} + +#else /* defined(FIO_HAVE_CPU_AFFINITY) && defined(ARCH_HAVE_CPU_CLOCK) */ + +int fio_monotonic_clocktest(void) +{ + log_info("cs: current platform does not support CPU clocks\n"); + return 0; +} + +#endif diff --git a/gettime.h b/gettime.h index 64651a1b..8ca37911 100644 --- a/gettime.h +++ b/gettime.h @@ -15,6 +15,7 @@ extern void fio_gettime(struct timeval *, void *); extern void fio_gtod_init(void); extern void fio_clock_init(void); extern int fio_start_gtod_thread(void); +extern int fio_monotonic_clocktest(void); extern struct timeval *fio_tv; diff --git a/init.c b/init.c index e90d7355..c894af3a 100644 --- a/init.c +++ b/init.c @@ -207,6 +207,11 @@ static struct option l_opts[FIO_NR_OPTIONS] = { .has_arg = required_argument, .val = 'C', }, + { + .name = (char *) "cpuclock-test", + .has_arg = no_argument, + .val = 'T', + }, { .name = NULL, }, @@ -1621,6 +1626,10 @@ int parse_cmd_line(int argc, char *argv[]) optind++; } break; + case 'T': + do_exit++; + exit_val = fio_monotonic_clocktest(); + break; default: do_exit++; exit_val = 1;