[PATCH] Change timeout to runtime and rearrange option entries

Runtime is a more descriptive name - the documentation is updated
as well, however the parsing has added an alias functionality to
support older names as well. So 'timeout' still works.

Also rearrange option entries, now they matter because the --cmdhelp
option will print them in order.

Signed-off-by: Jens Axboe <jens.axboe@oracle.com>

diff --git a/HOWTO b/HOWTO
index 1c8dd4ea3bc90681b4534c0d6a7e10d5ba5cc3c8..57c0730b13d0ef7ef8b257a97ff56c1181aa53cf 100644 (file)
--- a/HOWTO
+++ b/HOWTO
@@ -347,7 +347,7 @@ startdelay=int      Start this job the specified number of seconds after fio
                jobs, and you want to delay starting some jobs to a certain
                time.
 
-timeout=int    Tell fio to terminate processing after the specified number
+runtime=int    Tell fio to terminate processing after the specified number
                of seconds. It can be quite hard to determine for how long
                a specified job will run, so this parameter is handy to
                cap the total runtime to a given time.

diff --git a/README b/README
index 97251d019cb1925d43d25591473343b4f3ef4d18..2d5d499984db632eb4ab5e5b357418509c43bb29 100644 (file)
--- a/README
+++ b/README
@@ -54,7 +54,7 @@ Command line
 
 $ fio
         --output        Write output to file
-        --timeout       Runtime in seconds
+        --runtime       Runtime in seconds
         --latency-log   Generate per-job latency logs
         --bandwidth-log Generate per-job bandwidth logs
         --minimal       Minimal (terse) output
@@ -124,7 +124,7 @@ The job file parameters are:
                        'x' blocks have been written.
        end_fsync=x     If 'x', run fsync() after end-of-job.
        startdelay=x    Start this thread x seconds after startup
-       timeout=x       Terminate x seconds after startup. Can include a
+       runtime=x       Terminate x seconds after startup. Can include a
                        normal time suffix if not given in seconds, such as
                        'm' for minutes, 'h' for hours, and 'd' for days.
        offset=x        Start io at offset x (x string can include k/m/g)

diff --git a/init.c b/init.c
index 559ebc15d44708232f501aa7fae9b41c29348459..c2725261ad8481ee923de2fb5b6e3ac524868e03 100644 (file)
--- a/init.c
+++ b/init.c
@@ -77,6 +77,119 @@ static struct fio_option options[] = {
                .posval = { "sync", "libaio", "posixaio", "mmap", "splice",
                                "sg", "null", },
        },
