MySQL 性能压测

一、磁盘压测

  磁盘的性能直接影响 MySQL 的吞吐量。磁盘的随机 IO 性能越高,刷盘速度越快。这里磁盘压测选择 fio 进行测试,fio 可以使用命令 yum install fio 安装在 linux 上,也可以在官网下载 windows 版本,使用 fio 命令进行相关测试。

1. 安装

  linux

    安装命令:yum install fio

  windows

    下载路径:点击下载 Windows 版

2. 测试命令

  官方文档:点击查看文档

  1)命令参数

参数名称
可选值
参数解释
值解释
filename
.fio 测试脚本文件
路径
 
测试文件名称,通常选择需要测试的盘的data目录。
direct
0
禁用 DirectIO
是否使用directIO,测试过程绕过OS自带的buffer,使测试磁盘的结果更真实。Linux读写的时候,内核维护了缓存,数据先
写到缓存,后面再后台写到SSD。读的时候也优先读缓存里的数据。这样速度可以加快,但是一旦掉电缓存里的数据就没了。
所以有一种模式叫做DirectIO,跳过缓存,直接读写SSD。
1
启用 DirectIO
rw
randread
100%随机读
设置读写模式
randwrite
100%随机写
read
100%顺序读
write
100%顺序写
randrw
混合随机读写
rw
混合顺序读写
rwmixread
数值
比例值0~100
混合读写的读比例
rwmixwrite
数值
比例值0~100
混合读写的写比例
bs
数值
单位K、M、G
单次 IO 的块文件大小,比如 4k,单次 IO 的块文件大小为 4kb
bsrange
数值
给定数据块的大小范围
单次 IO 的块文件大小范围
size
数值
单位K、M、G
每个线程读写的数据文件大小,每次 IO 以给定块文件大小进行读写
numjobs
数值
 
每个job(任务)开1个线程,这里用了几,后面每个用-name指定的任务就开几个线程测试。
所以最终线程数=任务数(几个name=jobx)* numjobs
thread
   
使用pthread_create创建线程
fork
   
创建进程,进程的开销比线程要大,一般都采用thread测试。
runtime
数值
 
测试时间为1000秒,如果不写则一直将5g文件分4k每次写完为止。
ioengine
pync
指定io引擎使用pync方式
指定io引擎。libaio:Linux本地异步I/O。
请注意,Linux可能只支持具有非缓冲I/O的排队行为(设置为“direct=1”或“buffered=0”);
rbd:通过librbd直接访问CEPH Rados
libaio
指定io引擎使用libaio方式
iodepth
数值
队列的深度
在异步模式下,CPU不能一直无限的发命令到SSD。
比如SSD执行读写如果发生了卡顿,那有可能系统会一直不停的发命令,几千个,甚至几万个,这样一方面SSD扛不住,
另一方面这么多命令会很占内存,系统也要挂掉了。这样,就带来一个参数叫做队列深度。
Block
   
无需使用内核RBD驱动程序(rbd.ko)。该参数包含很多ioengine,如:libhdfs/rdma等
group_reporting
   
关于显示结果的,汇总每个进程的信息。
lockmem
数值
单位K、M、G
使用指定内存进行测试
nrfiles
数值
 
每个进程生成文件的数量。

  3)常用命令

    100%随机,100%读, 4K

    fio -direct=1 -iodepth 1 -thread -rw=randread -ioengine=psync -bs=4k -size=4G -numjobs=2 -runtime=180 -group_reporting -name=rand_100read_4k

 

    100%随机,100%写, 4K

    fio -direct=1 -iodepth 1 -thread -rw=randwrite -ioengine=psync -bs=4k -size=4G -numjobs=2 -runtime=180 -group_reporting -name=rand_100write_4k

 

    100%顺序,100%读 ,4K

    fio -direct=1 -iodepth 1 -thread -rw=read -ioengine=psync -bs=4k -size=4G -numjobs=2 -runtime=180 -group_reporting -name=sqe_100read_4k

 

    100%顺序,100%写 ,4K

    fio -direct=1 -iodepth 1 -thread -rw=write -ioengine=psync -bs=4k -size=4G -numjobs=2 -runtime=180 -group_reporting -name=sqe_100write_4k

 

    100%随机,70%读,30%写 4K

    fio -direct=1 -iodepth 1 -thread -rw=randrw -rwmixread=70 -ioengine=psync -bs=4k -size=4G -numjobs=2 -runtime=180 -group_reporting -name=randrw_70read_4k

  2)混合读写测试结果及分析

