【SysBench】深度优化文件 I/O

已于 2024-03-21 16:13:25 修改
阅读量1k 收藏 13
点赞数 32
分类专栏： SysBench 基准测试 文章标签： linux sysbench 基准测试 benchmark
于 2024-03-21 13:14:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wudi53433927/article/details/136885202
版权
文章详细描述了通过修改sysbench的参数，如使用direct+async模式、asyncbacklog、调整线程数以及影响I/O性能的其他因素，来优化文件I/O性能的过程。作者指出，每个优化措施对性能的影响各不相同，需要根据实际需求进行调整。
摘要由CSDN通过智能技术生成

上一篇对 sysbench fileio 进行了一定的测试优化，得到的结论与预期不符，本文将尝试查找问题以及进一步优化。

1、修改 sysbench 的参数

在准备阶段，修改创建测试文件的参数 file-extra-flags 为其他值，然后再修改其他参数进行测试。

1.1 dsync

1.1.1 准备文件

$ sysbench --threads=2 fileio --file-total-size=10G --file-num=2 --file-block-size=16K prepare --file-extra-flags=dsync
sysbench 1.0.20 (using bundled LuaJIT 2.1.0-beta2)

2 files, 5242880Kb each, 10240Mb total
Creating files for the test...
Extra file open flags: dsync 
Creating file test_file.0
Creating file test_file.1
10737418240 bytes written in 327.77 seconds (31.24 MiB/sec).

1.1.2 运行测试

$ sysbench --time=300 --threads=2 fileio --file-total-size=10G --file-num=2 --file-block-size=16K --file-test-mode=rndrw run --file-fsync-freq=1 --file-fsync-mode=fdatasync --file-extra-flags=dsync
sysbench 1.0.20 (using bundled LuaJIT 2.1.0-beta2)

Running the test with following options:
Number of threads: 2
Initializing random number generator from current time


Extra file open flags: dsync 
2 files, 5GiB each
10GiB total file size
Block size 16KiB
Number of IO requests: 0
Read/Write ratio for combined random IO test: 1.50
Periodic FSYNC enabled, calling fsync() each 1 requests.
Calling fsync() at the end of test, Enabled.
Using synchronous I/O mode
Doing random r/w test
Initializing worker threads...

Threads started!


File operations:
    reads/s:                      74.82
    writes/s:                     49.87
    fsyncs/s:                     99.76

Throughput:
    read, MiB/s:                  1.17
    written, MiB/s:               0.78

General statistics:
    total time:                          300.1178s
    total number of events:              67358

Latency (ms):
         min:                                    0.00
         avg:                                    8.91
         max:                                  955.28
         95th percentile:                       33.12
         sum:                               600004.59

Threads fairness:
    events (avg/stddev):           33679.0000/263.00
    execution time (avg/stddev):   300.0023/0.06
  • total number of events: 67358
  • avg: 8.91
  • 95th percentile: 33.12

对比 3T2，总请求数显著增加，平均响应时间显著减少，95%响应时间略有减少。性能显著提升。

1.1.3 清理文件

$ sysbench fileio cleanup

1.2 direct

使用 Direct I/O 进行测试。对应 MySQL 的 O_DIRECT 。

1.2.1 准备文件

$ sysbench --threads=2 fileio --file-total-size=10G --file-num=2 --file-block-size=16K prepare --file-extra-flags=direct

1.2.2 运行测试

$ sysbench --time=300 --threads=2 fileio --file-total-size=10G --file-num=2 --file-block-size=16K --file-test-mode=rndrw run --file-fsync-freq=1 --file-fsync-mode=fdatasync --file-extra-flags=direct
sysbench 1.0.20 (using bundled LuaJIT 2.1.0-beta2)

Running the test with following options:
Number of threads: 2
Initializing random number generator from current time


Extra file open flags: directio
2 files, 5GiB each
10GiB total file size
Block size 16KiB
Number of IO requests: 0
Read/Write ratio for combined random IO test: 1.50
Periodic FSYNC enabled, calling fsync() each 1 requests.
Calling fsync() at the end of test, Enabled.
Using synchronous I/O mode
Doing random r/w test
Initializing worker threads...

Threads started!


File operations:
    reads/s:                      82.40
    writes/s:                     54.93
    fsyncs/s:                     109.88

