yardstick/benchmark/runners/arithmetic.py

   1 # Copyright 2014: Mirantis Inc.
   2 # All Rights Reserved.
   3 #
   4 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
   5 #    not use this file except in compliance with the License. You may obtain
   6 #    a copy of the License at
   7 #
   8 #         http://www.apache.org/licenses/LICENSE-2.0
   9 #
  10 #    Unless required by applicable law or agreed to in writing, software
  11 #    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  12 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  13 #    License for the specific language governing permissions and limitations
  14 #    under the License.
  15
  16 # yardstick comment: this is a modified copy of
  17 # rally/rally/benchmark/runners/constant.py
  18
  19 """A runner that every run arithmetically steps specified input value(s) to
  20 the scenario. This just means step value(s) is added to the previous value(s).
  21 It is possible to combine several named input values and run with those either
  22 as nested for loops or combine each i:th index of each "input value list"
  23 until the end of the shortest list is reached (optimally all lists should be
  24 defined with the same number of values when using such iter_type).
  25 """
  26
  27 from __future__ import absolute_import
  28
  29 import itertools
  30 import logging
  31 import multiprocessing
  32 import os
  33 import time
  34 import traceback
  35
  36 import six
  37 from six.moves import range
  38
  39 from yardstick.benchmark.runners import base
  40
  41 LOG = logging.getLogger(__name__)
  42
  43
  44 def _worker_process(queue, cls, method_name, scenario_cfg,
  45                     context_cfg, aborted, output_queue):
  46
  47     sequence = 1
  48
  49     runner_cfg = scenario_cfg['runner']
  50
  51     interval = runner_cfg.get("interval", 1)
  52     if 'options' in scenario_cfg:
  53         options = scenario_cfg['options']
  54     else:  # options must be instatiated if not present in yaml
  55         options = {}
  56         scenario_cfg['options'] = options
  57
  58     runner_cfg['runner_id'] = os.getpid()
  59
  60     LOG.info("worker START, class %s", cls)
  61
  62     benchmark = cls(scenario_cfg, context_cfg)
  63     benchmark.setup()
  64     method = getattr(benchmark, method_name)
  65
  66     sla_action = None
  67     if "sla" in scenario_cfg:
  68         sla_action = scenario_cfg["sla"].get("action", "assert")
  69
  70     # To both be able to include the stop value and handle backwards stepping
  71     def margin(start, stop):
  72         return -1 if start > stop else 1
  73
  74     param_iters = \
  75         [range(d['start'], d['stop'] + margin(d['start'], d['stop']),
  76                d['step']) for d in runner_cfg['iterators']]
  77     param_names = [d['name'] for d in runner_cfg['iterators']]
  78
  79     iter_type = runner_cfg.get("iter_type", "nested_for_loops")
  80
  81     if iter_type == 'nested_for_loops':
  82         # Create a complete combination set of all parameter lists
  83         loop_iter = itertools.product(*param_iters)
  84     elif iter_type == 'tuple_loops':
  85         # Combine each i;th index of respective parameter list
  86         loop_iter = six.moves.zip(*param_iters)
  87     else:
  88         LOG.warning("iter_type unrecognized: %s", iter_type)
  89         raise TypeError("iter_type unrecognized: %s", iter_type)
  90
  91     # Populate options and run the requested method for each value combination
  92     for comb_values in loop_iter:
  93
  94         if aborted.is_set():
  95             break
  96
  97         LOG.debug("runner=%(runner)s seq=%(sequence)s START",
  98                   {"runner": runner_cfg["runner_id"], "sequence": sequence})
  99
 100         for i, value in enumerate(comb_values):
 101             options[param_names[i]] = value
 102
 103         data = {}
 104         errors = ""
 105
 106         try:
 107             result = method(data)
 108         except AssertionError as assertion:
 109             # SLA validation failed in scenario, determine what to do now
 110             if sla_action == "assert":
 111                 raise
 112             elif sla_action == "monitor":
 113                 LOG.warning("SLA validation failed: %s", assertion.args)
 114                 errors = assertion.args
 115         except Exception as e:
 116             errors = traceback.format_exc()
 117             LOG.exception(e)
 118         else:
 119             if result:
 120                 output_queue.put(result)
 121
 122         time.sleep(interval)
 123
 124         benchmark_output = {
 125             'timestamp': time.time(),
 126             'sequence': sequence,
 127             'data': data,
 128             'errors': errors
 129         }
 130
 131         queue.put(benchmark_output)
 132
 133         LOG.debug("runner=%(runner)s seq=%(sequence)s END",
 134                   {"runner": runner_cfg["runner_id"], "sequence": sequence})
 135
 136         sequence += 1
 137
 138         if errors and sla_action is None:
 139             break
 140
 141     try:
 142         benchmark.teardown()
 143     except Exception:
 144         # catch any exception in teardown and convert to simple exception
 145         # never pass exceptions back to multiprocessing, because some exceptions can
 146         # be unpicklable
 147         # https://bugs.python.org/issue9400
 148         LOG.exception("")
 149         raise SystemExit(1)
 150     LOG.info("worker END")
 151     LOG.debug("queue.qsize() = %s", queue.qsize())
 152     LOG.debug("output_queue.qsize() = %s", output_queue.qsize())
 153
 154
 155 class ArithmeticRunner(base.Runner):
 156     """Run a scenario arithmetically stepping input value(s)
 157
 158   Parameters
 159     interval - time to wait between each scenario invocation
 160         type:    int
 161         unit:    seconds
 162         default: 1 sec
 163     iter_type: - Iteration type of input parameter(s): nested_for_loops
 164                  or tuple_loops
 165         type:    string
 166         unit:    na
 167         default: nested_for_loops
 168     -
 169       name - name of scenario option that will be increased for each invocation
 170           type:    string
 171           unit:    na
 172           default: na
 173       start - value to use in first invocation of scenario
 174           type:    int
 175           unit:    na
 176           default: none
 177       stop - value indicating end of invocation. Can be set to same
 178              value as start for one single value.
 179           type:    int
 180           unit:    na
 181           default: none
 182       step - value added to start value in next invocation of scenario.
 183              Must not be set to zero. Can be set negative if start > stop
 184           type:    int
 185           unit:    na
 186           default: none
 187     -
 188       name - and so on......
 189     """
 190
 191     __execution_type__ = 'Arithmetic'
 192
 193     def _run_benchmark(self, cls, method, scenario_cfg, context_cfg):
 194         name = "{}-{}-{}".format(self.__execution_type__, scenario_cfg.get("type"), os.getpid())
 195         self.process = multiprocessing.Process(
 196             name=name,
 197             target=_worker_process,
 198             args=(self.result_queue, cls, method, scenario_cfg,
 199                   context_cfg, self.aborted, self.output_queue))
 200         self.process.start()