Ensure we have enough room for the ETA runstr

[fio.git] / eta.c

diff --git a/eta.c b/eta.c
index e12e4fc3fe4703b5a347d743e8eccbeebdf6a6db..dfe66f9e8ffbb455efe44de1b800c8e037c87895 100644 (file)
--- a/eta.c
+++ b/eta.c
@@ -7,14 +7,52 @@
 
 #include "fio.h"
 
-static char run_str[REAL_MAX_JOBS + 1];
+static char __run_str[REAL_MAX_JOBS + 1];
+
+/*
+ * Worst level condensing would be 1:5, so allow enough room for that
+ */
+static char run_str[__THREAD_RUNSTR_SZ(REAL_MAX_JOBS)];
+
+static void update_condensed_str(char *run_str, char *run_str_condensed)
+{
+       int i, ci, last, nr;
+       size_t len;
+
+       len = strlen(run_str);
+       if (!len)
+               return;
+
+       last = 0;
+       nr = 0;
+       ci = 0;
+       for (i = 0; i < len; i++) {
+               if (!last) {
+new:
+                       run_str_condensed[ci] = run_str[i];
+                       last = run_str[i];
+                       nr = 1;
+                       ci++;
+               } else if (last == run_str[i]) {
+                       nr++;
+               } else {
+                       ci += sprintf(&run_str_condensed[ci], "(%u),", nr);
+                       goto new;
+               }
+       }
+
+       if (nr)
+               ci += sprintf(&run_str_condensed[ci], "(%u)", nr);
+
+       run_str_condensed[ci + 1] = '\0';
+}
 
 /*
  * Sets the status of the 'td' in the printed status map.
  */
 static void check_str_update(struct thread_data *td)
 {
-       char c = run_str[td->thread_number - 1];
+       char c = __run_str[td->thread_number - 1];
 
        switch (td->runstate) {
        case TD_REAPED:
@@ -74,6 +112,9 @@ static void check_str_update(struct thread_data *td)
        case TD_FSYNCING:
                c = 'F';
                break;
+       case TD_FINISHING:
+               c = 'f';
+               break;
        case TD_CREATED:
                c = 'C';
                break;
@@ -88,7 +129,8 @@ static void check_str_update(struct thread_data *td)
                log_err("state %d\n", td->runstate);
        }
 
-       run_str[td->thread_number - 1] = c;
+       __run_str[td->thread_number - 1] = c;
+       update_condensed_str(__run_str, run_str);
 }
 
 /*
@@ -127,8 +169,10 @@ static int thread_eta(struct thread_data *td)
        unsigned long long bytes_total, bytes_done;
        unsigned long eta_sec = 0;
        unsigned long elapsed;
+       uint64_t timeout;
 
        elapsed = (mtime_since_now(&td->epoch) + 999) / 1000;
+       timeout = td->o.timeout / 1000000UL;
 
        bytes_total = td->total_io_size;
 
@@ -169,23 +213,33 @@ static int thread_eta(struct thread_data *td)
                double perc, perc_t;
 
                bytes_done = ddir_rw_sum(td->io_bytes);
-               perc = (double) bytes_done / (double) bytes_total;
-               if (perc > 1.0)
-                       perc = 1.0;
+
+               if (bytes_total) {
+                       perc = (double) bytes_done / (double) bytes_total;
+                       if (perc > 1.0)
+                               perc = 1.0;
+               } else
+                       perc = 0.0;
 
                if (td->o.time_based) {
-                       perc_t = (double) elapsed /
-                                       (double) (td->o.timeout / 1000);
-                       if (perc_t < perc)
-                               perc = perc_t;
+                       if (timeout) {
+                               perc_t = (double) elapsed / (double) timeout;
+                               if (perc_t < perc)
+                                       perc = perc_t;
+                       } else {
+                               /*
+                                * Will never hit, we can't have time_based
+                                * without a timeout set.
+                                */
+                               perc = 0.0;
+                       }
                }
 
                eta_sec = (unsigned long) (elapsed * (1.0 / perc)) - elapsed;
 
                if (td->o.timeout &&
-                   eta_sec > ( (td->o.timeout / 1000) + done_secs - elapsed))
-                       eta_sec = (td->o.timeout / 1000)  + done_secs
-                                       - elapsed;
+                   eta_sec > (timeout + done_secs - elapsed))
+                       eta_sec = timeout + done_secs - elapsed;
        } else if (td->runstate == TD_NOT_CREATED || td->runstate == TD_CREATED
                        || td->runstate == TD_INITIALIZED
                        || td->runstate == TD_SETTING_UP
@@ -199,8 +253,12 @@ static int thread_eta(struct thread_data *td)
                 * if given, otherwise assume it'll run at the specified rate.
                 */
                if (td->o.timeout) {
-                       t_eta = (td->o.timeout + td->o.start_delay  +
-                                       td->o.ramp_time ) / 1000;
+                       uint64_t timeout = td->o.timeout;
+                       uint64_t start_delay = td->o.start_delay;
+                       uint64_t ramp_time = td->o.ramp_time;
+
+                       t_eta = timeout + start_delay + ramp_time;
+                       t_eta /= 1000000ULL;
 
                        if (in_ramp_time(td)) {
                                unsigned long ramp_left;
@@ -214,7 +272,7 @@ static int thread_eta(struct thread_data *td)
                rate_bytes = ddir_rw_sum(td->o.rate);
                if (rate_bytes) {
                        r_eta = (bytes_total / 1024) / rate_bytes;
-                       r_eta += td->o.start_delay / 1000;
+                       r_eta += (td->o.start_delay / 1000000ULL);
                }
 
                if (r_eta && t_eta)
@@ -327,7 +385,8 @@ int calc_thread_status(struct jobs_eta *je, int force)
                        bw_avg_time = td->o.bw_avg_time;
                if (td->runstate == TD_RUNNING || td->runstate == TD_VERIFYING
                    || td->runstate == TD_FSYNCING
-                   || td->runstate == TD_PRE_READING) {
+                   || td->runstate == TD_PRE_READING
+                   || td->runstate == TD_FINISHING) {
                        je->nr_running++;
                        if (td_read(td)) {
                                je->t_rate[0] += td->o.rate[DDIR_READ];
@@ -426,7 +485,8 @@ int calc_thread_status(struct jobs_eta *je, int force)
                return 0;
 
        je->nr_threads = thread_number;
-       memcpy(je->run_str, run_str, thread_number * sizeof(char));
+       update_condensed_str(__run_str, run_str);
+       memcpy(je->run_str, run_str, strlen(run_str));
        return 1;
 }
 
@@ -532,7 +592,7 @@ void print_thread_status(void)
        if (!thread_number)
                return;
 
-       size = sizeof(*je) + thread_number * sizeof(char) + 1;
+       size = sizeof(*je) + THREAD_RUNSTR_SZ;
        je = malloc(size);
        memset(je, 0, size);
 
@@ -544,5 +604,6 @@ void print_thread_status(void)
 
 void print_status_init(int thr_number)
 {
-       run_str[thr_number] = 'P';
+       __run_str[thr_number] = 'P';
+       update_condensed_str(__run_str, run_str);
 }