对 Hyperdisk 性能进行基准化分析

如需对 Hyperdisk 性能进行基准化分析，请使用灵活的 I/O 测试工具 (FIO)，而不是 dd 等其他磁盘基准化分析工具。默认情况下，dd 使用非常低的 I/O 队列深度，因此难以确保基准化分析生成足够数量的字节和 I/O 操作来准确测试磁盘性能。

此外，与 dd 配合使用的特殊设备的运行速度通常非常慢，无法准确反映磁盘性能。一般而言，请避免在 Hyperdisk 性能基准中使用 /dev/urandom、/dev/random 和 /dev/zero 等特殊设备。

如需衡量正在运行的实例上正在使用的磁盘的 IOPS 和吞吐量，请使用预期的配置对文件系统进行基准化分析。使用此选项可测试实际工作负载，而不会丢失现有磁盘上的内容。请注意，在对现有磁盘上的文件系统进行基准化分析时，有很多特定于开发环境的因素可能会影响基准化分析结果，并且您可能不会达到磁盘性能限制。

如需衡量 Hyperdisk 的原始性能，请直接对块存储设备进行基准化分析。使用此选项可将原始磁盘性能与磁盘性能限制进行比较。

以下命令适用于安装了 apt 软件包管理系统的 Debian 或 Ubuntu 操作系统。

对正在运行的实例上的磁盘的 IOPS 和吞吐量进行基准化分析

如果您要衡量正在运行的虚拟机实例上活跃磁盘的实际工作负载的 IOPS 和吞吐量，而不丢失磁盘的内容，请对照现有文件系统上的新目录进行基准化分析。

测试准备

  1. 连接到您的实例。

  2. 安装依赖项：

    sudo apt update
sudo apt install -y fio

  3. 如果 Hyperdisk 尚未设置格式，请设置磁盘格式并进行装载。

  4. 在终端中，列出挂接到虚拟机的磁盘，并找到要测试的磁盘。

    sudo lsblk

    上述命令会生成类似于以下内容的输出：

    NAME         MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINT
nvme0n1      259:0    0    10G  0 disk
├─nvme0n1p1  259:1    0   9.9G  0 part  /
├─nvme0n1p14 259:2    0     4M  0 part
└─nvme0n1p15 259:3    0   106M  0 part  /boot/efi
nvme0n2      259:4    0   3.4T  0 disk

    在此示例中，我们将测试一个设备名称为 nvme0n2 的 3,500 GiB 的 Hyperdisk Extreme 卷。

  5. 在磁盘上创建一个新目录 fiotest。在此示例中，该磁盘装载在 /mnt/disks/mnt_dir：

    TEST_DIR=/mnt/disks/mnt_dir/fiotest
sudo mkdir -p $TEST_DIR

  6. 如果虚拟机将 NVMe 磁盘接口用于 Hyperdisk 连接（如果原始磁盘名称以 nvme 为前缀），请执行以下步骤来获取虚拟机可用的 NUMA 节点的数量。

    NVMe 磁盘的基准测试策略因是只有一个 NUMA 节点的虚拟机还是有多个 NUMA 节点的虚拟机而异。使用 NVMe 磁盘接口测试 Hyperdisk 性能时，每个队列仅分配 256 NVMe 队列大小。由于可用的 NVMe 队列大小有限，以及来自挂接到同一虚拟机的其他磁盘的潜在争用，因此这些基准测试使用两个 NVMe 磁盘队列来维护能够处理 256 I/O 深度的总队列大小。

    1. 获取 NUMA 节点的数量。

      lscpu | grep -i 'numa node(s)' | awk '{print $NF}'

    2. 如果虚拟机只有 1 个 NUMA 节点，请获取 CPU 到 NVMe 的队列映射。稍后您要将此信息用于 --cpus-allowed 参数。

      QUEUE_1_CPUS=$(cat /sys/class/block/nvme0n2/mq/*/cpu_list | sed -n 1p | tr -d " \t")
QUEUE_2_CPUS=$(cat /sys/class/block/nvme0n2/mq/*/cpu_list | sed -n 2p | tr -d " \t")

测试写入吞吐量

