X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=stat.c;h=252b2dc96ce286666d059671f7322b1f283c87b0;hp=edeae877f817e77c05d4d95cc1f058e92b5770e4;hb=0e4dd95c548cca2e7bef7db3696231130cb4b594;hpb=d79db1222039e906dd49ae290daa59701f4e2385 diff --git a/stat.c b/stat.c index edeae877..252b2dc9 100644 --- a/stat.c +++ b/stat.c @@ -11,13 +11,16 @@ #include "diskutil.h" #include "lib/ieee754.h" #include "json.h" +#include "lib/getrusage.h" +#include "idletime.h" + +struct fio_mutex *stat_mutex; void update_rusage_stat(struct thread_data *td) { struct thread_stat *ts = &td->ts; - getrusage(RUSAGE_SELF, &td->ru_end); - + fio_getrusage(&td->ru_end); ts->usr_time += mtime_since(&td->ru_start.ru_utime, &td->ru_end.ru_utime); ts->sys_time += mtime_since(&td->ru_start.ru_stime, @@ -179,11 +182,12 @@ 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, - fio_fp64_t *plist) + fio_fp64_t *plist, unsigned int precision) { unsigned int len, j = 0, minv, maxv; unsigned int *ovals; - int is_last, scale_down; + int is_last, per_line, scale_down; + char fmt[32]; len = calc_clat_percentiles(io_u_plat, nr, plist, &ovals, &maxv, &minv); if (!len) @@ -201,20 +205,23 @@ static void show_clat_percentiles(unsigned int *io_u_plat, unsigned long nr, log_info(" clat percentiles (usec):\n |"); } + snprintf(fmt, sizeof(fmt), "%%1.%uf", precision); + per_line = (80 - 7) / (precision + 14); + for (j = 0; j < len; j++) { - char fbuf[8]; + char fbuf[16], *ptr = fbuf; /* for formatting */ - if (j != 0 && (j % 4) == 0) + if (j != 0 && (j % per_line) == 0) log_info(" |"); /* end of the list */ is_last = (j == len - 1); if (plist[j].u.f < 10.0) - sprintf(fbuf, " %2.2f", plist[j].u.f); - else - sprintf(fbuf, "%2.2f", plist[j].u.f); + ptr += sprintf(fbuf, " "); + + snprintf(ptr, sizeof(fbuf), fmt, plist[j].u.f); if (scale_down) ovals[j] = (ovals[j] + 999) / 1000; @@ -224,7 +231,7 @@ static void show_clat_percentiles(unsigned int *io_u_plat, unsigned long nr, if (is_last) break; - if (j % 4 == 3) /* for formatting */ + if ((j % per_line) == per_line - 1) /* for formatting */ log_info("\n"); } @@ -236,15 +243,13 @@ out: int calc_lat(struct io_stat *is, unsigned long *min, unsigned long *max, double *mean, double *dev) { - double n = is->samples; + double n = (double) is->samples; - if (is->samples == 0) + if (n == 0) return 0; *min = is->min_val; *max = is->max_val; - - n = (double) is->samples; *mean = is->mean.u.f; if (n > 1.0) @@ -258,7 +263,7 @@ int calc_lat(struct io_stat *is, unsigned long *min, unsigned long *max, void show_group_stats(struct group_run_stats *rs) { char *p1, *p2, *p3, *p4; - const char *ddir_str[] = { " READ", " WRITE" , " TRIM"}; + const char *str[] = { " READ", " WRITE" , " TRIM"}; int i; log_info("\nRun status group %d (all jobs):\n", rs->groupid); @@ -269,15 +274,17 @@ void show_group_stats(struct group_run_stats *rs) if (!rs->max_run[i]) continue; - p1 = num2str(rs->io_kb[i], 6, rs->kb_base, i2p); - p2 = num2str(rs->agg[i], 6, rs->kb_base, i2p); - p3 = num2str(rs->min_bw[i], 6, rs->kb_base, i2p); - p4 = num2str(rs->max_bw[i], 6, rs->kb_base, i2p); + p1 = num2str(rs->io_kb[i], 6, rs->kb_base, i2p, 8); + p2 = num2str(rs->agg[i], 6, rs->kb_base, i2p, rs->unit_base); + p3 = num2str(rs->min_bw[i], 6, rs->kb_base, i2p, rs->unit_base); + p4 = num2str(rs->max_bw[i], 6, rs->kb_base, i2p, rs->unit_base); - log_info("%s: io=%sB, aggrb=%sB/s, minb=%sB/s, maxb=%sB/s," - " mint=%llumsec, maxt=%llumsec\n", ddir_str[i], p1, p2, - p3, p4, rs->min_run[i], - rs->max_run[i]); + log_info("%s: io=%s, aggrb=%s/s, minb=%s/s, maxb=%s/s," + " mint=%llumsec, maxt=%llumsec\n", + rs->unified_rw_rep ? " MIXED" : str[i], + p1, p2, p3, p4, + (unsigned long long) rs->min_run[i], + (unsigned long long) rs->max_run[i]); free(p1); free(p2); @@ -343,8 +350,8 @@ static void display_lat(const char *name, unsigned long min, unsigned long max, if (!usec_to_msec(&min, &max, &mean, &dev)) base = "(msec)"; - minp = num2str(min, 6, 1, 0); - maxp = num2str(max, 6, 1, 0); + minp = num2str(min, 6, 1, 0, 0); + maxp = num2str(max, 6, 1, 0, 0); log_info(" %s %s: min=%s, max=%s, avg=%5.02f," " stdev=%5.02f\n", name, base, minp, maxp, mean, dev); @@ -356,7 +363,7 @@ static void display_lat(const char *name, unsigned long min, unsigned long max, static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts, int ddir) { - const char *ddir_str[] = { "read ", "write", "trim" }; + const char *str[] = { "read ", "write", "trim" }; unsigned long min, max, runt; unsigned long long bw, iops; double mean, dev; @@ -372,15 +379,16 @@ 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], 6, 1, i2p); - bw_p = num2str(bw, 6, 1, i2p); + io_p = num2str(ts->io_bytes[ddir], 6, 1, i2p, 8); + bw_p = num2str(bw, 6, 1, i2p, ts->unit_base); iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt; - iops_p = num2str(iops, 6, 1, 0); + iops_p = num2str(iops, 6, 1, 0, 0); - log_info(" %s: io=%sB, bw=%sB/s, iops=%s, runt=%6llumsec\n", - ddir_str[ddir], io_p, bw_p, iops_p, - ts->runtime[ddir]); + log_info(" %s: io=%s, bw=%s/s, iops=%s, runt=%6llumsec\n", + rs->unified_rw_rep ? "mixed" : str[ddir], + io_p, bw_p, iops_p, + (unsigned long long) ts->runtime[ddir]); free(io_p); free(bw_p); @@ -396,11 +404,19 @@ static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts, if (ts->clat_percentiles) { show_clat_percentiles(ts->io_u_plat[ddir], ts->clat_stat[ddir].samples, - ts->percentile_list); + ts->percentile_list, + ts->percentile_precision); } if (calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev)) { - double p_of_agg = 100.0; - const char *bw_str = "KB"; + double p_of_agg = 100.0, fkb_base = (double)rs->kb_base; + const char *bw_str = (rs->unit_base == 1 ? "Kbit" : "KB"); + + if (rs->unit_base == 1) { + min *= 8.0; + max *= 8.0; + mean *= 8.0; + dev *= 8.0; + } if (rs->agg[ddir]) { p_of_agg = mean * 100 / (double) rs->agg[ddir]; @@ -408,15 +424,15 @@ static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts, p_of_agg = 100.0; } - if (mean > 999999.9) { - min /= 1000.0; - max /= 1000.0; - mean /= 1000.0; - dev /= 1000.0; - bw_str = "MB"; + if (mean > fkb_base * fkb_base) { + min /= fkb_base; + max /= fkb_base; + mean /= fkb_base; + dev /= fkb_base; + bw_str = (rs->unit_base == 1 ? "Mbit" : "MB"); } - log_info(" bw (%s/s) : min=%5lu, max=%5lu, per=%3.2f%%," + log_info(" bw (%-4s/s): min=%5lu, max=%5lu, per=%3.2f%%," " avg=%5.02f, stdev=%5.02f\n", bw_str, min, max, p_of_agg, mean, dev); } @@ -481,21 +497,20 @@ static void show_latencies(struct thread_stat *ts) show_lat_m(io_u_lat_m); } -void show_thread_status(struct thread_stat *ts, struct group_run_stats *rs) +static void show_thread_status_normal(struct thread_stat *ts, + struct group_run_stats *rs) { double usr_cpu, sys_cpu; unsigned long runtime; double io_u_dist[FIO_IO_U_MAP_NR]; time_t time_p; - char time_buf[64]; + char time_buf[32]; - if (!(ts->io_bytes[DDIR_READ] + ts->io_bytes[DDIR_WRITE] + - ts->io_bytes[DDIR_TRIM]) && !(ts->total_io_u[DDIR_READ] + - ts->total_io_u[DDIR_WRITE] + ts->total_io_u[DDIR_TRIM])) + if (!ddir_rw_sum(ts->io_bytes) && !ddir_rw_sum(ts->total_io_u)) return; time(&time_p); - ctime_r((const time_t *) &time_p, time_buf); + os_ctime_r((const time_t *) &time_p, time_buf, sizeof(time_buf)); if (!ts->error) { log_info("%s: (groupid=%d, jobs=%d): err=%2d: pid=%d: %s", @@ -531,8 +546,11 @@ void show_thread_status(struct thread_stat *ts, struct group_run_stats *rs) sys_cpu = 0; } - log_info(" cpu : usr=%3.2f%%, sys=%3.2f%%, ctx=%lu, majf=%lu," - " minf=%lu\n", usr_cpu, sys_cpu, ts->ctx, ts->majf, ts->minf); + log_info(" cpu : usr=%3.2f%%, sys=%3.2f%%, ctx=%llu," + " majf=%llu, minf=%llu\n", usr_cpu, sys_cpu, + (unsigned long long) ts->ctx, + (unsigned long long) ts->majf, + (unsigned long long) ts->minf); stat_calc_dist(ts->io_u_map, ddir_rw_sum(ts->total_io_u), io_u_dist); log_info(" IO depths : 1=%3.1f%%, 2=%3.1f%%, 4=%3.1f%%, 8=%3.1f%%," @@ -553,18 +571,31 @@ void show_thread_status(struct thread_stat *ts, struct group_run_stats *rs) io_u_dist[1], io_u_dist[2], io_u_dist[3], io_u_dist[4], io_u_dist[5], io_u_dist[6]); - log_info(" issued : total=r=%lu/w=%lu/d=%lu," - " short=r=%lu/w=%lu/d=%lu\n", - ts->total_io_u[0], ts->total_io_u[1], - ts->total_io_u[2], - ts->short_io_u[0], ts->short_io_u[1], - ts->short_io_u[2]); + log_info(" issued : total=r=%llu/w=%llu/d=%llu," + " short=r=%llu/w=%llu/d=%llu," + " drop=r=%llu/w=%llu/d=%llu\n", + (unsigned long long) ts->total_io_u[0], + (unsigned long long) ts->total_io_u[1], + (unsigned long long) ts->total_io_u[2], + (unsigned long long) ts->short_io_u[0], + (unsigned long long) ts->short_io_u[1], + (unsigned long long) ts->short_io_u[2], + (unsigned long long) ts->drop_io_u[0], + (unsigned long long) ts->drop_io_u[1], + (unsigned long long) ts->drop_io_u[2]); if (ts->continue_on_error) { - log_info(" errors : total=%lu, first_error=%d/<%s>\n", - ts->total_err_count, + log_info(" errors : total=%llu, first_error=%d/<%s>\n", + (unsigned long long)ts->total_err_count, ts->first_error, strerror(ts->first_error)); } + if (ts->latency_depth) { + log_info(" latency : target=%llu, window=%llu, percentile=%.2f%%, depth=%u\n", + (unsigned long long)ts->latency_target, + (unsigned long long)ts->latency_window, + ts->latency_percentile.u.f, + ts->latency_depth); + } } static void show_ddir_status_terse(struct thread_stat *ts, @@ -587,8 +618,9 @@ static void show_ddir_status_terse(struct thread_stat *ts, iops = (1000 * (uint64_t) ts->total_io_u[ddir]) / runt; } - log_info(";%llu;%llu;%llu;%llu", ts->io_bytes[ddir] >> 10, bw, iops, - ts->runtime[ddir]); + log_info(";%llu;%llu;%llu;%llu", + (unsigned long long) ts->io_bytes[ddir] >> 10, bw, iops, + (unsigned long long) ts->runtime[ddir]); if (calc_lat(&ts->slat_stat[ddir], &min, &max, &mean, &dev)) log_info(";%lu;%lu;%f;%f", min, max, mean, dev); @@ -613,7 +645,7 @@ static void show_ddir_status_terse(struct thread_stat *ts, log_info(";0%%=0"); continue; } - log_info(";%2.2f%%=%u", ts->percentile_list[i].u.f, ovals[i]); + log_info(";%f%%=%u", ts->percentile_list[i].u.f, ovals[i]); } if (calc_lat(&ts->lat_stat[ddir], &min, &max, &mean, &dev)) @@ -642,9 +674,9 @@ 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, iops; + unsigned long long bw; unsigned int *ovals = NULL; - double mean, dev; + double mean, dev, iops; unsigned int len, minv, maxv; int i; const char *ddirname[] = {"read", "write", "trim"}; @@ -654,21 +686,29 @@ static void add_ddir_status_json(struct thread_stat *ts, assert(ddir_rw(ddir)); + if (ts->unified_rw_rep && ddir != DDIR_READ) + return; + dir_object = json_create_object(); - json_object_add_value_object(parent, ddirname[ddir], dir_object); + json_object_add_value_object(parent, + ts->unified_rw_rep ? "mixed" : ddirname[ddir], dir_object); - iops = bw = 0; + bw = 0; + iops = 0.0; if (ts->runtime[ddir]) { uint64_t runt = ts->runtime[ddir]; bw = ((1000 * ts->io_bytes[ddir]) / runt) / 1024; - iops = (1000 * (uint64_t) ts->total_io_u[ddir]) / runt; + 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, "bw", bw); - json_object_add_value_int(dir_object, "iops", iops); + json_object_add_value_float(dir_object, "iops", iops); json_object_add_value_int(dir_object, "runtime", ts->runtime[ddir]); + json_object_add_value_int(dir_object, "total_ios", ts->total_io_u[ddir]); + json_object_add_value_int(dir_object, "short_ios", ts->short_io_u[ddir]); + json_object_add_value_int(dir_object, "drop_ios", ts->drop_io_u[ddir]); if (!calc_lat(&ts->slat_stat[ddir], &min, &max, &mean, &dev)) { min = max = 0; @@ -707,7 +747,7 @@ static void add_ddir_status_json(struct thread_stat *ts, json_object_add_value_int(percentile_object, "0.00", 0); continue; } - snprintf(buf, sizeof(buf) - 1, "%2.2f", ts->percentile_list[i].u.f); + snprintf(buf, sizeof(buf), "%f", ts->percentile_list[i].u.f); json_object_add_value_int(percentile_object, (const char *)buf, ovals[i]); } @@ -724,7 +764,7 @@ static void add_ddir_status_json(struct thread_stat *ts, if (ovals) free(ovals); - if (!calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev)) { + if (calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev)) { if (rs->agg[ddir]) { p_of_agg = mean * 100 / (double) rs->agg[ddir]; if (p_of_agg > 100.0) @@ -736,7 +776,7 @@ static void add_ddir_status_json(struct thread_stat *ts, } json_object_add_value_int(dir_object, "bw_min", min); json_object_add_value_int(dir_object, "bw_max", max); - json_object_add_value_float(dir_object, "bw_agg", mean); + 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); } @@ -770,8 +810,10 @@ static void show_thread_status_terse_v2(struct thread_stat *ts, sys_cpu = 0; } - log_info(";%f%%;%f%%;%lu;%lu;%lu", usr_cpu, sys_cpu, ts->ctx, ts->majf, - ts->minf); + log_info(";%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); @@ -791,11 +833,11 @@ static void show_thread_status_terse_v2(struct thread_stat *ts, log_info(";%3.2f%%", io_u_lat_m[i]); /* Additional output if continue_on_error set - default off*/ if (ts->continue_on_error) - log_info(";%lu;%d", ts->total_err_count, ts->first_error); + log_info(";%llu;%d", (unsigned long long) ts->total_err_count, ts->first_error); log_info("\n"); /* Additional output if description is set */ - if (ts->description) + if (strlen(ts->description)) log_info(";%s", ts->description); log_info("\n"); @@ -832,8 +874,10 @@ static void show_thread_status_terse_v3_v4(struct thread_stat *ts, sys_cpu = 0; } - log_info(";%f%%;%f%%;%lu;%lu;%lu", usr_cpu, sys_cpu, ts->ctx, ts->majf, - ts->minf); + log_info(";%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); @@ -857,7 +901,7 @@ static void show_thread_status_terse_v3_v4(struct thread_stat *ts, /* Additional output if continue_on_error set - default off*/ if (ts->continue_on_error) - log_info(";%lu;%d", ts->total_err_count, ts->first_error); + log_info(";%llu;%d", (unsigned long long) ts->total_err_count, ts->first_error); /* Additional output if description is set */ if (strlen(ts->description)) @@ -913,9 +957,9 @@ static struct json_object *show_thread_status_json(struct thread_stat *ts, for (i = 0; i < 7; i++) { char name[20]; if (i < 6) - snprintf(name, 19, "%d", 1 << i); + snprintf(name, 20, "%d", 1 << i); else - snprintf(name, 19, ">=%d", 1 << i); + snprintf(name, 20, ">=%d", 1 << i); json_object_add_value_float(tmp, (const char *)name, io_u_dist[i]); } @@ -940,7 +984,14 @@ static struct json_object *show_thread_status_json(struct thread_stat *ts, /* Additional output if continue_on_error set - default off*/ if (ts->continue_on_error) { json_object_add_value_int(root, "total_err", ts->total_err_count); - json_object_add_value_int(root, "total_err", ts->first_error); + json_object_add_value_int(root, "first_error", ts->first_error); + } + + if (ts->latency_depth) { + json_object_add_value_int(root, "latency_depth", ts->latency_depth); + json_object_add_value_int(root, "latency_target", ts->latency_target); + json_object_add_value_float(root, "latency_percentile", ts->latency_percentile.u.f); + json_object_add_value_int(root, "latency_window", ts->latency_window); } /* Additional output if description is set */ @@ -961,6 +1012,18 @@ static void show_thread_status_terse(struct thread_stat *ts, log_err("fio: bad terse version!? %d\n", terse_version); } +struct json_object *show_thread_status(struct thread_stat *ts, + struct group_run_stats *rs) +{ + if (output_format == FIO_OUTPUT_TERSE) + show_thread_status_terse(ts, rs); + else if (output_format == FIO_OUTPUT_JSON) + return show_thread_status_json(ts, rs); + else + show_thread_status_normal(ts, rs); + return NULL; +} + static void sum_stat(struct io_stat *dst, struct io_stat *src, int nr) { double mean, S; @@ -1014,6 +1077,10 @@ void sum_group_stats(struct group_run_stats *dst, struct group_run_stats *src) dst->agg[i] += src->agg[i]; } + if (!dst->kb_base) + dst->kb_base = src->kb_base; + if (!dst->unit_base) + dst->unit_base = src->unit_base; } void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src, int nr) @@ -1021,15 +1088,27 @@ void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src, int nr) int l, k; for (l = 0; l < DDIR_RWDIR_CNT; l++) { - sum_stat(&dst->clat_stat[l], &src->clat_stat[l], nr); - sum_stat(&dst->slat_stat[l], &src->slat_stat[l], nr); - sum_stat(&dst->lat_stat[l], &src->lat_stat[l], nr); - sum_stat(&dst->bw_stat[l], &src->bw_stat[l], nr); - - dst->io_bytes[l] += src->io_bytes[l]; - - if (dst->runtime[l] < src->runtime[l]) - dst->runtime[l] = src->runtime[l]; + if (!dst->unified_rw_rep) { + sum_stat(&dst->clat_stat[l], &src->clat_stat[l], nr); + sum_stat(&dst->slat_stat[l], &src->slat_stat[l], nr); + sum_stat(&dst->lat_stat[l], &src->lat_stat[l], nr); + sum_stat(&dst->bw_stat[l], &src->bw_stat[l], nr); + + dst->io_bytes[l] += src->io_bytes[l]; + + if (dst->runtime[l] < src->runtime[l]) + dst->runtime[l] = src->runtime[l]; + } else { + sum_stat(&dst->clat_stat[0], &src->clat_stat[l], nr); + sum_stat(&dst->slat_stat[0], &src->slat_stat[l], nr); + sum_stat(&dst->lat_stat[0], &src->lat_stat[l], nr); + sum_stat(&dst->bw_stat[0], &src->bw_stat[l], nr); + + dst->io_bytes[0] += src->io_bytes[l]; + + if (dst->runtime[0] < src->runtime[l]) + dst->runtime[0] = src->runtime[l]; + } } dst->usr_time += src->usr_time; @@ -1050,14 +1129,26 @@ void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src, int nr) dst->io_u_lat_m[k] += src->io_u_lat_m[k]; for (k = 0; k < DDIR_RWDIR_CNT; k++) { - dst->total_io_u[k] += src->total_io_u[k]; - dst->short_io_u[k] += src->short_io_u[k]; + if (!dst->unified_rw_rep) { + dst->total_io_u[k] += src->total_io_u[k]; + dst->short_io_u[k] += src->short_io_u[k]; + dst->drop_io_u[k] += src->drop_io_u[k]; + } else { + dst->total_io_u[0] += src->total_io_u[k]; + dst->short_io_u[0] += src->short_io_u[k]; + dst->drop_io_u[0] += src->drop_io_u[k]; + } } for (k = 0; k < DDIR_RWDIR_CNT; k++) { int m; - for (m = 0; m < FIO_IO_U_PLAT_NR; m++) - dst->io_u_plat[k][m] += src->io_u_plat[k][m]; + + for (m = 0; m < FIO_IO_U_PLAT_NR; m++) { + if (!dst->unified_rw_rep) + dst->io_u_plat[k][m] += src->io_u_plat[k][m]; + else + dst->io_u_plat[0][m] += src->io_u_plat[k][m]; + } } dst->total_run_time += src->total_run_time; @@ -1089,16 +1180,16 @@ void init_thread_stat(struct thread_stat *ts) ts->groupid = -1; } -void show_run_stats(void) +void __show_run_stats(void) { struct group_run_stats *runstats, *rs; struct thread_data *td; struct thread_stat *threadstats, *ts; int i, j, nr_ts, last_ts, idx; int kb_base_warned = 0; + int unit_base_warned = 0; struct json_object *root = NULL; struct json_array *array = NULL; - runstats = malloc(sizeof(struct group_run_stats) * (groupid + 1)); for (i = 0; i < groupid + 1; i++) @@ -1142,10 +1233,8 @@ void show_run_stats(void) ts = &threadstats[j]; ts->clat_percentiles = td->o.clat_percentiles; - if (td->o.overwrite_plist) - memcpy(ts->percentile_list, td->o.percentile_list, sizeof(td->o.percentile_list)); - else - memcpy(ts->percentile_list, def_percentile_list, sizeof(def_percentile_list)); + ts->percentile_precision = td->o.percentile_precision; + memcpy(ts->percentile_list, td->o.percentile_list, sizeof(td->o.percentile_list)); idx++; ts->members++; @@ -1154,12 +1243,12 @@ void show_run_stats(void) /* * These are per-group shared already */ - strncpy(ts->name, td->o.name, FIO_JOBNAME_SIZE); + strncpy(ts->name, td->o.name, FIO_JOBNAME_SIZE - 1); if (td->o.description) strncpy(ts->description, td->o.description, - FIO_JOBNAME_SIZE); + FIO_JOBDESC_SIZE - 1); else - memset(ts->description, 0, FIO_JOBNAME_SIZE); + memset(ts->description, 0, FIO_JOBDESC_SIZE); /* * If multiple entries in this group, this is @@ -1174,10 +1263,16 @@ void show_run_stats(void) ts->pid = td->pid; ts->kb_base = td->o.kb_base; + ts->unit_base = td->o.unit_base; + 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; + } 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; } ts->continue_on_error = td->o.continue_on_error; @@ -1187,13 +1282,24 @@ void show_run_stats(void) if (!td->error && td->o.continue_on_error && td->first_error) { ts->error = td->first_error; - strcpy(ts->verror, td->verror); + ts->verror[sizeof(ts->verror) - 1] = '\0'; + strncpy(ts->verror, td->verror, sizeof(ts->verror) - 1); } else if (td->error) { ts->error = td->error; - strcpy(ts->verror, td->verror); + ts->verror[sizeof(ts->verror) - 1] = '\0'; + strncpy(ts->verror, td->verror, sizeof(ts->verror) - 1); } } + ts->latency_depth = td->latency_qd; + ts->latency_target = td->o.latency_target; + ts->latency_percentile = td->o.latency_percentile; + ts->latency_window = td->o.latency_window; + + ts->nr_block_infos = td->ts.nr_block_infos; + for (i = 0; i < ts->nr_block_infos; i++) + ts->block_infos[i] = td->ts.block_infos[i]; + sum_thread_stats(ts, &td->ts, idx); } @@ -1203,6 +1309,8 @@ void show_run_stats(void) ts = &threadstats[i]; rs = &runstats[ts->groupid]; rs->kb_base = ts->kb_base; + rs->unit_base = ts->unit_base; + rs->unified_rw_rep += ts->unified_rw_rep; for (j = 0; j < DDIR_RWDIR_CNT; j++) { if (!ts->runtime[j]) @@ -1247,8 +1355,18 @@ void show_run_stats(void) if (output_format == FIO_OUTPUT_NORMAL) log_info("\n"); else if (output_format == FIO_OUTPUT_JSON) { + char time_buf[32]; + time_t time_p; + + time(&time_p); + os_ctime_r((const time_t *) &time_p, time_buf, + sizeof(time_buf)); + time_buf[strlen(time_buf) - 1] = '\0'; + root = json_create_object(); json_object_add_value_string(root, "fio version", fio_version_string); + json_object_add_value_int(root, "timestamp", time_p); + json_object_add_value_string(root, "time", time_buf); array = json_create_array(); json_object_add_value_array(root, "jobs", array); } @@ -1265,12 +1383,14 @@ void show_run_stats(void) struct json_object *tmp = show_thread_status_json(ts, rs); json_array_add_value_object(array, tmp); } else - show_thread_status(ts, rs); + show_thread_status_normal(ts, rs); } if (output_format == FIO_OUTPUT_JSON) { /* disk util stats, if any */ show_disk_util(1, root); + show_idle_prof_stats(FIO_OUTPUT_JSON, root); + json_print_object(root); log_info("\n"); json_free_object(root); @@ -1288,20 +1408,42 @@ void show_run_stats(void) if (is_backend) fio_server_send_du(); - else if (output_format == FIO_OUTPUT_NORMAL) + else if (output_format == FIO_OUTPUT_NORMAL) { show_disk_util(0, NULL); + show_idle_prof_stats(FIO_OUTPUT_NORMAL, NULL); + } + + if ( !(output_format == FIO_OUTPUT_TERSE) && append_terse_output) { + log_info("\nAdditional Terse Output:\n"); + + for (i = 0; i < nr_ts; i++) { + ts = &threadstats[i]; + rs = &runstats[ts->groupid]; + show_thread_status_terse(ts, rs); + } + } + log_info_flush(); free(runstats); free(threadstats); } -static void *__show_running_run_stats(void *arg) +void show_run_stats(void) +{ + fio_mutex_down(stat_mutex); + __show_run_stats(); + fio_mutex_up(stat_mutex); +} + +void __show_running_run_stats(void) { struct thread_data *td; unsigned long long *rt; struct timeval tv; int i; + fio_mutex_down(stat_mutex); + rt = malloc(thread_number * sizeof(unsigned long long)); fio_gettime(&tv, NULL); @@ -1314,14 +1456,24 @@ static void *__show_running_run_stats(void *arg) if (td_trim(td) && td->io_bytes[DDIR_TRIM]) td->ts.runtime[DDIR_TRIM] += rt[i]; - update_rusage_stat(td); + 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); } - show_run_stats(); + for_each_td(td, i) { + if (td->runstate >= TD_EXITED) + continue; + if (td->rusage_sem) { + td->update_rusage = 1; + fio_mutex_down(td->rusage_sem); + } + td->update_rusage = 0; + } + + __show_run_stats(); for_each_td(td, i) { if (td_read(td) && td->io_bytes[DDIR_READ]) @@ -1333,20 +1485,64 @@ static void *__show_running_run_stats(void *arg) } free(rt); - return NULL; + fio_mutex_up(stat_mutex); } -/* - * Called from signal handler. It _should_ be safe to just run this inline - * in the sig handler, but we should be disturbing the system less by just - * creating a thread to do it. - */ -void show_running_run_stats(void) +static int status_interval_init; +static struct timeval status_time; +static int status_file_disabled; + +#define FIO_STATUS_FILE "fio-dump-status" + +static int check_status_file(void) { - pthread_t thread; + struct stat sb; + const char *temp_dir; + char fio_status_file_path[PATH_MAX]; + + if (status_file_disabled) + return 0; + + temp_dir = getenv("TMPDIR"); + if (temp_dir == NULL) { + temp_dir = getenv("TEMP"); + if (temp_dir && strlen(temp_dir) >= PATH_MAX) + temp_dir = NULL; + } + if (temp_dir == NULL) + temp_dir = "/tmp"; + + snprintf(fio_status_file_path, sizeof(fio_status_file_path), "%s/%s", temp_dir, FIO_STATUS_FILE); + + if (stat(fio_status_file_path, &sb)) + return 0; + + if (unlink(fio_status_file_path) < 0) { + 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; + } + + return 1; +} - pthread_create(&thread, NULL, __show_running_run_stats, NULL); - pthread_detach(thread); +void check_for_running_stats(void) +{ + if (status_interval) { + if (!status_interval_init) { + fio_gettime(&status_time, NULL); + status_interval_init = 1; + } else if (mtime_since_now(&status_time) >= status_interval) { + show_running_run_stats(); + fio_gettime(&status_time, NULL); + return; + } + } + if (check_status_file()) { + show_running_run_stats(); + return; + } } static inline void add_stat_sample(struct io_stat *is, unsigned long data) @@ -1370,24 +1566,55 @@ static inline void add_stat_sample(struct io_stat *is, unsigned long data) static void __add_log_sample(struct io_log *iolog, unsigned long val, enum fio_ddir ddir, unsigned int bs, - unsigned long t) + unsigned long t, uint64_t offset) { - const int nr_samples = iolog->nr_samples; + uint64_t nr_samples = iolog->nr_samples; + struct io_sample *s; + + if (iolog->disabled) + return; if (!iolog->nr_samples) iolog->avg_last = t; if (iolog->nr_samples == iolog->max_samples) { - int new_size = sizeof(struct io_sample) * iolog->max_samples*2; + size_t new_size; + void *new_log; + + new_size = 2 * iolog->max_samples * log_entry_sz(iolog); + + if (iolog->log_gz && (new_size > iolog->log_gz)) { + if (iolog_flush(iolog, 0)) { + log_err("fio: failed flushing iolog! Will stop logging.\n"); + iolog->disabled = 1; + return; + } + nr_samples = iolog->nr_samples; + } else { + new_log = realloc(iolog->log, new_size); + if (!new_log) { + log_err("fio: failed extending iolog! Will stop logging.\n"); + iolog->disabled = 1; + return; + } + iolog->log = new_log; + iolog->max_samples <<= 1; + } + } + + s = get_sample(iolog, nr_samples); + + s->val = val; + s->time = t; + io_sample_set_ddir(iolog, s, ddir); + s->bs = bs; + + if (iolog->log_offset) { + struct io_sample_offset *so = (void *) s; - iolog->log = realloc(iolog->log, new_size); - iolog->max_samples <<= 1; + so->offset = offset; } - iolog->log[nr_samples].val = val; - iolog->log[nr_samples].time = t; - iolog->log[nr_samples].ddir = ddir; - iolog->log[nr_samples].bs = bs; iolog->nr_samples++; } @@ -1397,9 +1624,76 @@ static inline void reset_io_stat(struct io_stat *ios) ios->mean.u.f = ios->S.u.f = 0; } +void reset_io_stats(struct thread_data *td) +{ + struct thread_stat *ts = &td->ts; + int i, j; + + for (i = 0; i < DDIR_RWDIR_CNT; i++) { + reset_io_stat(&ts->clat_stat[i]); + reset_io_stat(&ts->slat_stat[i]); + reset_io_stat(&ts->lat_stat[i]); + reset_io_stat(&ts->bw_stat[i]); + reset_io_stat(&ts->iops_stat[i]); + + ts->io_bytes[i] = 0; + ts->runtime[i] = 0; + + for (j = 0; j < FIO_IO_U_PLAT_NR; j++) + ts->io_u_plat[i][j] = 0; + } + + for (i = 0; i < FIO_IO_U_MAP_NR; i++) { + ts->io_u_map[i] = 0; + ts->io_u_submit[i] = 0; + ts->io_u_complete[i] = 0; + ts->io_u_lat_u[i] = 0; + ts->io_u_lat_m[i] = 0; + ts->total_submit = 0; + ts->total_complete = 0; + } + + for (i = 0; i < 3; i++) { + ts->total_io_u[i] = 0; + ts->short_io_u[i] = 0; + ts->drop_io_u[i] = 0; + } +} + +static void _add_stat_to_log(struct io_log *iolog, unsigned long elapsed) +{ + /* + * Note an entry in the log. Use the mean from the logged samples, + * making sure to properly round up. Only write a log entry if we + * had actual samples done. + */ + if (iolog->avg_window[DDIR_READ].samples) { + unsigned long mr; + + mr = iolog->avg_window[DDIR_READ].mean.u.f + 0.50; + __add_log_sample(iolog, mr, DDIR_READ, 0, elapsed, 0); + } + if (iolog->avg_window[DDIR_WRITE].samples) { + unsigned long mw; + + mw = iolog->avg_window[DDIR_WRITE].mean.u.f + 0.50; + __add_log_sample(iolog, mw, DDIR_WRITE, 0, elapsed, 0); + } + if (iolog->avg_window[DDIR_TRIM].samples) { + unsigned long mw; + + mw = iolog->avg_window[DDIR_TRIM].mean.u.f + 0.50; + __add_log_sample(iolog, mw, DDIR_TRIM, 0, elapsed, 0); + } + + reset_io_stat(&iolog->avg_window[DDIR_READ]); + reset_io_stat(&iolog->avg_window[DDIR_WRITE]); + reset_io_stat(&iolog->avg_window[DDIR_TRIM]); +} + static void add_log_sample(struct thread_data *td, struct io_log *iolog, unsigned long val, enum fio_ddir ddir, - unsigned int bs) + unsigned int bs, uint64_t offset) { unsigned long elapsed, this_window; @@ -1412,7 +1706,7 @@ static void add_log_sample(struct thread_data *td, struct io_log *iolog, * If no time averaging, just add the log sample. */ if (!iolog->avg_msec) { - __add_log_sample(iolog, val, ddir, bs, elapsed); + __add_log_sample(iolog, val, ddir, bs, elapsed, offset); return; } @@ -1430,35 +1724,27 @@ static void add_log_sample(struct thread_data *td, struct io_log *iolog, if (this_window < iolog->avg_msec) return; - /* - * Note an entry in the log. Use the mean from the logged samples, - * making sure to properly round up. Only write a log entry if we - * had actual samples done. - */ - if (iolog->avg_window[DDIR_READ].samples) { - unsigned long mr; - - mr = iolog->avg_window[DDIR_READ].mean.u.f + 0.50; - __add_log_sample(iolog, mr, DDIR_READ, 0, elapsed); - } - if (iolog->avg_window[DDIR_WRITE].samples) { - unsigned long mw; + _add_stat_to_log(iolog, elapsed); - mw = iolog->avg_window[DDIR_WRITE].mean.u.f + 0.50; - __add_log_sample(iolog, mw, DDIR_WRITE, 0, elapsed); - } - if (iolog->avg_window[DDIR_TRIM].samples) { - unsigned long mw; + iolog->avg_last = elapsed; +} - mw = iolog->avg_window[DDIR_TRIM].mean.u.f + 0.50; - __add_log_sample(iolog, mw, DDIR_TRIM, 0, elapsed); - } +void finalize_logs(struct thread_data *td) +{ + unsigned long elapsed; + elapsed = mtime_since_now(&td->epoch); - reset_io_stat(&iolog->avg_window[DDIR_READ]); - reset_io_stat(&iolog->avg_window[DDIR_WRITE]); - reset_io_stat(&iolog->avg_window[DDIR_TRIM]); - iolog->avg_last = elapsed; + if (td->clat_log) + _add_stat_to_log(td->clat_log, elapsed); + if (td->slat_log) + _add_stat_to_log(td->slat_log, elapsed); + if (td->lat_log) + _add_stat_to_log(td->lat_log, elapsed); + if (td->bw_log) + _add_stat_to_log(td->bw_log, elapsed); + if (td->iops_log) + _add_stat_to_log(td->iops_log, elapsed); } void add_agg_sample(unsigned long val, enum fio_ddir ddir, unsigned int bs) @@ -1469,7 +1755,7 @@ void add_agg_sample(unsigned long val, enum fio_ddir ddir, unsigned int bs) return; iolog = agg_io_log[ddir]; - __add_log_sample(iolog, val, ddir, bs, mtime_since_genesis()); + __add_log_sample(iolog, val, ddir, bs, mtime_since_genesis(), 0); } static void add_clat_percentile_sample(struct thread_stat *ts, @@ -1482,7 +1768,7 @@ static void add_clat_percentile_sample(struct thread_stat *ts, } void add_clat_sample(struct thread_data *td, enum fio_ddir ddir, - unsigned long usec, unsigned int bs) + unsigned long usec, unsigned int bs, uint64_t offset) { struct thread_stat *ts = &td->ts; @@ -1492,14 +1778,14 @@ void add_clat_sample(struct thread_data *td, enum fio_ddir ddir, add_stat_sample(&ts->clat_stat[ddir], usec); if (td->clat_log) - add_log_sample(td, td->clat_log, usec, ddir, bs); + add_log_sample(td, td->clat_log, usec, ddir, bs, offset); if (ts->clat_percentiles) add_clat_percentile_sample(ts, usec, ddir); } void add_slat_sample(struct thread_data *td, enum fio_ddir ddir, - unsigned long usec, unsigned int bs) + unsigned long usec, unsigned int bs, uint64_t offset) { struct thread_stat *ts = &td->ts; @@ -1509,11 +1795,11 @@ void add_slat_sample(struct thread_data *td, enum fio_ddir ddir, add_stat_sample(&ts->slat_stat[ddir], usec); if (td->slat_log) - add_log_sample(td, td->slat_log, usec, ddir, bs); + add_log_sample(td, td->slat_log, usec, ddir, bs, offset); } void add_lat_sample(struct thread_data *td, enum fio_ddir ddir, - unsigned long usec, unsigned int bs) + unsigned long usec, unsigned int bs, uint64_t offset) { struct thread_stat *ts = &td->ts; @@ -1523,7 +1809,7 @@ void add_lat_sample(struct thread_data *td, enum fio_ddir ddir, add_stat_sample(&ts->lat_stat[ddir], usec); if (td->lat_log) - add_log_sample(td, td->lat_log, usec, ddir, bs); + add_log_sample(td, td->lat_log, usec, ddir, bs, offset); } void add_bw_sample(struct thread_data *td, enum fio_ddir ddir, unsigned int bs, @@ -1549,11 +1835,15 @@ void add_bw_sample(struct thread_data *td, enum fio_ddir ddir, unsigned int bs, if (!delta) continue; /* No entries for interval */ - rate = delta * 1000 / spent / 1024; + if (spent) + rate = delta * 1000 / spent / 1024; + else + rate = 0; + add_stat_sample(&ts->bw_stat[ddir], rate); if (td->bw_log) - add_log_sample(td, td->bw_log, rate, ddir, bs); + add_log_sample(td, td->bw_log, rate, ddir, bs, 0); td->stat_io_bytes[ddir] = td->this_io_bytes[ddir]; } @@ -1561,7 +1851,7 @@ void add_bw_sample(struct thread_data *td, enum fio_ddir ddir, unsigned int bs, fio_gettime(&td->bw_sample_time, NULL); } -void add_iops_sample(struct thread_data *td, enum fio_ddir ddir, +void add_iops_sample(struct thread_data *td, enum fio_ddir ddir, unsigned int bs, struct timeval *t) { struct thread_stat *ts = &td->ts; @@ -1584,14 +1874,42 @@ void add_iops_sample(struct thread_data *td, enum fio_ddir ddir, if (!delta) continue; /* No entries for interval */ - iops = (delta * 1000) / spent; + if (spent) + iops = (delta * 1000) / spent; + else + iops = 0; + add_stat_sample(&ts->iops_stat[ddir], iops); if (td->iops_log) - add_log_sample(td, td->iops_log, iops, ddir, 0); + add_log_sample(td, td->iops_log, iops, ddir, bs, 0); td->stat_io_blocks[ddir] = td->this_io_blocks[ddir]; } fio_gettime(&td->iops_sample_time, NULL); } + +void stat_init(void) +{ + stat_mutex = fio_mutex_init(FIO_MUTEX_UNLOCKED); +} + +void stat_exit(void) +{ + /* + * When we have the mutex, we know out-of-band access to it + * have ended. + */ + fio_mutex_down(stat_mutex); + fio_mutex_remove(stat_mutex); +} + +/* + * Called from signal handler. Wake up status thread. + */ +void show_running_run_stats(void) +{ + helper_do_stat = 1; + pthread_cond_signal(&helper_cond); +}