性能测试工具总结

http://blog.csdn.net/motred_/article/details/52268225

1.1    磁盘性能测试

dd

1.2 网络测试

1.2.1 iperf工具简介

iperf是一个网络性能测试工具。Iperf可以测试TCP和UDP带宽质量。iperf可以测量最大TCP带宽，具有多种参数和UDP特性。 Iperf可以报告带宽，延迟抖动和数据包丢失。利用Iperf这一特性，可以用来测试一些网络设备如路由器，防火墙，交换机等的性能。

 

1.2.2 iperf参数介绍

命令行选项

描述

客户端与服务器共用选项

-f, --format [bkmaBKMA]

格式化带宽数输出。支持的格式有： 
'b' = bits/sec 'B' = Bytes/sec 
'k' = Kbits/sec 'K' = KBytes/sec 
'm' = Mbits/sec 'M' = MBytes/sec 
'g' = Gbits/sec 'G' = GBytes/sec 
'a' = adaptive bits/sec 'A' = adaptive Bytes/sec 
自适应格式是kilo-和mega-二者之一。除了带宽之外的字段都输出为字节，除非指定输出的格式，默认的参数是a。 
注 意：在计算字节byte时，Kilo = 1024， Mega = 1024^2，Giga = 1024^3。通常，在网络中，Kilo = 1000， Mega = 1000^2， and Giga = 1000^3，所以，Iperf也按此来计算比特（位）。如果这些困扰了你，那么请使用-f b参数，然后亲自计算一下。

-i, --interval #

设置每次报告之间的时间间隔，单位为秒。如果设置为非零值，就会按照此时间间隔输出测试报告。默认值为零。

-l, --len #[KM]

设置读写缓冲区的长度。TCP方式默认为8KB，UDP方式默认为1470字节。

-m, --print_mss

输出TCP MSS值（通过TCP_MAXSEG支持）。MSS值一般比MTU值小40字节。通常情况

-p, --port #

设置端口，与服务器端的监听端口一致。默认是5001端口，与ttcp的一样。

-u, --udp

使用UDP方式而不是TCP方式。参看-b选项。

-w, --window #[KM]

设置套接字缓冲区为指定大小。对于TCP方式，此设置为TCP窗口大小。对于UDP方式，此设置为接受UDP数据包的缓冲区大小，限制可以接受数据包的最大值。

-B, --bind host

绑定到主机的多个地址中的一个。对于客户端来 说，这个参数设置了出栈接口。对于服务器端来说，这个参数设置入栈接口。这个参数只用于具有多网络接口的主机。在Iperf的UDP模式下，此参数用于绑 定和加入一个多播组。使用范围在224.0.0.0至239.255.255.255的多播地址。参考-T参数。

-C, --compatibility

与低版本的Iperf使用时，可以使用兼容模式。不需要两端同时使用兼容模式，但是强烈推荐两端同时使用兼容模式。某些情况下，使用某些数据流可以引起1.7版本的服务器端崩溃或引起非预期的连接尝试。

-M, --mss #[KM}

通过TCP_MAXSEG选项尝试设置TCP最大信息段的值。MSS值的大小通常是TCP/IP头减去40字节。在以太网中，MSS值 为1460字节（MTU1500字节）。许多操作系统不支持此选项。

-N, --nodelay

设置TCP无延迟选项，禁用Nagle's运算法则。通常情况此选项对于交互程序，例如telnet，是禁用的。

-V (from v1.6 or higher)

绑定一个IPv6地址。 
服务端：$ iperf -s –V 
客户端：$ iperf -c <Server IPv6 Address> -V 
注意：在1.6.3或更高版本中，指定IPv6地址不需要使用-B参数绑定，在1.6之前的版本则需要。在大多数操作系统中，将响应IPv4客户端映射的IPv4地址。

服务器端专用选项

-s, --server

Iperf服务器模式

-D (v1.2或更高版本)

Unix平台下Iperf作为后台守护进程运行。在Win32平台下，Iperf将作为服务运行。

-R(v1.2或更高版本，仅用于Windows)

卸载Iperf服务（如果它在运行）。

-o(v1.2或更高版本，仅用于Windows)

重定向输出到指定文件

-c, --client host

如果Iperf运行在服务器模式，并且用-c参数指定一个主机，那么Iperf将只接受指定主机的连接。此参数不能工作于UDP模式。

-P, --parallel #

服务器关闭之前保持的连接数。默认是0，这意味着永远接受连接。

客户端专用选项

-b, --bandwidth #[KM]

UDP模式使用的带宽，单位bits/sec。此选项与-u选项相关。默认值是1 Mbit/sec。

-c, --client host

运行Iperf的客户端模式，连接到指定的Iperf服务器端。

-d, --dualtest

运行双测试模式。这将使服务器端反向连接到客户端，使用-L 参数中指定的端口（或默认使用客户端连接到服务器端的端口）。这些在操作的同时就立即完成了。如果你想要一个交互的测试，请尝试-r参数。

-n, --num #[KM]

传送的缓冲器数量。通常情况，Iperf按照10秒钟发送数据。-n参数跨越此限制，按照指定次数发送指定长度的数据，而不论该操作耗费多少时间。参考-l与-t选项。

-r, --tradeoff

往复测试模式。当客户端到服务器端的测试结束时，服务器端通过-l选项指定的端口（或默认为客户端连接到服务器端的端口），反向连接至客户端。当客户端连接终止时，反向连接随即开始。如果需要同时进行双向测试，请尝试-d参数。

-t, --time #

设置传输的总时间。Iperf在指定的时间内，重复的发送指定长度的数据包。默认是10秒钟。参考-l与-n选项。

-L, --listenport #

指定服务端反向连接到客户端时使用的端口。默认使用客户端连接至服务端的端口。

-P, --parallel #

线程数。指定客户端与服务端之间使用的线程数。默认是1线程。需要客户端与服务器端同时使用此参数。

-S, --tos #

出栈数据包的服务类型。许多路由器忽略TOS字段。你可以指定这个值，使用以"0x"开始的16进制数，或以"0"开始的8进制数或10进制数。 
例如，16进制'0x10' = 8进制'020' = 十进制'16'。TOS值1349就是： 
IPTOS_LOWDELAY minimize delay 0x10 
IPTOS_THROUGHPUT maximize throughput 0x08 
IPTOS_RELIABILITY maximize reliability 0x04 
IPTOS_LOWCOST minimize cost 0x02

-T, --ttl #

出栈多播数据包的TTL值。这本质上就是数据通过路由器的跳数。默认是1，链接本地。

-F (from v1.2 or higher)

使用特定的数据流测量带宽，例如指定的文件。 
$ iperf -c <server address> -F <file-name>

-I (from v1.2 or higher)

与-F一样，由标准输入输出文件输入数据。

杂项

-h, --help

显示命令行参考并退出 。

-v, --version

显示版本信息和编译信息并退出。

2.    Ceph自带测试工具

http://tracker.ceph.com/projects/ceph/wiki/Benchmark_Ceph_Cluster_Performance

2.1集群基准性能测试

1. rados bench

命令行格式：rados bench seconds mode [ -b objsize ] [ -t threads ]

参数说明：mode 可以是 write 、 seq 或 rand 。 seq 和 rand 分别是顺序读、随机读压力测试，默认对象尺寸是 4 MB ，默认模拟线程数为 16 。 注：-b objsize 仅适用于 write 模式。

例：

rados bench -p pool 30 write -b blocksize --no-cleanup

rados bench -p scbench 30 seq
rados bench -p scbench 30 rand

2. rados load-gen

A bit similar to the rados bench, rados load-gen is another interesting tool provided by Ceph, which runs out-of-the-box. As the name suggests, the rados load-gen tool can be used to generate load on a Ceph cluster and can be useful to simulate high load scenarios.

