Sysbench安装与使用

Sysbench安装与使用

Sysbench安装

curl -s https://packagecloud.io/install/repositories/akopytov/sysbench/script.deb.sh | sudo bash
sudo apt -y install sysbench
sysbench --version

Sysbench使用

内存测试

查看内存帮助信息

sysbench memory help # 查看内存帮助信息
sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)

memory options:
    # 用于测试的内存块大小，默认为1K。
  --memory-block-size=SIZE    size of memory block for test [1K]
    # 要传输的数据的总大小，默认为100G。
  --memory-total-size=SIZE    total size of data to transfer [100G]
    # 内存访问范围，可以是全局（global）或局部（local），默认为全局。
  --memory-scope=STRING       memory access scope {global,local} [global]
    # 是否从HugeTLB（大页内存）池中分配内存，默认为关闭（off）
  --memory-hugetlb[=on|off]   allocate memory from HugeTLB pool [off]
    # 内存操作类型，可以是读取（read）、写入（write）或无操作（none），默认为写入。
  --memory-oper=STRING        type of memory operations {read, write, none} [write]
    # 内存访问模式，可以是顺序（seq）或随机（rnd），默认为顺序。
  --memory-access-mode=STRING memory access mode {seq,rnd} [seq]

执行命令

sysbench memory run

sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)

Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
# 使用了1个线程进行测试，每个线程的随机数生成器都是基于当前时间初始化的。

Running memory speed test with the following options:
  block size: 1KiB
  total size: 102400MiB
  operation: write
  scope: global
# 内存速度测试选项:每次写入数据的块大小为1KiB，总共写入了102400MiB的数据。
# 操作类型：写入操作。
# 范围：全局范围内的测试。

Initializing worker threads...
Threads started!
Total operations: 37904989 (3789406.67 per second)
37016.59 MiB transferred (3700.59 MiB/sec)

General statistics:
    total time:                          10.0002s
    total number of events:              37904989
# 总体统计：
# 总时间：测试持续了10.0002秒。
#总事件数：完成了37904989个操作。

Latency (ms):
         min:                                    0.00
         avg:                                    0.00
         max:                                    0.98
         95th percentile:                        0.00
         sum:                                 4551.24

# 延迟（毫秒）：
# 最小值：0.00
# 平均值：0.00
# 最大值：0.98
# 95百分位值：0.00
# 总和：4551.24

Threads fairness:
    events (avg/stddev):           37904989.0000/0.00
    execution time (avg/stddev):   4.5512/0.00

# 线程公平性：
# 事件数（平均/标准差）：每个线程完成的事件数，平均值为37904989.0000。
# 执行时间（平均/标准差）：每个线程的平均执行时间为4.5512秒。

CPU测试

查看CPU帮助信息

sysbench cpu help # 查看CPU帮助信息
sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)

cpu options:
  --cpu-max-prime=N upper limit for primes generator [10000]
 # 质数生成器的上限值，默认为10000。
 # 通过该选项，您可以调整在CPU测试中生成质数的上限值。更高的上限值会导致更大的计算量，可以用来测试系统在处理更复杂计算任务时的性能表现。

# 执行命令
sysbench cpu --cpu-max-prime=5000 run

sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)

Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
# 使用了1个线程进行测试，每个线程的随机数生成器都是基于当前时间初始化的。

Prime numbers limit: 5000
# 质数上限：5000

Initializing worker threads...
Threads started!
CPU speed:
    events per second:  2548.98
# CPU速度：每秒生成约2548.98个事件

General statistics:
    total time:                          10.0003s
    total number of events:              25495
# 总体统计：
# 总时间：测试持续了10.0003秒。
# 总事件数：完成了25495个事件。

Latency (ms):
         min:                                    0.30
         avg:                                    0.39
         max:                                    1.43
         95th percentile:                        0.51
         sum:                                 9981.24
