diskutil Dump info related to disk utilization updates
job:x Dump info only related to job number x
mutex Dump info only related to mutex up/down ops
+ profile Dump info related to profile extensions
+ time Dump info related to internal time keeping
? or help Show available debug options.
You can specify as many as you want, eg --debug=file,mem will enable
__asm__("bsfl %1,%0" :"=r" (bitmask) :"r" (~bitmask));
return bitmask;
}
+
+static inline unsigned long long get_cpu_clock(void)
+{
+ unsigned long ret;
+
+ __asm__ __volatile__("rdtsc" : "=A" (ret));
+ return ret;
+}
+
#define ARCH_HAVE_FFZ
#define ARCH_HAVE_SSE
+#define ARCH_HAVE_CPU_CLOCK
#endif
__asm__("bsfl %1,%0" :"=r" (bitmask) :"r" (~bitmask));
return bitmask;
}
+
+static inline unsigned long long get_cpu_clock(void)
+{
+ unsigned int lo, hi;
+
+ __asm__ __volatile__("rdtsc" : "=a" (lo), "=d" (hi));
+ return ((unsigned long long) hi << 32ULL) | lo;
+}
+
#define ARCH_HAVE_FFZ
#define ARCH_HAVE_SSE
+#define ARCH_HAVE_CPU_CLOCK
#endif
FD_JOB,
FD_MUTEX,
FD_PROFILE,
+ FD_TIME,
FD_DEBUG_MAX,
};
#include "helpers.h"
#include "options.h"
#include "profile.h"
+#include "time.h"
#ifdef FIO_HAVE_GUASI
#include <guasi.h>
unsigned int gtod_reduce;
unsigned int gtod_cpu;
unsigned int gtod_offload;
+ enum fio_cs clocksource;
char *read_iolog_file;
char *write_iolog_file;
extern char *job_section;
extern int fio_gtod_offload;
extern int fio_gtod_cpu;
+extern enum fio_cs fio_clock_source;
extern struct thread_data *threads;
return 0;
}
-/*
- * Time functions
- */
-extern unsigned long long utime_since(struct timeval *, struct timeval *);
-extern unsigned long long utime_since_now(struct timeval *);
-extern unsigned long mtime_since(struct timeval *, struct timeval *);
-extern unsigned long mtime_since_now(struct timeval *);
-extern unsigned long time_since_now(struct timeval *);
-extern unsigned long mtime_since_genesis(void);
-extern void usec_spin(unsigned int);
-extern void usec_sleep(struct thread_data *, unsigned long);
-extern void fill_start_time(struct timeval *);
-extern void fio_gettime(struct timeval *, void *);
-extern void fio_gtod_init(void);
-extern void fio_gtod_update(void);
-extern void set_genesis_time(void);
-extern int ramp_time_over(struct thread_data *);
-extern int in_ramp_time(struct thread_data *);
-
/*
* Init/option functions
*/
*/
#include <unistd.h>
+#include <math.h>
#include <sys/time.h>
#include "fio.h"
#include "hash.h"
-static int clock_gettime_works = 0;
+static unsigned long cycles_per_usec;
static struct timeval last_tv;
+static unsigned long last_cycles;
static int last_tv_valid;
static struct timeval *fio_tv;
int fio_gtod_offload = 0;
int fio_gtod_cpu = -1;
+enum fio_cs fio_clock_source = CS_GTOD;
+
#ifdef FIO_DEBUG_TIME
#define HASH_BITS 8
if (fio_tv) {
memcpy(tp, fio_tv, sizeof(*tp));
return;
- } else if (!clock_gettime_works) {
-gtod:
+ }
+
+ switch (fio_clock_source) {
+ case CS_GTOD:
gettimeofday(tp, NULL);
- } else {
+ break;
+ case CS_CGETTIME: {
struct timespec ts;
if (clock_gettime(CLOCK_REALTIME, &ts) < 0) {
- clock_gettime_works = 0;
- goto gtod;
+ log_err("fio: clock_gettime fails\n");
+ assert(0);
}
tp->tv_sec = ts.tv_sec;
tp->tv_usec = ts.tv_nsec / 1000;
+ break;
+ }
+#ifdef ARCH_HAVE_CPU_CLOCK
+ case CS_CPUCLOCK: {
+ unsigned long long usecs, t;
+
+ t = get_cpu_clock();
+ if (t < last_cycles) {
+ dprint(FD_TIME, "CPU clock going back in time\n");
+ t = last_cycles;
+ }
+
+ usecs = t / cycles_per_usec;
+ tp->tv_sec = usecs / 1000000;
+ tp->tv_usec = usecs % 1000000;
+ last_cycles = t;
+ break;
+ }
+#endif
+ default:
+ log_err("fio: invalid clock source %d\n", fio_clock_source);
+ break;
}
/*
memcpy(&last_tv, tp, sizeof(*tp));
}
+static unsigned long get_cycles_per_usec(void)
+{
+ struct timeval s, e;
+ unsigned long long c_s, c_e;
+
+ gettimeofday(&s, NULL);
+ c_s = get_cpu_clock();
+ do {
+ unsigned long long elapsed;
+
+ gettimeofday(&e, NULL);
+ elapsed = utime_since(&s, &e);
+ if (elapsed >= 10) {
+ c_e = get_cpu_clock();
+ break;
+ }
+ } while (1);
+
+ return c_e - c_s;
+}
+
+void fio_clock_init(void)
+{
+ double delta, mean, S;
+ unsigned long avg, cycles[10];
+ int i, samples;
+
+ last_tv_valid = 0;
+
+ cycles[0] = get_cycles_per_usec();
+ S = delta = mean = 0.0;
+ for (i = 0; i < 10; i++) {
+ cycles[i] = get_cycles_per_usec();
+ delta = cycles[i] - mean;
+ if (delta) {
+ mean += delta / (i + 1.0);
+ S += delta * (cycles[i] - mean);
+ }
+ }
+
+ S = sqrt(S / (10 - 1.0));
+
+ samples = avg = 0;
+ for (i = 0; i < 10; i++) {
+ double this = cycles[i];
+
+ if ((max(this, mean) - min(this, mean)) > S)
+ continue;
+ samples++;
+ avg += this;
+ }
+
+ S /= 10.0;
+ mean /= 10.0;
+
+ for (i = 0; i < 10; i++)
+ dprint(FD_TIME, "cycles[%d]=%lu\n", i, cycles[i] / 10);
+
+ avg /= (samples * 10);
+ dprint(FD_TIME, "avg: %lu\n", avg);
+ dprint(FD_TIME, "mean=%f, S=%f\n", mean, S);
+
+ cycles_per_usec = avg;
+}
+
void fio_gtod_init(void)
{
fio_tv = smalloc(sizeof(struct timeval));
{ .name = "job", .shift = FD_JOB },
{ .name = "mutex", .shift = FD_MUTEX },
{ .name = "profile", .shift = FD_PROFILE },
+ { .name = "time", .shift = FD_TIME },
{ .name = NULL, },
};
return 0;
}
+static int fio_clock_source_cb(void *data, const char *str)
+{
+ struct thread_data *td = data;
+
+ fio_clock_source = td->o.clocksource;
+ fio_time_init();
+ return 0;
+}
+
static int str_lockmem_cb(void fio_unused *data, unsigned long *val)
{
mlock_size = *val;
.off1 = td_var_offset(ramp_time),
.help = "Ramp up time before measuring performance",
},
+ {
+ .name = "clocksource",
+ .type = FIO_OPT_STR,
+ .cb = fio_clock_source_cb,
+ .off1 = td_var_offset(clocksource),
+ .help = "What type of timing source to use",
+ .def = "gettimeofday",
+ .posval = {
+ { .ival = "gettimeofday",
+ .oval = CS_GTOD,
+ .help = "Use gettimeofday(2) for timing",
+ },
+ { .ival = "clock_gettime",
+ .oval = CS_CGETTIME,
+ .help = "Use clock_gettime(2) for timing",
+ },
+#ifdef ARCH_HAVE_CPU_CLOCK
+ { .ival = "cpu",
+ .oval = CS_CPUCLOCK,
+ .help = "Use CPU private clock",
+ },
+#endif
+ },
+ },
{
.name = "mem",
.alias = "iomem",
static struct timeval genesis;
static unsigned long ns_granularity;
+unsigned long long genesis_cycles;
unsigned long long utime_since(struct timeval *s, struct timeval *e)
{
return 0;
}
-static void fio_init time_init(void)
+void fio_init fio_time_init(void)
{
int i;
+ fio_clock_init();
+
/*
* Check the granularity of the nanosleep function
*/
void set_genesis_time(void)
{
fio_gettime(&genesis, NULL);
+ genesis_cycles = get_cpu_clock();
}
void fill_start_time(struct timeval *t)
--- /dev/null
+#ifndef FIO_TIME_H
+#define FIO_TIME_H
+
+/*
+ * Clock sources
+ */
+enum fio_cs {
+ CS_GTOD = 1,
+ CS_CGETTIME,
+ CS_CPUCLOCK,
+};
+
+extern unsigned long long utime_since(struct timeval *, struct timeval *);
+extern unsigned long long utime_since_now(struct timeval *);
+extern unsigned long mtime_since(struct timeval *, struct timeval *);
+extern unsigned long mtime_since_now(struct timeval *);
+extern unsigned long time_since_now(struct timeval *);
+extern unsigned long mtime_since_genesis(void);
+extern void usec_spin(unsigned int);
+extern void usec_sleep(struct thread_data *, unsigned long);
+extern void fill_start_time(struct timeval *);
+extern void fio_gettime(struct timeval *, void *);
+extern void fio_gtod_init(void);
+extern void fio_clock_init(void);
+extern void fio_gtod_update(void);
+extern void set_genesis_time(void);
+extern int ramp_time_over(struct thread_data *);
+extern int in_ramp_time(struct thread_data *);
+extern unsigned long long genesis_cycles;
+extern void fio_time_init(void);
+
+#endif