Throughput:
    read, MiB/s:                  1.29
    written, MiB/s:               0.86

General statistics:
    total time:                          300.0174s
    total number of events:              74166

Latency (ms):
         min:                                    0.00
         avg:                                    8.09
         max:                                  882.69
         95th percentile:                       29.19
         sum:                               599909.27

Threads fairness:
    events (avg/stddev):           37083.0000/215.00
    execution time (avg/stddev):   299.9546/0.00
  • total number of events: 74166
  • avg: 8.09
  • 95th percentile: 29.19

对比 1.1，总请求数显著增加，平均响应时间略有减少，95%响应时间显著减少。性能显著提升了

1.3 direct + async

继续使用 1.2 中创建的测试文件进行测试。

$ sysbench --time=300 --threads=2 fileio --file-total-size=10G --file-num=2 --file-block-size=16K --file-test-mode=rndrw run --file-fsync-freq=1 --file-fsync-mode=fdatasync --file-extra-flags=direct --file-io-mode=async
sysbench 1.0.20 (using bundled LuaJIT 2.1.0-beta2)

Running the test with following options:
Number of threads: 2
Initializing random number generator from current time


Extra file open flags: directio
2 files, 5GiB each
10GiB total file size
Block size 16KiB
Number of IO requests: 0
Read/Write ratio for combined random IO test: 1.50
Periodic FSYNC enabled, calling fsync() each 1 requests.
Calling fsync() at the end of test, Enabled.
Using asynchronous I/O mode
Doing random r/w test
Initializing worker threads...

Threads started!


File operations:
    reads/s:                      259.88
    writes/s:                     172.96
    fsyncs/s:                     345.93

Throughput:
    read, MiB/s:                  4.06
    written, MiB/s:               2.70

General statistics:
    total time:                          300.5423s
    total number of events:              234052

Latency (ms):
         min:                                    0.00
         avg:                                    2.56
         max:                                  910.07
         95th percentile:                        0.04
         sum:                               599958.35

Threads fairness:
    events (avg/stddev):           117026.0000/940.00
    execution time (avg/stddev):   299.9792/0.00
  • total number of events: 234052
  • avg: 2.56
  • 95th percentile: 0.04

对比 1.2，总请求数增加了 2 倍，平均响应时间减少为 2/3 ，%95响应时间减少为前者的近 1/730 。性能达到质的提升。

1.4 direct + async + async-backlog

1.4.1 增加 async-backlog

$ sysbench --time=300 --threads=2 fileio --file-total-size=10G --file-num=2 --file-block-size=16K --file-test-mode=rndrw run --file-fsync-freq=1 --file-fsync-mode=fdatasync --file-extra-flags=direct --file-io-mode=async --file-async-backlog=256
sysbench 1.0.20 (using bundled LuaJIT 2.1.0-beta2)

Running the test with following options:
Number of threads: 2
Initializing random number generator from current time


Extra file open flags: directio
2 files, 5GiB each
10GiB total file size
Block size 16KiB
Number of IO requests: 0
Read/Write ratio for combined random IO test: 1.50
Periodic FSYNC enabled, calling fsync() each 1 requests.
Calling fsync() at the end of test, Enabled.
Using asynchronous I/O mode
Doing random r/w test
Initializing worker threads...

Threads started!


File operations:
    reads/s:                      280.63
    writes/s:                     186.99
    fsyncs/s:                     373.99

Throughput:
    read, MiB/s:                  4.38
    written, MiB/s:               2.92

General statistics:
    total time:                          300.4804s
    total number of events:              252881

Latency (ms):
         min:                                    0.00
         avg:                                    2.37
         max:                                 1090.04
         95th percentile:                        0.04
         sum:                               599765.77

Threads fairness:
    events (avg/stddev):           126440.5000/2636.50
    execution time (avg/stddev):   299.8829/0.00
  • total number of events: 252881
  • avg: 2.37
  • max: 1090.04
  • 95th percentile: 0.04

对比 1.3，总请求数显著增加，平均响应时间略有减少，%95响应时间无变化。性能显著提升了。但也应注意最大响应时间随队列长度增加了。

1.4.2 减少 async-backlog

