dd命令进行磁盘性能测试
0.说在前面的话
因数据库迁移的需要，对前后两个环境的存储性能进行测试，而存储之于数据库的性能而言是至关重要的，在此使用系统自带的dd命令进行简单的读写测试，方便做横向对比。如果可以，则建议使用fio工具可以有更精准的结果。
1.dd命令的介绍
-
功能说明：可从标准输入或文件读取数据，依指定的格式来转换数据，再输出到文件，设备或标准输出。
-
语法：
dd [bs=<字节数>][cbs=<字节数>][conv=<关键字>][count=<区块数>][ibs=<字节数>][if=<文件>][obs=<字节数>][of=<文件>][seek=<区块数>][skip=<区块数>][--help][--version]
- 主要参数：
bs=<字节数> 将ibs( 输入)与obs(输出)设成指定的字节数。
cbs=<字节数> 转换时，每次只转换指定的字节数。
conv=<关键字> 指定文件转换的方式，conv的值包括：sync(写缓存，默认)、fsync、fdatasync。
count=<区块数> 仅读取指定的区块数。
ibs=<字节数> 每次读取的字节数。
if=<文件> 从文件读取。
obs=<字节数> 每次输出的字节数。
of=<文件> 输出到文件。
seek=<区块数> 一开始输出时，跳过指定的区块数。
skip=<区块数> 一开始读取时，跳过指定的区块数。
- 使用样例：
if=xxx 从xxx读取，如if=/dev/zero,该设备无穷尽地提供0,（不产生读磁盘IO）
of=xxx 向xxx写出，如of=/dev/null,写入它的内容都会永远丢失. （不产生写磁盘IO）
2.Linux下的测试脚本
为便于操作，使用LLM生成了测试脚本，但有以下注意事项：
- 顺序读写的BLOCK取1M，因为读取速度较快，需要读较大的文件（>10GB）；
- 随机读写，将BLOCK取4K，来模拟DB读写数据页的大小（非真实随机，仅参考），因读写较慢，取>2GB即可；
- 操作系统有时会缓存同名文件，读写的文件名加了个时间戳；
- 至少执行3次，结果才可以稳定。
#!/bin/bash
# Disk Performance Benchmark Script
# Usage: ./disk_benchmark_redhat.sh /path/to/test/directory
# Check arguments
if [ $# -eq 0 ]; then
echo "Error: Test directory must be specified as argument"
echo "Usage: $0 /path/to/test/directory"
exit 1
fi
TEST_DIR=$1
TIMESTAMP=$(date +%s) # Get current timestamp
TEST_FILE="$TEST_DIR/dd_testfile_$TIMESTAMP"
BLOCK_SIZE=1M # 1M
COUNT=10240 # 10GB Test with 10GB file
RAND_BLOCK_SIZE=4K # 4K
RAND_COUNT=512K # 2GB
# Check if test directory exists
if [ ! -d "$TEST_DIR" ]; then
echo "Error: Directory $TEST_DIR does not exist"
exit 1
fi
# Check available space
AVAIL_SPACE=$(df -B1G "$TEST_DIR" | awk 'NR==2 {print $4}')
if [ "$AVAIL_SPACE" -lt 2 ]; then
echo "Error: Insufficient space in directory $TEST_DIR, at least 20GB required"
exit 1
fi
echo "============================================="
echo "Starting Disk Performance Test - $(date)"
echo "Test Directory: $TEST_DIR"
echo "============================================="
# Sequential Write Test
echo -e "\n1. Sequential Write Test..."
WRITE_SPEED=$(dd if=/dev/zero of="$TEST_FILE" bs=$BLOCK_SIZE count=$COUNT oflag=direct conv=fdatasync 2>&1 | tail -1 | awk '{print $(NF-1), $NF}')
echo "Sequential Write Speed: $WRITE_SPEED"
# Sequential Read Test
echo -e "\n2. Sequential Read Test..."
READ_SPEED=$(dd if="$TEST_FILE" of=/dev/null bs=$BLOCK_SIZE iflag=direct count=$COUNT 2>&1 | tail -1 | awk '{print $(NF-1), $NF}')
echo "Sequential Read Speed: $READ_SPEED"
# Random Write Test (using direct flag to bypass cache)
echo -e "\n3. Random Write Test..."
RAND_WRITE_SPEED=$(dd if=/dev/zero of="$TEST_FILE" bs=$RAND_BLOCK_SIZE count=$RAND_COUNT oflag=direct 2>&1 | tail -1 | awk '{print $(NF-1), $NF}')
echo "Random Write Speed (4K): $RAND_WRITE_SPEED"
# Random Read Test (using direct flag to bypass cache)
echo -e "\n4. Random Read Test..."
RAND_READ_SPEED=$(dd if="$TEST_FILE" of=/dev/null bs=$RAND_BLOCK_SIZE count=$RAND_COUNT iflag=direct 2>&1 | tail -1 | awk '{print $(NF-1), $NF}')
echo "Random Read Speed (4K): $RAND_READ_SPEED"
# Clean up test file
rm -f "$TEST_FILE"
echo "============================================="
echo "Test Summary - $(date)"
echo "============================================="
echo "1. Sequential Write Speed (1M): $WRITE_SPEED"
echo "2. Sequential Read Speed (1M): $READ_SPEED"
echo "3. Random Write Speed (4K): $RAND_WRITE_SPEED"
echo "4. Random Read Speed (4K): $RAND_READ_SPEED"
echo "============================================="
3.AIX下的测试脚本
AIX下的dd命令与Liunx下的dd差别挺大的，通过各种调整如下，由于参数的用法与linux的不一致，且机器的特性差异很大，仅供两边对照参考。
#!/bin/ksh
# Disk Performance Test Script for AIX
# Usage: ./disk_benchmark_aix.sh /path/to/test/directory
# Check parameters
if [ $# -eq 0 ]; then
echo "Error: Must specify test directory"
echo "Usage: $0 /path/to/test/directory"
exit 1
fi
TEST_DIR=$1
TIMESTAMP=$(perl -e 'print time') # AIX-compatible timestamp
TEST_FILE="$TEST_DIR/test_$TIMESTAMP.dat"
BLOCK_SIZE=1048576 # 1M
COUNT=10240 # 10G
RAND_BLOCK_SIZE=4096 # 4k
RAND_COUNT=524288 # 2G
MB=1048576 # 1MB
# CACHE_DROP="sync; /usr/sbin/lockfs -f / 2>/dev/null" # AIX cache drop
# Check directory
if [ ! -d "$TEST_DIR" ]; then
echo "Error: Directory $TEST_DIR does not exist"
exit 1
fi
# Check space (AIX df format)
AVAIL_SPACE=$(df -g "$TEST_DIR" | awk 'NR==2 {print $3}' | tr -d 'GB')
if [ "$AVAIL_SPACE" -lt 20 ]; then
echo "Error: Need at least 20GB free space in $TEST_DIR"
exit 1
fi
echo "============================================="
echo "AIX Disk Performance Test - $(date)"
echo "Test Directory: $TEST_DIR"
echo "============================================="
# Sequential Write (o_direct for AIX)
echo "\n1. Sequential Write Test..."
WRITE_SPEED=$((time dd if=/dev/zero of=$TEST_FILE bs=$BLOCK_SIZE count=$COUNT conv=sync,notrunc) 2>&1 | awk '/real/ {split($2, t, "m"); sub("s", "", t[2]); sec=t[1]*60 + t[2]; print '$BLOCK_SIZE'*'$COUNT'/'$MB'/sec, "MB/s"}')
echo "Sequential Write Speed: $WRITE_SPEED"
# Sequential Read (i_direct for AIX)
echo "\n2. Sequential Read Test..."
READ_SPEED=$((time dd if="$TEST_FILE" of=/dev/null bs=$BLOCK_SIZE count=$COUNT conv=sync,notrunc) 2>&1 | awk '/real/ {split($2, t, "m"); sub("s", "", t[2]); sec=t[1]*60 + t[2]; print '$BLOCK_SIZE'*'$COUNT'/'$MB'/sec, "MB/s"}')
echo "Sequential Read Speed: $READ_SPEED"
# Random Write (4K blocks)
echo "\n3. Random Write Test..."
RAND_WRITE_SPEED=$((time dd if=/dev/zero of=$TEST_FILE bs=$RAND_BLOCK_SIZE count=$RAND_COUNT conv=sync,notrunc) 2>&1 | awk '/real/ {split($2, t, "m"); sub("s", "", t[2]); sec=t[1]*60 + t[2]; print '$RAND_BLOCK_SIZE'*'$RAND_COUNT'/'$MB'/sec, "MB/s"}')
echo "Random Write Speed (4K): $RAND_WRITE_SPEED"
# Random Read (4K blocks)
echo "\n4. Random Read Test..."
RAND_READ_SPEED=$((time dd if="$TEST_FILE" of=/dev/null bs=$RAND_BLOCK_SIZE count=$RAND_COUNT conv=sync,notrunc) 2>&1 | awk '/real/ {split($2, t, "m"); sub("s", "", t[2]); sec=t[1]*60 + t[2]; print '$RAND_BLOCK_SIZE'*'$RAND_COUNT'/'$MB'/sec, "MB/s"}')
echo "Random Read Speed (4K): $RAND_READ_SPEED"
# Cleanup
rm -f "$TEST_FILE"
echo "============================================="
echo "Test Summary - $(date)"
echo "============================================="
echo "1. Sequential Write (1M): $WRITE_SPEED"
echo "2. Sequential Read (1M): $READ_SPEED"
echo "3. Random Write (4K): $RAND_WRITE_SPEED"
echo "4. Random Read (4K): $RAND_READ_SPEED"
echo "============================================="
4.测试说明
- AIX下的dd命令没有如iflag=direct、oflag=direct等参数，没办法绕过缓存读写磁盘
- 在Liunx下通过iflag、oflag开启缓存，前后的对比结果差异极大，如下：
# 启用iflag=direct、oflag=direct，直接读写磁盘
=============================================
Test Summary - Thu Jul 17 08:58:18 CST 2025
=============================================
1. Sequential Write Speed (1M): 493 MB/s
2. Sequential Read Speed (1M): 840 MB/s
3. Random Write Speed (4K): 20.5 MB/s
4. Random Read Speed (4K): 62.3 MB/s
=============================================
# 禁用iflag=direct、oflag=direct，使用操作系统缓存
=============================================
Test Summary - Thu Jul 17 09:09:13 CST 2025
=============================================
1. Sequential Write Speed (1M): 2.8 GB/s
2. Sequential Read Speed (1M): 7.2 GB/s
3. Random Write Speed (4K): 1.4 GB/s
4. Random Read Speed (4K): 5.0 GB/s
=============================================
- 上述测试只针对在已挂载的磁盘目录上执行，不对裸设备读写（避免造成风险）。
- 如果想确切对比AIX、Linux之间的磁盘性能，还是要考虑使用fio工具较妥，后面再折腾吧。
5.附件
- Redhat 8.10下的dd命令的介绍
DD(1) User Commands DD(1)
NAME
dd - convert and copy a file
SYNOPSIS
dd [OPERAND]...
dd OPTION
DESCRIPTION
Copy a file, converting and formatting according to the operands.
bs=BYTES
read and write up to BYTES bytes at a time (default: 512); overrides ibs and obs
cbs=BYTES
convert BYTES bytes at a time
conv=CONVS
convert the file as per the comma separated symbol list
count=N
copy only N input blocks
ibs=BYTES
read up to BYTES bytes at a time (default: 512)
if=FILE
read from FILE instead of stdin
iflag=FLAGS
read as per the comma separated symbol list
obs=BYTES
write BYTES bytes at a time (default: 512)
of=FILE
write to FILE instead of stdout
oflag=FLAGS
write as per the comma separated symbol list
seek=N skip N obs-sized blocks at start of output
skip=N skip N ibs-sized blocks at start of input
status=LEVEL
The LEVEL of information to print to stderr; 'none' suppresses everything but error messages, 'noxfer' suppresses the final
transfer statistics, 'progress' shows periodic transfer statistics
N and BYTES may be followed by the following multiplicative suffixes: c =1, w =2, b =512, kB =1000, K =1024, MB =1000*1000, M
=1024*1024, xM =M, GB =1000*1000*1000, G =1024*1024*1024, and so on for T, P, E, Z, Y.
Each CONV symbol may be:
ascii from EBCDIC to ASCII
ebcdic from ASCII to EBCDIC
ibm from ASCII to alternate EBCDIC
block pad newline-terminated records with spaces to cbs-size
unblock
replace trailing spaces in cbs-size records with newline
lcase change upper case to lower case
ucase change lower case to upper case
sparse try to seek rather than write the output for NUL input blocks
swab swap every pair of input bytes
sync pad every input block with NULs to ibs-size; when used with block or unblock, pad with spaces rather than NULs
excl fail if the output file already exists
nocreat
do not create the output file
notrunc
do not truncate the output file
noerror
continue after read errors
fdatasync
physically write output file data before finishing
fsync likewise, but also write metadata
Each FLAG symbol may be:
append append mode (makes sense only for output; conv=notrunc suggested)
direct use direct I/O for data
directory
fail unless a directory
dsync use synchronized I/O for data
sync likewise, but also for metadata
fullblock
accumulate full blocks of input (iflag only)
nonblock
use non-blocking I/O
noatime
do not update access time
nocache
Request to drop cache. See also oflag=sync
noctty do not assign controlling terminal from file
nofollow
do not follow symlinks
count_bytes
treat 'count=N' as a byte count (iflag only)
skip_bytes
treat 'skip=N' as a byte count (iflag only)
seek_bytes
treat 'seek=N' as a byte count (oflag only)
Sending a USR1 signal to a running 'dd' process makes it print I/O statistics to standard error and then resume copying.
Options are:
--help display this help and exit
--version
output version information and exit
AUTHOR
Written by Paul Rubin, David MacKenzie, and Stuart Kemp.
REPORTING BUGS
GNU coreutils online help: <https://www.gnu.org/software/coreutils/>
Report dd translation bugs to <https://translationproject.org/team/>
COPYRIGHT
Copyright © 2018 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <https://gnu.org/licenses/gpl.html>.
This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law.
SEE ALSO
Full documentation at: <https://www.gnu.org/software/coreutils/dd>
or available locally via: info '(coreutils) dd invocation'
GNU coreutils 8.30 July 2018 DD(1)
- AIX 7.1下的dd命令介绍
dd Command
Purpose
Converts and copies a file.
Syntax
dd [ bs=BlockSize ][cbs=BlockSize ]
[lcase | ucase ] [iblock ]
[noerror ] [swab ] [sync ]
[oblock ] [notrunc ]][count=
InputBlocks ] [ files=InputFiles ] [fskip=
SkipEOFs ] [ ibs=InputBlockSize ] [if=
InFile ] [ obs=OutputBlockSize ] [of=
OutFile ] [ seek=RecordNumber ] [skip=
SkipInputBlocks ][ span=yes|no ]
dd [ Option=Value ]
Description
The dd command reads the InFile parameter or standard input, does the specified conversions, then copies the converted data to the OutFile parameter or standard output. The input and output block size can be specified to take advantage of raw physical I/O.
Note: The term Block refers to the quantity of data read or written by the dd command in one operation and is not necessarily the same size as a disk block.
Where sizes are specified, a number of bytes is expected. A number ending with w, b, or k specifies multiplication by 2, 512, or 1024 respectively; a pair of numbers separated by an x or an * (asterisk) indicates a product. The count parameter expects the number of blocks, not
the number of bytes, to be copied.
The character-set mappings associated with the conv=ascii and conv=ebcdic flags are complementary operations. These flags map between ASCII characters and the subset of EBCDIC characters found on most workstations and keypunches.
Use the cbs parameter value if specifying any of the block, unblock, ascii, ebcdic, or ibm conversions. If unblock or ascii parameters are specified, then the dd command performs a fixed-length to variable-length conversion. Otherwise it performs a conversion from variable-
length to fixed-length. The cbs parameter determines the fixed-length. Attention: If the cbs parameter value is specified smaller than the smallest input block, the converted block is truncated.
After it finishes, the dd command reports the number of whole and partial input and output blocks.
Note:
1 Usually, you need only write access to the output file. However, when the output file is not on a direct-access device and you use the seek flag, you also need read access to the file.
2 The dd command inserts new-line characters only when converting with the conv=ascii or conv=unblock flags set; it pads only when converting with the conv=ebcdic, conv=ibm, or conv=block flags set.
3 Use the backup, tar, or cpio command instead of the dd command whenever possible to copy files to tape. These commands are designed for use with tape devices. For more information on using tape devices, see the rmt special file.
4 The block size values specified with the bs, ibs and obs flags must always be a multiple of the physical block size for the media being used.
5 When the conv=sync flag is specified, the dd command pads any partial input blocks with nulls. Thus, the dd command inserts nulls into the middle of the data stream if any of the reads do not receive a full block of data (as specified by the ibs flag). This is a common
occurrence when reading from pipes.
6 If the bs flag is specified by itself and no conversions other than sync, noerror or notrunc are specified, then the data from each input block will be written as a separate output block; if the read returns less than a full block and sync is not specified, then the
resulting output block will be the same size as the input block. If the bs flag is not specified, or a conversion other than sync, noerror or notrunc is specified, then the input will be processed and collected into fullsized output blocks until the end of input is
reached.
Spanning across devices
The dd can be made to span across devices if the input file is larger than the output device physical size.
Note: Care has to be taken when specifying the block size bs as exact multiple of the physical size of the device because improper block size will result in data inconsistency, or overlap.
The spanning of dd across devices will not occur if either one of the InFile or the OutFile parameter is stdin or stdout.
Spanning will occur in such a way that dd will prompt for next device during write if the output device is full. During read from the input device, dd will prompt for next device if the data is completely read from the input device even when the device has not reached the end.
In this case it would be required to press 'n' to quit.
Flags
Item
Description
bs=BlockSize
Specifies both the input and output block size, superseding the ibs and obs flags. The block size values specified with the bs flag must always be a multiple of the physical block size for the media being used.
cbs=BlockSize
Specifies the conversion block size for variable-length to fixed-length and fixed-length to variable-length conversions, such as conv=block.
count=InputBlocks
Copies only the number of input blocks specified by the InputBlocks variable.
conv= Conversion,....
Specifies one or more conversion options. Multiple conversions should be separated by commas. The following list describes the possible options:
ascii
Converts EBCDIC to ASCII. This option is incompatible with the ebcdic, ibm, block, and unblock options.
block
Converts variable-length records to fixed-length. The length is determined by the conversion block size (cbs). This option is incompatible with the ascii, ebcdic, ibm, and unblock options.
ebcdic
Converts ASCII to standard EBCDIC. This option is incompatible with the ascii, ibm, block, and unblock options.
ibm
Converts ASCII to an IBM version of EBCDIC. This option is incompatible with the ascii, ebcdic, block, and unblock options.
iblock, oblock
Minimize data loss resulting from a read or write error on direct access devices. If you specify the iblock variable and an error occurs during a block read (where the block size is 512 or the size specified by the ibs=InputBlockSize variable), the dd command
attempts to reread the data block in smaller size units. If the dd command can determine the sector size of the input device, it reads the damaged block one sector at a time. Otherwise, it reads it 512 bytes at a time. The input block size ( ibs) must be a multiple
of this retry size. This option contains data loss associated with a read error to a single sector. The oblock conversion works similarly on output.
lcase
Makes all alphabetic characters lowercase.
noerror
Does not stop processing on an error.
notrunc
Does not truncate the output file. Instead, blocks not explicitly written to output are preserved.
ucase
Makes all alphabetic characters uppercase.
swab
Swaps every pair of bytes.
sync
Pads every input block to the ibs value.
unblock
Converts fixed-length blocks to variable-length. The length is determined by the conversion block size (cbs). This option is incompatible with the ascii, ebcdic, ibm, and block options.
files=InputFiles
Copies the number of files specified by the InputFiles variable value of input files before ending (makes sense only where input is a magnetic tape or similar device).
fskip=SkipEOFs
Skips past the number of end-of-file characters specified by the SkipEOFs variable before starting to copy; this SkipEOFs variable is useful for positioning on multifile magnetic tapes.
ibs=InputBlockSize
Specifies the input-block size; the default is 512 bytes or one block. The block-size values specified with the ibs flag must always be a multiple of the physical block size for the media being used.
if=InFile
Specifies the input file name; standard input is the default.
obs=OutputBlockSize
Specifies the output-block size; the default is 512 bytes or one block. The block size values specified with the obs flag must always be a multiple of the physical block size for the media being used.
of=OutFile
Specifies the output file name; standard output is the default.
seek=RecordNumber
Seeks the record specified by the RecordNumber variable from the beginning of output file before copying.
skip=SkipInputBlocks
Skips the specified SkipInputBlocks value of input blocks before starting to copy.
span=yes|no
Allows spanning across devices if specified yes and works as default if specified as no. See Spanning Across Devices, for more information..
Exit Status
This command returns the following exit values:
Item
Description
0
The input file was copied successfully.
>0
An error occurred.
Examples
1 To convert an ASCII text file to EBCDIC, type:
dd if=text.ascii of=text.ebcdic conv=ebcdic This command converts the text.ascii file to EBCDIC representation, storing the EBCDIC version in the text.ebcdic file.
Note: When you specify the conv=ebcdic parameter, the dd command converts the ASCII ^ (circumflex) character to an unused EBCDIC character (9A hexadecimal), and the ASCII ~ (tilde) to the EBCDIC ^ (NOT symbol).
2 To convert the variable-length record ASCII file /etc/passwd to a file of 132-byte fixed-length EBCDIC records, type:
dd if=/etc/passwd cbs=132 conv=ebcdic of=/tmp/passwd.ebcdic
3 To convert the 132-byte-per-record EBCDIC file to variable-length ASCII lines in lowercase, type:
dd if=/tmp/passwd.ebcdic cbs=132 conv=ascii of=/tmp/passwd.ascii
4 To convert the variable-length record ASCII file /etc/passwd to a file of 132-byte fixed-length records in the IBM version of EBCDIC, type:
dd if=/etc/passwd cbs=132 conv=ibm of=/tmp/passwd.ibm
5 To copy blocks from a tape with 1KB blocks to another tape using 2KB blocks, type:
dd if=/dev/rmt0 ibs=1024 obs=2048 of=/dev/rmt1
6 To use the dd command as a filter, type:
ls -l | dd conv=ucase This command displays a long listing of the current directory in uppercase.
Note: The performance of the dd command and cpio command to the 9348 Magnetic Tape Unit Model 12 can be improved by changing the default block size. To change the block size, use the chdev command in the following way:
chdev -l Device_name -a block_size=32k
7 To perform efficient transfers to 3.5-inch 1.4MB diskette using 36 blocks of 512 bytes, type:
dd if=Filename of=/dev/rfd0 bs=36b conv=sync
This command writes the value of the Filename parameter to the diskette device a cylinder at a time. The conv=sync is required when reading from disk and when the file size is not a multiple of the diskette block size. Do not try this if the input to the dd command is a
pipe instead of a file, it will pad most of the input with nulls instead of just the last block.
8 To copy blocks from a input file with block size set to 720b blocks into a 1.44MB size diskette type:
dd if=testfile of=/dev/fd0 bs=720b conv=sync
Note: If the input file is larger than the physical size of the output device then dd will prompt you for another device.
9 To copy blocks from a input file with block size set to 32k blocks to a tape type:
dd if=inputfile of=/dev/rmt0 bs=32k conv=sync
10 To copy blocks of data from tape to a file in the current directory with block size set to 32k blocks type as follows:
dd if=/dev/rmt0 of=outfile bs=32k conv=sync
11 To copy blocks from an input file with block size set to 720b, onto a 1.44MB size diskette, enter:
dd if=testfile of=/dev/fd0 bs=720b conv=sync span=yes
Note: If the input file is larger than the physical size of the output device, then dd will prompt you for another device.
12 To copy blocks from an input file with block size set to 32k, to a tape, enter:
dd if=inputfile of=/dev/rmt0 bs=32k conv=sync span=yes
13 To copy blocks of data from tape with block size set to 32k, to a file in the current directory, enter:
dd if=dev/rmt0 of=outfile bs=32k conv=sync span=yes
Files
Item
Description
/usr/bin/dd
Contains the dd command.
浙公网安备 33010602011771号