# 延迟（毫秒）：
# 最小值：0.30
# 平均值：0.39
# 最大值：1.43
# 95百分位值：0.51
# 总和：9981.24

Threads fairness:
    events (avg/stddev):           25495.0000/0.00
    execution time (avg/stddev):   9.9812/0.00
# 线程公平性：
# 事件数（平均/标准差）：每个线程完成的事件数，平均值为25495.0000。
# 执行时间（平均/标准差）：每个线程的平均执行时间为9.9812秒。

IO测试

查看文件IO帮助信息

sysbench fileio help # 查看文件IO帮助信息

sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)

fileio options:
    # 要创建的文件数，默认为128
  --file-num=N                  要创建的文件数，默认为128
    # 在所有IO操作中使用的块大小，默认为16384
  --file-block-size=N           在所有IO操作中使用的块大小，默认为16384
    # 要创建的文件的总大小，默认为2G
  --file-total-size=SIZE        要创建的文件的总大小，默认为2G
    # 测试模式 {seqwr, seqrewr, seqrd, rndrd, rndwr, rndrw}
  --file-test-mode=STRING       测试模式 {seqwr, seqrewr, seqrd, rndrd, rndwr, rndrw}
    # 文件操作模式 {sync,async,mmap}，默认为sync
  --file-io-mode=STRING         文件操作模式 {sync,async,mmap}，默认为sync
    # 每个线程要排队的异步操作数量，默认为128
  --file-async-backlog=N        每个线程要排队的异步操作数量，默认为128
    # 用于打开文件的附加标志列表 {sync,dsync,direct}，默认为空
  --file-extra-flags=[LIST,...] 用于打开文件的附加标志列表 {sync,dsync,direct}，默认为空
    # 在这个数量的请求后执行fsync()（0表示不使用fsync()），默认为100
  --file-fsync-freq=N           在这个数量的请求后执行fsync()（0表示不使用fsync()），默认为100
    # 每次写操作后执行fsync()，默认为关闭（off）
  --file-fsync-all[=on|off]     每次写操作后执行fsync()，默认为关闭（off）
    # 在测试结束时执行fsync()，默认为开启（on）
  --file-fsync-end[=on|off]     在测试结束时执行fsync()，默认为开启（on）
    # 使用哪种同步方法 {fsync, fdatasync}，默认为fsync
  --file-fsync-mode=STRING      使用哪种同步方法 {fsync, fdatasync}，默认为fsync
    # 如果可能，最多合并此数量的IO请求（0表示不合并），默认为0
  --file-merged-requests=N      如果可能，最多合并此数量的IO请求（0表示不合并），默认为0
    # 组合测试的读/写比率，默认为1.5
  --file-rw-ratio=N             组合测试的读/写比率，默认为1.5

执行命令

sysbench fileio --num-threads=1 --file-total-size=1G --file-test-mode=rndrw run

WARNING: the --test option is deprecated. You can pass a script name or path on the command line without any options.
sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)

Running the test with following options:
Number of threads: 1                          # 备注：使用了单个线程
Initializing random number generator from current time

Extra file open flags: (none)
128 files, 8MiB each                          # 备注：每个文件大小为8MiB，共创建了128个文件
1GiB total file size                           # 备注：总文件大小为1GiB
Block size 16KiB                               # 备注：使用的块大小为16KiB
Number of IO requests: 0
Read/Write ratio for combined random IO test: 1.50
Periodic FSYNC enabled, calling fsync() each 100 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:                      1489.71     # 备注：每秒读取1489.71次
    writes/s:                     993.14      # 备注：每秒写入993.14次
    fsyncs/s:                     3183.33     # 备注：每秒执行3183.33次fsync()

Throughput:
    read, MiB/s:                  23.28       # 备注：读取吞吐量为23.28MiB/s
    written, MiB/s:               15.52       # 备注：写入吞吐量为15.52MiB/s

General statistics:
    total time:                          10.0272s   # 备注：测试总时间为10.0272秒
    total number of events:              56697      # 备注：总事件数为56697个