使用 1 MB 的 I/O 块大小和至少 64 的 I/O 深度，通过执行具有多个并行数据流（16 个或更多）的顺序写入来测试写入吞吐量。

  1. 如果 Hyperdisk 使用 SCSI 接口：

    sudo fio --directory=$TEST_DIR \
--numjobs=16 --size=10G --time_based \
--runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \
--iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \
--name=write_throughput

  2. 如果 Hyperdisk 使用 NVMe 接口：

    1. 如果虚拟机只有一个 NUMA 节点，请使用以下命令：

      sudo fio --directory=$TEST_DIR --numjobs=8 \
--size=10G --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \
--iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \
--cpus_allowed_policy=split \
--group_reporting \
--name=write_throughput --cpus_allowed=$QUEUE_1_CPUS \
--name=write_throughput_2 --cpus_allowed=$QUEUE_2_CPUS

    2. 如果虚拟机有多个 NUMA 节点，请使用以下命令：

      sudo fio --directory=$TEST_DIR --numjobs=8 \
--size=10G --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \
--iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \
--group_reporting \
--name=write_throughput --numa_cpu_nodes=0 \
--name=write_throughput_2 --numa_cpu_nodes=1

测试写入 IOPS

使用 4 KB 的 I/O 块大小和至少 256 的 I/O 深度，通过执行随机写入来测试写入 IOPS。

  1. 如果 Hyperdisk 是使用 SCSI 接口挂接的：

    sudo fio --directory=$TEST_DIR \
--numjobs=16 --size=10G -time_based \
--runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \
--iodepth_batch_submit=256  --iodepth_batch_complete_max=256 \
--name=write_iops

  2. 如果 Hyperdisk 使用 NVMe 接口：

    1. 如果虚拟机只有一个 NUMA 节点，请使用以下命令：

      sudo fio --directory=$TEST_DIR --numjobs=8 \
--size=10G --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \
--iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \
--cpus_allowed_policy=split \
--group_reporting \
--name=write_iops --cpus_allowed=$QUEUE_1_CPUS \
--name=write_iops_2 --cpus_allowed=$QUEUE_2_CPUS

    2. 如果虚拟机有多个 NUMA 节点，请使用以下命令：

      sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \
--time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \
--iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \
--group_reporting \
--name=write_iops --numa_cpu_nodes=0 \
--name=write_iops_2 --numa_cpu_nodes=1

测试读取吞吐量

使用 1 MB 的 I/O 块大小和至少 64 的 I/O 深度，通过执行具有多个并行数据流（16 个或更多）的顺序读取来测试读取吞吐量。

  1. 如果 Hyperdisk 使用 SCSI 接口：

    sudo fio --directory=$TEST_DIR \
--numjobs=16 --size=10G --time_based \
--runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \
--iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \
--name=read_throughput

  2. 如果 Hyperdisk 使用 NVMe 接口：

    1. 如果虚拟机只有一个 NUMA 节点，请使用以下命令：

      sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \
--time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \
--iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \
--cpus_allowed_policy=split \
--group_reporting \
--name=read_throughput --cpus_allowed=$QUEUE_1_CPUS \
--name=read_throughput_2 --cpus_allowed=$QUEUE_2_CPUS

    2. 如果虚拟机有多个 NUMA 节点，请使用以下命令：

      sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \
--time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \
--iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \
--group_reporting \
--name=read_throughput --numa_cpu_nodes=0 \
--name=read_throughput_2 --numa_cpu_nodes=1

测试读取 IOPS

使用 4 KB 的 I/O 块大小和至少 256 的 I/O 深度，通过执行随机读取来测试读取 IOPS。

  1. 如果 Hyperdisk 使用 SCSI 接口：

    sudo fio --directory=$TEST_DIR \
--numjobs=16 --size=10G --time_based \
--runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \
--iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \
--name=read_iops

  2. 如果 Hyperdisk 使用 NVMe 接口：

    1. 如果虚拟机只有一个 NUMA 节点，请使用以下命令：

      sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \
--time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \
--iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \
--cpus_allowed_policy=split \
--group_reporting \
--name=read_iops --cpus_allowed=$QUEUE_1_CPUS \
--name=read_iops_2 --cpus_allowed=$QUEUE_2_CPUS

    2. 如果虚拟机有多个 NUMA 节点，请使用以下命令：

      sudo fio --directory=$TEST_DIR --numjobs=8 --size=10G \