复制代码
[root@VM-12-17-centos /]# fio -direct=1 -iodepth 1 -thread -rw=randrw -rwmixread=70 -ioengine=psync -bs=4k -size=4G -numjobs=2 -runtime=180 -group_reporting -name=randrw_70read_4k
randrw_70read_4k: (g=0): rw=randrw, bs=(R) 4096B-4096B, (W) 4096B-4096B, (T) 4096B-4096B, ioengine=psync, iodepth=1
...
fio-3.7
Starting 2 threads
randrw_70read_4k: Laying out IO file (1 file / 4096MiB)
randrw_70read_4k: Laying out IO file (1 file / 4096MiB)
Jobs: 2 (f=2): [m(2)][100.0%][r=8492KiB/s,w=3707KiB/s][r=2123,w=926 IOPS][eta 00m:00s]
randrw_70read_4k: (groupid=0, jobs=2): err= 0: pid=15680: Wed Dec 29 15:45:14 2021             ---------------> job 名称 (job 组,job 个数);错误数; PID; 测试时间
   read: IOPS=2446, BW=9784KiB/s (10.0MB/s)(1720MiB/180002msec)                                --------------->    读IO:IOPS值,BW宽带;(读取大小/运行时间)
    clat (usec): min=271, max=53597, avg=506.50, stdev=328.71                                  --------------->        clat完成延迟:最小延迟,最大延迟,平均延迟,标准差
     lat (usec): min=271, max=53597, avg=507.23, stdev=328.72                                  --------------->           lat总延迟:最小延迟,最大延迟,平均延迟,标准差
    clat percentiles (usec):                                                                   --------------->        clat完成延迟占比(usec是微秒, msec是毫秒):1.00th=[330],表示在 330 微秒内完成的占比为1%
     |  1.00th=[  330],  5.00th=[  359], 10.00th=[  379], 20.00th=[  404],
     | 30.00th=[  429], 40.00th=[  449], 50.00th=[  465], 60.00th=[  486],
     | 70.00th=[  506], 80.00th=[  537], 90.00th=[  586], 95.00th=[  693],
     | 99.00th=[ 1434], 99.50th=[ 2114], 99.90th=[ 5080], 99.95th=[ 5932],
     | 99.99th=[ 8160]
   bw (  KiB/s): min= 2384, max= 6216, per=50.00%, avg=4891.91, stdev=600.69, samples=720      --------------->    基于样本的宽带统计:最小,最大,线程在job组接收总宽带占比,平均,标准差,抽样样本数     
   iops        : min=  596, max= 1554, avg=1222.97, stdev=150.18, samples=720                  --------------->               磁盘IO:最小,最大,平均,标准差,抽样样本数
  write: IOPS=1051, BW=4207KiB/s (4308kB/s)(740MiB/180002msec)
    clat (usec): min=466, max=36834, avg=710.69, stdev=401.84
     lat (usec): min=467, max=36835, avg=711.58, stdev=401.85
    clat percentiles (usec):
     |  1.00th=[  529],  5.00th=[  553], 10.00th=[  570], 20.00th=[  594],
     | 30.00th=[  611], 40.00th=[  627], 50.00th=[  644], 60.00th=[  660],
     | 70.00th=[  676], 80.00th=[  709], 90.00th=[  799], 95.00th=[ 1045],
     | 99.00th=[ 2114], 99.50th=[ 3032], 99.90th=[ 5538], 99.95th=[ 6652],
     | 99.99th=[12780]
   bw (  KiB/s): min=  856, max= 2784, per=50.00%, avg=2103.67, stdev=258.73, samples=720
   iops        : min=  214, max=  696, avg=525.91, stdev=64.68, samples=720
  lat (usec)   : 500=47.52%, 750=45.50%, 1000=3.87%                                            --------------->    总延迟占比:500微秒,750微秒,1000微秒
  lat (msec)   : 2=2.40%, 4=0.47%, 10=0.23%, 20=0.01%, 50=0.01%                                --------------->    总延迟占比:2毫秒,4毫秒,10毫秒,20毫秒,50毫秒
  lat (msec)   : 100=0.01%                                                                     --------------->    总延迟占比:100毫秒
  cpu          : usr=0.91%, sys=3.78%, ctx=629682, majf=0, minf=10                             --------------->    CPU 使用率:用户占比,系统占比,上下文切换次数,主要页面错误次数,次要页面错误数量
  IO depths    : 1=100.0%, 2=0.0%, 4=0.0%, 8=0.0%, 16=0.0%, 32=0.0%, >=64=0.0%                 --------------->    IO 队列深度分布范围占比,1=100.0%, 2=0.0% 表示深度在1 ~ 2之间占比为100%
     submit    : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%                --------------->    在一个提交调用中提交了多少个 i/o 片段数的范围占比
     complete  : 0=0.0%, 4=100.0%, 8=0.0%, 16=0.0%, 32=0.0%, 64=0.0%, >=64=0.0%                --------------->    在一个完成调用中提交了多少个 i/o 片段数的范围占比
     issued rwts: total=440292,189339,0,0 short=0,0,0,0 dropped=0,0,0,0                        --------------->    发出的读取/写入/修剪请求的数量,以及其中有多少个请求被缩短或丢弃。
     latency   : target=0, window=0, percentile=100.00%, depth=1                               --------------->    值用于 latency _ target 和相关选项