命令行格式及参数说明：

rados -p <pool-name> load-gen--num-objects: The total number of objects--min-object-size: The minimum object size in bytes--max-object-size: The maximum object size in bytes--min-ops: The minimum number of operations--max-ops: The maximum number of operations--min-op-len: The minimum operation length--max-op-len: The maximum operation length--max-backlog: The maximum backlog (in MB)--percent: The percentage of read operations--target-throughput: The target throughput (in MB)--run-length: The total run time in second

2.2 块设备基准性能测试

命令行格式：rados bench-write 

[–io-size size-in-B/K/M/G/T] [–io-threads num-ios-in-flight]

[–io-total total-size-to-write-in-B/K/M/G/T]

[–io-pattern seq | rand] image-spec\

参数说明：

--io-size: The write size in bytes; the default is 4M
--io-threads: The number of threads; the default is 16
--io-total: The total bytes to write; the default is 1024M
--io-pattern <seq|rand>: This is the write pattern, the default is seq

 

例：

rbd bench-write image --pool=pool --io-size size --io-pattern seq

rbd bench-write image --pool=pool --io-size size --io-pattern rand

 

3. fio使用说明(块设备测试)

3.1 fio简介

fio 是一个 开源的硬件I/O压力测试工具，主要是用来测试磁盘/SSD的io性能，也可测试cpu，nic的io性能。它可以支持13种不同的I/O引擎，包括：sync, mmap, libaio, posixaio, SG v3, splice, network, syslet,guasi, solarisaio, I/O priorities (针对新的Linux内核),rate I/O, forked or threaded jobs等。不同引擎的具体含义，可以参看fio的说明文档（安装后可以通过man fio查看）。Fio支持以下功能：

       1）支持十几种存储引擎，可以自定义

       2）自带做图工具，调用gnuplot做图

3）支持几乎所有的存储描述参数

       4）大量对CPU，内存，进程/线程，文件，IO特性的配置

       5）压缩，trace回放等

 

3.2 fio简单用法

顺序读：
fio -filename=/dev/rbd0 -direct=1 -iodepth 32 -thread -rw=read -ioengine=libaio-bs=4K -numjobs=1 -runtime=1800 -ramp_tim=60 -norandommap -group_reporting-name=cephtest

随机读：
fio -filename=/dev/rbd0 -direct=1 -iodepth 32 -thread -rw=randread-ioengine=libaio -bs=4K -numjobs=1 -runtime=1800 -ramp_tim=60 -norandommap-group_reporting -name=cephtest

顺序写：
fio -filename=/dev/rbd0 -direct=1 -iodepth 32 -thread -rw=write-ioengine=libaio -bs=4K -numjobs=1 -runtime=1800 -ramp_tim=60 -norandommap-group_reporting -name=cephtest

随机写：

 fio -filename=/dev/rbd0 -direct=1 -iodepth 32 -thread-rw=randwrite -ioengine=libaio -bs=4K -numjobs=1 -runtime=1800 -ramp_tim=60-norandommap -group_reporting -name=cephtest

3.3 fio参数说明

参数类型：

str 字符串

time时间（int)

int 整数

bool

irange 整数范围

float_list 符点数列

3.2.1 一个job包含的基本的参数

1）IO类型

向文件发起的IO类型。

<1> readwrite=str,rw=str

read 顺序读

write 顺序写

randwrite 随机写

randread 随机读

rw,readwrite 顺序混合读写

randrw 随机混合读写

[参数备注]

对于混合io类型，混认是50%的读，50%的写，对于特定的io类型，因为速度可能不同，结果可能会有稍有偏差.

通过在在str之后加“:<nr>”可以配置在执行一下获取offset操作之前要执行的IO次数。For a random read, it would lik ‘rw=randread:8′ for passing in an offset modifier with a value of 8.如果后缀用于顺序IO类型的话，，那么将在每次IO之后，将这个值加到产生的offset之后。e.g. rw=write:4k每次写之后将会跳过4K。它将顺序的IO转化为带有洞的顺序IO。参考‘rw_sequencer’选项。

<2>rw_sequencer=str

如果rw=<str>后有offset修饰的话，这个选项可以控制这个数字<nr>如何修饰产生的IO offset.可以接收的值是：

sequential 产生顺序的offset

identical 产生相同的offset

[参数备注]

‘sequential’仅用于随机IO。通常情况下，fio在每次IO之后，将会生成一个新的随机IO。e.g.rw=randread:8，将会在每8次IO之后执行seek，而不是每次IO之后。顺序IO已经是顺序的，再设置为‘sequential’将不会产生任何不同。‘identical’会产生同‘sequential’相似的行为，只是它会连续产生8次相同的offset，然后生成一个新的offset.

2）block size

产生的IO单元的大小，可以是一个孤立的值，也可以是一个范围。

<1>blocksize=int,bs=int

单次IO的block size,默认为4k。如果是单个值的话，将会对读写都生效。如果是一个逗号，再跟一个int值的话，则是仅对于写有效。也就是说，格式可以是bs=read_end_write或是bs=read,write。e.g. bs=4k,8k读使用4k的块，写使用8k的块。e.g.bs=,8k将使得写采用8k的块，读采用默认的值。

3）IO size

将会读/写多少数据

<1>size=int

这个job IO总共要传输的数据的大小。FIO将会执行到所有的数据传输完成，除非设定了运行时间（‘runtime’选项）。除非有特定的‘nrfiles’选项和‘filesize’选项被设置，fio将会在job定义的文件中平分这个大小。如果这个值不设置的话，fio将会使用这个文件或设备的总大小。如果这些文件不存在的话，size选项一定要给出。也可以给出一个1到100的百分比。e.g. size=20%，fio将会使用给定的文件或设备的20%的空间。

4）IO引擎

发起IO的方式。

<1>ioengine=str

定义job向文件发起IO的方式

sync 基本的read,write.lseek用来作定位

psync 基本的pread,pwrite

vsync 基本的readv,writev

libaio Linux专有的异步IO。Linux仅支持非buffered IO的队列行为。

posixaio glibc posix异步IO

solarisaio solaris独有的异步IO

windowsaio windows独有的异步IO

mmap 文件通过内存映射到用户空间，使用memcpy写入和读出数据

splice 使用splice和vmsplice在用户空间和内核之间传输数据

syslet-rw 使用syslet 系统调用来构造普通的read/write异步IO

sg SCSI generic sg v3 io.可以是使用SG_IO ioctl来同步，或是目标是一个sg字符设备，我们使用read和write执行异步IO

null 不传输任何数据，只是伪装成这样。主要用于训练使用fio，或是基本debug/test的目的。

net 根据给定的host:port通过网络传输数据。根据具体的协议，hostname,port,listen,filename这些选项将被用来说明建立哪种连接，协议选项将决定哪种协议被使用。

netsplice 像net，但是使用splic/vmsplice来映射数据和发送/接收数据。

cpuio 不传输任何的数据，但是要根据cpuload=和cpucycle=选项占用CPU周期.e.g. cpuload=85将使用job不做任何的实际IO，但要占用85%的CPU周期。在SMP机器上，使用numjobs=<no_of_cpu>来获取需要的CPU，因为cpuload仅会载入单个CPU，然后占用需要的比例。

guasi GUASI IO引擎是一般的用于异步IO的用户空间异步系统调用接

