Prueba de rendimiento avanzado y prueba de estabilidad de la herramienta learning-103-Fio

 

Prefacio

   En la sección anterior, hablamos sobre la instalación de herramientas Fio, la instalación de bibliotecas dependientes y el entorno gcc, y el uso simple. Hoy es una explicación avanzada, principalmente sobre alguna experiencia práctica en pruebas de rendimiento y pruebas de estabilidad, así como algunas precauciones. Para las pruebas de rendimiento del disco, cada fabricante de servidores tendrá su propio conjunto de procedimientos y fabricantes como Huawei H3C probarán el rendimiento de sus servidores. Hay muchas herramientas para probar el rendimiento del disco, actualmente las principales son: fio y iozone 

Fio (usado en este artículo)

iozone (también relativamente bueno)

La instalación y el proceso de fio se encuentran en la sección anterior: https://blog.csdn.net/u013521274/article/details/107949362

---

1. Prueba de rendimiento de Fio

La prueba de rendimiento es principalmente para probar el rendimiento de lectura y escritura del disco, generalmente probando  lectura secuencial, escritura secuencial, lectura aleatoria , escritura aleatoria , 4 modos.

Indicadores de rendimiento de la prueba:  ancho de banda io promedio de   bw 

                          Iops   es un indicador de prueba de rendimiento que puede entenderse simplemente como el número de lecturas y escrituras por segundo (este indicador se muestra en los resultados de la prueba)

Hay muchos parámetros que se deben configurar al escribir un script en Fio, como se muestra a continuación:

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

Las instrucciones detalladas de configuración de los parámetros de Fio se muestran arriba. Si tiene alguna pregunta, puede verificar los detalles en línea.

En segundo lugar, el código real

2.1 Código de prueba (lectura y escritura secuenciales)

#!/bin/sh

export test=fio

echo "fio_write测试"
echo $(date +%F%n%T)
fio -directory=/fiorwtest -rw=write -bs=1M -direct=1 -iodepth 2 -ioengine=libaio -size 1G  -thread -numjobs=2  -group_reporting -name=write1M_1Gjob
echo $(date +%F%n%T)
sync
echo 3 > /proc/sys/vm/drop_caches
#ansible all -m shell -a "/tmp/qingli.sh"
echo "write 执行完毕"
echo "fio_read测试"
echo $(date +%F%n%T)
fio -directory=/fiorwtest -rw=read -bs=1M -direct=1 -iodepth 2 -ioengine=libaio -size 1G  -thread -numjobs=2  -group_reporting -name=write1M_1Gjob
echo $(date +%F%n%T)
sync
echo 3 > /proc/sys/vm/drop_caches
#ansible all -m shell -a "/tmp/qingli.sh" 196执行197上的
rm -f /fiorwtest/write1M_1Gjob*
echo "read 执行完毕"

Como se muestra arriba, el programa ejecuta primero la operación de escritura, ejecuta la operación de lectura y finalmente borra el archivo generado. El resultado de la ejecución es el siguiente.

Como se muestra en la figura anterior, el cuadro de línea roja es nuestro indicador de resultado, uno es la operación de escritura y el otro es la operación de lectura.

2.2 Código Fio (lectura y escritura aleatoria)

#!/bin/sh

export test=fio

#随机写
echo "randwrite4k4job"
echo $(date +%F%n%T)
fio -directory=/hlstor/cluster/fubenjuan1 -rw=randwrite -bs=4k -direct=1 -iodepth 8 -ioengine=libaio -size 35G  -thread -numjobs=4  -group_reporting -name=randwrite4k_4job
echo $(date +%F%n%T)
sync
echo 3 > /proc/sys/vm/drop_caches
ansible all -m shell -a "/tmp/qingli.sh"
#随机读
echo "randread4k4job"
echo $(date +%F%n%T)
fio -directory=/hlstor/cluster/fubenjuan1 -rw=randread -bs=4k -direct=1 -iodepth 8 -ioengine=libaio -size 35G  -thread -numjobs=4  -group_reporting -name=randwrite4k_4job
echo $(date +%F%n%T)
sync
echo 3 > /proc/sys/vm/drop_caches
ansible all -m shell -a "/tmp/qingli.sh"
rm -f /hlstor/cluster/fubenjuan1/randwrite4k_4job*

