系统性能测试工具

# Install
RHRL/CentOS
yum install epel-release
yum install stress stress-ng

#Debian/Ubuntu
apt install stress stress-ng

# Syntax
# stress-ng 基本用法与stress完全兼容，但有更多的参数可选，并且可以查看统计信息;

#1.在两个CPU核心上跑开方运算，并且启动一个不断分配释放1G内存的线程，运行10秒后停止
stress --cpu 2 --vm 1 --vm-bytes 1G  -v --timeout 120

#2.启动一个线程不断执行sync系统调用回写磁盘缓存，并且启动一个线程不停地写入删除512MB数据，运行10秒停止
stress --io 1 --hdd 1 --hdd-bytes 512M -v --timeout 10

#3.--sock 可以模拟大量的socket连接断开以及数据的发送接收等等
stress-ng --sock 2 -v --timeout 10 --metrics-brief

#4.Note: Numbers may be suffixed with s,m,h,d,y (time) or B,K,M,G (size).
Example: stress --cpu 8 --io 4 --vm 2 --vm-bytes 128M --timeout 10s -v

Example: stress --cpu 24 --hdd 8 --hdd-bytes 1G --io 8 --vm 4 --vm-bytes 4G --timeout 1200s -v

yum install fio -y

filename=/dev/sdb1 #测试文件名称通常选择需要测试的盘的data目录(测试必须指定切勿在系统分区做测试会破坏系统分区而导致系统崩溃无法启动)
directory=/app/    #在根目录下创建一个空目录，在测试命令中使用directory参数指定该目录，而不使用filename参数。
direct=1         #使用directIO绕过OS自带的 buffer 使测试磁盘的结果更真实(bool类型)。
rw=read          #read(顺序读)| randread(随机读) | write(顺序写) | randwrite (随机写) | randrw (混合随机读写模式) 5种方式
rwmixwrite=30    #在混合读写的模式下写占30%
rwmixread=70     #在混合读写的模式下写占70%
bs=16k           #设置I/O block块文件大小为16k(默认4k)
bsrange=512-2048 #提定数据块的大小范围
name=jobname     #任务的名称（且任务名称可以相同）
numjobs=1        #每个job（任务）开1个线程  最终线程数=任务数(几个name=jobx) * numjobs
size=5G          #指定job处理的文件的大小及每个线程读写的数据量
runtime=1000     #指定在多少秒后停止进程，此处测试时间为1000秒
ioengine=libaio #I/O引擎选择(一共19种)，默认值是sync同步阻塞I/O , libaio是Linux的本地native异步I/O。
iodepth=16      #队列的深度,如果ioengine采用异步方式，该参数表示一批提交保持的io单元数 
lockmem=1g      #使用1g内存进行测试。
nrfiles=8       #每个进程生成文件的数量。
time_based      #如果在runtime指定的时间还没到时文件就被读写完成，将继续重复知道runtime时间结束。
thread          #使用pthread_create创建线程，另一种是fork创建进程，由于进程的开销比线程要大所以一般都采用thread测试；
zero_buffers    #用0初始化系统buffer。
group_reporting #当同时指定了numjobs了时，输出结果按组显示

#实例1.本地异步I/O 4k 块 不使用系统缓存  读测试 测试深度16 时间60s
$fio -filename=/dev/sdb/ -name="BS 4KB read test" -ioengine=libaio -direct=1 -thread -rw=read -size=1M -numjobs=16 -bs=4k -iodepth=16 -runtime=60 -time_based -group_reporting

$fio -directory=/app/ -name="BS 4KB read test" -ioengine=libaio -direct=1 -thread -rw=read -size=1M -numjobs=16 -bs=4k -iodepth=16 -runtime=60 -time_based -group_reporting

$fio --bs=4k --ioengine=libaio --iodepth=1 --direct=1 --rw=read --time_based --runtime=60 --refill_buffers --norandommap --randrepeat=0 --group_reporting --name=fio-read --size=500M --filename=/dev/sdb1


示例2.配置文件形式:fio.conf
#测试命令
fio fio.conf
cat > fio.comf <<END
[global]
ioengine=libaio
direct=1
thread=1
norandommap=1
randrepeat=0
runtime=60
ramp_time=6
size=1g
directory=/data
[read4k-rand]
stonewall
group_reporting
bs=4k
rw=randread
numjobs=8
iodepth=32
[read64k-seq]
stonewall
group_reporting
bs=64k
rw=read
numjobs=4
iodepth=8
[write4k-rand]
stonewall
group_reporting
bs=4k
rw=randwrite
numjobs=2
iodepth=4
[write64k-seq]
stonewall
group_reporting
bs=64k
rw=write
numjobs=2
iodepth=4
END