rdma RDMA I/O引擎支持RDMA内存语义（RDMA_WRITE/RDMA_READ）和通道主义(Send/Recv）用于InfiniBand,RoCE和iWARP协议

external 指明要调用一个外部的IO引擎（二进制文件）。e.g. ioengine=external:/tmp/foo.o将载入/tmp下的foo.o这个IO引擎

5）IO depth

如果IO引擎是异步的，这个指定我们需要保持的队列深度

<1>iodepth=int

加于文件之上的保持的IO单元。默认对于每个文件来说是1，可以设置一个更大的值来提供并发度。iodepth大于1不会影响同步IO引擎（除非verify_async这个选项被设置）。even async engines may impose OS restrictions causing the desired depth not to be achieved.这会在Linux使用libaio并且设置direct=1的时候发生，因为buffered io在OS中不是异步的。在外部通过类似于iostat这些工具来观察队列深度来保证这个IO队列深度是我们想要的。这个可以参考褚霸的博客http://blog.yufeng.info/archives/2104

6）IO type

<1>direct=bool

true,则标明采用non-buffered io.同O_DIRECT效果一样。ZFS和Solaris不支持direct io，在windows同步IO引擎不支持direct io

<2>buffered=bool

true,则标明采用buffered io。是direct的反义词，默认是true

7）Num files

负载将分发到几个文件之中

<1>nrfiles=int

用于这个job的文件数目,默认为1

<2>openfiles=int

在同一时间可以同时打开的文件数目，默认同nrfiles相等，可以设置小一些，来限制同时打开的文件数目。

8）Num threads

<1>numjobs=int

创建特定数目的job副本。可能是创建大量的线程/进程来执行同一件事。我们将这样一系列的job，看作一个特定的group

3.2.2 详细参数

<1>name=str

job名，用于输出信息用的名字。如果不设置的话，fio输出信息时将采用job name，如果设置的话，将用设置的名字。在命令行中，这个参数有特殊的作用，标明一个新job的开始。

<2>description=str

job的说明信息,在job运行的时候不起作用，只是在输出文件描述信息的时候才起作用。

<3>directory=str

使用的文件的路径前缀，默认是./

<4>filename=str

一般情况下，fio会根据job名，线程号，文件名来产生一个文件名。如果，想在多个job之间共享同一个文件的话，可以设定一个名字来代替默认的名字.如果ioengine是‘net’的话，文件名则是以这种格式=host,port,protocol.如果ioengine是基于文件的话，可以通过‘:’分割来设定一系列的文件。e.g. filename=/dev/sda:/dev/sdb 希望job打开/dev/sda和/dev/sdb作为两个工作文件。

<5>opendir=str

让fio递归的添加目录下和子目录下的所有文件。

<6>lockfile=str

fio在文件上执行IO之前默认是不锁文件的，这样的话，当有多个线程在此文件上执行IO的话，会造成结果的不一致。这个选项可以用来共享文件的负载，支持的锁类型：

none 默认不使用锁

exclusive 排它锁

readwrite 读写锁

在后面可以加一个数字后缀，如果设置的话，每一个线程将会执行这个数字指定的IO后才会放弃锁，因为锁的开销是比较大的，所以这种方式可以加速IO。

<7>kb_base=int

size换算单位，1000/1024,默认为1024

<8>randrepeat=bool

对于随机IO负载，配置生成器的种子，使得路径是可以预估的，使得每次重复执行生成的序列是一样的。

<9>use_os_rand=bool

fio可以使用操作系统的随机数产生器，也可以使用fio内部的随机数产生器（基于tausworthe），默认是采用fio内部的产生器,质量更数，速度更快。

<7>fallocate=str

如何准备测试文件

none 不执行预分配空间

posix 通过posix_fallocate()预分配空间

keep 通过fallocate()（设置FALLOC_FL_KEEP_SIZE）预分配空间

0 none的别名,出于兼容性

1 posix的别名，出于兼容性

并不是在所有的平台上都有效，‘keep’仅在linux上有效，ZFS不支持。默认为‘posix’

<8>fadvise_hint=bool

默认fio将使用fadvise()来告知内核fio要产生的IO类型，如果不想告诉kernel来执行一些特定的IO类型的话，可行关闭这个选项。如果设置的话，fio将使用POSIX_FADV_SEWUENTIAL来作顺序IO，使用POSIX_FADV_RANDOM来做随机IO

<9>filesize=int

单个文件的大小，可以是一个范围，在这种情况下，fio将会在一个范围内选择一个大小来决定单个文件大小，如果没有设置的话，所有的文件将会是同样的大小。

<10>fill_device=bool,fill_fs=bool

填满空间直到达到终止条件ENOSPC，只对顺序写有意义。对于读负载，首行要填满挂载点，然后再启动IO，对于裸设备结点，这个设置则没有什么意义，因为，它的大小已被被文件系统知道了，此外写的超出文件将不会返回ENOSPC.

<11>blockalign=int,ba=int

配置随机io的对齐边界。默认是与blocksize的配置一致，对于direct_io，最小为512b,因为它与依赖的硬件块大小，对于使用文件的随机map来说，这个选项不起作用。

<14>blocksize_range=irange,bsrange=irange

不再采用单一的块大小，而是定义一个范围，fio将采用混合io块大小.IO单元大小一般是给定最小值的备数。同时应用于读写，当然也可以通过‘,’来隔开分别配置读写。

<15>bssplit=str

可以更为精确的控制产生的block size.这个选项可以用来定义各个块大小所占的权重.格式是

bssplit=blocksize/percentage;blocksize/percentage

bssplit=4k/10:64k/50;32k/40

产生的这样的负载：50% 64k的块，10% 4k的块, 40% 32k的块

可以分别为读和写来设置

e.g. bssplit=2k/50:4k/50,4k/90:8k/10

产生这样的负载：读（50% 64k的块，50% 4k的块），写（90% 4k的块, 10% 8k的块）

<16>blocksize_unaligned,bs_unaligned

如果这个选项被设置的，在bsrange范围内的大小都可以产生，这个选项对于direct io没有作用，因为对于direct io至少需要扇区对齐

<17>zero_buffers

如果这个选项设置的话，IO buffer全部位将被初始为0,如果没有置位的话，将会是随机数.

<18>refill_buffers

如果这个选项设置的话，fio将在每次submit之后都会将重新填满IO buffer,默认都会在初始是填满，以后重复利用。这个选项只有在zero_buffers没有设置的话，这个选项才有作用。

<19>scramble_buffer=bool

如果refilee_buffers成本太高的话，但是负载要求不使用重复数据块，设置这个选项的话，可以轻微的改动IO buffer内容，这种方法骗不过聪明的块压缩算法，但是可以骗过一些简单的算法。

<20>buffer_compress_percentage=int

如果这个设置的话，fio将会尝试提供可以压缩到特定级别的Buffer内容。FIO是能完提供混合的0和随机数来实现的。Note that this is per block size unit, for file/disk wide compression level that matches this setting, you’ll also want to set refill_buffers.

<21>buffer_compress_chunk=int

See buffer_compress_percentage. This setting allows fio to manage how big the ranges of random data and zeroed data is. Without this set, fio will provide buffer_compress_percentage of blocksize random data, followed by the remaining zeroed. With this set to some chunk size smaller than the block size, fio can alternate random and zeroed data throughout the IO buffer.

<22>file_service_type=str

fio切换job时，如何选择文件，支持下面的选项

random 随机选择一个文件 

roundrobin 循环使用打开的文件，默认

sequential 完成一个文件后，再移动到下一个文件

这个选项可以加后缀数字，标明切换到下一个新的频繁程度。

e.g. random:4 每4次IO后，将会切换到一下随机的文件

<23>iodepth_batch_submit=int,iodepth_batch=int

这个定义了一次性提交几个IO，默认是1，意味着一旦准备好就提交IO，这个选项可以用来一次性批量提交IO

<24>iodepth_batch_complete=int

这个选项定义了一次取回多少个IO，如果定义为1的话，意味着我们将向内核请求最小为1个IO.The IO retrieval will go on until we hit the limit set by iodetph_low.If this variable is set to 0, then fi will always check for completed events before quuing more IO.This helps reduce IO latency, at the cost of more retrieval sysstem calls.

<25>iodepth_low=int

这个水位标志标明什么时候开始重新填充这个队列，默认是同iodepth是一样的，意味着，每时每刻都在尝试填满这个队列。如果iodepth设置为16，而iodepth设置为4的话，那么fio将等到depth下降到4才开始重新填充

<26>offset=int

在文件特定的偏移开始读数据,在这个offset之前的数据将不会被使用，有效的文件大小=real_size-offset

<27>offset_increment=int

如果这个选项被设置的话，实际的offset=offset+offset_increment * thread_number,线程号是从0开始的一个计数器，对于每一个job来说是递增的。这个选项对于几个job同时并行在不交界的地方操作一个文件是有用的。

<28>fsync=int

如果写一个文件的话，每n次IO传输完block后，都会进行一次同步脏数据的操作。

e.g. fsync=int

fio每32次写之后，同步一次文件。如果采用non-buffered io，不需要使用sync同步文件

对于sg io引擎的话，可以在任何情况下同步磁盘cache.

<29>fdatasync=int

同fsync，但是采用fdatasync()来同步数据，但不同步元数据

<30>sync_file_range=str:val

对于每‘val’个写操作，将执行sync_file_range()。FIO将跟踪从上次sync_file_range()调用之扣的写范围，‘str’可以是以下的选择

wait_before SYNC_FILE_RANGE_WAIT_BEFORE

write SYNC_FILE_RANGE_WRITE

wait_after SYNC_FILE_RANGE_WAIT_AFTER

e.g.sync_file_range=wait_before,write:8,fio将在每8次写后使用SYNC_FILE_RANGE_WAIT_BEFORE|SYNC_FILE_RANGE_WRITE

<31>overwrite=bool

如果是true的话，写一个文件的话，将会覆盖已经存在的数据。如果文件不存在的话，它将会在写阶段开始的时候创建这个文件。

<32>end_fsync=bool

如果是true的话，当job退出的话，fsync将会同步文件内容

<33>fsync_on_close=bool

如果是true的话，关闭时，fio将会同步脏文件，不同于end_fsync的时，它将会在每个文件关闭时都会发生，而不是只在job结束时。

<34>rwmixread=int

混合读写中，读占的百分比

<35>rwmixwrite=int

混合读写中，写占的百分比；如果rwmixread=int和rwmixwrite=int同时使用的话并且相加不等于100%的话，第二个值将会覆盖第一个值。这可能要干扰比例的设定,如果要求fio来限制读和写到一定的比率。在果在这种情况下，那么分布会的有点的不同。

<36>norandommap

一般情况下，fio在做随机IO时，将会覆盖文件的每一个block.如果这个选项设置的话，fio将只是获取一个新的随机offset,而不会查询过去的历史。这意味着一些块可能没有读或写，一些块可能要读/写很多次。在个选项与verify=互斥，并只有多个块大小（bsrange=）正在使用，因为fio只会记录完整的块的重写。

<37>softrandommap=bool

See norandommap. If fio runs with the random block map enabled and it fails to allocate the map, if this option is set it will continue without a random block map. As coverage will not be as complete as with random maps, this option is disabled by default.

<38>nice=int

根据给定的nice值来运行这个job

<39>prio=int

设置job的优先级，linux将这个值限制在0-7之间，0是最高的。

<40>prioclass=int

设置优先级等级。

<41>thinktime=int

上一个IO完成之后，拖延x毫秒，然后跳到下一个。可以用来访真应用进行的处理。

<42>thinktime_spin=int

只有在thinktime设置时才有效，在为了sleep完thinktime规定的时间之前，假装花费CPU时间来做一些与数据接收有关的事情。

<43>thinktime_blocks

只有在thinktime设置时才有效，控制在等等‘thinktime’的时间内产生多少个block，如果没有设置的话，这个值将是1，每次block后，都会将等待‘thinktime’us。

<44>rate=int

限制job的带宽。

e.g.rate=500k,限制读和写到500k/s

e.g.rate=1m,500k,限制读到1MB/s，限制写到500KB/s

e.g.rate=,500k , 限制写到500kb/s

e.g.rate=500k, 限制读到500KB/s

<45>ratemin=int

告诉fio尽最在能力来保证这个最小的带宽，如果不能满足这个需要，将会导致程序退出。

<46>rate_iops=int

将带宽限制到固定数目的IOPS，基本上同rate一样，只是独立于带宽，如果job是指定了一个block size范围，而不是一个固定的值的话，最小blocksize将会作为标准。

<47>rate_iops_min=int

如果fio达不到这个IOPS的话，将会导致job退出。

<48>ratecycle=int

几个毫秒内的平均带宽。用于‘rate’和‘ratemin’

<49>cpumask=int

设置job使用的CPU.给出的参数是一个掩码来设置job可以运行的CPU。所以，如果要允许CPU在1和5上的话，可以通过10进制数来设置（1<<1 | 1<<5），或是34。查看sched_setaffinity的man page。它可能并不是支持所有的操作系统和kernel版本。This option doesn’t work well for a higher CPU count than what you can store in an integer mask, so it can only control cpus 1-32. For boxes with larger CPU counts, use cpus_allowed.

<50>cpus_allowed=str

功能同cpumask一样，但是允许通过一段文本来设置允许的CPU。e.g.上面的例子可是这样写cpus_allowed=1,5。这个选项允许设置一个CPU范围，如cpus_allowed=1,5,8-15

<51>startdelay=time

fio启动几秒后再启动job。只有在job文件包含几个jobs时才有效，是为了将某个job延时几秒后执行。

<52>runtime=time

控制fio在执行设定的时间后退出执行。很难来控制单个job的运行时间，所以这个参数是用来控制总的运行时间。

<53>time_based

如果设置的话，即使file已被完全读写或写完，也要执行完runtime规定的时间。它是通过循环执行相同的负载来实现的。

<54>ramp_tim=time

设定在记录任何性能信息之前要运行特定负载的时间。这个用来等性能稳定后，再记录日志结果，因此可以减少生成稳定的结果需要的运行时间。Note that the ramp_time is considered lead in time for a job, thus it will increase the total runtime if a special timeout or runtime is specified.

<55>invalidate=bool

Invalidate the buffer/page cache parts for this file prior to starting io. Defaults to true.

<56>sync=bool

使用sync来进行buffered写。对于多数引擎，这意味着使用O_SYNC

<57>iomem=str,mem=str

fio可以使用各种各样的类型的内存用来io单元buffer.

malloc 使用malloc()

shm 使用共享内存.通过shmget()分配

shmhuge 同shm一样，可以使用huge pages

mmap 使用mmap。可以是匿名内存，或是支持的文件，如果一个文件名在选项后面设置的话，格式是mem=mmap:/path/to/file

mmaphuge 使用mmapped huge file.在mmaphuge扣面添加文件名，alamem=mmaphuge:/hugetlbfs/file

分配的区域是由job允许的最大block size * io 队列的长度。对于shmhuge和mmaphuge，系统应该有空闲的页来分配。这个可以通过检测和设置reading/writing /proc/sys/vm/nr_hugepages来实现（linux）。FIO假设一个huge page是4MB。所以要计算对于一个JOB文件需要的Huge page数量，加上所有jobs的队列长度再乘以最大块大小，然后除以每个huge page的大小。可以通过查看/proc/meminfo来看huge pages的大小。如果通过设置nr_hugepages=0来使得不允许分配huge pages，使用mmaphug或是shmhuge将会失败。

mmaphuge需要挂载hugelbfs而且要指定文件的位置，所以如果要挂载在/huge下的话，可以使用mem=mmaphuge:/huge/somefile

<58>iomem_align=int

标明IO内存缓冲的内存对齐方式。Note that the given alignment is applied to the first IO unit buffer, if using iodepth the alignment of the following buffers are given by the bs used. In other words, if using a bs that is a multiple of the page sized in the system, all buffers will be aligned to this value. If using a bs that is not page aligned, the alignment of subsequent IO memory buffers is the sum of the iomem_align and bs used.

<59>hugepage-size=int

设置huge page的大小。至少要与系统的设定相等。默认是4MB，必然是MB的倍数，所以用hugepage-size=Xm是用来避免出现不是2的整数次方的情况。

<60>exitall

当一个job退出时，会终止运行其它的job，默认是等待所有的job都完成，FIO才退出，但有时候这并不是我们想要的。

<61>bwavgtime=int

在给定时间内的平均带宽。值是以毫秒为单位的

<62>iopsavgtime=int

在给定时间内的平均IOPS，值是以毫秒为单位的

<63>create_serialize=bool

job将会串行化创建job,这将会用来避免数据文件的交叉，这依赖于文件系统和系统的CPU数

<64>create_fsync=bool

创建后同步数据文件，这是默认的值

<65>create_on_open=bool

不会为IO预先创建文件，只是在要向文件发起IO的时候，才创建open()

<66>create_only=bool

如果设置为true的话，fio将只运行到job的配置阶段。如果文件需要部署或是更新的磁盘的话，只有上面的事才会做，实际的文件内容并没有执行。

<67>pre_read=bool

如果这个选项被设置的话，在执行IO操作之前，文件将会被预读到内存.这会删除‘invalidate’标志，因为预读数据，然后丢弃cache中的数据的话，是没有意义的。这只是对可以seek的IO引擎有效，因为这允许读相同的数据多次。因此对于network和splice不起作用。

<68>unlink=bool

完成后将删除job产生的文件。默认是not,如果设置为true的话，将会花很多时间重复创建这些文件。

<69>loops=int

重复运行某个job多次，默认是1

<70>do_verify=bool

写完成后，执行一个校验的阶段，只有当verify设置的时候才有效。默认是true

<80>verify=str

写一个文件时，每次执行完一个job扣，fio可以检验文件内容.允许的校验算法是：

md5,crc64,crc32c,crc32c-intel,crc32,crc16,crc7,sha512,sha256,sha1,meta,null.

这个选项可以用来执行重复的burn-in测试，来保证写数据已经正确的读回。如果是read或随机读，fio将假设它将会检验先前写的文件。如果是各种格式的写，verify将会是对新写入的数据进行校验。

<81>verifysort=bool

如果设置的话，fio will sort written verify blocks when it deems it faster to read them back in a sorted manner. This is often the case when overwriting an existing file, since the blocks are already laid out in the file system. You can ignore this option unless doing huge amounts of really fast IO where the red-black tree sorting CPU time becomes significant.

<82>verify_offset=int

Swap the verification header with data somewhere else in the block before writing. Its swapped back before verifying.

<83>verify_interval=int

Write the verification header at a finer granularity than the blocksize. It will be written for chunks the size of header_interval. blocksize should divide this evenly

<84>verify_pattern=str

<85>verify_fatal=bool

<86>verify_dump=bool

<87>verify_async=int

<88>verify_async_cpus=str

<89>verify_backlog=int

<90>verify_backlog_batch=int

<91>stonewall,wait_for_previous

等待先前的job执行完成后，再启动一个新的job。可以用来在job文件中加入串行化的点。stone wall也用来启动一个新reporting group

<92>new_group

启动一个新的reporting group。如果这个选项没有设置的话，在job文件中的job将属于相同的reporting group，除非通过stonewall隔开

<93>group_reporting

如果‘numjobs’设置的话，我们感兴趣的可能是打印group的统计值，而不是一个单独的job。这在‘numjobs’的值很大时，一般是设置为true的，可以减少输出的信息量。如果‘group_reporting’设置的话，fio将会显示最终的per-groupreport而不是每一个job都会显示

<94>thread

fio默认会使用fork()创建job，如果这个选项设置的话，fio将使用pthread_create来创建线程

<95>zonesize=int

将一个文件分为设定的大小的zone

<96>zoneskip=int

跳过这个zone的数据都被读完后，会跳过设定数目的zone.

<97>write_iolog=str

将IO模式写到一个指定的文件中。为每一个job指定一个单独的文件，否则iolog将会分散的的，文件将会冲突。

<98>read_iolog=str

将开一个指定的文件，回复里面的日志。这可以用来存储一个负载，并进行重放。给出的iolog也可以是一个二进制文件，允许fio来重放通过blktrace获取的负载。

<99>replay_no_stall

当使用read_iolog重放I/O时，默认是尝试遵守这个时间戳，在每个IOPS之前会有适当的延迟。通过设置这个属性，将不会遵守这个时间戳，会根据期望的顺序，尝试回复，越快越好。结果就是相同类型的IO，但是不同的时间

<101>replay_redirect

当使用read_iolog回放IO时，默认的行为是在每一个IOP来源的major/minor设备上回放IOPS。这在有些情况是不是期望的，比如在另一台机器上回放，或是更换了硬件，使是major/minor映射关系发生了改变。Replay_redirect将会导致所有的IOPS回放到单个设备上，不管这些IO来源于哪里。e.g.replay_redirect=/dev/sdc将会使得所有的IO都会重定向到/dev/sdc.这就意味着多个设备的数据都会重放到一个设置，如果想来自己多个设备的数据重放到多个设置的话，需要处理我们的trace，生成独立的trace，再使用fio进行重放，不过这会破坏多个设备访问的严格次序。

<102>write_bw_log=str

在job file写这个job的带宽日志。可以在他们的生命周期内存储job的带宽数据。内部的fio_generate_plots脚本可以使用gnuplot将这些文本转化成图。

<103>write_lat_log=str

同write_bw_log类似，只是这个选项可以存储io提交，完成和总的响应时间。如果没有指定文件名，默认的文件名是jobname_type.log。即使给出了文件名，fio也会添加两种类型的log。

e.g.如果我们指定write_lat_log=foo

实际的log名将是foo_slat.log,foo_slat.log和foo_lat.log.这会帮助fio_generate_plot来自动处理log

<104>write_iops_log=str

类似于write_bw_log,但是写的是IOPS.如果没有给定文件名的话，默认的文件名是jobname_type.log。

<105>log_avg_msec=int

默认，fio每完成一个IO将会记录一个日志（iops,latency,bw log）。当向磁盘写日志的时候，将会很快变的很大。设置这个选项的话，fio将会在一定的时期内平均这些值，指少日志的数量，默认是0

<106>lockmem=int

使用mlock可以指定特定的内存大小，用来访真少量内存

<107>exec_preren=str

运行job之前，通过过system执行指定的命令

<108>exec_postrun=str

job执行完成后，通过system执行指定的命令

<109>ioscheduler=str

在运行之前，尝试将文件所在的设备切换到指定的调度器。

<110>cpuload=int

如果job是非常占用CPU周期的，可以指定战胜CPU周期的百分比。

<111>cpuchunks=int

如果job是非常战胜CPU周期的，将load分拆为时间的cycles，以毫秒为单位

<112>disk_util=bool

产生磁盘利用率统计信息。默认是打开的

<113>disable_lat=bool

延迟的有效数字。Disable measurements of total latency numbers. Useful only for cutting back the number of calls to gettimeofday,as that does impact performance at really high IOPS rates.Note that to really get rid of a large amount of these calls, this option must be used with disable_slat and disable_bw as well.

<114>disable_clat=bool

<115>disable_slat_bool

<116>disable_bw=bool

<117>clat_percentiles=bool

允许报告完成完成响应时间的百分比

<118>percentile_list=float_list

<119>gtod_reduce=bool

<120>gtod_cpu=int

<121>continue_on_error=str

一般情况下，一旦检测到错误，fio将会退出这个job.如果这个选项设置的话，fio将会一直执行到有‘non-fatal错误‘（EIO或EILSEQ）或是执行时间耗完，或是指定的I/Osize完成。如果这个选项设置的话，将会添加两个状态，总的错误计数和第一个error。允许的值是

none 全部IO或检验错误后，都会退出

read 读错误时会继续执行，其它的错误会退出

write 写错误时会继续执行，其它的错误会退出

io 任何IO error时会继续执行，其它的错误会退出

verify 校验错误时会继续执行，其它的错误会退出

all 遇到所有的错误都会继续执行

<122>cgroup=str

<123>cgroup_weitht=int

<124>cgroup_weight=int

<125>cgroup_nodelete=bool

<126>uid=int

不是使用调用者的用户来执行，而是指定用户ID

<127>gid=int

设置group id

<128>flow_id=int

<129>flow=int

<130>flow_watermark=int

<131>flow_sleep=int

下面的参数只对指定的IO引擎有效：

[libaio] userspace_reap

[netsplice]hostname=str

[net]hostname=str

[netsplice]port=int

[netsplice]proto=str

[net]protocol=str

[net]proto=str

[net]listen

 

3.2.3 Fio输出结果说明

在运行时，fio将打印当前job创建的状态

e.g.

Threads: 1: [_r] [24.8% done] [ 13509/  8334 kb/s] [eta 00h:01m:31s]

生命周期

P   线程已经启动，还没有启动

C 线程启动

I 纯种已经初始化，等待中

p 线程运行中，预读文件

R 顺序读

r 随机读

W 顺序写

w 随机写

M 混合顺序读写

m 混合随机读写

F 等待执行fsync()

V 运行，检验写的数据

E 线程退出,还没有被主线程获取状态

_ Thread reaped, or

X Thread reaped, exited with an error.

K Thread reaped, exited due to signal.

 

其它的值都是可以自解释的：

当前正在运行的IO线程数。

从上次检查之后的IO速度（读速度/写速度）

估计的完成百分比

整个group的估计完成时间

当fio完成的时候（或是通过ctrl-c终止的时候），将会打印每一个线程的数据，每个group的数据，和磁盘数据。

io= 执行了多少M的IO

bw= 平均IO带宽

iops=   IOPS

runt= 线程运行时间

slat 提交延迟

clat 完成延迟

lat响应时间

bw 带宽

cpu利用率

IO depths=io队列

IO submit=单个IO提交要提交的IO数

IO complete=Like the above submit number, but for completions instead.

IO issued= The number of read/write requests issued, and how many

of them were short.

IO latencies=IO完延迟的分布

 

io= 总共执行了多少size的IO

aggrb= group总带宽

minb= 最小.平均带宽.

maxb= 最大平均带宽.

mint= group中线程的最短运行时间.

maxt= group中线程的最长运行时间.

 

ios= 所有group总共执行的IO数.

merge= 总共发生的IO合并数.

ticks= Number of ticks we kept the disk busy.

io_queue= 花费在队列上的总共时间.

util= 磁盘利用率

 

为了便于脚本分析，可能需要将结果生成表或图，fio可以生成以分号分割的结果。

 

4.   Iometer使用说明(块设备测试)

4.1. 简述

Iometer包括2个程序，Iometer.exe和Dynamo.exe。其中Iometer是控制程序，是图形界面，让你轻松的调节参数和显示测试结果，而Dynamo就是让测试盘产生压力测试的主程序了，用Iometer来控制Dynamo程序。在Windows下运行Iometer时，会自动打开Dynamo

程序（仔细观察会发现开了2个窗口，那个Dos的命令行程序就是Dynamo了。）

4.2 基本操作

1.       运行iometer主程序iometer.exe

2.       将dynamo放入linux环境下，并运行：

./dynamo -iwindowsip -m linuxip

3.       选择测试目标

4.       添加测试规则

点击Edit，调整对齐方式

5.       设置测试时间

 

 

6.       测试并查看结果

测试结果保存在文件resultt.csv中

 

4.3 参数说明

1.主界面

1）Topology/Workers:

Worker的数量取决于当前机器上的CPU核心数（我的CPU是2600K，4核8线程,所以有8个Worker)，每个Worker可以让你制定硬盘同时执行的线程数，不过一般我们家用测试只跑一个Worker即可，所以只需要1个Worker即可，多线程测试适合高性能服务器或者企业级的存储设备用的。这里多余的Worker我们可以在测试前删除。
2）Targets:（在设置Disk Target时会有3种不同的图标来表示不同类型的硬盘情况）

