Add functionality to the unified_rw_reporting parameter to output

separate and mixed stats when set to 'both' or 2.

To achieve this, the stats are gathered on a per/data direction
(read/write/etc) basis and then summed into the mixed stats when
generating output.

This functionality also allows setting unified_rw_reporting to
'none' or 'mixed' instead of 0 or 1 respectively.

Signed-off-by: Brandon Paupore <brandon.paupore@wdc.com>
Co-authored-by: Jeff Lien <jeff.lien@wdc.com>

diff --git a/HOWTO b/HOWTO
index 386fd12aa7b14b80405a4df2851b3c0f7e967fd0..ba0c02222f848f5d9cc52dd9eb00f70f2fa2a9a5 100644 (file)
--- a/HOWTO
+++ b/HOWTO
@@ -1144,11 +1144,31 @@ I/O type
        behaves in a similar fashion, except it sends the same offset 8 number of
        times before generating a new offset.
 
-.. option:: unified_rw_reporting=bool
+.. option:: unified_rw_reporting=str
 
        Fio normally reports statistics on a per data direction basis, meaning that
-       reads, writes, and trims are accounted and reported separately. If this
-       option is set fio sums the results and report them as "mixed" instead.
+       reads, writes, and trims are accounted and reported separately. This option
+       determines whether fio reports the results normally, summed together, or as
+       both options.
+       Accepted values are:
+
+               **none**
+                       Normal statistics reporting.
+
+               **mixed**
+                       Statistics are summed per data direction and reported together.
+
+               **both**
+                       Statistics are reported normally, followed by the mixed statistics.
+
+               **0**
+                       Backward-compatible alias for **none**.
+
+               **1**
+                       Backward-compatible alias for **mixed**.
+               
+               **2**
+                       Alias for **both**.
 
 .. option:: randrepeat=bool
 

