X-Git-Url: https://git.kernel.dk/?a=blobdiff_plain;f=stat.c;h=3e57e544e1e421a3f4fd350b5b55d303371a46ce;hb=c7334fa3f3be87854354044615b0c0e473c50713;hp=552d88dde06797c9098820da224cd0891aab268e;hpb=3aea75b14510301a80744b417ac08840ccfcf5b3;p=fio.git diff --git a/stat.c b/stat.c index 552d88dd..3e57e544 100644 --- a/stat.c +++ b/stat.c @@ -657,6 +657,33 @@ static void show_block_infos(int nr_block_infos, uint32_t *block_infos, i == BLOCK_STATE_COUNT - 1 ? '\n' : ','); } +static void show_ss_normal(struct thread_stat *ts, struct buf_output *out) +{ + char *p1, *p2; + unsigned long long bw_mean, iops_mean; + const int i2p = is_power_of_2(ts->kb_base); + + if (!ts->ss_dur) + return; + + bw_mean = steadystate_bw_mean(ts); + iops_mean = steadystate_iops_mean(ts); + + p1 = num2str(bw_mean / ts->kb_base, 6, ts->kb_base, i2p, ts->unit_base); + p2 = num2str(iops_mean, 6, 1, 0, 0); + + log_buf(out, " steadystate : attained=%s, bw=%s/s, iops=%s, %s%s=%.3f%s\n", + ts->ss_state & __FIO_SS_ATTAINED ? "yes" : "no", + p1, p2, + 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 ? "%" : ""); + + free(p1); + free(p2); +} + static void show_thread_status_normal(struct thread_stat *ts, struct group_run_stats *rs, struct buf_output *out) @@ -669,6 +696,8 @@ static void show_thread_status_normal(struct thread_stat *ts, if (!ddir_rw_sum(ts->io_bytes) && !ddir_rw_sum(ts->total_io_u)) return; + + memset(time_buf, 0, sizeof(time_buf)); time(&time_p); os_ctime_r((const time_t *) &time_p, time_buf, sizeof(time_buf)); @@ -761,6 +790,9 @@ static void show_thread_status_normal(struct thread_stat *ts, if (ts->nr_block_infos) show_block_infos(ts->nr_block_infos, ts->block_infos, ts->percentile_list, out); + + if (ts->ss_dur) + show_ss_normal(ts, out); } static void show_ddir_status_terse(struct thread_stat *ts, @@ -1255,6 +1287,56 @@ static struct json_object *show_thread_status_json(struct thread_stat *ts, } } + if (ts->ss_dur) { + struct json_object *data; + struct json_array *iops, *bw; + int i, j, k; + 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" : "", + (float) ts->ss_limit.u.f, + 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); + + snprintf(ss_buf, sizeof(ss_buf), "%f%s", (float) ts->ss_criterion.u.f, + 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); + + data = json_create_object(); + json_object_add_value_object(tmp, "data", data); + bw = json_create_array(); + iops = json_create_array(); + + /* + ** if ss was attained or the buffer is not full, + ** ss->head points to the first element in the list. + ** 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)) + j = ts->ss_head; + else + j = ts->ss_head == 0 ? ts->ss_dur - 1 : ts->ss_head - 1; + for (i = 0; i < ts->ss_dur; i++) { + k = (j + i) % ts->ss_dur; + json_array_add_value_int(bw, ts->ss_bw_data[k]); + json_array_add_value_int(iops, ts->ss_iops_data[k]); + } + json_object_add_value_int(data, "bw_mean", steadystate_bw_mean(ts)); + json_object_add_value_int(data, "iops_mean", steadystate_iops_mean(ts)); + json_object_add_value_array(data, "iops", iops); + json_object_add_value_array(data, "bw", bw); + } + return root; } @@ -1578,6 +1660,20 @@ void __show_run_stats(void) ts->block_infos[k] = td->ts.block_infos[k]; sum_thread_stats(ts, &td->ts, idx == 1); + + if (td->o.ss_dur) { + ts->ss_state = td->ss.state; + ts->ss_dur = td->ss.dur; + ts->ss_head = td->ss.head; + ts->ss_bw_data = td->ss.bw_data; + ts->ss_iops_data = td->ss.iops_data; + ts->ss_limit.u.f = td->ss.limit; + ts->ss_slope.u.f = td->ss.slope; + ts->ss_deviation.u.f = td->ss.deviation; + ts->ss_criterion.u.f = td->ss.criterion; + } + else + ts->ss_dur = ts->ss_state = 0; } for (i = 0; i < nr_ts; i++) { @@ -1648,7 +1744,8 @@ void __show_run_stats(void) os_ctime_r((const time_t *) &now.tv_sec, time_buf, sizeof(time_buf)); - time_buf[strlen(time_buf) - 1] = '\0'; + if (time_buf[strlen(time_buf) - 1] == '\n') + time_buf[strlen(time_buf) - 1] = '\0'; root = json_create_object(); json_object_add_value_string(root, "fio version", fio_version_string); @@ -2002,7 +2099,7 @@ static struct io_logs *get_cur_log(struct io_log *iolog) return iolog->pending; } -static void __add_log_sample(struct io_log *iolog, unsigned long val, +static void __add_log_sample(struct io_log *iolog, union io_sample_data data, enum fio_ddir ddir, unsigned int bs, unsigned long t, uint64_t offset) { @@ -2019,8 +2116,8 @@ static void __add_log_sample(struct io_log *iolog, unsigned long val, s = get_sample(iolog, cur_log, cur_log->nr_samples); - s->val = val; - s->time = t + iolog->td->unix_epoch; + s->data = data; + s->time = t + (iolog->td ? iolog->td->unix_epoch : 0); io_sample_set_ddir(iolog, s, ddir); s->bs = bs; @@ -2088,14 +2185,14 @@ static void __add_stat_to_log(struct io_log *iolog, enum fio_ddir ddir, * had actual samples done. */ if (iolog->avg_window[ddir].samples) { - unsigned long val; + union io_sample_data data; if (log_max) - val = iolog->avg_window[ddir].max_val; + data.val = iolog->avg_window[ddir].max_val; else - val = iolog->avg_window[ddir].mean.u.f + 0.50; + data.val = iolog->avg_window[ddir].mean.u.f + 0.50; - __add_log_sample(iolog, val, ddir, 0, elapsed, 0); + __add_log_sample(iolog, data, ddir, 0, elapsed, 0); } reset_io_stat(&iolog->avg_window[ddir]); @@ -2111,7 +2208,7 @@ static void _add_stat_to_log(struct io_log *iolog, unsigned long elapsed, } static long add_log_sample(struct thread_data *td, struct io_log *iolog, - unsigned long val, enum fio_ddir ddir, + union io_sample_data data, enum fio_ddir ddir, unsigned int bs, uint64_t offset) { unsigned long elapsed, this_window; @@ -2125,7 +2222,7 @@ static long 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, offset); + __add_log_sample(iolog, data, ddir, bs, elapsed, offset); return 0; } @@ -2133,7 +2230,7 @@ static long add_log_sample(struct thread_data *td, struct io_log *iolog, * Add the sample. If the time period has passed, then * add that entry to the log and clear. */ - add_stat_sample(&iolog->avg_window[ddir], val); + add_stat_sample(&iolog->avg_window[ddir], data.val); /* * If period hasn't passed, adding the above sample is all we @@ -2173,7 +2270,7 @@ void finalize_logs(struct thread_data *td, bool unit_logs) _add_stat_to_log(td->iops_log, elapsed, td->o.log_max != 0); } -void add_agg_sample(unsigned long val, enum fio_ddir ddir, unsigned int bs) +void add_agg_sample(union io_sample_data data, enum fio_ddir ddir, unsigned int bs) { struct io_log *iolog; @@ -2181,7 +2278,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(), 0); + __add_log_sample(iolog, data, ddir, bs, mtime_since_genesis(), 0); } static void add_clat_percentile_sample(struct thread_stat *ts, @@ -2205,7 +2302,8 @@ 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, offset); + add_log_sample(td, td->clat_log, sample_val(usec), ddir, bs, + offset); if (ts->clat_percentiles) add_clat_percentile_sample(ts, usec, ddir); @@ -2235,7 +2333,7 @@ void add_clat_sample(struct thread_data *td, enum fio_ddir ddir, memcpy(&(dst->io_u_plat), io_u_plat, FIO_IO_U_PLAT_NR * sizeof(unsigned int)); flist_add(&dst->list, &hw->list); - __add_log_sample(iolog, (unsigned long)dst, ddir, bs, + __add_log_sample(iolog, sample_plat(dst), ddir, bs, elapsed, offset); /* @@ -2264,7 +2362,7 @@ 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, offset); + add_log_sample(td, td->slat_log, sample_val(usec), ddir, bs, offset); td_io_u_unlock(td); } @@ -2282,7 +2380,8 @@ 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, offset); + add_log_sample(td, td->lat_log, sample_val(usec), ddir, bs, + offset); td_io_u_unlock(td); } @@ -2303,7 +2402,8 @@ void add_bw_sample(struct thread_data *td, struct io_u *io_u, add_stat_sample(&ts->bw_stat[io_u->ddir], rate); if (td->bw_log) - add_log_sample(td, td->bw_log, rate, io_u->ddir, bytes, io_u->offset); + add_log_sample(td, td->bw_log, sample_val(rate), io_u->ddir, + bytes, io_u->offset); td->stat_io_bytes[io_u->ddir] = td->this_io_bytes[io_u->ddir]; td_io_u_unlock(td); @@ -2348,7 +2448,8 @@ static int add_bw_samples(struct thread_data *td, struct timeval *t) if (td->o.min_bs[ddir] == td->o.max_bs[ddir]) bs = td->o.min_bs[ddir]; - next = add_log_sample(td, td->bw_log, rate, ddir, bs, 0); + next = add_log_sample(td, td->bw_log, sample_val(rate), + ddir, bs, 0); next_log = min(next_log, next); } @@ -2376,7 +2477,8 @@ void add_iops_sample(struct thread_data *td, struct io_u *io_u, add_stat_sample(&ts->iops_stat[io_u->ddir], 1); if (td->iops_log) - add_log_sample(td, td->iops_log, 1, io_u->ddir, bytes, io_u->offset); + add_log_sample(td, td->iops_log, sample_val(1), io_u->ddir, + bytes, io_u->offset); td->stat_io_blocks[io_u->ddir] = td->this_io_blocks[io_u->ddir]; td_io_u_unlock(td); @@ -2421,7 +2523,8 @@ static int add_iops_samples(struct thread_data *td, struct timeval *t) if (td->o.min_bs[ddir] == td->o.max_bs[ddir]) bs = td->o.min_bs[ddir]; - next = add_log_sample(td, td->iops_log, iops, ddir, bs, 0); + next = add_log_sample(td, td->iops_log, + sample_val(iops), ddir, bs, 0); next_log = min(next_log, next); } @@ -2457,12 +2560,12 @@ int calc_log_samples(void) next = min(td->o.iops_avg_time, td->o.bw_avg_time); continue; } - if (!per_unit_log(td->bw_log)) { + if (td->bw_log && !per_unit_log(td->bw_log)) { tmp = add_bw_samples(td, &now); if (tmp < next) next = tmp; } - if (!per_unit_log(td->iops_log)) { + if (td->iops_log && !per_unit_log(td->iops_log)) { tmp = add_iops_samples(td, &now); if (tmp < next) next = tmp;