--time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \
--iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \
--group_reporting \
--name=read_iops --numa_cpu_nodes=0 \
--name=read_iops_2 --numa_cpu_nodes=1

清理

移除测试目录。

sudo rm $TEST_DIR/write* $TEST_DIR/read*

对 C3 虚拟机上的 Hyperdisk Extreme 的 IOPS 和吞吐量进行基准化分析

Google Cloud Hyperdisk Extreme 可在具有 176 个 vCPU 的 C3 虚拟机上提供更高的性能。如需达到更高的性能限制，您必须将多个 Hyperdisk Extreme 卷挂接到虚拟机。

如需测量正在运行的 C3 虚拟机上活跃磁盘的实际工作负载的每秒 I/O 数 (IOPS) 或吞吐量，而不会丢失现有数据磁盘的内容，请对现有文件系统上的新目录进行基准化分析，并将向虚拟机挂接新的 Hyperdisk Extreme 卷以执行基准化分析任务。

对于使用 NVMe 接口挂接的磁盘，建议在虚拟机可用的所有 NVMe 队列间分配 I/O 工作负载。这样可以最大限度地提高 Hyperdisk 性能。在具有 176 个 vCPU 的 C3 虚拟机上，有四个 NUMA 节点一对一映射到 4 个 NVMe 队列。对于本部分中的基准测试，假设存在此映射。

测试准备

  1. 向虚拟机添加新的 Hyperdisk Extreme 磁盘，并参阅 Hyperdisk 性能限制以得到实现目标性能所需的磁盘设置。

  2. 连接到您的实例：

  3. 安装依赖项：

    sudo apt update
sudo apt install -y fio

  4. 列出挂接到虚拟机的磁盘，并找到要测试的磁盘。

    sudo lsblk

    上述命令会生成类似于以下内容的输出：

    NAME         MAJ:MIN RM   SIZE RO TYPE  MOUNTPOINT
nvme0n1      259:0    0    10G  0 disk
├─nvme0n1p1  259:1    0   9.9G  0 part  /
├─nvme0n1p14 259:2    0     4M  0 part
└─nvme0n1p15 259:3    0   106M  0 part  /boot/efi
nvme0n2      259:4    0   2.5T  0 disk
nvme0n3      259:5    0   2.5T  0 disk
nvme0n4      259:6    0   2.5T  0 disk

    在此示例中，我们将在设备名为 nvme0n2、nvme0n3 和 nvme0n4 的三个 2,500 GiB Hyperdisk Extreme 卷上测试 Google Cloud Hyperdisk 性能。

对 C3 上的 Hyperdisk Extreme 的吞吐量进行基准化分析

本部分介绍如何对 Hyperdisk Extreme 磁盘的读写吞吐量进行基准化分析。

测试准备

在开始对挂接到具有 176 个 vCPU 的 C3 虚拟机的 Hyperdisk Extreme 磁盘性能进行基准化分析之前，请完成以下步骤。

  1. 在操作系统中创建新目录 fiotest。在此示例中，根目录为 /mnt/disks/mnt_dir：

    TEST_DIR=/mnt/disks/mnt_dir/fiotest
sudo mkdir -p $TEST_DIR

  2. 由于该虚拟机需要多个磁盘才能达到最高性能级别，因此为简单起见，请对所有挂接的 Hyperdisk 卷执行 RAID 0。这样可以更轻松地将数据均匀分布到多个 Hyperdisk 卷中。

    在此示例中，RAID 0 是挂接到 C3 虚拟机的三个 Hyperdisk Extreme 卷上的性能。

    sudo mdadm --create /dev/md0 --level=0 --raid-devices=3 /dev/nvme0n2 /dev/nvme0n3 /dev/nvme0n4

  3. 格式化并装载 RAID 卷 /dev/md0。

测试写入吞吐量

使用 1 MiB 的 I/O 块大小和每个 NVMe 队列至少 32 的总 I/O 深度，通过执行具有多个并行数据流（至少 16 个）的顺序写入来测试写入吞吐量。

