-B, --max-buffer-size=BUFFER_SIZE

Each write(2) call uses a maximum buffer of size BUFFER_SIZE.

-b, --min-buffer-size=BUFFER_SIZE

Each write(2) call uses a minimum buffer of size BUFFER_SIZE.

-c, --continue-after-error

Continue after data integrity errors.

-d, --direct

Use direct I/O. Should only be used on block device files. Not all operating systems support direct I/O

-g, --generate-load

Equivalent to: -v -t -P -p random -i 0.

-i, --iterations=COUNT

Write/read data COUNT times. If count is 0, repeats forever.

-l, --logfile=LOGFILE

Send log messages to LOGFILE.

--no-progress

Don't show progess (default).

--no-rcfiles

Don't use standard rcfiles.

-q, --no-statistics

Don't output statistics.

--no-tui

Don't use TUI interface.

-o, --offset=OFFSET

Seek to OFFSET before starting I/O.

-P, --progress

Show progess.

-p, --pattern=PATTERN

Use data pattern PATTERN when reading or writing data.

-r, --random

Read/Write buffers to random offsets.

--raw

An alias for --read-after-write.

--rcfile=RCFILE

Read command-line options from RCFILE.

--read

Read date from FILE.

--read-after-write

Read back data after writing to FILE.

-S, --seed=SEED

Use SEED for random number seed.

-s, --sync

Use synchronous I/O.

--statistics

Output statistics (default).

-t, --tui

Use curses-based, terminal user interface.

-u, --units=UNITS

Show tranfer rate in UNITS units.

--usage

Show brief usage message and exit.

-V, --version

Output version information and exit.

-v, --detailed-statistics

Output detailed statistics.

--write

Write data to FILE.

-?, --help

Show this help and exit.

FILE

Regular or device file to write data to.

LOGFILE

Path to a file used for logging.

MAX_BUFFER_SIZE

Mimimum buffer size used in each write(2) call (default is MIN_BUFFER_SIZE bytes). MAX_BUFFER_SIZE. Must be an even multiple of 512 bytes and can be specified in bytes, kibibytes(k), kilobytes(K), mebibytes(m), megabytes(M), gibibytes(g), gigabytes(G). tebibytes(t), or terabytes(T). MAX_BUFFER_SIZE defaults to MIN_BUFFER_SIZE. If MAX_BUFFER_SIZE > MIN_BUFFER_SIZE, random buffers sizes between the two limits are used. MAX_BUFFER_SIZE must be an even multiple of MIN_BUFFER_SIZE.

MIN_BUFFER_SIZE

Mimimum buffer size used in each write(2) call (default is 512 bytes). MIN_BUFFER_SIZE. Must be an even multiple of 512 bytes and can be specified in bytes, kibibytes(k), kilobytes(K), mebibytes(m), megabytes(M), gibibytes(g), gigabytes(G). tebibytes(t), or terabytes(T).

OFFSET

Position to seek to in the file before starting I/O (default is 0). OFFSET must be an even multiple of 512 bytes and can be specified in bytes, kibibytes(k), kilobytes(K), mebibytes(m), megabytes(M), gibibytes(g), gigabytes(G). tebibytes(t), or terabytes(T).

PATTERN

Data pattern used when writing/reading data. Available patterns are: none, zeros, random, and numbers. The default pattern is none.

RCFILE

Read additional command-line options from RCFILE. Other options on the command-line will override options in RCFILE.

SEED

Used to seed the random number generator Must be >= 1 and <= 2^32.

TRANSFER_SIZE

Total number of bytes to transfer (must be an even multiple of both MIN_BUFFER_SIZE and MAX_BUFFER)SIZE). TRANSER_SIZE can be specified in bytes, kilobytes, megabytes, or gigabytes.

UNITS

Kibibytes(k), kilobytes(K), mebibytes(m), megabytes(M), gibibytes(g), gigabytes(G). tebibytes(t), or terabytes(T).

