CN108920319A

CN108920319A - 一种可实时显示性能数据的硬盘压力测试方法

Info

Publication number: CN108920319A
Application number: CN201810833473.8A
Authority: CN
Inventors: 闫硕
Original assignee: Zhengzhou Yunhai Information Technology Co Ltd
Current assignee: Zhengzhou Yunhai Information Technology Co Ltd
Priority date: 2018-07-26
Filing date: 2018-07-26
Publication date: 2018-11-30

Abstract

本发明提供一种可实时显示性能数据的硬盘压力测试方法，包括如下步骤：获取用户输入的参数，根据输入参数的数量进行判断测试；获取系统的硬盘信息；根据获取的硬盘信息和测试策略生成每个硬盘在每个测试策略下的测试参数文件；执行测试，获取实时测试数据并将获取的实时测试数据进行图形显示。借助FIO和Python能够自动化的根据执行的测试策略进行硬盘稳定性测试，并实时记录每个测试策略的测试过程中的硬盘性能值。然后每隔一段时间将收集的性能结果进行处理，以图形化的方式展现出来。硬盘稳定性是否出现波动，是否满足要求，一目了然。

Description

一种可实时显示性能数据的硬盘压力测试方法

技术领域

本发明涉及硬盘测试技术领域，具体涉及一种可实时显示性能数据的硬盘压力测试方法。

背景技术

随着IT领域技术的不断发展，传统信息化服务以及日趋强大的云计算服务对服务器的存储需求越来越高。硬盘作为服务器承载数据存储的重要设备，其稳定性作为服务器的一项重要指标，越来越被重视。这要求服务器在7*24小时的工作下，能够保证硬盘的工作维持在一个合理的稳态状态下，不能够出现忽高忽低的现象，这将影响服务器上运行的业务的性能，也是不利于硬盘本身的健康的。所以在服务器测试阶段，对硬盘的稳定性的测试就是必须的了。

FIO是Linux下测试硬盘稳定性最常用的工具，但是在使用FIO进行测试时，只产生了一堆各种数据，无法直观的从这些数据中看出硬盘稳定性是否出现波动等异常。普通测试人员需要花费大量的时间来处理这些数据，进而判断硬盘稳定性的结果，十分影响测试效率。

发明内容

为了克服上述现有技术中的不足，本发明提供一种可实时显示性能数据的硬盘压力测试方法，以解决上述技术问题。

本发明的技术方案是：

一种可实时显示性能数据的硬盘压力测试方法，包括如下步骤：

获取用户输入的参数，根据输入参数的数量进行判断测试；

获取系统的硬盘信息；

根据获取的硬盘信息和测试策略生成每个硬盘在每个测试策略下的测试参数文件；

执行测试，获取实时测试数据并将获取的实时测试数据进行图形显示。

进一步的，步骤获取用户输入的参数，根据输入参数的数量进行判断测试，之前包括：

安装测试软件包和FIO工具，获取测试文件所在的完整路径；

创建日志文件夹和日志文件，获取当前时间作为唯一的时间戳加入到日志文件的命名中。

进一步的，步骤获取用户输入的参数，根据输入参数的数量进行判断测试，包括检查输入参数，判断是否输入了系统盘的盘符来进行测试，具体包括：

若输入参数只有两个：第一个默认都是本文件名称，第二个是测试总时长，没有输入系统盘的盘符，所以此时不需要测试系统盘；

若输入参数是三个，第一个默认都是本文件的名称，第二个是测试总时长，第三个则是要测试的系统盘的盘符；

若输入参数数量不是2和3，则提示测试人员输入错误，需要更正输入参数的数量。

进一步的，步骤获取用户输入的参数，根据输入参数的数量进行判断测试，包括检查输入参数，判断输入测试总时长进行测试，还包括：

若输入的测试总时长小于设定的阈值，每个测试策略分到的时间不足以获取到实时的性能数据，此时则直接退出测试，并提示测试人员输入的总时长小于设定的阈值。

进一步的，步骤获取系统的硬盘信息，具体包括：

获取SATA/SAS盘信息；

获取shannon pciessd盘信息；

获取NVME盘信息；

获取当前的系统盘盘符；将系统盘盘符从获取到的所有盘符中删除掉。如果不删除，读写系统盘操作会导致系统损坏无法使用

进一步的，步骤根据获取的硬盘信息和测试策略生成每个硬盘在每个测试策略下的测试参数文件，包括：

