gettime: add support for CLOCK_MONOTONIC_RAW
[fio.git] / gettime.c
CommitLineData
02bcaa8c 1/*
f5cc024a 2 * Clock functions
02bcaa8c 3 */
f5cc024a 4
02bcaa8c 5#include <unistd.h>
c223da83 6#include <math.h>
02bcaa8c 7#include <sys/time.h>
03e20d68 8#include <time.h>
02bcaa8c
JA
9
10#include "fio.h"
be4ecfdf 11#include "smalloc.h"
02bcaa8c
JA
12
13#include "hash.h"
7d11f871 14#include "os/os.h"
02bcaa8c 15
dac499a0
AV
16#if defined(ARCH_HAVE_CPU_CLOCK)
17#ifndef ARCH_CPU_CLOCK_CYCLES_PER_USEC
c223da83 18static unsigned long cycles_per_usec;
71339117 19static unsigned long inv_cycles_per_usec;
b3fa625b 20static uint64_t max_cycles_for_mult;
96170421
CE
21#endif
22#ifdef ARCH_CPU_CLOCK_WRAPS
73df3e07 23static unsigned long long cycles_start, cycles_wrap;
09a32402 24#endif
dac499a0 25#endif
4de98eb0 26int tsc_reliable = 0;
5d879392
JA
27
28struct tv_valid {
ba458c2f 29 uint64_t last_cycles;
02dcf81c
JA
30 int last_tv_valid;
31 int warned;
5d879392 32};
03be65c9 33#ifdef ARCH_HAVE_CPU_CLOCK
67bf9823 34#ifdef CONFIG_TLS_THREAD
b4ea84da 35static __thread struct tv_valid static_tv_valid;
67bf9823 36#else
5d879392 37static pthread_key_t tv_tls_key;
67bf9823 38#endif
03be65c9 39#endif
02bcaa8c 40
16de1bf9 41enum fio_cs fio_clock_source = FIO_PREFERRED_CLOCK_SOURCE;
fa80feae 42int fio_clock_source_set = 0;
10aa136b 43static enum fio_cs fio_clock_source_inited = CS_INVAL;
c223da83 44
02bcaa8c
JA
45#ifdef FIO_DEBUG_TIME
46
47#define HASH_BITS 8
48#define HASH_SIZE (1 << HASH_BITS)
49
01743ee1 50static struct flist_head hash[HASH_SIZE];
02bcaa8c
JA
51static int gtod_inited;
52
53struct gtod_log {
01743ee1 54 struct flist_head list;
02bcaa8c
JA
55 void *caller;
56 unsigned long calls;
57};
58
59static struct gtod_log *find_hash(void *caller)
60{
61 unsigned long h = hash_ptr(caller, HASH_BITS);
01743ee1 62 struct flist_head *entry;
02bcaa8c 63
01743ee1
JA
64 flist_for_each(entry, &hash[h]) {
65 struct gtod_log *log = flist_entry(entry, struct gtod_log,
66 list);
02bcaa8c
JA
67
68 if (log->caller == caller)
69 return log;
70 }
71
72 return NULL;
73}
74
d5e16441 75static void inc_caller(void *caller)
02bcaa8c
JA
76{
77 struct gtod_log *log = find_hash(caller);
78
79 if (!log) {
80 unsigned long h;
81
82 log = malloc(sizeof(*log));
01743ee1 83 INIT_FLIST_HEAD(&log->list);
02bcaa8c
JA
84 log->caller = caller;
85 log->calls = 0;
86
87 h = hash_ptr(caller, HASH_BITS);
01743ee1 88 flist_add_tail(&log->list, &hash[h]);
02bcaa8c
JA
89 }
90
d5e16441 91 log->calls++;
02bcaa8c
JA
92}
93
94static void gtod_log_caller(void *caller)
95{
d5e16441
JA
96 if (gtod_inited)
97 inc_caller(caller);
02bcaa8c
JA
98}
99
100static void fio_exit fio_dump_gtod(void)
101{
102 unsigned long total_calls = 0;
103 int i;
104
105 for (i = 0; i < HASH_SIZE; i++) {
01743ee1 106 struct flist_head *entry;
02bcaa8c
JA
107 struct gtod_log *log;
108
01743ee1
JA
109 flist_for_each(entry, &hash[i]) {
110 log = flist_entry(entry, struct gtod_log, list);
02bcaa8c 111
5ec10eaa
JA
112 printf("function %p, calls %lu\n", log->caller,
113 log->calls);
02bcaa8c
JA
114 total_calls += log->calls;
115 }
116 }
117
118 printf("Total %lu gettimeofday\n", total_calls);
119}
120
121static void fio_init gtod_init(void)
122{
123 int i;
124
125 for (i = 0; i < HASH_SIZE; i++)
01743ee1 126 INIT_FLIST_HEAD(&hash[i]);
02bcaa8c
JA
127
128 gtod_inited = 1;
129}
130
131#endif /* FIO_DEBUG_TIME */
132
67bf9823 133#ifdef CONFIG_CLOCK_GETTIME
9ff1c070
JA
134static int fill_clock_gettime(struct timespec *ts)
135{
c544f604
SN
136#if defined(CONFIG_CLOCK_MONOTONIC_RAW)
137 return clock_gettime(CLOCK_MONOTONIC_RAW, ts);
138#elif defined(CONFIG_CLOCK_MONOTONIC)
9ff1c070
JA
139 return clock_gettime(CLOCK_MONOTONIC, ts);
140#else
141 return clock_gettime(CLOCK_REALTIME, ts);
142#endif
143}
1e97cce9 144#endif
67bf9823 145
9eb271b9 146static void __fio_gettime(struct timeval *tp)
02bcaa8c 147{
c223da83 148 switch (fio_clock_source) {
67bf9823 149#ifdef CONFIG_GETTIMEOFDAY
c223da83 150 case CS_GTOD:
02bcaa8c 151 gettimeofday(tp, NULL);
c223da83 152 break;
67bf9823
JA
153#endif
154#ifdef CONFIG_CLOCK_GETTIME
c223da83 155 case CS_CGETTIME: {
02bcaa8c
JA
156 struct timespec ts;
157
9ff1c070 158 if (fill_clock_gettime(&ts) < 0) {
c223da83
JA
159 log_err("fio: clock_gettime fails\n");
160 assert(0);
02bcaa8c
JA
161 }
162
163 tp->tv_sec = ts.tv_sec;
164 tp->tv_usec = ts.tv_nsec / 1000;
c223da83
JA
165 break;
166 }
67bf9823 167#endif
c223da83
JA
168#ifdef ARCH_HAVE_CPU_CLOCK
169 case CS_CPUCLOCK: {
ba458c2f 170 uint64_t usecs, t;
03be65c9
JA
171 struct tv_valid *tv;
172
173#ifdef CONFIG_TLS_THREAD
174 tv = &static_tv_valid;
175#else
176 tv = pthread_getspecific(tv_tls_key);
177#endif
c223da83
JA
178
179 t = get_cpu_clock();
96170421 180#ifdef ARCH_CPU_CLOCK_WRAPS
73df3e07
JA
181 if (t < cycles_start && !cycles_wrap)
182 cycles_wrap = 1;
03be65c9
JA
183 else if (cycles_wrap && t >= cycles_start && !tv->warned) {
184 log_err("fio: double CPU clock wrap\n");
185 tv->warned = 1;
02dcf81c 186 }
c223da83 187
73df3e07 188 t -= cycles_start;
96170421 189#endif
9eb271b9
JA
190 tv->last_cycles = t;
191 tv->last_tv_valid = 1;
919e789d
CE
192#ifdef ARCH_CPU_CLOCK_CYCLES_PER_USEC
193 usecs = t / ARCH_CPU_CLOCK_CYCLES_PER_USEC;
194#else
b3fa625b
JA
195 if (t < max_cycles_for_mult)
196 usecs = (t * inv_cycles_per_usec) / 16777216UL;
197 else
198 usecs = t / cycles_per_usec;
919e789d 199#endif
c223da83
JA
200 tp->tv_sec = usecs / 1000000;
201 tp->tv_usec = usecs % 1000000;
c223da83
JA
202 break;
203 }
204#endif
205 default:
206 log_err("fio: invalid clock source %d\n", fio_clock_source);
207 break;
02bcaa8c 208 }
67bf9823
JA
209}
210
211#ifdef FIO_DEBUG_TIME
212void fio_gettime(struct timeval *tp, void *caller)
213#else
214void fio_gettime(struct timeval *tp, void fio_unused *caller)
215#endif
216{
67bf9823
JA
217#ifdef FIO_DEBUG_TIME
218 if (!caller)
219 caller = __builtin_return_address(0);
220
221 gtod_log_caller(caller);
222#endif
27325ed5 223 if (fio_unlikely(fio_gettime_offload(tp)))
67bf9823 224 return;
67bf9823 225
9eb271b9 226 __fio_gettime(tp);
02bcaa8c 227}
be4ecfdf 228
919e789d 229#if defined(ARCH_HAVE_CPU_CLOCK) && !defined(ARCH_CPU_CLOCK_CYCLES_PER_USEC)
c223da83
JA
230static unsigned long get_cycles_per_usec(void)
231{
232 struct timeval s, e;
ba458c2f 233 uint64_t c_s, c_e;
67bf9823 234 enum fio_cs old_cs = fio_clock_source;
c223da83 235
67bf9823
JA
236#ifdef CONFIG_CLOCK_GETTIME
237 fio_clock_source = CS_CGETTIME;
238#else
239 fio_clock_source = CS_GTOD;
240#endif
241 __fio_gettime(&s);
9ff1c070 242
c223da83
JA
243 c_s = get_cpu_clock();
244 do {
ba458c2f 245 uint64_t elapsed;
c223da83 246
67bf9823 247 __fio_gettime(&e);
9ff1c070 248
c223da83 249 elapsed = utime_since(&s, &e);
486332e5 250 if (elapsed >= 1280) {
c223da83
JA
251 c_e = get_cpu_clock();
252 break;
253 }
254 } while (1);
255
67bf9823 256 fio_clock_source = old_cs;
c011000d 257 return (c_e - c_s + 127) >> 7;
c223da83
JA
258}
259
fa80feae
JA
260#define NR_TIME_ITERS 50
261
e259879e 262static int calibrate_cpu_clock(void)
c223da83
JA
263{
264 double delta, mean, S;
e51a6629 265 uint64_t minc, maxc, avg, cycles[NR_TIME_ITERS];
c223da83
JA
266 int i, samples;
267
c223da83
JA
268 cycles[0] = get_cycles_per_usec();
269 S = delta = mean = 0.0;
fa80feae 270 for (i = 0; i < NR_TIME_ITERS; i++) {
c223da83
JA
271 cycles[i] = get_cycles_per_usec();
272 delta = cycles[i] - mean;
273 if (delta) {
274 mean += delta / (i + 1.0);
275 S += delta * (cycles[i] - mean);
276 }
277 }
278
e259879e
JA
279 /*
280 * The most common platform clock breakage is returning zero
281 * indefinitely. Check for that and return failure.
282 */
283 if (!cycles[0] && !cycles[NR_TIME_ITERS - 1])
284 return 1;
285
fa80feae 286 S = sqrt(S / (NR_TIME_ITERS - 1.0));
c223da83 287
e51a6629
JA
288 minc = -1ULL;
289 maxc = samples = avg = 0;
fa80feae 290 for (i = 0; i < NR_TIME_ITERS; i++) {
c223da83
JA
291 double this = cycles[i];
292
e51a6629
JA
293 minc = min(cycles[i], minc);
294 maxc = max(cycles[i], maxc);
295
03e20d68 296 if ((fmax(this, mean) - fmin(this, mean)) > S)
c223da83
JA
297 continue;
298 samples++;
299 avg += this;
300 }
301
fa80feae 302 S /= (double) NR_TIME_ITERS;
89db727d 303 mean /= 10.0;
c223da83 304
fa80feae 305 for (i = 0; i < NR_TIME_ITERS; i++)
4b91ee8f
JA
306 dprint(FD_TIME, "cycles[%d]=%llu\n", i,
307 (unsigned long long) cycles[i] / 10);
c223da83 308
d7abad3d 309 avg /= samples;
b0ff22d7 310 avg = (avg + 5) / 10;
e51a6629
JA
311 minc /= 10;
312 maxc /= 10;
4b91ee8f 313 dprint(FD_TIME, "avg: %llu\n", (unsigned long long) avg);
e51a6629
JA
314 dprint(FD_TIME, "min=%llu, max=%llu, mean=%f, S=%f\n",
315 (unsigned long long) minc,
316 (unsigned long long) maxc, mean, S);
c223da83
JA
317
318 cycles_per_usec = avg;
71339117 319 inv_cycles_per_usec = 16777216UL / cycles_per_usec;
b3fa625b 320 max_cycles_for_mult = ~0ULL / inv_cycles_per_usec;
71339117 321 dprint(FD_TIME, "inv_cycles_per_usec=%lu\n", inv_cycles_per_usec);
96170421 322#ifdef ARCH_CPU_CLOCK_WRAPS
73df3e07
JA
323 cycles_start = get_cpu_clock();
324 dprint(FD_TIME, "cycles_start=%llu\n", cycles_start);
96170421 325#endif
e259879e 326 return 0;
09a32402
JA
327}
328#else
e259879e 329static int calibrate_cpu_clock(void)
09a32402 330{
919e789d
CE
331#ifdef ARCH_CPU_CLOCK_CYCLES_PER_USEC
332 return 0;
333#else
e259879e 334 return 1;
09a32402 335#endif
919e789d
CE
336}
337#endif // ARCH_HAVE_CPU_CLOCK
09a32402 338
67bf9823 339#ifndef CONFIG_TLS_THREAD
5d879392
JA
340void fio_local_clock_init(int is_thread)
341{
342 struct tv_valid *t;
343
572cfb3f 344 t = calloc(1, sizeof(*t));
9eb271b9 345 if (pthread_setspecific(tv_tls_key, t)) {
5d879392 346 log_err("fio: can't set TLS key\n");
9eb271b9
JA
347 assert(0);
348 }
5d879392
JA
349}
350
351static void kill_tv_tls_key(void *data)
352{
353 free(data);
354}
67bf9823
JA
355#else
356void fio_local_clock_init(int is_thread)
357{
358}
359#endif
5d879392 360
09a32402
JA
361void fio_clock_init(void)
362{
01423eae
JA
363 if (fio_clock_source == fio_clock_source_inited)
364 return;
365
67bf9823 366#ifndef CONFIG_TLS_THREAD
5d879392
JA
367 if (pthread_key_create(&tv_tls_key, kill_tv_tls_key))
368 log_err("fio: can't create TLS key\n");
67bf9823 369#endif
5d879392 370
01423eae 371 fio_clock_source_inited = fio_clock_source;
e259879e
JA
372
373 if (calibrate_cpu_clock())
374 tsc_reliable = 0;
fa80feae
JA
375
376 /*
377 * If the arch sets tsc_reliable != 0, then it must be good enough
378 * to use as THE clock source. For x86 CPUs, this means the TSC
379 * runs at a constant rate and is synced across CPU cores.
380 */
381 if (tsc_reliable) {
aad918e4 382 if (!fio_clock_source_set && !fio_monotonic_clocktest(0))
fa80feae
JA
383 fio_clock_source = CS_CPUCLOCK;
384 } else if (fio_clock_source == CS_CPUCLOCK)
385 log_info("fio: clocksource=cpu may not be reliable\n");
c223da83
JA
386}
387
1f440ece 388uint64_t utime_since(const struct timeval *s, const struct timeval *e)
be4ecfdf 389{
39ab7da2 390 long sec, usec;
aa60bc58 391 uint64_t ret;
39ab7da2
JA
392
393 sec = e->tv_sec - s->tv_sec;
394 usec = e->tv_usec - s->tv_usec;
395 if (sec > 0 && usec < 0) {
396 sec--;
397 usec += 1000000;
398 }
399
400 /*
401 * time warp bug on some kernels?
402 */
403 if (sec < 0 || (sec == 0 && usec < 0))
404 return 0;
405
406 ret = sec * 1000000ULL + usec;
407
408 return ret;
be4ecfdf
JA
409}
410
1f440ece 411uint64_t utime_since_now(const struct timeval *s)
be4ecfdf 412{
39ab7da2
JA
413 struct timeval t;
414
415 fio_gettime(&t, NULL);
416 return utime_since(s, &t);
be4ecfdf 417}
783a3eb1 418
1f440ece 419uint64_t mtime_since(const struct timeval *s, const struct timeval *e)
783a3eb1 420{
39ab7da2 421 long sec, usec, ret;
783a3eb1 422
39ab7da2
JA
423 sec = e->tv_sec - s->tv_sec;
424 usec = e->tv_usec - s->tv_usec;
425 if (sec > 0 && usec < 0) {
426 sec--;
427 usec += 1000000;
783a3eb1
JA
428 }
429
39ab7da2
JA
430 if (sec < 0 || (sec == 0 && usec < 0))
431 return 0;
432
433 sec *= 1000UL;
434 usec /= 1000UL;
435 ret = sec + usec;
436
437 return ret;
783a3eb1
JA
438}
439
1f440ece 440uint64_t mtime_since_now(const struct timeval *s)
783a3eb1 441{
39ab7da2
JA
442 struct timeval t;
443 void *p = __builtin_return_address(0);
783a3eb1 444
39ab7da2
JA
445 fio_gettime(&t, p);
446 return mtime_since(s, &t);
447}
783a3eb1 448
1f440ece 449uint64_t time_since_now(const struct timeval *s)
39ab7da2
JA
450{
451 return mtime_since_now(s) / 1000;
783a3eb1 452}
7d11f871 453
67bf9823
JA
454#if defined(FIO_HAVE_CPU_AFFINITY) && defined(ARCH_HAVE_CPU_CLOCK) && \
455 defined(CONFIG_SFAA)
7d11f871 456
aad918e4
JA
457#define CLOCK_ENTRIES_DEBUG 100000
458#define CLOCK_ENTRIES_TEST 10000
7d11f871
JA
459
460struct clock_entry {
58002f9a
JA
461 uint32_t seq;
462 uint32_t cpu;
ba458c2f 463 uint64_t tsc;
7d11f871
JA
464};
465
466struct clock_thread {
467 pthread_t thread;
468 int cpu;
aad918e4 469 int debug;
7d11f871
JA
470 pthread_mutex_t lock;
471 pthread_mutex_t started;
aad918e4 472 unsigned long nr_entries;
58002f9a 473 uint32_t *seq;
7d11f871
JA
474 struct clock_entry *entries;
475};
476
58002f9a 477static inline uint32_t atomic32_inc_return(uint32_t *seq)
7d11f871
JA
478{
479 return 1 + __sync_fetch_and_add(seq, 1);
480}
481
482static void *clock_thread_fn(void *data)
483{
484 struct clock_thread *t = data;
485 struct clock_entry *c;
486 os_cpu_mask_t cpu_mask;
58002f9a 487 uint32_t last_seq;
7d11f871
JA
488 int i;
489
c763aea6 490 if (fio_cpuset_init(&cpu_mask)) {
37e20021 491 int __err = errno;
c763aea6
JA
492
493 log_err("clock cpuset init failed: %s\n", strerror(__err));
494 goto err_out;
495 }
496
7d11f871
JA
497 fio_cpu_set(&cpu_mask, t->cpu);
498
499 if (fio_setaffinity(gettid(), cpu_mask) == -1) {
e66d7f90
JA
500 int __err = errno;
501
502 log_err("clock setaffinity failed: %s\n", strerror(__err));
c763aea6 503 goto err;
7d11f871
JA
504 }
505
7d11f871 506 pthread_mutex_lock(&t->lock);
b9b3498e 507 pthread_mutex_unlock(&t->started);
7d11f871 508
58002f9a 509 last_seq = 0;
7d11f871 510 c = &t->entries[0];
aad918e4 511 for (i = 0; i < t->nr_entries; i++, c++) {
58002f9a
JA
512 uint32_t seq;
513 uint64_t tsc;
7d11f871
JA
514
515 c->cpu = t->cpu;
516 do {
58002f9a
JA
517 seq = atomic32_inc_return(t->seq);
518 if (seq < last_seq)
519 break;
7d11f871
JA
520 tsc = get_cpu_clock();
521 } while (seq != *t->seq);
522
523 c->seq = seq;
524 c->tsc = tsc;
525 }
526
aad918e4
JA
527 if (t->debug) {
528 unsigned long long clocks;
529
530 clocks = t->entries[i - 1].tsc - t->entries[0].tsc;
531 log_info("cs: cpu%3d: %llu clocks seen\n", t->cpu, clocks);
532 }
58002f9a 533
e259879e
JA
534 /*
535 * The most common platform clock breakage is returning zero
536 * indefinitely. Check for that and return failure.
537 */
58002f9a 538 if (!t->entries[i - 1].tsc && !t->entries[0].tsc)
c763aea6 539 goto err;
e259879e 540
d47d7cb3 541 fio_cpuset_exit(&cpu_mask);
7d11f871 542 return NULL;
c763aea6
JA
543err:
544 fio_cpuset_exit(&cpu_mask);
545err_out:
546 return (void *) 1;
7d11f871
JA
547}
548
549static int clock_cmp(const void *p1, const void *p2)
550{
551 const struct clock_entry *c1 = p1;
552 const struct clock_entry *c2 = p2;
553
b9b3498e
JA
554 if (c1->seq == c2->seq)
555 log_err("cs: bug in atomic sequence!\n");
556
7d11f871
JA
557 return c1->seq - c2->seq;
558}
559
aad918e4 560int fio_monotonic_clocktest(int debug)
7d11f871 561{
8a1db9a1 562 struct clock_thread *cthreads;
7d11f871
JA
563 unsigned int nr_cpus = cpus_online();
564 struct clock_entry *entries;
aad918e4 565 unsigned long nr_entries, tentries, failed = 0;
80da8a8f 566 struct clock_entry *prev, *this;
58002f9a 567 uint32_t seq = 0;
caa3eb1c 568 unsigned int i;
7d11f871 569
aad918e4
JA
570 if (debug) {
571 log_info("cs: reliable_tsc: %s\n", tsc_reliable ? "yes" : "no");
d5e3f5d8 572
b5b571a3 573#ifdef FIO_INC_DEBUG
aad918e4 574 fio_debug |= 1U << FD_TIME;
b5b571a3 575#endif
aad918e4
JA
576 nr_entries = CLOCK_ENTRIES_DEBUG;
577 } else
578 nr_entries = CLOCK_ENTRIES_TEST;
579
4f1d43c2 580 calibrate_cpu_clock();
aad918e4
JA
581
582 if (debug) {
b5b571a3 583#ifdef FIO_INC_DEBUG
aad918e4 584 fio_debug &= ~(1U << FD_TIME);
b5b571a3 585#endif
aad918e4 586 }
4f1d43c2 587
8a1db9a1 588 cthreads = malloc(nr_cpus * sizeof(struct clock_thread));
aad918e4 589 tentries = nr_entries * nr_cpus;
7d11f871
JA
590 entries = malloc(tentries * sizeof(struct clock_entry));
591
aad918e4
JA
592 if (debug)
593 log_info("cs: Testing %u CPUs\n", nr_cpus);
7d11f871
JA
594
595 for (i = 0; i < nr_cpus; i++) {
8a1db9a1 596 struct clock_thread *t = &cthreads[i];
7d11f871
JA
597
598 t->cpu = i;
aad918e4 599 t->debug = debug;
7d11f871 600 t->seq = &seq;
aad918e4
JA
601 t->nr_entries = nr_entries;
602 t->entries = &entries[i * nr_entries];
7d11f871
JA
603 pthread_mutex_init(&t->lock, NULL);
604 pthread_mutex_init(&t->started, NULL);
605 pthread_mutex_lock(&t->lock);
6b0110cd
JA
606 if (pthread_create(&t->thread, NULL, clock_thread_fn, t)) {
607 failed++;
608 nr_cpus = i;
609 break;
610 }
7d11f871
JA
611 }
612
613 for (i = 0; i < nr_cpus; i++) {
8a1db9a1 614 struct clock_thread *t = &cthreads[i];
7d11f871
JA
615
616 pthread_mutex_lock(&t->started);
617 }
618
619 for (i = 0; i < nr_cpus; i++) {
8a1db9a1 620 struct clock_thread *t = &cthreads[i];
7d11f871
JA
621
622 pthread_mutex_unlock(&t->lock);
623 }
624
814917be 625 for (i = 0; i < nr_cpus; i++) {
8a1db9a1 626 struct clock_thread *t = &cthreads[i];
7d11f871
JA
627 void *ret;
628
629 pthread_join(t->thread, &ret);
630 if (ret)
631 failed++;
632 }
8a1db9a1 633 free(cthreads);
7d11f871
JA
634
635 if (failed) {
aad918e4
JA
636 if (debug)
637 log_err("Clocksource test: %lu threads failed\n", failed);
7d11f871
JA
638 goto err;
639 }
640
641 qsort(entries, tentries, sizeof(struct clock_entry), clock_cmp);
642
643 for (failed = i = 0; i < tentries; i++) {
80da8a8f 644 this = &entries[i];
7d11f871
JA
645
646 if (!i) {
647 prev = this;
648 continue;
649 }
650
651 if (prev->tsc > this->tsc) {
652 uint64_t diff = prev->tsc - this->tsc;
653
aad918e4
JA
654 if (!debug) {
655 failed++;
656 break;
657 }
658
4e0a8fa2
JA
659 log_info("cs: CPU clock mismatch (diff=%llu):\n",
660 (unsigned long long) diff);
661 log_info("\t CPU%3u: TSC=%llu, SEQ=%u\n", prev->cpu, (unsigned long long) prev->tsc, prev->seq);
662 log_info("\t CPU%3u: TSC=%llu, SEQ=%u\n", this->cpu, (unsigned long long) this->tsc, this->seq);
7d11f871
JA
663 failed++;
664 }
665
666 prev = this;
667 }
668
aad918e4
JA
669 if (debug) {
670 if (failed)
671 log_info("cs: Failed: %lu\n", failed);
672 else
673 log_info("cs: Pass!\n");
674 }
7d11f871
JA
675err:
676 free(entries);
677 return !!failed;
678}
679
680#else /* defined(FIO_HAVE_CPU_AFFINITY) && defined(ARCH_HAVE_CPU_CLOCK) */
681
aad918e4 682int fio_monotonic_clocktest(int debug)
7d11f871 683{
aad918e4
JA
684 if (debug)
685 log_info("cs: current platform does not support CPU clocks\n");
686 return 1;
7d11f871
JA
687}
688
689#endif