Compiling on certain platforms produces warnings like
stat.c: In function ‘add_clat_sample’:
stat.c:2241:28: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
because the size of a pointer is different to that of a long. Work
around this by explicitly naming the union used in io_sample, forcing
the "val" in the union to be a uint64_t, changing function parameters to
accept a union (rather than an unsigned long) and adding helper
functions to wrap values into a union.
Signed-off-by: Sitsofe Wheeler <sitsofe@yahoo.com>
s = (struct io_sample *)((char *)__get_sample(samples, log_offset, i) +
i * sizeof(struct io_u_plat_entry));
s = (struct io_sample *)((char *)__get_sample(samples, log_offset, i) +
i * sizeof(struct io_u_plat_entry));
+ entry = s->data.plat_entry;
io_u_plat = entry->io_u_plat;
fprintf(f, "%lu, %u, %u, ", (unsigned long) s->time,
io_u_plat = entry->io_u_plat;
fprintf(f, "%lu, %u, %u, ", (unsigned long) s->time,
s = (struct io_sample *)((void *)s + sizeof(struct io_u_plat_entry) * i);
s->time = le64_to_cpu(s->time);
s = (struct io_sample *)((void *)s + sizeof(struct io_u_plat_entry) * i);
s->time = le64_to_cpu(s->time);
- s->val = le64_to_cpu(s->val);
+ s->data.val = le64_to_cpu(s->data.val);
s->__ddir = le32_to_cpu(s->__ddir);
s->bs = le32_to_cpu(s->bs);
s->__ddir = le32_to_cpu(s->__ddir);
s->bs = le32_to_cpu(s->bs);
}
if (ret->log_type == IO_LOG_TYPE_HIST) {
}
if (ret->log_type == IO_LOG_TYPE_HIST) {
- s->plat_entry = (struct io_u_plat_entry *)(((void *)s) + sizeof(*s));
- s->plat_entry->list.next = NULL;
- s->plat_entry->list.prev = NULL;
+ s->data.plat_entry = (struct io_u_plat_entry *)(((void *)s) + sizeof(*s));
+ s->data.plat_entry->list.next = NULL;
+ s->data.plat_entry->list.prev = NULL;
calc_rate(unified_rw_rep, rate_time, io_bytes, rate_io_bytes,
je->rate);
memcpy(&rate_prev_time, &now, sizeof(now));
calc_rate(unified_rw_rep, rate_time, io_bytes, rate_io_bytes,
je->rate);
memcpy(&rate_prev_time, &now, sizeof(now));
- add_agg_sample(je->rate[DDIR_READ], DDIR_READ, 0);
- add_agg_sample(je->rate[DDIR_WRITE], DDIR_WRITE, 0);
- add_agg_sample(je->rate[DDIR_TRIM], DDIR_TRIM, 0);
+ add_agg_sample(sample_val(je->rate[DDIR_READ]), DDIR_READ, 0);
+ add_agg_sample(sample_val(je->rate[DDIR_WRITE]), DDIR_WRITE, 0);
+ add_agg_sample(sample_val(je->rate[DDIR_TRIM]), DDIR_TRIM, 0);
}
disp_time = mtime_since(&disp_prev_time, &now);
}
disp_time = mtime_since(&disp_prev_time, &now);
for (i = 0; i < nr_samples; i++) {
s = __get_sample(samples, log_offset, i);
for (i = 0; i < nr_samples; i++) {
s = __get_sample(samples, log_offset, i);
- entry = (struct io_u_plat_entry *) (uintptr_t) s->val;
+ entry = s->data.plat_entry;
io_u_plat = entry->io_u_plat;
entry_before = flist_first_entry(&entry->list, struct io_u_plat_entry, list);
io_u_plat = entry->io_u_plat;
entry_before = flist_first_entry(&entry->list, struct io_u_plat_entry, list);
s = __get_sample(samples, log_offset, i);
if (!log_offset) {
s = __get_sample(samples, log_offset, i);
if (!log_offset) {
- fprintf(f, "%lu, %lu, %u, %u\n",
+ fprintf(f, "%lu, %" PRId64 ", %u, %u\n",
- (unsigned long) s->val,
io_sample_ddir(s), s->bs);
} else {
struct io_sample_offset *so = (void *) s;
io_sample_ddir(s), s->bs);
} else {
struct io_sample_offset *so = (void *) s;
- fprintf(f, "%lu, %lu, %u, %u, %llu\n",
+ fprintf(f, "%lu, %" PRId64 ", %u, %u, %llu\n",
- (unsigned long) s->val,
io_sample_ddir(s), s->bs,
(unsigned long long) so->offset);
}
io_sample_ddir(s), s->bs,
(unsigned long long) so->offset);
}
struct flist_head list;
};
struct flist_head list;
};
+
+union io_sample_data {
+ uint64_t val;
+ struct io_u_plat_entry *plat_entry;
+};
+
+#define sample_val(value) ((union io_sample_data) { .val = value })
+#define sample_plat(plat) ((union io_sample_data) { .plat_entry = plat })
+
/*
* A single data sample
*/
struct io_sample {
uint64_t time;
/*
* A single data sample
*/
struct io_sample {
uint64_t time;
- union {
- uint64_t val;
- struct io_u_plat_entry *plat_entry;
- };
+ union io_sample_data data;
uint32_t __ddir;
uint32_t bs;
};
uint32_t __ddir;
uint32_t bs;
};
/* Do the subtraction on server side so that client doesn't have to
* reconstruct our linked list from packets.
*/
/* Do the subtraction on server side so that client doesn't have to
* reconstruct our linked list from packets.
*/
- cur_plat_entry = s->plat_entry;
+ cur_plat_entry = s->data.plat_entry;
prev_plat_entry = flist_first_entry(&cur_plat_entry->list, struct io_u_plat_entry, list);
cur_plat = cur_plat_entry->io_u_plat;
prev_plat = prev_plat_entry->io_u_plat;
prev_plat_entry = flist_first_entry(&cur_plat_entry->list, struct io_u_plat_entry, list);
cur_plat = cur_plat_entry->io_u_plat;
prev_plat = prev_plat_entry->io_u_plat;
struct io_sample *s = get_sample(log, cur_log, i);
s->time = cpu_to_le64(s->time);
struct io_sample *s = get_sample(log, cur_log, i);
s->time = cpu_to_le64(s->time);
- s->val = cpu_to_le64(s->val);
+ s->data.val = cpu_to_le64(s->data.val);
s->__ddir = cpu_to_le32(s->__ddir);
s->bs = cpu_to_le32(s->bs);
s->__ddir = cpu_to_le32(s->__ddir);
s->bs = cpu_to_le32(s->bs);
-static void __add_log_sample(struct io_log *iolog, unsigned long val,
+static void __add_log_sample(struct io_log *iolog, union io_sample_data data,
enum fio_ddir ddir, unsigned int bs,
unsigned long t, uint64_t offset)
{
enum fio_ddir ddir, unsigned int bs,
unsigned long t, uint64_t offset)
{
s = get_sample(iolog, cur_log, cur_log->nr_samples);
s = get_sample(iolog, cur_log, cur_log->nr_samples);
s->time = t + (iolog->td ? iolog->td->unix_epoch : 0);
io_sample_set_ddir(iolog, s, ddir);
s->bs = bs;
s->time = t + (iolog->td ? iolog->td->unix_epoch : 0);
io_sample_set_ddir(iolog, s, ddir);
s->bs = bs;
* had actual samples done.
*/
if (iolog->avg_window[ddir].samples) {
* had actual samples done.
*/
if (iolog->avg_window[ddir].samples) {
+ union io_sample_data data;
- val = iolog->avg_window[ddir].max_val;
+ data.val = iolog->avg_window[ddir].max_val;
- val = iolog->avg_window[ddir].mean.u.f + 0.50;
+ data.val = iolog->avg_window[ddir].mean.u.f + 0.50;
- __add_log_sample(iolog, val, ddir, 0, elapsed, 0);
+ __add_log_sample(iolog, data, ddir, 0, elapsed, 0);
}
reset_io_stat(&iolog->avg_window[ddir]);
}
reset_io_stat(&iolog->avg_window[ddir]);
}
static long 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,
+ union io_sample_data data, enum fio_ddir ddir,
unsigned int bs, uint64_t offset)
{
unsigned long elapsed, this_window;
unsigned int bs, uint64_t offset)
{
unsigned long elapsed, this_window;
* If no time averaging, just add the log sample.
*/
if (!iolog->avg_msec) {
* If no time averaging, just add the log sample.
*/
if (!iolog->avg_msec) {
- __add_log_sample(iolog, val, ddir, bs, elapsed, offset);
+ __add_log_sample(iolog, data, ddir, bs, elapsed, offset);
* Add the sample. If the time period has passed, then
* add that entry to the log and clear.
*/
* Add the sample. If the time period has passed, then
* add that entry to the log and clear.
*/
- add_stat_sample(&iolog->avg_window[ddir], val);
+ add_stat_sample(&iolog->avg_window[ddir], data.val);
/*
* If period hasn't passed, adding the above sample is all we
/*
* If period hasn't passed, adding the above sample is all we
_add_stat_to_log(td->iops_log, elapsed, td->o.log_max != 0);
}
_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)
+void add_agg_sample(union io_sample_data data, enum fio_ddir ddir, unsigned int bs)
return;
iolog = agg_io_log[ddir];
return;
iolog = agg_io_log[ddir];
- __add_log_sample(iolog, val, ddir, bs, mtime_since_genesis(), 0);
+ __add_log_sample(iolog, data, ddir, bs, mtime_since_genesis(), 0);
}
static void add_clat_percentile_sample(struct thread_stat *ts,
}
static void add_clat_percentile_sample(struct thread_stat *ts,
add_stat_sample(&ts->clat_stat[ddir], usec);
if (td->clat_log)
add_stat_sample(&ts->clat_stat[ddir], usec);
if (td->clat_log)
- add_log_sample(td, td->clat_log, usec, ddir, bs, offset);
+ add_log_sample(td, td->clat_log, sample_val(usec), ddir, bs,
+ offset);
if (ts->clat_percentiles)
add_clat_percentile_sample(ts, usec, ddir);
if (ts->clat_percentiles)
add_clat_percentile_sample(ts, usec, ddir);
memcpy(&(dst->io_u_plat), io_u_plat,
FIO_IO_U_PLAT_NR * sizeof(unsigned int));
flist_add(&dst->list, &hw->list);
memcpy(&(dst->io_u_plat), io_u_plat,
FIO_IO_U_PLAT_NR * sizeof(unsigned int));
flist_add(&dst->list, &hw->list);
- __add_log_sample(iolog, (unsigned long)dst, ddir, bs,
+ __add_log_sample(iolog, sample_plat(dst), ddir, bs,
add_stat_sample(&ts->slat_stat[ddir], usec);
if (td->slat_log)
add_stat_sample(&ts->slat_stat[ddir], usec);
if (td->slat_log)
- add_log_sample(td, td->slat_log, usec, ddir, bs, offset);
+ add_log_sample(td, td->slat_log, sample_val(usec), ddir, bs, offset);
add_stat_sample(&ts->lat_stat[ddir], usec);
if (td->lat_log)
add_stat_sample(&ts->lat_stat[ddir], usec);
if (td->lat_log)
- add_log_sample(td, td->lat_log, usec, ddir, bs, offset);
+ add_log_sample(td, td->lat_log, sample_val(usec), ddir, bs,
+ offset);
add_stat_sample(&ts->bw_stat[io_u->ddir], rate);
if (td->bw_log)
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);
+ add_log_sample(td, td->bw_log, sample_val(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);
td->stat_io_bytes[io_u->ddir] = td->this_io_bytes[io_u->ddir];
td_io_u_unlock(td);
if (td->o.min_bs[ddir] == td->o.max_bs[ddir])
bs = td->o.min_bs[ddir];
if (td->o.min_bs[ddir] == td->o.max_bs[ddir])
bs = td->o.min_bs[ddir];
- next = add_log_sample(td, td->bw_log, rate, ddir, bs, 0);
+ next = add_log_sample(td, td->bw_log, sample_val(rate),
+ ddir, bs, 0);
next_log = min(next_log, next);
}
next_log = min(next_log, next);
}
add_stat_sample(&ts->iops_stat[io_u->ddir], 1);
if (td->iops_log)
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);
+ add_log_sample(td, td->iops_log, sample_val(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);
td->stat_io_blocks[io_u->ddir] = td->this_io_blocks[io_u->ddir];
td_io_u_unlock(td);
if (td->o.min_bs[ddir] == td->o.max_bs[ddir])
bs = td->o.min_bs[ddir];
if (td->o.min_bs[ddir] == td->o.max_bs[ddir])
bs = td->o.min_bs[ddir];
- next = add_log_sample(td, td->iops_log, iops, ddir, bs, 0);
+ next = add_log_sample(td, td->iops_log,
+ sample_val(iops), ddir, bs, 0);
next_log = min(next_log, next);
}
next_log = min(next_log, next);
}
unsigned int, uint64_t);
extern void add_slat_sample(struct thread_data *, enum fio_ddir, unsigned long,
unsigned int, uint64_t);
unsigned int, uint64_t);
extern void add_slat_sample(struct thread_data *, enum fio_ddir, unsigned long,
unsigned int, uint64_t);
-extern void add_agg_sample(unsigned long, enum fio_ddir, unsigned int);
+extern void add_agg_sample(union io_sample_data, enum fio_ddir, unsigned int);
extern void add_iops_sample(struct thread_data *, struct io_u *,
unsigned int);
extern void add_bw_sample(struct thread_data *, struct io_u *,
extern void add_iops_sample(struct thread_data *, struct io_u *,
unsigned int);
extern void add_bw_sample(struct thread_data *, struct io_u *,