#include "fio.h"
#include "diskutil.h"
+#include "ieee754.h"
void update_rusage_stat(struct thread_data *td)
{
static int double_cmp(const void *a, const void *b)
{
- const double fa = *(const double *)a;
- const double fb = *(const double *)b;
+ const fio_fp64_t fa = *(const fio_fp64_t *) a;
+ const fio_fp64_t fb = *(const fio_fp64_t *) b;
int cmp = 0;
- if (fa > fb)
+ if (fa.u.f > fb.u.f)
cmp = 1;
- else if (fa < fb)
+ else if (fa.u.f < fb.u.f)
cmp = -1;
return cmp;
* Find and display the p-th percentile of clat
*/
static void show_clat_percentiles(unsigned int *io_u_plat, unsigned long nr,
- double *user_list)
+ fio_fp64_t *plist)
{
unsigned long sum = 0;
unsigned int len, i, j = 0;
- const double *plist;
int is_last = 0;
- static const double def_list[FIO_IO_U_LIST_MAX_LEN] = {
- 1.0, 5.0, 10.0, 20.0, 30.0,
- 40.0, 50.0, 60.0, 70.0, 80.0,
- 90.0, 95.0, 99.0, 99.5, 99.9};
- plist = user_list;
- if (!plist)
- plist = def_list;
-
- for (len = 0; len <FIO_IO_U_LIST_MAX_LEN && plist[len] != 0; len++)
- ;
+ len = 0;
+ while (len < FIO_IO_U_LIST_MAX_LEN && plist[len].u.f != 0.0)
+ len++;
/*
- * Sort the user-specified list. Note that this does not work
- * for NaN values
+ * Sort the percentile list. Note that it may already be sorted if
+ * we are using the default values, but since it's a short list this
+ * isn't a worry. Also note that this does not work for NaN values.
*/
- if (user_list && len > 1)
- qsort((void*)user_list, len, sizeof(user_list[0]), double_cmp);
+ if (len > 1)
+ qsort((void*)plist, len, sizeof(plist[0]), double_cmp);
log_info(" clat percentiles (usec) :");
for (i = 0; i < FIO_IO_U_PLAT_NR && !is_last; i++) {
sum += io_u_plat[i];
- while (sum >= (plist[j] / 100 * nr)) {
- assert(plist[j] <= 100.0);
+ while (sum >= (plist[j].u.f / 100.0 * nr)) {
+ assert(plist[j].u.f <= 100.0);
/* for formatting */
if (j != 0 && (j % 4) == 0)
*max = is->max_val;
n = (double) is->samples;
- *mean = is->mean;
+ *mean = is->mean.u.f;
if (n > 1.0)
- *dev = sqrt(is->S / (n - 1.0));
+ *dev = sqrt(is->S.u.f / (n - 1.0));
else
*dev = 0;
double p_of_agg;
p_of_agg = mean * 100 / (double) rs->agg[ddir];
- log_info(" bw (KB/s) : min=%5lu, max=%5lu, per=%3.2f%%,"
+ log_info(" bw (KB/s) : min=%5lu, max=%5lu, per=%3.2f%%,"
" avg=%5.02f, stdev=%5.02f\n", min, max, p_of_agg,
mean, dev);
}
* #Parallel_algorithm>
*/
if (nr == 1) {
- mean = src->mean;
- S = src->S;
+ mean = src->mean.u.f;
+ S = src->S.u.f;
} else {
- double delta = src->mean - dst->mean;
+ double delta = src->mean.u.f - dst->mean.u.f;
- mean = ((src->mean * src->samples) +
- (dst->mean * dst->samples)) /
+ mean = ((src->mean.u.f * src->samples) +
+ (dst->mean.u.f * dst->samples)) /
(dst->samples + src->samples);
- S = src->S + dst->S + pow(delta, 2.0) *
+ S = src->S.u.f + dst->S.u.f + pow(delta, 2.0) *
(dst->samples * src->samples) /
(dst->samples + src->samples);
}
dst->samples += src->samples;
- dst->mean = mean;
- dst->S = S;
+ dst->mean.u.f = mean;
+ dst->S.u.f = S;
+}
+
+void sum_thread_stats(struct thread_stat *dst, struct thread_stat *src, int nr)
+{
+ int l, k;
+
+ for (l = 0; l <= DDIR_WRITE; l++) {
+ sum_stat(&dst->clat_stat[l], &src->clat_stat[l], nr);
+ sum_stat(&dst->slat_stat[l], &src->slat_stat[l], nr);
+ sum_stat(&dst->lat_stat[l], &src->lat_stat[l], nr);
+ sum_stat(&dst->bw_stat[l], &src->bw_stat[l], nr);
+
+ dst->io_bytes[l] += src->io_bytes[l];
+
+ if (dst->runtime[l] < src->runtime[l])
+ dst->runtime[l] = src->runtime[l];
+ }
+
+ dst->usr_time += src->usr_time;
+ dst->sys_time += src->sys_time;
+ dst->ctx += src->ctx;
+ dst->majf += src->majf;
+ dst->minf += src->minf;
+
+ for (k = 0; k < FIO_IO_U_MAP_NR; k++)
+ dst->io_u_map[k] += src->io_u_map[k];
+ for (k = 0; k < FIO_IO_U_MAP_NR; k++)
+ dst->io_u_submit[k] += src->io_u_submit[k];
+ for (k = 0; k < FIO_IO_U_MAP_NR; k++)
+ dst->io_u_complete[k] += src->io_u_complete[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 <= 2; k++) {
+ dst->total_io_u[k] += src->total_io_u[k];
+ dst->short_io_u[k] += src->short_io_u[k];
+ }
+
+ for (k = 0; k <= DDIR_WRITE; k++) {
+ int m;
+ for (m = 0; m < FIO_IO_U_PLAT_NR; m++)
+ dst->io_u_plat[k][m] += src->io_u_plat[k][m];
+ }
+
+ dst->total_run_time += src->total_run_time;
+ dst->total_submit += src->total_submit;
+ dst->total_complete += src->total_complete;
}
void show_run_stats(void)
struct group_run_stats *runstats, *rs;
struct thread_data *td;
struct thread_stat *threadstats, *ts;
- int i, j, k, l, nr_ts, last_ts, idx;
+ int i, j, nr_ts, last_ts, idx;
int kb_base_warned = 0;
runstats = malloc(sizeof(struct group_run_stats) * (groupid + 1));
ts->clat_percentiles = td->o.clat_percentiles;
if (td->o.overwrite_plist)
- ts->percentile_list = td->o.percentile_list;
+ memcpy(ts->percentile_list, td->o.percentile_list, sizeof(td->o.percentile_list));
else
- ts->percentile_list = NULL;
+ memcpy(ts->percentile_list, def_percentile_list, sizeof(def_percentile_list));
idx++;
ts->members++;
}
}
- for (l = 0; l <= DDIR_WRITE; l++) {
- sum_stat(&ts->clat_stat[l], &td->ts.clat_stat[l], idx);
- sum_stat(&ts->slat_stat[l], &td->ts.slat_stat[l], idx);
- sum_stat(&ts->lat_stat[l], &td->ts.lat_stat[l], idx);
- sum_stat(&ts->bw_stat[l], &td->ts.bw_stat[l], idx);
-
- ts->io_bytes[l] += td->ts.io_bytes[l];
-
- if (ts->runtime[l] < td->ts.runtime[l])
- ts->runtime[l] = td->ts.runtime[l];
- }
-
- ts->usr_time += td->ts.usr_time;
- ts->sys_time += td->ts.sys_time;
- ts->ctx += td->ts.ctx;
- ts->majf += td->ts.majf;
- ts->minf += td->ts.minf;
-
- for (k = 0; k < FIO_IO_U_MAP_NR; k++)
- ts->io_u_map[k] += td->ts.io_u_map[k];
- for (k = 0; k < FIO_IO_U_MAP_NR; k++)
- ts->io_u_submit[k] += td->ts.io_u_submit[k];
- for (k = 0; k < FIO_IO_U_MAP_NR; k++)
- ts->io_u_complete[k] += td->ts.io_u_complete[k];
- for (k = 0; k < FIO_IO_U_LAT_U_NR; k++)
- ts->io_u_lat_u[k] += td->ts.io_u_lat_u[k];
- for (k = 0; k < FIO_IO_U_LAT_M_NR; k++)
- ts->io_u_lat_m[k] += td->ts.io_u_lat_m[k];
-
-
- for (k = 0; k <= 2; k++) {
- ts->total_io_u[k] += td->ts.total_io_u[k];
- ts->short_io_u[k] += td->ts.short_io_u[k];
- }
-
- for (k = 0; k <= DDIR_WRITE; k++) {
- int m;
- for (m = 0; m < FIO_IO_U_PLAT_NR; m++)
- ts->io_u_plat[k][m] += td->ts.io_u_plat[k][m];
- }
-
- ts->total_run_time += td->ts.total_run_time;
- ts->total_submit += td->ts.total_submit;
- ts->total_complete += td->ts.total_complete;
+ sum_thread_stats(ts, &td->ts, idx);
}
for (i = 0; i < nr_ts; i++) {
if (data < is->min_val)
is->min_val = data;
- delta = val - is->mean;
+ delta = val - is->mean.u.f;
if (delta) {
- is->mean += delta / (is->samples + 1.0);
- is->S += delta * (val - is->mean);
+ is->mean.u.f += delta / (is->samples + 1.0);
+ is->S.u.f += delta * (val - is->mean.u.f);
}
is->samples++;
if (!ddir_rw(ddir))
return;
- spent = mtime_since(&td->stat_sample_time[ddir], t);
+ spent = mtime_since(&td->bw_sample_time, t);
if (spent < td->o.bw_avg_time)
return;
if (td->bw_log)
add_log_sample(td, td->bw_log, rate, ddir, bs);
- fio_gettime(&td->stat_sample_time[ddir], NULL);
+ fio_gettime(&td->bw_sample_time, NULL);
td->stat_io_bytes[ddir] = td->this_io_bytes[ddir];
}
+
+void add_iops_sample(struct thread_data *td, enum fio_ddir ddir,
+ struct timeval *t)
+{
+ struct thread_stat *ts = &td->ts;
+ unsigned long spent, iops;
+
+ if (!ddir_rw(ddir))
+ return;
+
+ spent = mtime_since(&td->iops_sample_time, t);
+ if (spent < td->o.iops_avg_time)
+ return;
+
+ iops = ((td->this_io_blocks[ddir] - td->stat_io_blocks[ddir]) * 1000) / spent;
+
+ add_stat_sample(&ts->iops_stat[ddir], iops);
+
+ if (td->iops_log) {
+ assert(iops);
+ add_log_sample(td, td->iops_log, iops, ddir, 0);
+ }
+
+ fio_gettime(&td->iops_sample_time, NULL);
+ td->stat_io_blocks[ddir] = td->this_io_blocks[ddir];
+}
projects / fio.git / blobdiff