$ sysbench --time=300 --threads=2 fileio --file-total-size=10G --file-num=2 --file-block-size=16K --file-test-mode=rndrw run --file-fsync-freq=1 --file-fsync-mode=fdatasync --file-extra-flags=direct --file-io-mode=async --file-async-backlog=2
sysbench 1.0.20 (using bundled LuaJIT 2.1.0-beta2)

Running the test with following options:
Number of threads: 2
Initializing random number generator from current time


Extra file open flags: directio
2 files, 5GiB each
10GiB total file size
Block size 16KiB
Number of IO requests: 0
Read/Write ratio for combined random IO test: 1.50
Periodic FSYNC enabled, calling fsync() each 1 requests.
Calling fsync() at the end of test, Enabled.
Using asynchronous I/O mode
Doing random r/w test
Initializing worker threads...

Threads started!


File operations:
    reads/s:                      81.39
    writes/s:                     54.25
    fsyncs/s:                     108.51

Throughput:
    read, MiB/s:                  1.27
    written, MiB/s:               0.85

General statistics:
    total time:                          300.0773s
    total number of events:              73259

Latency (ms):
         min:                                    0.00
         avg:                                    8.19
         max:                                 1257.79
         95th percentile:                       26.20
         sum:                               599988.95

Threads fairness:
    events (avg/stddev):           36629.5000/177.50
    execution time (avg/stddev):   299.9945/0.01

对比 1.3，总请求数显著降低，平均响应时间显著增加，%95响应时间显著增加。性能显著降低了，又回到了 1.2 的水平。

1.5 增加线程数

在 1.4.1 的基础上，增加线程数：

$ sysbench --time=300 --threads=16 fileio --file-total-size=10G --file-num=2 --file-block-size=16K --file-test-mode=rndrw run --file-fsync-freq=1 --file-fsync-mode=fdatasync --file-extra-flags=direct --file-io-mode=async --file-async-backlog=256
sysbench 1.0.20 (using bundled LuaJIT 2.1.0-beta2)

Running the test with following options:
Number of threads: 16
Initializing random number generator from current time


Extra file open flags: directio
2 files, 5GiB each
10GiB total file size
Block size 16KiB
Number of IO requests: 0
Read/Write ratio for combined random IO test: 1.50
Periodic FSYNC enabled, calling fsync() each 1 requests.
Calling fsync() at the end of test, Enabled.
Using asynchronous I/O mode
Doing random r/w test
Initializing worker threads...

Threads started!


File operations:
    reads/s:                      310.62
    writes/s:                     210.30
    fsyncs/s:                     420.70

Throughput:
    read, MiB/s:                  4.85
    written, MiB/s:               3.29

General statistics:
    total time:                          300.4850s
    total number of events:              282909

Latency (ms):
         min:                                    0.00
         avg:                                   16.97
         max:                                 3926.18
         95th percentile:                        0.06
         sum:                              4800671.84

Threads fairness:
    events (avg/stddev):           17681.8125/231.15
    execution time (avg/stddev):   300.0420/0.01
  • total number of events: 282909
  • avg: 16.97
  • max: 3926.18
  • 95th percentile: 0.06
  • events (avg/stddev): 17681.8125/231.15

对比 1.4.1，总请求数显著增加，平均响应时间和最大响应时间显著增加，95%响应时间略有降低，线程平均请求数大幅下降。性能是否提升取决于对总请求数和响应时间的权衡取舍。

2、关闭文件系统缓存和 swappines

先查看内存状态，注意缓冲/缓存（buff/cache）。

$ free -m
              total        used        free      shared  buff/cache   available
Mem:           3770         176        3331          11         262        3370
Swap:          2047           0        2047

关闭文件系统缓存（默认值为 0 ，表示不释放）。为了安全关闭前需先 sync 以下。：

$ sync
$ sysctl vm.drop_caches=1
# 或
$ echo 1 > /proc/sys/vm/drop_caches

再次查看内存状态，注意到缓冲/缓存变小了。

$ free -m
              total        used        free      shared  buff/cache   available
Mem:           3770         164        3549          11          56        3454
Swap:          2047           0        2047

关闭 swappines （CentOS 默认值为 30 ，某些 Linux 为 60 ）。

$ sysctl vm.swappiness=0
# 或
$ echo 0 > /proc/sys/vm/swappiness

然后再次执行 1.4.1 测试：

