yardstick/benchmark/scenarios/compute/cyclictest.py

   1 ##############################################################################
   2 # Copyright (c) 2015 Huawei Technologies Co.,Ltd and other.
   3 #
   4 # All rights reserved. This program and the accompanying materials
   5 # are made available under the terms of the Apache License, Version 2.0
   6 # which accompanies this distribution, and is available at
   7 # http://www.apache.org/licenses/LICENSE-2.0
   8 ##############################################################################
   9 from __future__ import absolute_import
  10 from __future__ import print_function
  11
  12 import logging
  13 import os
  14 import re
  15 import time
  16
  17 import pkg_resources
  18 from oslo_serialization import jsonutils
  19
  20 import yardstick.ssh as ssh
  21 from yardstick.benchmark.scenarios import base
  22
  23 LOG = logging.getLogger(__name__)
  24 LOG.setLevel(logging.DEBUG)
  25
  26
  27 class Cyclictest(base.Scenario):
  28     """Execute cyclictest benchmark on guest vm
  29
  30   Parameters
  31     affinity - run thread #N on processor #N, if possible
  32         type:    int
  33         unit:    na
  34         default: 1
  35     interval - base interval of thread
  36         type:    int
  37         unit:    us
  38         default: 1000
  39     loops - number of loops, 0 for endless
  40         type:    int
  41         unit:    na
  42         default: 1000
  43     priority - priority of highest prio thread
  44         type:    int
  45         unit:    na
  46         default: 99
  47     threads - number of threads
  48         type:    int
  49         unit:    na
  50         default: 1
  51     histogram - dump a latency histogram to stdout after the run
  52                 here set the max time to be tracked
  53         type:    int
  54         unit:    ms
  55         default: 90
  56
  57     Read link below for more fio args description:
  58         https://rt.wiki.kernel.org/index.php/Cyclictest
  59     """
  60     __scenario_type__ = "Cyclictest"
  61
  62     TARGET_SCRIPT = "cyclictest_benchmark.bash"
  63     WORKSPACE = "/root/workspace/"
  64     REBOOT_CMD_PATTERN = r";\s*reboot\b"
  65
  66     def __init__(self, scenario_cfg, context_cfg):
  67         self.scenario_cfg = scenario_cfg
  68         self.context_cfg = context_cfg
  69         self.setup_done = False
  70
  71     def _put_files(self, client):
  72         setup_options = self.scenario_cfg["setup_options"]
  73         rpm_dir = setup_options["rpm_dir"]
  74         script_dir = setup_options["script_dir"]
  75         image_dir = setup_options["image_dir"]
  76         LOG.debug("Send RPMs from %s to workspace %s",
  77                   rpm_dir, self.WORKSPACE)
  78         client.put(rpm_dir, self.WORKSPACE, recursive=True)
  79         LOG.debug("Send scripts from %s to workspace %s",
  80                   script_dir, self.WORKSPACE)
  81         client.put(script_dir, self.WORKSPACE, recursive=True)
  82         LOG.debug("Send guest image from %s to workspace %s",
  83                   image_dir, self.WORKSPACE)
  84         client.put(image_dir, self.WORKSPACE, recursive=True)
  85
  86     def _connect_host(self):
  87         host = self.context_cfg["host"]
  88
  89         self.host = ssh.SSH.from_node(host, defaults={"user": "root"})
  90         self.host.wait(timeout=600)
  91
  92     def _connect_guest(self):
  93         host = self.context_cfg["host"]
  94         # why port 5555?
  95         self.guest = ssh.SSH.from_node(host,
  96                                        defaults={
  97                                            "user": "root", "ssh_port": 5555
  98                                        })
  99         self.guest.wait(timeout=600)
 100
 101     def _run_setup_cmd(self, client, cmd):
 102         LOG.debug("Run cmd: %s", cmd)
 103         status, stdout, stderr = client.execute(cmd)
 104         if status:
 105             if re.search(self.REBOOT_CMD_PATTERN, cmd):
 106                 LOG.debug("Error on reboot")
 107             else:
 108                 raise RuntimeError(stderr)
 109
 110     def _run_host_setup_scripts(self, scripts):
 111         setup_options = self.scenario_cfg["setup_options"]
 112         script_dir = os.path.basename(setup_options["script_dir"])
 113
 114         for script in scripts:
 115             cmd = "cd %s/%s; export PATH=./:$PATH; %s" %\
 116                   (self.WORKSPACE, script_dir, script)
 117             self._run_setup_cmd(self.host, cmd)
 118
 119             if re.search(self.REBOOT_CMD_PATTERN, cmd):
 120                 time.sleep(3)
 121                 self._connect_host()
 122
 123     def _run_guest_setup_scripts(self, scripts):
 124         setup_options = self.scenario_cfg["setup_options"]
 125         script_dir = os.path.basename(setup_options["script_dir"])
 126
 127         for script in scripts:
 128             cmd = "cd %s/%s; export PATH=./:$PATH; %s" %\
 129                   (self.WORKSPACE, script_dir, script)
 130             self._run_setup_cmd(self.guest, cmd)
 131
 132             if re.search(self.REBOOT_CMD_PATTERN, cmd):
 133                 time.sleep(3)
 134                 self._connect_guest()
 135
 136     def setup(self):
 137         """scenario setup"""
 138         setup_options = self.scenario_cfg["setup_options"]
 139         host_setup_seqs = setup_options["host_setup_seqs"]
 140         guest_setup_seqs = setup_options["guest_setup_seqs"]
 141
 142         self._connect_host()
 143         self._put_files(self.host)
 144         self._run_host_setup_scripts(host_setup_seqs)
 145
 146         self._connect_guest()
 147         self._put_files(self.guest)
 148         self._run_guest_setup_scripts(guest_setup_seqs)
 149
 150         # copy script to host
 151         self.target_script = pkg_resources.resource_filename(
 152             "yardstick.benchmark.scenarios.compute",
 153             Cyclictest.TARGET_SCRIPT)
 154         self.guest._put_file_shell(
 155             self.target_script, '~/cyclictest_benchmark.sh')
 156
 157         self.setup_done = True
 158
 159     def run(self, result):
 160         """execute the benchmark"""
 161         default_args = "-m -n -q"
 162
 163         if not self.setup_done:
 164             self.setup()
 165
 166         options = self.scenario_cfg["options"]
 167         affinity = options.get("affinity", 1)
 168         interval = options.get("interval", 1000)
 169         priority = options.get("priority", 99)
 170         loops = options.get("loops", 1000)
 171         threads = options.get("threads", 1)
 172         histogram = options.get("histogram", 90)
 173
 174         cmd_args = "-a %s -i %s -p %s -l %s -t %s -h %s %s" \
 175                    % (affinity, interval, priority, loops,
 176                       threads, histogram, default_args)
 177         cmd = "bash cyclictest_benchmark.sh %s" % (cmd_args)
 178         LOG.debug("Executing command: %s", cmd)
 179         status, stdout, stderr = self.guest.execute(cmd)
 180         if status:
 181             raise RuntimeError(stderr)
 182
 183         result.update(jsonutils.loads(stdout))
 184
 185         if "sla" in self.scenario_cfg:
 186             sla_error = ""
 187             for t, latency in result.items():
 188                 if 'max_%s_latency' % t not in self.scenario_cfg['sla']:
 189                     continue
 190
 191                 sla_latency = int(self.scenario_cfg['sla'][
 192                                   'max_%s_latency' % t])
 193                 latency = int(latency)
 194                 if latency > sla_latency:
 195                     sla_error += "%s latency %d > sla:max_%s_latency(%d); " % \
 196                         (t, latency, t, sla_latency)
 197             assert sla_error == "", sla_error
 198
 199
 200 def _test():    # pragma: no cover
 201     """internal test function"""
 202     key_filename = pkg_resources.resource_filename("yardstick.resources",
 203                                                    "files/yardstick_key")
 204     ctx = {
 205         "host": {
 206             "ip": "10.229.47.137",
 207             "user": "root",
 208             "key_filename": key_filename
 209         }
 210     }
 211
 212     logger = logging.getLogger("yardstick")
 213     logger.setLevel(logging.DEBUG)
 214
 215     options = {
 216         "affinity": 2,
 217         "interval": 100,
 218         "priority": 88,
 219         "loops": 10000,
 220         "threads": 2,
 221         "histogram": 80
 222     }
 223     sla = {
 224         "max_min_latency": 100,
 225         "max_avg_latency": 500,
 226         "max_max_latency": 1000,
 227     }
 228     args = {
 229         "options": options,
 230         "sla": sla
 231     }
 232     result = {}
 233
 234     cyclictest = Cyclictest(args, ctx)
 235     cyclictest.run(result)
 236     print(result)
 237
 238
 239 if __name__ == '__main__':    # pragma: no cover
 240     _test()