#测试2：
Jobs: 16 (f=16): [R(16)][100.0%][r=9941KiB/s,w=0KiB/s][r=2485,w=0 IOPS][eta 00m:00s]
BS 4KB read test: (groupid=0, jobs=16): err= 0: pid=2637: Tue Apr 28 21:27:01 2020
   #读IOPS          #BW=平均IO带宽         #runt=线程运行时间
   read: IOPS=2457, BW=9830KiB/s (10.1MB/s)(577MiB/60060msec)
   #slat=提交延迟，提交该IO请求到kernel所花的时间（不包括kernel处理的时间）
    slat (nsec): min=1665, max=243925k, avg=5226953.48, stdev=13063402.61
   #clat=完成延迟, 提交该IO请求到kernel后，处理所花的时间
    clat (usec): min=85, max=698388, avg=98913.96, stdev=63432.35
   #lat=响应时间
     lat (usec): min=88, max=698392, avg=104141.19, stdev=67428.64
    clat percentiles (msec):
     |  1.00th=[   41],  5.00th=[   47], 10.00th=[   50], 20.00th=[   53],
     | 30.00th=[   56], 40.00th=[   61], 50.00th=[   77], 60.00th=[   95],
     | 70.00th=[  114], 80.00th=[  140], 90.00th=[  182], 95.00th=[  224],
     | 99.00th=[  326], 99.50th=[  380], 99.90th=[  489], 99.95th=[  550],
     | 99.99th=[  625]
   #带宽
   bw (  KiB/s): min=   40, max= 1696, per=6.24%, avg=613.88, stdev=285.96, samples=1920
   iops        : min=   10, max=  424, avg=153.45, stdev=71.50, samples=1920
  lat (usec)   : 100=0.01%, 250=0.02%, 500=0.16%, 750=0.07%, 1000=0.04%
  lat (msec)   : 2=0.08%, 4=0.01%, 10=0.02%, 20=0.04%, 50=12.59%
  lat (msec)   : 100=49.84%, 250=33.90%, 500=3.12%, 750=0.09%
  #利用率
  cpu          : usr=0.02%, sys=0.11%, ctx=74903, majf=0, minf=285
  #io队列深度
  IO depths    : 1=0.1%, 2=0.1%, 4=0.1%, 8=0.1%, 16=99.8%, 32=0.0%, >=64=0.0%
     #单个IO提交要提交的IO数
     submit    : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
     #类似于上面的提交号，但是用于补全。
     complete  : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.1%, 32=0.0%, 64=0.0%, >=64=0.0%
     #发出的读/写请求的数量，
     issued rwts: total=147602,0,0,0 short=0,0,0,0 dropped=0,0,0,0
     #IO完延迟的分布
     latency   : target=0, window=0, percentile=100.00%, depth=16

Run status group 0 (all jobs):
   READ: bw=9830KiB/s (10.1MB/s), 9830KiB/s-9830KiB/s (10.1MB/s-10.1MB/s), io=577MiB (605MB), run=60060-60060msec

Disk stats (read/write):
  # ios=所有group总共执行的IO数.
  # merge=总共发生的IO合并数.
  # ticks=Number of ticks we kept the disk busy.
  # io_queue=花费在队列上的总共时间.
  # util=磁盘利用率
  vda: ios=147591/7, merge=0/3, ticks=7606987/26, in_queue=7607671, util=99.88%


