Merge branch 'histograms-PR' of https://github.com/cronburg/fio

[fio.git] / stat.c

diff --git a/stat.c b/stat.c
index e0e97cd923c18324ecc35597ba782495eb1e444a..96af94ba683deb5b4de2420e7fd04cf10e7b7d88 100644 (file)
--- a/stat.c
+++ b/stat.c
@@ -18,6 +18,8 @@
 #include "helper_thread.h"
 #include "smalloc.h"
 
+#define LOG_MSEC_SLACK 10
+
 struct fio_mutex *stat_mutex;
 
 void clear_rusage_stat(struct thread_data *td)
@@ -1949,6 +1951,7 @@ static struct io_logs *regrow_log(struct io_log *iolog)
                dst = get_sample(iolog, cur_log, i);
                memcpy(dst, src, log_entry_sz(iolog));
        }
+       cur_log->nr_samples = iolog->pending->nr_samples;
 
        iolog->pending->nr_samples = 0;
        return cur_log;
@@ -1962,6 +1965,7 @@ void regrow_logs(struct thread_data *td)
 {
        regrow_log(td->slat_log);
        regrow_log(td->clat_log);
+       regrow_log(td->clat_hist_log);
        regrow_log(td->lat_log);
        regrow_log(td->bw_log);
        regrow_log(td->iops_log);
@@ -2106,14 +2110,14 @@ static void _add_stat_to_log(struct io_log *iolog, unsigned long elapsed,
                __add_stat_to_log(iolog, ddir, elapsed, log_max);
 }
 
-static void add_log_sample(struct thread_data *td, struct io_log *iolog,
+static long add_log_sample(struct thread_data *td, struct io_log *iolog,
                           unsigned long val, enum fio_ddir ddir,
                           unsigned int bs, uint64_t offset)
 {
        unsigned long elapsed, this_window;
 
        if (!ddir_rw(ddir))
-               return;
+               return 0;
 
        elapsed = mtime_since_now(&td->epoch);
 
@@ -2122,7 +2126,7 @@ static void add_log_sample(struct thread_data *td, struct io_log *iolog,
         */
        if (!iolog->avg_msec) {
                __add_log_sample(iolog, val, ddir, bs, elapsed, offset);
-               return;
+               return 0;
        }
 
        /*
@@ -2136,12 +2140,19 @@ static void add_log_sample(struct thread_data *td, struct io_log *iolog,
         * need to do.
         */
        this_window = elapsed - iolog->avg_last;
-       if (this_window < iolog->avg_msec)
-               return;
+       if (elapsed < iolog->avg_last)
+               return iolog->avg_last - elapsed;
+       else if (this_window < iolog->avg_msec) {
+               int diff = iolog->avg_msec - this_window;
+
+               if (inline_log(iolog) || diff > LOG_MSEC_SLACK)
+                       return diff;
+       }
 
        _add_stat_to_log(iolog, elapsed, td->o.log_max != 0);
 
-       iolog->avg_last = elapsed;
+       iolog->avg_last = elapsed - (this_window - iolog->avg_msec);
+       return iolog->avg_msec;
 }
 
 void finalize_logs(struct thread_data *td, bool unit_logs)
@@ -2185,7 +2196,9 @@ 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, uint64_t offset)
 {
+       unsigned long elapsed, this_window;
        struct thread_stat *ts = &td->ts;
+       struct io_log *iolog = td->clat_hist_log;
 
        td_io_u_lock(td);
 
@@ -2197,6 +2210,35 @@ void add_clat_sample(struct thread_data *td, enum fio_ddir ddir,
        if (ts->clat_percentiles)
                add_clat_percentile_sample(ts, usec, ddir);
 
+       if (iolog && iolog->hist_msec) {
+               struct io_hist *hw = &(iolog->hist_window[ddir]);
+               (hw->samples)++;
+               elapsed = mtime_since_now(&td->epoch);
+               if (! hw->hist_last)
+                       hw->hist_last = elapsed;
+               this_window = elapsed - hw->hist_last;
+               
+               if (this_window >= iolog->hist_msec) {
+                       /*
+                        * Make a byte-for-byte copy of the latency histogram stored in
+                        * td->ts.io_u_plat[ddir], recording it in a log sample. Note that
+                        * the matching call to free() is located in iolog.c after printing
+                        * this sample to the log file.
+                        */
+                       unsigned int *io_u_plat = (unsigned int *)(td->ts.io_u_plat[ddir]);
+                       unsigned int *dst = malloc(FIO_IO_U_PLAT_NR * sizeof(unsigned int));
+                       memcpy(dst, io_u_plat, FIO_IO_U_PLAT_NR * sizeof(unsigned int));
+                       __add_log_sample(iolog, (uint64_t)dst, ddir, bs, elapsed, offset);
+
+                       /*
+                        * Update the last time we recorded as being now, minus any drift
+                        * in time we encountered before actually making the record.
+                        */
+                       hw->hist_last = elapsed - (this_window - iolog->hist_msec);
+                       hw->samples = 0;
+               }
+       }
+
        td_io_u_unlock(td);
 }
 
@@ -2263,10 +2305,13 @@ 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;
+       unsigned int next, next_log;
+
+       next_log = td->o.bw_avg_time;
 
        spent = mtime_since(&td->bw_sample_time, t);
        if (spent < td->o.bw_avg_time &&
-           td->o.bw_avg_time - spent >= 10)
+           td->o.bw_avg_time - spent >= LOG_MSEC_SLACK)
                return td->o.bw_avg_time - spent;
 
        td_io_u_lock(td);
@@ -2294,7 +2339,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];
 
-                       add_log_sample(td, td->bw_log, rate, ddir, bs, 0);
+                       next = add_log_sample(td, td->bw_log, rate, ddir, bs, 0);
+                       next_log = min(next_log, next);
                }
 
                td->stat_io_bytes[ddir] = td->this_io_bytes[ddir];