+       {
+               .name   = "iodepth",
+               .type   = FIO_OPT_INT,
+               .off1   = td_var_offset(iodepth),
+               .help   = "Amount of IO buffers to keep in flight",
+               .def    = "1",
+       },
+       {
+               .name   = "size",
+               .type   = FIO_OPT_STR_VAL,
+               .off1   = td_var_offset(total_file_size),
+               .help   = "Size of device or file",
+       },
+       {
+               .name   = "bs",
+               .type   = FIO_OPT_STR_VAL_INT,
+               .off1   = td_var_offset(bs[DDIR_READ]),
+               .off2   = td_var_offset(bs[DDIR_WRITE]),
+               .help   = "Block size unit",
+               .def    = "4k",
+       },
+       {
+               .name   = "bsrange",
+               .type   = FIO_OPT_RANGE,
+               .off1   = td_var_offset(min_bs[DDIR_READ]),
+               .off2   = td_var_offset(max_bs[DDIR_READ]),
+               .off3   = td_var_offset(min_bs[DDIR_WRITE]),
+               .off4   = td_var_offset(max_bs[DDIR_WRITE]),
+               .help   = "Set block size range (in more detail than bs)",
+       },
+       {
+               .name   = "bs_unaligned",
+               .type   = FIO_OPT_STR_SET,
+               .off1   = td_var_offset(bs_unaligned),
+               .help   = "Don't sector align IO buffer sizes",
+       },
+       {
+               .name   = "offset",
+               .type   = FIO_OPT_STR_VAL,
+               .off1   = td_var_offset(start_offset),
+               .help   = "Start IO from this offset",
+               .def    = "0",
+       },
+       {
+               .name   = "randrepeat",
+               .type   = FIO_OPT_BOOL,
+               .off1   = td_var_offset(rand_repeatable),
+               .help   = "Use repeatable random IO pattern",
+               .def    = "1",
+       },
+       {
+               .name   = "norandommap",
+               .type   = FIO_OPT_STR_SET,
+               .off1   = td_var_offset(norandommap),
+               .help   = "Accept potential duplicate random blocks",
+       },
+       {
+               .name   = "nrfiles",
+               .type   = FIO_OPT_INT,
+               .off1   = td_var_offset(nr_files),
+               .help   = "Split job workload between this number of files",
+               .def    = "1",
+       },
+       {
+               .name   = "fsync",
+               .type   = FIO_OPT_INT,
+               .off1   = td_var_offset(fsync_blocks),
+               .help   = "Issue fsync for writes every given number of blocks",
+               .def    = "0",
+       },
+       {
+               .name   = "direct",
+               .type   = FIO_OPT_BOOL,
+               .off1   = td_var_offset(odirect),
+               .help   = "Use O_DIRECT IO",
+               .def    = "1",
+       },
+       {
+               .name   = "overwrite",
+               .type   = FIO_OPT_BOOL,
+               .off1   = td_var_offset(overwrite),
+               .help   = "When writing, set whether to overwrite current data",
+               .def    = "0",
+       },
+       {
+               .name   = "loops",
+               .type   = FIO_OPT_INT,
+               .off1   = td_var_offset(loops),
+               .help   = "Number of times to run the job",
+               .def    = "1",
+       },
+       {
+               .name   = "numjobs",
+               .type   = FIO_OPT_INT,
+               .off1   = td_var_offset(numjobs),
+               .help   = "Duplicate this job this many times",
+               .def    = "1",
+       },
+       {
+               .name   = "startdelay",
+               .type   = FIO_OPT_INT,
+               .off1   = td_var_offset(start_delay),
+               .help   = "Only start job when this period has passed",
+               .def    = "0",
+       },
+       {
+               .name   = "runtime",
+               .alias  = "timeout",
+               .type   = FIO_OPT_STR_VAL_TIME,
+               .off1   = td_var_offset(timeout),
+               .help   = "Stop workload when this amount of time has passed",
+               .def    = "0",
+       },
        {
                .name   = "mem",
                .type   = FIO_OPT_STR,
@@ -125,27 +238,6 @@ static struct fio_option options[] = {
                .help   = "Use this IO scheduler on the backing device",
        },
 #endif
-       {
-               .name   = "size",
-               .type   = FIO_OPT_STR_VAL,
-               .off1   = td_var_offset(total_file_size),
-               .help   = "Size of device or file",
-       },
-       {
-               .name   = "bs",
-               .type   = FIO_OPT_STR_VAL_INT,
-               .off1   = td_var_offset(bs[DDIR_READ]),
-               .off2   = td_var_offset(bs[DDIR_WRITE]),
-               .help   = "Block size unit",
-               .def    = "4k",
-       },
-       {
-               .name   = "offset",
-               .type   = FIO_OPT_STR_VAL,
-               .off1   = td_var_offset(start_offset),
-               .help   = "Start IO from this offset",
-               .def    = "0",
-       },
        {
                .name   = "zonesize",
                .type   = FIO_OPT_STR_VAL,
@@ -167,43 +259,6 @@ static struct fio_option options[] = {
                .help   = "Lock down this amount of memory",
                .def    = "0",
        },
-       {
-               .name   = "bsrange",
-               .type   = FIO_OPT_RANGE,
-               .off1   = td_var_offset(min_bs[DDIR_READ]),
-               .off2   = td_var_offset(max_bs[DDIR_READ]),
-               .off3   = td_var_offset(min_bs[DDIR_WRITE]),
-               .off4   = td_var_offset(max_bs[DDIR_WRITE]),
-               .help   = "Set block size range",
-       },
-       {
-               .name   = "randrepeat",
-               .type   = FIO_OPT_BOOL,
-               .off1   = td_var_offset(rand_repeatable),
-               .help   = "Use repeatable random IO pattern",
-               .def    = "1",
-       },
-       {
-               .name   = "nrfiles",
-               .type   = FIO_OPT_INT,
-               .off1   = td_var_offset(nr_files),
-               .help   = "Split job workload between this number of files",
-               .def    = "1",
-       },
-       {
-               .name   = "iodepth",
-               .type   = FIO_OPT_INT,
-               .off1   = td_var_offset(iodepth),
-               .help   = "Amount of IO buffers to keep in flight",
-               .def    = "1",
-       },
-       {
-               .name   = "fsync",
-               .type   = FIO_OPT_INT,
-               .off1   = td_var_offset(fsync_blocks),
-               .help   = "Issue fsync for writes every given number of blocks",
-               .def    = "0",
-       },
        {
                .name   = "rwmixcycle",
                .type   = FIO_OPT_INT,
@@ -287,20 +342,6 @@ static struct fio_option options[] = {
                .help   = "Window average for rate limits (msec)",
                .def    = "1000",
        },
-       {
-               .name   = "startdelay",
-               .type   = FIO_OPT_INT,
-               .off1   = td_var_offset(start_delay),
-               .help   = "Only start job when this period has passed",
-               .def    = "0",
-       },
-       {
-               .name   = "timeout",
-               .type   = FIO_OPT_STR_VAL_TIME,
-               .off1   = td_var_offset(timeout),
-               .help   = "Stop workload when this amount of time has passed",
-               .def    = "0",
-       },
        {
                .name   = "invalidate",
                .type   = FIO_OPT_BOOL,
@@ -336,20 +377,6 @@ static struct fio_option options[] = {
                .help   = "Fsync file after creation",
                .def    = "1",
        },
-       {
-               .name   = "loops",
-               .type   = FIO_OPT_INT,
-               .off1   = td_var_offset(loops),
-               .help   = "Number of times to run the job",
-               .def    = "1",
-       },
-       {
-               .name   = "numjobs",
-               .type   = FIO_OPT_INT,
-               .off1   = td_var_offset(numjobs),
-               .help   = "Duplicate this job this many times",
-               .def    = "1",
-       },
        {
                .name   = "cpuload",
                .type   = FIO_OPT_INT,
@@ -362,20 +389,6 @@ static struct fio_option options[] = {
                .off1   = td_var_offset(cpucycle),
                .help   = "Length of the CPU burn cycles",
        },
-       {
-               .name   = "direct",
-               .type   = FIO_OPT_BOOL,
-               .off1   = td_var_offset(odirect),
-               .help   = "Use O_DIRECT IO",
-               .def    = "1",
-       },
-       {
-               .name   = "overwrite",
-               .type   = FIO_OPT_BOOL,
-               .off1   = td_var_offset(overwrite),
-               .help   = "When writing, set whether to overwrite current data",
-               .def    = "0",
-       },
 #ifdef FIO_HAVE_CPU_AFFINITY
        {
                .name   = "cpumask",
@@ -428,18 +441,6 @@ static struct fio_option options[] = {
                .off1   = td_var_offset(write_lat_log),
                .help   = "Write log of latency during run",
        },
-       {
-               .name   = "norandommap",
-               .type   = FIO_OPT_STR_SET,
-               .off1   = td_var_offset(norandommap),
-               .help   = "Accept potential duplicate random blocks",
-       },
-       {
-               .name   = "bs_unaligned",
-               .type   = FIO_OPT_STR_SET,
-               .off1   = td_var_offset(bs_unaligned),
-               .help   = "Don't sector align IO buffer sizes",
-       },
        {
                .name   = "hugepage-size",
                .type   = FIO_OPT_STR_VAL,

diff --git a/parse.c b/parse.c
index 10d2116e9d95442c5d1e34ad3c5729b9ef441cc3..886bde6b0c8b1130050234b40c7d047df602cba4 100644 (file)
--- a/parse.c
+++ b/parse.c
@@ -132,6 +132,8 @@ static struct fio_option *find_option(struct fio_option *options,
        while (o->name) {
                if (!strcmp(o->name, opt))
                        return o;
+               else if (o->alias && !strcmp(o->alias, opt))
+                       return o;
 
                o++;
        }

diff --git a/parse.h b/parse.h
index 2d4b55ec30999b932e9f3823981ba171191869a2..4ddb76a6335d6af7834e1209b8517fb125f01d6d 100644 (file)
--- a/parse.h
+++ b/parse.h
@@ -21,6 +21,7 @@ enum fio_opt_type {
  */
 struct fio_option {
        const char *name;               /* option name */
+       const char *alias;              /* possible old allowed name */
        enum fio_opt_type type;         /* option type */
        unsigned int off1;              /* potential parameters */
        unsigned int off2;

diff --git a/stat.c b/stat.c
index a665ec8f03cb72092bdb39b769011331a861b9eb..e7eb8ad68aeb369dafe30abb937ad2e5fa1b90bb 100644 (file)
--- a/stat.c
+++ b/stat.c
@@ -275,7 +275,6 @@ void update_rusage_stat(struct thread_data *td)
        td->usr_time += mtime_since(&td->ru_start.ru_utime, &td->ru_end.ru_utime);
        td->sys_time += mtime_since(&td->ru_start.ru_stime, &td->ru_end.ru_stime);
        td->ctx += td->ru_end.ru_nvcsw + td->ru_end.ru_nivcsw - (td->ru_start.ru_nvcsw + td->ru_start.ru_nivcsw);
-
        
        memcpy(&td->ru_start, &td->ru_end, sizeof(td->ru_end));
 }