+
+#if defined(FIO_HAVE_CPU_AFFINITY) && defined(ARCH_HAVE_CPU_CLOCK) && \
+ defined(CONFIG_SFAA)
+
+#define CLOCK_ENTRIES_DEBUG 100000
+#define CLOCK_ENTRIES_TEST 10000
+
+struct clock_entry {
+ uint32_t seq;
+ uint32_t cpu;
+ uint64_t tsc;
+};
+
+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;
+};
+
+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;
+ unsigned long long first;
+ int i;
+
+ 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) {
+ int __err = errno;
+
+ log_err("clock setaffinity failed: %s\n", strerror(__err));
+ goto err;
+ }
+
+ pthread_mutex_lock(&t->lock);
+ pthread_mutex_unlock(&t->started);
+
+ first = get_cpu_clock();
+ last_seq = 0;
+ c = &t->entries[0];
+ for (i = 0; i < t->nr_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;
+ }
+
+ 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 (!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)
+{
+ 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(int debug)
+{
+ struct clock_thread *cthreads;
+ unsigned int nr_cpus = cpus_online();
+ struct clock_entry *entries;
+ unsigned long nr_entries, tentries, failed = 0;
+ struct clock_entry *prev, *this;
+ uint32_t seq = 0;
+ unsigned int i;
+
+ 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;
+
+ calibrate_cpu_clock();
+
+ 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));
+
+ 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->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);
+ 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 = &cthreads[i];
+
+ pthread_mutex_lock(&t->started);
+ }
+
+ for (i = 0; i < nr_cpus; i++) {
+ struct clock_thread *t = &cthreads[i];
+
+ pthread_mutex_unlock(&t->lock);
+ }
+
+ for (i = 0; i < nr_cpus; i++) {
+ struct clock_thread *t = &cthreads[i];
+ void *ret;
+
+ pthread_join(t->thread, &ret);
+ if (ret)
+ failed++;
+ }
+ free(cthreads);
+
+ if (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++) {
+ this = &entries[i];
+
+ if (!i) {
+ prev = this;
+ continue;
+ }
+
+ 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);
+ log_info("\t CPU%3u: TSC=%llu, SEQ=%u\n", this->cpu, (unsigned long long) this->tsc, this->seq);
+ failed++;
+ }
+
+ prev = this;
+ }
+
+ if (debug) {
+ 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(int debug)
+{
+ if (debug)
+ log_info("cs: current platform does not support CPU clocks\n");
+ return 1;
+}
+
+#endif