X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=stat.c;h=80f804a19e0bd52ab2e790e07b8041938a50fa22;hp=6e47c34cbbcaf528a4951519c8383b0e8e6b9c96;hb=702bd977555105292f3d60dee896cd35ff8b11ef;hpb=71cb78c10a80f448b912dc20d24ea731f6a102d9 diff --git a/stat.c b/stat.c index 6e47c34c..80f804a1 100644 --- a/stat.c +++ b/stat.c @@ -37,9 +37,9 @@ void update_rusage_stat(struct thread_data *td) struct thread_stat *ts = &td->ts; fio_getrusage(&td->ru_end); - ts->usr_time += mtime_since(&td->ru_start.ru_utime, + ts->usr_time += mtime_since_tv(&td->ru_start.ru_utime, &td->ru_end.ru_utime); - ts->sys_time += mtime_since(&td->ru_start.ru_stime, + ts->sys_time += mtime_since_tv(&td->ru_start.ru_stime, &td->ru_end.ru_stime); ts->ctx += td->ru_end.ru_nvcsw + td->ru_end.ru_nivcsw - (td->ru_start.ru_nvcsw + td->ru_start.ru_nivcsw); @@ -58,7 +58,7 @@ void update_rusage_stat(struct thread_data *td) * group by looking at the index bits. * */ -static unsigned int plat_val_to_idx(unsigned int val) +static unsigned int plat_val_to_idx(unsigned long long val) { unsigned int msb, error_bits, base, offset, idx; @@ -66,7 +66,7 @@ static unsigned int plat_val_to_idx(unsigned int val) if (val == 0) msb = 0; else - msb = (sizeof(val)*8) - __builtin_clz(val) - 1; + msb = (sizeof(val)*8) - __builtin_clzll(val) - 1; /* * MSB <= (FIO_IO_U_PLAT_BITS-1), cannot be rounded off. Use @@ -100,7 +100,8 @@ static unsigned int plat_val_to_idx(unsigned int val) */ static unsigned long long plat_idx_to_val(unsigned int idx) { - unsigned int error_bits, k, base; + unsigned int error_bits; + unsigned long long k, base; assert(idx < FIO_IO_U_PLAT_NR); @@ -111,7 +112,7 @@ static unsigned long long plat_idx_to_val(unsigned int idx) /* Find the group and compute the minimum value of that group */ error_bits = (idx >> FIO_IO_U_PLAT_BITS) - 1; - base = 1 << (error_bits + FIO_IO_U_PLAT_BITS); + base = ((unsigned long long) 1) << (error_bits + FIO_IO_U_PLAT_BITS); /* Find its bucket number of the group */ k = idx % FIO_IO_U_PLAT_VAL; @@ -134,17 +135,17 @@ static int double_cmp(const void *a, const void *b) return cmp; } -unsigned int calc_clat_percentiles(unsigned int *io_u_plat, unsigned long nr, - fio_fp64_t *plist, unsigned int **output, - unsigned int *maxv, unsigned int *minv) +unsigned int calc_clat_percentiles(unsigned int *io_u_plat, unsigned long long nr, + fio_fp64_t *plist, unsigned long long **output, + unsigned long long *maxv, unsigned long long *minv) { - unsigned long sum = 0; + unsigned long long sum = 0; unsigned int len, i, j = 0; unsigned int oval_len = 0; - unsigned int *ovals = NULL; - int is_last; + unsigned long long *ovals = NULL; + bool is_last; - *minv = -1U; + *minv = -1ULL; *maxv = 0; len = 0; @@ -165,7 +166,7 @@ unsigned int calc_clat_percentiles(unsigned int *io_u_plat, unsigned long nr, /* * Calculate bucket values, note down max and min values */ - is_last = 0; + is_last = false; for (i = 0; i < FIO_IO_U_PLAT_NR && !is_last; i++) { sum += io_u_plat[i]; while (sum >= (plist[j].u.f / 100.0 * nr)) { @@ -173,7 +174,7 @@ unsigned int calc_clat_percentiles(unsigned int *io_u_plat, unsigned long nr, if (j == oval_len) { oval_len += 100; - ovals = realloc(ovals, oval_len * sizeof(unsigned int)); + ovals = realloc(ovals, oval_len * sizeof(*ovals)); } ovals[j] = plat_idx_to_val(i); @@ -182,7 +183,7 @@ unsigned int calc_clat_percentiles(unsigned int *io_u_plat, unsigned long nr, if (ovals[j] > *maxv) *maxv = ovals[j]; - is_last = (j == len - 1); + is_last = (j == len - 1) != 0; if (is_last) break; @@ -197,13 +198,16 @@ unsigned int calc_clat_percentiles(unsigned int *io_u_plat, unsigned long nr, /* * Find and display the p-th percentile of clat */ -static void show_clat_percentiles(unsigned int *io_u_plat, unsigned long nr, +static void show_clat_percentiles(unsigned int *io_u_plat, unsigned long long nr, fio_fp64_t *plist, unsigned int precision, - struct buf_output *out) -{ - unsigned int len, j = 0, minv, maxv; - unsigned int *ovals; - int is_last, per_line, scale_down; + bool is_clat, struct buf_output *out) +{ + unsigned int divisor, len, i, j = 0; + unsigned long long minv, maxv; + unsigned long long *ovals; + int per_line, scale_down, time_width; + const char *pre = is_clat ? "clat" : " lat"; + bool is_last; char fmt[32]; len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv); @@ -211,39 +215,42 @@ static void show_clat_percentiles(unsigned int *io_u_plat, unsigned long nr, goto out; /* - * We default to usecs, but if the value range is such that we - * should scale down to msecs, do that. + * We default to nsecs, but if the value range is such that we + * should scale down to usecs or msecs, do that. */ - if (minv > 2000 && maxv > 99999) { + if (minv > 2000000 && maxv > 99999999ULL) { + scale_down = 2; + divisor = 1000000; + log_buf(out, " %s percentiles (msec):\n |", pre); + } else if (minv > 2000 && maxv > 99999) { scale_down = 1; - log_buf(out, " clat percentiles (msec):\n |"); + divisor = 1000; + log_buf(out, " %s percentiles (usec):\n |", pre); } else { scale_down = 0; - log_buf(out, " clat percentiles (usec):\n |"); + divisor = 1; + log_buf(out, " %s percentiles (nsec):\n |", pre); } - snprintf(fmt, sizeof(fmt), "%%1.%uf", precision); - per_line = (80 - 7) / (precision + 14); - for (j = 0; j < len; j++) { - char fbuf[16], *ptr = fbuf; + time_width = max(5, (int) (log10(maxv / divisor) + 1)); + snprintf(fmt, sizeof(fmt), " %%%u.%ufth=[%%%dllu]%%c", precision + 3, + precision, time_width); + /* fmt will be something like " %5.2fth=[%4llu]%c" */ + per_line = (80 - 7) / (precision + 10 + time_width); + for (j = 0; j < len; j++) { /* for formatting */ if (j != 0 && (j % per_line) == 0) log_buf(out, " |"); /* end of the list */ - is_last = (j == len - 1); - - if (plist[j].u.f < 10.0) - ptr += sprintf(fbuf, " "); + is_last = (j == len - 1) != 0; - snprintf(ptr, sizeof(fbuf), fmt, plist[j].u.f); - - if (scale_down) + for (i = 0; i < scale_down; i++) ovals[j] = (ovals[j] + 999) / 1000; - log_buf(out, " %sth=[%5u]%c", fbuf, ovals[j], is_last ? '\n' : ','); + log_buf(out, fmt, plist[j].u.f, ovals[j], is_last ? '\n' : ','); if (is_last) break; @@ -257,8 +264,8 @@ out: free(ovals); } -bool calc_lat(struct io_stat *is, unsigned long *min, unsigned long *max, - double *mean, double *dev) +bool calc_lat(struct io_stat *is, unsigned long long *min, + unsigned long long *max, double *mean, double *dev) { double n = (double) is->samples; @@ -292,14 +299,14 @@ void show_group_stats(struct group_run_stats *rs, struct buf_output *out) if (!rs->max_run[i]) continue; - io = num2str(rs->iobytes[i], 4, 1, i2p, N2S_BYTE); - ioalt = num2str(rs->iobytes[i], 4, 1, !i2p, N2S_BYTE); - agg = num2str(rs->agg[i], 4, 1, i2p, rs->unit_base); - aggalt = num2str(rs->agg[i], 4, 1, !i2p, rs->unit_base); - min = num2str(rs->min_bw[i], 4, 1, i2p, rs->unit_base); - minalt = num2str(rs->min_bw[i], 4, 1, !i2p, rs->unit_base); - max = num2str(rs->max_bw[i], 4, 1, i2p, rs->unit_base); - maxalt = num2str(rs->max_bw[i], 4, 1, !i2p, rs->unit_base); + io = num2str(rs->iobytes[i], rs->sig_figs, 1, i2p, N2S_BYTE); + ioalt = num2str(rs->iobytes[i], rs->sig_figs, 1, !i2p, N2S_BYTE); + agg = num2str(rs->agg[i], rs->sig_figs, 1, i2p, rs->unit_base); + aggalt = num2str(rs->agg[i], rs->sig_figs, 1, !i2p, rs->unit_base); + min = num2str(rs->min_bw[i], rs->sig_figs, 1, i2p, rs->unit_base); + minalt = num2str(rs->min_bw[i], rs->sig_figs, 1, !i2p, rs->unit_base); + max = num2str(rs->max_bw[i], rs->sig_figs, 1, i2p, rs->unit_base); + maxalt = num2str(rs->max_bw[i], rs->sig_figs, 1, !i2p, rs->unit_base); log_buf(out, "%s: bw=%s (%s), %s-%s (%s-%s), io=%s (%s), run=%llu-%llumsec\n", rs->unified_rw_rep ? " MIXED" : str[i], agg, aggalt, min, max, minalt, maxalt, io, ioalt, @@ -355,6 +362,28 @@ static void stat_calc_lat(struct thread_stat *ts, double *dst, } } +/* + * To keep the terse format unaltered, add all of the ns latency + * buckets to the first us latency bucket + */ +void stat_calc_lat_nu(struct thread_stat *ts, double *io_u_lat_u) +{ + unsigned long ntotal = 0, total = ddir_rw_sum(ts->total_io_u); + int i; + + stat_calc_lat(ts, io_u_lat_u, ts->io_u_lat_u, FIO_IO_U_LAT_U_NR); + + for (i = 0; i < FIO_IO_U_LAT_N_NR; i++) + ntotal += ts->io_u_lat_n[i]; + + io_u_lat_u[0] += 100.0 * (double) ntotal / (double) total; +} + +void stat_calc_lat_n(struct thread_stat *ts, double *io_u_lat) +{ + stat_calc_lat(ts, io_u_lat, ts->io_u_lat_n, FIO_IO_U_LAT_N_NR); +} + void stat_calc_lat_u(struct thread_stat *ts, double *io_u_lat) { stat_calc_lat(ts, io_u_lat, ts->io_u_lat_u, FIO_IO_U_LAT_U_NR); @@ -365,14 +394,17 @@ void stat_calc_lat_m(struct thread_stat *ts, double *io_u_lat) stat_calc_lat(ts, io_u_lat, ts->io_u_lat_m, FIO_IO_U_LAT_M_NR); } -static void display_lat(const char *name, unsigned long min, unsigned long max, - double mean, double dev, struct buf_output *out) +static void display_lat(const char *name, unsigned long long min, + unsigned long long max, double mean, double dev, + struct buf_output *out) { - const char *base = "(usec)"; + const char *base = "(nsec)"; char *minp, *maxp; - if (usec_to_msec(&min, &max, &mean, &dev)) + if (nsec_to_msec(&min, &max, &mean, &dev)) base = "(msec)"; + else if (nsec_to_usec(&min, &max, &mean, &dev)) + base = "(usec)"; minp = num2str(min, 6, 1, 0, N2S_NONE); maxp = num2str(max, 6, 1, 0, N2S_NONE); @@ -388,8 +420,8 @@ static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts, int ddir, struct buf_output *out) { const char *str[] = { " read", "write", " trim" }; - unsigned long min, max, runt; - unsigned long long bw, iops; + unsigned long runt; + unsigned long long min, max, bw, iops; double mean, dev; char *io_p, *bw_p, *bw_p_alt, *iops_p; int i2p; @@ -403,12 +435,12 @@ static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts, runt = ts->runtime[ddir]; bw = (1000 * ts->io_bytes[ddir]) / runt; - io_p = num2str(ts->io_bytes[ddir], 4, 1, i2p, N2S_BYTE); - bw_p = num2str(bw, 4, 1, i2p, ts->unit_base); - bw_p_alt = num2str(bw, 4, 1, !i2p, ts->unit_base); + io_p = num2str(ts->io_bytes[ddir], ts->sig_figs, 1, i2p, N2S_BYTE); + bw_p = num2str(bw, ts->sig_figs, 1, i2p, ts->unit_base); + bw_p_alt = num2str(bw, ts->sig_figs, 1, !i2p, ts->unit_base); iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt; - iops_p = num2str(iops, 4, 1, 0, N2S_NONE); + iops_p = num2str(iops, ts->sig_figs, 1, 0, N2S_NONE); log_buf(out, " %s: IOPS=%s, BW=%s (%s)(%s/%llumsec)\n", rs->unified_rw_rep ? "mixed" : str[ddir], @@ -427,11 +459,19 @@ static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts, if (calc_lat(&ts->lat_stat[ddir], &min, &max, &mean, &dev)) display_lat(" lat", min, max, mean, dev, out); - if (ts->clat_percentiles) { + if (ts->clat_percentiles || ts->lat_percentiles) { + uint64_t samples; + + if (ts->clat_percentiles) + samples = ts->clat_stat[ddir].samples; + else + samples = ts->lat_stat[ddir].samples; + show_clat_percentiles(ts->io_u_plat[ddir], - ts->clat_stat[ddir].samples, + samples, ts->percentile_list, - ts->percentile_precision, out); + ts->percentile_precision, + ts->clat_percentiles, out); } if (calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev)) { double p_of_agg = 100.0, fkb_base = (double)rs->kb_base; @@ -446,6 +486,12 @@ static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts, else bw_str = "kB"; + if (rs->agg[ddir]) { + p_of_agg = mean * 100 / (double) (rs->agg[ddir] / 1024); + if (p_of_agg > 100.0) + p_of_agg = 100.0; + } + if (rs->unit_base == 1) { min *= 8.0; max *= 8.0; @@ -453,12 +499,6 @@ static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts, dev *= 8.0; } - if (rs->agg[ddir]) { - p_of_agg = mean * 100 / (double) rs->agg[ddir]; - if (p_of_agg > 100.0) - p_of_agg = 100.0; - } - if (mean > fkb_base * fkb_base) { min /= fkb_base; max /= fkb_base; @@ -467,25 +507,33 @@ static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts, bw_str = (rs->unit_base == 1 ? "Mibit" : "MiB"); } - log_buf(out, " bw (%5s/s): min=%5lu, max=%5lu, per=%3.2f%%, avg=%5.02f, stdev=%5.02f\n", - bw_str, min, max, p_of_agg, mean, dev); + log_buf(out, " bw (%5s/s): min=%5llu, max=%5llu, per=%3.2f%%, " + "avg=%5.02f, stdev=%5.02f, samples=%" PRIu64 "\n", + bw_str, min, max, p_of_agg, mean, dev, + (&ts->bw_stat[ddir])->samples); + } + if (calc_lat(&ts->iops_stat[ddir], &min, &max, &mean, &dev)) { + log_buf(out, " iops : min=%5llu, max=%5llu, " + "avg=%5.02f, stdev=%5.02f, samples=%" PRIu64 "\n", + min, max, mean, dev, (&ts->iops_stat[ddir])->samples); } } -static int show_lat(double *io_u_lat, int nr, const char **ranges, - const char *msg, struct buf_output *out) +static bool show_lat(double *io_u_lat, int nr, const char **ranges, + const char *msg, struct buf_output *out) { - int new_line = 1, i, line = 0, shown = 0; + bool new_line = true, shown = false; + int i, line = 0; for (i = 0; i < nr; i++) { if (io_u_lat[i] <= 0.0) continue; - shown = 1; + shown = true; if (new_line) { if (line) log_buf(out, "\n"); - log_buf(out, " lat (%s) : ", msg); - new_line = 0; + log_buf(out, " lat (%s) : ", msg); + new_line = false; line = 0; } if (line) @@ -493,13 +541,21 @@ static int show_lat(double *io_u_lat, int nr, const char **ranges, log_buf(out, "%s%3.2f%%", ranges[i], io_u_lat[i]); line++; if (line == 5) - new_line = 1; + new_line = true; } if (shown) log_buf(out, "\n"); - return shown; + return true; +} + +static void show_lat_n(double *io_u_lat_n, struct buf_output *out) +{ + const char *ranges[] = { "2=", "4=", "10=", "20=", "50=", "100=", + "250=", "500=", "750=", "1000=", }; + + show_lat(io_u_lat_n, FIO_IO_U_LAT_N_NR, ranges, "nsec", out); } static void show_lat_u(double *io_u_lat_u, struct buf_output *out) @@ -521,12 +577,15 @@ static void show_lat_m(double *io_u_lat_m, struct buf_output *out) static void show_latencies(struct thread_stat *ts, struct buf_output *out) { + double io_u_lat_n[FIO_IO_U_LAT_N_NR]; double io_u_lat_u[FIO_IO_U_LAT_U_NR]; double io_u_lat_m[FIO_IO_U_LAT_M_NR]; + stat_calc_lat_n(ts, io_u_lat_n); stat_calc_lat_u(ts, io_u_lat_u); stat_calc_lat_m(ts, io_u_lat_m); + show_lat_n(io_u_lat_n, out); show_lat_u(io_u_lat_u, out); show_lat_m(io_u_lat_m, out); } @@ -686,17 +745,17 @@ static void show_ss_normal(struct thread_stat *ts, struct buf_output *out) bw_mean = steadystate_bw_mean(ts); iops_mean = steadystate_iops_mean(ts); - p1 = num2str(bw_mean / ts->kb_base, 4, ts->kb_base, i2p, ts->unit_base); - p1alt = num2str(bw_mean / ts->kb_base, 4, ts->kb_base, !i2p, ts->unit_base); - p2 = num2str(iops_mean, 4, 1, 0, N2S_NONE); + p1 = num2str(bw_mean / ts->kb_base, ts->sig_figs, ts->kb_base, i2p, ts->unit_base); + p1alt = num2str(bw_mean / ts->kb_base, ts->sig_figs, ts->kb_base, !i2p, ts->unit_base); + p2 = num2str(iops_mean, ts->sig_figs, 1, 0, N2S_NONE); log_buf(out, " steadystate : attained=%s, bw=%s (%s), iops=%s, %s%s=%.3f%s\n", - ts->ss_state & __FIO_SS_ATTAINED ? "yes" : "no", + ts->ss_state & FIO_SS_ATTAINED ? "yes" : "no", p1, p1alt, p2, - ts->ss_state & __FIO_SS_IOPS ? "iops" : "bw", - ts->ss_state & __FIO_SS_SLOPE ? " slope": " mean dev", + ts->ss_state & FIO_SS_IOPS ? "iops" : "bw", + ts->ss_state & FIO_SS_SLOPE ? " slope": " mean dev", ts->ss_criterion.u.f, - ts->ss_state & __FIO_SS_PCT ? "%" : ""); + ts->ss_state & FIO_SS_PCT ? "%" : ""); free(p1); free(p1alt); @@ -816,14 +875,13 @@ static void show_thread_status_normal(struct thread_stat *ts, static void show_ddir_status_terse(struct thread_stat *ts, struct group_run_stats *rs, int ddir, - struct buf_output *out) + int ver, struct buf_output *out) { - unsigned long min, max; - unsigned long long bw, iops; - unsigned int *ovals = NULL; + unsigned long long min, max, minv, maxv, bw, iops; + unsigned long long *ovals = NULL; double mean, dev; - unsigned int len, minv, maxv; - int i; + unsigned int len; + int i, bw_stat; assert(ddir_rw(ddir)); @@ -840,16 +898,16 @@ static void show_ddir_status_terse(struct thread_stat *ts, (unsigned long long) ts->runtime[ddir]); if (calc_lat(&ts->slat_stat[ddir], &min, &max, &mean, &dev)) - log_buf(out, ";%lu;%lu;%f;%f", min, max, mean, dev); + log_buf(out, ";%llu;%llu;%f;%f", min/1000, max/1000, mean/1000, dev/1000); else - log_buf(out, ";%lu;%lu;%f;%f", 0UL, 0UL, 0.0, 0.0); + log_buf(out, ";%llu;%llu;%f;%f", 0ULL, 0ULL, 0.0, 0.0); if (calc_lat(&ts->clat_stat[ddir], &min, &max, &mean, &dev)) - log_buf(out, ";%lu;%lu;%f;%f", min, max, mean, dev); + log_buf(out, ";%llu;%llu;%f;%f", min/1000, max/1000, mean/1000, dev/1000); else - log_buf(out, ";%lu;%lu;%f;%f", 0UL, 0UL, 0.0, 0.0); + log_buf(out, ";%llu;%llu;%f;%f", 0ULL, 0ULL, 0.0, 0.0); - if (ts->clat_percentiles) { + if (ts->clat_percentiles || ts->lat_percentiles) { len = calc_clat_percentiles(ts->io_u_plat[ddir], ts->clat_stat[ddir].samples, ts->percentile_list, &ovals, &maxv, @@ -862,42 +920,56 @@ static void show_ddir_status_terse(struct thread_stat *ts, log_buf(out, ";0%%=0"); continue; } - log_buf(out, ";%f%%=%u", ts->percentile_list[i].u.f, ovals[i]); + log_buf(out, ";%f%%=%llu", ts->percentile_list[i].u.f, ovals[i]/1000); } if (calc_lat(&ts->lat_stat[ddir], &min, &max, &mean, &dev)) - log_buf(out, ";%lu;%lu;%f;%f", min, max, mean, dev); + log_buf(out, ";%llu;%llu;%f;%f", min/1000, max/1000, mean/1000, dev/1000); else - log_buf(out, ";%lu;%lu;%f;%f", 0UL, 0UL, 0.0, 0.0); + log_buf(out, ";%llu;%llu;%f;%f", 0ULL, 0ULL, 0.0, 0.0); if (ovals) free(ovals); - if (calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev)) { + bw_stat = calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev); + if (bw_stat) { double p_of_agg = 100.0; if (rs->agg[ddir]) { - p_of_agg = mean * 100 / (double) rs->agg[ddir]; + p_of_agg = mean * 100 / (double) (rs->agg[ddir] / 1024); if (p_of_agg > 100.0) p_of_agg = 100.0; } - log_buf(out, ";%lu;%lu;%f%%;%f;%f", min, max, p_of_agg, mean, dev); + log_buf(out, ";%llu;%llu;%f%%;%f;%f", min, max, p_of_agg, mean, dev); } else - log_buf(out, ";%lu;%lu;%f%%;%f;%f", 0UL, 0UL, 0.0, 0.0, 0.0); + log_buf(out, ";%llu;%llu;%f%%;%f;%f", 0ULL, 0ULL, 0.0, 0.0, 0.0); + + if (ver == 5) { + if (bw_stat) + log_buf(out, ";%" PRIu64, (&ts->bw_stat[ddir])->samples); + else + log_buf(out, ";%lu", 0UL); + + if (calc_lat(&ts->iops_stat[ddir], &min, &max, &mean, &dev)) + log_buf(out, ";%llu;%llu;%f;%f;%" PRIu64, min, max, + mean, dev, (&ts->iops_stat[ddir])->samples); + else + log_buf(out, ";%llu;%llu;%f;%f;%lu", 0ULL, 0ULL, 0.0, 0.0, 0UL); + } } static void add_ddir_status_json(struct thread_stat *ts, struct group_run_stats *rs, int ddir, struct json_object *parent) { - unsigned long min, max; - unsigned long long bw; - unsigned int *ovals = NULL; + unsigned long long min, max, minv, maxv; + unsigned long long bw_bytes, bw; + unsigned long long *ovals = NULL; double mean, dev, iops; - unsigned int len, minv, maxv; + unsigned int len; int i; const char *ddirname[] = {"read", "write", "trim"}; - struct json_object *dir_object, *tmp_object, *percentile_object, *clat_bins_object; + struct json_object *dir_object, *tmp_object, *percentile_object, *clat_bins_object = NULL; char buf[120]; double p_of_agg = 100.0; @@ -910,16 +982,20 @@ static void add_ddir_status_json(struct thread_stat *ts, json_object_add_value_object(parent, ts->unified_rw_rep ? "mixed" : ddirname[ddir], dir_object); + bw_bytes = 0; bw = 0; iops = 0.0; if (ts->runtime[ddir]) { uint64_t runt = ts->runtime[ddir]; - bw = ((1000 * ts->io_bytes[ddir]) / runt) / 1024; /* KiB/s */ + bw_bytes = ((1000 * ts->io_bytes[ddir]) / runt); /* Bytes/s */ + bw = bw_bytes / 1024; /* KiB/s */ iops = (1000.0 * (uint64_t) ts->total_io_u[ddir]) / runt; } - json_object_add_value_int(dir_object, "io_bytes", ts->io_bytes[ddir] >> 10); + json_object_add_value_int(dir_object, "io_bytes", ts->io_bytes[ddir]); + json_object_add_value_int(dir_object, "io_kbytes", ts->io_bytes[ddir] >> 10); + json_object_add_value_int(dir_object, "bw_bytes", bw_bytes); json_object_add_value_int(dir_object, "bw", bw); json_object_add_value_float(dir_object, "iops", iops); json_object_add_value_int(dir_object, "runtime", ts->runtime[ddir]); @@ -932,7 +1008,7 @@ static void add_ddir_status_json(struct thread_stat *ts, mean = dev = 0.0; } tmp_object = json_create_object(); - json_object_add_value_object(dir_object, "slat", tmp_object); + json_object_add_value_object(dir_object, "slat_ns", tmp_object); json_object_add_value_int(tmp_object, "min", min); json_object_add_value_int(tmp_object, "max", max); json_object_add_value_float(tmp_object, "mean", mean); @@ -943,34 +1019,34 @@ static void add_ddir_status_json(struct thread_stat *ts, mean = dev = 0.0; } tmp_object = json_create_object(); - json_object_add_value_object(dir_object, "clat", tmp_object); + json_object_add_value_object(dir_object, "clat_ns", tmp_object); json_object_add_value_int(tmp_object, "min", min); json_object_add_value_int(tmp_object, "max", max); json_object_add_value_float(tmp_object, "mean", mean); json_object_add_value_float(tmp_object, "stddev", dev); - if (ts->clat_percentiles) { + if (ts->clat_percentiles || ts->lat_percentiles) { len = calc_clat_percentiles(ts->io_u_plat[ddir], ts->clat_stat[ddir].samples, ts->percentile_list, &ovals, &maxv, &minv); + if (len > FIO_IO_U_LIST_MAX_LEN) + len = FIO_IO_U_LIST_MAX_LEN; } else len = 0; percentile_object = json_create_object(); json_object_add_value_object(tmp_object, "percentile", percentile_object); - for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++) { - if (i >= len) { - json_object_add_value_int(percentile_object, "0.00", 0); - continue; - } + for (i = 0; i < len; i++) { snprintf(buf, sizeof(buf), "%f", ts->percentile_list[i].u.f); json_object_add_value_int(percentile_object, (const char *)buf, ovals[i]); } if (output_format & FIO_OUTPUT_JSON_PLUS) { clat_bins_object = json_create_object(); - json_object_add_value_object(tmp_object, "bins", clat_bins_object); + if (ts->clat_percentiles) + json_object_add_value_object(tmp_object, "bins", clat_bins_object); + for(i = 0; i < FIO_IO_U_PLAT_NR; i++) { if (ts->io_u_plat[ddir][i]) { snprintf(buf, sizeof(buf), "%llu", plat_idx_to_val(i)); @@ -984,17 +1060,20 @@ static void add_ddir_status_json(struct thread_stat *ts, mean = dev = 0.0; } tmp_object = json_create_object(); - json_object_add_value_object(dir_object, "lat", tmp_object); + json_object_add_value_object(dir_object, "lat_ns", tmp_object); json_object_add_value_int(tmp_object, "min", min); json_object_add_value_int(tmp_object, "max", max); json_object_add_value_float(tmp_object, "mean", mean); json_object_add_value_float(tmp_object, "stddev", dev); + if (output_format & FIO_OUTPUT_JSON_PLUS && ts->lat_percentiles) + json_object_add_value_object(tmp_object, "bins", clat_bins_object); + if (ovals) free(ovals); if (calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev)) { if (rs->agg[ddir]) { - p_of_agg = mean * 100 / (double) rs->agg[ddir]; + p_of_agg = mean * 100 / (double) (rs->agg[ddir] / 1024); if (p_of_agg > 100.0) p_of_agg = 100.0; } @@ -1007,74 +1086,24 @@ static void add_ddir_status_json(struct thread_stat *ts, json_object_add_value_float(dir_object, "bw_agg", p_of_agg); json_object_add_value_float(dir_object, "bw_mean", mean); json_object_add_value_float(dir_object, "bw_dev", dev); -} + json_object_add_value_int(dir_object, "bw_samples", + (&ts->bw_stat[ddir])->samples); -static void show_thread_status_terse_v2(struct thread_stat *ts, - struct group_run_stats *rs, - struct buf_output *out) -{ - double io_u_dist[FIO_IO_U_MAP_NR]; - double io_u_lat_u[FIO_IO_U_LAT_U_NR]; - double io_u_lat_m[FIO_IO_U_LAT_M_NR]; - double usr_cpu, sys_cpu; - int i; - - /* General Info */ - log_buf(out, "2;%s;%d;%d", ts->name, ts->groupid, ts->error); - /* Log Read Status */ - show_ddir_status_terse(ts, rs, DDIR_READ, out); - /* Log Write Status */ - show_ddir_status_terse(ts, rs, DDIR_WRITE, out); - /* Log Trim Status */ - show_ddir_status_terse(ts, rs, DDIR_TRIM, out); - - /* CPU Usage */ - if (ts->total_run_time) { - double runt = (double) ts->total_run_time; - - usr_cpu = (double) ts->usr_time * 100 / runt; - sys_cpu = (double) ts->sys_time * 100 / runt; - } else { - usr_cpu = 0; - sys_cpu = 0; + if (!calc_lat(&ts->iops_stat[ddir], &min, &max, &mean, &dev)) { + min = max = 0; + mean = dev = 0.0; } - - log_buf(out, ";%f%%;%f%%;%llu;%llu;%llu", usr_cpu, sys_cpu, - (unsigned long long) ts->ctx, - (unsigned long long) ts->majf, - (unsigned long long) ts->minf); - - /* Calc % distribution of IO depths, usecond, msecond latency */ - stat_calc_dist(ts->io_u_map, ddir_rw_sum(ts->total_io_u), io_u_dist); - stat_calc_lat_u(ts, io_u_lat_u); - stat_calc_lat_m(ts, io_u_lat_m); - - /* Only show fixed 7 I/O depth levels*/ - log_buf(out, ";%3.1f%%;%3.1f%%;%3.1f%%;%3.1f%%;%3.1f%%;%3.1f%%;%3.1f%%", - io_u_dist[0], io_u_dist[1], io_u_dist[2], io_u_dist[3], - io_u_dist[4], io_u_dist[5], io_u_dist[6]); - - /* Microsecond latency */ - for (i = 0; i < FIO_IO_U_LAT_U_NR; i++) - log_buf(out, ";%3.2f%%", io_u_lat_u[i]); - /* Millisecond latency */ - for (i = 0; i < FIO_IO_U_LAT_M_NR; i++) - log_buf(out, ";%3.2f%%", io_u_lat_m[i]); - /* Additional output if continue_on_error set - default off*/ - if (ts->continue_on_error) - log_buf(out, ";%llu;%d", (unsigned long long) ts->total_err_count, ts->first_error); - log_buf(out, "\n"); - - /* Additional output if description is set */ - if (strlen(ts->description)) - log_buf(out, ";%s", ts->description); - - log_buf(out, "\n"); + json_object_add_value_int(dir_object, "iops_min", min); + json_object_add_value_int(dir_object, "iops_max", max); + json_object_add_value_float(dir_object, "iops_mean", mean); + json_object_add_value_float(dir_object, "iops_stddev", dev); + json_object_add_value_int(dir_object, "iops_samples", + (&ts->iops_stat[ddir])->samples); } -static void show_thread_status_terse_v3_v4(struct thread_stat *ts, - struct group_run_stats *rs, int ver, - struct buf_output *out) +static void show_thread_status_terse_all(struct thread_stat *ts, + struct group_run_stats *rs, int ver, + struct buf_output *out) { double io_u_dist[FIO_IO_U_MAP_NR]; double io_u_lat_u[FIO_IO_U_LAT_U_NR]; @@ -1083,15 +1112,19 @@ static void show_thread_status_terse_v3_v4(struct thread_stat *ts, int i; /* General Info */ - log_buf(out, "%d;%s;%s;%d;%d", ver, fio_version_string, - ts->name, ts->groupid, ts->error); + if (ver == 2) + log_buf(out, "2;%s;%d;%d", ts->name, ts->groupid, ts->error); + else + log_buf(out, "%d;%s;%s;%d;%d", ver, fio_version_string, + ts->name, ts->groupid, ts->error); + /* Log Read Status */ - show_ddir_status_terse(ts, rs, DDIR_READ, out); + show_ddir_status_terse(ts, rs, DDIR_READ, ver, out); /* Log Write Status */ - show_ddir_status_terse(ts, rs, DDIR_WRITE, out); + show_ddir_status_terse(ts, rs, DDIR_WRITE, ver, out); /* Log Trim Status */ - if (ver == 4) - show_ddir_status_terse(ts, rs, DDIR_TRIM, out); + if (ver == 2 || ver == 4 || ver == 5) + show_ddir_status_terse(ts, rs, DDIR_TRIM, ver, out); /* CPU Usage */ if (ts->total_run_time) { @@ -1111,7 +1144,7 @@ static void show_thread_status_terse_v3_v4(struct thread_stat *ts, /* Calc % distribution of IO depths, usecond, msecond latency */ stat_calc_dist(ts->io_u_map, ddir_rw_sum(ts->total_io_u), io_u_dist); - stat_calc_lat_u(ts, io_u_lat_u); + stat_calc_lat_nu(ts, io_u_lat_u); stat_calc_lat_m(ts, io_u_lat_m); /* Only show fixed 7 I/O depth levels*/ @@ -1127,11 +1160,14 @@ static void show_thread_status_terse_v3_v4(struct thread_stat *ts, log_buf(out, ";%3.2f%%", io_u_lat_m[i]); /* disk util stats, if any */ - show_disk_util(1, NULL, out); + if (ver >= 3) + show_disk_util(1, NULL, out); /* Additional output if continue_on_error set - default off*/ if (ts->continue_on_error) log_buf(out, ";%llu;%d", (unsigned long long) ts->total_err_count, ts->first_error); + if (ver == 2) + log_buf(out, "\n"); /* Additional output if description is set */ if (strlen(ts->description)) @@ -1172,6 +1208,7 @@ static struct json_object *show_thread_status_json(struct thread_stat *ts, struct json_object *root, *tmp; struct jobs_eta *je; double io_u_dist[FIO_IO_U_MAP_NR]; + double io_u_lat_n[FIO_IO_U_LAT_N_NR]; double io_u_lat_u[FIO_IO_U_LAT_U_NR]; double io_u_lat_m[FIO_IO_U_LAT_M_NR]; double usr_cpu, sys_cpu; @@ -1216,6 +1253,7 @@ static struct json_object *show_thread_status_json(struct thread_stat *ts, /* Calc % distribution of IO depths, usecond, msecond latency */ stat_calc_dist(ts->io_u_map, ddir_rw_sum(ts->total_io_u), io_u_dist); + stat_calc_lat_n(ts, io_u_lat_n); stat_calc_lat_u(ts, io_u_lat_u); stat_calc_lat_m(ts, io_u_lat_m); @@ -1231,9 +1269,17 @@ static struct json_object *show_thread_status_json(struct thread_stat *ts, json_object_add_value_float(tmp, (const char *)name, io_u_dist[i]); } + /* Nanosecond latency */ tmp = json_create_object(); - json_object_add_value_object(root, "latency_us", tmp); + json_object_add_value_object(root, "latency_ns", tmp); + for (i = 0; i < FIO_IO_U_LAT_N_NR; i++) { + const char *ranges[] = { "2", "4", "10", "20", "50", "100", + "250", "500", "750", "1000", }; + json_object_add_value_float(tmp, ranges[i], io_u_lat_n[i]); + } /* Microsecond latency */ + tmp = json_create_object(); + json_object_add_value_object(root, "latency_us", tmp); for (i = 0; i < FIO_IO_U_LAT_U_NR; i++) { const char *ranges[] = { "2", "4", "10", "20", "50", "100", "250", "500", "750", "1000", }; @@ -1312,19 +1358,19 @@ static struct json_object *show_thread_status_json(struct thread_stat *ts, char ss_buf[64]; snprintf(ss_buf, sizeof(ss_buf), "%s%s:%f%s", - ts->ss_state & __FIO_SS_IOPS ? "iops" : "bw", - ts->ss_state & __FIO_SS_SLOPE ? "_slope" : "", + ts->ss_state & FIO_SS_IOPS ? "iops" : "bw", + ts->ss_state & FIO_SS_SLOPE ? "_slope" : "", (float) ts->ss_limit.u.f, - ts->ss_state & __FIO_SS_PCT ? "%" : ""); + ts->ss_state & FIO_SS_PCT ? "%" : ""); tmp = json_create_object(); json_object_add_value_object(root, "steadystate", tmp); json_object_add_value_string(tmp, "ss", ss_buf); json_object_add_value_int(tmp, "duration", (int)ts->ss_dur); - json_object_add_value_int(tmp, "attained", (ts->ss_state & __FIO_SS_ATTAINED) > 0); + json_object_add_value_int(tmp, "attained", (ts->ss_state & FIO_SS_ATTAINED) > 0); snprintf(ss_buf, sizeof(ss_buf), "%f%s", (float) ts->ss_criterion.u.f, - ts->ss_state & __FIO_SS_PCT ? "%" : ""); + ts->ss_state & FIO_SS_PCT ? "%" : ""); json_object_add_value_string(tmp, "criterion", ss_buf); json_object_add_value_float(tmp, "max_deviation", ts->ss_deviation.u.f); json_object_add_value_float(tmp, "slope", ts->ss_slope.u.f); @@ -1340,7 +1386,7 @@ static struct json_object *show_thread_status_json(struct thread_stat *ts, ** otherwise it actually points to the second element ** in the list */ - if ((ts->ss_state & __FIO_SS_ATTAINED) || !(ts->ss_state & __FIO_SS_BUFFER_FULL)) + if ((ts->ss_state & FIO_SS_ATTAINED) || !(ts->ss_state & FIO_SS_BUFFER_FULL)) j = ts->ss_head; else j = ts->ss_head == 0 ? ts->ss_dur - 1 : ts->ss_head - 1; @@ -1362,10 +1408,8 @@ static void show_thread_status_terse(struct thread_stat *ts, struct group_run_stats *rs, struct buf_output *out) { - if (terse_version == 2) - show_thread_status_terse_v2(ts, rs, out); - else if (terse_version == 3 || terse_version == 4) - show_thread_status_terse_v3_v4(ts, rs, terse_version, out); + if (terse_version >= 2 && terse_version <= 5) + show_thread_status_terse_all(ts, rs, terse_version, out); else log_err("fio: bad terse version!? %d\n", terse_version); } @@ -1444,6 +1488,8 @@ void sum_group_stats(struct group_run_stats *dst, struct group_run_stats *src) dst->kb_base = src->kb_base; if (!dst->unit_base) dst->unit_base = src->unit_base; + if (!dst->sig_figs) + dst->sig_figs = src->sig_figs; } void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src, @@ -1457,6 +1503,7 @@ void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src, sum_stat(&dst->slat_stat[l], &src->slat_stat[l], first); sum_stat(&dst->lat_stat[l], &src->lat_stat[l], first); sum_stat(&dst->bw_stat[l], &src->bw_stat[l], first); + sum_stat(&dst->iops_stat[l], &src->iops_stat[l], first); dst->io_bytes[l] += src->io_bytes[l]; @@ -1467,6 +1514,7 @@ void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src, sum_stat(&dst->slat_stat[0], &src->slat_stat[l], first); sum_stat(&dst->lat_stat[0], &src->lat_stat[l], first); sum_stat(&dst->bw_stat[0], &src->bw_stat[l], first); + sum_stat(&dst->iops_stat[0], &src->iops_stat[l], first); dst->io_bytes[0] += src->io_bytes[l]; @@ -1493,6 +1541,8 @@ void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src, dst->io_u_submit[k] += src->io_u_submit[k]; for (k = 0; k < FIO_IO_U_MAP_NR; k++) dst->io_u_complete[k] += src->io_u_complete[k]; + for (k = 0; k < FIO_IO_U_LAT_N_NR; k++) + dst->io_u_lat_n[k] += src->io_u_lat_n[k]; for (k = 0; k < FIO_IO_U_LAT_U_NR; k++) dst->io_u_lat_u[k] += src->io_u_lat_u[k]; for (k = 0; k < FIO_IO_U_LAT_M_NR; k++) @@ -1546,6 +1596,7 @@ void init_thread_stat(struct thread_stat *ts) ts->clat_stat[j].min_val = -1UL; ts->slat_stat[j].min_val = -1UL; ts->bw_stat[j].min_val = -1UL; + ts->iops_stat[j].min_val = -1UL; } ts->groupid = -1; } @@ -1556,8 +1607,8 @@ void __show_run_stats(void) struct thread_data *td; struct thread_stat *threadstats, *ts; int i, j, k, nr_ts, last_ts, idx; - int kb_base_warned = 0; - int unit_base_warned = 0; + bool kb_base_warned = false; + bool unit_base_warned = false; struct json_object *root = NULL; struct json_array *array = NULL; struct buf_output output[FIO_OUTPUT_NR]; @@ -1613,6 +1664,7 @@ void __show_run_stats(void) ts = &threadstats[j]; ts->clat_percentiles = td->o.clat_percentiles; + ts->lat_percentiles = td->o.lat_percentiles; ts->percentile_precision = td->o.percentile_precision; memcpy(ts->percentile_list, td->o.percentile_list, sizeof(td->o.percentile_list)); opt_lists[j] = &td->opt_list; @@ -1645,15 +1697,16 @@ void __show_run_stats(void) ts->kb_base = td->o.kb_base; ts->unit_base = td->o.unit_base; + ts->sig_figs = td->o.sig_figs; ts->unified_rw_rep = td->o.unified_rw_rep; } else if (ts->kb_base != td->o.kb_base && !kb_base_warned) { log_info("fio: kb_base differs for jobs in group, using" " %u as the base\n", ts->kb_base); - kb_base_warned = 1; + kb_base_warned = true; } else if (ts->unit_base != td->o.unit_base && !unit_base_warned) { log_info("fio: unit_base differs for jobs in group, using" " %u as the base\n", ts->unit_base); - unit_base_warned = 1; + unit_base_warned = true; } ts->continue_on_error = td->o.continue_on_error; @@ -1707,6 +1760,7 @@ void __show_run_stats(void) rs = &runstats[ts->groupid]; rs->kb_base = ts->kb_base; rs->unit_base = ts->unit_base; + rs->sig_figs = ts->sig_figs; rs->unified_rw_rep += ts->unified_rw_rep; for (j = 0; j < DDIR_RWDIR_CNT; j++) { @@ -1825,8 +1879,10 @@ void __show_run_stats(void) } for (i = 0; i < FIO_OUTPUT_NR; i++) { - buf_output_flush(&output[i]); - buf_output_free(&output[i]); + struct buf_output *out = &output[i]; + + log_info_buf(out->buf, out->buflen); + buf_output_free(out); } log_info_flush(); @@ -1846,22 +1902,22 @@ void __show_running_run_stats(void) { struct thread_data *td; unsigned long long *rt; - struct timeval tv; + struct timespec ts; int i; fio_mutex_down(stat_mutex); rt = malloc(thread_number * sizeof(unsigned long long)); - fio_gettime(&tv, NULL); + fio_gettime(&ts, NULL); for_each_td(td, i) { td->update_rusage = 1; td->ts.io_bytes[DDIR_READ] = td->io_bytes[DDIR_READ]; td->ts.io_bytes[DDIR_WRITE] = td->io_bytes[DDIR_WRITE]; td->ts.io_bytes[DDIR_TRIM] = td->io_bytes[DDIR_TRIM]; - td->ts.total_run_time = mtime_since(&td->epoch, &tv); + td->ts.total_run_time = mtime_since(&td->epoch, &ts); - rt[i] = mtime_since(&td->start, &tv); + rt[i] = mtime_since(&td->start, &ts); if (td_read(td) && td->ts.io_bytes[DDIR_READ]) td->ts.runtime[DDIR_READ] += rt[i]; if (td_write(td) && td->ts.io_bytes[DDIR_WRITE]) @@ -1895,9 +1951,9 @@ void __show_running_run_stats(void) fio_mutex_up(stat_mutex); } -static int status_interval_init; -static struct timeval status_time; -static int status_file_disabled; +static bool status_interval_init; +static struct timespec status_time; +static bool status_file_disabled; #define FIO_STATUS_FILE "fio-dump-status" @@ -1928,7 +1984,7 @@ static int check_status_file(void) log_err("fio: failed to unlink %s: %s\n", fio_status_file_path, strerror(errno)); log_err("fio: disabling status file updates\n"); - status_file_disabled = 1; + status_file_disabled = true; } return 1; @@ -1939,7 +1995,7 @@ void check_for_running_stats(void) if (status_interval) { if (!status_interval_init) { fio_gettime(&status_time, NULL); - status_interval_init = 1; + status_interval_init = true; } else if (mtime_since_now(&status_time) >= status_interval) { show_running_run_stats(); fio_gettime(&status_time, NULL); @@ -1952,7 +2008,7 @@ void check_for_running_stats(void) } } -static inline void add_stat_sample(struct io_stat *is, unsigned long data) +static inline void add_stat_sample(struct io_stat *is, unsigned long long data) { double val = data; double delta; @@ -2125,7 +2181,7 @@ static void __add_log_sample(struct io_log *iolog, union io_sample_data data, if (iolog->disabled) return; if (flist_empty(&iolog->io_logs)) - iolog->avg_last = t; + iolog->avg_last[ddir] = t; cur_log = get_cur_log(iolog); if (cur_log) { @@ -2185,6 +2241,8 @@ void reset_io_stats(struct thread_data *td) ts->io_u_complete[i] = 0; } + for (i = 0; i < FIO_IO_U_LAT_N_NR; i++) + ts->io_u_lat_n[i] = 0; for (i = 0; i < FIO_IO_U_LAT_U_NR; i++) ts->io_u_lat_u[i] = 0; for (i = 0; i < FIO_IO_U_LAT_M_NR; i++) @@ -2254,9 +2312,9 @@ static long add_log_sample(struct thread_data *td, struct io_log *iolog, * If period hasn't passed, adding the above sample is all we * need to do. */ - this_window = elapsed - iolog->avg_last; - if (elapsed < iolog->avg_last) - return iolog->avg_last - elapsed; + this_window = elapsed - iolog->avg_last[ddir]; + if (elapsed < iolog->avg_last[ddir]) + return iolog->avg_last[ddir] - elapsed; else if (this_window < iolog->avg_msec) { int diff = iolog->avg_msec - this_window; @@ -2264,9 +2322,9 @@ static long add_log_sample(struct thread_data *td, struct io_log *iolog, return diff; } - _add_stat_to_log(iolog, elapsed, td->o.log_max != 0); + __add_stat_to_log(iolog, ddir, elapsed, td->o.log_max != 0); - iolog->avg_last = elapsed - (this_window - iolog->avg_msec); + iolog->avg_last[ddir] = elapsed - (this_window - iolog->avg_msec); return iolog->avg_msec; } @@ -2300,16 +2358,16 @@ void add_agg_sample(union io_sample_data data, enum fio_ddir ddir, unsigned int } static void add_clat_percentile_sample(struct thread_stat *ts, - unsigned long usec, enum fio_ddir ddir) + unsigned long long nsec, enum fio_ddir ddir) { - unsigned int idx = plat_val_to_idx(usec); + unsigned int idx = plat_val_to_idx(nsec); assert(idx < FIO_IO_U_PLAT_NR); ts->io_u_plat[ddir][idx]++; } void add_clat_sample(struct thread_data *td, enum fio_ddir ddir, - unsigned long usec, unsigned int bs, uint64_t offset) + unsigned long long nsec, unsigned int bs, uint64_t offset) { unsigned long elapsed, this_window; struct thread_stat *ts = &td->ts; @@ -2317,14 +2375,14 @@ void add_clat_sample(struct thread_data *td, enum fio_ddir ddir, td_io_u_lock(td); - add_stat_sample(&ts->clat_stat[ddir], usec); + add_stat_sample(&ts->clat_stat[ddir], nsec); if (td->clat_log) - add_log_sample(td, td->clat_log, sample_val(usec), ddir, bs, + add_log_sample(td, td->clat_log, sample_val(nsec), ddir, bs, offset); if (ts->clat_percentiles) - add_clat_percentile_sample(ts, usec, ddir); + add_clat_percentile_sample(ts, nsec, ddir); if (iolog && iolog->hist_msec) { struct io_hist *hw = &iolog->hist_window[ddir]; @@ -2386,7 +2444,7 @@ void add_slat_sample(struct thread_data *td, enum fio_ddir ddir, } void add_lat_sample(struct thread_data *td, enum fio_ddir ddir, - unsigned long usec, unsigned int bs, uint64_t offset) + unsigned long long nsec, unsigned int bs, uint64_t offset) { struct thread_stat *ts = &td->ts; @@ -2395,23 +2453,26 @@ void add_lat_sample(struct thread_data *td, enum fio_ddir ddir, td_io_u_lock(td); - add_stat_sample(&ts->lat_stat[ddir], usec); + add_stat_sample(&ts->lat_stat[ddir], nsec); if (td->lat_log) - add_log_sample(td, td->lat_log, sample_val(usec), ddir, bs, + add_log_sample(td, td->lat_log, sample_val(nsec), ddir, bs, offset); + if (ts->lat_percentiles) + add_clat_percentile_sample(ts, nsec, ddir); + td_io_u_unlock(td); } void add_bw_sample(struct thread_data *td, struct io_u *io_u, - unsigned int bytes, unsigned long spent) + unsigned int bytes, unsigned long long spent) { struct thread_stat *ts = &td->ts; unsigned long rate; if (spent) - rate = bytes * 1000 / spent; + rate = (unsigned long) (bytes * 1000000ULL / spent); else rate = 0; @@ -2427,8 +2488,8 @@ void add_bw_sample(struct thread_data *td, struct io_u *io_u, td_io_u_unlock(td); } -static int __add_samples(struct thread_data *td, struct timeval *parent_tv, - struct timeval *t, unsigned int avg_time, +static int __add_samples(struct thread_data *td, struct timespec *parent_tv, + struct timespec *t, unsigned int avg_time, uint64_t *this_io_bytes, uint64_t *stat_io_bytes, struct io_stat *stat, struct io_log *log, bool is_kb) @@ -2465,7 +2526,7 @@ static int __add_samples(struct thread_data *td, struct timeval *parent_tv, add_stat_sample(&stat[ddir], rate); - if (td->bw_log) { + if (log) { unsigned int bs = 0; if (td->o.min_bs[ddir] == td->o.max_bs[ddir]) @@ -2478,7 +2539,7 @@ static int __add_samples(struct thread_data *td, struct timeval *parent_tv, stat_io_bytes[ddir] = this_io_bytes[ddir]; } - timeval_add_msec(parent_tv, avg_time); + timespec_add_msec(parent_tv, avg_time); td_io_u_unlock(td); @@ -2490,7 +2551,7 @@ static int __add_samples(struct thread_data *td, struct timeval *parent_tv, return min(next, next_log); } -static int add_bw_samples(struct thread_data *td, struct timeval *t) +static int add_bw_samples(struct thread_data *td, struct timespec *t) { return __add_samples(td, &td->bw_sample_time, t, td->o.bw_avg_time, td->this_io_bytes, td->stat_io_bytes, @@ -2514,7 +2575,7 @@ void add_iops_sample(struct thread_data *td, struct io_u *io_u, td_io_u_unlock(td); } -static int add_iops_samples(struct thread_data *td, struct timeval *t) +static int add_iops_samples(struct thread_data *td, struct timespec *t) { return __add_samples(td, &td->iops_sample_time, t, td->o.iops_avg_time, td->this_io_blocks, td->stat_io_blocks, @@ -2528,7 +2589,7 @@ int calc_log_samples(void) { struct thread_data *td; unsigned int next = ~0U, tmp; - struct timeval now; + struct timespec now; int i; fio_gettime(&now, NULL); @@ -2541,12 +2602,14 @@ int calc_log_samples(void) next = min(td->o.iops_avg_time, td->o.bw_avg_time); continue; } - if (td->bw_log && !per_unit_log(td->bw_log)) { + if (!td->bw_log || + (td->bw_log && !per_unit_log(td->bw_log))) { tmp = add_bw_samples(td, &now); if (tmp < next) next = tmp; } - if (td->iops_log && !per_unit_log(td->iops_log)) { + if (!td->iops_log || + (td->iops_log && !per_unit_log(td->iops_log))) { tmp = add_iops_samples(td, &now); if (tmp < next) next = tmp;