Latency (ms):
         min:                                    0.00   # 备注：最小延迟为0.00ms
         avg:                                    0.18   # 备注：平均延迟为0.18ms
         max:                                   20.31   # 备注：最大延迟为20.31ms
         95th percentile:                        0.41   # 备注：95th百分位延迟为0.41ms
         sum:                                 9953.23   # 备注：总延迟为9953.23ms

Threads fairness:
    events (avg/stddev):           56697.0000/0.00   # 备注：每个线程平均事件数为56697.0000个
    execution time (avg/stddev):   9.9532/0.00        # 备注：每个线程平均执行时间为9.9532秒

线程测试

sysbench threads help      # 使用sysbench工具执行线程测试，并显示帮助信息
sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3) # sysbench版本信息及所使用的LuaJIT版本信息
threads options:                  # 线程选项:
  --thread-yields=N               # 每个请求要执行的yield次数 [1000]
  --thread-locks=N                # 每个线程的锁数 [8]

sysbench threads --thread-yields=100 --thread-locks=4 run

# `threads`: 指定要运行的测试类型，即线程测试。
# `--thread-yields=100`: 每个请求要执行的 yield 次数为100次。
# `--thread-locks=4`: 每个线程的锁数为4个。
# `run`: 表示执行测试。

sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)

Running the test with following options:  # 使用以下选项运行测试

Number of threads: 1  # 线程数：1

Initializing random number generator from current time  # 从当前时间初始化随机数生成器

Initializing worker threads...  # 初始化工作线程...

Threads started!  # 线程已启动！

General statistics:  # 总体统计：

    total time:                          10.0002s  # 总时间：10.0002秒
    total number of events:              99093  # 总事件数：99093

Latency (ms):  # 延迟（毫秒）：

         min:                                    0.07  # 最小值：0.07
         avg:                                    0.10  # 平均值：0.10
         max:                                    3.91  # 最大值：3.91
         95th percentile:                        0.14  # 95th百分位：0.14
         sum:                                 9946.98  # 总和：9946.98

Threads fairness:  # 线程公平性：
    events (avg/stddev):           99093.0000/0.00  # 事件（平均/标准差）：99093.0000/0.00
    execution time (avg/stddev):   9.9470/0.00  # 执行时间（平均/标准差）：9.9470/0.00

mutex测试

mutex帮助命令

sysbench mutex help
sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)

mutex options:  # 互斥锁选项

  --mutex-num=N   total size of mutex array [4096]  # 互斥锁数组的总大小 [4096]
  --mutex-locks=N number of mutex locks to do per thread [50000]  # 每个线程执行的互斥锁数量 [50000]
  --mutex-loops=N number of empty loops to do outside mutex lock [10000]  # 在互斥锁之外执行的空循环次数 [10000]

sysbench mutex run
sysbench 1.0.20 (using system LuaJIT 2.1.0-beta3)

Running the test with following options:  # 使用以下选项运行测试

Number of threads: 1  # 线程数：1

Initializing random number generator from current time  # 从当前时间初始化随机数生成器

Initializing worker threads...  # 初始化工作线程...

Threads started!  # 线程已启动！

General statistics:  # 总体统计：

    total time:                          0.1812s  # 总时间：0.1812秒
    total number of events:              1  # 总事件数：1

Latency (ms):  # 延迟（毫秒）：

         min:                                  181.07  # 最小值：181.07
         avg:                                  181.07  # 平均值：181.07
         max:                                  181.07  # 最大值：181.07
         95th percentile:                      179.94  # 95th百分位：179.94
         sum:                                  181.07  # 总和：181.07

Threads fairness:  # 线程公平性：
    events (avg/stddev):           1.0000/0.00  # 事件（平均/标准差）：1.0000/0.00
    execution time (avg/stddev):   0.1811/0.00  # 执行时间（平均/标准差）：0.1811/0.00