libaio,io_uring: move common cmdprio_prep() code to cmdprio

Move common cmdprio_prep() code to cmdprio.c to avoid code duplication.

Signed-off-by: Niklas Cassel <niklas.cassel@wdc.com>
Reviewed-by: Damien Le Moal <damien.lemoal@opensource.wdc.com>
Link: https://lore.kernel.org/r/20211112095428.158300-7-Niklas.Cassel@wdc.com
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/engines/cmdprio.c b/engines/cmdprio.c
index 2c764e496cbc2fc42e3fff2e51c9d0fc894161df..d36b6264e07d1dfb735ee2efb3ef2b735b8021a2 100644 (file)
--- a/engines/cmdprio.c
+++ b/engines/cmdprio.c
@@ -67,7 +67,7 @@ int fio_cmdprio_bssplit_parse(struct thread_data *td, const char *input,
        return ret;
 }
 
-int fio_cmdprio_percentage(struct cmdprio *cmdprio, struct io_u *io_u)
+static int fio_cmdprio_percentage(struct cmdprio *cmdprio, struct io_u *io_u)
 {
        enum fio_ddir ddir = io_u->ddir;
        unsigned int p = cmdprio->percentage[ddir];
@@ -89,6 +89,51 @@ int fio_cmdprio_percentage(struct cmdprio *cmdprio, struct io_u *io_u)
        return 0;
 }
 