汇总系统下获取到的所有硬盘的信息；

根据获取到的所有硬盘的信息，创建每个硬盘都覆盖到的FIO测试的测试策略文件，并将所有盘的FIO测试命令按照不同的测试策略汇总到以测试策略命名的文件中。

进一步的，步骤根据获取到的所有硬盘的信息，创建每个硬盘都覆盖到的FIO测试的测试策略文件之前包括：

创建FIO测试的测试策略文件保存的路径；

创建FIO测试的结果保存的路径。

进一步的，步骤执行测试，获取实时测试数据并将获取的实时测试数据进行图形显示，包括：

创建保存硬盘实时性能数据的文件夹；

创建保存图像的文件夹；

获取所有测试策略的列表，执行FIO测试；

根据当前在执行测试策略，获取所有盘在当前测试策略下的FIO测试的实时性能结果进行显示。

进一步的，步骤根据当前在执行测试策略，获取所有盘在当前测试策略下的FIO测试的实时性能结果，进行显示，包括：分别从保存实时性能数据的文件中获取包含三个指标：IOPS/BW/LAT的数据；

获取IOPS的历史数据；

处理IOPS的历史数据，其中，包括分别获取最大值和最小值，最大值*1.1和最小值*0.9作为图的Y轴的范围，将Y轴10等份作为Y轴的刻度；

获取BW的历史数据；

处理BW的历史数据，其中，包括分别获取最大值和最小值，然后最大值*1.1和最小值*0.9作为图的Y轴的范围，然后将Y轴10等份作为Y轴的刻度；

获取延迟（lat）的历史数据；

处理Lat的历史数据，其中，包括分别获取最大值和最小值，然后最大值*1.1和最小值*0.9作为图的Y轴的范围，然后将Y轴10等份作为Y轴的刻度，

将上述三个指标随时间的变化形成图像展显。

从以上技术方案可以看出，本发明具有以下优点：本发明借助FIO和Python能够自动化的根据执行的测试策略进行硬盘稳定性测试，并实时记录每个测试策略的测试过程中的硬盘性能值。然后每隔一段时间将收集的性能结果进行处理，以图形化的方式展现出来。硬盘稳定性是否出现波动，是否满足要求，一目了然。

通过本发明，能够在Linux系统下测试硬盘稳定性过程中更加有效的直观的观测硬盘稳定性测试，及时发现测试异常，提升测试的品质，进而提升整个服务器的品质。

此外，本发明设计原理可靠，结构简单，具有非常广泛的应用前景。

由此可见，本发明与现有技术相比，具有突出的实质性特点和显著地进步，其实施的有益效果也是显而易见的。

附图说明

图1为一种可实时显示性能数据的硬盘压力测试方法流程图；

图2为测试指标IOPS/BW/LAT随时间的变化形成图像。

具体实施方式

下面结合附图1和附图2并通过具体实施例对本发明进行详细阐述，以下实施例是对本发明的解释，而本发明并不局限于以下实施方式。

实施例一

S1：获取用户输入的参数，根据输入参数的数量进行判断测试；

S2：获取系统的硬盘信息；

S3：根据获取的硬盘信息和测试策略生成每个硬盘在每个测试策略下的测试参数文件；

S4：执行测试，获取实时测试数据并将获取的实时测试数据进行图形显示。

步骤S1之前包括：

S01：安装测试软件包和FIO工具，获取测试文件所在的完整路径；

S02：创建日志文件夹和日志文件，获取当前时间作为唯一的时间戳加入到日志文件的命名中。

步骤S1中，检查输入参数，判断是否输入了系统盘的盘符来进行测试，具体包括：

步骤S1中，检查输入参数，判断输入测试总时长进行测试，还包括：

步骤S2，具体包括：

S21：获取SATA/SAS盘信息；

S22：获取shannon pciessd盘信息；

S23：获取NVME盘信息；

S24：获取当前的系统盘盘符；将系统盘盘符从获取到的所有盘符中删除掉，如果不删除，读写系统盘操作会导致系统损坏无法使用。

步骤S3包括：

S31：汇总系统下获取到的所有硬盘的信息；

S32：根据获取到的所有硬盘的信息，创建每个硬盘都覆盖到的FIO测试的测试策略文件，并将所有盘的FIO测试命令按照不同的测试策略汇总到以测试策略命名的文件中。