黄色图标的表示的是”Logical drive 逻辑磁盘“，意思就是已经分过区的，格式化的并且上面拥有文件系统的磁盘。（会显示硬盘分区卷标和卷标名）

如果黄色图标上加了红色删除的线，则代表的是这块逻辑硬盘上没有iobw.tst文件。Iometer在对逻辑硬盘测试前，会生成一个iobw.tst的测试文件，通过对这个文件进行”读取/写入“操作来计算IO成绩和传输率。

蓝色的图标表示的是”原始(RAW)硬盘“的意思，指的是这块硬盘上文件系统无法识别或者没分区和格式化，测试文件不能在上面创建。（会显示硬盘的型号）这里有一点需要注意，如果之前做过Iometer逻辑硬盘测试，并在这个分区里已经有iobw.tst文件，则在下次做测试前必须先删除，不然是不能改变这个之前测试生成的iobw.txt文件大小的。（也就是说会影响到下次测试的准确性）
3）Maximum Disk Size / Starting Disk Sector / # ofOutstanding IO:

一般的机械硬盘sector（扇区）大小为512字节（扇区为硬盘最小存储单位）。如果这里使用默认的0时，意思就是写满这块硬盘的所有扇区，如果你想测的是固定大小时，可以透过设置Maximum Disk Size这个参数来达到。输入1000就代表会在测试前生成一个大小为1000X512字节的iobw.tst测试文件。Starting Disk Sector指的是由硬盘的第几个扇区开始写入。（这里要强调一点，如果你设置的Maximun Disk Size数字比当前磁盘系统的缓冲区小的话，测试成绩很可能是缓冲区性能，速度会爆高，所以适当设大点吧。）

