设为首页 - 加入收藏 ASP站长网（Aspzz.Cn）- 科技、建站、经验、云计算、5G、大数据,站长网！
热搜： 手机 数据 公司
当前位置： 首页 > 服务器 > 搭建环境 > Windows > 正文

使用dd检查存储性能

发布时间：2019-08-07 16:13 所属栏目：117 来源：Gregory Bartholomew
导读：本文包含一些示例命令，向你展示如何使用 dd 命令 粗略 估计硬盘驱动器和 RAID 阵列的性能。准确的测量必须考虑诸如写入放大和系统调用开销之类的事情，本指南不会考虑这些。对于可能提供更准确结果的工具，你可能需要考虑使用 hdparm。 为了分解与文件系

使用dd检查存储性能

本文包含一些示例命令，向你展示如何使用 dd 命令粗略估计硬盘驱动器和 RAID 阵列的性能。准确的测量必须考虑诸如写入放大和系统调用开销之类的事情，本指南不会考虑这些。对于可能提供更准确结果的工具，你可能需要考虑使用 hdparm。

为了分解与文件系统相关的性能问题，这些示例显示了如何通过直接读取和写入块设备来在块级测试驱动器和阵列的性能。警告：写入测试将会销毁用来运行测试的块设备上的所有数据。不要对包含你想要保留的数据的任何设备运行这些测试！

四个测试

下面是四个示例 dd 命令，可用于测试块设备的性能：

1、 从 $MY_DISK 读取的一个进程：

  1. # dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache

2、写入到 $MY_DISK 的一个进程：

  1. # dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct

3、从 $MY_DISK 并发读取的两个进程：

  1. # (dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache &); (dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache skip=200 &)

4、 并发写入到 $MY_DISK 的两个进程：

  1. # (dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct &); (dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct skip=200 &)
  • 执行读写测试时，相应的 iflag=nocache 和 oflag=direct 参数非常重要，因为没有它们，dd 命令有时会显示从内存中传输数据的结果速度，而不是从硬盘。
  • bs 和 count 参数的值有些随意，我选择的值应足够大，以便在大多数情况下为当前硬件提供合适的平均值。
  • null 和 zero 设备在读写测试中分别用于目标和源，因为它们足够快，不会成为性能测试中的限制因素。
  • 并发读写测试中第二个 dd 命令的 skip=200 参数是为了确保 dd 的两个副本在硬盘驱动器的不同区域上运行。

16 个示例

下面是演示，显示针对以下四个块设备中之一运行上述四个测试中的各个结果：

  1. MY_DISK=/dev/sda2（用在示例 1-X 中）
  2. MY_DISK=/dev/sdb2（用在示例 2-X 中）
  3. MY_DISK=/dev/md/stripped（用在示例 3-X 中）
  4. MY_DISK=/dev/md/mirrored（用在示例 4-X 中）

首先将计算机置于救援模式，以减少后台服务的磁盘 I/O 随机影响测试结果的可能性。警告：这将关闭所有非必要的程序和服务。在运行这些命令之前，请务必保存你的工作。你需要知道 root 密码才能进入救援模式。passwd 命令以 root 用户身份运行时，将提示你（重新）设置 root 帐户密码。

  1. $ sudo -i
  2. # passwd
  3. # setenforce 0
  4. # systemctl rescue

你可能还想暂时禁止将日志记录到磁盘：

  1. # sed -r -i.bak 's/^#?Storage=.*/Storage=none/' /etc/systemd/journald.conf
  2. # systemctl restart systemd-journald.service

如果你有交换设备，可以暂时禁用它并用于执行后面的测试：

  1. # swapoff -a
  2. # MY_DEVS=$(mdadm --detail /dev/md/swap | grep active | grep -o "/dev/sd.*")
  3. # mdadm --stop /dev/md/swap
  4. # mdadm --zero-superblock $MY_DEVS

示例 1-1 （从 sda 读取）

  1. # MY_DISK=$(echo $MY_DEVS | cut -d ' ' -f 1)
  2. # dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 1.7003 s, 123 MB/s

示例 1-2 （写入到 sda）

  1. # MY_DISK=$(echo $MY_DEVS | cut -d ' ' -f 1)
  2. # dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 1.67117 s, 125 MB/s

示例 1-3 （从 sda 并发读取）

  1. # MY_DISK=$(echo $MY_DEVS | cut -d ' ' -f 1)
  2. # (dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache &); (dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache skip=200 &)
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 3.42875 s, 61.2 MB/s
  4. 200+0 records in
  5. 200+0 records out
  6. 209715200 bytes (210 MB, 200 MiB) copied, 3.52614 s, 59.5 MB/s

示例 1-4 （并发写入到 sda）

  1. # MY_DISK=$(echo $MY_DEVS | cut -d ' ' -f 1)
  2. # (dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct &); (dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct skip=200 &)
  1. 200+0 records out
  2. 209715200 bytes (210 MB, 200 MiB) copied, 3.2435 s, 64.7 MB/s
  3. 200+0 records in
  4. 200+0 records out
  5. 209715200 bytes (210 MB, 200 MiB) copied, 3.60872 s, 58.1 MB/s