#测试3
Starting 1 process
Jobs: 1 (f=0): [R] [38.4% done] [4031KB/0KB/0KB /s] [1007/0/0 iops] [eta 01m:38s]
fio-read: (groupid=0, jobs=1): err= 0: pid=15639: Tue Apr 28 21:45:02 2020
  read : io=195600KB, bw=3259.1KB/s, iops=814, runt= 60001msec
    slat (usec): min=14, max=5370, avg=34.54, stdev=89.26
    clat (usec): min=3, max=1537.2K, avg=1179.49, stdev=8932.97
     lat (usec): min=75, max=1537.2K, avg=1216.66, stdev=8933.38
    clat percentiles (usec):
     |  1.00th=[  141],  5.00th=[  227], 10.00th=[  290], 20.00th=[  410],
     | 30.00th=[  532], 40.00th=[  684], 50.00th=[  844], 60.00th=[  988],
     | 70.00th=[ 1176], 80.00th=[ 1448], 90.00th=[ 1864], 95.00th=[ 2320],
     | 99.00th=[ 6112], 99.50th=[13760], 99.90th=[23680], 99.95th=[31104],
     | 99.99th=[154624]
    bw (KB  /s): min=   19, max= 4552, per=100.00%, avg=3371.60, stdev=989.34
    lat (usec) : 4=0.01%, 10=0.02%, 50=0.01%, 100=0.23%, 250=6.35%
    lat (usec) : 500=20.69%, 750=16.90%, 1000=16.37%
    lat (msec) : 2=31.73%, 4=6.07%, 10=0.86%, 20=0.59%, 50=0.15%
    lat (msec) : 100=0.01%, 250=0.01%, 2000=0.01%
  cpu          : usr=1.62%, sys=5.57%, ctx=49057, majf=0, minf=9
  IO depths    : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%
     submit    : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
     complete  : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%
     issued    : total=r=48900/w=0/d=0, short=r=0/w=0/d=0

Run status group 0 (all jobs):
   READ: io=195600KB, aggrb=3259KB/s, minb=3259KB/s, maxb=3259KB/s, mint=60001msec, maxt=60001msec

Disk stats (read/write):
  sdb: ios=48651/0, merge=0/0, ticks=55536/0, in_queue=55468, util=92.82%

#命令安装
tar xvfiperf-3.0b5.tar.gz
cd iperf-3.0b5
./configure
make && make install

#yum安装
yum install iperf

s,-server
在服务器模式下运行iperf，且一次只允许一个iperf连接。
-D,-damon
在后台运行服务器作为守护程序。
-I,-pidfile文件
使用进程ID编写一个文件，作为守护进程运行时最为有用（iperf3.1版本新功能）
-p：后接服务端监听的端口

-c, -c  主机地址
在客户端模式下运行Iperf，连接到在主机上运行的Iperf服务器
-u 使用UDP而不是TCP，详见-b选项
-b, bandwidth n 将目标带宽设置为n bits/sec（UDP默认为1  Mbits / sec，TCP无限制）。
-t, -time n 设置传输的时间（以秒为单位），默认发送10秒的数据
-R, 上传速度机械能测试
-4 指定ipv4
-f 格式化带宽数输出
-n 指定传输的字节数

-i：设置带宽报告的时间间隔，单位为秒
-B: 绑定C/S的ip地址

#实例1.机器带宽检测
iperf3 -s -i 1  #Server
iperf3 -c 172.31.0.25 -i 1 -t 10 60 #Client

[ ID] Interval           Transfer     Bandwidth       Retr  Cwnd
[  4]   0.00-1.00   sec   697 MBytes  5.84 Gbits/sec    0   3.01 MBytes

[ ID] Interval           Transfer     Bandwidth (带宽数)      Retr
[  4]   0.00-10.00  sec  7.07 GBytes  6.07 Gbits/sec  2006  sender
[  4]   0.00-10.00  sec  7.07 GBytes  6.07 Gbits/sec        receiver

#示例2.测试单线程UDP
iperf -s -u 
iperf -c 172.31.0.25-u -t 15 -i 1

#示例3.测试流量为10Mbps
iperf -u -c 192.168.90.234 -b 10M-i -2

#示例4.Linux设备和Android设备测试UDP带宽
iperf -s -u #以在本服务器启用iperf，并运行于udp模式
iperf -c server-ip -u -t 15 -i 1 # 在客户端（Android）

#示例5.上传速度测试
iperf -c ip -p 5204 -R

#示例6.绑定指定IP
iperf -s -p 25001 -B 192.168.33.103 (-u)
iperf -c -p 25001 -B 192.168.33.104 -4 -f K -n 10M -b 10M （-u）

# Install
yum install -y qperf
apt install qperf

# 基础语法
qperf SERVERNODE [OPTIONS] TESTS
qperf --help examples  #Some examples of using qperf

# 参数说明
man qperf

# 测试选项
Miscellaneous
    conf                    Show configuration
    quit                    Cause the server to quit
