#include "helper_thread.h"
#include "smalloc.h"
#include "zbd.h"
+#include "oslib/asprintf.h"
#define LOG_MSEC_SLACK 1
{
unsigned long long sum = 0;
unsigned int len, i, j = 0;
- unsigned int oval_len = 0;
unsigned long long *ovals = NULL;
bool is_last;
* isn't a worry. Also note that this does not work for NaN values.
*/
if (len > 1)
- qsort((void *)plist, len, sizeof(plist[0]), double_cmp);
+ qsort(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
is_last = false;
for (i = 0; i < FIO_IO_U_PLAT_NR && !is_last; i++) {
sum += io_u_plat[i];
- while (sum >= (plist[j].u.f / 100.0 * nr)) {
+ while (sum >= ((long double) 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];
}
}
+ if (!is_last)
+ log_err("fio: error calculating latency percentiles\n");
+
*output = ovals;
return len;
}
}
out:
- if (ovals)
- free(ovals);
+ free(ovals);
}
bool calc_lat(struct io_stat *is, 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, *zbd_w_st = NULL;
+ 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;
}
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)
- zbd_w_st = zbd_write_status(ts);
+ post_st = zbd_write_status(ts);
+ else if (ddir == DDIR_READ && ts->cachehit && ts->cachemiss) {
+ uint64_t total;
+ double hit;
+
+ 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" : str[ddir],
+ rs->unified_rw_rep ? "mixed" : io_ddir_name(ddir),
iops_p, bw_p, bw_p_alt, io_p,
(unsigned long long) ts->runtime[ddir],
- zbd_w_st ? : "");
+ post_st ? : "");
- free(zbd_w_st);
+ free(post_st);
free(io_p);
free(bw_p);
free(bw_p_alt);
* isn't a worry. Also note that this does not work for NaN values.
*/
if (len > 1)
- qsort((void *)plist, len, sizeof(plist[0]), double_cmp);
+ qsort(plist, len, sizeof(plist[0]), double_cmp);
/* Start only after the uninit entries end */
for (nr_uninit = 0;
free(p2);
}
+static void show_agg_stats(struct disk_util_agg *agg, int terse,
+ struct buf_output *out)
+{
+ if (!agg->slavecount)
+ return;
+
+ if (!terse) {
+ log_buf(out, ", aggrios=%llu/%llu, aggrmerge=%llu/%llu, "
+ "aggrticks=%llu/%llu, aggrin_queue=%llu, "
+ "aggrutil=%3.2f%%",
+ (unsigned long long) agg->ios[0] / agg->slavecount,
+ (unsigned long long) agg->ios[1] / agg->slavecount,
+ (unsigned long long) agg->merges[0] / agg->slavecount,
+ (unsigned long long) agg->merges[1] / agg->slavecount,
+ (unsigned long long) agg->ticks[0] / agg->slavecount,
+ (unsigned long long) agg->ticks[1] / agg->slavecount,
+ (unsigned long long) agg->time_in_queue / agg->slavecount,
+ agg->max_util.u.f);
+ } else {
+ log_buf(out, ";slaves;%llu;%llu;%llu;%llu;%llu;%llu;%llu;%3.2f%%",
+ (unsigned long long) agg->ios[0] / agg->slavecount,
+ (unsigned long long) agg->ios[1] / agg->slavecount,
+ (unsigned long long) agg->merges[0] / agg->slavecount,
+ (unsigned long long) agg->merges[1] / agg->slavecount,
+ (unsigned long long) agg->ticks[0] / agg->slavecount,
+ (unsigned long long) agg->ticks[1] / agg->slavecount,
+ (unsigned long long) agg->time_in_queue / agg->slavecount,
+ agg->max_util.u.f);
+ }
+}
+
+static void aggregate_slaves_stats(struct disk_util *masterdu)
+{
+ struct disk_util_agg *agg = &masterdu->agg;
+ struct disk_util_stat *dus;
+ struct flist_head *entry;
+ struct disk_util *slavedu;
+ double util;
+
+ flist_for_each(entry, &masterdu->slaves) {
+ slavedu = flist_entry(entry, struct disk_util, slavelist);
+ dus = &slavedu->dus;
+ agg->ios[0] += dus->s.ios[0];
+ agg->ios[1] += dus->s.ios[1];
+ agg->merges[0] += dus->s.merges[0];
+ agg->merges[1] += dus->s.merges[1];
+ agg->sectors[0] += dus->s.sectors[0];
+ agg->sectors[1] += dus->s.sectors[1];
+ agg->ticks[0] += dus->s.ticks[0];
+ agg->ticks[1] += dus->s.ticks[1];
+ agg->time_in_queue += dus->s.time_in_queue;
+ agg->slavecount++;
+
+ util = (double) (100 * dus->s.io_ticks / (double) slavedu->dus.s.msec);
+ /* System utilization is the utilization of the
+ * component with the highest utilization.
+ */
+ if (util > agg->max_util.u.f)
+ agg->max_util.u.f = util;
+
+ }
+
+ if (agg->max_util.u.f > 100.0)
+ agg->max_util.u.f = 100.0;
+}
+
+void print_disk_util(struct disk_util_stat *dus, struct disk_util_agg *agg,
+ int terse, struct buf_output *out)
+{
+ double util = 0;
+
+ if (dus->s.msec)
+ util = (double) 100 * dus->s.io_ticks / (double) dus->s.msec;
+ if (util > 100.0)
+ util = 100.0;
+
+ if (!terse) {
+ if (agg->slavecount)
+ log_buf(out, " ");
+
+ log_buf(out, " %s: ios=%llu/%llu, merge=%llu/%llu, "
+ "ticks=%llu/%llu, in_queue=%llu, util=%3.2f%%",
+ dus->name,
+ (unsigned long long) dus->s.ios[0],
+ (unsigned long long) dus->s.ios[1],
+ (unsigned long long) dus->s.merges[0],
+ (unsigned long long) dus->s.merges[1],
+ (unsigned long long) dus->s.ticks[0],
+ (unsigned long long) dus->s.ticks[1],
+ (unsigned long long) dus->s.time_in_queue,
+ util);
+ } else {
+ log_buf(out, ";%s;%llu;%llu;%llu;%llu;%llu;%llu;%llu;%3.2f%%",
+ dus->name,
+ (unsigned long long) dus->s.ios[0],
+ (unsigned long long) dus->s.ios[1],
+ (unsigned long long) dus->s.merges[0],
+ (unsigned long long) dus->s.merges[1],
+ (unsigned long long) dus->s.ticks[0],
+ (unsigned long long) dus->s.ticks[1],
+ (unsigned long long) dus->s.time_in_queue,
+ util);
+ }
+
+ /*
+ * If the device has slaves, aggregate the stats for
+ * those slave devices also.
+ */
+ show_agg_stats(agg, terse, out);
+
+ if (!terse)
+ log_buf(out, "\n");
+}
+
+void json_array_add_disk_util(struct disk_util_stat *dus,
+ struct disk_util_agg *agg, struct json_array *array)
+{
+ struct json_object *obj;
+ double util = 0;
+
+ if (dus->s.msec)
+ util = (double) 100 * dus->s.io_ticks / (double) dus->s.msec;
+ if (util > 100.0)
+ util = 100.0;
+
+ obj = json_create_object();
+ json_array_add_value_object(array, obj);
+
+ json_object_add_value_string(obj, "name", dus->name);
+ json_object_add_value_int(obj, "read_ios", dus->s.ios[0]);
+ json_object_add_value_int(obj, "write_ios", dus->s.ios[1]);
+ json_object_add_value_int(obj, "read_merges", dus->s.merges[0]);
+ json_object_add_value_int(obj, "write_merges", dus->s.merges[1]);
+ json_object_add_value_int(obj, "read_ticks", dus->s.ticks[0]);
+ json_object_add_value_int(obj, "write_ticks", dus->s.ticks[1]);
+ json_object_add_value_int(obj, "in_queue", dus->s.time_in_queue);
+ json_object_add_value_float(obj, "util", util);
+
+ /*
+ * If the device has slaves, aggregate the stats for
+ * those slave devices also.
+ */
+ if (!agg->slavecount)
+ return;
+ json_object_add_value_int(obj, "aggr_read_ios",
+ agg->ios[0] / agg->slavecount);
+ json_object_add_value_int(obj, "aggr_write_ios",
+ agg->ios[1] / agg->slavecount);
+ json_object_add_value_int(obj, "aggr_read_merges",
+ agg->merges[0] / agg->slavecount);
+ json_object_add_value_int(obj, "aggr_write_merge",
+ agg->merges[1] / agg->slavecount);
+ json_object_add_value_int(obj, "aggr_read_ticks",
+ agg->ticks[0] / agg->slavecount);
+ json_object_add_value_int(obj, "aggr_write_ticks",
+ agg->ticks[1] / agg->slavecount);
+ json_object_add_value_int(obj, "aggr_in_queue",
+ agg->time_in_queue / agg->slavecount);
+ json_object_add_value_float(obj, "aggr_util", agg->max_util.u.f);
+}
+
+static void json_object_add_disk_utils(struct json_object *obj,
+ struct flist_head *head)
+{
+ struct json_array *array = json_create_array();
+ struct flist_head *entry;
+ struct disk_util *du;
+
+ json_object_add_value_array(obj, "disk_util", array);
+
+ flist_for_each(entry, head) {
+ du = flist_entry(entry, struct disk_util, list);
+
+ aggregate_slaves_stats(du);
+ json_array_add_disk_util(&du->dus, &du->agg, array);
+ }
+}
+
+void show_disk_util(int terse, struct json_object *parent,
+ struct buf_output *out)
+{
+ struct flist_head *entry;
+ struct disk_util *du;
+ bool do_json;
+
+ if (!is_running_backend())
+ return;
+
+ if (flist_empty(&disk_list)) {
+ return;
+ }
+
+ if ((output_format & FIO_OUTPUT_JSON) && parent)
+ do_json = true;
+ else
+ do_json = false;
+
+ if (!terse && !do_json)
+ log_buf(out, "\nDisk stats (read/write):\n");
+
+ if (do_json)
+ json_object_add_disk_utils(parent, &disk_list);
+ else if (output_format & ~(FIO_OUTPUT_JSON | FIO_OUTPUT_JSON_PLUS)) {
+ flist_for_each(entry, &disk_list) {
+ du = flist_entry(entry, struct disk_util, list);
+
+ aggregate_slaves_stats(du);
+ print_disk_util(&du->dus, &du->agg, terse, out);
+ }
+ }
+}
+
static void show_thread_status_normal(struct thread_stat *ts,
struct group_run_stats *rs,
struct buf_output *out)
else
log_buf(out, ";%llu;%llu;%f;%f", 0ULL, 0ULL, 0.0, 0.0);
- if (ovals)
- free(ovals);
+ free(ovals);
bw_stat = calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev);
if (bw_stat) {
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;
+ struct json_object *dir_object, *tmp_object, *percentile_object = NULL,
+ *clat_bins_object = NULL;
char buf[120];
double p_of_agg = 100.0;
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;
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,
} else
len = 0;
- percentile_object = json_create_object();
- json_object_add_value_object(tmp_object, "percentile", percentile_object);
- for (i = 0; i < len; i++) {
- snprintf(buf, sizeof(buf), "%f", ts->percentile_list[i].u.f);
- json_object_add_value_int(percentile_object, (const char *)buf, ovals[i]);
+ if (ts->clat_percentiles) {
+ percentile_object = json_create_object();
+ json_object_add_value_object(tmp_object, "percentile", percentile_object);
+ for (i = 0; i < len; i++) {
+ snprintf(buf, sizeof(buf), "%f",
+ ts->percentile_list[i].u.f);
+ json_object_add_value_int(percentile_object, buf,
+ ovals[i]);
+ }
}
- if (output_format & FIO_OUTPUT_JSON_PLUS) {
+ free(ovals);
+
+ if (output_format & FIO_OUTPUT_JSON_PLUS && ts->clat_percentiles) {
clat_bins_object = json_create_object();
- if (ts->clat_percentiles)
- json_object_add_value_object(tmp_object, "bins", clat_bins_object);
+ json_object_add_value_object(tmp_object, "bins",
+ clat_bins_object);
for(i = 0; i < FIO_IO_U_PLAT_NR; i++) {
if (ddir_rw(ddir)) {
if (ts->io_u_plat[ddir][i]) {
snprintf(buf, sizeof(buf), "%llu", plat_idx_to_val(i));
- json_object_add_value_int(clat_bins_object, (const char *)buf, ts->io_u_plat[ddir][i]);
+ json_object_add_value_int(clat_bins_object, buf, ts->io_u_plat[ddir][i]);
}
} else {
if (ts->io_u_sync_plat[i]) {
snprintf(buf, sizeof(buf), "%llu", plat_idx_to_val(i));
- json_object_add_value_int(clat_bins_object, (const char *)buf, ts->io_u_sync_plat[i]);
+ json_object_add_value_int(clat_bins_object, buf, ts->io_u_sync_plat[i]);
}
}
}
json_object_add_value_int(tmp_object, "max", max);
json_object_add_value_float(tmp_object, "mean", mean);
json_object_add_value_float(tmp_object, "stddev", dev);
+ if (ts->lat_percentiles)
+ json_object_add_value_object(tmp_object, "percentile", percentile_object);
if (output_format & FIO_OUTPUT_JSON_PLUS && ts->lat_percentiles)
json_object_add_value_object(tmp_object, "bins", clat_bins_object);
- if (ovals)
- free(ovals);
-
if (calc_lat(&ts->bw_stat[ddir], &min, &max, &mean, &dev)) {
if (rs->agg[ddir]) {
p_of_agg = mean * 100 / (double) (rs->agg[ddir] / 1024);
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,
/* Additional output if continue_on_error set - default off*/
if (ts->continue_on_error)
log_buf(out, ";%llu;%d", (unsigned long long) ts->total_err_count, ts->first_error);
- if (ver == 2)
- log_buf(out, "\n");
/* Additional output if description is set */
- if (strlen(ts->description))
+ if (strlen(ts->description)) {
+ if (ver == 2)
+ log_buf(out, "\n");
log_buf(out, ";%s", ts->description);
+ }
log_buf(out, "\n");
}
snprintf(buf, sizeof(buf), "%f",
ts->percentile_list[i].u.f);
json_object_add_value_int(percentile_object,
- (const char *)buf,
+ buf,
percentiles[i]);
}
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);
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)
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];
}
}
- 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;
dst->io_u_submit[k] += src->io_u_submit[k];
dst->io_u_complete[k] += src->io_u_complete[k];
}
- for (k = 0; k < FIO_IO_U_LAT_N_NR; k++) {
+
+ for (k = 0; k < FIO_IO_U_LAT_N_NR; k++)
dst->io_u_lat_n[k] += src->io_u_lat_n[k];
+ for (k = 0; k < FIO_IO_U_LAT_U_NR; k++)
dst->io_u_lat_u[k] += src->io_u_lat_u[k];
+ for (k = 0; k < FIO_IO_U_LAT_M_NR; k++)
dst->io_u_lat_m[k] += src->io_u_lat_m[k];
- }
+
for (k = 0; k < FIO_IO_U_PLAT_NR; k++)
dst->io_u_sync_plat[k] += src->io_u_sync_plat[k];
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)
/*
* These are per-group shared already
*/
- strncpy(ts->name, td->o.name, FIO_JOBNAME_SIZE - 1);
+ snprintf(ts->name, sizeof(ts->name), "%s", td->o.name);
if (td->o.description)
- strncpy(ts->description, td->o.description,
- FIO_JOBDESC_SIZE - 1);
+ snprintf(ts->description,
+ sizeof(ts->description), "%s",
+ td->o.description);
else
memset(ts->description, 0, FIO_JOBDESC_SIZE);
if (!td->error && td->o.continue_on_error &&
td->first_error) {
ts->error = td->first_error;
- ts->verror[sizeof(ts->verror) - 1] = '\0';
- strncpy(ts->verror, td->verror, sizeof(ts->verror) - 1);
+ snprintf(ts->verror, sizeof(ts->verror), "%s",
+ td->verror);
} else if (td->error) {
ts->error = td->error;
- ts->verror[sizeof(ts->verror) - 1] = '\0';
- strncpy(ts->verror, td->verror, sizeof(ts->verror) - 1);
+ snprintf(ts->verror, sizeof(ts->verror), "%s",
+ td->verror);
}
}
}
if (temp_dir == NULL)
temp_dir = "/tmp";
+#ifdef __COVERITY__
+ __coverity_tainted_data_sanitize__(temp_dir);
+#endif
snprintf(fio_status_file_path, sizeof(fio_status_file_path), "%s/%s", temp_dir, FIO_STATUS_FILE);
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;
}
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,
io_u_plat = (uint64_t *) td->ts.io_u_plat[ddir];
dst = malloc(sizeof(struct io_u_plat_entry));
memcpy(&(dst->io_u_plat), io_u_plat,
- FIO_IO_U_PLAT_NR * sizeof(unsigned int));
+ FIO_IO_U_PLAT_NR * sizeof(uint64_t));
flist_add(&dst->list, &hw->list);
__add_log_sample(iolog, sample_plat(dst), ddir, bs,
elapsed, offset);