p2 = num2str(iops_mean, ts->sig_figs, 1, 0, N2S_NONE);
log_buf(out, " steadystate : attained=%s, bw=%s (%s), iops=%s, %s%s=%.3f%s\n",
- ts->ss_state & __FIO_SS_ATTAINED ? "yes" : "no",
+ ts->ss_state & FIO_SS_ATTAINED ? "yes" : "no",
p1, p1alt, p2,
- ts->ss_state & __FIO_SS_IOPS ? "iops" : "bw",
- ts->ss_state & __FIO_SS_SLOPE ? " slope": " mean dev",
+ ts->ss_state & FIO_SS_IOPS ? "iops" : "bw",
+ ts->ss_state & FIO_SS_SLOPE ? " slope": " mean dev",
ts->ss_criterion.u.f,
- ts->ss_state & __FIO_SS_PCT ? "%" : "");
+ ts->ss_state & FIO_SS_PCT ? "%" : "");
free(p1);
free(p1alt);
char ss_buf[64];
snprintf(ss_buf, sizeof(ss_buf), "%s%s:%f%s",
- ts->ss_state & __FIO_SS_IOPS ? "iops" : "bw",
- ts->ss_state & __FIO_SS_SLOPE ? "_slope" : "",
+ ts->ss_state & FIO_SS_IOPS ? "iops" : "bw",
+ ts->ss_state & FIO_SS_SLOPE ? "_slope" : "",
(float) ts->ss_limit.u.f,
- ts->ss_state & __FIO_SS_PCT ? "%" : "");
+ ts->ss_state & FIO_SS_PCT ? "%" : "");
tmp = json_create_object();
json_object_add_value_object(root, "steadystate", tmp);
json_object_add_value_string(tmp, "ss", ss_buf);
json_object_add_value_int(tmp, "duration", (int)ts->ss_dur);
- json_object_add_value_int(tmp, "attained", (ts->ss_state & __FIO_SS_ATTAINED) > 0);
+ json_object_add_value_int(tmp, "attained", (ts->ss_state & FIO_SS_ATTAINED) > 0);
snprintf(ss_buf, sizeof(ss_buf), "%f%s", (float) ts->ss_criterion.u.f,
- ts->ss_state & __FIO_SS_PCT ? "%" : "");
+ ts->ss_state & FIO_SS_PCT ? "%" : "");
json_object_add_value_string(tmp, "criterion", ss_buf);
json_object_add_value_float(tmp, "max_deviation", ts->ss_deviation.u.f);
json_object_add_value_float(tmp, "slope", ts->ss_slope.u.f);
** otherwise it actually points to the second element
** in the list
*/
- if ((ts->ss_state & __FIO_SS_ATTAINED) || !(ts->ss_state & __FIO_SS_BUFFER_FULL))
+ if ((ts->ss_state & FIO_SS_ATTAINED) || !(ts->ss_state & FIO_SS_BUFFER_FULL))
j = ts->ss_head;
else
j = ts->ss_head == 0 ? ts->ss_dur - 1 : ts->ss_head - 1;
td->ss.bw_data = calloc(td->ss.dur, sizeof(uint64_t));
td->ss.iops_data = calloc(td->ss.dur, sizeof(uint64_t));
- td->ss.state |= __FIO_SS_DATA;
+ td->ss.state |= FIO_SS_DATA;
}
void steadystate_setup(void)
ss->bw_data[ss->tail] = bw;
ss->iops_data[ss->tail] = iops;
- if (ss->state & __FIO_SS_IOPS)
+ if (ss->state & FIO_SS_IOPS)
new_val = iops;
else
new_val = bw;
- if (ss->state & __FIO_SS_BUFFER_FULL || ss->tail - ss->head == ss->dur - 1) {
- if (!(ss->state & __FIO_SS_BUFFER_FULL)) {
+ if (ss->state & FIO_SS_BUFFER_FULL || ss->tail - ss->head == ss->dur - 1) {
+ if (!(ss->state & FIO_SS_BUFFER_FULL)) {
/* first time through */
for(i = 0, ss->sum_y = 0; i < ss->dur; i++) {
- if (ss->state & __FIO_SS_IOPS)
+ if (ss->state & FIO_SS_IOPS)
ss->sum_y += ss->iops_data[i];
else
ss->sum_y += ss->bw_data[i];
j = (ss->head + i) % ss->dur;
- if (ss->state & __FIO_SS_IOPS)
+ if (ss->state & FIO_SS_IOPS)
ss->sum_xy += i * ss->iops_data[j];
else
ss->sum_xy += i * ss->bw_data[j];
}
- ss->state |= __FIO_SS_BUFFER_FULL;
+ ss->state |= FIO_SS_BUFFER_FULL;
} else { /* easy to update the sums */
ss->sum_y -= ss->oldest_y;
ss->sum_y += new_val;
ss->sum_xy = ss->sum_xy - ss->sum_y + ss->dur * new_val;
}
- if (ss->state & __FIO_SS_IOPS)
+ if (ss->state & FIO_SS_IOPS)
ss->oldest_y = ss->iops_data[ss->head];
else
ss->oldest_y = ss->bw_data[ss->head];
*/
ss->slope = (ss->sum_xy - (double) ss->sum_x * ss->sum_y / ss->dur) /
(ss->sum_x_sq - (double) ss->sum_x * ss->sum_x / ss->dur);
- if (ss->state & __FIO_SS_PCT)
+ if (ss->state & FIO_SS_PCT)
ss->criterion = 100.0 * ss->slope / (ss->sum_y / ss->dur);
else
ss->criterion = ss->slope;
ss->bw_data[ss->tail] = bw;
ss->iops_data[ss->tail] = iops;
- if (ss->state & __FIO_SS_BUFFER_FULL || ss->tail - ss->head == ss->dur - 1) {
- if (!(ss->state & __FIO_SS_BUFFER_FULL)) {
+ if (ss->state & FIO_SS_BUFFER_FULL || ss->tail - ss->head == ss->dur - 1) {
+ if (!(ss->state & FIO_SS_BUFFER_FULL)) {
/* first time through */
for(i = 0, ss->sum_y = 0; i < ss->dur; i++)
- if (ss->state & __FIO_SS_IOPS)
+ if (ss->state & FIO_SS_IOPS)
ss->sum_y += ss->iops_data[i];
else
ss->sum_y += ss->bw_data[i];
- ss->state |= __FIO_SS_BUFFER_FULL;
+ ss->state |= FIO_SS_BUFFER_FULL;
} else { /* easy to update the sum */
ss->sum_y -= ss->oldest_y;
- if (ss->state & __FIO_SS_IOPS)
+ if (ss->state & FIO_SS_IOPS)
ss->sum_y += ss->iops_data[ss->tail];
else
ss->sum_y += ss->bw_data[ss->tail];
}
- if (ss->state & __FIO_SS_IOPS)
+ if (ss->state & FIO_SS_IOPS)
ss->oldest_y = ss->iops_data[ss->head];
else
ss->oldest_y = ss->bw_data[ss->head];
ss->deviation = 0.0;
for (i = 0; i < ss->dur; i++) {
- if (ss->state & __FIO_SS_IOPS)
+ if (ss->state & FIO_SS_IOPS)
diff = ss->iops_data[i] - mean;
else
diff = ss->bw_data[i] - mean;
ss->deviation = max(ss->deviation, diff * (diff < 0.0 ? -1.0 : 1.0));
}
- if (ss->state & __FIO_SS_PCT)
+ if (ss->state & FIO_SS_PCT)
ss->criterion = 100.0 * ss->deviation / mean;
else
ss->criterion = ss->deviation;
if (!ss->dur || td->runstate <= TD_SETTING_UP ||
td->runstate >= TD_EXITED || !ss->state ||
- ss->state & __FIO_SS_ATTAINED)
+ ss->state & FIO_SS_ATTAINED)
continue;
td_iops = 0;
prev_groupid = td->groupid;
fio_gettime(&now, NULL);
- if (ss->ramp_time && !(ss->state & __FIO_SS_RAMP_OVER)) {
+ if (ss->ramp_time && !(ss->state & FIO_SS_RAMP_OVER)) {
/*
* Begin recording data one second after ss->ramp_time
* has elapsed
*/
if (utime_since(&td->epoch, &now) >= (ss->ramp_time + 1000000L))
- ss->state |= __FIO_SS_RAMP_OVER;
+ ss->state |= FIO_SS_RAMP_OVER;
}
td_io_u_lock(td);
* prev_iops/bw the first time through after ss->ramp_time
* is done.
*/
- if (ss->state & __FIO_SS_RAMP_OVER) {
+ if (ss->state & FIO_SS_RAMP_OVER) {
group_bw += 1000 * (td_bytes - ss->prev_bytes) / rate_time;
group_iops += 1000 * (td_iops - ss->prev_iops) / rate_time;
++group_ramp_time_over;
ss->prev_iops = td_iops;
ss->prev_bytes = td_bytes;
- if (td->o.group_reporting && !(ss->state & __FIO_SS_DATA))
+ if (td->o.group_reporting && !(ss->state & FIO_SS_DATA))
continue;
/*
(unsigned long long) group_bw,
ss->head, ss->tail);
- if (ss->state & __FIO_SS_SLOPE)
+ if (ss->state & FIO_SS_SLOPE)
ret = steadystate_slope(group_iops, group_bw, td);
else
ret = steadystate_deviation(group_iops, group_bw, td);
if (td->o.group_reporting) {
for_each_td(td2, j) {
if (td2->groupid == td->groupid) {
- td2->ss.state |= __FIO_SS_ATTAINED;
+ td2->ss.state |= FIO_SS_ATTAINED;
fio_mark_td_terminate(td2);
}
}
} else {
- ss->state |= __FIO_SS_ATTAINED;
+ ss->state |= FIO_SS_ATTAINED;
fio_mark_td_terminate(td);
}
}
ss->state = o->ss_state;
if (!td->ss.ramp_time)
- ss->state |= __FIO_SS_RAMP_OVER;
+ ss->state |= FIO_SS_RAMP_OVER;
ss->sum_x = o->ss_dur * (o->ss_dur - 1) / 2;
ss->sum_x_sq = (o->ss_dur - 1) * (o->ss_dur) * (2*o->ss_dur - 1) / 6;
};
enum {
- __FIO_SS_IOPS = 1,
- __FIO_SS_BW = 2,
- __FIO_SS_SLOPE = 4,
- __FIO_SS_ATTAINED = 8,
- __FIO_SS_RAMP_OVER = 16,
- __FIO_SS_DATA = 32,
- __FIO_SS_PCT = 64,
- __FIO_SS_BUFFER_FULL = 128,
-
- FIO_SS_IOPS = __FIO_SS_IOPS,
- FIO_SS_IOPS_SLOPE = __FIO_SS_IOPS | __FIO_SS_SLOPE,
- FIO_SS_BW = __FIO_SS_BW,
- FIO_SS_BW_SLOPE = __FIO_SS_BW | __FIO_SS_SLOPE,
+ __FIO_SS_IOPS = 0,
+ __FIO_SS_BW,
+ __FIO_SS_SLOPE,
+ __FIO_SS_ATTAINED,
+ __FIO_SS_RAMP_OVER,
+ __FIO_SS_DATA,
+ __FIO_SS_PCT,
+ __FIO_SS_BUFFER_FULL,
+};
+
+enum {
+ FIO_SS_IOPS = 1 << __FIO_SS_IOPS,
+ FIO_SS_BW = 1 << __FIO_SS_BW,
+ FIO_SS_SLOPE = 1 << __FIO_SS_SLOPE,
+ FIO_SS_ATTAINED = 1 << __FIO_SS_ATTAINED,
+ FIO_SS_RAMP_OVER = 1 << __FIO_SS_RAMP_OVER,
+ FIO_SS_DATA = 1 << __FIO_SS_DATA,
+ FIO_SS_PCT = 1 << __FIO_SS_PCT,
+ FIO_SS_BUFFER_FULL = 1 << __FIO_SS_BUFFER_FULL,
+
+ FIO_SS_IOPS_SLOPE = FIO_SS_IOPS | FIO_SS_SLOPE,
+ FIO_SS_BW_SLOPE = FIO_SS_BW | FIO_SS_SLOPE,
};
#define STEADYSTATE_MSEC 1000