Run status group 0 (all jobs):                                                                                            --------------->    job组统计数据
   READ: bw=9784KiB/s (10.0MB/s), 9784KiB/s-9784KiB/s (10.0MB/s-10.0MB/s), io=1720MiB (1803MB), run=180002-180002msec     --------------->        读IO:组所有线程总宽带,最小宽带和最大宽带(括号内外值表示的格式不一样),组运行最小和最大时间
  WRITE: bw=4207KiB/s (4308kB/s), 4207KiB/s-4207KiB/s (4308kB/s-4308kB/s), io=740MiB (776MB), run=180002-180002msec       --------------->        写IO

Disk stats (read/write):                                                                                                  --------------->    磁盘统计数据(读/写)
  vda: ios=440396/189721, merge=0/509, ticks=215922/131407, in_queue=346805, util=99.75%                                  --------------->        所有组IO数,IO调度合并数,IO操作数,磁盘队列花费的总时间,磁盘利用率
复制代码

 

3. IO 队列深度

  在某个时刻,有N个inflight的IO请求,包括在队列中的IO请求、磁盘正在处理的IO请求。N就是队列深度。
  加大硬盘队列深度就是让硬盘不断工作,减少硬盘的空闲时间。
  加大队列深度 -> 提高利用率 -> 获得IOPS和MBPS峰值 ->注意响应时间在可接受的范围内,
  增加队列深度的办法有很多,使用异步IO,同时发起多个IO请求,相当于队列中有多个IO请求,多线程发起同步IO请求,相当于队列中有多个IO请求。
  增大应用IO大小,到达底层之后,会变成多个IO请求,相当于队列中有多个IO请求 队列深度增加了。
  队列深度增加了,IO在队列的等待时间也会增加,导致IO响应时间变大,这需要权衡。
  为何要对磁盘I/O进行并行处理呢?主要目的是提升应用程序的性能。这一点对于多物理磁盘组成的虚拟磁盘(或LUN)显得尤为重要。
  如果一次提交一个I/O,虽然响应时间较短,但系统的吞吐量很小。
  相比较而言,一次提交多个I/O既缩短了磁头移动距离(通过电梯算法),同时也能够提升IOPS。
  假如一部电梯一次只能搭乘一人,那么每个人一但乘上电梯,就能快速达到目的地(响应时间),但需要耗费较长的等待时间(队列长度)。
  因此一次向磁盘系统提交多个I/O能够平衡吞吐量和整体响应时间。

  Linux系统查看默认队列深度:

[root@VM-12-17-centos /]# lsscsi -l
[0:0:1:0]    cd/dvd  QEMU     QEMU DVD-ROM     2.5+  /dev/sr0 
  state=running queue_depth=1 scsi_level=6 type=5 device_blocked=0 timeout=30

  1)使用 iostat 查看IO

    安装命令:yum install sysstat

