From 6043c5790f9978814ec25e3ea8f4d574daf6266e Mon Sep 17 00:00:00 2001 From: Jens Axboe Date: Fri, 3 Nov 2006 11:37:47 +0100 Subject: [PATCH] [PATCH] Add in-progress io rate Dumped along with percentage and eta. Signed-off-by: Jens Axboe --- HOWTO | 8 ++++---- eta.c | 22 +++++++++++++++++++++- fio.h | 1 + time.c | 5 +++++ 4 files changed, 31 insertions(+), 5 deletions(-) diff --git a/HOWTO b/HOWTO index 78a9be03..c17d29e5 100644 --- a/HOWTO +++ b/HOWTO @@ -454,7 +454,7 @@ cpuchunks=int If the job is a CPU cycle eater, split the load into fio spits out a lot of output. While running, fio will display the status of the jobs created. An example of that would be: -Threads running: 1: [_r] [24.79% done] [eta 00h:01m:31s] +Threads running: 1: [_r] [24.79% done] [ 13509/ 8334 kb/s] [eta 00h:01m:31s] The characters inside the square brackets denote the current status of each thread. The possible values (in typical life cycle order) are: @@ -476,9 +476,9 @@ E Thread exited, not reaped by main thread yet. _ Thread reaped. The other values are fairly self explanatory - number of threads -currently running and doing io, and the estimated completion percentage -and time for the running group. It's impossible to estimate runtime -of the following groups (if any). +currently running and doing io, rate of io since last check, and the estimated +completion percentage and time for the running group. It's impossible to +estimate runtime of the following groups (if any). When fio is done (or interrupted by ctrl-c), it will show the data for each thread, group of threads, and disks in that order. For each data diff --git a/eta.c b/eta.c index 8cf9ea25..339f6568 100644 --- a/eta.c +++ b/eta.c @@ -176,12 +176,22 @@ void print_thread_status(void) char eta_str[32]; double perc = 0.0; + static unsigned long long prev_io_bytes[2]; + static struct timeval prev_time; + static unsigned int r_rate, w_rate; + unsigned long long io_bytes[2]; + unsigned long mtime; + if (temp_stall_ts || terse_output) return; + if (!prev_io_bytes[0] && !prev_io_bytes[1]) + fill_start_time(&prev_time); + eta_secs = malloc(thread_number * sizeof(int)); memset(eta_secs, 0, thread_number * sizeof(int)); + io_bytes[0] = io_bytes[1] = 0; nr_pending = nr_running = t_rate = m_rate = 0; for_each_td(td, i) { if (td->runstate == TD_RUNNING || td->runstate == TD_VERIFYING|| @@ -198,6 +208,8 @@ void print_thread_status(void) eta_secs[i] = INT_MAX; check_str_update(td); + io_bytes[0] += td->io_bytes[0]; + io_bytes[1] += td->io_bytes[1]; } if (exitall_on_terminate) @@ -222,6 +234,14 @@ void print_thread_status(void) eta_to_str(eta_str, eta_sec); } + mtime = mtime_since_now(&prev_time); + if (mtime > 1000) { + r_rate = (io_bytes[0] - prev_io_bytes[0]) / mtime; + w_rate = (io_bytes[1] - prev_io_bytes[1]) / mtime; + gettimeofday(&prev_time, NULL); + memcpy(prev_io_bytes, io_bytes, sizeof(io_bytes)); + } + if (!nr_running && !nr_pending) return; @@ -230,7 +250,7 @@ void print_thread_status(void) printf(", commitrate %d/%dKiB/sec", t_rate, m_rate); if (eta_sec != INT_MAX && nr_running) { perc *= 100.0; - printf(": [%s] [%3.2f%% done] [eta %s]", run_str, perc,eta_str); + printf(": [%s] [%3.2f%% done] [%6u/%6u kb/s] [eta %s]", run_str, perc, r_rate, w_rate, eta_str); } printf("\r"); fflush(stdout); diff --git a/fio.h b/fio.h index 53e174e1..5bb55695 100644 --- a/fio.h +++ b/fio.h @@ -459,6 +459,7 @@ extern unsigned long mtime_since_genesis(void); extern void __usec_sleep(unsigned int); extern void usec_sleep(struct thread_data *, unsigned long); extern void rate_throttle(struct thread_data *, unsigned long, unsigned int, int); +extern void fill_start_time(struct timeval *); /* * Init functions diff --git a/time.c b/time.c index 5d3dee20..d08c7916 100644 --- a/time.c +++ b/time.c @@ -132,3 +132,8 @@ void time_init(void) { gettimeofday(&genesis, NULL); } + +void fill_start_time(struct timeval *t) +{ + memcpy(t, &genesis, sizeof(genesis)); +} -- 2.25.1