X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=stat.c;h=7c843e6b1423497ba3b0bf6b44227285d9c1e6c7;hp=82e79dfcf1885b7cbcf3e2ad1212be29e79877c2;hb=5d89c625949d8d4ae4abaefbc77b90d79cc8d09a;hpb=0aa8371d9fc40121098929a7f670dcdd259b8eee diff --git a/stat.c b/stat.c index 82e79dfc..7c843e6b 100644 --- a/stat.c +++ b/stat.c @@ -14,6 +14,7 @@ #include "lib/output_buffer.h" #include "helper_thread.h" #include "smalloc.h" +#include "zbd.h" #define LOG_MSEC_SLACK 1 @@ -138,7 +139,6 @@ unsigned int calc_clat_percentiles(uint64_t *io_u_plat, unsigned long long nr, { unsigned long long sum = 0; unsigned int len, i, j = 0; - unsigned int oval_len = 0; unsigned long long *ovals = NULL; bool is_last; @@ -160,6 +160,10 @@ unsigned int calc_clat_percentiles(uint64_t *io_u_plat, unsigned long long nr, if (len > 1) qsort((void *)plist, len, sizeof(plist[0]), double_cmp); + ovals = malloc(len * sizeof(*ovals)); + if (!ovals) + return 0; + /* * Calculate bucket values, note down max and min values */ @@ -169,11 +173,6 @@ unsigned int calc_clat_percentiles(uint64_t *io_u_plat, unsigned long long nr, while (sum >= (plist[j].u.f / 100.0 * nr)) { assert(plist[j].u.f <= 100.0); - if (j == oval_len) { - oval_len += 100; - ovals = realloc(ovals, oval_len * sizeof(*ovals)); - } - ovals[j] = plat_idx_to_val(i); if (ovals[j] < *minv) *minv = ovals[j]; @@ -415,22 +414,21 @@ static void display_lat(const char *name, unsigned long long min, 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", "sync" }; unsigned long runt; unsigned long long min, max, bw, iops; double mean, dev; - char *io_p, *bw_p, *bw_p_alt, *iops_p; + char *io_p, *bw_p, *bw_p_alt, *iops_p, *post_st = NULL; int i2p; if (ddir_sync(ddir)) { if (calc_lat(&ts->sync_stat, &min, &max, &mean, &dev)) { log_buf(out, " %s:\n", "fsync/fdatasync/sync_file_range"); - display_lat(str[ddir], min, max, mean, dev, out); + display_lat(io_ddir_name(ddir), min, max, mean, dev, out); show_clat_percentiles(ts->io_u_sync_plat, ts->sync_stat.samples, ts->percentile_list, ts->percentile_precision, - str[ddir], out); + io_ddir_name(ddir), out); } return; } @@ -450,12 +448,26 @@ static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts, iops = (1000 * (uint64_t)ts->total_io_u[ddir]) / runt; iops_p = num2str(iops, ts->sig_figs, 1, 0, N2S_NONE); + if (ddir == DDIR_WRITE) + post_st = zbd_write_status(ts); + else if (ddir == DDIR_READ && ts->cachehit && ts->cachemiss) { + uint64_t total; + double hit; - log_buf(out, " %s: IOPS=%s, BW=%s (%s)(%s/%llumsec)\n", - rs->unified_rw_rep ? "mixed" : str[ddir], + total = ts->cachehit + ts->cachemiss; + hit = (double) ts->cachehit / (double) total; + hit *= 100.0; + if (asprintf(&post_st, "; Cachehit=%0.2f%%", hit) < 0) + post_st = NULL; + } + + log_buf(out, " %s: IOPS=%s, BW=%s (%s)(%s/%llumsec)%s\n", + rs->unified_rw_rep ? "mixed" : io_ddir_name(ddir), iops_p, bw_p, bw_p_alt, io_p, - (unsigned long long) ts->runtime[ddir]); + (unsigned long long) ts->runtime[ddir], + post_st ? : ""); + free(post_st); free(io_p); free(bw_p); free(bw_p_alt); @@ -980,7 +992,6 @@ static void add_ddir_status_json(struct thread_stat *ts, double mean, dev, iops; unsigned int len; int i; - const char *ddirname[] = { "read", "write", "trim", "sync" }; struct json_object *dir_object, *tmp_object, *percentile_object, *clat_bins_object = NULL; char buf[120]; double p_of_agg = 100.0; @@ -992,7 +1003,7 @@ static void add_ddir_status_json(struct thread_stat *ts, dir_object = json_create_object(); json_object_add_value_object(parent, - ts->unified_rw_rep ? "mixed" : ddirname[ddir], dir_object); + ts->unified_rw_rep ? "mixed" : io_ddir_name(ddir), dir_object); if (ddir_rw(ddir)) { bw_bytes = 0; @@ -1054,10 +1065,16 @@ static void add_ddir_status_json(struct thread_stat *ts, if (ts->clat_percentiles || ts->lat_percentiles) { if (ddir_rw(ddir)) { + uint64_t samples; + + if (ts->clat_percentiles) + samples = ts->clat_stat[ddir].samples; + else + samples = ts->lat_stat[ddir].samples; + len = calc_clat_percentiles(ts->io_u_plat[ddir], - ts->clat_stat[ddir].samples, - ts->percentile_list, &ovals, &maxv, - &minv); + samples, ts->percentile_list, &ovals, + &maxv, &minv); } else { len = calc_clat_percentiles(ts->io_u_sync_plat, ts->sync_stat.samples, @@ -1144,6 +1161,16 @@ static void add_ddir_status_json(struct thread_stat *ts, json_object_add_value_float(dir_object, "iops_stddev", dev); json_object_add_value_int(dir_object, "iops_samples", (&ts->iops_stat[ddir])->samples); + + if (ts->cachehit + ts->cachemiss) { + uint64_t total; + double hit; + + total = ts->cachehit + ts->cachemiss; + hit = (double) ts->cachehit / (double) total; + hit *= 100.0; + json_object_add_value_float(dir_object, "cachehit", hit); + } } static void show_thread_status_terse_all(struct thread_stat *ts, @@ -1205,7 +1232,7 @@ static void show_thread_status_terse_all(struct thread_stat *ts, log_buf(out, ";%3.2f%%", io_u_lat_m[i]); /* disk util stats, if any */ - if (ver >= 3) + if (ver >= 3 && is_running_backend()) show_disk_util(1, NULL, out); /* Additional output if continue_on_error set - default off*/ @@ -1509,13 +1536,10 @@ struct json_object *show_thread_status(struct thread_stat *ts, return ret; } -static void sum_stat(struct io_stat *dst, struct io_stat *src, bool first) +static void __sum_stat(struct io_stat *dst, struct io_stat *src, bool first) { double mean, S; - if (src->samples == 0) - return; - dst->min_val = min(dst->min_val, src->min_val); dst->max_val = max(dst->max_val, src->max_val); @@ -1542,6 +1566,39 @@ static void sum_stat(struct io_stat *dst, struct io_stat *src, bool first) dst->samples += src->samples; dst->mean.u.f = mean; dst->S.u.f = S; + +} + +/* + * We sum two kinds of stats - one that is time based, in which case we + * apply the proper summing technique, and then one that is iops/bw + * numbers. For group_reporting, we should just add those up, not make + * them the mean of everything. + */ +static void sum_stat(struct io_stat *dst, struct io_stat *src, bool first, + bool pure_sum) +{ + if (src->samples == 0) + return; + + if (!pure_sum) { + __sum_stat(dst, src, first); + return; + } + + if (first) { + dst->min_val = src->min_val; + dst->max_val = src->max_val; + dst->samples = src->samples; + dst->mean.u.f = src->mean.u.f; + dst->S.u.f = src->S.u.f; + } else { + dst->min_val += src->min_val; + dst->max_val += src->max_val; + dst->samples += src->samples; + dst->mean.u.f += src->mean.u.f; + dst->S.u.f += src->S.u.f; + } } void sum_group_stats(struct group_run_stats *dst, struct group_run_stats *src) @@ -1577,22 +1634,22 @@ void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src, for (l = 0; l < DDIR_RWDIR_CNT; l++) { if (!dst->unified_rw_rep) { - sum_stat(&dst->clat_stat[l], &src->clat_stat[l], first); - 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); + sum_stat(&dst->clat_stat[l], &src->clat_stat[l], first, false); + sum_stat(&dst->slat_stat[l], &src->slat_stat[l], first, false); + sum_stat(&dst->lat_stat[l], &src->lat_stat[l], first, false); + sum_stat(&dst->bw_stat[l], &src->bw_stat[l], first, true); + sum_stat(&dst->iops_stat[l], &src->iops_stat[l], first, true); 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], first); - 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); + sum_stat(&dst->clat_stat[0], &src->clat_stat[l], first, false); + sum_stat(&dst->slat_stat[0], &src->slat_stat[l], first, false); + sum_stat(&dst->lat_stat[0], &src->lat_stat[l], first, false); + sum_stat(&dst->bw_stat[0], &src->bw_stat[l], first, true); + sum_stat(&dst->iops_stat[0], &src->iops_stat[l], first, true); dst->io_bytes[0] += src->io_bytes[l]; @@ -1607,7 +1664,7 @@ void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src, } } - sum_stat(&dst->sync_stat, &src->sync_stat, first); + sum_stat(&dst->sync_stat, &src->sync_stat, first, false); dst->usr_time += src->usr_time; dst->sys_time += src->sys_time; dst->ctx += src->ctx; @@ -1655,6 +1712,9 @@ void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src, dst->total_run_time += src->total_run_time; dst->total_submit += src->total_submit; dst->total_complete += src->total_complete; + dst->nr_zone_resets += src->nr_zone_resets; + dst->cachehit += src->cachehit; + dst->cachemiss += src->cachemiss; } void init_group_run_stat(struct group_run_stats *gs) @@ -2289,7 +2349,8 @@ static void __add_log_sample(struct io_log *iolog, union io_sample_data data, static inline void reset_io_stat(struct io_stat *ios) { - ios->max_val = ios->min_val = ios->samples = 0; + ios->min_val = -1ULL; + ios->max_val = ios->samples = 0; ios->mean.u.f = ios->S.u.f = 0; } @@ -2335,6 +2396,8 @@ void reset_io_stats(struct thread_data *td) ts->total_submit = 0; ts->total_complete = 0; + ts->nr_zone_resets = 0; + ts->cachehit = ts->cachemiss = 0; } static void __add_stat_to_log(struct io_log *iolog, enum fio_ddir ddir, @@ -2466,11 +2529,13 @@ void add_clat_sample(struct thread_data *td, enum fio_ddir ddir, unsigned long long nsec, unsigned long long bs, uint64_t offset) { + const bool needs_lock = td_async_processing(td); unsigned long elapsed, this_window; struct thread_stat *ts = &td->ts; struct io_log *iolog = td->clat_hist_log; - td_io_u_lock(td); + if (needs_lock) + __td_io_u_lock(td); add_stat_sample(&ts->clat_stat[ddir], nsec); @@ -2519,37 +2584,43 @@ void add_clat_sample(struct thread_data *td, enum fio_ddir ddir, } } - td_io_u_unlock(td); + if (needs_lock) + __td_io_u_unlock(td); } void add_slat_sample(struct thread_data *td, enum fio_ddir ddir, unsigned long usec, unsigned long long bs, uint64_t offset) { + const bool needs_lock = td_async_processing(td); struct thread_stat *ts = &td->ts; if (!ddir_rw(ddir)) return; - td_io_u_lock(td); + if (needs_lock) + __td_io_u_lock(td); add_stat_sample(&ts->slat_stat[ddir], usec); if (td->slat_log) add_log_sample(td, td->slat_log, sample_val(usec), ddir, bs, offset); - td_io_u_unlock(td); + if (needs_lock) + __td_io_u_unlock(td); } void add_lat_sample(struct thread_data *td, enum fio_ddir ddir, unsigned long long nsec, unsigned long long bs, uint64_t offset) { + const bool needs_lock = td_async_processing(td); struct thread_stat *ts = &td->ts; if (!ddir_rw(ddir)) return; - td_io_u_lock(td); + if (needs_lock) + __td_io_u_lock(td); add_stat_sample(&ts->lat_stat[ddir], nsec); @@ -2560,12 +2631,14 @@ void add_lat_sample(struct thread_data *td, enum fio_ddir ddir, if (ts->lat_percentiles) add_clat_percentile_sample(ts, nsec, ddir); - td_io_u_unlock(td); + if (needs_lock) + __td_io_u_unlock(td); } void add_bw_sample(struct thread_data *td, struct io_u *io_u, unsigned int bytes, unsigned long long spent) { + const bool needs_lock = td_async_processing(td); struct thread_stat *ts = &td->ts; unsigned long rate; @@ -2574,7 +2647,8 @@ void add_bw_sample(struct thread_data *td, struct io_u *io_u, else rate = 0; - td_io_u_lock(td); + if (needs_lock) + __td_io_u_lock(td); add_stat_sample(&ts->bw_stat[io_u->ddir], rate); @@ -2583,7 +2657,9 @@ void add_bw_sample(struct thread_data *td, struct io_u *io_u, bytes, io_u->offset); td->stat_io_bytes[io_u->ddir] = td->this_io_bytes[io_u->ddir]; - td_io_u_unlock(td); + + if (needs_lock) + __td_io_u_unlock(td); } static int __add_samples(struct thread_data *td, struct timespec *parent_tv, @@ -2592,6 +2668,7 @@ static int __add_samples(struct thread_data *td, struct timespec *parent_tv, struct io_stat *stat, struct io_log *log, bool is_kb) { + const bool needs_lock = td_async_processing(td); unsigned long spent, rate; enum fio_ddir ddir; unsigned long next, next_log; @@ -2602,7 +2679,8 @@ static int __add_samples(struct thread_data *td, struct timespec *parent_tv, if (spent < avg_time && avg_time - spent >= LOG_MSEC_SLACK) return avg_time - spent; - td_io_u_lock(td); + if (needs_lock) + __td_io_u_lock(td); /* * Compute both read and write rates for the interval. @@ -2639,7 +2717,8 @@ static int __add_samples(struct thread_data *td, struct timespec *parent_tv, timespec_add_msec(parent_tv, avg_time); - td_io_u_unlock(td); + if (needs_lock) + __td_io_u_unlock(td); if (spent <= avg_time) next = avg_time; @@ -2659,9 +2738,11 @@ static int add_bw_samples(struct thread_data *td, struct timespec *t) void add_iops_sample(struct thread_data *td, struct io_u *io_u, unsigned int bytes) { + const bool needs_lock = td_async_processing(td); struct thread_stat *ts = &td->ts; - td_io_u_lock(td); + if (needs_lock) + __td_io_u_lock(td); add_stat_sample(&ts->iops_stat[io_u->ddir], 1); @@ -2670,7 +2751,9 @@ void add_iops_sample(struct thread_data *td, struct io_u *io_u, bytes, io_u->offset); td->stat_io_blocks[io_u->ddir] = td->this_io_blocks[io_u->ddir]; - td_io_u_unlock(td); + + if (needs_lock) + __td_io_u_unlock(td); } static int add_iops_samples(struct thread_data *td, struct timespec *t)