# Running this command causes data loss on the targeted file on the device.
# We strongly recommend using a throwaway disk.

sudo fio --name=global --group_reporting=1 --filesize=1024G \
--filename=$TEST_DIR/fiotestfile --numjobs=4 --size=64G \
--offset_increment=64G --time_based --runtime=5m \
--ramp_time=10s --ioengine=libaio --direct=1 --verify=0 \
--bs=1M --iodepth=8 --rw=write \
--name=write_throughput --numa_cpu_nodes=0 \
--name=write_throughput_1 --numa_cpu_nodes=1 \
--name=write_throughput_2 --numa_cpu_nodes=2 \
--name=write_throughput_3 --numa_cpu_nodes=3

测试读取吞吐量

使用 1 MiB 的 I/O 块大小和每个 NVMe 队列至少 32 的总 I/O 深度，通过执行具有多个并行数据流（至少 16 个）的顺序读取来测试读取吞吐量。

sudo fio --name=global --group_reporting=1 --filesize=1024G \
--filename=$TEST_DIR/fiotestfile --numjobs=4 --size=64G \
--offset_increment=64G --time_based --runtime=5m \
--ramp_time=10s --ioengine=libaio --direct=1 \
--verify=0 --bs=1M --iodepth=8 --rw=read \
--name=read_throughput --numa_cpu_nodes=0 \
--name=read_throughput_1 --numa_cpu_nodes=1 \
--name=read_throughput_2 --numa_cpu_nodes=2 \
--name=read_throughput_3 --numa_cpu_nodes=3

对 C3 上的 Hyperdisk Extreme 的 IOPS 进行基准化分析

如需对每秒 I/O 数 (IOPS) 性能进行基准化分析，建议直接向原始磁盘（不使用 RAID）或是从原始磁盘执行并行小型 I/O 操作。

测试写入 IOPS

使用 4 KiB 的 I/O 块大小和至少 256 的 I/O 深度，并利用至少 2 个 NVMe 队列，通过执行随机写入来测试写入 IOPS。

# Running this command causes data loss on the targeted device.
# We strongly recommend using a throwaway disk.

sudo fio --name=global --group_reporting=1 \
--directory=/ --bs=4K --direct=1 \
--filesize=512G --iodepth=256 \
--iodepth_batch_complete_max=256 --iodepth_batch_submit=256 \
--ioengine=libaio --numjobs=5 --ramp_time=10s \
--randrepeat=0 --runtime=5m --rw=randwrite \
--time_based=1 --verify=0 \
--name=write_iops_test --filename=/dev/nvme0n2 --numa_cpu_nodes=0 \
--name=write_iops_test_1 --filename=/dev/nvme0n3  --numa_cpu_nodes=1 \
--name=write_iops_test_2 --filename=/dev/nvme0n4 --numa_cpu_nodes=2

测试读取 IOPS

使用 4 KiB 的 I/O 块大小和至少 256 的 I/O 深度，并利用至少 2 个 NVMe 队列，通过执行随机读取来测试读取 IOPS。

sudo fio --name=global --group_reporting=1 --directory=/ \
--bs=4K --direct=1 --filesize=512G --iodepth=256 \
--iodepth_batch_complete_max=256 --iodepth_batch_submit=256 \
--ioengine=libaio --numjobs=5 --ramp_time=10s \
--randrepeat=0 --runtime=5m --rw=randread \
--time_based=1 --verify=0 \
--name=read_iops_test --filename=/dev/nvme0n2 --numa_cpu_nodes=0 \
--name=read_iops_test_1 --filename=/dev/nvme0n3  --numa_cpu_nodes=1 \
--name=read_iops_test_2 --filename=/dev/nvme0n4 --numa_cpu_nodes=2

对 C3 上的 Hyperdisk Extreme 的延迟时间进行基准化分析

在测试 I/O 延迟时间时，请务必不要让虚拟机达到带宽或 IOPS 上限。如果达到上限，则观察到的延迟时间无法反映出实际的 Hyperdisk I/O 延迟时间。例如，如果虚拟机在 I/O 深度为 30 时达到 IOPS 上限，而 fio 命令将该深度翻倍，则总 IOPS 将保持不变，而报告的 I/O 延迟时间将翻倍。

