#include "idletime.h"
#include "lib/pow2.h"
#include "lib/output_buffer.h"
+#include "helper_thread.h"
struct fio_mutex *stat_mutex;
unsigned long long bw;
ts = &threadstats[i];
+ if (ts->groupid == -1)
+ continue;
rs = &runstats[ts->groupid];
rs->kb_base = ts->kb_base;
rs->unit_base = ts->unit_base;
fio_gettime(&tv, NULL);
for_each_td(td, i) {
- rt[i] = mtime_since(&td->start, &tv);
- if (td_read(td) && td->io_bytes[DDIR_READ])
- td->ts.runtime[DDIR_READ] += rt[i];
- if (td_write(td) && td->io_bytes[DDIR_WRITE])
- td->ts.runtime[DDIR_WRITE] += rt[i];
- if (td_trim(td) && td->io_bytes[DDIR_TRIM])
- td->ts.runtime[DDIR_TRIM] += rt[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);
+
+ rt[i] = mtime_since(&td->start, &tv);
+ 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])
+ td->ts.runtime[DDIR_WRITE] += rt[i];
+ if (td_trim(td) && td->ts.io_bytes[DDIR_TRIM])
+ td->ts.runtime[DDIR_TRIM] += rt[i];
}
for_each_td(td, i) {
__show_run_stats();
for_each_td(td, i) {
- if (td_read(td) && td->io_bytes[DDIR_READ])
+ if (td_read(td) && td->ts.io_bytes[DDIR_READ])
td->ts.runtime[DDIR_READ] -= rt[i];
- if (td_write(td) && td->io_bytes[DDIR_WRITE])
+ if (td_write(td) && td->ts.io_bytes[DDIR_WRITE])
td->ts.runtime[DDIR_WRITE] -= rt[i];
- if (td_trim(td) && td->io_bytes[DDIR_TRIM])
+ if (td_trim(td) && td->ts.io_bytes[DDIR_TRIM])
td->ts.runtime[DDIR_TRIM] -= rt[i];
}
is->samples++;
}
+/*
+ * Return a struct io_logs, which is added to the tail of the log
+ * list for 'iolog'.
+ */
+static struct io_logs *get_new_log(struct io_log *iolog)
+{
+ size_t new_size, new_samples;
+ struct io_logs *cur_log;
+
+ /*
+ * Cap the size at MAX_LOG_ENTRIES, so we don't keep doubling
+ * forever
+ */
+ if (!iolog->cur_log_max)
+ new_samples = DEF_LOG_ENTRIES;
+ else {
+ new_samples = iolog->cur_log_max * 2;
+ if (new_samples > MAX_LOG_ENTRIES)
+ new_samples = MAX_LOG_ENTRIES;
+ }
+
+ /*
+ * If the alloc size is sufficiently large, quiesce pending IO before
+ * attempting it. This is to avoid spending a long time in alloc with
+ * IO pending, which will unfairly skew the completion latencies of
+ * inflight IO.
+ */
+ new_size = new_samples * log_entry_sz(iolog);
+ if (new_size >= LOG_QUIESCE_SZ)
+ io_u_quiesce(iolog->td);
+
+ cur_log = malloc(sizeof(*cur_log));
+ if (cur_log) {
+ INIT_FLIST_HEAD(&cur_log->list);
+ cur_log->log = malloc(new_size);
+ if (cur_log->log) {
+ cur_log->nr_samples = 0;
+ cur_log->max_samples = new_samples;
+ flist_add_tail(&cur_log->list, &iolog->io_logs);
+ iolog->cur_log_max = new_samples;
+ return cur_log;
+ }
+ free(cur_log);
+ }
+
+ return NULL;
+}
+
+static struct io_logs *get_cur_log(struct io_log *iolog)
+{
+ struct io_logs *cur_log;
+
+ cur_log = iolog_cur_log(iolog);
+ if (!cur_log) {
+ cur_log = get_new_log(iolog);
+ if (!cur_log)
+ return NULL;
+ }
+
+ if (cur_log->nr_samples < cur_log->max_samples)
+ return cur_log;
+
+ /*
+ * No room for a new sample. If we're compressing on the fly, flush
+ * out the current chunk
+ */
+ if (iolog->log_gz) {
+ if (iolog_cur_flush(iolog, cur_log)) {
+ log_err("fio: failed flushing iolog! Will stop logging.\n");
+ return NULL;
+ }
+ }
+
+ /*
+ * Get a new log array, and add to our list
+ */
+ cur_log = get_new_log(iolog);
+ if (!cur_log) {
+ log_err("fio: failed extending iolog! Will stop logging.\n");
+ return NULL;
+ }
+
+ return cur_log;
+}
+
static void __add_log_sample(struct io_log *iolog, unsigned long val,
enum fio_ddir ddir, unsigned int bs,
unsigned long t, uint64_t offset)
{
- uint64_t nr_samples = iolog->nr_samples;
- struct io_sample *s;
+ struct io_logs *cur_log;
if (iolog->disabled)
return;
-
- if (!iolog->nr_samples)
+ if (flist_empty(&iolog->io_logs))
iolog->avg_last = t;
- if (iolog->nr_samples == iolog->max_samples) {
- size_t new_size;
- void *new_log;
+ cur_log = get_cur_log(iolog);
+ if (cur_log) {
+ struct io_sample *s;
- new_size = 2 * iolog->max_samples * log_entry_sz(iolog);
+ s = get_sample(iolog, cur_log, cur_log->nr_samples);
- 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->val = val;
+ s->time = t;
+ io_sample_set_ddir(iolog, s, ddir);
+ s->bs = bs;
- s = get_sample(iolog, nr_samples);
+ if (iolog->log_offset) {
+ struct io_sample_offset *so = (void *) s;
- 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;
+ so->offset = offset;
+ }
- so->offset = offset;
+ cur_log->nr_samples++;
+ return;
}
- iolog->nr_samples++;
+ iolog->disabled = true;
}
static inline void reset_io_stat(struct io_stat *ios)
}
}
-static void _add_stat_to_log(struct io_log *iolog, unsigned long elapsed)
+static void __add_stat_to_log(struct io_log *iolog, enum fio_ddir ddir,
+ unsigned long elapsed, bool log_max)
{
/*
* 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;
+ if (iolog->avg_window[ddir].samples) {
+ unsigned long val;
- 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;
+ if (log_max)
+ val = iolog->avg_window[ddir].max_val;
+ else
+ val = iolog->avg_window[ddir].mean.u.f + 0.50;
- mw = iolog->avg_window[DDIR_WRITE].mean.u.f + 0.50;
- __add_log_sample(iolog, mw, DDIR_WRITE, 0, elapsed, 0);
+ __add_log_sample(iolog, val, ddir, 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]);
+}
- 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_stat_to_log(struct io_log *iolog, unsigned long elapsed,
+ bool log_max)
+{
+ int ddir;
+
+ for (ddir = 0; ddir < DDIR_RWDIR_CNT; ddir++)
+ __add_stat_to_log(iolog, ddir, elapsed, log_max);
}
static void add_log_sample(struct thread_data *td, struct io_log *iolog,
if (this_window < iolog->avg_msec)
return;
- _add_stat_to_log(iolog, elapsed);
+ _add_stat_to_log(iolog, elapsed, td->o.log_max != 0);
iolog->avg_last = elapsed;
}
-void finalize_logs(struct thread_data *td)
+void finalize_logs(struct thread_data *td, bool unit_logs)
{
unsigned long elapsed;
elapsed = mtime_since_now(&td->epoch);
- 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);
+ if (td->clat_log && unit_logs)
+ _add_stat_to_log(td->clat_log, elapsed, td->o.log_max != 0);
+ if (td->slat_log && unit_logs)
+ _add_stat_to_log(td->slat_log, elapsed, td->o.log_max != 0);
+ if (td->lat_log && unit_logs)
+ _add_stat_to_log(td->lat_log, elapsed, td->o.log_max != 0);
+ if (td->bw_log && (unit_logs == per_unit_log(td->bw_log)))
+ _add_stat_to_log(td->bw_log, elapsed, td->o.log_max != 0);
+ if (td->iops_log && (unit_logs == per_unit_log(td->iops_log)))
+ _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)
{
struct thread_stat *ts = &td->ts;
- if (!ddir_rw(ddir))
- return;
-
td_io_u_lock(td);
add_stat_sample(&ts->clat_stat[ddir], usec);
td_io_u_unlock(td);
}
-void add_bw_sample(struct thread_data *td, enum fio_ddir ddir, unsigned int bs,
- struct timeval *t)
+void add_bw_sample(struct thread_data *td, struct io_u *io_u,
+ unsigned int bytes, unsigned long spent)
+{
+ struct thread_stat *ts = &td->ts;
+ unsigned long rate;
+
+ if (spent)
+ rate = bytes * 1000 / spent;
+ else
+ rate = 0;
+
+ td_io_u_lock(td);
+
+ 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);
+
+ td->stat_io_bytes[io_u->ddir] = td->this_io_bytes[io_u->ddir];
+ td_io_u_unlock(td);
+}
+
+static int add_bw_samples(struct thread_data *td, struct timeval *t)
{
struct thread_stat *ts = &td->ts;
unsigned long spent, rate;
+ enum fio_ddir ddir;
- if (!ddir_rw(ddir))
- return;
+ if (per_unit_log(td->bw_log))
+ return 0;
spent = mtime_since(&td->bw_sample_time, t);
- if (spent < td->o.bw_avg_time)
- return;
+ if (spent < td->o.bw_avg_time &&
+ td->o.bw_avg_time - spent >= 10)
+ return td->o.bw_avg_time - spent;
td_io_u_lock(td);
add_stat_sample(&ts->bw_stat[ddir], rate);
- if (td->bw_log)
+ if (td->bw_log) {
+ unsigned int bs = 0;
+
+ if (td->o.min_bs[ddir] == td->o.max_bs[ddir])
+ bs = td->o.min_bs[ddir];
+
add_log_sample(td, td->bw_log, rate, ddir, bs, 0);
+ }
td->stat_io_bytes[ddir] = td->this_io_bytes[ddir];
}
- fio_gettime(&td->bw_sample_time, NULL);
+ timeval_add_msec(&td->bw_sample_time, td->o.bw_avg_time);
+
+ td_io_u_unlock(td);
+
+ if (spent <= td->o.bw_avg_time)
+ return td->o.bw_avg_time;
+
+ return td->o.bw_avg_time - (1 + spent - td->o.bw_avg_time);
+}
+
+void add_iops_sample(struct thread_data *td, struct io_u *io_u,
+ unsigned int bytes)
+{
+ struct thread_stat *ts = &td->ts;
+
+ td_io_u_lock(td);
+
+ 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);
+
+ td->stat_io_blocks[io_u->ddir] = td->this_io_blocks[io_u->ddir];
td_io_u_unlock(td);
}
-void add_iops_sample(struct thread_data *td, enum fio_ddir ddir, unsigned int bs,
- struct timeval *t)
+static int add_iops_samples(struct thread_data *td, struct timeval *t)
{
struct thread_stat *ts = &td->ts;
unsigned long spent, iops;
+ enum fio_ddir ddir;
- if (!ddir_rw(ddir))
- return;
+ if (per_unit_log(td->iops_log))
+ return 0;
spent = mtime_since(&td->iops_sample_time, t);
- if (spent < td->o.iops_avg_time)
- return;
+ if (spent < td->o.iops_avg_time &&
+ td->o.iops_avg_time - spent >= 10)
+ return td->o.iops_avg_time - spent;
td_io_u_lock(td);
add_stat_sample(&ts->iops_stat[ddir], iops);
- if (td->iops_log)
+ if (td->iops_log) {
+ unsigned int bs = 0;
+
+ if (td->o.min_bs[ddir] == td->o.max_bs[ddir])
+ bs = td->o.min_bs[ddir];
+
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);
+ timeval_add_msec(&td->iops_sample_time, td->o.iops_avg_time);
+
td_io_u_unlock(td);
+
+ if (spent <= td->o.iops_avg_time)
+ return td->o.iops_avg_time;
+
+ return td->o.iops_avg_time - (1 + spent - td->o.iops_avg_time);
+}
+
+/*
+ * Returns msecs to next event
+ */
+int calc_log_samples(void)
+{
+ struct thread_data *td;
+ unsigned int next = ~0U, tmp;
+ struct timeval now;
+ int i;
+
+ fio_gettime(&now, NULL);
+
+ for_each_td(td, i) {
+ if (!ramp_time_over(td) ||
+ !(td->runstate == TD_RUNNING || td->runstate == TD_VERIFYING)) {
+ next = min(td->o.iops_avg_time, td->o.bw_avg_time);
+ continue;
+ }
+ if (!per_unit_log(td->bw_log)) {
+ tmp = add_bw_samples(td, &now);
+ if (tmp < next)
+ next = tmp;
+ }
+ if (!per_unit_log(td->iops_log)) {
+ tmp = add_iops_samples(td, &now);
+ if (tmp < next)
+ next = tmp;
+ }
+ }
+
+ return next == ~0U ? 0 : next;
}
void stat_init(void)
*/
void show_running_run_stats(void)
{
- helper_do_stat = 1;
- pthread_cond_signal(&helper_cond);
+ helper_do_stat();
}
uint32_t *io_u_block_info(struct thread_data *td, struct io_u *io_u)
projects / fio.git / blobdiff