$ sysbench --time=300 --threads=2 fileio --file-total-size=10G --file-num=2 --file-block-size=16K --file-test-mode=rndrw run --file-fsync-freq=1 --file-fsync-mode=fdatasync --file-extra-flags=direct --file-io-mode=async --file-async-backlog=256
sysbench 1.0.20 (using bundled LuaJIT 2.1.0-beta2)

Running the test with following options:
Number of threads: 2
Initializing random number generator from current time


Extra file open flags: directio
2 files, 5GiB each
10GiB total file size
Block size 16KiB
Number of IO requests: 0
Read/Write ratio for combined random IO test: 1.50
Periodic FSYNC enabled, calling fsync() each 1 requests.
Calling fsync() at the end of test, Enabled.
Using asynchronous I/O mode
Doing random r/w test
Initializing worker threads...

Threads started!


File operations:
    reads/s:                      290.28
    writes/s:                     193.24
    fsyncs/s:                     386.49

Throughput:
    read, MiB/s:                  4.54
    written, MiB/s:               3.02

General statistics:
    total time:                          300.2884s
    total number of events:              261252

Latency (ms):
         min:                                    0.00
         avg:                                    2.30
         max:                                 1132.16
         95th percentile:                        0.05
         sum:                               599736.20

Threads fairness:
    events (avg/stddev):           130626.0000/1558.00
    execution time (avg/stddev):   299.8681/0.00
  • total number of events: 261252
  • avg: 2.30
  • max: 1132.16
  • 95th percentile: 0.05

对比 1.4.1，总请求数显著增加，平均响应时间略有减少，95%响应时间和最大响应时间略有增加。

3、优化磁盘

磁盘并不是单指传统的机械硬盘，而是指代所有物理存储，包括单个硬盘驱动器、RAID 阵列和 SSD 固态硬盘等。

3.1 hdparm 关闭写回缓存（writeback）

查看磁盘写回缓存的状态：

$ hdparm -W /dev/sda

/dev/sda:
SG_IO: bad/missing sense data, sb[]:  70 00 05 00 00 00 00 0a 00 00 00 00 20 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
 write-caching = not supported

发现不支持写回缓存，所以没必要关闭了。

3.2 使用其他块大小的文件系统和物理磁盘

此处仅提供一个思路，使用 16K 块大小的固态硬盘（最好是使用 PCIe4.0 或 5.0 接口的），目的是与文件（或文件系统）块大小对齐。笔者暂时没有合适的测试环境， 读者如有可自行测试。

4、总结

本文仅抛砖引玉，暂时得到的结论是使用 direct + async-backlog ，增加线程数，关闭文件系统缓存和 swappines，优化磁盘，都是对 I/O 性能优化的有效手段。这些参数具体应该配置为多少合适，需要读者自行基准测试，并权衡指标的关键程度获得。

独上西楼影三人
关注
专栏目录
使用SYSbench 在LPA3588上进行磁盘IO性能基准测试
neardi_dev的博客
12-07 197
sysbench是一款开源的多线程性能测试工具，可以执行CPU/内存/线程/IO/数据库等方面的性能测试
sysbench 压测 mysql_sysbench 压测 MySQL 性能及优化
weixin_39849548的博客
01-19 192
sysbench 安装流程下载wget https://github.com/akopytov/sysbench/archive/master.zipunzip 安装yum install unzip解压unzip master.zip安装相关依赖yum -y install make automake libtool pkgconfig libaio-devel vim-commonyum -...
[转]MySQL 5.6 my.cnf配置优化
weixin_33757609的博客
02-17 919
为什么80%的码农都做不了架构师？>>> ...
sysbench 命令：跨平台的基准测试工具
最新发布
qq_38641599的博客
09-27 1129
sysbench 是一个跨平台的基准测试工具，用于评估系统性能，包括 CPU、内存、文件 I/O、数据库等性能。‍。
sysbench--实践--01--文件IO测试
zhou920786312的博客
06-02 610
2、testname 指定测试项目名称 2.2、查看测试项目帮助命令 2.3、案例 3、command 3.1、prepare 测试前准备工作，例如为fileis测试在磁盘上创建必要的文件，为OLTP测试准备测试数据执行完整的测试，必须指定–-test选项测试结束后删除数据版本信息。帮助信息。sysbench尝试向数据库发送的事务数tps。parameter h for pareto distibution [0.2]sysbench配置文件路径。
用systemtap对sysbench IO测试结果的分析1
weixin_34253126的博客
07-17 347
 http://www.actionsky.com/docs/archives/171  2016年5月6日  黄炎 近期在一些简单的sysbench IO测试中, 遇到了一些不合常识的测试结果. 从结果看, 虽然不是有实际意义的测试结果, 但探索过程中, 利用到了Systemtap进行观测(动态追踪), 可在其他分析中借用. 目录 1 测试环境准备 2 现象1 2.1...
