The following changes since commit 729071019ee23804d52bed47357e4324be6b06bf: Merge branch 'master' of https://github.com/chengli-rutgers/fio into master (2020-10-09 07:28:55 -0600) are available in the Git repository at: git://git.kernel.dk/fio.git master for you to fetch changes up to 60c52212520b905a1740d3c8815c34cc48471c5c: Merge branch 'master' of https://github.com/bvanassche/fio into master (2020-10-10 20:30:52 -0600) ---------------------------------------------------------------- Alexey Dobriyan (1): simplify MB/s, IOPS interactive printout code Bart Van Assche (9): configure: Remove the CLOCK_MONOTONIC_PRECISE probe gettime: Introduce fio_get_mono_time() gettime: Simplify get_cycles_per_msec() gettime: Introduce rel_time_since() helper_thread: Introduce a function for blocking Unix signals helper_thread: Introduce the wait_for_action() function Change the return value of two functions from 'void' into 'int' helper_thread: Rework the interval timer code helper_thread: Increase timer accuracy Jens Axboe (3): flow: avoid holes in struct fio_flow flow: use unsigned long for the counter Merge branch 'master' of https://github.com/bvanassche/fio into master configure | 61 ++++-------- engines/posixaio.c | 41 +------- eta.c | 70 +++++-------- fio_time.h | 2 + flow.c | 6 +- gettime.c | 76 ++++++++------ gettime.h | 1 + helper_thread.c | 285 ++++++++++++++++++++++++++++++++++++----------------- stat.c | 4 +- stat.h | 2 +- steadystate.c | 3 +- steadystate.h | 2 +- 12 files changed, 306 insertions(+), 247 deletions(-) --- Diff of recent changes: diff --git a/configure b/configure index 12b7cb58..39a9248d 100755 --- a/configure +++ b/configure @@ -1104,46 +1104,6 @@ EOF fi print_config "CLOCK_MONOTONIC" "$clock_monotonic" -########################################## -# CLOCK_MONOTONIC_RAW probe -if test "$clock_monotonic_raw" != "yes" ; then - clock_monotonic_raw="no" -fi -if test "$clock_gettime" = "yes" ; then - cat > $TMPC << EOF -#include <stdio.h> -#include <time.h> -int main(int argc, char **argv) -{ - return clock_gettime(CLOCK_MONOTONIC_RAW, NULL); -} -EOF - if compile_prog "" "$LIBS" "clock monotonic"; then - clock_monotonic_raw="yes" - fi -fi -print_config "CLOCK_MONOTONIC_RAW" "$clock_monotonic_raw" - -########################################## -# CLOCK_MONOTONIC_PRECISE probe -if test "$clock_monotonic_precise" != "yes" ; then - clock_monotonic_precise="no" -fi -if test "$clock_gettime" = "yes" ; then - cat > $TMPC << EOF -#include <stdio.h> -#include <time.h> -int main(int argc, char **argv) -{ - return clock_gettime(CLOCK_MONOTONIC_PRECISE, NULL); -} -EOF - if compile_prog "" "$LIBS" "clock monotonic precise"; then - clock_monotonic_precise="yes" - fi -fi -print_config "CLOCK_MONOTONIC_PRECISE" "$clock_monotonic_precise" - ########################################## # clockid_t probe if test "$clockid_t" != "yes" ; then @@ -2722,6 +2682,24 @@ else pdb=no fi print_config "Windows PDB generation" "$pdb" + +########################################## +# check for timerfd support +timerfd_create="no" +cat > $TMPC << EOF +#include <sys/time.h> +#include <sys/timerfd.h> + +int main(int argc, char **argv) +{ + return timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK); +} +EOF +if compile_prog "" "" "timerfd_create"; then + timerfd_create="yes" +fi +print_config "timerfd_create" "$timerfd_create" + ############################################################################# if test "$wordsize" = "64" ; then @@ -3023,6 +3001,9 @@ fi if test "$statx_syscall" = "yes"; then output_sym "CONFIG_HAVE_STATX_SYSCALL" fi +if test "$timerfd_create" = "yes"; then + output_sym "CONFIG_HAVE_TIMERFD_CREATE" +fi if test "$fallthrough" = "yes"; then CFLAGS="$CFLAGS -Wimplicit-fallthrough" fi diff --git a/engines/posixaio.c b/engines/posixaio.c index 82c6aa65..135d088c 100644 --- a/engines/posixaio.c +++ b/engines/posixaio.c @@ -17,47 +17,14 @@ struct posixaio_data { unsigned int queued; }; -static int fill_timespec(struct timespec *ts) +static unsigned long long ts_utime_since_now(const struct timespec *start) { -#ifdef CONFIG_CLOCK_GETTIME -#ifdef CONFIG_CLOCK_MONOTONIC - clockid_t clk = CLOCK_MONOTONIC; -#else - clockid_t clk = CLOCK_REALTIME; -#endif - if (!clock_gettime(clk, ts)) - return 0; - - perror("clock_gettime"); - return 1; -#else - struct timeval tv; - - gettimeofday(&tv, NULL); - ts->tv_sec = tv.tv_sec; - ts->tv_nsec = tv.tv_usec * 1000; - return 0; -#endif -} - -static unsigned long long ts_utime_since_now(struct timespec *t) -{ - long long sec, nsec; struct timespec now; - if (fill_timespec(&now)) + if (fio_get_mono_time(&now) < 0) return 0; - - sec = now.tv_sec - t->tv_sec; - nsec = now.tv_nsec - t->tv_nsec; - if (sec > 0 && nsec < 0) { - sec--; - nsec += 1000000000; - } - sec *= 1000000; - nsec /= 1000; - return sec + nsec; + return utime_since(start, &now); } static int fio_posixaio_cancel(struct thread_data fio_unused *td, @@ -102,7 +69,7 @@ static int fio_posixaio_getevents(struct thread_data *td, unsigned int min, unsigned int r; int i; - if (t && !fill_timespec(&start)) + if (t && fio_get_mono_time(&start) == 0) have_timeout = 1; else memset(&start, 0, sizeof(start)); diff --git a/eta.c b/eta.c index e8c72780..d1c9449f 100644 --- a/eta.c +++ b/eta.c @@ -534,56 +534,38 @@ bool calc_thread_status(struct jobs_eta *je, int force) static int gen_eta_str(struct jobs_eta *je, char *p, size_t left, char **rate_str, char **iops_str) { - bool has_r = je->rate[DDIR_READ] || je->iops[DDIR_READ]; - bool has_w = je->rate[DDIR_WRITE] || je->iops[DDIR_WRITE]; - bool has_t = je->rate[DDIR_TRIM] || je->iops[DDIR_TRIM]; + static const char c[DDIR_RWDIR_CNT] = {'r', 'w', 't'}; + bool has[DDIR_RWDIR_CNT]; + bool has_any = false; + const char *sep; int l = 0; - if (!has_r && !has_w && !has_t) + for_each_rw_ddir(ddir) { + has[ddir] = (je->rate[ddir] || je->iops[ddir]); + has_any |= has[ddir]; + } + if (!has_any) return 0; - if (has_r) { - l += snprintf(p + l, left - l, "[r=%s", rate_str[DDIR_READ]); - if (!has_w) - l += snprintf(p + l, left - l, "]"); - } - if (has_w) { - if (has_r) - l += snprintf(p + l, left - l, ","); - else - l += snprintf(p + l, left - l, "["); - l += snprintf(p + l, left - l, "w=%s", rate_str[DDIR_WRITE]); - if (!has_t) - l += snprintf(p + l, left - l, "]"); - } - if (has_t) { - if (has_r || has_w) - l += snprintf(p + l, left - l, ","); - else if (!has_r && !has_w) - l += snprintf(p + l, left - l, "["); - l += snprintf(p + l, left - l, "t=%s]", rate_str[DDIR_TRIM]); - } - if (has_r) { - l += snprintf(p + l, left - l, "[r=%s", iops_str[DDIR_READ]); - if (!has_w) - l += snprintf(p + l, left - l, " IOPS]"); - } - if (has_w) { - if (has_r) - l += snprintf(p + l, left - l, ","); - else - l += snprintf(p + l, left - l, "["); - l += snprintf(p + l, left - l, "w=%s", iops_str[DDIR_WRITE]); - if (!has_t) - l += snprintf(p + l, left - l, " IOPS]"); + l += snprintf(p + l, left - l, "["); + sep = ""; + for_each_rw_ddir(ddir) { + if (has[ddir]) { + l += snprintf(p + l, left - l, "%s%c=%s", + sep, c[ddir], rate_str[ddir]); + sep = ","; + } } - if (has_t) { - if (has_r || has_w) - l += snprintf(p + l, left - l, ","); - else if (!has_r && !has_w) - l += snprintf(p + l, left - l, "["); - l += snprintf(p + l, left - l, "t=%s IOPS]", iops_str[DDIR_TRIM]); + l += snprintf(p + l, left - l, "]["); + sep = ""; + for_each_rw_ddir(ddir) { + if (has[ddir]) { + l += snprintf(p + l, left - l, "%s%c=%s", + sep, c[ddir], iops_str[ddir]); + sep = ","; + } } + l += snprintf(p + l, left - l, " IOPS]"); return l; } diff --git a/fio_time.h b/fio_time.h index c00f8e78..b3bbd4c0 100644 --- a/fio_time.h +++ b/fio_time.h @@ -13,6 +13,8 @@ extern uint64_t ntime_since(const struct timespec *, const struct timespec *); extern uint64_t ntime_since_now(const struct timespec *); extern uint64_t utime_since(const struct timespec *, const struct timespec *); extern uint64_t utime_since_now(const struct timespec *); +extern int64_t rel_time_since(const struct timespec *, + const struct timespec *); extern uint64_t mtime_since(const struct timespec *, const struct timespec *); extern uint64_t mtime_since_now(const struct timespec *); extern uint64_t mtime_since_tv(const struct timeval *, const struct timeval *); diff --git a/flow.c b/flow.c index ee4d761d..ea6b0ec9 100644 --- a/flow.c +++ b/flow.c @@ -5,9 +5,9 @@ struct fio_flow { unsigned int refs; - struct flist_head list; unsigned int id; - unsigned long long flow_counter; + struct flist_head list; + unsigned long flow_counter; unsigned int total_weight; }; @@ -90,7 +90,7 @@ static struct fio_flow *flow_get(unsigned int id) return flow; } -static void flow_put(struct fio_flow *flow, unsigned long long flow_counter, +static void flow_put(struct fio_flow *flow, unsigned long flow_counter, unsigned int weight) { if (!flow_lock) diff --git a/gettime.c b/gettime.c index c3a4966b..f85da6e0 100644 --- a/gettime.c +++ b/gettime.c @@ -127,18 +127,33 @@ static void fio_init gtod_init(void) #endif /* FIO_DEBUG_TIME */ -#ifdef CONFIG_CLOCK_GETTIME -static int fill_clock_gettime(struct timespec *ts) +/* + * Queries the value of the monotonic clock if a monotonic clock is available + * or the wall clock time if no monotonic clock is available. Returns 0 if + * querying the clock succeeded or -1 if querying the clock failed. + */ +int fio_get_mono_time(struct timespec *ts) { -#if defined(CONFIG_CLOCK_MONOTONIC_RAW) - return clock_gettime(CLOCK_MONOTONIC_RAW, ts); -#elif defined(CONFIG_CLOCK_MONOTONIC) - return clock_gettime(CLOCK_MONOTONIC, ts); + int ret; + +#ifdef CONFIG_CLOCK_GETTIME +#if defined(CONFIG_CLOCK_MONOTONIC) + ret = clock_gettime(CLOCK_MONOTONIC, ts); #else - return clock_gettime(CLOCK_REALTIME, ts); + ret = clock_gettime(CLOCK_REALTIME, ts); #endif -} +#else + struct timeval tv; + + ret = gettimeofday(&tv, NULL); + if (ret == 0) { + ts->tv_sec = tv.tv_sec; + ts->tv_nsec = tv.tv_usec * 1000; + } #endif + assert(ret <= 0); + return ret; +} static void __fio_gettime(struct timespec *tp) { @@ -155,8 +170,8 @@ static void __fio_gettime(struct timespec *tp) #endif #ifdef CONFIG_CLOCK_GETTIME case CS_CGETTIME: { - if (fill_clock_gettime(tp) < 0) { - log_err("fio: clock_gettime fails\n"); + if (fio_get_mono_time(tp) < 0) { + log_err("fio: fio_get_mono_time() fails\n"); assert(0); } break; @@ -224,19 +239,13 @@ static unsigned long get_cycles_per_msec(void) { struct timespec s, e; uint64_t c_s, c_e; - enum fio_cs old_cs = fio_clock_source; uint64_t elapsed; -#ifdef CONFIG_CLOCK_GETTIME - fio_clock_source = CS_CGETTIME; -#else - fio_clock_source = CS_GTOD; -#endif - __fio_gettime(&s); + fio_get_mono_time(&s); c_s = get_cpu_clock(); do { - __fio_gettime(&e); + fio_get_mono_time(&e); c_e = get_cpu_clock(); elapsed = ntime_since(&s, &e); @@ -244,7 +253,6 @@ static unsigned long get_cycles_per_msec(void) break; } while (1); - fio_clock_source = old_cs; return (c_e - c_s) * 1000000 / elapsed; } @@ -516,23 +524,33 @@ uint64_t mtime_since_now(const struct timespec *s) return mtime_since(s, &t); } -uint64_t mtime_since(const struct timespec *s, const struct timespec *e) +/* + * Returns *e - *s in milliseconds as a signed integer. Note: rounding is + * asymmetric. If the difference yields +1 ns then 0 is returned. If the + * difference yields -1 ns then -1 is returned. + */ +int64_t rel_time_since(const struct timespec *s, const struct timespec *e) { - int64_t sec, usec; + int64_t sec, nsec; sec = e->tv_sec - s->tv_sec; - usec = (e->tv_nsec - s->tv_nsec) / 1000; - if (sec > 0 && usec < 0) { + nsec = e->tv_nsec - s->tv_nsec; + if (nsec < 0) { sec--; - usec += 1000000; + nsec += 1000ULL * 1000 * 1000; } + assert(0 <= nsec && nsec < 1000ULL * 1000 * 1000); - if (sec < 0 || (sec == 0 && usec < 0)) - return 0; + return sec * 1000 + nsec / (1000 * 1000); +} - sec *= 1000; - usec /= 1000; - return sec + usec; +/* + * Returns *e - *s in milliseconds as an unsigned integer. Returns 0 if + * *e < *s. + */ +uint64_t mtime_since(const struct timespec *s, const struct timespec *e) +{ + return max(rel_time_since(s, e), (int64_t)0); } uint64_t time_since_now(const struct timespec *s) diff --git a/gettime.h b/gettime.h index c55f5cba..f1d619ad 100644 --- a/gettime.h +++ b/gettime.h @@ -16,6 +16,7 @@ enum fio_cs { CS_INVAL, }; +extern int fio_get_mono_time(struct timespec *); extern void fio_gettime(struct timespec *, void *); extern void fio_gtod_init(void); extern void fio_clock_init(void); diff --git a/helper_thread.c b/helper_thread.c index a2fb7c29..2d553654 100644 --- a/helper_thread.c +++ b/helper_thread.c @@ -1,4 +1,8 @@ #include <signal.h> +#include <unistd.h> +#ifdef CONFIG_HAVE_TIMERFD_CREATE +#include <sys/timerfd.h> +#endif #ifdef CONFIG_VALGRIND_DEV #include <valgrind/drd.h> #else @@ -11,6 +15,9 @@ #include "steadystate.h" #include "pshared.h" +static int sleep_accuracy_ms; +static int timerfd = -1; + enum action { A_EXIT = 1, A_RESET = 2, @@ -25,6 +32,13 @@ static struct helper_data { struct fio_sem *startup_sem; } *helper_data; +struct interval_timer { + const char *name; + struct timespec expires; + uint32_t interval_ms; + int (*func)(void); +}; + void helper_thread_destroy(void) { if (!helper_data) @@ -83,6 +97,18 @@ static int read_from_pipe(int fd, void *buf, size_t len) } #endif +static void block_signals(void) +{ +#ifdef HAVE_PTHREAD_SIGMASK + sigset_t sigmask; + + ret = pthread_sigmask(SIG_UNBLOCK, NULL, &sigmask); + assert(ret == 0); + ret = pthread_sigmask(SIG_BLOCK, &sigmask, NULL); + assert(ret == 0); +#endif +} + static void submit_action(enum action a) { const char data = a; @@ -128,128 +154,207 @@ void helper_thread_exit(void) pthread_join(helper_data->thread, NULL); } -static unsigned int task_helper(struct timespec *last, struct timespec *now, unsigned int period, void do_task()) +/* Resets timers and returns the time in milliseconds until the next event. */ +static int reset_timers(struct interval_timer timer[], int num_timers, + struct timespec *now) { - unsigned int next, since; - - since = mtime_since(last, now); - if (since >= period || period - since < 10) { - do_task(); - timespec_add_msec(last, since); - if (since > period) - next = period - (since - period); - else - next = period; - } else - next = period - since; - - return next; + uint32_t msec_to_next_event = INT_MAX; + int i; + + for (i = 0; i < num_timers; ++i) { + timer[i].expires = *now; + timespec_add_msec(&timer[i].expires, timer[i].interval_ms); + msec_to_next_event = min_not_zero(msec_to_next_event, + timer[i].interval_ms); + } + + return msec_to_next_event; } -static void *helper_thread_main(void *data) +/* + * Waits for an action from fd during at least timeout_ms. `fd` must be in + * non-blocking mode. + */ +static uint8_t wait_for_action(int fd, unsigned int timeout_ms) { - struct helper_data *hd = data; - unsigned int msec_to_next_event, next_log, next_si = status_interval; - unsigned int next_ss = STEADYSTATE_MSEC; - struct timespec ts, last_du, last_ss, last_si; - char action; - int ret = 0; - - sk_out_assign(hd->sk_out); + struct timeval timeout = { + .tv_sec = timeout_ms / 1000, + .tv_usec = (timeout_ms % 1000) * 1000, + }; + fd_set rfds, efds; + uint8_t action = 0; + uint64_t exp; + int res; -#ifdef HAVE_PTHREAD_SIGMASK + res = read_from_pipe(fd, &action, sizeof(action)); + if (res > 0 || timeout_ms == 0) + return action; + FD_ZERO(&rfds); + FD_SET(fd, &rfds); + FD_ZERO(&efds); + FD_SET(fd, &efds); +#ifdef CONFIG_HAVE_TIMERFD_CREATE { - sigset_t sigmask; - - /* Let another thread handle signals. */ - ret = pthread_sigmask(SIG_UNBLOCK, NULL, &sigmask); - assert(ret == 0); - ret = pthread_sigmask(SIG_BLOCK, &sigmask, NULL); - assert(ret == 0); + /* + * If the timer frequency is 100 Hz, select() will round up + * `timeout` to the next multiple of 1 / 100 Hz = 10 ms. Hence + * use a high-resolution timer if possible to increase + * select() timeout accuracy. + */ + struct itimerspec delta = {}; + + delta.it_value.tv_sec = timeout.tv_sec; + delta.it_value.tv_nsec = timeout.tv_usec * 1000; + res = timerfd_settime(timerfd, 0, &delta, NULL); + assert(res == 0); + FD_SET(timerfd, &rfds); } #endif + res = select(max(fd, timerfd) + 1, &rfds, NULL, &efds, + timerfd >= 0 ? NULL : &timeout); + if (res < 0) { + log_err("fio: select() call in helper thread failed: %s", + strerror(errno)); + return A_EXIT; + } + if (FD_ISSET(fd, &rfds)) + read_from_pipe(fd, &action, sizeof(action)); + if (timerfd >= 0 && FD_ISSET(timerfd, &rfds)) { + res = read(timerfd, &exp, sizeof(exp)); + assert(res == sizeof(exp)); + } + return action; +} + +/* + * Verify whether or not timer @it has expired. If timer @it has expired, call + * @it->func(). @now is the current time. @msec_to_next_event is an + * input/output parameter that represents the time until the next event. + */ +static int eval_timer(struct interval_timer *it, const struct timespec *now, + unsigned int *msec_to_next_event) +{ + int64_t delta_ms; + bool expired; + + /* interval == 0 means that the timer is disabled. */ + if (it->interval_ms == 0) + return 0; + + delta_ms = rel_time_since(now, &it->expires); + expired = delta_ms <= sleep_accuracy_ms; + if (expired) { + timespec_add_msec(&it->expires, it->interval_ms); + delta_ms = rel_time_since(now, &it->expires); + if (delta_ms < it->interval_ms - sleep_accuracy_ms || + delta_ms > it->interval_ms + sleep_accuracy_ms) { + dprint(FD_HELPERTHREAD, + "%s: delta = %" PRIi64 " <> %u. Clock jump?\n", + it->name, delta_ms, it->interval_ms); + delta_ms = it->interval_ms; + it->expires = *now; + timespec_add_msec(&it->expires, it->interval_ms); + } + } + *msec_to_next_event = min((unsigned int)delta_ms, *msec_to_next_event); + return expired ? it->func() : 0; +} + +static void *helper_thread_main(void *data) +{ + struct helper_data *hd = data; + unsigned int msec_to_next_event, next_log; + struct interval_timer timer[] = { + { + .name = "disk_util", + .interval_ms = DISK_UTIL_MSEC, + .func = update_io_ticks, + }, + { + .name = "status_interval", + .interval_ms = status_interval, + .func = __show_running_run_stats, + }, + { + .name = "steadystate", + .interval_ms = steadystate_enabled ? STEADYSTATE_MSEC : + 0, + .func = steadystate_check, + } + }; + struct timespec ts; + int clk_tck, ret = 0; -#ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK - clock_gettime(CLOCK_MONOTONIC, &ts); +#ifdef _SC_CLK_TCK + clk_tck = sysconf(_SC_CLK_TCK); #else - clock_gettime(CLOCK_REALTIME, &ts); + /* + * The timer frequence is variable on Windows. Instead of trying to + * query it, use 64 Hz, the clock frequency lower bound. See also + * https://carpediemsystems.co.uk/2019/07/18/windows-system-timer-granularity/. + */ + clk_tck = 64; +#endif + dprint(FD_HELPERTHREAD, "clk_tck = %d\n", clk_tck); + assert(clk_tck > 0); + sleep_accuracy_ms = (1000 + clk_tck - 1) / clk_tck; + +#ifdef CONFIG_HAVE_TIMERFD_CREATE + timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK); + assert(timerfd >= 0); + sleep_accuracy_ms = 1; #endif - memcpy(&last_du, &ts, sizeof(ts)); - memcpy(&last_ss, &ts, sizeof(ts)); - memcpy(&last_si, &ts, sizeof(ts)); + + sk_out_assign(hd->sk_out); + + /* Let another thread handle signals. */ + block_signals(); + + fio_get_mono_time(&ts); + msec_to_next_event = reset_timers(timer, ARRAY_SIZE(timer), &ts); fio_sem_up(hd->startup_sem); - msec_to_next_event = DISK_UTIL_MSEC; while (!ret && !hd->exit) { - uint64_t since_du; - struct timeval timeout = { - .tv_sec = msec_to_next_event / 1000, - .tv_usec = (msec_to_next_event % 1000) * 1000, - }; - fd_set rfds, efds; - - if (read_from_pipe(hd->pipe[0], &action, sizeof(action)) < 0) { - FD_ZERO(&rfds); - FD_SET(hd->pipe[0], &rfds); - FD_ZERO(&efds); - FD_SET(hd->pipe[0], &efds); - if (select(1, &rfds, NULL, &efds, &timeout) < 0) { - log_err("fio: select() call in helper thread failed: %s", - strerror(errno)); - ret = 1; - } - if (read_from_pipe(hd->pipe[0], &action, sizeof(action)) < - 0) - action = 0; - } + uint8_t action; + int i; -#ifdef CONFIG_PTHREAD_CONDATTR_SETCLOCK - clock_gettime(CLOCK_MONOTONIC, &ts); -#else - clock_gettime(CLOCK_REALTIME, &ts); -#endif + action = wait_for_action(hd->pipe[0], msec_to_next_event); + if (action == A_EXIT) + break; - if (action == A_RESET) { - last_du = ts; - last_ss = ts; - } + fio_get_mono_time(&ts); + + msec_to_next_event = INT_MAX; - since_du = mtime_since(&last_du, &ts); - if (since_du >= DISK_UTIL_MSEC || DISK_UTIL_MSEC - since_du < 10) { - ret = update_io_ticks(); - timespec_add_msec(&last_du, DISK_UTIL_MSEC); - msec_to_next_event = DISK_UTIL_MSEC; - if (since_du >= DISK_UTIL_MSEC) - msec_to_next_event -= (since_du - DISK_UTIL_MSEC); - } else - msec_to_next_event = DISK_UTIL_MSEC - since_du; + if (action == A_RESET) + msec_to_next_event = reset_timers(timer, + ARRAY_SIZE(timer), &ts); + + for (i = 0; i < ARRAY_SIZE(timer); ++i) + ret = eval_timer(&timer[i], &ts, &msec_to_next_event); if (action == A_DO_STAT) __show_running_run_stats(); - if (status_interval) { - next_si = task_helper(&last_si, &ts, status_interval, __show_running_run_stats); - msec_to_next_event = min(next_si, msec_to_next_event); - } - next_log = calc_log_samples(); if (!next_log) next_log = DISK_UTIL_MSEC; - if (steadystate_enabled) { - next_ss = task_helper(&last_ss, &ts, STEADYSTATE_MSEC, steadystate_check); - msec_to_next_event = min(next_ss, msec_to_next_event); - } - msec_to_next_event = min(next_log, msec_to_next_event); - dprint(FD_HELPERTHREAD, "next_si: %u, next_ss: %u, next_log: %u, msec_to_next_event: %u\n", - next_si, next_ss, next_log, msec_to_next_event); + dprint(FD_HELPERTHREAD, + "next_log: %u, msec_to_next_event: %u\n", + next_log, msec_to_next_event); if (!is_backend) print_thread_status(); } + if (timerfd >= 0) { + close(timerfd); + timerfd = -1; + } + fio_writeout_logs(false); sk_out_drop(); diff --git a/stat.c b/stat.c index 7f987c7f..eb40bd7f 100644 --- a/stat.c +++ b/stat.c @@ -2299,7 +2299,7 @@ void __show_run_stats(void) free(opt_lists); } -void __show_running_run_stats(void) +int __show_running_run_stats(void) { struct thread_data *td; unsigned long long *rt; @@ -2350,6 +2350,8 @@ void __show_running_run_stats(void) free(rt); fio_sem_up(stat_sem); + + return 0; } static bool status_file_disabled; diff --git a/stat.h b/stat.h index 0d141666..6dd5ef74 100644 --- a/stat.h +++ b/stat.h @@ -319,7 +319,7 @@ extern void show_group_stats(struct group_run_stats *rs, struct buf_output *); extern bool calc_thread_status(struct jobs_eta *je, int force); extern void display_thread_status(struct jobs_eta *je); extern void __show_run_stats(void); -extern void __show_running_run_stats(void); +extern int __show_running_run_stats(void); extern void show_running_run_stats(void); extern void check_for_running_stats(void); extern void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src, bool first); diff --git a/steadystate.c b/steadystate.c index bd2f70dd..2e3da1db 100644 --- a/steadystate.c +++ b/steadystate.c @@ -196,7 +196,7 @@ static bool steadystate_deviation(uint64_t iops, uint64_t bw, return false; } -void steadystate_check(void) +int steadystate_check(void) { int i, j, ddir, prev_groupid, group_ramp_time_over = 0; unsigned long rate_time; @@ -302,6 +302,7 @@ void steadystate_check(void) } } } + return 0; } int td_steadystate_init(struct thread_data *td) diff --git a/steadystate.h b/steadystate.h index 51472c46..bbb86fbb 100644 --- a/steadystate.h +++ b/steadystate.h @@ -4,7 +4,7 @@ #include "thread_options.h" extern void steadystate_free(struct thread_data *); -extern void steadystate_check(void); +extern int steadystate_check(void); extern void steadystate_setup(void); extern int td_steadystate_init(struct thread_data *); extern uint64_t steadystate_bw_mean(struct thread_stat *);
