Recent changes (master)

[Jens Axboe <axboe@kernel.dk>]

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 *);