复制代码
[root@VM-12-17-centos /]# iostat -xd 3
Linux 3.10.0-1160.11.1.el7.x86_64 (VM-12-17-centos)     12/29/2021     _x86_64_    (4 CPU)

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vda               0.01    30.69    5.76   57.96    40.85   930.80    30.50     0.11    2.75    0.64    2.96   0.30   1.91
scd0              0.00     0.00    0.00    0.00     0.03     0.00    99.52     0.00    0.50    0.50    0.00   0.38   0.00

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vda               0.00    11.00    0.00    1.67     0.00    50.67    60.80     0.00    1.20    0.00    1.20   0.20   0.03
scd0              0.00     0.00    0.00    0.00     0.00     0.00     0.00     0.00    0.00    0.00    0.00   0.00   0.00

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vda               0.00     0.00    0.00    0.33     0.00     1.33     8.00     0.00    1.00    0.00    1.00   1.00   0.03
scd0              0.00     0.00    0.00    0.00     0.00     0.00     0.00     0.00    0.00    0.00    0.00   0.00   0.00

Device:         rrqm/s   wrqm/s     r/s     w/s    rkB/s    wkB/s avgrq-sz avgqu-sz   await r_await w_await  svctm  %util
vda               0.00     3.67    0.00    1.33     0.00    21.33    32.00     0.00    1.00    0.00    1.00   0.25   0.03
scd0              0.00     0.00    0.00    0.00     0.00     0.00     0.00     0.00    0.00    0.00    0.00   0.00   0.00
复制代码

  2)参数解释

参数名称解释
rrqms 每秒这个设备相关的读取请求有多少被Merge了(当系统调用需要读取数据的时候,VFS将请求发到各个FS,如果FS发现不同的读取请求读取的是相同Block的数据,FS会将这个请求合并Merge)
wrqm/s 每秒这个设备相关的写入请求有多少被Merge了。
rsec/s 每秒从设备读取的扇区数。
wsec/s 每秒写入设备的扇区数。
rKB/s 每秒从设备中读取的千字节数。
wKB/s 每秒写入设备的千字节数。
avgrq-sz 平均请求扇区的大小,发送给设备的请求的平均大小(扇区)。
avgqu-sz 是平均请求队列的长度。毫无疑问,队列长度越短越好,发送到设备的请求的平均队列长度。
await 每一个IO请求的处理的平均时间(单位是微秒毫秒)。这里可以理解为IO的响应时间,一般地系统IO响应时间应该低于5ms,如果大于10ms就比较大了。
这个时间包括了队列时间和服务时间,也就是说,一般情况下,await大于svctm,它们的差值越小,则说明队列时间越短,反之差值越大,队列时间越长,说明系统出了问题。
svctm 表示平均每次设备I/O操作的服务时间(以毫秒为单位)。如果svctm的值与await很接近,表示几乎没有I/O等待,磁盘性能很好。
如果await的值远高于svctm的值,则表示I/O队列等待太长,系统上运行的应用程序将变慢。
%util 在统计时间内所有处理IO时间,除以总共统计时间。例如,如果统计间隔1秒,该设备有0.8秒在处理IO,而0.2秒闲置,那么该设备的%util = 0.8/1 = 80%,
所以该参数暗示了设备的繁忙程度,一般地,如果该参数是100%表示磁盘设备已经接近满负荷运行了(当然如果是多磁盘,即使%util是100%,因为磁盘的并发能力,所以磁盘使用未必就到了瓶颈)。

参考文章:FIO 测试工具参考文章

二、数据库压测

  我们使用 sysbench 工具进行测试数据的插入和压力测试。

1. 安装

  docker 安装命令:docker pull severalnines/sysbench  

2. 启动

  docker run -itd --name sysbench {镜像ID} bash

3. 常用命令

  1)常用参数列表

命令
描述
--db-driver=mysql
mysql 数据库驱动
--time=300
300 秒测试时长
--threads=64
64 个测试线程
--report-interval=2
输出压测信息的间隔时间为 2 秒
--mysql-host=10.0.12.17
数据库地址
--mysql-port=3306
数据库端口
--mysql-user=root
数据库用户
--mysql-password=123456
数据库密码
--mysql-db=sbtest
测试库名称
--tables=24
测试库表数量
--table_size=1000000
测试表数据量
oltp_read_write
读写性能测试
oltp_read_only
只读性能测试
oltp_delete
删除性能测试
oltp_update_index
更新索引字段性能测试
oltp_update_non_index
更新非索引字段性能测试
oltp_insert
插入性能测试
oltp_write_only
写入性能测试
--db-ps-mode=disable
禁止 ps 模式
cleanup
清理表和数据
run
运行测试
prepare
构建表和测试数据

  2)常用命令模板

