Iawen's Blog

我喜欢这样自由的随手涂鸦,因为我喜欢风......

前言

性能测试(Performance Test):通常收集所有和测试有关的所有性能,通常被不同人在不同场合下进行使用。 性能测试是一种“正常”测试,主要测试使用时系统是否满足要求,同时可能为了保留系统的扩展空间而进行的一些稍稍超过“正常”范围的测试(比如:当前系统使用用户100人,可能未来人数会增多到300人,所以要让系统能够在300人情况下正常运行)

压力测试(Stress Test):压力测试的目标是测试在一定的负载下系统长时间运行的稳定性,但是这个负载不一定是应用系统本身造成的。比如我们经常利用脚本或工具事先吃掉服务器的一部分cpu、内存或带宽等,创造出一定的负载环境并测试被测应用系统在此环境下的事物处理能力,响应时间等等。压力测试尤其关注大业务量情况下长时间运行系统性能的变化(例如是否反应变慢、是否会内存泄漏导致系统逐渐崩溃、是否能恢复)。

1. ab

1.1 参数说明

  • -d 不用显示 saved table 的百分比资料
  • -k KeepAlive
  • -S 不显示长信息
  • -c 并发数
  • -n 同一个联机建立几个请求通道

1.2 输出说明

[root@iawen nodejs]# ab -c 10 -t 3 -k http://139.199.186.239:8080/ 
This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking 139.199.186.239 (be patient)
Finished 1128 requests


Server Software:        nginx/1.13.12
Server Hostname:        139.199.186.239
Server Port:            8080

Document Path:          /
Document Length:        12 bytes