示例 2-1 （从 sdb 读取）

  1. # MY_DISK=$(echo $MY_DEVS | cut -d ' ' -f 2)
  2. # dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 1.67285 s, 125 MB/s

示例 2-2 （写入到 sdb）

  1. # MY_DISK=$(echo $MY_DEVS | cut -d ' ' -f 2)
  2. # dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 1.67198 s, 125 MB/s

示例 2-3 （从 sdb 并发读取）

  1. # MY_DISK=$(echo $MY_DEVS | cut -d ' ' -f 2)
  2. # (dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache &); (dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache skip=200 &)
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 3.52808 s, 59.4 MB/s
  4. 200+0 records in
  5. 200+0 records out
  6. 209715200 bytes (210 MB, 200 MiB) copied, 3.57736 s, 58.6 MB/s

示例 2-4 （并发写入到 sdb）

  1. # MY_DISK=$(echo $MY_DEVS | cut -d ' ' -f 2)
  2. # (dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct &); (dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct skip=200 &)
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 3.7841 s, 55.4 MB/s
  4. 200+0 records in
  5. 200+0 records out
  6. 209715200 bytes (210 MB, 200 MiB) copied, 3.81475 s, 55.0 MB/s

示例 3-1 （从 RAID0 读取）

  1. # mdadm --create /dev/md/stripped --homehost=any --metadata=1.0 --level=0 --raid-devices=2 $MY_DEVS
  2. # MY_DISK=/dev/md/stripped
  3. # dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 0.837419 s, 250 MB/s

示例 3-2 （写入到 RAID0）

  1. # MY_DISK=/dev/md/stripped
  2. # dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 0.823648 s, 255 MB/s

示例 3-3 （从 RAID0 并发读取）

  1. # MY_DISK=/dev/md/stripped
  2. # (dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache &); (dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache skip=200 &)
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 1.31025 s, 160 MB/s
  4. 200+0 records in
  5. 200+0 records out
  6. 209715200 bytes (210 MB, 200 MiB) copied, 1.80016 s, 116 MB/s

示例 3-4 （并发写入到 RAID0）

  1. # MY_DISK=/dev/md/stripped
  2. # (dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct &); (dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct skip=200 &)
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 1.65026 s, 127 MB/s
  4. 200+0 records in
  5. 200+0 records out
  6. 209715200 bytes (210 MB, 200 MiB) copied, 1.81323 s, 116 MB/s

示例 4-1 （从 RAID1 读取）

  1. # mdadm --stop /dev/md/stripped
  2. # mdadm --create /dev/md/mirrored --homehost=any --metadata=1.0 --level=1 --raid-devices=2 --assume-clean $MY_DEVS
  3. # MY_DISK=/dev/md/mirrored
  4. # dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 1.74963 s, 120 MB/s

示例 4-2 （写入到 RAID1）

  1. # MY_DISK=/dev/md/mirrored
  2. # dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 1.74625 s, 120 MB/s

示例 4-3 （从 RAID1 并发读取）

  1. # MY_DISK=/dev/md/mirrored
  2. # (dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache &); (dd if=$MY_DISK of=/dev/null bs=1MiB count=200 iflag=nocache skip=200 &)
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 1.67171 s, 125 MB/s
  4. 200+0 records in
  5. 200+0 records out
  6. 209715200 bytes (210 MB, 200 MiB) copied, 1.67685 s, 125 MB/s

示例 4-4 （并发写入到 RAID1）

  1. # MY_DISK=/dev/md/mirrored
  2. # (dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct &); (dd if=/dev/zero of=$MY_DISK bs=1MiB count=200 oflag=direct skip=200 &)
  1. 200+0 records in
  2. 200+0 records out
  3. 209715200 bytes (210 MB, 200 MiB) copied, 4.09666 s, 51.2 MB/s
  4. 200+0 records in
  5. 200+0 records out
  6. 209715200 bytes (210 MB, 200 MiB) copied, 4.1067 s, 51.1 MB/s

恢复交换设备和日志配置

  1. # mdadm --stop /dev/md/stripped /dev/md/mirrored
  2. # mdadm --create /dev/md/swap --homehost=any --metadata=1.0 --level=1 --raid-devices=2 $MY_DEVS
  3. # mkswap /dev/md/swap
  4. # swapon -a
  5. # mv /etc/systemd/journald.conf.bak /etc/systemd/journald.conf
  6. # systemctl restart systemd-journald.service
  7. # reboot

结果解读

示例 1-1、1-2、2-1 和 2-2 表明我的每个驱动器以大约 125 MB/s 的速度读写。

示例 1-3、1-4、2-3 和 2-4 表明，当在同一驱动器上并行完成两次读取或写入时，每个进程的驱动器带宽大约为一半（60 MB/s）。

（编辑：ASP站长网）
相关内容
网友评论
推荐文章
    热点阅读

      【免责声明】本站内容转载自互联网，其发布内容言论不代表本站观点，如果其链接、内容的侵犯您的权益，烦请提交相关链接至邮箱nqiang002@foxmail.com我们将及时予以处理。

      建议您使用1366×768 分辨率、Microsoft Internet Explorer 11浏览器以获得本站的出色浏览效果

      Copygight © 2008-2023 http://www.aspzz.cn All Rights Reserved. ASP站长网

      站长：nqiang002#foxmail.com（请把#换成@）