Socket Based
    rds_bw                  RDS streaming one way bandwidth
    rds_lat                 RDS one way latency
    sctp_bw                 SCTP streaming one way bandwidth
    sctp_lat                SCTP one way latency
    tcp_bw                  TCP streaming one way bandwidth
    tcp_lat                 TCP one way latency
    udp_bw                  UDP streaming one way bandwidth
    udp_lat                 UDP one way latency
RDMA Send/Receive
    rc_bi_bw                RC streaming two way bandwidth
    rc_bw                   RC streaming one way bandwidth
    rc_lat                  RC one way latency
    uc_bi_bw                UC streaming two way bandwidth
    uc_bw                   UC streaming one way bandwidth
    uc_lat                  UC one way latency
    ud_bi_bw                UD streaming two way bandwidth
    ud_bw                   UD streaming one way bandwidth
    ud_lat                  UD one way latency
    xrc_bi_bw               XRC streaming two way bandwidth
    xrc_bw                  XRC streaming one way bandwidth
    xrc_lat                 XRC one way latency
RDMA
    rc_rdma_read_bw         RC RDMA read streaming one way bandwidth
    rc_rdma_read_lat        RC RDMA read one way latency
    rc_rdma_write_bw        RC RDMA write streaming one way bandwidth
    rc_rdma_write_lat       RC RDMA write one way latency
    rc_rdma_write_poll_lat  RC RDMA write one way polling latency
    uc_rdma_write_bw        UC RDMA write streaming one way bandwidth
    uc_rdma_write_lat       UC RDMA write one way latency
    uc_rdma_write_poll_lat  UC RDMA write one way polling latency
InfiniBand Atomics
    rc_compare_swap_mr      RC compare and swap messaging rate
    rc_fetch_add_mr         RC fetch and add messaging rate
Verification
    ver_rc_compare_swap     Verify RC compare and swap
    ver_rc_fetch_add        Verify RC fetch and add

# 0.服务端直接运行如下，无需任何参数
$ qperf  #此时终端阻塞
# 默认开启端口号：19765
# 通过netstat查看，如下:
$ netstat -tunlup
# tcp 0 0 0.0.0.0:19765 0.0.0.0:* LISTEN 53755/qperf

# 1.客户端运行TCP/UDP带宽和延迟测试:
qperf -t 30 10.10.107.192 -v tcp_bw udp_bw tcp_lat udp_lat conf
# tcp_bw:
#     bw              =   672 MB/sec
#     msg_rate        =  10.2 K/sec
#     time            =    30 sec
#     send_cost       =  1.52 sec/GB
#     recv_cost       =  1.78 sec/GB
#     send_cpus_used  =   102 % cpus
#     recv_cpus_used  =   120 % cpus
# udp_bw:
#     send_bw         =   514 MB/sec
#     recv_bw         =  3.52 MB/sec
#     msg_rate        =   108 /sec
#     time            =    30 sec
#     send_cost       =  1.91 sec/GB
#     recv_cost       =   101 sec/GB
#     send_cpus_used  =    98 % cpus
#     recv_cpus_used  =  35.5 % cpus
# tcp_lat:
#     latency        =  95.9 us
#     msg_rate       =  10.4 K/sec
#     time           =    30 sec
#     loc_cpus_used  =  32.8 % cpus
#     rem_cpus_used  =  28.6 % cpus
# udp_lat:
#     latency        =  83.4 us
#     msg_rate       =    12 K/sec
#     time           =    30 sec
#     loc_cpus_used  =  29.6 % cpus
#     rem_cpus_used  =  28.2 % cpus
# conf:
#     loc_node   =  master-01
#     loc_cpu    =  2 Cores: Intel Core i3  540 @ 3.07GHz
#     loc_os     =  Linux 5.7.0-1.el7.elrepo.x86_64
#     loc_qperf  =  0.4.9
#     rem_node   =  master-02
#     rem_cpu    =  2 Cores: Intel Core i3  540 @ 3.07GHz
#     rem_os     =  Linux 5.7.0-1.el7.elrepo.x86_64
#     rem_qperf  =  0.4.9

# 2.客户端运行测量RDMA UD的延迟和带宽:
qperf myserver ud_lat ud_bw

# 3.客户端运行测量RDMA UC双向带宽:
qperf myserver rc_bi_bw

# 4.客户端运行获取消息大小从1到64K的TCP延时范围
qperf myserver -oo msg_size:1:64K:*2 -vu tcp_lat

