# Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
|
# Use of this source code is governed by a BSD-style license that can be
|
# found in the LICENSE file.
|
|
"""Library to run fio scripts.
|
|
fio_runner launch fio and collect results.
|
The output dictionary can be add to autotest keyval:
|
results = {}
|
results.update(fio_util.fio_runner(job_file, env_vars))
|
self.write_perf_keyval(results)
|
|
Decoding class can be invoked independently.
|
|
"""
|
|
import json
|
import logging
|
import re
|
|
import common
|
from autotest_lib.client.bin import utils
|
|
class fio_graph_generator():
|
"""
|
Generate graph from fio log that created when specified these options.
|
- write_bw_log
|
- write_iops_log
|
- write_lat_log
|
|
The following limitations apply
|
- Log file name must be in format jobname_testpass
|
- Graph is generate using Google graph api -> Internet require to view.
|
"""
|
|
html_head = """
|
<html>
|
<head>
|
<script type="text/javascript" src="https://www.google.com/jsapi"></script>
|
<script type="text/javascript">
|
google.load("visualization", "1", {packages:["corechart"]});
|
google.setOnLoadCallback(drawChart);
|
function drawChart() {
|
"""
|
|
html_tail = """
|
var chart_div = document.getElementById('chart_div');
|
var chart = new google.visualization.ScatterChart(chart_div);
|
chart.draw(data, options);
|
}
|
</script>
|
</head>
|
<body>
|
<div id="chart_div" style="width: 100%; height: 100%;"></div>
|
</body>
|
</html>
|
"""
|
|
h_title = { True: 'Percentile', False: 'Time (s)' }
|
v_title = { 'bw' : 'Bandwidth (KB/s)',
|
'iops': 'IOPs',
|
'lat' : 'Total latency (us)',
|
'clat': 'Completion latency (us)',
|
'slat': 'Submission latency (us)' }
|
graph_title = { 'bw' : 'bandwidth',
|
'iops': 'IOPs',
|
'lat' : 'total latency',
|
'clat': 'completion latency',
|
'slat': 'submission latency' }
|
|
test_name = ''
|
test_type = ''
|
pass_list = ''
|
|
@classmethod
|
def _parse_log_file(cls, file_name, pass_index, pass_count, percentile):
|
"""
|
Generate row for google.visualization.DataTable from one log file.
|
Log file is the one that generated using write_{bw,lat,iops}_log
|
option in the FIO job file.
|
|
The fio log file format is timestamp, value, direction, blocksize
|
The output format for each row is { c: list of { v: value} }
|
|
@param file_name: log file name to read data from
|
@param pass_index: index of current run pass
|
@param pass_count: number of all test run passes
|
@param percentile: flag to use percentile as key instead of timestamp
|
|
@return: list of data rows in google.visualization.DataTable format
|
"""
|
# Read data from log
|
with open(file_name, 'r') as f:
|
data = []
|
|
for line in f.readlines():
|
if not line:
|
break
|
t, v, _, _ = [int(x) for x in line.split(', ')]
|
data.append([t / 1000.0, v])
|
|
# Sort & calculate percentile
|
if percentile:
|
data.sort(key=lambda x: x[1])
|
l = len(data)
|
for i in range(l):
|
data[i][0] = 100 * (i + 0.5) / l
|
|
# Generate the data row
|
all_row = []
|
row = [None] * (pass_count + 1)
|
for d in data:
|
row[0] = {'v' : '%.3f' % d[0]}
|
row[pass_index + 1] = {'v': d[1]}
|
all_row.append({'c': row[:]})
|
|
return all_row
|
|
@classmethod
|
def _gen_data_col(cls, pass_list, percentile):
|
"""
|
Generate col for google.visualization.DataTable
|
|
The output format is list of dict of label and type. In this case,
|
type is always number.
|
|
@param pass_list: list of test run passes
|
@param percentile: flag to use percentile as key instead of timestamp
|
|
@return: list of column in google.visualization.DataTable format
|
"""
|
if percentile:
|
col_name_list = ['percentile'] + [p[0] for p in pass_list]
|
else:
|
col_name_list = ['time'] + [p[0] for p in pass_list]
|
|
return [{'label': name, 'type': 'number'} for name in col_name_list]
|
|
@classmethod
|
def _gen_data_row(cls, test_type, pass_list, percentile):
|
"""
|
Generate row for google.visualization.DataTable by generate all log
|
file name and call _parse_log_file for each file
|
|
@param test_type: type of value collected for current test. i.e. IOPs
|
@param pass_list: list of run passes for current test
|
@param percentile: flag to use percentile as key instead of timestamp
|
|
@return: list of data rows in google.visualization.DataTable format
|
"""
|
all_row = []
|
pass_count = len(pass_list)
|
for pass_index, log_file_name in enumerate([p[1] for p in pass_list]):
|
all_row.extend(cls._parse_log_file(log_file_name, pass_index,
|
pass_count, percentile))
|
return all_row
|
|
@classmethod
|
def _write_data(cls, f, test_type, pass_list, percentile):
|
"""
|
Write google.visualization.DataTable object to output file.
|
https://developers.google.com/chart/interactive/docs/reference
|
|
@param f: html file to update
|
@param test_type: type of value collected for current test. i.e. IOPs
|
@param pass_list: list of run passes for current test
|
@param percentile: flag to use percentile as key instead of timestamp
|
"""
|
col = cls._gen_data_col(pass_list, percentile)
|
row = cls._gen_data_row(test_type, pass_list, percentile)
|
data_dict = {'cols' : col, 'rows' : row}
|
|
f.write('var data = new google.visualization.DataTable(')
|
json.dump(data_dict, f)
|
f.write(');\n')
|
|
@classmethod
|
def _write_option(cls, f, test_name, test_type, percentile):
|
"""
|
Write option to render scatter graph to output file.
|
https://google-developers.appspot.com/chart/interactive/docs/gallery/scatterchart
|
|
@param test_name: name of current workload. i.e. randwrite
|
@param test_type: type of value collected for current test. i.e. IOPs
|
@param percentile: flag to use percentile as key instead of timestamp
|
"""
|
option = {'pointSize': 1}
|
if percentile:
|
option['title'] = ('Percentile graph of %s for %s workload' %
|
(cls.graph_title[test_type], test_name))
|
else:
|
option['title'] = ('Graph of %s for %s workload over time' %
|
(cls.graph_title[test_type], test_name))
|
|
option['hAxis'] = {'title': cls.h_title[percentile]}
|
option['vAxis'] = {'title': cls.v_title[test_type]}
|
|
f.write('var options = ')
|
json.dump(option, f)
|
f.write(';\n')
|
|
@classmethod
|
def _write_graph(cls, test_name, test_type, pass_list, percentile=False):
|
"""
|
Generate graph for test name / test type
|
|
@param test_name: name of current workload. i.e. randwrite
|
@param test_type: type of value collected for current test. i.e. IOPs
|
@param pass_list: list of run passes for current test
|
@param percentile: flag to use percentile as key instead of timestamp
|
"""
|
logging.info('fio_graph_generator._write_graph %s %s %s',
|
test_name, test_type, str(pass_list))
|
|
|
if percentile:
|
out_file_name = '%s_%s_percentile.html' % (test_name, test_type)
|
else:
|
out_file_name = '%s_%s.html' % (test_name, test_type)
|
|
with open(out_file_name, 'w') as f:
|
f.write(cls.html_head)
|
cls._write_data(f, test_type, pass_list, percentile)
|
cls._write_option(f, test_name, test_type, percentile)
|
f.write(cls.html_tail)
|
|
def __init__(self, test_name, test_type, pass_list):
|
"""
|
@param test_name: name of current workload. i.e. randwrite
|
@param test_type: type of value collected for current test. i.e. IOPs
|
@param pass_list: list of run passes for current test
|
"""
|
self.test_name = test_name
|
self.test_type = test_type
|
self.pass_list = pass_list
|
|
def run(self):
|
"""
|
Run the graph generator.
|
"""
|
self._write_graph(self.test_name, self.test_type, self.pass_list, False)
|
self._write_graph(self.test_name, self.test_type, self.pass_list, True)
|
|
|
def fio_parse_dict(d, prefix):
|
"""
|
Parse fio json dict
|
|
Recursively flaten json dict to generate autotest perf dict
|
|
@param d: input dict
|
@param prefix: name prefix of the key
|
"""
|
|
# No need to parse something that didn't run such as read stat in write job.
|
if 'io_bytes' in d and d['io_bytes'] == 0:
|
return {}
|
|
results = {}
|
for k, v in d.items():
|
|
# remove >, >=, <, <=
|
for c in '>=<':
|
k = k.replace(c, '')
|
|
key = prefix + '_' + k
|
|
if type(v) is dict:
|
results.update(fio_parse_dict(v, key))
|
else:
|
results[key] = v
|
return results
|
|
|
def fio_parser(lines, prefix=None):
|
"""
|
Parse the json fio output
|
|
This collects all metrics given by fio and labels them according to unit
|
of measurement and test case name.
|
|
@param lines: text output of json fio output.
|
@param prefix: prefix for result keys.
|
"""
|
results = {}
|
fio_dict = json.loads(lines)
|
|
if prefix:
|
prefix = prefix + '_'
|
else:
|
prefix = ''
|
|
results[prefix + 'fio_version'] = fio_dict['fio version']
|
|
if 'disk_util' in fio_dict:
|
results.update(fio_parse_dict(fio_dict['disk_util'][0],
|
prefix + 'disk'))
|
|
for job in fio_dict['jobs']:
|
job_prefix = '_' + prefix + job['jobname']
|
job.pop('jobname')
|
|
|
for k, v in job.iteritems():
|
# Igonre "job options", its alphanumerc keys confuses tko.
|
# Besides, these keys are redundant.
|
if k == 'job options':
|
continue
|
results.update(fio_parse_dict({k:v}, job_prefix))
|
|
return results
|
|
def fio_generate_graph():
|
"""
|
Scan for fio log file in output directory and send data to generate each
|
graph to fio_graph_generator class.
|
"""
|
log_types = ['bw', 'iops', 'lat', 'clat', 'slat']
|
|
# move fio log to result dir
|
for log_type in log_types:
|
logging.info('log_type %s', log_type)
|
logs = utils.system_output('ls *_%s.*log' % log_type, ignore_status=True)
|
if not logs:
|
continue
|
|
pattern = r"""(?P<jobname>.*)_ # jobname
|
((?P<runpass>p\d+)_|) # pass
|
(?P<type>bw|iops|lat|clat|slat) # type
|
(.(?P<thread>\d+)|) # thread id for newer fio.
|
.log
|
"""
|
matcher = re.compile(pattern, re.X)
|
|
pass_list = []
|
current_job = ''
|
|
for log in logs.split():
|
match = matcher.match(log)
|
if not match:
|
logging.warn('Unknown log file %s', log)
|
continue
|
|
jobname = match.group('jobname')
|
runpass = match.group('runpass') or '1'
|
if match.group('thread'):
|
runpass += '_' + match.group('thread')
|
|
# All files for particular job name are group together for create
|
# graph that can compare performance between result from each pass.
|
if jobname != current_job:
|
if pass_list:
|
fio_graph_generator(current_job, log_type, pass_list).run()
|
current_job = jobname
|
pass_list = []
|
pass_list.append((runpass, log))
|
|
if pass_list:
|
fio_graph_generator(current_job, log_type, pass_list).run()
|
|
|
cmd = 'mv *_%s.*log results' % log_type
|
utils.run(cmd, ignore_status=True)
|
utils.run('mv *.html results', ignore_status=True)
|
|
|
def fio_runner(test, job, env_vars,
|
name_prefix=None,
|
graph_prefix=None):
|
"""
|
Runs fio.
|
|
Build a result keyval and performence json.
|
The JSON would look like:
|
{"description": "<name_prefix>_<modle>_<size>G",
|
"graph": "<graph_prefix>_1m_write_wr_lat_99.00_percent_usec",
|
"higher_is_better": false, "units": "us", "value": "xxxx"}
|
{...
|
|
|
@param test: test to upload perf value
|
@param job: fio config file to use
|
@param env_vars: environment variable fio will substituete in the fio
|
config file.
|
@param name_prefix: prefix of the descriptions to use in chrome perfi
|
dashboard.
|
@param graph_prefix: prefix of the graph name in chrome perf dashboard
|
and result keyvals.
|
@return fio results.
|
|
"""
|
|
# running fio with ionice -c 3 so it doesn't lock out other
|
# processes from the disk while it is running.
|
# If you want to run the fio test for performance purposes,
|
# take out the ionice and disable hung process detection:
|
# "echo 0 > /proc/sys/kernel/hung_task_timeout_secs"
|
# -c 3 = Idle
|
# Tried lowest priority for "best effort" but still failed
|
ionice = 'ionice -c 3'
|
options = ['--output-format=json']
|
fio_cmd_line = ' '.join([env_vars, ionice, 'fio',
|
' '.join(options),
|
'"' + job + '"'])
|
fio = utils.run(fio_cmd_line)
|
|
logging.debug(fio.stdout)
|
|
fio_generate_graph()
|
|
filename = re.match('.*FILENAME=(?P<f>[^ ]*)', env_vars).group('f')
|
diskname = utils.get_disk_from_filename(filename)
|
|
if diskname:
|
model = utils.get_disk_model(diskname)
|
size = utils.get_disk_size_gb(diskname)
|
perfdb_name = '%s_%dG' % (model, size)
|
else:
|
perfdb_name = filename.replace('/', '_')
|
|
if name_prefix:
|
perfdb_name = name_prefix + '_' + perfdb_name
|
|
result = fio_parser(fio.stdout, prefix=name_prefix)
|
if not graph_prefix:
|
graph_prefix = ''
|
|
for k, v in result.iteritems():
|
# Remove the prefix for value, and replace it the graph prefix.
|
if name_prefix:
|
k = k.replace('_' + name_prefix, graph_prefix)
|
|
# Make graph name to be same as the old code.
|
if k.endswith('bw'):
|
test.output_perf_value(description=perfdb_name, graph=k, value=v,
|
units='KB_per_sec', higher_is_better=True)
|
elif k.rstrip('0').endswith('clat_percentile_99.'):
|
test.output_perf_value(description=perfdb_name, graph=k, value=v,
|
units='us', higher_is_better=False)
|
elif k.rstrip('0').endswith('clat_ns_percentile_99.'):
|
test.output_perf_value(description=perfdb_name, graph=k, value=v,
|
units='ns', higher_is_better=False)
|
return result
|