@@ -2305,9 +2351,10 @@ static int add_bw_samples(struct thread_data *td, struct timeval *t)
        td_io_u_unlock(td);
 
        if (spent <= td->o.bw_avg_time)
-               return td->o.bw_avg_time;
+               return min(next_log, td->o.bw_avg_time);
 
-       return td->o.bw_avg_time - (1 + spent - td->o.bw_avg_time);
+       next = td->o.bw_avg_time - (1 + spent - td->o.bw_avg_time);
+       return min(next, next_log);
 }
 
 void add_iops_sample(struct thread_data *td, struct io_u *io_u,
@@ -2331,10 +2378,13 @@ 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;
+       unsigned int next, next_log;
+
+       next_log = td->o.iops_avg_time;
 
        spent = mtime_since(&td->iops_sample_time, t);
        if (spent < td->o.iops_avg_time &&
-           td->o.iops_avg_time - spent >= 10)
+           td->o.iops_avg_time - spent >= LOG_MSEC_SLACK)
                return td->o.iops_avg_time - spent;
 
        td_io_u_lock(td);
@@ -2362,7 +2412,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];
 
-                       add_log_sample(td, td->iops_log, iops, ddir, bs, 0);
+                       next = add_log_sample(td, td->iops_log, iops, ddir, bs, 0);
+                       next_log = min(next_log, next);
                }
 
                td->stat_io_blocks[ddir] = td->this_io_blocks[ddir];
@@ -2373,9 +2424,10 @@ static int add_iops_samples(struct thread_data *td, struct timeval *t)
        td_io_u_unlock(td);
 
        if (spent <= td->o.iops_avg_time)
-               return td->o.iops_avg_time;
+               return min(next_log, td->o.iops_avg_time);
 
-       return td->o.iops_avg_time - (1 + spent - td->o.iops_avg_time);
+       next = td->o.iops_avg_time - (1 + spent - td->o.iops_avg_time);
+       return min(next, next_log);
 }
 
 /*