# Install
git clone https://github.com/wg/wrk.git --depth=1 && cd wrk && make

# Syntax
Usage: wrk <options> <url>
Options:
  -c, --connections <N>  Connections to keep open 需要模拟的个并发请求连接数量
  -d, --duration    <T>  Duration of test 测试的测试时长
  -t, --threads     <N>  Number of threads to use 并发线程数量
  -s, --script      <S>  Load Lua script file  指定 Lua 脚本的路径
  -H, --header      <H>  Add header to request 指定请求带的 Header 参数
      --latency          Print latency statistics 是否打印请求延迟统计
      --timeout     <T>  Socket/request timeout 设置请求超时时间

Numeric arguments may include a SI unit (1k, 1M, 1G)
Time arguments may include a time unit (2s, 2m, 2h)

#实例1.八线程400个请求测试10分钟
wrk -t8 -c400 -d10m http://localhost:8080/index.html
#输出结果：
Making 10000000 requests to http://localhost:8080/index.html
  8 threads and 400 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency   439.75us  350.49us   7.60ms   92.88%
    Req/Sec    61.13k     8.26k   72.00k    87.54%
  10000088 requests in 19.87s, 3.42GB read
Requests/sec: 503396.23  #QPS
Transfer/sec:    176.16MB

#示例2.#实例1.八线程400个请求测试10分钟
wrk -t8 -c400 -H "accept-encoding: gzip" -d1m http://localhost:8080/index.html

# Centos 安装 autoreconf
$ yum -y install install autoconf automake libtool
$ git clone https://github.com/httperf/httperf.git
# 注意：如果从CVS仓库出口建设的源代码，而不是官方的gzip压缩的源tar文件，下面的命令必须在前面的那些之前执行
$ autoreconf -i
$ ./configure
$ make && make install