测试随机读写的 -rw=randwrite、randread
-rw=  --设置为randwrite randread  其他无差别

Una diferencia de parámetro

2.3 bucle de código Fio 

Hay tres formas de hacer un bucle en el código, que es similar a la escritura en bucle en lenguaje Python y Java. Permítanme presentarles brevemente un ejemplo.

La escritura general de bucle for es la siguiente:

#!/bin/sh

export test=fio

rwmode=("a" "b" "c" "d")
bssize=("1" "2" "3" "4")

for i in ${rwmode[@]}
do 
    echo $i
    echo $(date +%F%n%T)
	
    for j in ${bssize[@]}
    do	
	  echo $j
    done;
done;
---------------------------第2种----------------------------------
#!/bin/sh

export test=fio

rwmode=("a b c d")
bssize=("1 2 3 4")     差别在这 这个数组的写法

for i in ${rwmode[@]}
do 
    echo $i
    echo $(date +%F%n%T)
	
    for j in ${bssize[@]}
    do	
	  echo $j
    done;
done;

Como se muestra arriba, la diferencia radica en la escritura de la matriz rwmode. Los resultados de ambas ejecuciones son los mismos.

Simulador de Shell en línea https://c.runoob.com/compile/18

2.3 Bucle de combate real del código Fio

Ejecute operaciones de tamaño de bloque de 4k, 1024k en modo de escritura cíclicamente, y operaciones de tamaño de bloque de 4k, 1024k en modo de lectura

Tenga en cuenta que los cambios de parámetro deben agregar el signo $

Beneficios de los bucles: menos código

Desventajas de los bucles: escasa legibilidad (según sus necesidades)

Nota: En el código fio aquí, hay un nuevo parámetro -runtime = 900

           En él, la unidad del parámetro de tiempo de ejecución es segundos

     1. Se inicia el momento en que fio ejecuta el tiempo de ejecución, incluso si se ha ejecutado, debe continuar ejecutándose hasta que alcance el tiempo de ejecución. Si se establece, incluso si el archivo se ha leído, escrito o escrito por completo, se debe ejecutar el tiempo especificado por el tiempo de ejecución. Se logra ejecutando la misma carga en un bucle.
     2. Configure el tiempo para ejecutar una carga específica antes de grabar cualquier información de interpretación. Se utiliza para registrar los resultados del registro después de que el rendimiento sea estable, por lo que puede reducir el tiempo de ejecución necesario para generar resultados estables.

     3. Utilizado en la prueba de deuda, sin tiempo de ejecución de fallas por debajo del 60% de la carga de la CPU.

#!/bin/sh

export test=fio

rwmode=( "write" "read" )
bssize=( "4k" "1024k" )

for j in  ${rwmode[@]};
    do for i in  ${bssize[@]};
        do echo "fuse_fenbujuan_$j_$i_1job"
        echo $(date +%F%n%T)
        fio -directory=/hlstor/fenbujuan1 -rw=$j -bs=$i -direct=1 -iodepth 8 -ioengine=libaio -size 50G  -thread -numjobs=1 -runtime=900 -group_reporting -name=$j_$i_1job
        echo $(date +%F%n%T)
        sleep 60
        echo 3 > /proc/sys/vm/drop_caches
    done;
done;

Tres, monitoreo del desempeño

3.1 comando iostat

comando y resultados de iostat

iostat -m 1 
iostat -x 1
iostat -h 1  
每1秒刷新

3.2 Memoria en tiempo real

#!/bin/bash
echo `date` > /root/ansible_test.txt

时间保存到文件

El estado en tiempo real de la memoria se envía al archivo de registro. 

#!/bin/sh
while :
do
    free -m >> nei.log
    sleep 1
done

-m 是字节  -h 可视化比较好 

while :
do
    free -h >> /lyfiolog/Memory.log
    sleep 1
done

 Los resultados de los dos comandos son los siguientes:

3.3 La salida de registro de la ejecución del script sh, es decir, la salida de registro de fio

      Este comando puede generar registros en un archivo, pero no se puede detener durante la ejecución y no puede hacer otras cosas.

 sh fio-liyang-w2.sh >> fioly.log

     Después de agregar este comando nohup, se ejecutará en segundo plano y no afectará a otras cosas.