-- 表、数据构建

复制代码
sysbench 
--db-driver=mysql 
--time=300 
--threads=64 
--report-interval=2 
--mysql-host=10.0.12.17 
--mysql-port=3306 
--mysql-user=root 
--mysql-password=123456 
--mysql-db=sbtest 
--tables=24 
--table_size=1000000 
oltp_read_write 
--db-ps-mode=disable 
prepare
复制代码

-- 读写性能测试

复制代码
sysbench \
--db-driver=mysql \
--time=300 \
--threads=64 \
--report-interval=2 \
--mysql-host=10.0.12.17 \
--mysql-port=3306 \
--mysql-user=root \
--mysql-password=123456 \
--mysql-db=sbtest \
--tables=24 \
--table_size=1000000 \
oltp_read_write \
--db-ps-mode=disable \
run
复制代码

-- 只读性能测试

复制代码
sysbench \
--db-driver=mysql \
--time=300 \
--threads=64 \
--report-interval=2 \
--mysql-host=10.0.12.17 \
--mysql-port=3306 \
--mysql-user=root \
--mysql-password=123456 \
--mysql-db=sbtest \
--tables=24 \
--table_size=1000000 \
oltp_read_only \
--db-ps-mode=disable \
run
复制代码

-- 删除性能测试

复制代码
sysbench \
--db-driver=mysql \
--time=300 \
--threads=64 \
--report-interval=2 \
--mysql-host=10.0.12.17 \
--mysql-port=3306 \
--mysql-user=root \
--mysql-password=123456 \
--mysql-db=sbtest \
--tables=24 \
--table_size=1000000 \
oltp_delete \
--db-ps-mode=disable \
run
复制代码

-- 更新索引字段性能测试

复制代码
sysbench \
--db-driver=mysql \
--time=300 \
--threads=64 \
--report-interval=2 \
--mysql-host=10.0.12.17 \
--mysql-port=3306 \
--mysql-user=root \
--mysql-password=123456 \
--mysql-db=sbtest \
--tables=24 \
--table_size=1000000 \
oltp_update_index \
--db-ps-mode=disable \
run
复制代码

-- 插入性能测试

复制代码
sysbench \
--db-driver=mysql \
--time=300 \
--threads=64 \
--report-interval=2 \
--mysql-host=10.0.12.17 \
--mysql-port=3306 \
--mysql-user=root \
--mysql-password=123456 \
--mysql-db=sbtest \
--tables=24 \
--table_size=1000000 \
oltp_insert \
--db-ps-mode=disable \
run
复制代码

-- 写入性能测试

复制代码
sysbench \
--db-driver=mysql \
--time=300 \
--threads=64 \
--report-interval=2 \
--mysql-host=10.0.12.17 \
--mysql-port=3306 \
--mysql-user=root \
--mysql-password=123456 \
--mysql-db=sbtest \
--tables=24 \
--table_size=1000000 \
oltp_write_only \
--db-ps-mode=disable \
run
复制代码

-- cleanup 数据清理

复制代码
sysbench \
--db-driver=mysql \
--time=300 \
--threads=64 \
--report-interval=2 \
--mysql-host=10.0.12.17 \
--mysql-port=3306 \
--mysql-user=root \
--mysql-password=123456 \
--mysql-db=sbtest \
--tables=24 \
--table_size=1000000 \
oltp_read_write \
--db-ps-mode=disable \
cleanup
复制代码

4. 性能测试分析

  首先通过模板命令构建测试库和数据,使用读写命令模板对测试库进行压力测试。测试过程打印的日志如下:

复制代码
root@b432439eb3ab:/# sysbench \
mode=disable \
run
> --db-driver=mysql \
> --time=300 \
> --threads=64 \
> --report-interval=2 \
> --mysql-host=10.0.12.17 \
> --mysql-port=3306 \
> --mysql-user=root \
> --mysql-password=123456 \
> --mysql-db=sbtest \
> --tables=24 \
> --table_size=1000000 \
> oltp_read_write \
> --db-ps-mode=disable \
> run
sysbench 1.0.17 (using bundled LuaJIT 2.1.0-beta2)

