def _initialize_atomic(self, name, root, real_name=None, count=1):
real_name = real_name or name
root[name] = {
# streaming algorithms
"sa":
[[streaming.MinComputation(), None],
[streaming.PercentileComputation(0.5, self.iters_num), None],
[streaming.PercentileComputation(0.9, self.iters_num), None],
[streaming.PercentileComputation(0.95, self.iters_num), None],
[streaming.MaxComputation(), None],
[streaming.MeanComputation(), None],
[
streaming.MeanComputation(), lambda st, has_result:
("%.1f%%" % (st.result() * 100) if has_result else "n/a")
],
[
streaming.IncrementComputation(),
lambda st, has_result: st.result()
]],
"children":
collections.OrderedDict(),
"real_name":
real_name,
"count_per_iteration":
count
}
def __init__(self, *args, **kwargs):
super(MainStatsTable, self).__init__(*args, **kwargs)
iters_num = self._workload["total_iteration_count"]
for name in (self._get_atomic_names() + ["total"]):
self._data[name] = [
[streaming.MinComputation(), None],
[streaming.PercentileComputation(0.5, iters_num), None],
[streaming.PercentileComputation(0.9, iters_num), None],
[streaming.PercentileComputation(0.95, iters_num), None],
[streaming.MaxComputation(), None],
[streaming.MeanComputation(), None],
[streaming.MeanComputation(),
lambda st, has_result: ("%.1f%%" % (st.result() * 100)
if has_result else "n/a")],
[streaming.IncrementComputation(),
lambda st, has_result: st.result()]]
def test_stream(self):
stream = range(10)
mean_computation = algo.MeanComputation()
for value in stream:
mean_computation.add(value)
excepted_mean = float(sum(stream)) / len(stream)
self.assertEqual(excepted_mean, mean_computation.result())
def _initialize_atomic(self, name, root, real_name=None, count=1):
real_name = real_name or name
root[name] = {
# streaming algorithms
"sa": [
streaming.PointsSaver(),
streaming.MinComputation(),
streaming.MaxComputation(),
streaming.MeanComputation(),
streaming.MeanComputation(),
streaming.IncrementComputation()
],
"children":
collections.OrderedDict(),
"real_name":
real_name,
"count_per_iteration":
count
}
def test_merge(self):
single_mean = algo.MeanComputation()
for val in six.moves.range(100):
single_mean.add(val)
means = [algo.MeanComputation() for _ in six.moves.range(10)]
for idx, mean in enumerate(means):
for val in six.moves.range(idx * 10, (idx + 1) * 10):
mean.add(val)
merged_mean = means[0]
for mean in means[1:]:
merged_mean.merge(mean)
self.assertEqual(single_mean.count, merged_mean.count)
self.assertEqual(single_mean.total, merged_mean.total)
self.assertEqual(single_mean.result(), merged_mean.result())
def _init_columns(self):
return costilius.OrderedDict(
(("Min (sec)", streaming.MinComputation()),
("Median (sec)", streaming.PercentileComputation(50)),
("90%ile (sec)", streaming.PercentileComputation(90)),
("95%ile (sec)", streaming.PercentileComputation(95)),
("Max (sec)", streaming.MaxComputation()),
("Avg (sec)", streaming.MeanComputation()),
("Success", streaming.ProgressComputation(self.base_size)),
("Count", streaming.IncrementComputation())))
def __init__(self, criterion_value):
super(Outliers, self).__init__(criterion_value)
self.max_outliers = self.criterion_value.get("max", 0)
# NOTE(msdubov): Having 3 as default is reasonable (need enough data).
self.min_iterations = self.criterion_value.get("min_iterations", 3)
self.sigmas = self.criterion_value.get("sigmas", 3.0)
self.iterations = 0
self.outliers = 0
self.threshold = None
self.mean_comp = streaming_algorithms.MeanComputation()
self.std_comp = streaming_algorithms.StdDevComputation()
def _init_row(self, name, iterations_count):
def round_3(stream, no_result):
if no_result:
return "n/a"
return round(stream.result(), 3)
return [("Action", name),
("Min (sec)", streaming.MinComputation(), round_3),
("Median (sec)",
streaming.PercentileComputation(0.5,
iterations_count), round_3),
("90%ile (sec)",
streaming.PercentileComputation(0.9,
iterations_count), round_3),
("95%ile (sec)",
streaming.PercentileComputation(0.95,
iterations_count), round_3),
("Max (sec)", streaming.MaxComputation(), round_3),
("Avg (sec)", streaming.MeanComputation(), round_3),
("Success", streaming.MeanComputation(),
lambda stream, no_result: "%.1f%%" % (stream.result() * 100)),
("Count", streaming.IncrementComputation(),
lambda x, no_result: x.result())]
def add_iteration(self, iteration):
for name, value in self._map_iteration_values(iteration):
if name not in self._data:
self._data[name] = [
streaming.PointsSaver(),
streaming.IncrementComputation(),
streaming.MinComputation(),
streaming.MaxComputation(),
streaming.MeanComputation()
]
points, count, min_v, max_v, avg = self._data[name]
count.add()
for ins in (points, min_v, max_v, avg):
ins.add(value)
def add_iteration(self, iteration):
for name, value in self._map_iteration_values(iteration):
if name not in self._data:
iters_num = self._workload["total_iteration_count"]
self._data[name] = [
[streaming.MinComputation(), None],
[streaming.PercentileComputation(0.5, iters_num), None],
[streaming.PercentileComputation(0.9, iters_num), None],
[streaming.PercentileComputation(0.95, iters_num), None],
[streaming.MaxComputation(), None],
[streaming.MeanComputation(), None],
[streaming.IncrementComputation(),
lambda v, na: v.result()]]
self._data[name][-1][0].add(None)
self._data[name][-2][0].add(1)
for idx, dummy in enumerate(self._data[name][:-1]):
self._data[name][idx][0].add(value)
def add_iteration(self, iteration):
for name, value in self._map_iteration_values(iteration):
if name not in self._data:
self._data[name] = streaming.MeanComputation()
self._data[name].add(value or 0)
def test_one_value(self):
mean_computation = algo.MeanComputation()
mean_computation.add(10.0)
self.assertEqual(10.0, mean_computation.result())
def test_empty_stream(self):
mean_computation = algo.MeanComputation()
self.assertIsNone(mean_computation.result())
def __init__(self, criterion_value):
super(MaxAverageDuration, self).__init__(criterion_value)
self.avg = 0.0
self.avg_comp = streaming_algorithms.MeanComputation()
def test_empty_stream(self):
mean_computation = algo.MeanComputation()
self.assertRaises(exceptions.RallyException, mean_computation.result)
