X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=time.c;h=1999969955b2828d6a9d38b425147b5ac3b5babf;hp=cb44c209ec984a1d74ecc0b48054f999c0eed007;hb=fc220349e45144360917db48010b503a9874930d;hpb=02bcaa8c31feb93c61b701d143a7eea3efd2124d diff --git a/time.c b/time.c index cb44c209..19999699 100644 --- a/time.c +++ b/time.c @@ -3,138 +3,180 @@ #include "fio.h" -static struct timeval genesis; +static struct timespec genesis; +static unsigned long ns_granularity; -unsigned long utime_since(struct timeval *s, struct timeval *e) +void timespec_add_msec(struct timespec *ts, unsigned int msec) { - double sec, usec; + uint64_t adj_nsec = 1000000ULL * msec; - sec = e->tv_sec - s->tv_sec; - usec = e->tv_usec - s->tv_usec; - if (sec > 0 && usec < 0) { - sec--; - usec += 1000000; - } - - sec *= (double) 1000000; + ts->tv_nsec += adj_nsec; + if (adj_nsec >= 1000000000) { + uint64_t adj_sec = adj_nsec / 1000000000; - return sec + usec; + ts->tv_nsec -= adj_sec * 1000000000; + ts->tv_sec += adj_sec; + } + if (ts->tv_nsec >= 1000000000){ + ts->tv_nsec -= 1000000000; + ts->tv_sec++; + } } -static unsigned long utime_since_now(struct timeval *s) +/* + * busy looping version for the last few usec + */ +uint64_t usec_spin(unsigned int usec) { - struct timeval t; + struct timespec start; + uint64_t t; + + fio_gettime(&start, NULL); + while ((t = utime_since_now(&start)) < usec) + nop; - fio_gettime(&t, NULL); - return utime_since(s, &t); + return t; } -unsigned long mtime_since(struct timeval *s, struct timeval *e) +uint64_t usec_sleep(struct thread_data *td, unsigned long usec) { - double sec, usec; + struct timespec req; + struct timespec tv; + uint64_t t = 0; - sec = e->tv_sec - s->tv_sec; - usec = e->tv_usec - s->tv_usec; - if (sec > 0 && usec < 0) { - sec--; - usec += 1000000; - } + do { + unsigned long ts = usec; - sec *= (double) 1000; - usec /= (double) 1000; + if (usec < ns_granularity) { + t += usec_spin(usec); + break; + } - return sec + usec; -} + ts = usec - ns_granularity; -unsigned long mtime_since_now(struct timeval *s) -{ - struct timeval t; - void *p = __builtin_return_address(0); + if (ts >= 1000000) { + req.tv_sec = ts / 1000000; + ts -= 1000000 * req.tv_sec; + } else + req.tv_sec = 0; + + req.tv_nsec = ts * 1000; + fio_gettime(&tv, NULL); + + if (nanosleep(&req, NULL) < 0) + break; + + ts = utime_since_now(&tv); + t += ts; + if (ts >= usec) + break; - fio_gettime(&t, p); - return mtime_since(s, &t); + usec -= ts; + } while (!td->terminate); + + return t; } -unsigned long time_since_now(struct timeval *s) +uint64_t time_since_genesis(void) { - return mtime_since_now(s) / 1000; + return time_since_now(&genesis); } -/* - * busy looping version for the last few usec - */ -void __usec_sleep(unsigned int usec) +uint64_t mtime_since_genesis(void) { - struct timeval start; - - fio_gettime(&start, NULL); - while (utime_since_now(&start) < usec) - nop; + return mtime_since_now(&genesis); } -void usec_sleep(struct thread_data *td, unsigned long usec) +uint64_t utime_since_genesis(void) { - struct timespec req, rem; + return utime_since_now(&genesis); +} - req.tv_sec = usec / 1000000; - req.tv_nsec = usec * 1000 - req.tv_sec * 1000000; +bool in_ramp_time(struct thread_data *td) +{ + return td->o.ramp_time && !td->ramp_time_over; +} - do { - if (usec < 5000) { - __usec_sleep(usec); - break; - } +static bool parent_update_ramp(struct thread_data *td) +{ + struct thread_data *parent = td->parent; - rem.tv_sec = rem.tv_nsec = 0; - if (nanosleep(&req, &rem) < 0) - break; + if (!parent || parent->ramp_time_over) + return false; - if ((rem.tv_sec + rem.tv_nsec) == 0) - break; + reset_all_stats(parent); + parent->ramp_time_over = true; + td_set_runstate(parent, TD_RAMP); + return true; +} - req.tv_nsec = rem.tv_nsec; - req.tv_sec = rem.tv_sec; +bool ramp_time_over(struct thread_data *td) +{ + if (!td->o.ramp_time || td->ramp_time_over) + return true; + + if (utime_since_now(&td->epoch) >= td->o.ramp_time) { + td->ramp_time_over = true; + reset_all_stats(td); + reset_io_stats(td); + td_set_runstate(td, TD_RAMP); + + /* + * If we have a parent, the parent isn't doing IO. Hence + * the parent never enters do_io(), which will switch us + * from RAMP -> RUNNING. Do this manually here. + */ + if (parent_update_ramp(td)) + td_set_runstate(td, TD_RUNNING); + + return true; + } - usec = rem.tv_sec * 1000000 + rem.tv_nsec / 1000; - } while (!td->terminate); + return false; } -void rate_throttle(struct thread_data *td, unsigned long time_spent, - unsigned int bytes, int ddir) +void fio_time_init(void) { - unsigned long usec_cycle; + int i; - if (!td->rate) - return; + fio_clock_init(); - usec_cycle = td->rate_usec_cycle * (bytes / td->min_bs[ddir]); + /* + * Check the granularity of the nanosleep function + */ + for (i = 0; i < 10; i++) { + struct timespec tv, ts; + unsigned long elapsed; - if (time_spent < usec_cycle) { - unsigned long s = usec_cycle - time_spent; + fio_gettime(&tv, NULL); + ts.tv_sec = 0; + ts.tv_nsec = 1000; - td->rate_pending_usleep += s; - if (td->rate_pending_usleep >= 100000) { - usec_sleep(td, td->rate_pending_usleep); - td->rate_pending_usleep = 0; - } - } else { - long overtime = time_spent - usec_cycle; + nanosleep(&ts, NULL); + elapsed = utime_since_now(&tv); - td->rate_pending_usleep -= overtime; + if (elapsed > ns_granularity) + ns_granularity = elapsed; } } -unsigned long mtime_since_genesis(void) +void set_genesis_time(void) { - return mtime_since_now(&genesis); + fio_gettime(&genesis, NULL); } -static void fio_init time_init(void) +void set_epoch_time(struct thread_data *td, int log_unix_epoch) { - fio_gettime(&genesis, NULL); + fio_gettime(&td->epoch, NULL); + if (log_unix_epoch) { + struct timeval tv; + gettimeofday(&tv, NULL); + td->unix_epoch = (unsigned long long)(tv.tv_sec) * 1000 + + (unsigned long long)(tv.tv_usec) / 1000; + } } -void fill_start_time(struct timeval *t) +void fill_start_time(struct timespec *t) { memcpy(t, &genesis, sizeof(genesis)); }