# of Outstanding I/O 指的是同时发送的IO请求（聪明人知道这个就是体现NCQ的作用了），预设值是1，一般家用测试不会去修改这个项目的，只有厂家秀分数做广告时会去改成32来跑最大IOPS忽悠用户。
4）Write IO Data Pattern（新版Iometer相比2006和2008版多出来的项目）

Repeating Bytes: 生成的IO数据是重复的，比如第一批IO数据是全”A”，第二批是全”B”，这个数据模型是Iometer2008里默认使用的，也是最适合SandForce主控压缩算法的，所以SandForce做广告时都是用Iometer2008的数据。

Peseudo random: 缓冲区里用随机的数据模型填满，写入完后再重新生成新的随机数据到缓冲区，造成每次写入IO都不同。这个数据模型是从最初的版本一直到Iometer 2006默认采用的，非常不适合SandForce主控进行压缩算法。

Full random：生成一套随机的16MB大小的数据模型到缓冲区。每次写入IO都会使用这套缓冲区的随机数据模型。（虽然是随机数据，但是由于每次的随机数据都一样，所以对采用了副本压缩技术的SandForce控制器，相当于每次只需要更新随机数据的索引部分即可，还是能够压缩部分数据。）

7.        设置测试规则
1）Transfer Request Size （测试请求的文件大小）

