Add create_only option

[fio.git] / options.c

diff --git a/options.c b/options.c
index f9bd1a44225cd6f4769952392d0b39a0ce8b0e5d..28a228c6fefbb5ec7bab60ef8afc225685f70609 100644 (file)
--- a/options.c
+++ b/options.c
@@ -245,12 +245,9 @@ static int str_verify_cb(void *data, const char *mem)
 {
        struct thread_data *td = data;
 
-       if (td->o.verify != VERIFY_CRC32C_INTEL)
-               return 0;
-
-       if (!crc32c_intel_works()) {
-               log_info("fio: System does not support hw accelerated crc32c. Falling back to sw crc32c.\n");
-               td->o.verify = VERIFY_CRC32C;
+       if (td->o.verify == VERIFY_CRC32C_INTEL ||
+           td->o.verify == VERIFY_CRC32C) {
+               crc32c_intel_probe();
        }
 
        return 0;
@@ -689,12 +686,32 @@ static int str_verify_pattern_cb(void *data, const char *input)
                        }
                }
        }
+
+       /*
+        * Fill the pattern all the way to the end. This greatly reduces
+        * the number of memcpy's we have to do when verifying the IO.
+        */
+       while (i > 1 && i * 2 <= MAX_PATTERN_SIZE) {
+               memcpy(&td->o.verify_pattern[i], &td->o.verify_pattern[0], i);
+               i *= 2;
+       }
+       if (i == 1) {
+               /*
+                * The code in verify_io_u_pattern assumes a single byte pattern
+                * fills the whole verify pattern buffer.
+                */
+               memset(td->o.verify_pattern, td->o.verify_pattern[0],
+                      MAX_PATTERN_SIZE);
+       }
+
        td->o.verify_pattern_bytes = i;
+
        /*
         * VERIFY_META could already be set
         */
        if (td->o.verify == VERIFY_NONE)
                td->o.verify = VERIFY_PATTERN;
+
        return 0;
 }
 
@@ -927,6 +944,10 @@ static struct fio_option options[FIO_MAX_OPTS] = {
                            .oval = TD_DDIR_RW,
                            .help = "Sequential read and write mix",
                          },
+                         { .ival = "readwrite",
+                           .oval = TD_DDIR_RW,
+                           .help = "Sequential read and write mix",
+                         },
                          { .ival = "randrw",
                            .oval = TD_DDIR_RANDRW,
                            .help = "Random read and write mix"
@@ -1101,6 +1122,14 @@ static struct fio_option options[FIO_MAX_OPTS] = {
                .help   = "Start IO from this offset",
                .def    = "0",
        },
+       {
+               .name   = "offset_increment",
+               .type   = FIO_OPT_STR_VAL,
+               .off1   = td_var_offset(offset_increment),
+               .help   = "What is the increment from one offset to the next",
+               .parent = "offset",
+               .def    = "0",
+       },
        {
                .name   = "bs",
                .alias  = "blocksize",
@@ -1462,12 +1491,12 @@ static struct fio_option options[FIO_MAX_OPTS] = {
                            .help = "Use crc32 checksums for verification",
                          },
                          { .ival = "crc32c-intel",
-                           .oval = VERIFY_CRC32C_INTEL,
-                           .help = "Use hw crc32c checksums for verification",
+                           .oval = VERIFY_CRC32C,
+                           .help = "Use crc32c checksums for verification (hw assisted, if available)",
                          },
                          { .ival = "crc32c",
                            .oval = VERIFY_CRC32C,
-                           .help = "Use crc32c checksums for verification",
+                           .help = "Use crc32c checksums for verification (hw assisted, if available)",
                          },
                          { .ival = "crc16",
                            .oval = VERIFY_CRC16,
@@ -1670,6 +1699,13 @@ static struct fio_option options[FIO_MAX_OPTS] = {
                .name   = "zonesize",
                .type   = FIO_OPT_STR_VAL,
                .off1   = td_var_offset(zone_size),
+               .help   = "Amount of data to read per zone",
+               .def    = "0",
+       },
+       {
+               .name   = "zonerange",
+               .type   = FIO_OPT_STR_VAL,
+               .off1   = td_var_offset(zone_range),
                .help   = "Give size of an IO zone",
                .def    = "0",
        },
@@ -1848,6 +1884,13 @@ static struct fio_option options[FIO_MAX_OPTS] = {
                .help   = "Create files when they are opened for IO",
                .def    = "0",
        },
+       {
+               .name   = "create_only",
+               .type   = FIO_OPT_BOOL,
+               .off1   = td_var_offset(create_only),
+               .help   = "Only perform file creation phase",
+               .def    = "0",
+       },
        {
                .name   = "pre_read",
                .type   = FIO_OPT_BOOL,
@@ -1989,6 +2032,21 @@ static struct fio_option options[FIO_MAX_OPTS] = {
                .help   = "Slightly scramble buffers on every IO submit",
                .def    = "1",
        },
+       {
+               .name   = "buffer_compress_percentage",
+               .type   = FIO_OPT_INT,
+               .off1   = td_var_offset(compress_percentage),
+               .maxval = 100,
+               .minval = 1,
+               .help   = "How compressible the buffer is (approximately)",
+       },
+       {
+               .name   = "buffer_compress_chunk",
+               .type   = FIO_OPT_INT,
+               .off1   = td_var_offset(compress_chunk),
+               .parent = "buffer_compress_percentage",
+               .help   = "Size of compressible region in buffer",
+       },
        {
                .name   = "clat_percentiles",
                .type   = FIO_OPT_BOOL,
@@ -2142,6 +2200,40 @@ static struct fio_option options[FIO_MAX_OPTS] = {
                .off1   = td_var_offset(gid),
                .help   = "Run job with this group ID",
        },
+       {
+               .name   = "flow_id",
+               .type   = FIO_OPT_INT,
+               .off1   = td_var_offset(flow_id),
+               .help   = "The flow index ID to use",
+               .def    = "0",
+       },
+       {
+               .name   = "flow",
+               .type   = FIO_OPT_INT,
+               .off1   = td_var_offset(flow),
+               .help   = "Weight for flow control of this job",
+               .parent = "flow_id",
+               .def    = "0",
+       },
+       {
+               .name   = "flow_watermark",
+               .type   = FIO_OPT_INT,
+               .off1   = td_var_offset(flow_watermark),
+               .help   = "High watermark for flow control. This option"
+                       " should be set to the same value for all threads"
+                       " with non-zero flow.",
+               .parent = "flow_id",
+               .def    = "1024",
+       },
+       {
+               .name   = "flow_sleep",
+               .type   = FIO_OPT_INT,
+               .off1   = td_var_offset(flow_sleep),
+               .help   = "How many microseconds to sleep after being held"
+                       " back by the flow control mechanism",
+               .parent = "flow_id",
+               .def    = "0",
+       },
        {
                .name = NULL,
        },