Concurrency Level:      10
Time taken for tests:   3.001 seconds
Complete requests:      1128
Failed requests:        0
Write errors:           0
Keep-Alive requests:    0
Total transferred:      197400 bytes
HTML transferred:       13536 bytes
Requests per second:    375.89 [#/sec] (mean)
Time per request:       26.603 [ms] (mean)
Time per request:       2.660 [ms] (mean, across all concurrent requests)
Transfer rate:          64.24 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        6   11   4.5     11      62
Processing:     6   13  20.2     11     296
Waiting:        6   13  20.2     11     296
Total:         14   24  20.8     22     307

Percentage of the requests served within a certain time (ms)
  50%     22
  66%     24
  75%     25
  80%     26
  90%     28
  95%     30
  98%     56
  99%     70
 100%    307 (longest request)  
  • Document Path 文档路径
  • Document Length 文档长度
  • Concurrency Level:并发级别,命令中传入的c
  • Time taken for tests:表示完成所有测试所花费的时间,与命令中传入的t选项有细微出入
  • Complete requests:一共完成多少次请求
  • Failed requests:失败的请求数
  • Write errors:写错误(连接断开导致的)
  • Requests per second:它表示服务器每秒能处理多少请求,是重点反映服务器并发能力的指标。这个值又称RPS或QPS。
  • Time per request:第一个表示用户平均等待时间,第二个表示服务器平均请求处理事件。

2. sysbench - 数据库功能及性能测试工具

1.0 之后的版本使用方法跟之前的有所区别,下面所有内容基于 1.0.9 版本。 另外,为了方便管理测试,最好不要通过命令直接运行测试,而是写成脚本自动化执行测试。 GITHUB:https://github.com/akopytov/sysbench WIKI:https://wiki.gentoo.org/wiki/Sysbench

2.1 安装及简介

Linux 各大发行版通过自带安装工具直接安装即可,RHEL/CentOS 的安装命令如下:

yum -y install sysbench

sysbench 可以进行以下测试:

  • CPU 运算性能测试
  • 磁盘 IO 性能测试
  • 调度程序性能测试
  • 内存分配及传输速度测试
  • POSIX 线程性能测试
  • 数据库性能测试(OLTP 基准测试,需要通过 /usr/share/sysbench/ 目录中的 Lua 脚本执行,例如 oltp_read_only.lua 脚本执行只读测试)

另外,sysbench 还可以通过运行命令时指定自己的 Lua 脚本来自定义测试。

2.2 使用

2.2.1 查看帮助信息

可以通过 sysbench –help 查看 sysbench 的可用命令、选项及內建测试类型的帮助信息,不同测试类型可用的命令也不同:

# sysbench --help
Usage:
 sysbench [options]... [testname] [command]
Commands implemented by most tests: prepare run cleanup help # 可用的命令,四个
General options: # 通用选项
 --threads=N 要使用的线程数,默认 1 个 [1]
 --events=N 最大允许的事件个数 [0]
 --time=N 最大的总执行时间,以秒为单位 [10]
 --forced-shutdown=STRING 在 --time 时间限制到达后,强制关闭之前等待的秒数,默认“off”禁用(number of seconds to wait after the --time limit before forcing shutdown, or 'off' to disable) [off]
 --thread-stack-size=SIZE 每个线程的堆栈大小 [64K]
 --rate=N 平均传输速率。0 则无限制 [0]
 --report-interval=N 以秒为单位定期报告具有指定间隔的中间统计信息 0 禁用中间报告 [0]
 --report-checkpoints=[LIST,...] 转储完整的统计信息并在指定的时间点重置所有计数器。参数是一个逗号分隔的值列表,表示从测试开始经过这个时间量时必须执行报告检查点(以秒为单位)。报告检查点默认关闭。 []
 --debug[=on|off] 打印更多 debug 信息 [off]
 --validate[=on|off] 尽可能执行验证检查 [off]
 --help[=on|off] 显示帮助信息并退出 [off]
 --version[=on|off] 显示版本信息并退出 [off]
 --config-file=FILENAME 包含命令行选项的文件
 --tx-rate=N 废弃,改用 --rate [0]
 --max-requests=N 废弃,改用 --events [0]
 --max-time=N 废弃,改用 --time [0]
 --num-threads=N 废弃,改用 --threads [1]
Pseudo-Random Numbers Generator options: # 伪随机数发生器选项
 --rand-type=STRING random numbers distribution {uniform,gaussian,special,pareto} [special]
 --rand-spec-iter=N number of iterations used for numbers generation [12]
 --rand-spec-pct=N percentage of values to be treated as 'special' (for special distribution) [1]
 --rand-spec-res=N percentage of 'special' values to use (for special distribution) [75]
 --rand-seed=N seed for random number generator. When 0, the current time is used as a RNG seed. [0]
 --rand-pareto-h=N parameter h for pareto distribution [0.2]
Log options: # 日志选项
 --verbosity=N verbosity level {5 - debug, 0 - only critical messages} [3]
--percentile=N percentile to calculate in latency statistics (1-100). Use the special value of 0 to disable percentile calculations [95]
 --histogram[=on|off] print latency histogram in report [off]
General database options: # 通用的数据库选项
--db-driver=STRING 指定要使用的数据库驱动程序 ('help' to get list of available drivers)
 --db-ps-mode=STRING prepared statements usage mode {auto, disable} [auto]
 --db-debug[=on|off] print database-specific debug information [off]
Compiled-in database drivers: # 內建的数据库驱动程序,默认支持 MySQL 和 PostgreSQL
 mysql - MySQL driver
 pgsql - PostgreSQL driver
mysql options: # MySQL 数据库专用选项
 --mysql-host=[LIST,...] MySQL server host [localhost]
 --mysql-port=[LIST,...] MySQL server port [3306]
 --mysql-socket=[LIST,...] MySQL socket
 --mysql-user=STRING MySQL user [sbtest]
 --mysql-password=STRING MySQL password []
 --mysql-db=STRING MySQL database name [sbtest]
 --mysql-ssl[=on|off] use SSL connections, if available in the client library [off]
 --mysql-ssl-cipher=STRING use specific cipher for SSL connections []
 --mysql-compression[=on|off] use compression, if available in the client library [off]
 --mysql-debug[=on|off] trace all client library calls [off]
 --mysql-ignore-errors=[LIST,...] list of errors to ignore, or "all" [1213,1020,1205]
 --mysql-dry-run[=on|off] Dry run, pretend that all MySQL client API calls are successful without executing them [off]
pgsql options: # PostgreSQL 数据库专用选项
 --pgsql-host=STRING PostgreSQL server host [localhost]
 --pgsql-port=N PostgreSQL server port [5432]
 --pgsql-user=STRING PostgreSQL user [sbtest]
 --pgsql-password=STRING PostgreSQL password []
 --pgsql-db=STRING PostgreSQL database name [sbtest]
Compiled-in tests: # 內建测试类型
 fileio - File I/O test
 cpu - CPU performance test
 memory - Memory functions speed test
 threads - Threads subsystem performance test
 mutex - Mutex performance test
See 'sysbench <testname> help' for a list of options for each test.

通过 sysbench help 命令可以查看具体一个测试类型的帮助信息。

# sysbench fileio help
sysbench 1.0.9 (using system LuaJIT 2.0.4)
fileio options:
 --file-num=N number of files to create [128]
 --file-block-size=N block size to use in all IO operations [16384]
 --file-total-size=SIZE total size of files to create [2G]
 --file-test-mode=STRING test mode {seqwr, seqrewr, seqrd, rndrd, rndwr, rndrw}
 --file-io-mode=STRING file operations mode {sync,async,mmap} [sync]
 --file-async-backlog=N number of asynchronous operatons to queue per thread [128]
 --file-extra-flags=STRING additional flags to use on opening files {sync,dsync,direct} []
 --file-fsync-freq=N do fsync() after this number of requests (0 - don't use fsync()) [100]
 --file-fsync-all[=on|off] do fsync() after each write operation [off]
 --file-fsync-end[=on|off] do fsync() at the end of test [on]
 --file-fsync-mode=STRING which method to use for synchronization {fsync, fdatasync} [fsync]
 --file-merged-requests=N merge at most this number of IO requests if possible (0 - don't merge) [0]
 --file-rw-ratio=N reads/writes ratio for combined test [1.5]

2.2.2 测试 CPU

CPU 测试时,会计算素数(对这个数字除以 2 到这个数字平方根之间的所有数字来验证素数)直到某个指定值所需要的时间。单纯的测试一组非常有限 CPU 硬件性能。 CPU 基准测试时可以指定线程数量和素数上限。

先查看帮助信息:

sysbench cpu help
sysbench 1.0.9 (using system LuaJIT 2.0.4)
cpu options:
    --cpu-max-prime=N 素数发生器的上限(upper limit for primes generator) [10000]

开始测试:

sysbench --cpu-max-prime=10000 --threads=2 cpu run
sysbench 1.0.15 (using bundled LuaJIT 2.1.0-beta2)
Running the test with following options:
Number of threads: 2
Initializing random number generator from current time
Prime numbers limit: 10000
Initializing worker threads...
Threads started!
CPU speed:
 events per second: 1911.40
General statistics:
 total time: 10.0004s
 total number of events: 19118
Latency (ms):
 min: 0.85
 avg: 1.05
 max: 3.10
 95th percentile: 1.37
 sum: 19983.36
Threads fairness:
 events (avg/stddev): 9559.0000/7.00
 execution time (avg/stddev): 9.9917/0.00

2.2.3 测试 fileio

使用 fileio 时,需要创建一组测试文件,测试文件需要大于可用内存的大小,避免文件缓存在内存中影响结果。测试流程为:准备测试文件-》测试-》回收测试文件,命令如下:

sysbench --file-total-size=28G fileio prepare
sysbench --file-total-size=28G --file-test-mode=rndrw --time=300 --max-requests=0 fileio run
sysbench --file-total-size=28G fileio cleanup123

对于 I/O 基准测试,可以通过 –file-test-mode 告诉 sysbench 要运行的工作负载的类型,可用类型有:

  • seqwr:顺序写入
  • seqrewr:顺序重写
  • seqrd:顺序读取
  • rndrd:随机读取
  • rndwr:随机写入
  • rndrw:随机读取/写入

上面的例子中使用的是随机读取/写入(rndrw)。通过 –time 选项指定测试持续时间(以秒为单位)。 帮助信息:

sysbench fileio help
sysbench 1.0.9 (using system LuaJIT 2.0.4)
fileio options:
 --file-num=N number of files to create [128]
 --file-block-size=N block size to use in all IO operations [16384]
 --file-total-size=SIZE total size of files to create [2G]
 --file-test-mode=STRING test mode {seqwr, seqrewr, seqrd, rndrd, rndwr, rndrw}
 --file-io-mode=STRING file operations mode {sync,async,mmap} [sync]
 --file-async-backlog=N number of asynchronous operatons to queue per thread [128]
 --file-extra-flags=STRING additional flags to use on opening files {sync,dsync,direct} []
 --file-fsync-freq=N do fsync() after this number of requests (0 - don't use fsync()) [100]
 --file-fsync-all[=on|off] do fsync() after each write operation [off]
 --file-fsync-end[=on|off] do fsync() at the end of test [on]
 --file-fsync-mode=STRING which method to use for synchronization {fsync, fdatasync} [fsync]
 --file-merged-requests=N merge at most this number of IO requests if possible (0 - don't merge) [0]
 --file-rw-ratio=N reads/writes ratio for combined test [1.5]1234567891011121314151617

命令的完整输出如下:

sysbench --file-total-size=28G fileio prepare
sysbench 1.0.9 (using system LuaJIT 2.0.4)
128 files, 229376Kb each, 28672Mb total
Creating files for the test...
Extra file open flags: 0
Creating file test_file.0
Creating file test_file.1
...此处总共创建了 128 个文件,每个 229376Kb,总共 28672Mb
Creating file test_file.127
30064771072 bytes written in 255.52 seconds (112.21 MiB/sec).
 
# sysbench --file-total-size=28G --file-test-mode=rndrw --time=300 --max-requests=0 fileio run
sysbench 1.0.9 (using system LuaJIT 2.0.4)
Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
Extra file open flags: 0
128 files, 224MiB each
28GiB 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 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: 96.00
 writes/s: 64.00
 fsyncs/s: 204.47
Throughput:
 read, MiB/s: 1.50
 written, MiB/s: 1.00
General statistics:
 total time: 300.0016s
 total number of events: 109341
Latency (ms):
 min: 0.00
 avg: 2.74
 max: 256.76
 95th percentile: 7.17
 sum: 299726.28
Threads fairness:
 events (avg/stddev): 109341.0000/0.00
 execution time (avg/stddev): 299.7263/0.00
[root@VM_157_18_centos ~]# sysbench --file-total-size=28G fileio cleanup
sysbench 1.0.9 (using system LuaJIT 2.0.4)
Removing test files...

2.2.4 测试 memory

当在 sysbench 中进行内存测试时,会分配一个内存缓冲区并在此执行读写操作,每次操作都会读完或写满缓冲区。然后重复此操作直到达到指定大小(–memory-total-size)。可以提供多个线程(–threads),不同的缓冲区大小(–memory-block-size)和请求类型(读或写,顺序或随机)。

帮助信息:

sysbench memory help
sysbench 1.0.9 (using system LuaJIT 2.0.4)
memory options:
 --memory-block-size=SIZE size of memory block for test [1K]
 --memory-total-size=SIZE total size of data to transfer [100G]
 --memory-scope=STRING memory access scope {global,local} [global]
 --memory-hugetlb[=on|off] allocate memory from HugeTLB pool [off]
 --memory-oper=STRING type of memory operations {read, write, none} [write]
 --memory-access-mode=STRING memory access mode {seq,rnd} [seq]

例如,指定 4 个线程,缓冲区大小为 8KB,在内存中传输 4GB 数据的测试:

sysbench --threads=4 --memory-block-size=8k --memory-total-size=4G memory run
sysbench 1.0.9 (using system LuaJIT 2.0.4)
Running the test with following options:
Number of threads: 4
Initializing random number generator from current time
Running memory speed test with the following options:
 block size: 8KiB
 total size: 4096MiB
 operation: write
 scope: global
Initializing worker threads...
Threads started!
Total operations: 524288 (731249.24 per second)
4096.00 MiB transferred (5712.88 MiB/sec)
General statistics:
 total time: 0.7150s
 total number of events: 524288
Latency (ms):
 min: 0.00
 avg: 0.00
 max: 43.03
 95th percentile: 0.00
 sum: 1871.33
Threads fairness:
 events (avg/stddev): 131072.0000/0.00
 execution time (avg/stddev): 0.4678/0.04

2.2.5 测试 threads

测试 threads 时,每个工作线程将被分配一个 mutex(一种锁)。每次执行时,每个线程将循环若干次(通过 –thread-yields 的数量设置),循环时这个线程会锁定,在再次执行时解锁。 通过调整各种参数,可以模拟具有单个或多个锁的高并发线程下的情况。

帮助信息:

sysbench threads help
sysbench 1.0.9 (using system LuaJIT 2.0.4)
threads options:
 --thread-yields=N number of yields to do per request [1000]
 --thread-locks=N number of locks per thread [8]

运行测试:

sysbench --thread-yields=2000 --thread-locks=8 threads run
sysbench 1.0.9 (using system LuaJIT 2.0.4)
Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
Initializing worker threads...
Threads started!
General statistics:
 total time: 10.0002s
 total number of events: 16554
Latency (ms):
 min: 0.50
 avg: 0.60
 max: 37.05
 95th percentile: 0.94
 sum: 9978.12
Threads fairness:
 events (avg/stddev): 16554.0000/0.00
 execution time (avg/stddev): 9.9781/0.00

2.2.6 测试 mutex

测试 mutex 时,sysbench 将为每个线程运行一个请求。这个请求首先会对 CPU 施加一些压力(使用一个简单的增量循环,通过 –mutex-loops 参数设置),然后随机使用一个 mutex(锁),递增一个全局变量并再次释放锁。这个过程根据锁的个数(–mutex-locks)多次重复。随机 mutex 取自大小为 –mutex-num 的参数池。

帮助信息:

sysbench mutex help
sysbench 1.0.9 (using system LuaJIT 2.0.4)
mutex options:
 --mutex-num=N total size of mutex array [4096]
 --mutex-locks=N number of mutex locks to do per thread [50000]
 --mutex-loops=N number of empty loops to do outside mutex lock [10000]

运行测试:

sysbench mutex run
sysbench 1.0.9 (using system LuaJIT 2.0.4)
Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
Initializing worker threads...
Threads started!
General statistics:
 total time: 0.2132s
 total number of events: 1
Latency (ms):
 min: 213.10
 avg: 213.10
 max: 213.10
 95th percentile: 211.60
 sum: 213.10
Threads fairness:
 events (avg/stddev): 1.0000/0.00
 execution time (avg/stddev): 0.2131/0.00

2.2.7 OLTP 基准测试

OLTP 基准测试模拟了一个简单的事务处理系统的工作负载。然而最新版本的 sysbench 把 OLTP 这个曾经的內建测试类型移除了,如果要用,需要在命令中指定测试类型的位置用 /usr/share/sysbench/oltp_read_only.lua 脚本代替测试类型。 流程:指定数据库-》建表并生成数据-》运行测试-》清理测试表。 首先生成表,注意替换命令中的数据库密码和 MySQL 套接字,如果 MySQL 安装在默认位置,可以去掉 –mysql-socket 选项:

sysbench --db-driver=mysql --mysql-user=root --mysql-password=<pwd> \
 --mysql-socket=<mysql.sock path> --mysql-db=foo --range_size=100 \
 --table_size=10000 --tables=2 --threads=2 --events=0 --time=60 \
 --rand-type=uniform /usr/share/sysbench/oltp_read_only.lua prepare​

运行测试,指定了 2 个并发线程,:

sysbench --db-driver=mysql --mysql-user=root --mysql-password=<pwd> \
 --mysql-socket=<mysql.sock path> --mysql-db=foo --range_size=100 \
 --table_size=10000 --tables=2 --threads=2 --events=0 --time=60 \
 --rand-type=uniform /usr/share/sysbench/oltp_read_only.lua run

清理测试时生成的测试表:

sysbench --db-driver=mysql --mysql-user=root --mysql-password=<pwd> \
 --mysql-socket=<mysql.sock path> --mysql-db=foo --range_size=100 \
 --table_size=10000 --tables=2 --threads=2 --events=0 --time=60 \
 --rand-type=uniform /usr/share/sysbench/oltp_read_only.lua cleanup

例如我的选项就是:

sysbench --db-driver=mysql --mysql-user=root --mysql-password=1qaz@WSX --mysql-db=foo \
--range_size=100 --table_size=10000 --tables=2 --threads=1 --events=0 --time=60 \
--rand-type=uniform /usr/share/sysbench/oltp_read_only.lua prepare
sysbench 1.0.9 (using system LuaJIT 2.0.4)
Creating table 'sbtest1'...
Inserting 10000 records into 'sbtest1'
Creating a secondary index on 'sbtest1'...
Creating table 'sbtest2'...
Inserting 10000 records into 'sbtest2'
Creating a secondary index on 'sbtest2'...

# sysbench --db-driver=mysql --mysql-user=root --mysql-password=1qaz@WSX --mysql-db=foo \
--range_size=100 --table_size=10000 --tables=2 --threads=1 --events=0 --time=60 \
--rand-type=uniform /usr/share/sysbench/oltp_read_only.lua run
sysbench 1.0.9 (using system LuaJIT 2.0.4)
Running the test with following options:
Number of threads: 1
Initializing random number generator from current time
Initializing worker threads...
Threads started!
SQL statistics:
 queries performed:
 read: 645708
 write: 0
 other: 92244
 total: 737952
 transactions: 46122 (768.67 per sec.)
 queries: 737952 (12298.73 per sec.)
 ignored errors: 0 (0.00 per sec.)
 reconnects: 0 (0.00 per sec.)
General statistics:
 total time: 60.0003s
 total number of events: 46122
Latency (ms):
 min: 1.06
 avg: 1.30
 max: 34.08
 95th percentile: 1.50
 sum: 59896.08
Threads fairness:
 events (avg/stddev): 46122.0000/0
 
# sysbench --db-driver=mysql --mysql-user=root --mysql-password=1qaz@WSX --mysql-db=foo \
--range_size=100 --table_size=10000 --tables=2 --threads=1 --events=0 --time=60 \
--rand-type=uniform /usr/share/sysbench/oltp_read_only.lua cleanup
sysbench 1.0.9 (using system LuaJIT 2.0.4)
Dropping table 'sbtest1'...
Dropping table 'sbtest2'...