zoukankan      html  css  js  c++  java
  • sysbench 0.5使用手册

    注意:本文刚开始只介绍了sysbench 0.5之前的版本,在了解了sysbench 0.5之后进行了补充,大部分测试和参数都是一样的,只是sysbench 0.5 在测试数据库方面更加全面丰富。

    关注sysbench 0.5 oltp 测试的,可以直接调到最后sysbench 0.5部分。

    1. sysbench 介绍

    sysbench是一个模块化的、跨平台、多线程基准测试工具,主要用于评估测试各种不同系统参数 下的数据库负载情况。关于这个项目的详细介绍请看:http://sysbench.sourceforge.net

    它主要包括以下几种方式的测试:

    1. cpu性能
    2. 磁盘io性能
    3. 调度程序性能
    4. 内存分配及传输速度
    5. POSIX线程性能
    6. 数据库性能(OLTP基准测试)

    目前sysbench主要支持MySQL,Pgsql和Oracle这3种数据库。

    2. 安装sysbench

    基于Debain的操作系统,可以直接安装:

    sudo apt-get install sysbench

    也可以下载源码,然后自己编译安装。

    项目主页:http://sysbench.sourceforge.net/
    下载地址:http://sourceforge.net/projects/sysbench
    文档地址:http://sysbench.sourceforge.net/docs

    3. 开始测试

    3.1 CPU性能测试

    根据官网的介绍可知:CPU测试使用64位整数,测试计算素数直到某个最大值所需要的时间。

    sysbench --test=cpu --cpu-max-prime=20000 run

    输出如下:

    Maximum prime number checked in CPU test: 200000
    
    
    Test execution summary:
        total time:                          286.5703s
        total number of events:              10000
        total time taken by event execution: 285197.4463
        per-request statistics:
             min:                                109.67ms
             avg:                              28519.74ms
             max:                              36760.02ms
             approx.  95 percentile:           31751.56ms
    
    Threads fairness:
        events (avg/stddev):           9.7656/0.81
        execution time (avg/stddev):   278.5131/6.05

    我们只需要关心测试的总时间(total time)即可。

    CPU性能测试有一个需要注意的地方,上面的测试只使用了一个线程,如果在两个cpu processor不同的电脑上做比较,这是不公平的。公平的做法是指定合理的线程数,如下所示:

    sysbench --test=cpu --num-threads=`grep "processor" /proc/cpuinfo | wc -l` 
                    --cpu-max-prime=200000 run

    补充知识:

    查看CPU核数的方法

    1. 查看物理cpu个数

       grep "physical id" /proc/cpuinfo | sort -u | wc -l
    2. 查看核心数量

       grep "core id" /proc/cpuinfo | sort -u | wc -l
    3. 查看线程数量

       grep "processor" /proc/cpuinfo | sort -u | wc -l

    在sysbench的测试中,--num-threads取值为"线程数量"即可,再大的值没有什么意义,对测试结果也没有什么影响。

    3.2 线程(thread)测试

    测试线程调度器的性能。对于高负载情况下测试线程调度器的行为非常有用。

    sysbench --test=threads --num-threads=64 run  

    下面是输出结果:

    Number of threads: 64
    
    Doing thread subsystem performance test
    Thread yields per test: 1000 Locks used: 8
    Threads started!
    Done.
    
    
    Test execution summary:
        total time:                          4.5845s
        total number of events:              10000
        total time taken by event execution: 291.9995
        per-request statistics:
             min:                                  0.76ms
             avg:                                 29.20ms
             max:                                152.71ms
             approx.  95 percentile:              71.11ms
    
    Threads fairness:
        events (avg/stddev):           156.2500/5.81
        execution time (avg/stddev):   4.5625/0.02

    说实话,我也不怎么会分析这个测试结果,网上搜了半天也没有搜到,几乎所有的资料都是简单的罗列出测试结果, 也不告诉我们应该怎么分析,实在是太不照顾新手了。 我自己是通过(total time:)判断线程调度的性能的,下面是我在服务器上运行这个测试的输出:

    Number of threads: 64
    
    Doing thread subsystem performance test
    Thread yields per test: 1000 Locks used: 8
    Threads started!
    Done.
    
    
    Test execution summary:
        total time:                          2.4829s
        total number of events:              10000
        total time taken by event execution: 157.3468
        per-request statistics:
             min:                                  0.21ms
             avg:                                 15.73ms
             max:                                166.69ms
             approx.  95 percentile:             119.14ms
    
    Threads fairness:
        events (avg/stddev):           156.2500/22.25
        execution time (avg/stddev):   2.4585/0.02

    可以看到total time 比在我自己电脑上少了一半,服务器的线程调度肯定比普通电脑快多了。

    3.3 互斥锁(mutex)

    测试互斥锁的性能,方式是模拟所有线程在同一时刻并发运行,并都短暂请求互斥锁。

    sysbench --test=mutex --num-threads=16 --mutex-num=2048 
                    --mutex-locks=1000000 --mutex-loops=5000 run

    输出结果如下:

    Number of threads: 16
    
    Doing mutex performance test
    Threads started!
    Done.
    
    
    Test execution summary:
        total time:                          3.6123s
        total number of events:              16
        total time taken by event execution: 57.6636
        per-request statistics:
             min:                               3580.79ms
             avg:                               3603.98ms
             max:                               3610.94ms
             approx.  95 percentile:         10000000.00ms
    
    Threads fairness:
        events (avg/stddev):           1.0000/0.00
        execution time (avg/stddev):   3.6040/0.01

    为了不误导别人,我就不解释各参数的含义了,可以请参考这里

    3.4 内存测试

    内存测试测试了内存的连续读写性能。

    sysbench --test=memory --memory-block-size=8K --memory-total-size=2G  --num-threads=16 run

    上面这条语句指定了整个测试过程中,传输2G的数据量,每个block的大小为8K(大写的K)。 测试结果如下所示,我们最关心的是吞吐量(8030.45MB/sec),和后面的磁盘io 测试结果比较可知,内存的连续读写比磁盘的连续读写快十几倍。

    Number of threads: 16
    
    Doing memory operations speed test
    Memory block size: 8K
    
    Memory transfer size: 2048M
    
    Memory operations type: write
    Memory scope type: global
    Threads started!
    Done.
    
    Operations performed: 262144 (1027897.89 ops/sec)
    
    2048.00 MB transferred (8030.45 MB/sec)
    
    
    Test execution summary:
        total time:                          0.2550s
        total number of events:              262144
        total time taken by event execution: 3.1911
        per-request statistics:
             min:                                  0.00ms
             avg:                                  0.01ms
             max:                                 29.55ms
             approx.  95 percentile:               0.00ms
    
    Threads fairness:
        events (avg/stddev):           16384.0000/926.14
        execution time (avg/stddev):   0.1994/0.02

    3.5 文件IO基准测试

    文件IO(fileio)基准测试可以测试系统在不同IO负载下的性能。这对于比较不同的硬盘驱动器,不同的RAID 卡,不同的RAID 模式,都很有帮助。可以根据测试结果调整IO子系统。文件IO基准测试模拟了很多InnoDB 的IO特性。

    测试的第一步是准备(Prepare)阶段,生成测试用到的数据文件,生成的数据文件至少要比内存大。 如果文件中的数据能完全放入内存中,则操作系统 缓存大部分的数据,导致测试结果无法体现IO密集型的工作负载。首先通过下面的命令创建一个数据集:

    sysbench --test=fileio --file-total-size=40G prepare

    这个命令会在当前工作目录下创建测试文件,后续的运行(run)阶段将通过读写这些文件进行测试。 第二步就是运行(run)阶段,针对不同的IO 类型有不同的测试选项:

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

    下面的命令运行文件I/O混合随机读/写基准测试:

    sysbench --test=fileio --file-total-size=40G --file-test-mode=rndrw
                    --init-rng=on --max-time=300 --max-requests=0 run

    结果如下:

    Extra file open flags: 0
    128 files, 240Mb each
    30Gb total file size
    Block size 16Kb
    Number of random requests for random IO: 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
    Threads started!
    Time limit exceeded, exiting...
    Done.
    
    Operations performed:  15900 Read, 10600 Write, 33842 Other = 60342 Total
    Read 248.44Mb  Written 165.62Mb  Total transferred 414.06Mb  (1.3802Mb/sec)
       88.33 Requests/sec executed
    
    Test execution summary:
        total time:                          300.0074s
        total number of events:              26500
        total time taken by event execution: 164.1563
        per-request statistics:
             min:                                  0.01ms
             avg:                                  6.19ms
             max:                                315.51ms
             approx.  95 percentile:              15.83ms
    
    Threads fairness:
        events (avg/stddev):           26500.0000/0.00
        execution time (avg/stddev):   164.1563/0.00

    输出结果中包含了大量的信息。和IO子系统密切相关的包括每秒请求数和总吞吐量。在上述例子中, 每秒请求数是88.33 Requests/sec , 吞吐量是1.3802Mb/sec 。另外,时间信息也非常有用, 尤其是大约95%的时间分布。这些数据对于评估磁盘性能十分有用。

    测试完成以后,运行清除(cleanup)操作删除第一步生成的测试文件。

    sysbench --test=fileio --fil-total-size=30G cleanup

    3.6 oltp

    下面来看最重要也是最复杂的测试————oltp。oltp 基准测试模拟了一个简单的事物处理系统的工作负载。 下面的例子使用的是一张超过百万行记录的表,第一步是先生成这张表:

    sysbench --test=oltp --oltp-table-size=1000000 --mysql-db=test 
                    --mysql-user=root prepare

    生成数据只需要上面这条简单的命令即可。这条命令在test 数据库中新建了一个表(sbtest),并在表中插入了1000000条记录。

    对于非默认安装的mysql,需要指定连接到msyql服务器的socket(my.cnf中的socket值),如下所示:

    sysbench --test=oltp --oltp-table-size=1000000 --mysql-user=root 
    --mysql-db=test --mysql-socket=/data/ntse/lmx/sysbench/var/mysqld.sock 
    prepare

    数据加载完成以后就可以开始测试了,这个例子采用了16个线程,测试时长为720秒:

    sysbench --test=oltp --oltp-table-size=1000000 --mysql-db=test 
                    --mysql-user=root --max-time=720 --max-requests=0 
                    --num-threads=16 --oltp-test-mode=complex run

    与插入记录时一样,如果mysql是非默认安装,还需要指定--mysql-socket的值。

    Number of threads: 16
    
    Doing OLTP test.
    Running mixed OLTP test
    Using Special distribution (12 iterations,  1 pct of values are returned in 75 pct cases)
    Using "BEGIN" for starting transactions
    Using auto_inc on the id column
    Threads started!
    Time limit exceeded, exiting...
    (last message repeated 15 times)
    Done.
    
    OLTP test statistics:
        queries performed:
            read:                            26225724
            write:                           9366330
            other:                           3746532
            total:                           39338586
        transactions:                        1873266 (2601.71 per sec.)
        deadlocks:                           0      (0.00 per sec.)
        read/write requests:                 35592054 (49432.47 per sec.)
        other operations:                    3746532 (5203.42 per sec.)
    
    Test execution summary:
        total time:                          720.0136s
        total number of events:              1873266
        total time taken by event execution: 11506.8251
        per-request statistics:
             min:                                  2.37ms
             avg:                                  6.14ms
             max:                                400.48ms
             approx.  95 percentile:              14.90ms
    
    Threads fairness:
        events (avg/stddev):           117079.1250/275.62
        execution time (avg/stddev):   719.1766/0.01

    如上所示,结果中包含了相当多的信息。其中最有价值的信息如下;

    • 总的事务数
    • 每秒事务数
    • 时间统计信息(最小,平均,最大响应时间,以及95%百分比响应时间)
    • 线程公平性统计信息

    最最重要的当然是每秒事务数(2601.71 per sec.)。

    oltp 测试注意事项:

    1. --max-requests --max-requests 默认值为10000 ,如果设置了--max-requests 或者使用默认值 ,分析结果的时候主要查看运行时间(total time),一般情况下,都将--max-requests 赋值为0 ,即不限制请求数量,通过--max-time 来指定测试时长,然后查看系统的每秒事务数。

    2. --oltp-test-mode

      --oltp-test-mode用以指定测试模式,取值有(simeple,complex,nontrx),默认是complex。不同模式会执行不同的语句。 具体执行语句如下所示:

      1. Simple 这种模式只是简单的执行selec语句。

             SELECT c FROM sbtest WHERE id=N  
      2. complex(Advanced transactional) 在事务中,可能包含下列语句。

        • Point queries:

            SELECT c FROM sbtest WHERE id=N
        • Range queries:

            SELECT c FROM sbtest WHERE id BETWEEN N AND M 
        • Range SUM() queries:

            SELECT SUM(K) FROM sbtest WHERE id BETWEEN N and M
        • Range ORDER BY queries:

            SELECT c FROM sbtest WHERE id between N and M ORDER BY c
        • Range DISTINCT queries:

            SELECT DISTINCT c FROM sbtest WHERE id BETWEEN N and M ORDER BY c
        • UPDATEs on index column:

            UPDATE sbtest SET k=k+1 WHERE id=N 
        • UPDATEs on non-index column:

            UPDATE sbtest SET c=N WHERE id=M 
        • DELETE queries:

            DELETE FROM sbtest WHERE id=N 
        • INSERT queries:

            INSERT INTO sbtest VALUES (...)
      3. nontrx(Non-transactional) 这种模式包含下列SQL语句。

        • Point queries:

            SELECT pad FROM sbtest WHERE id=N
        • UPDATEs on index column:

            UPDATE sbtest SET k=k+1 WHERE id=N
        • UPDATEs on non-index column:

            UPDATE sbtest SET c=N WHERE id=M
        • DELETE queries:

            DELETE FROM sbtest WHERE id=N
        • INSERT queries:

            INSERT INTO sbtest (k, c, pad) VALUES(N, M, S)
    3. simple 与 --oltp-read-only 的区别

      simple模式和在complex模式下开启read-only选项都只包含select语句。但是 simple 模式只包含最简单的select语句,相反地,complex 模式中,如果我们开启read-only 选项,即--oltp-read-only=on,则会包含复杂的SQL语句。如:

       SELECT SUM(K) FROM sbtest WHERE id BETWEEN N and M
       SELECT DISTINCT c FROM sbtest WHERE id BETWEEN N and M ORDER BY c
    4. 测试自有的存储引擎

      测试自有的存储引擎需要告诉sysbench,这个存储引擎是否支持事务。

      如下所示:

      • 准备

          sysbench --test=oltp --mysql-table-engine=tnt --mysql-engine-trx=yes 
                          --oltp-table-size=100000 --mysql-user=root --mysql-db=test 
                          --mysql-socket=/data/ntse/lmx/sysbench/var/mysqld.sock 
                          prepare
      • 测试

          sysbench --test=oltp --mysql-table-engine=tnt --mysql-engine-trx=yes 
                          --oltp-table-size=100000 --mysql-user=root --mysql-db=test 
                          --mysql-socket=/data/ntse/lmx/sysbench/var/mysqld.sock 
                          --oltp-test-mode=complex --num-threads=16 --max-time=720 
                          --max-requests=0 run
      • 清除

          sysbench --test=oltp --mysql-table-engine=tnt --mysql-engine-trx=yes 
                          --oltp-table-size=100000 --mysql-user=root --mysql-db=test 
                          --mysql-socket=/data/ntse/lmx/sysbench/var/mysqld.sock 
                          clean

    4. sysbench 0.5

    4.1 下载安装

    1. 下载

       bzr branch lp:sysbench
    2. 安装依赖库

       sudo apt-get installlibtool
    3. 安装

       tar -zxvf sysbench.tar.gz
       cd sysbench
       ./autogen.sh
       ./configure
       make
       #make install #可选
    4. 开始测试

       cd sysbench/sysbench
       ./sysbench --test=./tests/db/oltp.lua
       --debug=yes 
       --mysql-host=localhost 
       --mysql-socket=PATH/mysqld.sock 
       --mysql-db=test 
       --mysql-table-engine=innodb 
       --mysql-engine-trx=yes 
       --mysql-user=root 
       --max-requests=0 
       --max-time=60 
       --num-threads=16 
       --oltp-table-size=100000 
       --report-interval=10 [prepare|run|cleanup]
    5. 解释

      • --debug 参数用以打印更加详细的调试信息
      • --report-interval 用以打印中间结果
      • 除了测试oltp,sysbench 0.5还可以进行插入操作的性能测试(insert.lua),选择操作的性能测试(select.lua)等。
  • 相关阅读:
    SourceInsight工具增强——AStyle(代码格式化)、PC-Lint(静态检查)
    读《Top benefits of continuous integration》有感
    授人以鱼不如授人以渔——和女儿学一起学成语
    Linux内存使用情况以及内存泄露分析之工具与方法
    常用gcc选项
    KVM内核文档阅读笔记
    关于Linux虚拟化技术KVM的科普 科普五(From 世民谈云计算)
    关于Linux虚拟化技术KVM的科普 科普四(From humjb_1983)
    关于Linux虚拟化技术KVM的科普 科普三(From OenHan)
    关于Linux虚拟化技术KVM的科普 科普二(KVM虚拟机代码揭秘)
  • 原文地址:https://www.cnblogs.com/moss_tan_jun/p/6594705.html
Copyright © 2011-2022 走看看