Running the test with following options:
Number of threads: 64
Report intermediate results every 2 second(s)
Initializing random number generator from current time


Initializing worker threads...

Threads started!                                                                                                                  ---------------> 以上是测试初始化日志                  

[ 2s ] thds: 64 tps: 269.73 qps: 5805.83 (r/w/o: 4121.67/1112.81/571.36) lat (ms,95%): 411.96 err/s: 0.00 reconn/s: 0.00          ---------------> [测试时间] thds:线程数,tps:事务并发数,qps:查询并发数,(r/w/o:读/写/其它请求数),95%请求延迟毫秒,每秒失败,每秒重连        
[ 4s ] thds: 64 tps: 211.52 qps: 4248.81 (r/w/o: 2981.22/844.56/423.03) lat (ms,95%): 682.06 err/s: 0.00 reconn/s: 0.00
[ 6s ] thds: 64 tps: 276.53 qps: 5479.60 (r/w/o: 3826.42/1100.12/553.06) lat (ms,95%): 397.39 err/s: 0.00 reconn/s: 0.00
[ 8s ] thds: 64 tps: 269.51 qps: 5457.28 (r/w/o: 3830.69/1087.56/539.03) lat (ms,95%): 397.39 err/s: 0.00 reconn/s: 0.00
[ 10s ] thds: 64 tps: 266.50 qps: 5288.52 (r/w/o: 3699.51/1056.00/533.00) lat (ms,95%): 427.07 err/s: 0.00 reconn/s: 0.00
[ 12s ] thds: 64 tps: 258.95 qps: 5287.53 (r/w/o: 3700.82/1068.80/517.91) lat (ms,95%): 434.83 err/s: 0.00 reconn/s: 0.00
复制代码
  读写测试结果
复制代码
[ 298s ] thds: 64 tps: 303.00 qps: 6029.47 (r/w/o: 4249.48/1173.99/606.00) lat (ms,95%): 350.33 err/s: 0.00 reconn/s: 0.00
[ 300s ] thds: 64 tps: 343.48 qps: 6922.09 (r/w/o: 4829.21/1406.42/686.46) lat (ms,95%): 350.33 err/s: 0.00 reconn/s: 0.00
SQL statistics:                                                            ---------------> SQL 统计:
    queries performed:                                                     --------------->    查询执行:
        read:                            1510866                           --------------->        读:    总读请求次数
        write:                           431676                            --------------->        写:    总写请求次数
        other:                           215838                            --------------->      其它:    其它请求次数
        total:                           2158380                           --------------->        总:    所有请求次数
    transactions:                        107919 (359.52 per sec.)          --------------->  事务总数:    总事务数(测试期间每秒事务次数)
    queries:                             2158380 (7190.49 per sec.)        --------------->  请求总数:    总请求数(测试期间每秒请求次数)
    ignored errors:                      0      (0.00 per sec.)            --------------->忽略失败数:    忽略失败数(测试期间每秒失败次数)
    reconnects:                          0      (0.00 per sec.)            --------------->  重连次数:    重连次数(测试期间每秒重连次数)

General statistics:                                                        ---------------> 常规统计:
    total time:                          300.1700s                         --------------->    测试总时长
    total number of events:              107919                            --------------->    测试总事务数

Latency (ms):                                                              ---------------> 延迟(毫秒)
         min:                                   20.99                      --------------->    最低延迟
         avg:                                  177.95                      --------------->    平均延迟
         max:                                  873.35                      --------------->    最高延迟
         95th percentile:                      314.45                      --------------->    95%延迟
         sum:                             19203669.55                      --------------->    总延迟

Threads fairness:                                                          ---------------> 线程分析
    events (avg/stddev):           1686.2344/11.20                         --------------->    事务数(平均/标准差)
    execution time (avg/stddev):   300.0573/0.04                           --------------->    执行时间(平均/标准差)
复制代码
posted @   维维尼~  阅读(903)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 【.NET】调用本地 Deepseek 模型
· CSnakes vs Python.NET:高效嵌入与灵活互通的跨语言方案对比
· Plotly.NET 一个为 .NET 打造的强大开源交互式图表库
· DeepSeek “源神”启动!「GitHub 热点速览」
· 上周热点回顾(2.17-2.23)
点击右上角即可分享
微信分享提示