IOPING(1)                        User Commands                       IOPING(1)

       ioping - simple disk I/O latency monitoring tool

       ioping [-ABCDLRWGYykq] [-c count] [-i interval] [-l speed] [-t time]
              [-T time] [-s size] [-S wsize] [-o offset] [-w deadline]
              [-p period] [-P period] directory|file|device
       ioping -h | -v

       This tool generates various I/O patterns and lets you monitor I/O speed
       and latency in real time.

       -c count
              Stop after count requests.

       -i interval
              Set time between requests to interval (1s).

       -l speed
              Set speed limit in bytes per second. Set interval to request-
              size / speed.

       -t time
              Minimal valid request time (0us).  Too fast requests are ignored
              in statistics.

       -T time
              Maximum valid request time.  Too slow requests are ignored in

       -s size
              Request size (4k).

       -S wsize
              Working set size (1m for directory, whole size for file or

       -o offset
              Starting offset in the file/device (0).

       -w deadline
              Stop after deadline time passed.

       -p period
              Print raw statistics for every period requests (see format

       -P period
              Print raw statistics for every period in time.

       -A     Use asynchronous I/O (io_setup(2), io_submit(2) etc syscalls).

       -B     Batch mode. Be quiet and print final statistics in raw format.

       -C     Use cached I/O. Suppress cache invalidation via
              posix_fadvise(2)) before read and fdatasync(2) after each write.

       -D     Use direct I/O (see O_DIRECT in open(2)).

       -L     Use sequential operations rather than random. This also sets
              default request size to 256k (as in -s 256k).

       -R     Disk seek rate test. This option suppress human-readable output
              for each request (as -q), sets default interval to zero (-i 0),
              stops measurement after 3 seconds (-w 3) and increases default
              working set size to 64m (-S 64m). Working set (-S) should be
              increased accordingly if disk has huge cache.

       -W     Use writes rather than reads. Safe for directory target. Write
              I/O gives more reliable results for systems where non-cached
              reads are not supported or cached at some level. Might be
              *DANGEROUS* for file/device: it will shred your data. In this
              case should be repeated three times (-WWW).

       -G     Alternate read and write requests.

       -Y     Use sync I/O (see O_SYNC in open(2)).

       -y     Use data sync I/O (see O_DSYNC in open(2)).

       -k     Keep and reuse temporary working file "ioping.tmp" (only for
              directory target).

       -q     Suppress periodical human-readable output.

       -h     Display help message and exit.

       -v     Display version and exit.

   Argument suffixes
       For options that expect time argument (-i, -P and -w), default is
       seconds, unless you specify one of the following suffixes (case-

       ns, nsec
              nanoseconds (a billionth of a second, 1 / 1 000 000 000)

       us, usec
              microseconds (a millionth of a second, 1 / 1 000 000)

       ms, msec
              milliseconds (a thousandth of a second, 1 / 1 000)

       s, sec seconds

       m, min minutes

       h, hour

       For options that expect "size" argument (-s, -S and -o), default is
       bytes, unless you specify one of the following suffixes (case-

       sector disk sectors (a sector is always 512).

       KiB, k, kb
              kilobytes (1 024 bytes)

       page   memory pages (a page is always 4KiB).

       MiB, m, mb
              megabytes (1 048 576 bytes)

       GiB, g, gb
              gigabytes (1 073 741 824 bytes)

       TiB, t, tb
              terabytes (1 099 511 627 776 bytes)

       For options that expect "number" argument (-p and -c) you can
       optionally specify one of the following suffixes (case-insensitive):

       k      kilo (thousands, 1 000)

       m      mega (millions, 1 000 000)

       g      giga (billions, 1 000 000 000)

       t      tera (trillions, 1 000 000 000 000)

       Returns 0 upon success. The following error codes are defined:

       1      Invalid usage (error in arguments).

       2      Error during preparation stage.

       3      Error during runtime.

       ioping -p 100 -c 200 -i 0 -q .
       99 10970974 9024 36961531 90437 110818 358872 30756 100 12516420
       100 9573265 10446 42785821 86849 95733 154609 10548 100 10649035
       (1) (2)     (3)   (4)      (5)   (6)   (7)    (8)   (9) (10)

       (1) count of requests in statistics
       (2) running time         (nanoseconds)
       (3) requests per second  (iops)
       (4) transfer speed       (bytes per second)
       (5) minimal request time (nanoseconds)
       (6) average request time (nanoseconds)
       (7) maximum request time (nanoseconds)
       (8) request time standard deviation (nanoseconds)
       (9) total requests       (including warmup, too slow or too fast)
       (10) total running time  (nanoseconds)

       ioping .
              Show disk I/O latency using the default values and the current
              directory, until interrupted. This command prepares temporary
              (unlinked/hidden) working file and reads random chunks from it
              using non-cached read requests.

       ioping -c 10 -s 1M /tmp
              Measure latency on /tmp using 10 requests of 1 megabyte each.

       ioping -R /dev/sda
              Measure disk seek rate.

       ioping -RL /dev/sda
              Measure disk sequential speed.

       ioping -RLB . | awk '{print $4}'
              Get disk sequential speed in bytes per second.

       iostat(1), dd(1), fio(1), stress(1), stress-ng(1), dbench(1),
       sysbench(1), fsstress, xfstests, hdparm(8), badblocks(8),


       This program was written by Konstantin Khlebnikov ⟨⟩.
       Man-page was written by Kir Kolyshkin ⟨⟩.

                                   Oct 2014                          IOPING(1)