diff --git a/eta.c b/eta.c
index d1c9449f47173451895f9ce71167aa23276dc370..b2d40381e02b010625e63ce78137c8c487844718 100644 (file)
--- a/eta.c
+++ b/eta.c
@@ -331,7 +331,7 @@ static void calc_rate(int unified_rw_rep, unsigned long mtime,
                else
                        this_rate = 0;
 
-               if (unified_rw_rep) {
+               if (unified_rw_rep == UNIFIED_MIXED) {
                        rate[i] = 0;
                        rate[0] += this_rate;
                } else
@@ -356,7 +356,7 @@ static void calc_iops(int unified_rw_rep, unsigned long mtime,
                else
                        this_iops = 0;
 
-               if (unified_rw_rep) {
+               if (unified_rw_rep == UNIFIED_MIXED) {
                        iops[i] = 0;
                        iops[0] += this_iops;
                } else

diff --git a/fio.1 b/fio.1
index 481193254832befdd285394d6424c209b8805989..f09b236969777ba462d37d7e767fffa3e2ff33d4 100644 (file)
--- a/fio.1
+++ b/fio.1
@@ -918,10 +918,32 @@ behaves in a similar fashion, except it sends the same offset 8 number of
 times before generating a new offset.
 .RE
 .TP
-.BI unified_rw_reporting \fR=\fPbool
+.BI unified_rw_reporting \fR=\fPstr
 Fio normally reports statistics on a per data direction basis, meaning that
-reads, writes, and trims are accounted and reported separately. If this
-option is set fio sums the results and report them as "mixed" instead.
+reads, writes, and trims are accounted and reported separately. This option
+determines whether fio reports the results normally, summed together, or as
+both options.
+Accepted values are:
+.RS
+.TP
+.B none
+Normal statistics reporting.
+.TP
+.B mixed
+Statistics are summed per data direction and reported together.
+.TP
+.B both
+Statistics are reported normally, followed by the mixed statistics.
+.TP
+.B 0
+Backward-compatible alias for \fBnone\fR.
+.TP
+.B 1
+Backward-compatible alias for \fBmixed\fR.
+.TP
+.B 2
+Alias for \fBboth\fR.
+.RE
 .TP
 .BI randrepeat \fR=\fPbool
 Seed the random number generator used for random I/O patterns in a

diff --git a/options.c b/options.c
index 1e91b3e9e23a79eb780b35c22e9cd7681e82ab58..a35997525725d8b674977bff58ccd906ed8ea038 100644 (file)
--- a/options.c
+++ b/options.c
@@ -4530,12 +4530,39 @@ struct fio_option fio_options[FIO_MAX_OPTS] = {
        {
                .name   = "unified_rw_reporting",
                .lname  = "Unified RW Reporting",
-               .type   = FIO_OPT_BOOL,
+               .type   = FIO_OPT_STR,
                .off1   = offsetof(struct thread_options, unified_rw_rep),
                .help   = "Unify reporting across data direction",
-               .def    = "0",
+               .def    = "none",
                .category = FIO_OPT_C_GENERAL,
                .group  = FIO_OPT_G_INVALID,
+               .posval = {
+                         { .ival = "none",
+                           .oval = UNIFIED_SPLIT,
+                           .help = "Normal statistics reporting",
+                         },
+                         { .ival = "mixed",
+                           .oval = UNIFIED_MIXED,
+                           .help = "Statistics are summed per data direction and reported together",
+                         },
+                         { .ival = "both",
+                           .oval = UNIFIED_BOTH,
+                           .help = "Statistics are reported normally, followed by the mixed statistics"
+                         },
+                         /* Compatibility with former boolean values */
+                         { .ival = "0",
+                           .oval = UNIFIED_SPLIT,
+                           .help = "Alias for 'none'",
+                         },
+                         { .ival = "1",
+                           .oval = UNIFIED_MIXED,
+                           .help = "Alias for 'mixed'",
+                         },
+                         { .ival = "2",
+                           .oval = UNIFIED_BOTH,
+                           .help = "Alias for 'both'",
+                         },
+               },
        },
        {
                .name   = "continue_on_error",

diff --git a/stat.c b/stat.c
index eb40bd7f44bb7c4c40c84fc5c70fa9648f996772..a221f33b043994e10c7ac87b4f51eae0a57294d1 100644 (file)
--- a/stat.c
+++ b/stat.c
@@ -282,6 +282,46 @@ bool calc_lat(struct io_stat *is, unsigned long long *min,
        return true;
 }
 
+void show_mixed_group_stats(struct group_run_stats *rs, struct buf_output *out) 
+{
+       char *io, *agg, *min, *max;
+       char *ioalt, *aggalt, *minalt, *maxalt;
+       uint64_t io_mix = 0, agg_mix = 0, min_mix = -1, max_mix = 0, min_run = -1, max_run = 0;
+       int i;
+       const int i2p = is_power_of_2(rs->kb_base);
+
+       for (i = 0; i < DDIR_RWDIR_CNT; i++) {
+               if (!rs->max_run[i])
+                       continue;
+               io_mix += rs->iobytes[i];
+               agg_mix += rs->agg[i];
+               min_mix = min_mix < rs->min_bw[i] ? min_mix : rs->min_bw[i];
+               max_mix = max_mix > rs->max_bw[i] ? max_mix : rs->max_bw[i];
+               min_run = min_run < rs->min_run[i] ? min_run : rs->min_run[i];
+               max_run = max_run > rs->max_run[i] ? max_run : rs->max_run[i];
+       }
+       io = num2str(io_mix, rs->sig_figs, 1, i2p, N2S_BYTE);
+       ioalt = num2str(io_mix, rs->sig_figs, 1, !i2p, N2S_BYTE);
+       agg = num2str(agg_mix, rs->sig_figs, 1, i2p, rs->unit_base);
+       aggalt = num2str(agg_mix, rs->sig_figs, 1, !i2p, rs->unit_base);
+       min = num2str(min_mix, rs->sig_figs, 1, i2p, rs->unit_base);
+       minalt = num2str(min_mix, rs->sig_figs, 1, !i2p, rs->unit_base);
+       max = num2str(max_mix, rs->sig_figs, 1, i2p, rs->unit_base);
+       maxalt = num2str(max_mix, rs->sig_figs, 1, !i2p, rs->unit_base);
+       log_buf(out, "  MIXED: bw=%s (%s), %s-%s (%s-%s), io=%s (%s), run=%llu-%llumsec\n",
+                       agg, aggalt, min, max, minalt, maxalt, io, ioalt,
+                       (unsigned long long) min_run,
+                       (unsigned long long) max_run);
+       free(io);
+       free(agg);
+       free(min);
+       free(max);
+       free(ioalt);
+       free(aggalt);
+       free(minalt);
+       free(maxalt);
+}
+
 void show_group_stats(struct group_run_stats *rs, struct buf_output *out)
 {
        char *io, *agg, *min, *max;
@@ -306,7 +346,7 @@ void show_group_stats(struct group_run_stats *rs, struct buf_output *out)
                max = num2str(rs->max_bw[i], rs->sig_figs, 1, i2p, rs->unit_base);
                maxalt = num2str(rs->max_bw[i], rs->sig_figs, 1, !i2p, rs->unit_base);
                log_buf(out, "%s: bw=%s (%s), %s-%s (%s-%s), io=%s (%s), run=%llu-%llumsec\n",
-                               rs->unified_rw_rep ? "  MIXED" : str[i],
+                               (rs->unified_rw_rep == UNIFIED_MIXED) ? "  MIXED" : str[i],
                                agg, aggalt, min, max, minalt, maxalt, io, ioalt,
                                (unsigned long long) rs->min_run[i],
                                (unsigned long long) rs->max_run[i]);
@@ -320,6 +360,10 @@ void show_group_stats(struct group_run_stats *rs, struct buf_output *out)
                free(minalt);
                free(maxalt);
        }
+       
+       /* Need to aggregate statisitics to show mixed values */
+       if (rs->unified_rw_rep == UNIFIED_BOTH) 
+               show_mixed_group_stats(rs, out);
 }
 
 void stat_calc_dist(uint64_t *map, unsigned long total, double *io_u_dist)
@@ -426,6 +470,168 @@ static double convert_agg_kbytes_percent(struct group_run_stats *rs, int ddir, i
        return p_of_agg;
 }
 
+static void show_mixed_ddir_status(struct group_run_stats *rs, struct thread_stat *ts,
+                            struct buf_output *out)
+{
+       unsigned long runt;
+       unsigned long long min, max, bw, iops;
+       double mean, dev;
+       char *io_p, *bw_p, *bw_p_alt, *iops_p, *post_st = NULL;
+       struct thread_stat *ts_lcl;
+
+       int i2p;
+       int ddir = 0, i;
+
+       /* Handle aggregation of Reads (ddir = 0), Writes (ddir = 1), and Trims (ddir = 2) */
+       ts_lcl = malloc(sizeof(struct thread_stat));
+       memset((void *)ts_lcl, 0, sizeof(struct thread_stat));
+       ts_lcl->unified_rw_rep = UNIFIED_MIXED;               /* calculate mixed stats  */
+       for (i = 0; i < DDIR_RWDIR_CNT; i++) {
+               ts_lcl->clat_stat[i].min_val = ULONG_MAX;
+               ts_lcl->slat_stat[i].min_val = ULONG_MAX;
+               ts_lcl->lat_stat[i].min_val = ULONG_MAX;
+               ts_lcl->bw_stat[i].min_val = ULONG_MAX;
+               ts_lcl->iops_stat[i].min_val = ULONG_MAX;
+               ts_lcl->clat_high_prio_stat[i].min_val = ULONG_MAX;
+               ts_lcl->clat_low_prio_stat[i].min_val = ULONG_MAX;
+       }
+       ts_lcl->sync_stat.min_val = ULONG_MAX;
+
+       sum_thread_stats(ts_lcl, ts, 1);
+
+       assert(ddir_rw(ddir));
+
+       if (!ts_lcl->runtime[ddir])
+               return;
+
+       i2p = is_power_of_2(rs->kb_base);
+       runt = ts_lcl->runtime[ddir];
+
+       bw = (1000 * ts_lcl->io_bytes[ddir]) / runt;
+       io_p = num2str(ts_lcl->io_bytes[ddir], ts->sig_figs, 1, i2p, N2S_BYTE);
+       bw_p = num2str(bw, ts->sig_figs, 1, i2p, ts->unit_base);
+       bw_p_alt = num2str(bw, ts->sig_figs, 1, !i2p, ts->unit_base);
+
+       iops = (1000 * ts_lcl->total_io_u[ddir]) / runt;
+       iops_p = num2str(iops, ts->sig_figs, 1, 0, N2S_NONE);
+
+       log_buf(out, "  mixed: IOPS=%s, BW=%s (%s)(%s/%llumsec)%s\n",
+                       iops_p, bw_p, bw_p_alt, io_p,
+                       (unsigned long long) ts_lcl->runtime[ddir],
+                       post_st ? : "");
+
+       free(post_st);
+       free(io_p);
+       free(bw_p);
+       free(bw_p_alt);
+       free(iops_p);
+
+       if (calc_lat(&ts_lcl->slat_stat[ddir], &min, &max, &mean, &dev))
+               display_lat("slat", min, max, mean, dev, out);
+       if (calc_lat(&ts_lcl->clat_stat[ddir], &min, &max, &mean, &dev))
+               display_lat("clat", min, max, mean, dev, out);
+       if (calc_lat(&ts_lcl->lat_stat[ddir], &min, &max, &mean, &dev))
+               display_lat(" lat", min, max, mean, dev, out);
+       if (calc_lat(&ts_lcl->clat_high_prio_stat[ddir], &min, &max, &mean, &dev)) {
+               display_lat(ts_lcl->lat_percentiles ? "high prio_lat" : "high prio_clat",
+                               min, max, mean, dev, out);
+               if (calc_lat(&ts_lcl->clat_low_prio_stat[ddir], &min, &max, &mean, &dev))
+                       display_lat(ts_lcl->lat_percentiles ? "low prio_lat" : "low prio_clat",
+                                       min, max, mean, dev, out);
+       }
+
+       if (ts->slat_percentiles && ts_lcl->slat_stat[ddir].samples > 0)
+               show_clat_percentiles(ts_lcl->io_u_plat[FIO_SLAT][ddir],
+                               ts_lcl->slat_stat[ddir].samples,
+                               ts->percentile_list,
+                               ts->percentile_precision, "slat", out);
+       if (ts->clat_percentiles && ts_lcl->clat_stat[ddir].samples > 0)
+               show_clat_percentiles(ts_lcl->io_u_plat[FIO_CLAT][ddir],
+                               ts_lcl->clat_stat[ddir].samples,
+                               ts->percentile_list,
+                               ts->percentile_precision, "clat", out);
+       if (ts->lat_percentiles && ts_lcl->lat_stat[ddir].samples > 0)
+               show_clat_percentiles(ts_lcl->io_u_plat[FIO_LAT][ddir],
+                               ts_lcl->lat_stat[ddir].samples,
+                               ts->percentile_list,
+                               ts->percentile_precision, "lat", out);
+
+       if (ts->clat_percentiles || ts->lat_percentiles) {
+               const char *name = ts->lat_percentiles ? "lat" : "clat";
+               char prio_name[32];
+               uint64_t samples;
+
+               if (ts->lat_percentiles)
+                       samples = ts_lcl->lat_stat[ddir].samples;
+               else
+                       samples = ts_lcl->clat_stat[ddir].samples;
+
+               /* Only print this if some high and low priority stats were collected */
+               if (ts_lcl->clat_high_prio_stat[ddir].samples > 0 &&
+                               ts_lcl->clat_low_prio_stat[ddir].samples > 0)
+               {
+                       sprintf(prio_name, "high prio (%.2f%%) %s",
+                                       100. * (double) ts_lcl->clat_high_prio_stat[ddir].samples / (double) samples,
+                                       name);
+                       show_clat_percentiles(ts_lcl->io_u_plat_high_prio[ddir],
+                                       ts_lcl->clat_high_prio_stat[ddir].samples,
+                                       ts->percentile_list,
+                                       ts->percentile_precision, prio_name, out);
+
+                       sprintf(prio_name, "low prio (%.2f%%) %s",
+                                       100. * (double) ts_lcl->clat_low_prio_stat[ddir].samples / (double) samples,
+                                       name);
+                       show_clat_percentiles(ts_lcl->io_u_plat_low_prio[ddir],
+                                       ts_lcl->clat_low_prio_stat[ddir].samples,
+                                       ts->percentile_list,
+                                       ts->percentile_precision, prio_name, out);
+               }
+       }
+
+       if (calc_lat(&ts_lcl->bw_stat[ddir], &min, &max, &mean, &dev)) {
+               double p_of_agg = 100.0, fkb_base = (double)rs->kb_base;
+               const char *bw_str;
+
+               if ((rs->unit_base == 1) && i2p)
+                       bw_str = "Kibit";
+               else if (rs->unit_base == 1)
+                       bw_str = "kbit";
+               else if (i2p)
+                       bw_str = "KiB";
+               else
+                       bw_str = "kB";
+
+               p_of_agg = convert_agg_kbytes_percent(rs, ddir, mean);
+
+               if (rs->unit_base == 1) {
+                       min *= 8.0;
+                       max *= 8.0;
+                       mean *= 8.0;
+                       dev *= 8.0;
+               }
+
+               if (mean > fkb_base * fkb_base) {
+                       min /= fkb_base;
+                       max /= fkb_base;
+                       mean /= fkb_base;
+                       dev /= fkb_base;
+                       bw_str = (rs->unit_base == 1 ? "Mibit" : "MiB");
+               }
+
+               log_buf(out, "   bw (%5s/s): min=%5llu, max=%5llu, per=%3.2f%%, "
+                       "avg=%5.02f, stdev=%5.02f, samples=%" PRIu64 "\n",
+                       bw_str, min, max, p_of_agg, mean, dev,
+                       (&ts_lcl->bw_stat[ddir])->samples);
+       }
+       if (calc_lat(&ts_lcl->iops_stat[ddir], &min, &max, &mean, &dev)) {
+               log_buf(out, "   iops        : min=%5llu, max=%5llu, "
+                       "avg=%5.02f, stdev=%5.02f, samples=%" PRIu64 "\n",
+                       min, max, mean, dev, (&ts_lcl->iops_stat[ddir])->samples);
+       }
+
+       free(ts_lcl);
+}
+
 static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts,
                             int ddir, struct buf_output *out)
 {
@@ -477,7 +683,7 @@ static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts,
        }
 
        log_buf(out, "  %s: IOPS=%s, BW=%s (%s)(%s/%llumsec)%s\n",
-                       rs->unified_rw_rep ? "mixed" : io_ddir_name(ddir),
+                       (ts->unified_rw_rep == UNIFIED_MIXED) ? "mixed" : io_ddir_name(ddir),
                        iops_p, bw_p, bw_p_alt, io_p,
                        (unsigned long long) ts->runtime[ddir],
                        post_st ? : "");
@@ -1083,6 +1289,9 @@ static void show_thread_status_normal(struct thread_stat *ts,
                        show_ddir_status(rs, ts, ddir, out);
        }
 
+       if (ts->unified_rw_rep == UNIFIED_BOTH)
+               show_mixed_ddir_status(rs, ts, out);
+
        show_latencies(ts, out);
 
        if (ts->sync_stat.samples)
@@ -1205,7 +1414,7 @@ static void show_ddir_status_terse(struct thread_stat *ts,
                                        &minv);
        else
                len = 0;
-
+       
        for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++) {
                if (i >= len) {
                        log_buf(out, ";0%%=0");
@@ -1249,6 +1458,40 @@ static void show_ddir_status_terse(struct thread_stat *ts,
        }
 }
 
+static void show_mixed_ddir_status_terse(struct thread_stat *ts,
+                                  struct group_run_stats *rs,
+                                  int ver, struct buf_output *out)
+{
+       struct thread_stat *ts_lcl;
+       int i;
+
+       /* Handle aggregation of Reads (ddir = 0), Writes (ddir = 1), and Trims (ddir = 2) */
+       ts_lcl = malloc(sizeof(struct thread_stat));
+       memset((void *)ts_lcl, 0, sizeof(struct thread_stat));
+       ts_lcl->unified_rw_rep = UNIFIED_MIXED;               /* calculate mixed stats  */
+       for (i = 0; i < DDIR_RWDIR_CNT; i++) {
+               ts_lcl->clat_stat[i].min_val = ULONG_MAX;
+               ts_lcl->slat_stat[i].min_val = ULONG_MAX;
+               ts_lcl->lat_stat[i].min_val = ULONG_MAX;
+               ts_lcl->bw_stat[i].min_val = ULONG_MAX;
+               ts_lcl->iops_stat[i].min_val = ULONG_MAX;
+               ts_lcl->clat_high_prio_stat[i].min_val = ULONG_MAX;
+               ts_lcl->clat_low_prio_stat[i].min_val = ULONG_MAX;
+       }
+       ts_lcl->sync_stat.min_val = ULONG_MAX;
+       ts_lcl->lat_percentiles = ts->lat_percentiles;
+       ts_lcl->clat_percentiles = ts->clat_percentiles;
+       ts_lcl->slat_percentiles = ts->slat_percentiles;
+       ts_lcl->percentile_precision = ts->percentile_precision;                
+       memcpy(ts_lcl->percentile_list, ts->percentile_list, sizeof(ts->percentile_list));
+       
+       sum_thread_stats(ts_lcl, ts, 1);
+
+       /* add the aggregated stats to json parent */
+       show_ddir_status_terse(ts_lcl, rs, DDIR_READ, ver, out);
+       free(ts_lcl);
+}
+
 static struct json_object *add_ddir_lat_json(struct thread_stat *ts, uint32_t percentiles,
                struct io_stat *lat_stat, uint64_t *io_u_plat)
 {
@@ -1310,12 +1553,12 @@ static void add_ddir_status_json(struct thread_stat *ts,
 
        assert(ddir_rw(ddir) || ddir_sync(ddir));
 
-       if (ts->unified_rw_rep && ddir != DDIR_READ)
+       if ((ts->unified_rw_rep == UNIFIED_MIXED) && ddir != DDIR_READ)
                return;
 
        dir_object = json_create_object();
        json_object_add_value_object(parent,
-               ts->unified_rw_rep ? "mixed" : io_ddir_name(ddir), dir_object);
+               (ts->unified_rw_rep == UNIFIED_MIXED) ? "mixed" : io_ddir_name(ddir), dir_object);
 
        if (ddir_rw(ddir)) {
                bw_bytes = 0;
@@ -1418,6 +1661,39 @@ static void add_ddir_status_json(struct thread_stat *ts,
        }
 }
 
+static void add_mixed_ddir_status_json(struct thread_stat *ts,
+               struct group_run_stats *rs, struct json_object *parent)
+{
+       struct thread_stat *ts_lcl;
+       int i;
+
+       /* Handle aggregation of Reads (ddir = 0), Writes (ddir = 1), and Trims (ddir = 2) */
+       ts_lcl = malloc(sizeof(struct thread_stat));
+       memset((void *)ts_lcl, 0, sizeof(struct thread_stat));
+       ts_lcl->unified_rw_rep = UNIFIED_MIXED;               /* calculate mixed stats  */
+       for (i = 0; i < DDIR_RWDIR_CNT; i++) {
+               ts_lcl->clat_stat[i].min_val = ULONG_MAX;
+               ts_lcl->slat_stat[i].min_val = ULONG_MAX;
+               ts_lcl->lat_stat[i].min_val = ULONG_MAX;
+               ts_lcl->bw_stat[i].min_val = ULONG_MAX;
+               ts_lcl->iops_stat[i].min_val = ULONG_MAX;
+               ts_lcl->clat_high_prio_stat[i].min_val = ULONG_MAX;
+               ts_lcl->clat_low_prio_stat[i].min_val = ULONG_MAX;
+       }
+       ts_lcl->sync_stat.min_val = ULONG_MAX;
+       ts_lcl->lat_percentiles = ts->lat_percentiles;
+       ts_lcl->clat_percentiles = ts->clat_percentiles;
+       ts_lcl->slat_percentiles = ts->slat_percentiles;
+       ts_lcl->percentile_precision = ts->percentile_precision;                
+       memcpy(ts_lcl->percentile_list, ts->percentile_list, sizeof(ts->percentile_list));
+
+       sum_thread_stats(ts_lcl, ts, 1);
+
+       /* add the aggregated stats to json parent */
+       add_ddir_status_json(ts_lcl, rs, DDIR_READ, parent);
+       free(ts_lcl);
+}
+
 static void show_thread_status_terse_all(struct thread_stat *ts,
                                         struct group_run_stats *rs, int ver,
                                         struct buf_output *out)
@@ -1435,14 +1711,17 @@ static void show_thread_status_terse_all(struct thread_stat *ts,
                log_buf(out, "%d;%s;%s;%d;%d", ver, fio_version_string,
                        ts->name, ts->groupid, ts->error);
 
-       /* Log Read Status */
+       /* Log Read Status, or mixed if unified_rw_rep = 1 */
        show_ddir_status_terse(ts, rs, DDIR_READ, ver, out);
-       /* Log Write Status */
-       show_ddir_status_terse(ts, rs, DDIR_WRITE, ver, out);
-       /* Log Trim Status */
-       if (ver == 2 || ver == 4 || ver == 5)
-               show_ddir_status_terse(ts, rs, DDIR_TRIM, ver, out);
-
+       if (ts->unified_rw_rep != UNIFIED_MIXED) {
+               /* Log Write Status */
+               show_ddir_status_terse(ts, rs, DDIR_WRITE, ver, out);
+               /* Log Trim Status */
+               if (ver == 2 || ver == 4 || ver == 5)
+                       show_ddir_status_terse(ts, rs, DDIR_TRIM, ver, out);
+       }
+       if (ts->unified_rw_rep == UNIFIED_BOTH)
+               show_mixed_ddir_status_terse(ts, rs, ver, out);
        /* CPU Usage */
        if (ts->total_run_time) {
                double runt = (double) ts->total_run_time;
@@ -1547,6 +1826,9 @@ static struct json_object *show_thread_status_json(struct thread_stat *ts,
        add_ddir_status_json(ts, rs, DDIR_TRIM, root);
        add_ddir_status_json(ts, rs, DDIR_SYNC, root);
 
+       if (ts->unified_rw_rep == UNIFIED_BOTH)
+               add_mixed_ddir_status_json(ts, rs, root);
+
        /* CPU Usage */
        if (ts->total_run_time) {
                double runt = (double) ts->total_run_time;
@@ -1875,7 +2157,7 @@ void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src,
        int k, l, m;
 
        for (l = 0; l < DDIR_RWDIR_CNT; l++) {
-               if (!dst->unified_rw_rep) {
+               if (!(dst->unified_rw_rep == UNIFIED_MIXED)) {
                        sum_stat(&dst->clat_stat[l], &src->clat_stat[l], first, false);
                        sum_stat(&dst->clat_high_prio_stat[l], &src->clat_high_prio_stat[l], first, false);
                        sum_stat(&dst->clat_low_prio_stat[l], &src->clat_low_prio_stat[l], first, false);
@@ -1931,7 +2213,7 @@ void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src,
                dst->io_u_lat_m[k] += src->io_u_lat_m[k];
 
        for (k = 0; k < DDIR_RWDIR_CNT; k++) {
-               if (!dst->unified_rw_rep) {
+               if (!(dst->unified_rw_rep == UNIFIED_MIXED)) {
                        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];
@@ -1947,7 +2229,7 @@ void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src,
        for (k = 0; k < FIO_LAT_CNT; k++)
                for (l = 0; l < DDIR_RWDIR_CNT; l++)
                        for (m = 0; m < FIO_IO_U_PLAT_NR; m++)
-                               if (!dst->unified_rw_rep)
+                               if (!(dst->unified_rw_rep == UNIFIED_MIXED))
                                        dst->io_u_plat[k][l][m] += src->io_u_plat[k][l][m];
                                else
                                        dst->io_u_plat[k][0][m] += src->io_u_plat[k][l][m];
@@ -1957,7 +2239,7 @@ void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src,
 
        for (k = 0; k < DDIR_RWDIR_CNT; k++) {
                for (m = 0; m < FIO_IO_U_PLAT_NR; m++) {
-                       if (!dst->unified_rw_rep) {
+                       if (!(dst->unified_rw_rep == UNIFIED_MIXED)) {
                                dst->io_u_plat_high_prio[k][m] += src->io_u_plat_high_prio[k][m];
                                dst->io_u_plat_low_prio[k][m] += src->io_u_plat_low_prio[k][m];
                        } else {
@@ -2166,7 +2448,7 @@ void __show_run_stats(void)
                rs->kb_base = ts->kb_base;
                rs->unit_base = ts->unit_base;
                rs->sig_figs = ts->sig_figs;
-               rs->unified_rw_rep += ts->unified_rw_rep;
+               rs->unified_rw_rep |= ts->unified_rw_rep;
 
                for (j = 0; j < DDIR_RWDIR_CNT; j++) {
                        if (!ts->runtime[j])

diff --git a/stat.h b/stat.h
index 6dd5ef743a0803b79d5652615dabba416c01dad3..d08d4dc09780720eea3f1fa5896d12a11bae5e40 100644 (file)
--- a/stat.h
+++ b/stat.h
@@ -146,6 +146,9 @@ enum block_info_state {
 #define FIO_JOBNAME_SIZE       128
 #define FIO_JOBDESC_SIZE       256
 #define FIO_VERROR_SIZE                128
+#define UNIFIED_SPLIT          0
+#define UNIFIED_MIXED          1
+#define UNIFIED_BOTH           2
 
 enum fio_lat {
        FIO_SLAT = 0,