你要测试的文件块大小，比如测4KB随机的就填写4KB，测128KB持续的就填128KB。
2）Percent of Access Specification （当前规则占此测试中的比例）

如果你测试中需要添加多条规则的话，这个就可以设置比例了，比如50%做4KB随机测试，同时另外50%做128KB持续测试。
3）Percent Read/Write Distribution （测试请求的读/写的比率）

当前测试规则的读取/写入比率，比如66%读取的同时34%为写入，打个比方，我们的操作系统运行时在读取的时候，后台也在写入。
4）Percent Random/Sequential Distribution （测试请求的随机/持续比例）

随机和持续占的百分比，比如测4KB随机80%的同时测4KB持续20%。
5）Align I/O on （对齐 I/O到指定大小）

SSD要分区对齐，这里也是这个道理，一般测SSD都是对齐到4KB。如果设4KB，指的是测试的数据每次都是4KB对齐的。
6）设置规则的全局显示

全部设置完了，起个名字，然后最后再看下没问题即可点下面的OK确认。

       1）Run Time （测试时间）

可以设置测试的时间，如果全0代表无限。
2）Ramp up Time

我们知道如果磁盘系统使用阵列卡的话，上来会有个很高的缓存数据，为了保证测试数据的准确性，这里可以设置一定的时间，这样测试结果就不会计算这部分时间的数据，得到更真实的测试数字。

