+
+#if defined(FIO_HAVE_CPU_AFFINITY) && defined(ARCH_HAVE_CPU_CLOCK) && \
+ defined(CONFIG_SFAA)
+
+#define CLOCK_ENTRIES 100000
+
+struct clock_entry {
+ uint32_t seq;
+ uint32_t cpu;
+ uint64_t tsc;
+};
+
+struct clock_thread {
+ pthread_t thread;
+ int cpu;
+ pthread_mutex_t lock;
+ pthread_mutex_t started;
+ uint32_t *seq;
+ struct clock_entry *entries;
+};
+
+static inline uint32_t atomic32_inc_return(uint32_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;
+ uint32_t last_seq;
+ 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_lock(&t->lock);
+ pthread_mutex_unlock(&t->started);
+
+ last_seq = 0;
+ c = &t->entries[0];
+ for (i = 0; i < CLOCK_ENTRIES; i++, c++) {
+ uint32_t seq;
+ uint64_t tsc;
+
+ c->cpu = t->cpu;
+ do {
+ seq = atomic32_inc_return(t->seq);
+ if (seq < last_seq)
+ break;
+ tsc = get_cpu_clock();
+ } while (seq != *t->seq);
+
+ c->seq = seq;
+ 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);
+
+ /*
+ * The most common platform clock breakage is returning zero
+ * indefinitely. Check for that and return failure.
+ */
+ if (!t->entries[i - 1].tsc && !t->entries[0].tsc)
+ return (void *) 1;
+
+ return NULL;
+}
+
+static int clock_cmp(const void *p1, const void *p2)
+{
+ const struct clock_entry *c1 = p1;
+ const struct clock_entry *c2 = p2;
+
+ if (c1->seq == c2->seq)
+ log_err("cs: bug in atomic sequence!\n");
+
+ 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;
+ struct clock_entry *prev, *this;
+ uint32_t seq = 0;
+ unsigned int i;
+
+ log_info("cs: reliable_tsc: %s\n", tsc_reliable ? "yes" : "no");
+
+ 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;
+ 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: %lu threads failed\n", failed);
+ goto err;
+ }
+
+ qsort(entries, tentries, sizeof(struct clock_entry), clock_cmp);
+
+ for (failed = i = 0; i < tentries; i++) {
+ 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=%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");
+
+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