[PATCH] Change timeout to runtime and rearrange option entries
authorJens Axboe <jens.axboe@oracle.com>
Thu, 11 Jan 2007 10:04:31 +0000 (11:04 +0100)
committerJens Axboe <jens.axboe@oracle.com>
Thu, 11 Jan 2007 10:04:31 +0000 (11:04 +0100)
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>
HOWTO
README
init.c
parse.c
parse.h
stat.c

diff --git a/HOWTO b/HOWTO
index 1c8dd4e..57c0730 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 97251d0..2d5d499 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 559ebc1..c272526 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 10d2116..886bde6 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 2d4b55e..4ddb76a 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 a665ec8..e7eb8ad 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));
 }