Add support for I/O priority hints
v2 cover Add support for I/O priority hints
Linux kernel 6.5 will add support for I/O priority hints, which can be used (for now) to specify a command duration limit for block devices supporting this feature.
This patch series extends fio I/O priority options and adds new options to allow users to specify I/O priority hints.
Changes from v1:
- Added patch 1
- Addressed Niklas comments
Damien Le Moal (5):
os-linux: Cleanup IO priority class and value macros
os-linux: add initial support for IO priority hints
options: add priohint option
cmdprio: Add support for per I/O priority hint
stats: Add hint information to per priority level stats
HOWTO.rst | 32 ++++++++++++++++++++++++++++---- backend.c | 9 ++++++--- cconv.c | 2 ++ engines/cmdprio.c | 9 ++++++--- engines/cmdprio.h | 1 + engines/io_uring.c | 25 +++++++++++++++++++++++-- engines/libaio.c | 21 +++++++++++++++++++++ fio.1 | 30 +++++++++++++++++++++++++++--- options.c | 31 ++++++++++++++++++++++++++++--- os/os-dragonfly.h | 4 ++-- os/os-linux.h | 27 +++++++++++++++++++-------- os/os.h | 7 +++++-- server.h | 2 +- stat.c | 10 +++++++--- thread_options.h | 3 ++- 15 files changed, 178 insertions(+), 35 deletions(-)
Signature · 1 line
2.41.0
PATCH v2 1/5 os-linux: Cleanup IO priority class and value macros
In os/os-linux.h, define the ioprio() macro using the already defined IOPRIO_MAX_PRIO macro instead of hard coding the maximum priority value again. Also move the definitions of the ioprio_class() and ioprio() macros before the ioprio_value() function and use ioprio_class() inside ioprio_value_is_class_rt() instead of re-coding the iopriority class extraction again in that function.
--- os/os-linux.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
os/os-linux.h +4 -4
@@ -131,6 +131,9 @@ enum {#define IOPRIO_MIN_PRIO_CLASS 0#define IOPRIO_MAX_PRIO_CLASS 3 +#define ioprio_class (ioprio) ((ioprio) >> IOPRIO_CLASS_SHIFT) +#define ioprio (ioprio) ((ioprio) & IOPRIO_MAX_PRIO) +static inline int ioprio_value (int ioprio_class,int ioprio) {/*
@@ -144,7 +147,7 @@ static inline int ioprio_value(int ioprio_class, int ioprio)static inline bool ioprio_value_is_class_rt (unsigned int priority) { -return (priority >>IOPRIO_CLASS_SHIFT ) ==IOPRIO_CLASS_RT ; +return ioprio_class (priority) ==IOPRIO_CLASS_RT ; }static inline int ioprio_set (int which,int who,int ioprio_class,int ioprio)
@@ -153,9 +156,6 @@ static inline int ioprio_set(int which, int who, int ioprio_class, int ioprio) ioprio_value(ioprio_class, ioprio)); } -#define ioprio_class (ioprio) ((ioprio) >> IOPRIO_CLASS_SHIFT) -#define ioprio (ioprio) ((ioprio) & 7) -#ifndef CONFIG_HAVE_GETTID static inline int gettid (void ) {
Signature · 1 line
2.41.0
Re: [PATCH v2 1/5] os-linux: Cleanup IO priority class and value macros
Quoted 48 lines · Damien Le Moal
In
os/os-linux.h, define theioprio()macro using the already definedIOPRIO_MAX_PRIOmacro instead of hard coding the maximum priority value again. Also move the definitions of theioprio_class()andioprio()macros before theioprio_value()function and useioprio_class()insideioprio_value_is_class_rt()instead of re-coding the iopriority class extraction again in that function.Signed-off-by Damien Le Moal <[email protected]>--- os/os-linux.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)os/os-linux.h +4
-4@@ -131,6 +131,9 @@ enum {#define IOPRIO_MIN_PRIO_CLASS 0#define IOPRIO_MAX_PRIO_CLASS 3 +#define ioprio_class (ioprio) ((ioprio) >> IOPRIO_CLASS_SHIFT) +#define ioprio (ioprio) ((ioprio) & IOPRIO_MAX_PRIO) +static inline int ioprio_value (int ioprio_class,int ioprio) {/* @@ -144,7 +147,7 @@ static inline int ioprio_value(int ioprio_class, int ioprio)static inline bool ioprio_value_is_class_rt (unsigned int priority) { -return (priority >>IOPRIO_CLASS_SHIFT ) ==IOPRIO_CLASS_RT ; +return ioprio_class (priority) ==IOPRIO_CLASS_RT ; }static inline int ioprio_set (int which,int who,int ioprio_class,int ioprio)@@ -153,9 +156,6 @@ static inline int ioprio_set(int which, int who, int ioprio_class, int ioprio) ioprio_value(ioprio_class, ioprio)); } -#define ioprio_class (ioprio) ((ioprio) >> IOPRIO_CLASS_SHIFT) -#define ioprio (ioprio) ((ioprio) & 7) -#ifndef CONFIG_HAVE_GETTID static inline int gettid (void ) {Signature · 1 line
2.41.0
PATCH v2 2/5 os-linux: add initial support for IO priority hints
In reply to Damien Le MoalAdd initial support for Linux to allow specifying a hint for any priority value. With this change, a priority value becomes the combination of a priority class, a priority level and a hint. The generic os.h ioprio manipulation macros, as well as the os-dragonfly.h ioprio manipulation macros are modified to ignore this hint.
For all other OSes that do not support priority classes, priotity hints are ignored and always equal to 0.
--- backend.c | 5 +++-- engines/cmdprio.c | 4 ++-- options.c | 2 +- os/os-dragonfly.h | 4 ++-- os/os-linux.h | 19 +++++++++++++++---- os/os.h | 7 +++++-- 6 files changed, 28 insertions(+), 13 deletions(-)
backend.c +3 -2
@@ -1800,12 +1800,13 @@ static void *thread_main(void *data)/* ioprio_set() has to be done before td_io_init() */ if (fio_option_is_set (o, ioprio) ||fio_option_is_set (o, ioprio_class)) { - ret =ioprio_set (IOPRIO_WHO_PROCESS ,0 , o->ioprio_class, o->ioprio); + ret =ioprio_set (IOPRIO_WHO_PROCESS ,0 , o->ioprio_class, + o->ioprio,0 );if (ret ==-1 ) {td_verror (td, errno,"ioprio_set" ); goto err; } - td->ioprio =ioprio_value (o->ioprio_class, o->ioprio); + td->ioprio =ioprio_value (o->ioprio_class, o->ioprio,0 ); td->ts.ioprio = td->ioprio; }
engines/cmdprio.c +2 -2
@@ -342,7 +342,7 @@ static int fio_cmdprio_gen_perc(struct thread_data *td, struct cmdprio *cmdprio) prio = &cmdprio->perc_entry[ddir]; prio->perc = options->percentage[ddir]; prio->prio =ioprio_value (options->class[ddir], - options->level[ddir]); + options->level[ddir],0 );assign_clat_prio_index (prio, &values[ddir]); ret =init_ts_clat_prio (ts, ddir, &values[ddir]);
@@ -400,7 +400,7 @@ static int fio_cmdprio_parse_and_gen_bssplit(struct thread_data *td, goto err; implicit_cmdprio =ioprio_value (options->class[ddir], - options->level[ddir]); + options->level[ddir],0 ); ret = fio_cmdprio_generate_bsprio_desc(&cmdprio->bsprio_desc[ddir], &parse_res[ddir],
options.c +1 -1
@@ -344,7 +344,7 @@ static int parse_cmdprio_bssplit_entry(struct thread_options *o,case 4 :/* bs/perc/class/level case */ class =min (class, (unsigned int )IOPRIO_MAX_PRIO_CLASS ); level =min (level, (unsigned int )IOPRIO_MAX_PRIO ); - entry->prio =ioprio_value (class, level); + entry->prio =ioprio_value (class, level,0 );break ;default :log_err ("fio: invalid cmdprio_bssplit format\n" );
os/os-dragonfly.h +2 -2
@@ -171,8 +171,8 @@ static inline int fio_getaffinity(int pid, os_cpu_mask_t *mask)* ioprio_set() with 4 arguments, so define fio's ioprio_set() as a macro. * Note that there is no idea of class within ioprio_set(2) unlike Linux. */ -#define ioprio_value (ioprio_class, ioprio) (ioprio) -#define ioprio_set (which, who, ioprio_class, ioprio) \ +#define ioprio_value (ioprio_class, ioprio, ioprio_hint) (ioprio) +#define ioprio_set (which, who, ioprio_class, ioprio, ioprio_hint) \ ioprio_set(which, who, ioprio)#define ioprio (ioprio) (ioprio)
os/os-linux.h +15 -4
@@ -125,16 +125,24 @@ enum {#define IOPRIO_BITS 16#define IOPRIO_CLASS_SHIFT 13 +#define IOPRIO_HINT_BITS 10 +#define IOPRIO_HINT_SHIFT 3 +#define IOPRIO_MIN_PRIO 0/* highest priority */ #define IOPRIO_MAX_PRIO 7/* lowest priority */ #define IOPRIO_MIN_PRIO_CLASS 0#define IOPRIO_MAX_PRIO_CLASS 3 +#define IOPRIO_MIN_PRIO_HINT 0 +#define IOPRIO_MAX_PRIO_HINT ((1 << IOPRIO_HINT_BITS) - 1) +#define ioprio_class (ioprio) ((ioprio) >> IOPRIO_CLASS_SHIFT)#define ioprio (ioprio) ((ioprio) & IOPRIO_MAX_PRIO) +#define ioprio_hint (ioprio) \ + (((ioprio) >> IOPRIO_HINT_SHIFT) & IOPRIO_MAX_PRIO_HINT) -static inline int ioprio_value (int ioprio_class,int ioprio) +static inline int ioprio_value (int ioprio_class,int ioprio,int ioprio_hint) {/* * If no class is set, assume BE
@@ -142,7 +150,9 @@ static inline int ioprio_value(int ioprio_class, int ioprio)if (!ioprio_class) ioprio_class =IOPRIO_CLASS_BE ; -return (ioprio_class <<IOPRIO_CLASS_SHIFT ) | ioprio; +return (ioprio_class <<IOPRIO_CLASS_SHIFT ) | + (ioprio_hint <<IOPRIO_HINT_SHIFT ) | + ioprio; }static inline bool ioprio_value_is_class_rt (unsigned int priority)
@@ -150,10 +160,11 @@ static inline bool ioprio_value_is_class_rt(unsigned int priority)return ioprio_class (priority) ==IOPRIO_CLASS_RT ; } -static inline int ioprio_set (int which,int who,int ioprio_class,int ioprio) +static inline int ioprio_set (int which,int who,int ioprio_class,int ioprio, +int ioprio_hint) {return syscall (__NR_ioprio_set, which, who, -ioprio_value (ioprio_class, ioprio)); +ioprio_value (ioprio_class, ioprio, ioprio_hint)); }#ifndef CONFIG_HAVE_GETTID
os/os.h +5 -2
@@ -120,11 +120,14 @@ extern int fio_cpus_split(os_cpu_mask_t *mask, unsigned int cpu);#define ioprio_value_is_class_rt (prio) (false)#define IOPRIO_MIN_PRIO_CLASS 0#define IOPRIO_MAX_PRIO_CLASS 0 +#define ioprio_hint (prio) 0 +#define IOPRIO_MIN_PRIO_HINT 0 +#define IOPRIO_MAX_PRIO_HINT 0#endif #ifndef FIO_HAVE_IOPRIO -#define ioprio_value (prioclass, prio) (0) +#define ioprio_value (prioclass, prio, priohint) (0)#define ioprio (ioprio) 0 -#define ioprio_set (which, who, prioclass, prio) (0) +#define ioprio_set (which, who, prioclass, prio, priohint) (0)#define IOPRIO_MIN_PRIO 0#define IOPRIO_MAX_PRIO 0#endif
Signature · 1 line
2.41.0
PATCH v2 3/5 options: add priohint option
In reply to Damien Le MoalIntroduce the new option priohint to allow a user to specify an I/O priority hint applying to all IOs issued by a job. This increases fio server version (FIO_SERVER_VER) to 101.
--- HOWTO.rst | 6 ++++++ backend.c | 8 +++++--- cconv.c | 2 ++ fio.1 | 5 +++++ options.c | 18 ++++++++++++++++++ server.h | 2 +- thread_options.h | 3 ++- 7 files changed, 39 insertions(+), 5 deletions(-)
HOWTO.rst +6 -0
@@ -3424,6 +3424,12 @@ Threads, processes and job synchronization priority setting, see I/O engine specific :option:`cmdprio_percentage` and :option:`cmdprio_class` options. +.. option:: priohint=int + + Set the I/O priority hint. This has effects only for devices with + features controlled through priority hints (e.g. block devices + supporting command duration limits). + .. option:: cpus_allowed=str Controls the same options as :option:`cpumask`, but accepts a textual
backend.c +5 -3
@@ -1799,14 +1799,16 @@ static void *thread_main(void *data)/* ioprio_set() has to be done before td_io_init() */ if (fio_option_is_set (o, ioprio) || -fio_option_is_set (o, ioprio_class)) { +fio_option_is_set (o, ioprio_class) || +fio_option_is_set (o, ioprio_hint)) { ret =ioprio_set (IOPRIO_WHO_PROCESS ,0 , o->ioprio_class, - o->ioprio,0 ); + o->ioprio, o->ioprio_hint);if (ret ==-1 ) {td_verror (td, errno,"ioprio_set" ); goto err; } - td->ioprio =ioprio_value (o->ioprio_class, o->ioprio,0 ); + td->ioprio =ioprio_value (o->ioprio_class, o->ioprio, + o->ioprio_hint); td->ts.ioprio = td->ioprio; }
cconv.c +2 -0
@@ -281,6 +281,7 @@ int convert_thread_options_to_cpu(struct thread_options *o, o->nice =le32_to_cpu (top->nice); o->ioprio =le32_to_cpu (top->ioprio); o->ioprio_class =le32_to_cpu (top->ioprio_class); + o->ioprio_hint =le32_to_cpu (top->ioprio_hint); o->file_service_type =le32_to_cpu (top->file_service_type); o->group_reporting =le32_to_cpu (top->group_reporting); o->stats =le32_to_cpu (top->stats);
@@ -496,6 +497,7 @@ void convert_thread_options_to_net(struct thread_options_pack *top, top->nice =cpu_to_le32 (o->nice); top->ioprio =cpu_to_le32 (o->ioprio); top->ioprio_class =cpu_to_le32 (o->ioprio_class); + top->ioprio_hint =cpu_to_le32 (o->ioprio_hint); top->file_service_type =cpu_to_le32 (o->file_service_type); top->group_reporting =cpu_to_le32 (o->group_reporting); top->stats =cpu_to_le32 (o->stats);
fio.1 +5 -0
@@ -3132,6 +3132,11 @@ Set the I/O priority class. See man \fBionice\fR\|(1). For per-command priority setting, see the I/O engine specific `cmdprio_percentage` and `cmdprio_class` options. .TP +.BI priohint \fR=\fPint +Set the I/O priority hint. This has effects only for devices with +features controlled through priority hints (e.g. block devices supporting +command duration limits). +.TP .BI cpus_allowed \fR=\fPstr Controls the same options as \fBcpumask\fR, but accepts a textual specification of the permitted CPUs instead and CPUs are indexed from 0. So
options.c +18 -0
@@ -3806,6 +3806,18 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .category = FIO_OPT_C_GENERAL, .group = FIO_OPT_G_CRED, }, + { + .name = "priohint", + .lname = "I/O nice priority hint", + .type = FIO_OPT_INT, + .off1 = offsetof(struct thread_options, ioprio_hint), + .help = "Set job IO priority hint", + .minval = IOPRIO_MIN_PRIO_HINT, + .maxval = IOPRIO_MAX_PRIO_HINT, + .interval = 1, + .category = FIO_OPT_C_GENERAL, + .group = FIO_OPT_G_CRED, + }, #else { .name = "prioclass",
@@ -3813,6 +3825,12 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .type = FIO_OPT_UNSUPPORTED, .help = "Your platform does not support IO priority classes", }, + { + .name = "priohint", + .lname = "I/O nice priority hint", + .type = FIO_OPT_UNSUPPORTED, + .help = "Your platform does not support IO priority hints", + },#endif { .name = "thinktime",
server.h +1 -1
@@ -51,7 +51,7 @@ struct fio_net_cmd_reply { };enum { -FIO_SERVER_VER =100 , +FIO_SERVER_VER =101 ,FIO_SERVER_MAX_FRAGMENT_PDU =1024 ,FIO_SERVER_MAX_CMD_MB =2048 ,
thread_options.h +2 -1
@@ -248,6 +248,7 @@ struct thread_options {unsigned int nice;unsigned int ioprio;unsigned int ioprio_class; +unsigned int ioprio_hint;unsigned int file_service_type;unsigned int group_reporting;unsigned int stats;
@@ -568,6 +569,7 @@ struct thread_options_pack {uint32_t nice;uint32_t ioprio;uint32_t ioprio_class; +uint32_t ioprio_hint;uint32_t file_service_type;uint32_t group_reporting;uint32_t stats;
@@ -601,7 +603,6 @@ struct thread_options_pack {uint32_t lat_percentiles;uint32_t slat_percentiles;uint32_t percentile_precision; -uint32_t pad5;fio_fp64_t percentile_list[FIO_IO_U_LIST_MAX_LEN ];uint8_t read_iolog_file[FIO_TOP_STR_MAX ];
Signature · 1 line
2.41.0
Re: [PATCH v2 3/5] options: add priohint option
Quoted 5 lines · Damien Le Moal
HOWTO.rst +0
-0
HOWTO.rst Threads, processes and job synchronization · line 3432
Quoted 9 lines
HOWTO.rst +6
-0@@ -3424,6 +3424,12 @@ Threads, processes and job synchronization priority setting, see I/O engine specific :option:`cmdprio_percentage` and :option:`cmdprio_class` options. +.. option:: priohint=int + + Set the I/O priority hint. This has effects only for devices with + features controlled through priority hints (e.g. block devices + supporting command duration limits). +
I would rephrase that as:
Set the I/O priority hint. This is only applicable to devices with features controlled through priority hints (e.g. block devices supporting command duration limits, or CDL). CDL is a way to XXX
and finish the XXX, and apply to the man page as well.
Assume people don't know what CDL is, because that will generally be true!
Signature · 1 line
Jens Axboe
PATCH v2 4/5 cmdprio: Add support for per I/O priority hint
In reply to Damien Le MoalIntroduce the new option cmdprio_hint to allow specifying I/O priority hints per IO with the iouring and libaio IO engines. A third acceptable format for the cmdprio_bssplit option is also introduced to allow specifying an IO hint in addition to a priority class and level.
--- HOWTO.rst | 28 +++++++++++++++++++++++----- engines/cmdprio.c | 9 ++++++--- engines/cmdprio.h | 1 + engines/io_uring.c | 25 +++++++++++++++++++++++-- engines/libaio.c | 21 +++++++++++++++++++++ fio.1 | 27 +++++++++++++++++++++++---- options.c | 13 ++++++++++--- 7 files changed, 107 insertions(+), 17 deletions(-)
HOWTO.rst +23 -5
@@ -2275,6 +2275,16 @@ with the caveat that when used on the command line, they must come after the reads and writes. See :manpage:`ionice(1)`. See also the :option:`prioclass` option. +.. option:: cmdprio_hint=int[,int] : [io_uring] [libaio] + + Set the I/O priority hint to use for I/Os that must be issued with + a priority when :option:`cmdprio_percentage` or + :option:`cmdprio_bssplit` is set. If not specified when + :option:`cmdprio_percentage` or :option:`cmdprio_bssplit` is set, + this defaults to 0 (no hint). A single value applies to reads and + writes. Comma-separated values may be specified for reads and writes. + See also the :option:`priohint` option. + .. option:: cmdprio=int[,int] : [io_uring] [libaio] Set the I/O priority value to use for I/Os that must be issued with
@@ -2301,9 +2311,9 @@ with the caveat that when used on the command line, they must come after the cmdprio_bssplit=blocksize/percentage:blocksize/percentage - In this case, each entry will use the priority class and priority - level defined by the options :option:`cmdprio_class` and - :option:`cmdprio` respectively. + In this case, each entry will use the priority class, priority hint + and priority level defined by the options :option:`cmdprio_class`, + :option:`cmdprio` and :option:`cmdprio_hint` respectively. The second accepted format for this option is:
@@ -2314,7 +2324,14 @@ with the caveat that when used on the command line, they must come after the accepted format does not restrict all entries to have the same priority class and priority level. - For both formats, only the read and write data directions are supported, + The third accepted format for this option is: + + cmdprio_bssplit=blocksize/percentage/class/level/hint:... + + This is an extension of the second accepted format that allows to also + specify a priority hint. + + For all formats, only the read and write data directions are supported, values for trim IOs are ignored. This option is mutually exclusive with the :option:`cmdprio_percentage` option.
@@ -3428,7 +3445,8 @@ Threads, processes and job synchronization Set the I/O priority hint. This has effects only for devices with features controlled through priority hints (e.g. block devices - supporting command duration limits). + supporting command duration limits). For per-I/O priority hint + setting, see the I/O engine specific :option:`cmdprio_hint` option. .. option:: cpus_allowed=str
engines/cmdprio.c +6 -3
@@ -267,7 +267,8 @@ static int fio_cmdprio_percentage(struct cmdprio *cmdprio, struct io_u *io_u,* 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. +* value as defined by the cmdprio/cmdprio_hint/cmdprio_class or +* cmdprio_bssplit options. * * Return true if the io_u ioprio was changed and false otherwise. */
@@ -342,7 +343,8 @@ static int fio_cmdprio_gen_perc(struct thread_data *td, struct cmdprio *cmdprio) prio = &cmdprio->perc_entry[ddir]; prio->perc = options->percentage[ddir]; prio->prio =ioprio_value (options->class[ddir], - options->level[ddir],0 ); + options->level[ddir], + options->hint[ddir]);assign_clat_prio_index (prio, &values[ddir]); ret =init_ts_clat_prio (ts, ddir, &values[ddir]);
@@ -400,7 +402,8 @@ static int fio_cmdprio_parse_and_gen_bssplit(struct thread_data *td, goto err; implicit_cmdprio =ioprio_value (options->class[ddir], - options->level[ddir],0 ); + options->level[ddir], + options->hint[ddir]); ret = fio_cmdprio_generate_bsprio_desc(&cmdprio->bsprio_desc[ddir], &parse_res[ddir],
engines/cmdprio.h +1 -0
@@ -39,6 +39,7 @@ struct cmdprio_options {unsigned int percentage[CMDPRIO_RWDIR_CNT ];unsigned int class[CMDPRIO_RWDIR_CNT ];unsigned int level[CMDPRIO_RWDIR_CNT ]; +unsigned int hint[CMDPRIO_RWDIR_CNT ];char *bssplit_str; };
engines/io_uring.c +23 -2
@@ -157,6 +157,21 @@ static struct fio_option options[] = { .category = FIO_OPT_C_ENGINE, .group = FIO_OPT_G_IOURING, }, + { + .name = "cmdprio_hint", + .lname = "Asynchronous I/O priority hint", + .type = FIO_OPT_INT, + .off1 = offsetof(struct ioring_options , + cmdprio_options.hint[DDIR_READ]), + .off2 = offsetof(struct ioring_options , + cmdprio_options.hint[DDIR_WRITE]), + .help = "Set asynchronous IO priority hint", + .minval = IOPRIO_MIN_PRIO_HINT, + .maxval = IOPRIO_MAX_PRIO_HINT, + .interval = 1, + .category = FIO_OPT_C_ENGINE, + .group = FIO_OPT_G_IOURING, + }, { .name = "cmdprio", .lname = "Asynchronous I/O priority level",
@@ -195,6 +210,12 @@ static struct fio_option options[] = { .type = FIO_OPT_UNSUPPORTED, .help = "Your platform does not support I/O priority classes", }, + { + .name = "cmdprio_hint", + .lname = "Asynchronous I/O priority hint", + .type = FIO_OPT_UNSUPPORTED, + .help = "Your platform does not support I/O priority classes", + }, { .name = "cmdprio", .lname = "Asynchronous I/O priority level",
@@ -365,8 +386,8 @@ static int fio_ioring_prep(struct thread_data *td, struct io_u *io_u)/* * Since io_uring can have a submission context (sqthread_poll) * that is different from the process context, we cannot rely on -* the IO priority set by ioprio_set() (option prio/prioclass) -* to be inherited. +* the IO priority set by ioprio_set() (options prio, prioclass, +* and priohint) to be inherited. * td->ioprio will have the value of the "default prio", so set * this unconditionally. This value might get overridden by * fio_ioring_cmdprio_prep() if the option cmdprio_percentage or
engines/libaio.c +21 -0
@@ -102,6 +102,21 @@ static struct fio_option options[] = { .category = FIO_OPT_C_ENGINE, .group = FIO_OPT_G_LIBAIO, }, + { + .name = "cmdprio_hint", + .lname = "Asynchronous I/O priority hint", + .type = FIO_OPT_INT, + .off1 = offsetof(struct libaio_options , + cmdprio_options.hint[DDIR_READ]), + .off2 = offsetof(struct libaio_options , + cmdprio_options.hint[DDIR_WRITE]), + .help = "Set asynchronous IO priority hint", + .minval = IOPRIO_MIN_PRIO_HINT, + .maxval = IOPRIO_MAX_PRIO_HINT, + .interval = 1, + .category = FIO_OPT_C_ENGINE, + .group = FIO_OPT_G_LIBAIO, + }, { .name = "cmdprio", .lname = "Asynchronous I/O priority level",
@@ -140,6 +155,12 @@ static struct fio_option options[] = { .type = FIO_OPT_UNSUPPORTED, .help = "Your platform does not support I/O priority classes", }, + { + .name = "cmdprio_hint", + .lname = "Asynchronous I/O priority hint", + .type = FIO_OPT_UNSUPPORTED, + .help = "Your platform does not support I/O priority classes", + }, { .name = "cmdprio", .lname = "Asynchronous I/O priority level",
fio.1 +23 -4
@@ -2072,6 +2072,14 @@ is set, this defaults to the highest priority class. A single value applies to reads and writes. Comma-separated values may be specified for reads and writes. See man \fBionice\fR\|(1). See also the \fBprioclass\fR option. .TP +.BI (io_uring,libaio)cmdprio_hint \fR=\fPint[,int] +Set the I/O priority hint to use for I/Os that must be issued with a +priority when \fBcmdprio_percentage\fR or \fBcmdprio_bssplit\fR is set. +If not specified when \fBcmdprio_percentage\fR or \fBcmdprio_bssplit\fR +is set, this defaults to 0 (no hint). A single value applies to reads and +writes. Comma-separated values may be specified for reads and writes. +See also the \fBpriohint\fR option. +.TP .BI (io_uring,libaio)cmdprio \fR=\fPint[,int] Set the I/O priority value to use for I/Os that must be issued with a priority when \fBcmdprio_percentage\fR or \fBcmdprio_bssplit\fR is set.
@@ -2097,8 +2105,9 @@ The first accepted format for this option is the same as the format of the cmdprio_bssplit=blocksize/percentage:blocksize/percentage .RE .P -In this case, each entry will use the priority class and priority level defined -by the options \fBcmdprio_class\fR and \fBcmdprio\fR respectively. +In this case, each entry will use the priority class, priority hint and +priority level defined by the options \fBcmdprio_class\fR, \fBcmdprio\fR +and \fBcmdprio_hint\fR respectively. .P The second accepted format for this option is: .RS
@@ -2111,7 +2120,16 @@ entry. In comparison with the first accepted format, the second accepted format does not restrict all entries to have the same priority class and priority level. .P -For both formats, only the read and write data directions are supported, values +The third accepted format for this option is: +.RS +.P +cmdprio_bssplit=blocksize/percentage/class/level/hint:... +.RE +.P +This is an extension of the second accepted format that allows to also +specify a priority hint. +.P +For all formats, only the read and write data directions are supported, values for trim IOs are ignored. This option is mutually exclusive with the \fBcmdprio_percentage\fR option. .RE
@@ -3135,7 +3153,8 @@ priority setting, see the I/O engine specific `cmdprio_percentage` and .BI priohint \fR=\fPint Set the I/O priority hint. This has effects only for devices with features controlled through priority hints (e.g. block devices supporting -command duration limits). +command duration limits). For per-I/O priority hint setting, see the I/O +engine specific \fBcmdprio_hint\fB option. .TP .BI cpus_allowed \fR=\fPstr Controls the same options as \fBcpumask\fR, but accepts a textual
options.c +10 -3
@@ -313,15 +313,17 @@ static int parse_cmdprio_bssplit_entry(struct thread_options *o,int matches =0 ;char *bs_str =NULL ;long long bs_val; -unsigned int perc =0 , class, level; +unsigned int perc =0 , class, level, hint;/* * valid entry formats: * bs/ - %s/ - set perc to 0, prio to -1. * bs/perc - %s/%u - set prio to -1. * bs/perc/class/level - %s/%u/%u/%u +* bs/perc/class/level/hint - %s/%u/%u/%u/%u */ - matches =sscanf (str,"%m[^/]/%u/%u/%u" , &bs_str, &perc, &class, &level); + matches =sscanf (str,"%m[^/]/%u/%u/%u/%u" , + &bs_str, &perc, &class, &level, &hint);if (matches <1 ) {log_err ("fio: invalid cmdprio_bssplit format\n" );return 1 ;
@@ -342,9 +344,14 @@ static int parse_cmdprio_bssplit_entry(struct thread_options *o,case 2 :/* bs/perc case */ break ;case 4 :/* bs/perc/class/level case */ +case 5 :/* bs/perc/class/level/hint case */ class =min (class, (unsigned int )IOPRIO_MAX_PRIO_CLASS ); level =min (level, (unsigned int )IOPRIO_MAX_PRIO ); - entry->prio =ioprio_value (class, level,0 ); +if (matches ==5 ) + hint =min (hint, (unsigned int )IOPRIO_MAX_PRIO_HINT ); +else + hint =0 ; + entry->prio =ioprio_value (class, level, hint);break ;default :log_err ("fio: invalid cmdprio_bssplit format\n" );
Signature · 1 line
2.41.0
Re: [PATCH v2 4/5] cmdprio: Add support for per I/O priority hint
Quoted 29 lines · Damien Le Moal
engines/io_uring.c +15
-0@@ -157,6 +157,21 @@ static struct fio_option options[] = { .category = FIO_OPT_C_ENGINE, .group = FIO_OPT_G_IOURING, }, + { + .name = "cmdprio_hint", + .lname = "Asynchronous I/O priority hint", + .type = FIO_OPT_INT, + .off1 = offsetof(struct ioring_options , + cmdprio_options.hint[DDIR_READ]), + .off2 = offsetof(struct ioring_options , + cmdprio_options.hint[DDIR_WRITE]), + .help = "Set asynchronous IO priority hint", + .minval = IOPRIO_MIN_PRIO_HINT, + .maxval = IOPRIO_MAX_PRIO_HINT, + .interval = 1, + .category = FIO_OPT_C_ENGINE, + .group = FIO_OPT_G_IOURING, + }, { .name = "cmdprio", .lname = "Asynchronous I/O priority level",@@ -195,6 +210,12 @@ static struct fio_option options[] = { .type = FIO_OPT_UNSUPPORTED, .help = "Your platform does not support I/O priority classes",
engines/io_uring.c static struct fio_option options[] = { · line 221
Quoted 10 lines
engines/io_uring.c +6
-0}, + { + .name = "cmdprio_hint", + .lname = "Asynchronous I/O priority hint", + .type = FIO_OPT_UNSUPPORTED, + .help = "Your platform does not support I/O priority classes", + }, { .name = "cmdprio", .lname = "Asynchronous I/O priority level",
Since neither this nor libaio actually do anything with these values, why isn't this just a generic option? You could flag the two engines where it actually works with an engine flag, and check if it's set and we don't have that flag and error out in the generic code.
Signature · 1 line
Jens Axboe
Re: [PATCH v2 4/5] cmdprio: Add support for per I/O priority hint
Quoted 37 lines · Jens Axboe
Quoted 36 lines · Damien Le Moal
engines/io_uring.c +21
-0@@ -157,6 +157,21 @@ static struct fio_option options[] = { .category = FIO_OPT_C_ENGINE, .group = FIO_OPT_G_IOURING, }, + { + .name = "cmdprio_hint", + .lname = "Asynchronous I/O priority hint", + .type = FIO_OPT_INT, + .off1 = offsetof(struct ioring_options , + cmdprio_options.hint[DDIR_READ]), + .off2 = offsetof(struct ioring_options , + cmdprio_options.hint[DDIR_WRITE]), + .help = "Set asynchronous IO priority hint", + .minval = IOPRIO_MIN_PRIO_HINT, + .maxval = IOPRIO_MAX_PRIO_HINT, + .interval = 1, + .category = FIO_OPT_C_ENGINE, + .group = FIO_OPT_G_IOURING, + }, { .name = "cmdprio", .lname = "Asynchronous I/O priority level",@@ -195,6 +210,12 @@ static struct fio_option options[] = { .type = FIO_OPT_UNSUPPORTED, .help = "Your platform does not support I/O priority classes", }, + { + .name = "cmdprio_hint", + .lname = "Asynchronous I/O priority hint", + .type = FIO_OPT_UNSUPPORTED, + .help = "Your platform does not support I/O priority classes", + },
Quoted 8 lines
engines/io_uring.c static struct fio_option options[] = { · line 177
Quoted 3 lines
engines/io_uring.c +0
-0{ .name = "cmdprio", .lname = "Asynchronous I/O priority level",Since neither this nor libaio actually do anything with these values, why isn't this just a generic option? You could flag the two engines where it actually works with an engine flag, and check if it's set and we don't have that flag and error out in the generic code.
Hmmm. I would like to keep the async IO prio option definitions and storage together with the cmdprio_options struct, which is common to both libaio and iouring engines. If we move the hint option definition to be a generic one, we cannot use that struct and would need a job field. I can make that work, but that makes the code a little messier by spreading out the controls for async IO prio.
I agree that we can drop the error output though as indeed the hint value is unused on systems without hint support. But warning the user about the lack of support is nice I think.
Checking the code again though, one thing I noticed is that iouring and libaio cmdprio_xxx options definition is identical, modulo the group. So all these definitions could be moved to engines/cmdprio.h as macros and IO engines supporting these options can use these to add the options. The other option is to move the definition of all these options to be generic ones and use the engine flag trick you mention to indicate support.
Signature · 2 lines
Damien Le Moal Western Digital Research
PATCH v2 5/5 stats: Add hint information to per priority level stats
In reply to Damien Le MoalModify the json and standard per-priority output stats to display the hint value together with the priority class and level.
--- stat.c | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-)
stat.c +7 -3
@@ -597,10 +597,11 @@ static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts,continue ;snprintf (buf,sizeof (buf), -"%s prio %u/%u" , +"%s prio %u/%u/%u" , clat_type,ioprio_class (ts->clat_prio[ddir][i].ioprio), -ioprio (ts->clat_prio[ddir][i].ioprio)); +ioprio (ts->clat_prio[ddir][i].ioprio), +ioprio_hint (ts->clat_prio[ddir][i].ioprio));display_lat (buf, min, max, mean, dev, out); } }
@@ -640,10 +641,11 @@ static void show_ddir_status(struct group_run_stats *rs, struct thread_stat *ts,continue ;snprintf (prio_name,sizeof (prio_name), -"%s prio %u/%u (%.2f%% of IOs)" , +"%s prio %u/%u/%u (%.2f%% of IOs)" , clat_type,ioprio_class (ts->clat_prio[ddir][i].ioprio),ioprio (ts->clat_prio[ddir][i].ioprio), +ioprio_hint (ts->clat_prio[ddir][i].ioprio),100. * (double ) prio_samples / (double ) samples); show_clat_percentiles(ts->clat_prio[ddir][i].io_u_plat, prio_samples, ts->percentile_list,
@@ -1533,6 +1535,8 @@ static void add_ddir_status_json(struct thread_stat *ts, ioprio_class(ts->clat_prio[ddir][i].ioprio));json_object_add_value_int (obj,"prio" ,ioprio (ts->clat_prio[ddir][i].ioprio)); +json_object_add_value_int (obj,"priohint" , +ioprio_hint (ts->clat_prio[ddir][i].ioprio)); tmp_object = add_ddir_lat_json(ts, ts->clat_percentiles | ts->lat_percentiles,
Signature · 1 line
2.41.0