步骤S3之前包括：

创建FIO测试的测试策略文件保存的路径；

创建FIO测试的结果保存的路径。

步骤S4包括：

S41：创建保存硬盘实时性能数据的文件夹；

S42：创建保存图像的文件夹；

S43：获取所有测试策略的列表，执行FIO测试；

S44：根据当前在执行测试策略，获取所有盘在当前测试策略下的FIO测试的实时性能结果进行显示。

步骤S44包括：分别从保存实时性能数据的文件中获取包含三个指标：IOPS/BW/LAT的数据；

获取IOPS的历史数据；

获取BW的历史数据；

获取延迟（lat）的历史数据；

将上述三个指标随时间的变化形成图像展显。

实施例二

步骤1获取用户输入的第一个参数，即测试总时间，然后均分到每个测试策略。比如总时间是43200秒，共28个测试策略，则每个策略的执行时间是43200/28=1542秒。

步骤2：判断是否有输入第二个参数，如果输入了，则此参数为系统盘要测试的盘符；如果没有，就不再测试系统盘。

步骤3：如果输入参数超过两个，则提示测试人员，并退出测试。

步骤4：判断输入的测试总时间是否太短（小于600），如果总时间太短的话，则每个测试策略均分到的测试时间就非常短，不能够很好的进行稳定性测试。则时间过短就退出测试；符合要求，就继续下面的步骤。

步骤5：将当前时间作为时间戳，加入到命名中，建立存放日志的文件夹，使其是惟一的。

步骤6：检测测试工具所依赖的系统包是否已经安装。如果没有安装，则提示测试人员然后退出测试；如果安装了，则继续下面的步骤

步骤7：检测测试工具是否已安装，如果没有安装，则执行安装程序；如果已经安装了，则继续下面的步骤。

步骤8：获取所有盘的盘符，然后剔除系统盘。如果输入了系统盘测试的盘符，则将指定的系统盘加入到要测试的硬盘的盘符列表中。

步骤9：根据所有的盘符和测试策略，形成每个硬盘在买个测试策略下的测试参数文件。

步骤10：开始挨个执行测试策略。

步骤11在执行某个策略时，分别从保存实时性能数据的文件中获取数据（包含三个指标：IOPS/BW/LAT），然后形成一幅图，将这三个指标随时间的变化形成图像展现。

步骤12：判断硬盘压力测试是否已经结束，如果还没有结束，则延迟一段时间后，返回执行步骤11；如果已经结束，则返回步骤10，执行下一个测试策略。

直到所有的测试策略都执行完毕，输出测试结束信息给测试人员，并结束测试。

实现过程：

#引入必要的软件包

import matplotlib

matplotlib.use('Agg')

import os

import sys

import time

import re

import subprocess

import matplotlib.pyplot as plyt

import paramiko

import json

import numpy

import shutil

#获取测试文件所在的完整路径，供后面生成测试日志等路径时使用

current_path = os.path.abspath(os.path.join(os.path.dirname(__file__),os.pardir))

sys.path.append(current_path)

#获取当前时间，作为唯一的时间戳加入到日志文件的命名中，保证日志文件的唯一性。

time_start = time.strftime('%Y%m%d%H%M%S', time.localtime(time.time()))

log_dir_name = time_start + "_SIT_FIO_TEST_RHEL"

log_file_name = time_start + "_SIT_FIO_TEST_RHEL.log"

log_path_temp = current_path + "/log"

if not os.path.isdir(log_path_temp):

os.mkdir(log_path_temp)

log_path_dir = log_path_temp + "/" + log_dir_name

log_path = log_path_dir + "/" + log_file_name

if not os.path.isdir(log_path_dir):

os.mkdir(log_path_dir)

resultlog = open(log_path, mode="w")

# 检查输入，因为要判断是否输入了系统盘的盘符来进行测试，所以要分两种情况。

input_length = len(sys.argv)

#如果输入参数只有两个：第一个默认都是本文件名称，那第二个是测试总时长，没有输入系统盘的盘符，所以此时不需要测试系统盘。

if input_length == 2:

total_time = sys.argv[1]

#如果输入参数是三个，第一个默认都是本文件的名称，第二个是测试总时长，第三个则是要测试的系统盘的盘符。

elif input_length == 3:

total_time = sys.argv[1]

if int(total_time) < 600:

print("\033[31m Input total test time is too short! Pleaseincrease it to at least 600 seconds! \033[0m")

