X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=eta.c;h=ba066546bcd485552032eeb1d9d2eba1488c86b0;hp=f90d428197656f362fcdf199865a65f06dbebbec;hb=129fb2d422557e493020a8eac00867749af284b4;hpb=7be39be8deca720afcab621c8512032a064173ba diff --git a/eta.c b/eta.c index f90d4281..ba066546 100644 --- a/eta.c +++ b/eta.c @@ -6,15 +6,35 @@ #include #include "fio.h" +#include "lib/pow2.h" -static char run_str[REAL_MAX_JOBS + 1]; +static char __run_str[REAL_MAX_JOBS + 1]; +static char run_str[__THREAD_RUNSTR_SZ(REAL_MAX_JOBS)]; + +static void update_condensed_str(char *rstr, char *run_str_condensed) +{ + if (*rstr) { + while (*rstr) { + int nr = 1; + + *run_str_condensed++ = *rstr++; + while (*(rstr - 1) == *rstr) { + rstr++; + nr++; + } + run_str_condensed += sprintf(run_str_condensed, "(%u),", nr); + } + run_str_condensed--; + } + *run_str_condensed = '\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 +94,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,17 +111,23 @@ 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); } /* * Convert seconds to a printable string. */ -static void eta_to_str(char *str, unsigned long eta_sec) +void eta_to_str(char *str, unsigned long eta_sec) { unsigned int d, h, m, s; int disp_hour = 0; + if (eta_sec == -1) { + sprintf(str, "--"); + return; + } + s = eta_sec % 60; eta_sec /= 60; m = eta_sec % 60; @@ -122,16 +151,21 @@ static void eta_to_str(char *str, unsigned long eta_sec) /* * Best effort calculation of the estimated pending runtime of a job. */ -static int thread_eta(struct thread_data *td) +static unsigned long 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; + if (td->flags & TD_F_NO_PROGRESS) + return -1; + if (td->o.fill_device && td->o.size == -1ULL) { if (!td->fill_device_size || td->fill_device_size == -1ULL) return 0; @@ -169,23 +203,36 @@ 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; - 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 + done_secs - elapsed)) - eta_sec = td->o.timeout + 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 || td->runstate == TD_RAMP || td->runstate == TD_PRE_READING) { int t_eta = 0, r_eta = 0; @@ -196,8 +243,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; + 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; @@ -211,7 +262,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; + r_eta += (td->o.start_delay / 1000000ULL); } if (r_eta && t_eta) @@ -239,14 +290,19 @@ static void calc_rate(int unified_rw_rep, unsigned long mtime, int i; for (i = 0; i < DDIR_RWDIR_CNT; i++) { - unsigned long long diff; + unsigned long long diff, this_rate; diff = io_bytes[i] - prev_io_bytes[i]; + if (mtime) + this_rate = ((1000 * diff) / mtime) / 1024; + else + this_rate = 0; + if (unified_rw_rep) { rate[i] = 0; - rate[0] += ((1000 * diff) / mtime) / 1024; + rate[0] += this_rate; } else - rate[i] = ((1000 * diff) / mtime) / 1024; + rate[i] = this_rate; prev_io_bytes[i] = io_bytes[i]; } @@ -259,14 +315,19 @@ static void calc_iops(int unified_rw_rep, unsigned long mtime, int i; for (i = 0; i < DDIR_RWDIR_CNT; i++) { - unsigned long long diff; + unsigned long long diff, this_iops; diff = io_iops[i] - prev_io_iops[i]; + if (mtime) + this_iops = (diff * 1000) / mtime; + else + this_iops = 0; + if (unified_rw_rep) { iops[i] = 0; - iops[0] += (diff * 1000) / mtime; + iops[0] += this_iops; } else - iops[i] = (diff * 1000) / mtime; + iops[i] = this_iops; prev_io_iops[i] = io_iops[i]; } @@ -291,7 +352,7 @@ int calc_thread_status(struct jobs_eta *je, int force) static struct timeval rate_prev_time, disp_prev_time; if (!force) { - if (output_format != FIO_OUTPUT_NORMAL && + if (!(output_format & FIO_OUTPUT_NORMAL) && f_out == stdout) return 0; if (temp_stall_ts || eta_print == FIO_ETA_NEVER) @@ -319,29 +380,31 @@ int calc_thread_status(struct jobs_eta *je, int force) unified_rw_rep += td->o.unified_rw_rep; if (is_power_of_2(td->o.kb_base)) je->is_pow2 = 1; + je->unit_base = td->o.unit_base; if (td->o.bw_avg_time < bw_avg_time) 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 += td->o.rate[DDIR_READ]; - je->t_iops += td->o.rate_iops[DDIR_READ]; - je->m_rate += td->o.ratemin[DDIR_READ]; - je->m_iops += td->o.rate_iops_min[DDIR_READ]; + je->t_rate[0] += td->o.rate[DDIR_READ]; + je->t_iops[0] += td->o.rate_iops[DDIR_READ]; + je->m_rate[0] += td->o.ratemin[DDIR_READ]; + je->m_iops[0] += td->o.rate_iops_min[DDIR_READ]; } if (td_write(td)) { - je->t_rate += td->o.rate[DDIR_WRITE]; - je->t_iops += td->o.rate_iops[DDIR_WRITE]; - je->m_rate += td->o.ratemin[DDIR_WRITE]; - je->m_iops += td->o.rate_iops_min[DDIR_WRITE]; + je->t_rate[1] += td->o.rate[DDIR_WRITE]; + je->t_iops[1] += td->o.rate_iops[DDIR_WRITE]; + je->m_rate[1] += td->o.ratemin[DDIR_WRITE]; + je->m_iops[1] += td->o.rate_iops_min[DDIR_WRITE]; } if (td_trim(td)) { - je->t_rate += td->o.rate[DDIR_TRIM]; - je->t_iops += td->o.rate_iops[DDIR_TRIM]; - je->m_rate += td->o.ratemin[DDIR_TRIM]; - je->m_iops += td->o.rate_iops_min[DDIR_TRIM]; + je->t_rate[2] += td->o.rate[DDIR_TRIM]; + je->t_iops[2] += td->o.rate_iops[DDIR_TRIM]; + je->m_rate[2] += td->o.ratemin[DDIR_TRIM]; + je->m_iops[2] += td->o.rate_iops_min[DDIR_TRIM]; } je->files_open += td->nr_open_files; @@ -349,7 +412,7 @@ int calc_thread_status(struct jobs_eta *je, int force) je->nr_running++; je->nr_ramp++; } else if (td->runstate == TD_SETTING_UP) - je->nr_running++; + je->nr_setting_up++; else if (td->runstate < TD_RUNNING) je->nr_pending++; @@ -360,7 +423,7 @@ int calc_thread_status(struct jobs_eta *je, int force) check_str_update(td); - if (td->runstate > TD_RAMP) { + if (td->runstate > TD_SETTING_UP) { int ddir; for (ddir = DDIR_READ; ddir < DDIR_RWDIR_CNT; ddir++) { @@ -421,7 +484,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; } @@ -446,16 +510,19 @@ void display_thread_status(struct jobs_eta *je) } p += sprintf(p, "Jobs: %d (f=%d)", je->nr_running, je->files_open); - if (je->m_rate || je->t_rate) { + if (je->m_rate[0] || je->m_rate[1] || je->t_rate[0] || je->t_rate[1]) { char *tr, *mr; - mr = num2str(je->m_rate, 4, 0, je->is_pow2); - tr = num2str(je->t_rate, 4, 0, je->is_pow2); + mr = num2str(je->m_rate[0] + je->m_rate[1], 4, 0, je->is_pow2, 8); + tr = num2str(je->t_rate[0] + je->t_rate[1], 4, 0, je->is_pow2, 8); p += sprintf(p, ", CR=%s/%s KB/s", tr, mr); free(tr); free(mr); - } else if (je->m_iops || je->t_iops) - p += sprintf(p, ", CR=%d/%d IOPS", je->t_iops, je->m_iops); + } else if (je->m_iops[0] || je->m_iops[1] || je->t_iops[0] || je->t_iops[1]) { + p += sprintf(p, ", CR=%d/%d IOPS", + je->t_iops[0] + je->t_iops[1], + je->m_iops[0] + je->m_iops[1]); + } if (je->eta_sec != INT_MAX && je->nr_running) { char perc_str[32]; char *iops_str[DDIR_RWDIR_CNT]; @@ -464,18 +531,24 @@ void display_thread_status(struct jobs_eta *je) int l; int ddir; - if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running) + if ((!je->eta_sec && !eta_good) || je->nr_ramp == je->nr_running || + je->eta_sec == -1) strcpy(perc_str, "-.-% done"); else { + double mult = 100.0; + + if (je->nr_setting_up && je->nr_running) + mult *= (1.0 - (double) je->nr_setting_up / (double) je->nr_running); + eta_good = 1; - perc *= 100.0; + perc *= mult; sprintf(perc_str, "%3.1f%% done", perc); } for (ddir = DDIR_READ; ddir < DDIR_RWDIR_CNT; ddir++) { rate_str[ddir] = num2str(je->rate[ddir], 5, - 1024, je->is_pow2); - iops_str[ddir] = num2str(je->iops[ddir], 4, 1, 0); + 1024, je->is_pow2, je->unit_base); + iops_str[ddir] = num2str(je->iops[ddir], 4, 1, 0, 0); } left = sizeof(output) - (p - output) - 1; @@ -502,8 +575,7 @@ void display_thread_status(struct jobs_eta *je) if (!eta_new_line_init) { fio_gettime(&disp_eta_new_line, NULL); eta_new_line_init = 1; - } else if (eta_new_line && - mtime_since_now(&disp_eta_new_line) > eta_new_line * 1000) { + } else if (eta_new_line && mtime_since_now(&disp_eta_new_line) > eta_new_line) { fio_gettime(&disp_eta_new_line, NULL); eta_new_line_pending = 1; } @@ -511,19 +583,35 @@ void display_thread_status(struct jobs_eta *je) fflush(stdout); } -void print_thread_status(void) +struct jobs_eta *get_jobs_eta(int force, size_t *size) { struct jobs_eta *je; - size_t size; if (!thread_number) - return; + return NULL; - size = sizeof(*je) + thread_number * sizeof(char) + 1; - je = malloc(size); - memset(je, 0, size); + *size = sizeof(*je) + THREAD_RUNSTR_SZ + 1; + je = malloc(*size); + if (!je) + return NULL; + memset(je, 0, *size); + + if (!calc_thread_status(je, force)) { + free(je); + return NULL; + } + + *size = sizeof(*je) + strlen((char *) je->run_str) + 1; + return je; +} + +void print_thread_status(void) +{ + struct jobs_eta *je; + size_t size; - if (calc_thread_status(je, 0)) + je = get_jobs_eta(0, &size); + if (je) display_thread_status(je); free(je); @@ -531,5 +619,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); }