nohup sh fio.sh  >> fio.log &

Cuatro, prueba de estabilidad

        Se puede realizar una prueba de línea estable o una prueba de confiabilidad, no hay mucha distinción, el propósito principal es detectar que el disco está entre el 55% y el 80% de la carga de la CPU, el tiempo de ejecución sin fallas y se puede usar para determinar el rendimiento del disco, o del sistema de almacenamiento magnético NAS Hay una buena medida de su robustez.

        La estabilidad no es muy diferente de la prueba de rendimiento anterior. La clave es mantener la máquina en funcionamiento, seguir funcionando y volver a funcionar después de funcionar. Por lo general, tarda entre 2 y 3 días en realizarse. Obtenga el resultado final: bw iops, etc. son una buena medida de estabilidad.

        El siguiente es un ejemplo: solo una pequeña parte del código, hay más proyectos reales que este.

#!/bin/sh

export test=fio

echo "nfs_fuben"


echo "write4k8job"
echo $(date +%F%n%T)
fio  -directory=/data/test1fuben  -rw=write  -bs=4k  -direct=1  -iodepth 8  -ioengine=libaio  -size 20G   -thread  -numjobs=8  -group_reporting  -name=write4k_8job
echo $(date +%F%n%T)

echo "read4k8job"
echo $(date +%F%n%T)
fio  -directory=/data/test1fuben  -rw=read  -bs=4k  -direct=1  -iodepth 8  -ioengine=libaio  -size 20G   -thread  -numjobs=8  -group_reporting  -name=write4k_8job
echo $(date +%F%n%T)



echo "write1M4job"
echo $(date +%F%n%T)
fio  -directory=/data/test1fuben  -rw=write  -bs=1M  -direct=1  -iodepth 8  -ioengine=libaio  -size 20G   -thread  -numjobs=4  -group_reporting  -name=write1m_4job
echo $(date +%F%n%T)

echo "read1M4job"
echo $(date +%F%n%T)
fio  -directory=/data/test1fuben  -rw=read  -bs=1M  -direct=1  -iodepth 8  -ioengine=libaio  -size 20G   -thread  -numjobs=4  -group_reporting  -name=write1m_4job
echo $(date +%F%n%T)

Cinco, resuma el informe de prueba usted mismo

capa de racimo	Escritura secuencial 4k	Lectura secuencial 4k	Escritura secuencial de 1 M	Lectura secuencial de 1 M	4k escritura aleatoria	4k lectura aleatoria	Escritura aleatoria de 1 M	1M de lectura aleatoria
bw	36 M / s	65,2 M / s	2384	3061	120	131	1952	2598
iops	18,9 mil	33,4 km	2384	3061	30,8	33,5	1952	2599

     Como se muestra en la tabla anterior, esta prueba en la capa de clúster puede ser de diferentes volúmenes, volúmenes distribuidos, volúmenes de réplica, volúmenes de corrección de errores o capas Fuse y nfs. Realicé la prueba con diferentes bloques -bs, 4k, lectura y escritura secuencial de 1M, lectura y escritura aleatoria, algunos de los resultados más altos se deben a que mi computadora es una unidad de estado sólido SSD. Los resultados se resumen en esta tabla. Es más intuitivo.

5.2 Atención

     En proyectos de combate reales, el servidor de la máquina de prueba a menudo necesita instalar dos sistemas operativos, Linux y Windows Server. Windows es un poco diferente cuando se ejecuta Fio. En el comando Fio, -numjobs generalmente se establece en 4 8 10, etc. Linux dará un valor final después de ejecutar estos 4 archivos, como se muestra en la primera figura de este artículo.

     Pero en Windows, numjobs = 4 producirá 4 resultados de ejecución, debido a que cada archivo produce un resultado. Luego, en el resultado de la prueba, el peso de estos 4 resultados debe sumarse para ser el resultado final de la prueba.

para resumir:

Para la prueba de rendimiento de fio en la sección anterior, he dado un paso avanzado. Si tiene alguna pregunta, puede dejar un mensaje y responder si lo ve. 

Este artículo hace referencia al blog: https://blog.csdn.net/qq_14935437/article/details/93749444