【SysBench】sysbench 测试 CPU、文件 I/O、内存、线程和 POSIX 互斥
影三人
03-20 1765
sysbench 测试 CPU、文件 I/O、内存、线程和 POSIX 互斥
sysbench 1.0.17
01-04
3. **磁盘I/O基准测试**：sysbench能进行文件系统级别的I/O压力测试，支持多种文件系统类型。它允许你自定义读写大小、操作模式（顺序或随机）、IO调度器、队列深度等参数，以全面了解磁盘性能。 4. **数据库测试**...
sysbench-1.0.20.tar.gz
04-01
《sysbench在ARM架构下测试CPU性能的深度解析》 sysbench是一款强大的多线程、跨平台的系统性能基准测试工具，广泛应用于评估系统的CPU、内存、I/O等各项性能。在本文中，我们将深入探讨如何在基于ARM架构的设备上...
sysbench-master.zip
12-31
sysbench可以进行随机读写、顺序读写等多种I/O操作，帮助识别磁盘或存储设备的性能。这对于优化存储配置、评估存储解决方案的性能至关重要。 五、sysbench的CPU性能测试 sysbench提供了一个内置的CPU基准测试模块，...
sysbench-1.0.20-x86-64-rhel9.tgz
11-03
sysbench是Linux环境中的一款多线程、跨平台的性能测试工具，它主要用于评估和测试系统的各种性能指标，包括CPU、内存、磁盘I/O以及数据库等。在RHEL9.0这个最新版本的操作系统上，sysbench 1.0.20的安装和使用显得...
使用sysbench对Oracle做基准测试(-) 安装篇
道行尚浅（老道）的博客
10-14 7399
sysbench是一款开源的多线程性能测试工具， 可以执行CPU/内存/线程/IO/数据库等方面的性能测试。数据库目前支持MySQL/Oracle/PostgreSQL。
测试软件：sysbench-fileio
crj2951的博客
07-29 159
1、测试环境是PC服务器，磁盘用的是oracle acfs 2、创建文件 [root@ ogg]# sysbench --test=fileio --num-threads=32 --file-t...
性能测试sysbench之IO性能测试
fycghy0803的专栏
10-25 467
1.执行命令： sysbench --test=fileio --threads=1 --file-total-size=1000M --file-test-mode=rndrw prepare //准备进行随机的读取的文件 sysbench --test=fileio --threads=1--file-total-size=1000M --file-test-mo...
sysbench测试磁盘IO
aa5181的专栏
08-13 422
系统：CentOS 7.4 工具：sysbench1.0.17 测试IO性能分三个阶段：准备阶段、运行阶段和清理阶段 准备阶段： #sysbench--file-num=20--threads=20--...
sysbench fileio 基准测试
喜欢吃一口烤肉的啵啵
07-30 1545
sysbench介绍 源码地址：https://github.com/akopytov/sysbench sysbench is a scriptable multi-threaded benchmark tool based on LuaJIT. It is most frequently used for database benchmarks, but can also be used to...
Sysbench使用之二fileio
姚远OracleACE的博客
01-19 935
源码安装 安装方法参见： https://github.com/akopytov/sysbench 源码编译的安装步骤如下： yum -y install make automake libtool pkgconfig libaio-devel openssl-devel wget https://github.com/akopytov/sysbench/archive/master.zip unzip master.zip cd sysbench-master/ ./autogen.sh ./con
sysbench
来啊 快活啊
07-18 1872
severalnines/sysbench
Linux I/O性能分析与调优手册
此外，优化文件系统配置、调整缓存策略、合理分配I/O调度器等也是提高Linux系统I/O性能的重要手段。 Linux性能分析调优涉及到多个层面，不仅包括对硬件性能的理解，还包括对操作系统内核参数、文件系统以及应用层面...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

独上西楼影三人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值