with the caveat that when used on the command line, they must come after the
:option:`ioengine` that defines them is selected.
-.. option:: cmdprio_percentage=int : [io_uring] [libaio]
-
- Set the percentage of I/O that will be issued with higher priority by setting
- the priority bit. Non-read I/O is likely unaffected by ``cmdprio_percentage``.
- This option cannot be used with the `prio` or `prioclass` options. For this
- option to set the priority bit properly, NCQ priority must be supported and
- enabled and :option:`direct`\=1 option must be used. fio must also be run as
- the root user.
+.. option:: cmdprio_percentage=int[,int] : [io_uring] [libaio]
+
+ Set the percentage of I/O that will be issued with the highest priority.
+ Default: 0. A single value applies to reads and writes. Comma-separated
+ values may be specified for reads and writes. This option cannot be used
+ with the :option:`prio` or :option:`prioclass` options. For this option
+ to be effective, NCQ priority must be supported and enabled, and `direct=1'
+ option must be used. fio must also be run as the root user.
.. option:: fixedbufs : [io_uring]
--- /dev/null
+/*
+ * IO priority handling declarations and helper functions common to the
+ * libaio and io_uring engines.
+ */
+
+#ifndef FIO_CMDPRIO_H
+#define FIO_CMDPRIO_H
+
+#include "../fio.h"
+
+struct cmdprio {
+ unsigned int percentage[DDIR_RWDIR_CNT];
+};
+
+static int fio_cmdprio_init(struct thread_data *td, struct cmdprio *cmdprio,
+ bool *has_cmdprio)
+{
+ struct thread_options *to = &td->o;
+ bool has_cmdprio_percentage = false;
+ int i;
+
+ for (i = 0; i < DDIR_RWDIR_CNT; i++) {
+ if (cmdprio->percentage[i])
+ has_cmdprio_percentage = true;
+ }
+
+ /*
+ * Check for option conflicts
+ */
+ if (has_cmdprio_percentage &&
+ (fio_option_is_set(to, ioprio) ||
+ fio_option_is_set(to, ioprio_class))) {
+ log_err("%s: cmdprio_percentage option and mutually exclusive "
+ "prio or prioclass option is set, exiting\n",
+ to->name);
+ return 1;
+ }
+
+ *has_cmdprio = has_cmdprio_percentage;
+
+ return 0;
+}
+
+#endif
#include "../lib/types.h"
#include "../os/linux/io_uring.h"
+#include "cmdprio.h"
struct io_sq_ring {
unsigned *head;
int prepped;
struct ioring_mmap mmap[3];
+
+ bool use_cmdprio;
};
struct ioring_options {
void *pad;
unsigned int hipri;
- unsigned int cmdprio_percentage;
+ struct cmdprio cmdprio;
unsigned int fixedbufs;
unsigned int registerfiles;
unsigned int sqpoll_thread;
.name = "cmdprio_percentage",
.lname = "high priority percentage",
.type = FIO_OPT_INT,
- .off1 = offsetof(struct ioring_options, cmdprio_percentage),
- .minval = 1,
+ .off1 = offsetof(struct ioring_options,
+ cmdprio.percentage[DDIR_READ]),
+ .off2 = offsetof(struct ioring_options,
+ cmdprio.percentage[DDIR_WRITE]),
+ .minval = 0,
.maxval = 100,
.help = "Send high priority I/O this percentage of the time",
.category = FIO_OPT_C_ENGINE,
{
struct ioring_options *o = td->eo;
struct ioring_data *ld = td->io_ops_data;
- if (rand_between(&td->prio_state, 0, 99) < o->cmdprio_percentage) {
- ld->sqes[io_u->index].ioprio = ioprio_value(IOPRIO_CLASS_RT, 0);
+ struct io_uring_sqe *sqe = &ld->sqes[io_u->index];
+ struct cmdprio *cmdprio = &o->cmdprio;
+ unsigned int p = cmdprio->percentage[io_u->ddir];
+
+ if (p && rand_between(&td->prio_state, 0, 99) < p) {
+ sqe->ioprio = ioprio_value(IOPRIO_CLASS_RT, 0);
io_u->flags |= IO_U_F_PRIORITY;
} else {
- ld->sqes[io_u->index].ioprio = 0;
+ sqe->ioprio = 0;
}
- return;
}
static enum fio_q_status fio_ioring_queue(struct thread_data *td,
{
struct ioring_data *ld = td->io_ops_data;
struct io_sq_ring *ring = &ld->sq_ring;
- struct ioring_options *o = td->eo;
unsigned tail, next_tail;
fio_ro_check(td, io_u);
if (next_tail == atomic_load_acquire(ring->head))
return FIO_Q_BUSY;
- if (o->cmdprio_percentage)
+ if (ld->use_cmdprio)
fio_ioring_prio_prep(td, io_u);
ring->array[tail & ld->sq_ring_mask] = io_u->index;
atomic_store_release(ring->tail, next_tail);
{
struct ioring_options *o = td->eo;
struct ioring_data *ld;
- struct thread_options *to = &td->o;
+ struct cmdprio *cmdprio = &o->cmdprio;
+ int ret;
/* sqthread submission requires registered files */
if (o->sqpoll_thread)
td->io_ops_data = ld;
- /*
- * Check for option conflicts
- */
- if ((fio_option_is_set(to, ioprio) || fio_option_is_set(to, ioprio_class)) &&
- o->cmdprio_percentage != 0) {
- log_err("%s: cmdprio_percentage option and mutually exclusive "
- "prio or prioclass option is set, exiting\n", to->name);
- td_verror(td, EINVAL, "fio_io_uring_init");
+ ret = fio_cmdprio_init(td, cmdprio, &ld->use_cmdprio);
+ if (ret) {
+ td_verror(td, EINVAL, "fio_ioring_init");
return 1;
}
#include "../lib/pow2.h"
#include "../optgroup.h"
#include "../lib/memalign.h"
+#include "cmdprio.h"
/* Should be defined in newest aio_abi.h */
#ifndef IOCB_FLAG_IOPRIO
unsigned int queued;
unsigned int head;
unsigned int tail;
+
+ bool use_cmdprio;
};
struct libaio_options {
void *pad;
unsigned int userspace_reap;
- unsigned int cmdprio_percentage;
+ struct cmdprio cmdprio;
unsigned int nowait;
};
.name = "cmdprio_percentage",
.lname = "high priority percentage",
.type = FIO_OPT_INT,
- .off1 = offsetof(struct libaio_options, cmdprio_percentage),
- .minval = 1,
+ .off1 = offsetof(struct libaio_options,
+ cmdprio.percentage[DDIR_READ]),
+ .off2 = offsetof(struct libaio_options,
+ cmdprio.percentage[DDIR_WRITE]),
+ .minval = 0,
.maxval = 100,
.help = "Send high priority I/O this percentage of the time",
.category = FIO_OPT_C_ENGINE,
static void fio_libaio_prio_prep(struct thread_data *td, struct io_u *io_u)
{
struct libaio_options *o = td->eo;
- if (rand_between(&td->prio_state, 0, 99) < o->cmdprio_percentage) {
+ struct cmdprio *cmdprio = &o->cmdprio;
+ unsigned int p = cmdprio->percentage[io_u->ddir];
+
+ if (p && rand_between(&td->prio_state, 0, 99) < p) {
io_u->iocb.aio_reqprio = ioprio_value(IOPRIO_CLASS_RT, 0);
io_u->iocb.u.c.flags |= IOCB_FLAG_IOPRIO;
io_u->flags |= IO_U_F_PRIORITY;
}
- return;
}
static struct io_u *fio_libaio_event(struct thread_data *td, int event)
struct io_u *io_u)
{
struct libaio_data *ld = td->io_ops_data;
- struct libaio_options *o = td->eo;
fio_ro_check(td, io_u);
return FIO_Q_COMPLETED;
}
- if (o->cmdprio_percentage)
+ if (ld->use_cmdprio)
fio_libaio_prio_prep(td, io_u);
ld->iocbs[ld->head] = &io_u->iocb;
static int fio_libaio_init(struct thread_data *td)
{
struct libaio_data *ld;
- struct thread_options *to = &td->o;
struct libaio_options *o = td->eo;
+ struct cmdprio *cmdprio = &o->cmdprio;
+ int ret;
ld = calloc(1, sizeof(*ld));
ld->io_us = calloc(ld->entries, sizeof(struct io_u *));
td->io_ops_data = ld;
- /*
- * Check for option conflicts
- */
- if ((fio_option_is_set(to, ioprio) || fio_option_is_set(to, ioprio_class)) &&
- o->cmdprio_percentage != 0) {
- log_err("%s: cmdprio_percentage option and mutually exclusive "
- "prio or prioclass option is set, exiting\n", to->name);
+
+ ret = fio_cmdprio_init(td, cmdprio, &ld->use_cmdprio);
+ if (ret) {
td_verror(td, EINVAL, "fio_libaio_init");
return 1;
}
+
return 0;
}
with the caveat that when used on the command line, they must come after the
\fBioengine\fR that defines them is selected.
.TP
-.BI (io_uring,libaio)cmdprio_percentage \fR=\fPint
-Set the percentage of I/O that will be issued with higher priority by setting
-the priority bit. Non-read I/O is likely unaffected by ``cmdprio_percentage``.
-This option cannot be used with the `prio` or `prioclass` options. For this
-option to set the priority bit properly, NCQ priority must be supported and
-enabled and `direct=1' option must be used. fio must also be run as the root
-user.
+.BI (io_uring,libaio)cmdprio_percentage \fR=\fPint[,int]
+Set the percentage of I/O that will be issued with the highest priority.
+Default: 0. A single value applies to reads and writes. Comma-separated
+values may be specified for reads and writes. This option cannot be used
+with the `prio` or `prioclass` options. For this option to be effective,
+NCQ priority must be supported and enabled, and `direct=1' option must be
+used. fio must also be run as the root user.
.TP
.BI (io_uring)fixedbufs
If fio is asked to do direct IO, then Linux will map pages for each IO call, and