Specifies which APIs to test. api_list is a comma-separated list with the following valid values:

(Default: All APIs)

Example, --api=mpiio,phdf5 specifies that the MPI I/O and Parallel HDF5 APIs are to be monitored.

Block size versus transfer buffer size: 
The transfer buffer size is the size of a buffer in memory. The data in that buffer is broken into block size pieces and written to the file.

Transfer buffer size is discussed below with the -x (or --min-xfer-size) and -X (or --max-xfer-size) options.

The pattern in which the blocks are written to the file is described in the discussion of the -I (or --interleaved) option.


If this option is set and the MPI-I/O and PHDF5 APIs are in use, all the blocks of every process will be written at once with an MPI derived type.

Sets the debugging level. debug_flags is a comma-separated list of debugging flags with the following valid values:

(Default: No debugging)

Example: --debug=2,r,t specifies to run a moderate level of debugging while collecting raw data I/O throughput information and verifying the correctness of the data.

Throughput values are computed by dividing the total amount of transferred data (excluding metadata) over the time spent by the slowest process. Several time counters are defined to measure the data transfer time and the total elapsed time; the latter includes the time spent during file open and close operations. A number of iterations can be specified with the option -i (or --num-iterations) to create the desired population of measurements from which maximum, minimum, and average values can be obtained. The timing scheme is the following:

    for each iteration
        initialize elapsed time counter
        initialize data transfer time counter
        for each file
            start and accumulate elapsed time counter
                file open
                start and accumulate data transfer time counter
                    access entire file
                stop data transfer time counter
                file close
            stop elapsed time counter
        end file
        save elapsed time counter
        save data transfer time counter
    end iteration
            

The reported write throughput is based on the accumulated data transfer time, while the write open-close throughput uses the accumulated elapsed time.

Depending on the selected geometry, each test dataset can be a linear array of size bytes-per-process * num-processes or a square array of size (bytes-per-process * num-processes) × (bytes-per-process * num-processes). The number of processes is set by the -p (or --min-num-processes) and -P (or --max-num-processes) options.

Interleaved and contiguous patterns in 1D geometry: 
When a contiguous access pattern is chosen, the dataset is evenly divided into num-processes regions and each process writes data to its assigned region. When interleaved blocks are written to a dataset, space for the first block of the first process is allocated in the dataset, then space is allocated for the first block of the second process, etc., until space is allocated for the first block of each process, then space is allocated for the second block of the first process, the second block of the second process, etc.

For example, with a three process run, 512KB bytes-per-process, 256KB transfer buffer size, and 64KB block size, each process must issue two transfer requests to complete access to the dataset.

Contiguous blocks of the first transfer request are written as follows: 
    1111----2222----3333----

Interleaved blocks of the first transfer request are written as follows: 
    123123123123------------

The actual number of I/O operations involved in a transfer request depends on the access pattern and communication mode. When using independent I/O with an interleaved access pattern, each process performs four small non-contiguous I/O operations per transfer request. If collective I/O is turned on, the combined content of the buffers of the three processes will be written using one collective I/O operation per transfer request.

For details regarding the impact of performance and access patterns in 2D, see the “h5perf User Guide.”

This option and the -X size option (or --max-xfer-size=size) control transfer-buffer-size, the size of the transfer buffer in memory. In 1D geometry, the transfer buffer is a linear array of size transfer-buffer-size. In 2D geometry, the transfer buffer is a rectangular array of size block-size × transfer-buffer-size, or transfer-buffer-size × block-size if the interleaved access pattern is selected.