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     queue.put({'runner_id': runner_cfg['runner_id'],
  67                'scenario_cfg': scenario_cfg,
  68                'context_cfg': context_cfg})
  69
  70     sla_action = None
  71     if "sla" in scenario_cfg:
  72         sla_action = scenario_cfg["sla"].get("action", "assert")
  73
  74     # To both be able to include the stop value and handle backwards stepping
  75     def margin(start, stop):
  76         return -1 if start > stop else 1
  77
  78     param_iters = \
  79         [range(d['start'], d['stop'] + margin(d['start'], d['stop']),
  80                d['step']) for d in runner_cfg['iterators']]
  81     param_names = [d['name'] for d in runner_cfg['iterators']]
  82
  83     iter_type = runner_cfg.get("iter_type", "nested_for_loops")
  84
  85     if iter_type == 'nested_for_loops':
  86         # Create a complete combination set of all parameter lists
  87         loop_iter = itertools.product(*param_iters)
  88     elif iter_type == 'tuple_loops':
  89         # Combine each i;th index of respective parameter list
  90         loop_iter = six.moves.zip(*param_iters)
  91     else:
  92         LOG.warning("iter_type unrecognized: %s", iter_type)
  93         raise TypeError("iter_type unrecognized: %s", iter_type)
  94
  95     # Populate options and run the requested method for each value combination
  96     for comb_values in loop_iter:
  97
  98         if aborted.is_set():
  99             break
 100
 101         LOG.debug("runner=%(runner)s seq=%(sequence)s START",
 102                   {"runner": runner_cfg["runner_id"], "sequence": sequence})
 103
 104         for i, value in enumerate(comb_values):
 105             options[param_names[i]] = value
 106
 107         data = {}
 108         errors = ""
 109
 110         try:
 111             result = method(data)
 112         except AssertionError as assertion:
 113             # SLA validation failed in scenario, determine what to do now
 114             if sla_action == "assert":
 115                 raise
 116             elif sla_action == "monitor":
 117                 LOG.warning("SLA validation failed: %s", assertion.args)
 118                 errors = assertion.args
 119         except Exception as e:
 120             errors = traceback.format_exc()
 121             LOG.exception(e)
 122         else:
 123             if result:
 124                 output_queue.put(result)
 125
 126         time.sleep(interval)
 127
 128         benchmark_output = {
 129             'timestamp': time.time(),
 130             'sequence': sequence,
 131             'data': data,
 132             'errors': errors
 133         }
 134
 135         record = {'runner_id': runner_cfg['runner_id'],
 136                   'benchmark': benchmark_output}
 137
 138         queue.put(record)
 139
 140         LOG.debug("runner=%(runner)s seq=%(sequence)s END",
 141                   {"runner": runner_cfg["runner_id"], "sequence": sequence})
 142
 143         sequence += 1
 144
 145         if errors and sla_action is None:
 146             break
 147
 148     benchmark.teardown()
 149     LOG.info("worker END")
 150
 151
 152 class ArithmeticRunner(base.Runner):
 153     """Run a scenario arithmetically stepping input value(s)
 154
 155   Parameters
 156     interval - time to wait between each scenario invocation
 157         type:    int
 158         unit:    seconds
 159         default: 1 sec
 160     iter_type: - Iteration type of input parameter(s): nested_for_loops
 161                  or tuple_loops
 162         type:    string
 163         unit:    na
 164         default: nested_for_loops
 165     -
 166       name - name of scenario option that will be increased for each invocation
 167           type:    string
 168           unit:    na
 169           default: na
 170       start - value to use in first invocation of scenario
 171           type:    int
 172           unit:    na
 173           default: none
 174       stop - value indicating end of invocation. Can be set to same
 175              value as start for one single value.
 176           type:    int
 177           unit:    na
 178           default: none
 179       step - value added to start value in next invocation of scenario.
 180              Must not be set to zero. Can be set negative if start > stop
 181           type:    int
 182           unit:    na
 183           default: none
 184     -
 185       name - and so on......
 186     """
 187
 188     __execution_type__ = 'Arithmetic'
 189
 190     def _run_benchmark(self, cls, method, scenario_cfg, context_cfg):
 191         self.process = multiprocessing.Process(
 192             target=_worker_process,
 193             args=(self.result_queue, cls, method, scenario_cfg,
 194                   context_cfg, self.aborted, self.output_queue))
 195         self.process.start()