or

spew -b 16k 1m /tmp/bigfile

Writes 1 mebibyte (1 mebibyte = 1024*1024 bytes) using 16 kibibytes (1 kibibyte = 1024 bytes) requests to the file /tmp/bigfile using the default pattern (random). Displays the write transfer rate in kibibytes per second and the write transfer time in seconds.

spew --write -u m -i 10 -b 1k 256k /dev/sda1

or

spew -u m -i 10 -b 1k 256k /dev/sda1

Writes 256 kibibytes using 1 kibibyte requests to the block device file /dev/sda1 10 times using the default pattern (random). The iteration and cumulative write transfer rates are displayed in mebibytes per second and the iteration and cumulative write transfer times are displayed in seconds.

spew --raw -d -o 1m -b 16m 1g /tmp/bigfile

or

regorge -s -o 1m -b 16m 1g /tmp/bigfile

Write 1 gibibyte (1 gibibyte = 1024*1024*1024 bytes) starting at an offset of 1 mebibyte using 16 mebibyte requests to the file /tmp/bigfile using the default pattern (random). The data is written synchronously and flushed at file close. Then read in the same data using the same request size and offset. The data is checked to ensure that the data read in matches the data read out. Write and read tranfers rates are displayed in kibibytes/second. Read are write transfer times are displayed in seconds.

spew --read -i 0 -u M -p zeros -b 512 1m /dev/zero

or

gorge -i 0 -u M -p zeros -b 512 1m /dev/zero

Read 1 mebibyte of data using 512 byte requests from the file /dev/zero an infinite number of times using the zeros pattern (don't check the data). The iteration and cumulative read transfer rates are displayed in megabytes (1 megabyte = 1,000,000 bytes) per second and the iteration and cumulative read transfer times are displayed in seconds.

spew --raw -g -r -b 1k -B 256K 1t /dev/md1

or

regorge -g -r -b 1k -B 256K 1t /dev/md1

Write 1 tebibyte (1 tebibyte = 1024*1024*1024*1024 bytes) using 1-256 kibibyte requests to the block device /dev/md1 using the random pattern. Random seeks are performed before each transfer, but each block between the start and end of the data is written exactly once. The request sizes are chosen randomly. Then read in the same data using the same request sizes and seeks in the same sequence. Repeat the above sequence an infinite number of times until told to quit (via signal or TUI command).

The data is checked to ensure that the data read in matches the data read out. A curses-based TUI is used to diplay iteration and cumulative transfer rates, transfer times, and bytes transferred. Display verbose statistics after quitting.

Find the largest blocksize that is a power of 2 and is >= MAX_BUFFER_SIZE. Call this maxbuffersize. Find the smallest buffersize that is a power of 2 and is >= MIN_BUFFER_SIZE. Call this minbuffersize. Chunksize = maxbuffersize * (difference in number of bits between min and maxbuffersize + 1). The number of chunks is TRANFSER_SIZE/chunksize. Call this numchunks. There will be numchunks number of read/writes that are of size maxbuffersize, 2 * numchunks number of read/writes that are of size maxbuffersize/2, 4 * numchunks number of read/writes that are of size maxbuffersize/4, and so on until minbuffersize is reached. MIN_BUFFER_SIZE is used for any remaining transfers if TRANSFER_SIZE is not evenly divisible by chunksize.

Example: Using a MIN_BLOCK_SIZE of 1k, a MAX_BLOCK_SIZE of 8k and a TRANSFER_SIZE of 264k results in 8 8k read/writes, 16 4k read/write, 32 2k read/writes, and 64 + 8 1k read/writes.

od -A d --format=d8 --width=32 <file>

$HOME/.spewrc or $SPEWRC

Holds user default options. These options precede any options included on the command-line.

/etc/spew.conf

Holds system-wide default options. These options precede any options included on the command-line and options included from $HOME/.spewrc or $SPEWRC.

Copyright 2004 Hewlett-Packard Corp.