diff --git a/wa/workloads/sysbench/LICENSE b/wa/workloads/sysbench/LICENSE new file mode 100644 index 00000000..89abf69c --- /dev/null +++ b/wa/workloads/sysbench/LICENSE @@ -0,0 +1,24 @@ +Included sysbench binary is Free Software ditributed under GPLv2: + +/* Copyright (C) 2004 MySQL AB +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +*/ + +The full text of the license may be viewed here: + +http://www.gnu.org/licenses/gpl-2.0.html + +Source code for sysbench may be obtained here: + +https://github.com/akopytov/sysbench + diff --git a/wa/workloads/sysbench/__init__.py b/wa/workloads/sysbench/__init__.py new file mode 100644 index 00000000..fd960953 --- /dev/null +++ b/wa/workloads/sysbench/__init__.py @@ -0,0 +1,215 @@ +# Copyright 2013-2015 ARM Limited +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +# pylint: disable=E1101,W0201,E0203 + +import os + +from wa import Workload, Parameter, Executable, WorkloadError, ConfigError +from wa.utils.exec_control import once +from wa.utils.misc import parse_value +from wa.utils.types import numeric + + +class Sysbench(Workload): + + name = 'sysbench' + description = """ + A modular, cross-platform and multi-threaded benchmark tool for evaluating + OS parameters that are important for a system running a database under + intensive load. + + The idea of this benchmark suite is to quickly get an impression about + system performance without setting up complex database benchmarks or + even without installing a database at all. + + **Features of SysBench** + + * file I/O performance + * scheduler performance + * memory allocation and transfer speed + * POSIX threads implementation performance + * database server performance + + + See: https://github.com/akopytov/sysbench + + """ + + parameters = [ + Parameter('timeout', kind=int, default=300, + description=''' + timeout for workload execution (adjust from default if + running on a slow target and/or specifying a large value for + ``max_requests`` + '''), + Parameter('test', kind=str, default='cpu', + allowed_values=['fileio', 'cpu', 'memory', 'threads', 'mutex'], + description='sysbench test to run'), + Parameter('num_threads', kind=int, default=8, + description=''' + The number of threads sysbench will launch. + '''), + Parameter('max_requests', kind=int, default=None, + description='The limit for the total number of requests.'), + Parameter('max_time', kind=int, default=None, + description=''' + The limit for the total execution time. If neither this nor + ``max_requests`` is specified, this will default to 30 + seconds. + '''), + Parameter('file_test_mode', default=None, + allowed_values=['seqwr', 'seqrewr', 'seqrd', 'rndrd', 'rndwr', 'rndrw'], + description=''' + File test mode to use. This should only be specified if + ``test`` is ``"fileio"``; if that is the case and + ``file_test_mode`` is not specified, it will default to + ``"seqwr"`` (please see sysbench documentation for + explanation of various modes). + '''), + Parameter('cmd_params', kind=str, default='', + description=''' + Additional parameters to be passed to sysbench as a single + string. + '''), + Parameter('taskset_mask', kind=int, default=0, + description=''' + The processes spawned by sysbench will be pinned to cores as + specified by this parameter. + '''), + ] + + def validate(self): + if (self.max_requests is None) and (self.max_time is None): + self.max_time = 30 + if self.max_time and (self.max_time + 10) > self.timeout: + self.timeout = self.max_time + 10 + if self.test == 'fileio' and not self.file_test_mode: + self.logger.debug('Test is "fileio" and no file_test_mode specified -- using default.') + self.file_test_mode = 'seqwr' + elif self.test != 'fileio' and self.file_test_mode: + raise ConfigError('file_test_mode must not be specified unless test is "fileio"') + + @once + def initialize(self, context): + exe = Executable(self, self.target.abi, 'sysbench') + host_binary = context.resolver.get(exe) + Sysbench.target_binary = self.target.install(host_binary) + + def setup(self, context): + self.host_results_file = None + params = dict(test=self.test, + num_threads=self.num_threads) + if self.max_requests: + params['max_requests'] = self.max_requests + if self.max_time: + params['max_time'] = self.max_time + self.target_results_file = self.target.get_workpath('sysbench_result.txt') + self.command = self._build_command(**params) + + def run(self, context): + self.target.execute(self.command, timeout=self.timeout) + + def extract_results(self, context): + self.host_results_file = os.path.join(context.output_directory, 'sysbench_result.txt') + self.target.pull(self.target_results_file, self.host_results_file) + context.add_artifact('sysbench_output', self.host_results_file, kind='raw') + + def update_output(self, context): + if not os.path.exists(self.host_results_file): + self.logger.warning('No results file found.') + return + + with open(self.host_results_file) as fh: + find_line_with('General statistics:', fh) + extract_metric('total time', fh.next(), context.output) + extract_metric('total number of events', fh.next(), context.output, lower_is_better=False) + find_line_with('response time:', fh) + extract_metric('min', fh.next(), context.output, 'response time ') + extract_metric('avg', fh.next(), context.output, 'response time ') + extract_metric('max', fh.next(), context.output, 'response time ') + extract_metric('approx. 95 percentile', fh.next(), context.output) + find_line_with('Threads fairness:', fh) + extract_threads_fairness_metric('events', fh.next(), context.output) + extract_threads_fairness_metric('execution time', fh.next(), context.output) + + def teardown(self, context): + self.target.remove(self.target_results_file) + + @once + def finalize(self, context): + self.target.uninstall('sysbench') + + def _build_command(self, **parameters): + param_strings = ['--{}={}'.format(k.replace('_', '-'), v) + for k, v in parameters.iteritems()] + if self.file_test_mode: + param_strings.append('--file-test-mode={}'.format(self.file_test_mode)) + sysbench_command = '{} {} {} run'.format(self.target_binary, ' '.join(param_strings), self.cmd_params) + if self.taskset_mask: + taskset_string = '{} taskset 0x{:x} '.format(self.target.busybox, self.taskset_mask) + else: + taskset_string = '' + return 'cd {} && {} {} > sysbench_result.txt'.format(self.target.working_directory, taskset_string, sysbench_command) + + +# Utility functions + +def find_line_with(text, fh): + for line in fh: + if text in line: + return + message = 'Could not extract sysbench results from {}; did not see "{}"' + raise WorkloadError(message.format(fh.name, text)) + + +def extract_metric(metric, line, output, prefix='', lower_is_better=True): + try: + name, value_part = [part.strip() for part in line.split(':')] + if name != metric: + message = 'Name mismatch: expected "{}", got "{}"' + raise WorkloadError(message.format(metric, name.strip())) + if not value_part or not value_part[0].isdigit(): + raise ValueError('value part does not start with a digit: {}'.format(value_part)) + idx = -1 + if not value_part[idx].isdigit(): # units detected at the end of the line + while not value_part[idx - 1].isdigit(): + idx -= 1 + value = numeric(value_part[:idx]) + units = value_part[idx:] + else: + value = numeric(value_part) + units = None + output.add_metric(prefix + metric, + value, units, lower_is_better=lower_is_better) + except Exception as e: + message = 'Could not extract sysbench metric "{}"; got "{}"' + raise WorkloadError(message.format(prefix + metric, e)) + + +def extract_threads_fairness_metric(metric, line, output): + try: + name_part, value_part = [part.strip() for part in line.split(':')] + name = name_part.split('(')[0].strip() + if name != metric: + message = 'Name mismatch: expected "{}", got "{}"' + raise WorkloadError(message.format(metric, name)) + avg, stddev = [numeric(v) for v in value_part.split('/')] + output.add_metric('thread fairness {} avg'.format(metric), avg) + output.add_metric('thread fairness {} stddev'.format(metric), + stddev, lower_is_better=True) + except Exception as e: + message = 'Could not extract sysbench metric "{}"; got "{}"' + raise WorkloadError(message.format(metric, e)) diff --git a/wa/workloads/sysbench/bin/arm64/sysbench b/wa/workloads/sysbench/bin/arm64/sysbench new file mode 100755 index 00000000..e04ab996 Binary files /dev/null and b/wa/workloads/sysbench/bin/arm64/sysbench differ diff --git a/wa/workloads/sysbench/bin/armeabi/sysbench b/wa/workloads/sysbench/bin/armeabi/sysbench new file mode 100644 index 00000000..7004dfba Binary files /dev/null and b/wa/workloads/sysbench/bin/armeabi/sysbench differ