直接以单个原始磁盘设备为目标便足以得到实际的 I/O 延迟时间。

测试写入延迟时间

使用 4 KiB 的 I/O 块大小和值为 4 的 I/O 深度，通过执行随机写入来测试写入延迟时间。

# Running this command causes data loss on the targeted device.
# We strongly recommend using a throwaway disk.

sudo fio --filename=/dev/nvme0n2  \
--filesize=512G --time_based \
--runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=4 --rw=randwrite \
--iodepth_batch_submit=4 --iodepth_batch_complete_max=4 \
--name=write_latency

测试读取延迟时间

使用 4 KiB 的 I/O 块大小和值为 4 的 I/O 深度，通过执行随机读取来测试读取延迟时间。

sudo fio --filename=/dev/nvme0n2  \
--filesize=512G --time_based \
--runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=4 --rw=randread \
--iodepth_batch_submit=4 --iodepth_batch_complete_max=4 \
--name=read_latency

清理

  1. 移除测试文件。

    sudo rm -rf $TEST_DIR/*

  2. 卸载并停止 RAID 卷。

    sudo umount /dev/md0
sudo mdadm --stop /dev/md0

  3. 分离并删除挂接的 Hyperdisk 卷。请参阅 gcloud compute instances detach-disk 和 gcloud compute disks delete 命令。

对原始 Hyperdisk 性能进行基准化分析

如果您要在开发环境之外单独衡量 Hyperdisk 卷的性能，您可以在一次性的磁盘和虚拟机上测试块存储设备的读取和写入性能。

以下命令假定虚拟机挂接了一个 3,500 GiB 的 Hyperdisk Extreme 卷。此磁盘大小是实现 32 个 vCPU 虚拟机吞吐量限制所必需的。如果设备容量不同，请在以下命令中修改 --filesize 参数的值。如需详细了解虚拟机机器类型的性能限制，请参阅机器类型支持。

测试准备

  1. 连接到您的实例。

  2. 安装依赖项：

    sudo apt-get update
sudo apt-get install -y fio

  3. 获取原始磁盘的路径。将该路径存储在变量中。以下示例使用 /dev/nvme0n2 作为原始磁盘路径：

    TEST_DIR=/dev/nvme0n2

  4. 使用非零数据填充磁盘。对于 Hyperdisk 而言，从空白块读取内容的延迟配置文件与包含数据的块不同。我们建议您在运行任何读取延迟基准化分析之前先填充磁盘。

    # Running this command causes data loss on the second device.
# We strongly recommend using a throwaway VM and disk.

sudo fio --name=fill_disk \
--filename=$TEST_DIR --filesize=2500G \
--ioengine=libaio --direct=1 --verify=0 --randrepeat=0 \
--bs=128K --iodepth=64 --rw=randwrite \
--iodepth_batch_submit=64  --iodepth_batch_complete_max=64

  5. 如果虚拟机将 NVMe 磁盘接口用于 Hyperdisk 连接（如果原始磁盘名称以 nvme 为前缀），请执行以下步骤来获取虚拟机可用的 NUMA 节点的数量。

    NVMe 磁盘的基准测试策略因是只有一个 NUMA 节点的虚拟机还是有多个 NUMA 节点的虚拟机而异。使用 NVMe 磁盘接口测试 Hyperdisk 性能时，每个队列仅分配 256 NVMe 队列大小。由于可用的 NVMe 队列大小有限，以及来自挂接到同一虚拟机的其他磁盘的潜在争用，因此这些基准测试使用两个 NVMe 磁盘队列来维护能够处理 256 I/O 深度的总队列大小。

    1. 获取 NUMA 节点的数量。

      lscpu | grep -i 'numa node(s)' | awk '{print $NF}'

    2. 如果虚拟机只有 1 个 NUMA 节点，请获取 CPU 到 NVMe 的队列映射。稍后您要将此信息用于 --cpus-allowed 参数。

      QUEUE_1_CPUS=$(cat /sys/class/block/nvme0n2/mq/*/cpu_list | sed -n 1p | tr -d " \t")