resultlog.write("Input total test time is too short! Pleaseincrease it to at least 600 seconds! " + os.linesep)

sys.exit(255)

sys_part = sys.argv[2]

#如果输入参数数量不是2和3，则提示测试人员输入错误，需要更正输入参数的数量。

else:

print("\033[31m Input Error! Usage:%s total_time(seconds) sys_partition(Optional) \033[0m" % sys.argv[0])

resultlog.write("Input Error! Usage:%s total_time(seconds) sys_partition(Optional)" % sys.argv[0] + os.linesep)

sys.exit(255)

#判断输入的时间是否太短，如果太短的话，每个测试策略分到的时间只有几秒钟，并不足以获取到实时的性能数据，此时则直接退出测试，然后提示测试人员。

if int(total_time) < 600:

sys.exit(255)

#因为需要安装FIO工具来进行压力测绘，但是FIO还需要其他系统包的支持，如果这些依赖包没有安装，则退出测试，并提示测试人员将依赖包安装上；

status_libaio_devel = subprocess.Popen("rpm -qa|grep libaio-devel", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

status_libaio_devel.wait()

returncode_status_libaio_devel = status_libaio_devel.returncode

if returncode_status_libaio_devel != 0:

print("\033[31mPlease use yum -y install libaio-devel to finish thepreperation \033[0m")

resultlog.write("Please use yum -y install libaio-devel to finish thepreperation" + os.linesep)

sys.exit(255)

# 安装硬盘压力测试工具FIO，

status_fio_first_time_process = subprocess.Popen("which fio", shell=True,stdout=subprocess.PIPE, stderr=subprocess.PIPE)

status_fio_first_time_process.wait()

status_fio_first_time = status_fio_first_time_process.returncode

if status_fio_first_time != 0:

print("\033[31m fio is not installed!Please wait while installingfio! \033[0m")

resultlog.write("fio is not installed!Please wait while installingfio!" + os.linesep)

os.chdir("tool")

subprocess.Popen("tar -zxf fio-fio-2.15.tar.gz", shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE).wait()

os.chdir("fio-fio-2.15")

install_fio = subprocess.Popen("./configure && make && make install",shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

install_fio.wait()

status_install_fio = install_fio.returncode

if status_install_fio != 0:

print("\033[31m fio is installed failed!Please check if make/gccis installed! \033[0m")

resultlog.write("fio is installed failed!Please check if make/gccis installed!" + os.linesep)

sys.exit(255)

status_fio_second_time_process = subprocess.Popen("which fio", shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

status_fio_second_time_process.wait()

status_fio_second_time = status_fio_second_time_process.returncode

#判断FIO是否有成功安装。不成功的退出测试程序，并通知测试人员；成功的提示测试人员后，继续网下进行测试。

if status_fio_second_time != 0:

print("\033[31m fio installation failed! \033[0m")

resultlog.write("fio installation failed!" + os.linesep)

exit(255)

else:

print("\033[32m fio is installed successfully! \033[0m")

resultlog.write("fio is installed successfully!" + os.linesep)

os.chdir(current_path)

# 获取系统的硬盘信息。因为现在硬盘种类非常多，有NVME盘、SATA/SAS盘、PCIESSD等，不同的盘在系统下的命名方式不一样。需要根据不同的盘，进行分类获取然后汇总。

# 获取普通SATA/SAS盘信息

hdd_list = []

hdd_list_temp = subprocess.Popen("fdisk -l|grep 'Disk /dev/sd'", shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE).stdout.readlines()

for item_hdd in hdd_list_temp:

hdd_name_temp = re.search(r'/dev/([a-zA-Z]+)', item_hdd)

if hdd_name_temp is not None:

hdd_list.append(hdd_name_temp.groups()[0])

# 获取shannon pciessd盘信息

dfx_list = []

dfx_list_temp = subprocess.Popen("fdisk -l|grep 'Disk /dev/df'", shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE).stdout.readlines()

for item_dfx in dfx_list_temp:

dfx_name_temp = re.search(r'/dev/([a-zA-Z]+)', item_dfx)

if dfx_name_temp is not None:

hdd_list.append(dfx_name_temp.groups()[0])

# 获取NVME盘信息

nvme_list = []

nvme_list_temp = subprocess.Popen("fdisk -l|grep 'Disk /dev/nvme'", shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE).stdout.readlines()

for item_nvme in nvme_list_temp:

nvme_name_temp = re.search(r'/dev/([a-zA-Z]+[0-9]+n[0-9]+)', item_nvme)

if nvme_name_temp is not None:

hdd_list.append(nvme_name_temp.groups()[0])

# 获取当前的系统盘盘符

df_list_temp = subprocess.Popen("df", shell=True, stderr=subprocess.PIPE,stdout=subprocess.PIPE).stdout.readlines()

for item_df in df_list_temp:

df_temp = re.search(r'/$', item_df)

if df_temp is not None:

sysdisk_temp = item_df

break

sysdisk_name_temp = re.search(r'/dev/([a-zA-Z]+)', sysdisk_temp).groups()[0]

if sysdisk_name_temp is not None:

sysdisk_flag = sysdisk_name_temp[:2]

else:

print("\033[31m System disk name is not found! \033[0m")

resultlog.write("System disk name is not found! " + os.linesep)

exit(255)

#将系统盘盘符从获取到的所有盘符中删除掉。因为如果不删除的话，读写系统盘操作会导致系统损坏无法使用。

if sysdisk_flag == "nv":

sysdisk_name = re.search(r'([a-zA-Z]+[[0-9]+n[0-9]]*)', sysdisk_name_temp).groups()[0]

nvme_list_final = [item for item in nvme_list if item != sysdisk_name]

hdd_list_final = hdd_list

dfx_list_final = dfx_list

elif sysdisk_flag == "sd":

sysdisk_name = re.search(r'([a-zA-Z]+)', sysdisk_name_temp).groups()[0]

nvme_list_final = nvme_list

hdd_list_final = [item for item in hdd_list if item != sysdisk_name]

dfx_list_final = dfx_list

elif sysdisk_flag == "df":

sysdisk_name = re.search(r'([a-zA-Z]+)', sysdisk_name_temp).groups()[0]

nvme_list_final = nvme_list

hdd_list_final = hdd_list

dfx_list_final = [item for item in dfx_list if item != sysdisk_name]

else:

print("\033[31m No system disk find!Exit! \033[0m")

resultlog.write("No system disk find!Exit!" + os.linesep)

sys.exit(255)

diskname_list = []

# 将系统下获取到的所有硬盘的信息汇总到一起

diskname_list.extend(nvme_list_final)

diskname_list.extend(hdd_list_final)

diskname_list.extend(dfx_list_final)

disk_number = len(diskname_list)

# add system disk part to diskname list

if len(sys.argv) == 3:

diskname_list.append(sys.argv[2])

# 创建FIO测试的测试策略文件保存的路径

conf_dir = log_path_dir + "/fio_conf"

if not os.path.isdir(conf_dir):

os.mkdir(conf_dir)

#创建FIO测试的结果保存的路径

result_dir = log_path_dir + "/result"

if not os.path.isdir(result_dir):

os.mkdir(result_dir)

time_every_policy = int(int(total_time) / 28)

# 创建FIO测试的测试策略文件。根据前面获取到的所有硬盘的信息，每个硬盘都需要覆盖到。

policy_list = ["read", "write", "randread", "randwrite"]

block_list = ["4k", "16k", "64k", "128k", "256k", "512k", "1024k"]

for diskname in diskname_list:

for policy in policy_list:

for block in block_list:

conf_file_name = conf_dir + "/" + policy + "-" + block + "-"+ diskname

file_handler = open(conf_file_name, mode="w")

file_handler.write("[global]" + os.linesep)

file_handler.write("bs=%s" % block + os.linesep)

file_handler.write("ioengine=libaio" + os.linesep)

file_handler.write("rw=%s" % policy + os.linesep)

file_handler.write("time_based" + os.linesep)

file_handler.write("direct=1" + os.linesep)

file_handler.write("group_reporting" + os.linesep)

file_handler.write("randrepeat=0" + os.linesep)

file_handler.write("norandommap" + os.linesep)

file_handler.write("iodepth=128" + os.linesep)

file_handler.write("log_avg_msec=10000" + os.linesep)

file_handler.write("write_bw_log=%s-%s-%s" %(policy, block,diskname) + os.linesep)

file_handler.write("write_iops_log=%s-%s-%s" %(policy, block,diskname) + os.linesep)

file_handler.write("write_lat_log=%s-%s-%s" %(policy, block,diskname) + os.linesep)

file_handler.write("numjobs=1" + os.linesep)

file_handler.write("timeout=8800" + os.linesep)

file_handler.write("runtime=%s" % time_every_policy +os.linesep)

file_handler.write("[%s]" % policy + os.linesep)

file_handler.write("filename=/dev/%s" % diskname)

file_handler.close()

all_conf_name = os.listdir(conf_dir)

conf_temp = log_path_dir + "/conf"

if not os.path.isdir(conf_temp):

os.mkdir(conf_temp)

#将所有盘的FIO测试命令按照不同的测试策略汇总到以测试策略命名的文件中，这样当执行这个策略文件时，所有的盘都执行的是一样的测试策略。

policy_test = []

for item_policy in policy_list:

for item_block in block_list:

policy_test.append(item_policy + "-" + item_block)

for item_policy_test in policy_test:

with open("%s/%s" % (conf_temp, item_policy_test), mode="wb") ashandler:

for item_conf in all_conf_name:

data_temp = re.search(r'^%s' % item_policy_test, item_conf)

if data_temp is not None:

handler.write(item_conf + os.linesep)

run_dir = log_path_dir + "/run"

if not os.path.isdir(run_dir):

os.mkdir(run_dir)

#创建保存硬盘实时性能数据的文件夹

rawdata_dir = log_path_dir + "/rawdata"

if not os.path.isdir(rawdata_dir):

os.mkdir(rawdata_dir)

#创建保存图像的文件夹

image_dir = log_path_dir + "/image"

if not os.path.isdir(image_dir):

os.mkdir(image_dir)

for item_policy_test in policy_test:

with open("%s/%s" % (conf_temp, item_policy_test), mode="r") as conf_to_run:

conf_to_run_list = conf_to_run.readlines()

with open("%s/run-%s" % (run_dir, item_policy_test), mode="wb") ashandler:

for item_run in conf_to_run_list:

handler.write("fio %s/%s >> %s/%s 2>&1 &" % (conf_dir.strip(), item_run.strip(), result_dir.strip(), item_run.strip()) + os.linesep)

# 获取所有测试策略的列表

run_item_list = os.listdir(run_dir)

os.chdir(rawdata_dir)

# 执行FIO测试

resultlog.write("Begin FIO stress test!Start time %s" % time_start +os.linesep)

print("Begin FIO stress test!Start time %s" % time_start)

for item_to_run in run_item_list:

# 获取当前执行的测试策略

filter_pattern = "-".join(item_to_run.split("-")[1:])

# 在后台执行FIO测试程序

print("\033[32m Begin to run %s \033[0m" % filter_pattern)

resultlog.write("Begin to run %s" % filter_pattern + os.linesep)

run_fio = subprocess.Popen("/bin/sh %s/%s" %(run_dir, item_to_run), shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)

#因为要持续不断的来获取实时性能数据并画成图像。此处使用一个无限循环。当本测试策略结束后，退出此无限循环，继续下一个策略的测试。

while 0 < 1 :

# 根据当前在执行侧测试策略，获取所有盘在当前测试策略下的FIO测试的实时性能结果。

raw_data_all_filename_temp = os.listdir(rawdata_dir)

# like:randread-4k

for item_diskname in diskname_list:

filter_pattern = "-".join(item_to_run.split("-")[1:]) + "-" +item_diskname

raw_data_filename_now = [item for item in raw_data_all_filename_temp if re.search(r'%s' % filter_pattern, item) is not None]

raw_data_filename_now_iops = [item for item in raw_data_filename_now if re.search(r'_iops', item) is not None][0]

raw_data_filename_now_bw = [item for item in raw_data_filename_now if re.search(r'_bw', item) is not None][0]

raw_data_filename_now_lat = [item for item in raw_data_filename_now if re.search(r'_lat', item) is not None][0]

figure_name = filter_pattern

# 获取IOPS的历史数据

with open(raw_data_filename_now_iops, mode='rb') as rawdata_file_iops:

content_iops = rawdata_file_iops.readlines()

# 获取BW的历史数据

with open(raw_data_filename_now_bw, mode='rb') as rawdata_file_bw:

content_bw = rawdata_file_bw.readlines()

#获取延迟（lat）的历史数据

with open(raw_data_filename_now_lat, mode='rb') as rawdata_file_lat:

content_lat = rawdata_file_lat.readlines()

# 处理IOPS的历史数据。分别获取最大值和最小值，然后最大值*1.1和最小值*0.9作为图的Y轴的范围，然后将Y轴10等份作为Y轴的刻度。

data_1_list_iops = [float(item.split(',')[1].strip()) for item incontent_iops]

data_2_list_iops = []

x_data = 0

for y_data in range(0, len(data_1_list_iops)):

data_2_list_iops.append(x_data)

x_data += 10

max_y_iops = max(data_1_list_iops) * 1.1

min_y_iops = min(data_1_list_iops) * 0.9

jiange_iops = (max_y_iops - min_y_iops) / 10

y_ticks_iops = numpy.arange(min_y_iops, max_y_iops, step=jiange_iops)

data_second_iops = numpy.array(data_2_list_iops)

data_data_iops = numpy.array(data_1_list_iops)

# 处理BW的历史数据。分别获取最大值和最小值，然后最大值*1.1和最小值*0.9作为图的Y轴的范围，然后将Y轴10等份作为Y轴的刻度。

data_1_list_bw = [float(item.split(',')[1].strip()) for item incontent_bw]

data_2_list_bw = []

x_data = 0

for y_data in range(0, len(data_1_list_bw)):

data_2_list_bw.append(x_data)

x_data += 10

max_y_bw = max(data_1_list_bw) * 1.1

min_y_bw = min(data_1_list_bw) * 0.9

jiange_bw = (max_y_bw - min_y_bw) / 10

y_ticks_bw = numpy.arange(min_y_bw, max_y_bw, step=jiange_bw)

data_second_bw = numpy.array(data_2_list_bw)

data_data_bw = numpy.array(data_1_list_bw)

#处理Lat的历史数据。分别获取最大值和最小值，然后最大值*1.1和最小值*0.9作为图的Y轴的范围，然后将Y轴10等份作为Y轴的刻度。

data_1_list_lat = [float(item.split(',')[1].strip()) for item incontent_lat]

data_2_list_lat = []

x_data = 0

for y_data in range(0, len(data_1_list_lat)):

data_2_list_lat.append(x_data)

x_data += 10

max_y_lat = max(data_1_list_lat) * 1.1

min_y_lat = min(data_1_list_lat) * 0.9

jiange_lat = (max_y_lat - min_y_lat) / 10

y_ticks_lat = numpy.arange(min_y_lat, max_y_lat, step=jiange_lat)

data_second_lat = numpy.array(data_2_list_lat)

data_data_lat = numpy.array(data_1_list_lat)

# 画图。设置图像的大小和标题。

figure_1 = plyt.figure(figure_name, figsize=(20, 10))

plyt.suptitle(figure_name)

plyt.subplots_adjust(hspace=1)

# 画IOPS的图像

fig_iops = plyt.subplot(311)

fig_iops.grid(True)

plyt.ylim((min_y_iops, max_y_iops))

plyt.yticks(y_ticks_iops)

plyt.xlabel("time(secs)")

plyt.ylabel("IOPS")

fig_iops.set_title("IOPS")

fig_iops.plot(data_second_iops, data_data_iops)

time.sleep(1)

# 画BW的图像

fig_bw = plyt.subplot(312)

fig_bw.grid(True)

plyt.ylim((min_y_bw, max_y_bw))

plyt.yticks(y_ticks_bw)

plyt.xlabel("time(secs)")

plyt.ylabel("BW(KB/s)")

fig_bw.set_title("BandWidth")

fig_bw.plot(data_second_bw, data_data_bw)

time.sleep(1)

# 画lat的图像

fig_lat = plyt.subplot(313)

fig_lat.grid(True)

plyt.ylim((min_y_lat, max_y_lat))

plyt.yticks(y_ticks_lat)

plyt.xlabel("time(secs)")

plyt.ylabel("Lat(usecs)")

fig_lat.set_title("Latency")

fig_lat.plot(data_second_lat, data_data_lat)

time.sleep(1)

figure_name_temp = figure_name + '.jpg'

figure_1.savefig(os.path.join(image_dir, figure_name_temp))

plyt.close()

#延迟一段时间之后，继续下一次获取数据和画图

time.sleep(10)

#判断FIO进程是否已经结束，如果后台没有FIO进程执行了，说明当前这个测试策略已经结果，将继续进行下一个测试策略的监控

fio_run_status = subprocess.Popen("ps -aux|grep fio|grep -vgrep", shell=True, stderr=subprocess.PIPE, stdout=subprocess.PIPE)

fio_run_status.wait()

if fio_run_status.returncode == 0:

time.sleep(2)

else:

break

#记录测试结束时间，并退出测试程序。

resultlog.close()

end_time = time.strftime('%Y%m%d%H%M%S', time.localtime(time.time()))

resultlog.write("End FIO stress test!End time %s" % time_start +os.linesep)

print("\033[32m End FIO stress test!End time %s \033[0m" % end_time)

sys.exit(0)

本发明的说明书和权利要求书及上述附图中的术语“第一”、“第二”、“第三”“第四”等（如果存在）是用于区别类似的对象，而不必用于描述特定的顺序或先后次序。应该理解这样使用的数据在适当情况下可以互换，以便这里描述的本发明的实施例能够以除了在这里图示或描述的那些以外的顺序实施。此外，术语“包括”和“具有”以及他们的任何变形，意图在于覆盖不排他的包含。

对所公开的实施例的上述说明，使本领域专业技术人员能够实现或使用本发明。对这些实施例的多种修改对本领域的专业技术人员来说将是显而易见的，本文中所定义的一般原理可以在不脱离本发明的精神或范围的情况下，在其它实施例中实现。因此，本发明将不会被限制于本文所示的这些实施例，而是要符合与本文所公开的原理和新颖特点相一致的最宽的范围。

Claims

1.一种可实时显示性能数据的硬盘压力测试方法，其特征在于，包括如下步骤：

获取用户输入的参数，根据输入参数的数量进行判断测试；

获取系统的硬盘信息；

2.根据权利要求1所述的一种可实时显示性能数据的硬盘压力测试方法，其特征在于，步骤获取用户输入的参数，根据输入参数的数量进行判断测试，之前包括：

安装测试软件包和FIO工具，获取测试文件所在的完整路径；

3.根据权利要求1所述的一种可实时显示性能数据的硬盘压力测试方法，其特征在于，步骤获取用户输入的参数，根据输入参数的数量进行判断测试，包括检查输入参数，判断是否输入了系统盘的盘符来进行测试，具体包括：

4.根据权利要求3所述的一种可实时显示性能数据的硬盘压力测试方法，其特征在于，步骤获取用户输入的参数，根据输入参数的数量进行判断测试，包括检查输入参数，判断输入测试总时长进行测试，还包括：

5.根据权利要求1所述的一种可实时显示性能数据的硬盘压力测试方法，其特征在于，步骤获取系统的硬盘信息，具体包括：

获取SATA/SAS盘信息；

获取shannon pciessd盘信息；

获取NVME盘信息；

获取当前的系统盘盘符；将系统盘盘符从获取到的所有盘符中删除掉。

6.根据权利要求5所述的一种可实时显示性能数据的硬盘压力测试方法，其特征在于，步骤根据获取的硬盘信息和测试策略生成每个硬盘在每个测试策略下的测试参数文件，包括：

汇总系统下获取到的所有硬盘的信息；

7.根据权利要求6所述的一种可实时显示性能数据的硬盘压力测试方法，其特征在于，步骤根据获取到的所有硬盘的信息，创建每个硬盘都覆盖到的FIO测试的测试策略文件之前包括：

创建FIO测试的测试策略文件保存的路径；

创建FIO测试的结果保存的路径。

8.根据权利要求1所述的一种可实时显示性能数据的硬盘压力测试方法，其特征在于，步骤执行测试，获取实时测试数据并将获取的实时测试数据进行图形显示，包括：

创建保存硬盘实时性能数据的文件夹；

创建保存图像的文件夹；

获取所有测试策略的列表，执行FIO测试；

9.根据权利要求8所述的一种可实时显示性能数据的硬盘压力测试方法，其特征在于，步骤根据当前在执行测试策略，获取所有盘在当前测试策略下的FIO测试的实时性能结果，进行显示，包括：分别从保存实时性能数据的文件中获取包含三个指标：IOPS/BW/LAT的数据，将这三个指标随时间的变化形成图像展显，其中，

获取IOPS的历史数据；

获取BW的历史数据；

获取延迟（lat）的历史数据；

处理Lat的历史数据，其中，包括分别获取最大值和最小值，然后最大值*1.1和最小值*0.9作为图的Y轴的范围，然后将Y轴10等份作为Y轴的刻度。