# 生成二进制程序路径 ./src/httperf
# 所有可用选项的列表可以通过指定--help选项得到（全选名称可以，只要他们保持明确的缩写）
httperf -h
Usage: httperf [-hdvV] [--add-header S] [--burst-length N] [--client N/N]
        [--close-with-reset] [--debug N] [--failure-status N]
        [--help] [--hog] [--http-version S] [--max-connections N]
        [--max-piped-calls N] [--method S] [--no-host-hdr]
        [--num-calls N] [--num-conns N] [--session-cookies]
        [--period [d|u|e]T1[,T2]|[v]T1,D1[,T2,D2]...[,Tn,Dn]
        [--print-reply [header|body]] [--print-request [header|body]]
        [--rate X] [--recv-buffer N] [--retry-on-failure] [--send-buffer N]
        [--server S|--servers file] [--server-name S] [--port N] [--uri S] [--myaddr S]
        [--think-timeout X] [--timeout X] [--verbose] [--version]
        [--wlog y|n,file] [--wsess N,N,X] [--wsesslog N,X,file]
        [--wset N,X]
        [--runtime X]
        [--use-timer-cache]
        [--periodic-stats]

# 参数解释:
--client=I/N  #指定当前客户端I，是N个客户端中的第几个。用于多个客户端发请求，希望确保每个客户端发的请求不是完全一致。一般不用指定
--server URL # 指定测试地址 域名或者IP
--port 端口  # 指定服务端口
--uri  路径  # 指定测试web端的地址
--rate 速率  # 指定请求速率
--num-conns 连接数     # 指定创建的连接数
--num-calls 调用数     # 指定每个连接发送多少请求
--send-buffer          # 指定发送http请求的最大buffer，默认为4K，一般不用指
--recv-buffer          # 指定接受http请求的最大buffer，默认为16K，一般不用指定
--timeout    # 设置超时时间

# 实例1.调用的httperf的最简单的方法
httperf --server blog.weiyigeek.top --port 443 # 默认请求参数如下即实际执行命令如下
# 实际执行: httperf --client=0/1 --server=blog.weiyigeek.top --port=443 --uri=/ --send-buffer=4096 --recv-buffer=16384 --num-conns=1 --num-calls=1
Maximum connect burst length: 0
# 结果总结：多个TCP连接是如何由客户端，有多少请求而发送的，有多少收到答复，什么总测试时间为启动。
#下面表明1个连接被启动的线，进行1个请求和收到1页的答复。它还表明总测试时间为0.435秒，意味着平均请求速率为每秒几乎正好0.5请求。
Total: connections 1 requests 1 replies 1 test-duration 0.435 s
# 用来与Web服务器通信的TCP连接的信息，连接被以每秒2.3连接的速率启动，该速度对应于周期的每个连接434.6毫秒。
Connection rate: 2.3 conn/s (434.6 ms/conn, <=1 concurrent connections)
# 成功的连接寿命的统计数据
Connection time [ms]: min 434.6 avg 434.6 max 434.6 median 434.5 stddev 0.0
# 统计是平均花费的时间建立一个TCP连接到服务器(所有成功的TCP连接机构进行计数，可能已经最终未能甚至连接)
Connection time [ms]: connect 217.3
# 每个连接中接收到答复的平均数量。与常规的HTTP/1.0，该值至多为1.0（当没有故障），但随着保持HTTP或HTTP / 1.1持久连接，这个值可以是任意高的，其表明在相同的连接被用来接收多个响应。
Connection length [replies/conn]: 1.000

# 请求速率与以字节为单位的HTTP请求的大小
Request rate: 2.3 req/s (434.6 ms/req)
Request size [B]: 71.0
# 为获得有意义的标准偏差，建议运行每个测试足够长的时间，以便获得至少30个样品，这将对应于至少150秒，即两分半钟的测试持续时间。
Reply rate [replies/s]: min 0.0 avg 0.0 max 0.0 stddev 0.0 (0 samples)
# 过了多长时间的服务器响应多久它采取收到回复信息
Reply time [ms]: response 217.3 transfer 0.0
Reply size [B]: header 161.0 content 253.0 footer 0.0 (total 414.0)
Reply status: 1xx=0 2xx=0 3xx=0 4xx=1 5xx=0

CPU time [s]: user 0.20 system 0.24 (user 45.1% system 54.9% total 100.0%)

# 以每秒千字节的平均网络吞吐量（其中一千字节是1024个字节）和以每秒兆比特（其中，a是兆位10 ^ 6位）
Net I/O: 1.1 KB/s (0.0*10^6 bps);

# 在测试期间发生的错误的统计数据
Errors: total 0 client-timo 0 socket-timo 0 connrefused 0 connreset 0
Errors: fd-unavail 0 addrunavail 0 ftab-full 0 other 0


# 实例3.设置连接数以及速率
$ httperf --server 10.20.172.196 --port 80 --num-conns 300 --rate 100 --timeout 5
# 实际执行: httperf --timeout=5 --client=0/1--server=10.0.172.196 --port=80 --uri=/index.html --rate=100 --send-buffer=4096--recv-buffer=16384 --num-conns=300 --num-calls=5 

Maximum connect burst length: 13
#• 最大并发连接数：13
Total: connections 300 requests 1475 replies 1475test-duration 6.204 s
#• 一共300个连接，1475个请求，应答了1475个，测试耗时：6.204秒
Connection rate: 48.4 conn/s (20.7 ms/conn, <=189concurrent connections)
#• 连接速率：48.4个每秒（每个连接耗时20.7 ms, 小于指定的300个并发连接）
Connection time [ms]: min 663.4 avg 1937.6 max 3808.4median 1720.5 stddev 964.7
#• 连接时间（微秒）：最小663.4，平均1937.6，最大3808.4，中位数 1720.5， 标准偏差964.7
Connection time [ms]: connect 1098.4
#• 连接时间（微秒）：连接1098.4
Connection length [replies/conn]: 5.000
#• 连接长度（应答/连接）：5.000
Request rate: 237.7 req/s (4.2 ms/req)
#• 请求速率：237.7(pqs)，每个请求4.2 ms
Request size : 79.0
#• 连接长度（应答/连接）： 79.0
Reply rate [replies/s]: min 268.8 avg 268.8 max 268.8stddev 0.0 (1 samples)
#• 响应速率（响应个数/秒）：最小268.8， 平均268.8，最大268.8，标准偏差 0.0（一个例样）
Reply time [ms]: response 80.7 transfer 87.2
#• 响应时间（微妙）：响应80.7，传输87.2
Reply size : header 283.0 content 21895.0 footer 0.0(total 22178.0)
#• 应包长度（字节）：响应头283.0 内容：21895.0 响应末端 -0.0（总共22178.0）
Reply status: 1xx=0 2xx=1475 3xx=0 4xx=0 5xx=0
#• 响应包状态： 2xx 有1475个，其他没有
CPU time [s]: user 0.45 system 5.48 (user 7.3% system88.3% total 95.6%)
#• CPU时间（秒）: 用户0.45 系统5.48（用户占了7.3% 系统占88.3% 总共95.6%）
Net I/O: 5167.4 KB/s (42.3*10^6 bps)
#• 网络I/O：5167.4 KB/s
Errors: total 5 client-timo 5 socket-timo 0 connrefused 0connreset 0
#• 错误：总数5 客户端超时5 套接字超时0 连接拒绝0 连接重置0
Errors: fd-unavail 0 addrunavail 0 ftab-full 0 other 0
#• 错误：fd不正确0 地址不正确0 ftab占满0其他0


# 实例4.以下是 gzip 格式访问的测试数据（因缓存文件以 gzip 格式保存，所以性能是最高的）
httperf --server weiyigeek.top -num-conns 2000 --add-header "accept-encoding: gzip"
#deflate (2级压缩率)格式访问的统计数据（需要从 gzip 解压，再压缩为 deflate 的数据处理）
httperf --server weiyigeek.top -num-conns 2000 --add-header "accept-encoding: deflate"
#normal 文本格式访问的统计数据
httperf --server weiyigeek.top --num-conns 2000 --add-header "accept-encoding: normal"
# 实际运行:httperf --client=0/1 -server=weiyigeek.top --port=80 --uri=/ --send-buffer=4096 --recv-buffer=16384 --add-header='accept-encoding: gzip' --num-conns=2000 --num-calls=1

# 方式1.源码安装apache后ab命令存放在apache安装目录的bin目录下
/usr/local/apache2/bin

# 方式2.通过yum的RPM包方式安装的ab命令默认存放在/usr/bin目录下
which ab
$/usr/bin/ab

# 方式3.如果不想安装apache但是又想使用ab命令情况下
yum -y install httpd-tools


# Syntax
-n 在测试会话中所执行的请求个数。默认时，仅执行一个请求。
-c 一次产生的请求个数。默认是一次一个。
-t 测试所进行的最大秒数。其内部隐含值是-n 50000，它可以使对服务器的测试限制在一个固定的总时间以内。默认时，没有时间限制。
-p 包含了需要POST的数据的文件。
-P 对一个中转代理提供BASIC认证信任。用户名和密码由一个:隔开，并以base64编码形式发送。无论服务器是否需要(即, 是否发送了401认证需求代码)，此字符串都会被发送。
-T POST数据所使用的Content-type头信息。
-v 设置显示信息的详细程度-4或更大值会显示头信息，3或更大值可以显示响应代码(404,200等),2或更大值可以显示警告和其他信息。
-V 显示版本号并退出。
-w 以HTML表的格式输出结果。默认时，它是白色背景的两列宽度的一张表。
-i 执行HEAD请求，而不是GET。
-x 设置<table>属性的字符串。
-X 对请求使用代理服务器。
-y 设置<tr>属性的字符串。
-z 设置<td>属性的字符串。
-C 对请求附加一个Cookie:行。其典型形式是name=value的一个参数对，此参数可以重复。
-H 对请求附加额外的头信息。此参数的典型形式是一个有效的头信息行，其中包含了以冒号分隔的字段和值的对(如,"Accept-Encoding:zip/zop;8bit")。
-A 对服务器提供BASIC认证信任。用户名和密码由一个:隔开，并以base64编码形式发送。无论服务器是否需要(即,是否发送了401认证需求代码)，此字符串都会被发送。
-h 显示使用方法。
-d 不显示"percentage served within XX [ms] table"的消息(为以前的版本提供支持)。
-e 产生一个以逗号分隔的(CSV)文件，其中包含了处理每个相应百分比的请求所需要(从1%到100%)的相应百分比的(以微妙为单位)时间。由于这种格式已经"二进制化"，所以比'gnuplot'格式更有用。
-g 把所有测试结果写入一个'gnuplot'或者TSV(以Tab分隔的)文件。此文件可以方便地导入到Gnuplot,IDL,Mathematica,Igor甚至Excel中。其中的第一行为标题。
-i 执行HEAD请求，而不是GET。
-k 启用HTTP KeepAlive功能，即在一个HTTP会话中执行多个请求。默认时，不启用KeepAlive功能。
-q 如果处理的请求数大于150，ab每处理大约10%或者100个请求时，会在stderr输出一个进度计数。此-q标记可以抑制这些信息。

# 实例1.ab命令常用选项参数
╭─root@test ~
╰─$ab -n 1000 -c 1000 http://10.20.172.196/
This is ApacheBench, Version 2.3 <$Revision: 1430300 $>
Benchmarking 10.20.172.196 (be patient)
Completed 100 requests
....
Completed 1000 requests
Finished 1000 requests
# 测试目标站点信息 #
#被测试的Web服务器软件名称
Server Software:        nginx/1.15.8.1
#表示请求的URL主机名
Server Hostname:        10.20.172.196
#表示被测试的Web服务器软件的监听端口
Server Port:            80
#表示请求的URL中的根绝对路径，通过该文件的后缀名
Document Path:          /
#表示HTTP响应数据的正文长度。
Document Length:        649 bytes
#表示并发用户数，我们设置的参数之一。
Concurrency Level:      1000
#表示所有这些请求被处理完成所花费的总时间。
Time taken for tests:   0.107 seconds
#表示总请求数量，我们设置的参数之一。
Complete requests:      1000
#表示失败的请求数量，这里的失败是指请求在连接服务器、发送数据等环节发生异常，以及无响应后超时的情况
Failed requests:        0
Write errors:           0
#表示所有请求的响应数据长度总和，包括每个HTTP响应数据的头信息和正文数据的长度
Total transferred:      888000 bytes
#表示所有请求的响应数据中正文数据的总和,实际是减去了Total transferred中HTTP响应数据中的头信息的长度。
HTML transferred:       649000 bytes
#[重点] QPS 吞吐率 =  Complete requests/Time taken for tests (越高，服务器性能越好)
Requests per second:    9313.50 [#/sec] (mean)
#[重点] 用户平均请求等待时间= Time token for tests/ (Complete requests/Concurrency Level)
Time per request:       107.371 [ms] (mean)
Time per request:       0.107 [ms] (mean, across all concurrent requests)
#[重点] 表示这些请求在单位时间内从服务器获取的数据长度=Total trnasferred/Time taken for tests，该统计很好的说明服务器的处理能力达到极限时，其出口宽带的需求量。
Transfer rate:          8076.55 [Kbytes/sec] received
# 每次请求平均连接时间
Connection Times (ms)
          min  mean[+/-sd] median   max
Connect:        0   29   8.1     29      42
Processing:    17   36  14.3     45      51
Waiting:        0   35  14.3     44      50
Total:         42   65   9.0     64      87

# 用于描述每个请求处理时间的分布情况
Percentage of the requests served within a certain time (ms)
  50%     64
  66%     69
  75%     71
  80%     73
  90%     78
  95%     81
  98%     84
  99%     86
 100%     87 (longest request)

#1.吞吐率（Requests per second）
服务器并发处理能力的量化描述(单位是reqs/s)，指的是在某个并发用户数下单位时间内处理的请求数。某个并发用户数下单位时间内能处理的最大请求数，称之为最大吞吐率。

记住：吞吐率是基于并发用户数的,代表了两个含义：
a、吞吐率和并发用户数相关
b、不同的并发用户数下，吞吐率一般是不同的

计算公式：总请求数/处理完成这些请求数所花费的时间，即 Request per second=Complete requests/Time taken for tests
必须要说明的是，这个数值表示当前机器的整体性能，值越大越好。

#2、并发连接数（The number of concurrent connections）
并发连接数指的是某个时刻服务器所接受的请求数目，简单的讲，就是一个会话。

#3、并发用户数（Concurrency Level）
要注意区分这个概念和并发连接数之间的区别，一个用户可能同时会产生多个会话也即连接数。在HTTP/1.1下，IE7支持两个并发连接，IE8支持6个并发连接，FireFox3支持4个并发连接，所以相应的，我们的并发用户数就得除以这个基数。

#4、用户平均请求等待时间（Time per request）
计算公式：处理完成所有请求数所花费的时间/(总请求数/并发用户数)，即：
Time per request = Time taken for tests/(Complete requests/Concurrency Level)

#5、服务器平均请求等待时间（Time per request:across all concurrent requests）
计算公式：处理完成所有请求数所花费的时间/总请求数，即：
Time taken for/testsComplete requests

可以看到，它是吞吐率的倒数。
同时，它也等于用户平均请求等待时间/并发用户数，即 Time per request/Concurrency Level