8.        查看测试结果

       1）Update Frequency (Seconds) （成绩更新频率/秒）

成绩更新的频率，你可以设置每秒更新或者60秒一更新等等。
       Results Since （结果从哪个时间段开始）
       Start of Test - 由于在进行测试时，每一秒的成绩都不同，如果选择这个选项，那 么Iometer显示的就是从测试一开始到现在为止的平均值。
       Last of Update - 如果选择的是这个，那么Iometer就会显示最后次更新到现在的  平均值。（如果你更新频率为30秒，那么成绩就是这个30秒内的平均值）

2）测试结果显示区域（图里的为默认，可以自己选择需要的结果）
              Total I/Os Per Second 当前规则下，每秒处理的IOPS数。
              Total MBs per Second 当前规则下，每秒的传输率。
              Average I/O Response Time(ms) 当前规则下，平均一次IOPS处理时间。
              Maximum I/O Response Time(ms) 当前规则下，最大一次IOPS处理时

间。
       %CPU Utilization (total) 当前规则下，CPU占用率
       Total Error Count 当前测试中，测试出错计数。

 

       测试结果说明：

 

5. Cosbench（对象存储测试）

下载地址：https://github.com/intel-cloud/cosbench/tree/master

Cosbench用户手册：

5.1 配置Controller和Driver

Controller：负责管理Driver和添加工作负载

Driver：负责实际的性能测试

Cosbench目录结构如下（版本0.4.2）

Controller和Driver对应配置在conf下，对应controller.conf、driver.conf

 

在controller下添加如下配置：

[controller]

drivers = 3

log_level = INFO

log_file = log/system.log

archive_dir = archive

 

[driver1]

name = driver1

url = http://172.93.21.14:18088/driver

 

[driver2]

name = driver2

url = http://172.93.21.15:18088/driver

 

[driver3]

name = driver3

url = http://172.93.21.16:18088/driver

 

启动controller

./start-controller.sh

 

启动Driver：

./start-driver.sh 1172.93.21.14 18088

./start-driver.sh 1172.93.21.15 18088

./start-driver.sh 1172.93.21.16 18088

 

页面登录地址：

Controller：http://172.93.21.15:19088/controller/index.html

Driver：http://172.93.21.14:18088/driver/index.html

 

5.2 添加工作负载

Contoller页面：

点击config workloads进入配置页面

选择swift测试，认证方式使用swauth，对应的配置信息使用radosgw-admin创建的用户信息，如下：

 

l  swauth配置：

username=testuser:swift;password=ZHPP0EOqd1NVMy7CHjDX6b4DeBHTnK73HN0RnE3M;

url=http://172.93.21.16:7480/auth/1.0

 

l  swift配置：

storage_url=http://172.93.21.16:7480/auth/1.0

 

l  配置读写选项：

l  点击保存generateconfiguration file，保存为xml格式：

 

返回主页面，点击submit new workloads加载工作负载，开始测试

 

IO监测工具

1. iostat

1.1 简介

iostat主要用于监控系统设备的IO负载情况，iostat首次运行时显示自系统启动开始的各项统计信息，之后运行iostat将显示自上次运行该命令以后的统计信息。用户可以通过指定统计的次数和时间来获得所需的统计信息。

1.2 使用说明

语法

iostat[ -c ] [ -d ] [ -h ] [ -N ] [ -k | -m ] [ -t ] [ -V ] [ -x ] [ -z ] [ device[...] | ALL ] [ -p [ device [,...] | ALL ] ] [ interval [ count ] ]

 

入门使用

iostat-d -k 2

参数 -d 表示，显示设备（磁盘）使用状态；-k某些使用block为单位的列强制使用Kilobytes为单位；2表示，数据显示每隔2秒刷新一次。

输出如下

 

iostat-d -k 1 10

Device:            tps    kB_read/s   kB_wrtn/s    kB_read    kB_wrtn

sda              39.29        21.14         1.44  441339807  29990031

sda1              0.00         0.00         0.00       1623        523

sda2              1.32         1.43         4.54  29834273   94827104

sda3              6.30         0.85        24.95  17816289  520725244

sda5              0.85         0.46         3.40   9543503   70970116

sda6              0.00         0.00         0.00        550        236

sda7              0.00         0.00         0.00        406          0

sda8              0.00         0.00         0.00        406         0

sda9              0.00         0.00         0.00        406          0

sda10            60.68        18.35        71.43 383002263 1490928140

 

Device:            tps    kB_read/s   kB_wrtn/s    kB_read    kB_wrtn

sda             327.55      5159.18       102.04       5056        100

sda1              0.00         0.00         0.00          0          0

 

输出信息的意义

 

tps：该设备每秒的传输次数（Indicate thenumber of transfers per second that were issued to the device.）。"一次传输"意思是"一次I/O请求"。多个逻辑请求可能会被合并为"一次I/O请求"。"一次传输"请求的大小是未知的。

 

kB_read/s：每秒从设备（drive expressed）读取的数据量；
kB_wrtn/s：每秒向设备（driveexpressed）写入的数据量；
kB_read：读取的总数据量；

kB_wrtn：写入的总数量数据量；这些单位都为Kilobytes。

 

上面的例子中，我们可以看到磁盘sda以及它的各个分区的统计数据，当时统计的磁盘总TPS是39.29，下面是各个分区的TPS。（因为是瞬间值，所以总TPS并不严格等于各个分区TPS的总和）

 

指定监控的设备名称为sda，该命令的输出结果和上面命令完全相同。

 iostat -d sda 2

默认监控所有的硬盘设备，现在指定只监控sda。 

 

-x参数

iostat还有一个比较常用的选项-x，该选项将用于显示和io相关的扩展数据。

iostat-d -x -k 1 10

Device:    rrqm/s wrqm/s   r/s  w/s  rsec/s  wsec/s   rkB/s    wkB/s avgrq-szavgqu-sz   await  svctm %util

sda          1.56 28.31  7.80 31.49   42.51   2.92    21.26     1.46    1.16     0.03    0.79  2.62  10.28

Device:    rrqm/s wrqm/s   r/s  w/s  rsec/s  wsec/s   rkB/s    wkB/s avgrq-szavgqu-sz   await  svctm %util

sda          2.00 20.00 381.00  7.00 12320.00  216.00 6160.00   108.00    32.31    1.75    4.50   2.17 84.20

 

输出信息的含义

　　rrqm/s：每秒进行merge的读操作数目。

　　wrqm/s：每秒进行merge的写操作数目。

