the job to exit. The same format as rate is used for read vs
write separation.
-rate_poisson=bool Real world random request flow follows Poisson process
- (https://en.wikipedia.org/wiki/Poisson_process). With
- rate_poisson=1, fio tries to simulate request flow under Poisson
- process (instead of even distribution, which is the default).
- Default: false.
+rate_process=str This option controls how fio manages rated IO
+ submissions. The default is 'linear', which submits IO in a
+ linear fashion with fixed delays between IOs that gets
+ adjusted based on IO completion rates. If this is set to
+ 'poisson', fio will submit IO based on a more real world
+ random request flow, known as the Poisson process
+ (https://en.wikipedia.org/wiki/Poisson_process).
latency_target=int If set, fio will attempt to find the max performance
point that the given workload will run at while maintaining a
bytes = td->rate_io_issue_bytes[ddir];
bps = td->rate_bps[ddir];
- if (td->o.poisson_rate) {
+ if (td->o.rate_process == RATE_PROCESS_POISSON) {
uint64_t val;
iops = bps / td->o.bs[ddir];
val = (int64_t) (1000000 / iops) *
o->per_job_logs = le32_to_cpu(top->per_job_logs);
o->trim_backlog = le64_to_cpu(top->trim_backlog);
- o->poisson_rate = le32_to_cpu(top->poisson_rate);
+ o->rate_process = le32_to_cpu(top->rate_process);
for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++)
o->percentile_list[i].u.f = fio_uint64_to_double(le64_to_cpu(top->percentile_list[i].u.i));
top->trim_backlog = __cpu_to_le64(o->trim_backlog);
top->offset_increment = __cpu_to_le64(o->offset_increment);
top->number_ios = __cpu_to_le64(o->number_ios);
- top->poisson_rate = cpu_to_le32(o->poisson_rate);
+ top->rate_process = cpu_to_le32(o->rate_process);
for (i = 0; i < FIO_IO_U_LIST_MAX_LEN; i++)
top->percentile_list[i].u.i = __cpu_to_le64(fio_double_to_uint64(o->percentile_list[i].u.f));
# Real world random request flow follows Poisson process. To give better
# insight on latency distribution, we simulate request flow under Poisson
# process.
-rate_poisson=1
\ No newline at end of file
+rate_process=poisson
If this rate of I/O is not met, the job will exit. The same format as \fBrate\fR
is used for read vs write separation.
.TP
-.BI rate_poisson \fR=\fPbool
-Real world random request flow follows Poisson process
-(https://en.wikipedia.org/wiki/Poisson_process). With \fBrate_poisson\fR=1, fio
-tries to simulate request flow under Poisson process (instead of even
-distribution, which is the default). Default: false.
+.BI rate_process \fR=\fPstr
+This option controls how fio manages rated IO submissions. The default is
+\fBlinear\fR, which submits IO in a linear fashion with fixed delays between
+IOs that gets adjusted based on IO completion rates. If this is set to
+\fBpoisson\fR, fio will submit IO based on a more real world random request
+flow, known as the Poisson process
+(https://en.wikipedia.org/wiki/Poisson_process).
.TP
.BI rate_cycle \fR=\fPint
Average bandwidth for \fBrate\fR and \fBrate_min\fR over this number of
enum {
IO_MODE_INLINE = 0,
- IO_MODE_OFFLOAD,
+ IO_MODE_OFFLOAD = 1,
+
+ RATE_PROCESS_LINEAR = 0,
+ RATE_PROCESS_POISSON = 1,
};
/*
.group = FIO_OPT_G_RATE,
},
{
- .name = "rate_poisson",
- .lname = "simulate requests under Poisson process",
- .type = FIO_OPT_BOOL,
- .off1 = td_var_offset(poisson_rate),
- .help = "With rate limit, simulate requests that follow Poisson process",
- .def = "0",
- .parent = "rate",
- .hide = 1,
+ .name = "rate_process",
+ .lname = "Rate Process",
+ .type = FIO_OPT_STR,
+ .off1 = td_var_offset(rate_process),
+ .help = "What process controls how rated IO is managed",
+ .def = "linear",
.category = FIO_OPT_C_IO,
.group = FIO_OPT_G_RATE,
+ .posval = {
+ { .ival = "linear",
+ .oval = RATE_PROCESS_LINEAR,
+ .help = "Linear rate of IO",
+ },
+ {
+ .ival = "poisson",
+ .oval = RATE_PROCESS_POISSON,
+ .help = "Rate follows Poisson process",
+ },
+ },
+ .parent = "rate",
},
{
.name = "rate_cycle",
unsigned int io_submit_mode;
unsigned int rate_iops[DDIR_RWDIR_CNT];
unsigned int rate_iops_min[DDIR_RWDIR_CNT];
- unsigned int poisson_rate;
+ unsigned int rate_process;
char *ioscheduler;
uint32_t io_submit_mode;
uint32_t rate_iops[DDIR_RWDIR_CNT];
uint32_t rate_iops_min[DDIR_RWDIR_CNT];
- uint32_t poisson_rate;
+ uint32_t rate_process;
uint32_t padding_0; /* for alignment assert */
uint8_t ioscheduler[FIO_TOP_STR_MAX];