QUEUE_2_CPUS=$(cat /sys/class/block/nvme0n2/mq/*/cpu_list | sed -n 2p | tr -d " \t")

测试写入吞吐量

使用 1 MB 的 I/O 大小和大于或等于 64 的 I/O 深度，通过执行具有多个并行数据流（16 个或更多）的顺序写入来测试写入吞吐量。

  1. 如果 Hyperdisk 使用 SCSI 接口挂接：

    # Running this command causes data loss on the second device.
# We strongly recommend using a throwaway VM and disk.

sudo fio --filename=$TEST_DIR \
--numjobs=16 --size=500G --time_based \
--runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \
--iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \
--offset_increment=20G \
--name=write_throughput

  2. 如果 Hyperdisk 使用 NVMe 接口：

    1. 如果虚拟机只有一个 NUMA 节点，请使用以下命令：

      # Running this command causes data loss on the second device.
# We strongly recommend using a throwaway VM and disk.

sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \
--time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \
--iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \
--cpus_allowed_policy=split \
--offset_increment=20G --group_reporting \
--name=write_throughput --cpus_allowed=$QUEUE_1_CPUS \
--name=write_throughput_2 --cpus_allowed=$QUEUE_2_CPUS

    2. 如果虚拟机有多个 NUMA 节点，请使用以下命令：

      # Running this command causes data loss on the second device.
# We strongly recommend using a throwaway VM and disk.

sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \
--time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=1M --iodepth=64 --rw=write \
--iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \
--offset_increment=20G --group_reporting \
--name=write_throughput --numa_cpu_nodes=0 \
--name=write_throughput_2 --numa_cpu_nodes=1

测试写入 IOPS

如需达到 Hyperdisk IOPS 上限，您必须维护一个较深的 I/O 队列。例如，如果写入延迟时间为 1 毫秒，则对于每个正在执行的 I/O，虚拟机最多可以达到 1,000 次 IOPS。如需达到 15,000 次写入 IOPS，虚拟机必须维护至少 15 个正在执行的 I/O 操作。如果磁盘和虚拟机能够达到 30,000 次写入 IOPS，则正在执行的 I/O 操作数量必须至少为 30 个。如果 I/O 大小超过 4 KB，则虚拟机在达到 IOPS 上限之前可能会先达到带宽上限。

使用 4 KB 的 I/O 块大小和至少 256 的 I/O 深度，通过执行随机写入来测试写入 IOPS。

  1. 如果 Hyperdisk Extreme 卷使用 SCSI 接口挂接：

    # Running this command causes data loss on the second device.
# We strongly recommend using a throwaway VM and disk.

sudo fio --filename=$TEST_DIR \
--numjobs=16 --size=500G -time_based \
--runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \
--iodepth_batch_submit=256  --iodepth_batch_complete_max=256 \
--name=write_iops

  2. 如果 Hyperdisk Extreme 卷使用 NVMe 接口挂接：

    1. 如果虚拟机只有一个 NUMA 节点，请使用以下命令：

      # Running this command causes data loss on the second device.
# We strongly recommend using a throwaway VM and disk.

sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \
--time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \
--iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \
--cpus_allowed_policy=split \
--group_reporting \
--name=write_write_iops --cpus_allowed=$QUEUE_1_CPUS \
--name=write_write_iops_2 --cpus_allowed=$QUEUE_2_CPUS

    2. 如果虚拟机有多个 NUMA 节点，请使用以下命令：

      # Running this command causes data loss on the second device.
# We strongly recommend using a throwaway VM and disk.

sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \
--time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randwrite \
--iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \
--group_reporting \
--name=write_iops --numa_cpu_nodes=0 \
--name=write_iops_2 --numa_cpu_nodes=1

测试写入延迟时间

在测试 I/O 延迟时间时，虚拟机不得达到带宽或 IOPS 上限，否则观察到的延迟时间将无法反映出实际的 Hyperdisk I/O 延迟时间。例如，如果在 I/O 深度为 30 时达到了 IOPS 上限，并且 fio 命令已将其加倍，则总 IOPS 将保持不变，并且所报告的 I/O 延迟时间将加倍。

# Running this command causes data loss on the second device.
# We strongly recommend using a throwaway VM and disk.
sudo fio --filename=$TEST_DIR \
--filesize=500G --time_based \
--runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=4 --rw=randwrite \
--iodepth_batch_submit=4 --iodepth_batch_complete_max=4 \
--name=write_latency

测试读取带宽

使用 1 MB 的 I/O 大小和至少 64 的 I/O 深度，通过执行具有多个并行数据流（16 个或更多）的顺序读取来测试读取吞吐量。

  1. 如果 Hyperdisk Extreme 卷使用 SCSI 接口挂接：

     sudo fio --filename=$TEST_DIR \
 --numjobs=16 --size=500G --time_based \
 --runtime=5m --ramp_time=10s --ioengine=libaio \
 --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \
 --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \
 --offset_increment=20G --name=read_bandwidth

  2. 如果 Hyperdisk Extreme 卷使用 NVMe 接口挂接：

    1. 如果虚拟机只有一个 NUMA 节点，请使用以下命令：

        sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \
  --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
  --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \
  --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \
  --cpus_allowed_policy=split \
  --offset_increment=20G --group_reporting \
  --name=read_bandwidth --cpus_allowed=$QUEUE_1_CPUS \
  --name=read_bandwidth_2 --cpus_allowed=$QUEUE_2_CPUS

    2. 如果虚拟机有多个 NUMA 节点，请使用以下命令：

        sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \
  --time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
  --direct=1 --verify=0 --bs=1M --iodepth=64 --rw=read \
  --iodepth_batch_submit=64 --iodepth_batch_complete_max=64 \
  --offset_increment=20G --group_reporting \
  --name=read_bandwidth --numa_cpu_nodes=0 \
  --name=read_bandwidth_2 --numa_cpu_nodes=1

测试读取 IOPS

如需达到 Hyperdisk IOPS 上限，您必须维护一个较深的 I/O 队列。 例如，如果 I/O 大小超过 4 KB，则虚拟机在达到 IOPS 限制之前可能会先达到带宽限制。如需达到机器类型可用的读取 IOPS 上限，请为此测试指定 --iodepth=256。

  1. 如果 Hyperdisk Extreme 卷使用 SCSI 接口挂接：

    sudo fio --filename=$TEST_DIR \
--numjobs=16 --size=500G --time_based \
--runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \
--iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \
--name=read_iops

  2. 如果 Hyperdisk Extreme 卷使用 NVMe 接口挂接：

    1. 如果虚拟机只有一个 NUMA 节点，请使用以下命令：

      sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \
--time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \
--iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \
--cpus_allowed_policy=split \
--group_reporting \
--name=read_iops --cpus_allowed=$QUEUE_1_CPUS \
--name=read_iops_2 --cpus_allowed=$QUEUE_2_CPUS

    2. 如果虚拟机有多个 NUMA 节点，请使用以下命令：

      sudo fio --filename=$TEST_DIR --numjobs=8 --size=500G \
--time_based --runtime=5m --ramp_time=10s --ioengine=libaio \
--direct=1 --verify=0 --bs=4K --iodepth=256 --rw=randread \
--iodepth_batch_submit=256 --iodepth_batch_complete_max=256 \
--group_reporting \
--name=read_iops --numa_cpu_nodes=0 \
--name=read_iops_2 --numa_cpu_nodes=1

测试读取延迟时间

请务必用数据填充磁盘，以获得实际的延迟时间测量结果。在此测试期间，虚拟机不得达到 IOPS 或吞吐量限制，因为 Hyperdisk 卷达到其饱和度限制后，它会回拒传入的 I/O 操作。此回拒会表现为 I/O 延迟时间的虚假增加。

 sudo fio --filename=$TEST_DIR \
 --filesize=500G --time_based \
 --runtime=5m --ramp_time=10s --ioengine=libaio \
 --direct=1 --verify=0 --bs=4K --iodepth=4 --rw=randread \
 --iodepth_batch_submit=4 --iodepth_batch_complete_max=4 \
 --name=read_latency

清理

如果您按照建议使用了一次性磁盘和虚拟机，则在完成基准化测试后，可以执行以下操作：

  • 分离并删除磁盘。
  • 删除虚拟机。

后续步骤