　　r/s：每秒完成的读I/O设备次数。

　　w/s：每秒完成的写I/O设备次数。

　　rsec/s：每秒读扇区数。

　　wsec/s：每秒写扇区数。

　　rkB/s：每秒读K字节数。

　　wkB/s：每秒写K字节数。

　　avgrq-sz：平均每次设备I/O操作的数据大小(扇区)。

　　avgqu-sz：平均I/O队列长度。

　　await：平均每次设备I/O操作的等待时间(毫秒)。

　　svctm：平均每次设备I/O操作的服务时间(毫秒)。

　　%util：一秒中有百分之多少的时间用于I/O操作，或者说一秒中有多少时间I/O队列是非空的。

-c参数

iostat还可以用来获取cpu部分状态值：

iostat-c 1 10

avg-cpu:%user %nice %sys %iowait %idle1.98 0.00 0.35 11.45 86.22

avg-cpu:%user %nice %sys %iowait %idle1.62 0.00 0.25 34.46 63.67

 

常见用法

iostat-d -k 1 10         #查看TPS和吞吐量信息(磁盘读写速度单位为KB)

iostat-d -m 2            #查看TPS和吞吐量信息(磁盘读写速度单位为MB)

iostat-d -x -k 1 10      #查看设备使用率（%util）、响应时间（await） iostat -c 1 10 #查看cpu状态

 

 

实例分析

ostat-d -k 1 |grep sda10

Device:            tps    kB_read/s   kB_wrtn/s    kB_read    kB_wrtn

sda10            60.72        18.95        71.53 395637647 1493241908

sda10           299.02      4266.67       129.41       4352        132

sda10           483.84      4589.90      4117.17       4544       4076

sda10           218.00      3360.00       100.00       3360        100

sda10           546.00      8784.00       124.00       8784        124

sda10           827.00     13232.00       136.00     13232        136

 

上面看到，磁盘每秒传输次数平均约400；每秒磁盘读取约5MB，写入约1MB。

iostat-d -x -k 1

Device:    rrqm/s wrqm/s   r/s  w/s  rsec/s  wsec/s   rkB/s    wkB/s avgrq-szavgqu-sz   await  svctm %util

sda          1.56 28.31  7.84 31.50   43.65   3.16    21.82     1.58    1.19     0.03    0.80  2.61  10.29

sda          1.98 24.75 419.80  6.93 13465.35  253.47 6732.67   126.73    32.15    2.00    4.70   2.00 85.25

sda          3.06 41.84 444.90 54.08 14204.08 2048.98 7102.04  1024.49    32.57    2.10    4.21   1.85 92.24

可以看到磁盘的平均响应时间<5ms，磁盘使用率>80。磁盘响应正常，但是已经很繁忙了。

 

 

 

2. blktrace

2.1功能概述

blktrace是一个针对Linux内核块设备I/O层的跟踪工具。通过使用这个工具，使用者可以获取I/O请求队列的各种详细的情况，包括：进行读写的进程名称、进程号、执行时间、读写的物理块号、块大小等。

2.2主要选项

选项

使用说明

-b size

指定抽取事件的buffer大小，为1024的倍数，即单位为KB。默认大小为512KB

-d dev

增加需要追踪的设备

-I file

增加多个需要追踪的设备，这些设备在文件file中指定。

文件中设备的格式为：设备1 设备2

【注】：设备为全路径，设备之间用空格分离

-n num-stub

指定使用多少的buffer，默认为四个子buffer

-l

使用网络侦听模式（blktrace server）。即此时运行blktrace的设备作为服务器，侦听来自客户机端的网络信息。网络相关

-h hostname

运行网络客户端模式，与由hostname指定的服务器端链接。网络相关

-p number

指定使用的网络端口（默认为8462）。网络相关

-o basename

从输入文件指定基础名字，默认为: device.blktrace.cpu。若使用命令：-o - 则当前与blkparse一起运行在实时模式，将数据输出到标准输出端。

-D dir

输出到指定的文件夹dir

-w seconds

设置运行的时间。单位为秒

 

2.3blkparse

1. 简介

blkparse用于将块设备的事件流解析成有格式的输出。

2.主要选项

选项

使用说明

-b batch

指定标准输入读取的批量

-i file

指定输入文件的基本名字，默认为device.blktrace.cpu

若使用命令:-i - 则与blktrace一起运行在实时模式，从标准输入读取

-F type, fmt

-f fmt

设置输出格式。其中：-f 指定了所有的事件的格式；-F type类型的事件的格式

-o file

输出到文件file

-w span

显示有span指定的时间间隔的trace

1. end_time: 显示0~end_time时间间隔之间的trace

2. start:end-time: 显示start_time~end_time时间间隔之间的trace

 

3.主要动作

缩写

解释说明

A

栈设备的重映射--- Remap动作详细说明了从哪个设备映射到哪个设备

C

之前的A发起完成的动作。输出将会详细显示请求的sector和大小，以及成功或者失败

Q

将节点加入到给定地址的I/O队列中

I

插入的A请求被发送到I/O调度器，此时请求已经完成成型。

 

4.      动作相关输出

缩写

解释说明

A

输出：起始地址+长度，并伴随着原设备和sector偏移量

例如：

2531656 + 8 <- (251,2) 72 起始地址+长度 <-（原设备主设备号/此设备号）偏移量

C

如果当前有一个payload，则其表示头之后的填充，跟随者出错值。

若果当前没有payload，则显示 起始地址+长度（单位为sector）。若果-t选项指定了，则会显示运行时间。

无论是以上哪种形式，都会跟着一个完成的出错值。

例如：

1024 + 1024 [0] 起始地址 + 长度 [出错码]

I/Q

若当前有一个payload，则输出payload的字节数目，并跟着payload的16进制表示(圆括号之间)

若当先没有payload，则显示起始地址+长度（单位为sector）若果-t选项指定了，则会显示运行时间。

无论是以上哪种形式，都会跟着与事件相关的命令。

例如：

20480 + 1024 [dd] 起始地址+长度[命令]

 

2.4blktrace使用

1. 工具安装

安装命令：yum -y install blktrace

设定debug文件系统：mount -tdebugfs none /sys/kernel/debug

2.     简单实例

实例1

命令

blktrace -d /dev/sda -o - |blkparse -i -

说明

追踪设备/dev/sda的I/O信息，将结果输出到屏幕，并将输出的信息重定向为blkparse的输入。经过blkparse解析之后，将结果输出到屏幕

 

 

 

       实例2

命令

cmd1: blktrace -d /dev/sdd -o trace | blkparse -i -

cmd2: blkparse -i trace

说明

cmd1是将blktrace的结果输出到已经事先指定好的文件trace中，注意这个trace文件必须在本地文件夹中存在，无需带有任何后缀。运行之后会产生两个新的文件叫做trace.blktrace.0和trace.blktrace.1。

cmd2将trace文件作为blkparse的输入，blkparse的结果依然输出到屏幕。

blkparse -i trace -o /root/trace.txt : 将分析结果输出到文件trace.txt

 

3. 输出结果分析

8,48 0 1 0.000000000 25413  Q  WS 0 + 1024 [dd]

数值

解释说明

8,48

major/minor。即：主设备号为8，次设备号为48

0

CPU ID（2字节宽度），即当前动作发生在CPU 0

1

序列号

0.000000000

当前事件发生的时间戳。%5T.%9t, 秒级为5个字节的区域，纳秒为9个字节的区域

25413

进程ID号，5字节的区域

Q

动作的标识，2字节区域。Q表示加入队列的动作

WS

RWBS，3字节的区域。其中：R：读；W：写；D：块扔除操作；B：barrier操作；S：同步操作。

WS表示当前为写同步操作

0 + 1024 [dd]

起始地址为0