+/**
+ * fio_cmdprio_set_ioprio - Set an io_u ioprio according to cmdprio options
+ *
+ * Generates a random percentage value to determine if an io_u ioprio needs
+ * to be set. If the random percentage value is within the user specified
+ * percentage of I/Os that should use a cmdprio priority value (rather than
+ * the default priority), then this function updates the io_u with an ioprio
+ * value as defined by the cmdprio/cmdprio_class or cmdprio_bssplit options.
+ *
+ * Return true if the io_u ioprio was changed and false otherwise.
+ */
+bool fio_cmdprio_set_ioprio(struct thread_data *td, struct cmdprio *cmdprio,
+                           struct io_u *io_u)
+{
+       enum fio_ddir ddir = io_u->ddir;
+       unsigned int p = fio_cmdprio_percentage(cmdprio, io_u);
+       unsigned int cmdprio_value =
+               ioprio_value(cmdprio->class[ddir], cmdprio->level[ddir]);
+
+       if (p && rand_between(&td->prio_state, 0, 99) < p) {
+               io_u->ioprio = cmdprio_value;
+               if (!td->ioprio || cmdprio_value < td->ioprio) {
+                       /*
+                        * The async IO priority is higher (has a lower value)
+                        * than the default priority (which is either 0 or the
+                        * value set by "prio" and "prioclass" options).
+                        */
+                       io_u->flags |= IO_U_F_HIGH_PRIO;
+               }
+               return true;
+       }
+
+       if (td->ioprio && td->ioprio < cmdprio_value) {
+               /*
+                * The IO will be executed with the default priority (which is
+                * either 0 or the value set by "prio" and "prioclass options),
+                * and this priority is higher (has a lower value) than the
+                * async IO priority.
+                */
+               io_u->flags |= IO_U_F_HIGH_PRIO;
+       }
+
+       return false;
+}
+
 int fio_cmdprio_init(struct thread_data *td, struct cmdprio *cmdprio,
                     bool *has_cmdprio)
 {

diff --git a/engines/cmdprio.h b/engines/cmdprio.h
index d3265741b554dc0c03b183cc46d0f0352222f798..732b087e5df637633fb6ba6deac6d19f2649a3c8 100644 (file)
--- a/engines/cmdprio.h
+++ b/engines/cmdprio.h
@@ -22,7 +22,8 @@ struct cmdprio {
 int fio_cmdprio_bssplit_parse(struct thread_data *td, const char *input,
                              struct cmdprio *cmdprio);
 
-int fio_cmdprio_percentage(struct cmdprio *cmdprio, struct io_u *io_u);
+bool fio_cmdprio_set_ioprio(struct thread_data *td, struct cmdprio *cmdprio,
+                           struct io_u *io_u);
 
 int fio_cmdprio_init(struct thread_data *td, struct cmdprio *cmdprio,
                     bool *has_cmdprio);

diff --git a/engines/io_uring.c b/engines/io_uring.c
index 0568b8f7cba344e0c1bd9c6d14abe81a76e65fbc..68c3311386da328abe7e19b435186b6a3fbe7fdd 100644 (file)
--- a/engines/io_uring.c
+++ b/engines/io_uring.c
@@ -456,37 +456,15 @@ static int fio_ioring_getevents(struct thread_data *td, unsigned int min,
        return r < 0 ? r : events;
 }
 
-static void fio_ioring_cmdprio_prep(struct thread_data *td, struct io_u *io_u)
+static inline void fio_ioring_cmdprio_prep(struct thread_data *td,
+                                          struct io_u *io_u)
 {
-       struct ioring_options *o = td->eo;
        struct ioring_data *ld = td->io_ops_data;
-       struct io_uring_sqe *sqe = &ld->sqes[io_u->index];
+       struct ioring_options *o = td->eo;
        struct cmdprio *cmdprio = &o->cmdprio;
-       enum fio_ddir ddir = io_u->ddir;
-       unsigned int p = fio_cmdprio_percentage(cmdprio, io_u);
-       unsigned int cmdprio_value =
-               ioprio_value(cmdprio->class[ddir], cmdprio->level[ddir]);
-
-       if (p && rand_between(&td->prio_state, 0, 99) < p) {
-               io_u->ioprio = cmdprio_value;
-               sqe->ioprio = cmdprio_value;
-               if (!td->ioprio || cmdprio_value < td->ioprio) {
-                       /*
-                        * The async IO priority is higher (has a lower value)
-                        * than the default priority (which is either 0 or the
-                        * value set by "prio" and "prioclass" options).
-                        */
-                       io_u->flags |= IO_U_F_HIGH_PRIO;
-               }
-       } else if (td->ioprio && td->ioprio < cmdprio_value) {
-               /*
-                * The IO will be executed with the default priority (which is
-                * either 0 or the value set by "prio" and "prioclass options),
-                * and this priority is higher (has a lower value) than the
-                * async IO priority.
-                */
-               io_u->flags |= IO_U_F_HIGH_PRIO;
-       }
+
+       if (fio_cmdprio_set_ioprio(td, cmdprio, io_u))
+               ld->sqes[io_u->index].ioprio = io_u->ioprio;
 }
 
 static enum fio_q_status fio_ioring_queue(struct thread_data *td,

diff --git a/engines/libaio.c b/engines/libaio.c
index 9c14dd88d5d0b3609a0a417fbcfb9c6b9c40c90b..dc6ad08e5a08c73c0380a4019645ea5d79f7718e 100644 (file)
--- a/engines/libaio.c
+++ b/engines/libaio.c
@@ -205,33 +205,15 @@ static int fio_libaio_prep(struct thread_data *td, struct io_u *io_u)
        return 0;
 }
 
-static void fio_libaio_cmdprio_prep(struct thread_data *td, struct io_u *io_u)
+static inline void fio_libaio_cmdprio_prep(struct thread_data *td,
+                                          struct io_u *io_u)
 {
        struct libaio_options *o = td->eo;
        struct cmdprio *cmdprio = &o->cmdprio;
-       enum fio_ddir ddir = io_u->ddir;
-       unsigned int p = fio_cmdprio_percentage(cmdprio, io_u);
-       unsigned int cmdprio_value =
-               ioprio_value(cmdprio->class[ddir], cmdprio->level[ddir]);
-
-       if (p && rand_between(&td->prio_state, 0, 99) < p) {
-               io_u->ioprio = cmdprio_value;
-               io_u->iocb.aio_reqprio = cmdprio_value;
+
+       if (fio_cmdprio_set_ioprio(td, cmdprio, io_u)) {
+               io_u->iocb.aio_reqprio = io_u->ioprio;
                io_u->iocb.u.c.flags |= IOCB_FLAG_IOPRIO;
-               if (!td->ioprio || cmdprio_value < td->ioprio) {
-                       /*
-                        * The async IO priority is higher (has a lower value)
-                        * than the default context priority.
-                        */
-                       io_u->flags |= IO_U_F_HIGH_PRIO;
-               }
-       } else if (td->ioprio && td->ioprio < cmdprio_value) {
-               /*
-                * The IO will be executed with the default context priority,
-                * and this priority is higher (has a lower value) than the
-                * async IO priority.
-                */
-               io_u->flags |= IO_U_F_HIGH_PRIO;
        }
 }