1 # Copyright 2014: Mirantis Inc.
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
8 # http://www.apache.org/licenses/LICENSE-2.0
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
16 # yardstick comment: this is a modified copy of
17 # rally/rally/benchmark/runners/constant.py
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).
27 from __future__ import absolute_import
31 import multiprocessing
37 from six.moves import range
39 from yardstick.benchmark.runners import base
40 from yardstick.common import exceptions as y_exc
42 LOG = logging.getLogger(__name__)
45 def _worker_process(queue, cls, method_name, scenario_cfg,
46 context_cfg, aborted, output_queue):
50 runner_cfg = scenario_cfg['runner']
52 interval = runner_cfg.get("interval", 1)
53 if 'options' in scenario_cfg:
54 options = scenario_cfg['options']
55 else: # options must be instatiated if not present in yaml
57 scenario_cfg['options'] = options
59 runner_cfg['runner_id'] = os.getpid()
61 LOG.info("worker START, class %s", cls)
63 benchmark = cls(scenario_cfg, context_cfg)
65 method = getattr(benchmark, method_name)
68 if "sla" in scenario_cfg:
69 sla_action = scenario_cfg["sla"].get("action", "assert")
71 # To both be able to include the stop value and handle backwards stepping
72 def margin(start, stop):
73 return -1 if start > stop else 1
76 [range(d['start'], d['stop'] + margin(d['start'], d['stop']),
77 d['step']) for d in runner_cfg['iterators']]
78 param_names = [d['name'] for d in runner_cfg['iterators']]
80 iter_type = runner_cfg.get("iter_type", "nested_for_loops")
82 if iter_type == 'nested_for_loops':
83 # Create a complete combination set of all parameter lists
84 loop_iter = itertools.product(*param_iters)
85 elif iter_type == 'tuple_loops':
86 # Combine each i;th index of respective parameter list
87 loop_iter = six.moves.zip(*param_iters)
89 LOG.warning("iter_type unrecognized: %s", iter_type)
90 raise TypeError("iter_type unrecognized: %s" % iter_type)
92 # Populate options and run the requested method for each value combination
93 for comb_values in loop_iter:
98 LOG.debug("runner=%(runner)s seq=%(sequence)s START",
99 {"runner": runner_cfg["runner_id"], "sequence": sequence})
101 for i, value in enumerate(comb_values):
102 options[param_names[i]] = value
108 result = method(data)
109 except y_exc.SLAValidationError as error:
110 # SLA validation failed in scenario, determine what to do now
111 if sla_action == "assert":
113 elif sla_action == "monitor":
114 LOG.warning("SLA validation failed: %s", error.args)
116 except Exception as e: # pylint: disable=broad-except
117 errors = traceback.format_exc()
121 output_queue.put(result)
126 'timestamp': time.time(),
127 'sequence': sequence,
132 queue.put(benchmark_output)
134 LOG.debug("runner=%(runner)s seq=%(sequence)s END",
135 {"runner": runner_cfg["runner_id"], "sequence": sequence})
139 if errors and sla_action is None:
145 # catch any exception in teardown and convert to simple exception
146 # never pass exceptions back to multiprocessing, because some exceptions can
148 # https://bugs.python.org/issue9400
151 LOG.info("worker END")
152 LOG.debug("queue.qsize() = %s", queue.qsize())
153 LOG.debug("output_queue.qsize() = %s", output_queue.qsize())
156 class ArithmeticRunner(base.Runner):
157 """Run a scenario arithmetically stepping input value(s)
160 interval - time to wait between each scenario invocation
164 iter_type: - Iteration type of input parameter(s): nested_for_loops
168 default: nested_for_loops
170 name - name of scenario option that will be increased for each invocation
174 start - value to use in first invocation of scenario
178 stop - value indicating end of invocation. Can be set to same
179 value as start for one single value.
183 step - value added to start value in next invocation of scenario.
184 Must not be set to zero. Can be set negative if start > stop
189 name - and so on......
192 __execution_type__ = 'Arithmetic'
194 def _run_benchmark(self, cls, method, scenario_cfg, context_cfg):
195 name = "{}-{}-{}".format(self.__execution_type__, scenario_cfg.get("type"), os.getpid())
196 self.process = multiprocessing.Process(
198 target=_worker_process,
199 args=(self.result_queue, cls, method, scenario_cfg,
200 context_cfg, self.aborted, self.output_queue))