1 # Copyright (c) 2018 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
6 # http://www.apache.org/licenses/LICENSE-2.0
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
14 """Algorithms to generate plots.
20 import plotly.offline as ploff
21 import plotly.graph_objs as plgo
23 from plotly.exceptions import PlotlyError
24 from collections import OrderedDict
25 from copy import deepcopy
27 from utils import mean
30 COLORS = ["SkyBlue", "Olive", "Purple", "Coral", "Indigo", "Pink",
31 "Chocolate", "Brown", "Magenta", "Cyan", "Orange", "Black",
32 "Violet", "Blue", "Yellow", "BurlyWood", "CadetBlue", "Crimson",
33 "DarkBlue", "DarkCyan", "DarkGreen", "Green", "GoldenRod",
34 "LightGreen", "LightSeaGreen", "LightSkyBlue", "Maroon",
35 "MediumSeaGreen", "SeaGreen", "LightSlateGrey"]
38 def generate_plots(spec, data):
39 """Generate all plots specified in the specification file.
41 :param spec: Specification read from the specification file.
42 :param data: Data to process.
43 :type spec: Specification
47 logging.info("Generating the plots ...")
48 for index, plot in enumerate(spec.plots):
50 logging.info(" Plot nr {0}: {1}".format(index + 1,
51 plot.get("title", "")))
52 plot["limits"] = spec.configuration["limits"]
53 eval(plot["algorithm"])(plot, data)
54 logging.info(" Done.")
55 except NameError as err:
56 logging.error("Probably algorithm '{alg}' is not defined: {err}".
57 format(alg=plot["algorithm"], err=repr(err)))
61 def plot_performance_box(plot, input_data):
62 """Generate the plot(s) with algorithm: plot_performance_box
63 specified in the specification file.
65 :param plot: Plot to generate.
66 :param input_data: Data to process.
67 :type plot: pandas.Series
68 :type input_data: InputData
72 plot_title = plot.get("title", "")
73 logging.info(" Creating the data set for the {0} '{1}'.".
74 format(plot.get("type", ""), plot_title))
75 data = input_data.filter_data(plot)
77 logging.error("No data.")
80 # Prepare the data for the plot
86 if y_vals.get(test["parent"], None) is None:
87 y_vals[test["parent"]] = list()
88 y_tags[test["parent"]] = test.get("tags", None)
90 if test["type"] in ("NDRPDR", ):
91 if "-pdr" in plot_title.lower():
92 y_vals[test["parent"]].\
93 append(test["throughput"]["PDR"]["LOWER"])
94 elif "-ndr" in plot_title.lower():
95 y_vals[test["parent"]]. \
96 append(test["throughput"]["NDR"]["LOWER"])
101 except (KeyError, TypeError):
102 y_vals[test["parent"]].append(None)
105 order = plot.get("sort", None)
107 y_sorted = OrderedDict()
108 y_tags_l = {s: [t.lower() for t in ts] for s, ts in y_tags.items()}
111 for suite, tags in y_tags_l.items():
113 tag = tag.split(" ")[-1]
114 if tag.lower() in tags:
117 if tag.lower() not in tags:
120 y_sorted[suite] = y_vals.pop(suite)
123 except KeyError as err:
124 logging.error("Not found: {0}".format(err))
130 # Add None to the lists with missing data
132 for val in y_sorted.values():
133 if len(val) > max_len:
135 for key, val in y_sorted.items():
136 if len(val) < max_len:
137 val.extend([None for _ in range(max_len - len(val))])
141 df = pd.DataFrame(y_sorted)
144 for i, col in enumerate(df.columns):
145 name = "{0}. {1}".format(i + 1, col.lower().replace('-ndrpdrdisc', '').
146 replace('-ndrpdr', ''))
148 traces.append(plgo.Box(x=[str(i + 1) + '.'] * len(df[col]),
149 y=[y / 1000000 if y else None for y in df[col]],
153 val_max = max(df[col])
154 except ValueError as err:
158 y_max.append(int(val_max / 1000000) + 1)
162 layout = deepcopy(plot["layout"])
163 if layout.get("title", None):
164 layout["title"] = "<b>Packet Throughput:</b> {0}". \
165 format(layout["title"])
167 layout["yaxis"]["range"] = [0, max(y_max)]
168 plpl = plgo.Figure(data=traces, layout=layout)
171 logging.info(" Writing file '{0}{1}'.".
172 format(plot["output-file"], plot["output-file-type"]))
173 ploff.plot(plpl, show_link=False, auto_open=False,
174 filename='{0}{1}'.format(plot["output-file"],
175 plot["output-file-type"]))
176 except PlotlyError as err:
177 logging.error(" Finished with error: {}".
178 format(str(err).replace("\n", " ")))
182 def plot_latency_error_bars(plot, input_data):
183 """Generate the plot(s) with algorithm: plot_latency_error_bars
184 specified in the specification file.
186 :param plot: Plot to generate.
187 :param input_data: Data to process.
188 :type plot: pandas.Series
189 :type input_data: InputData
193 plot_title = plot.get("title", "")
194 logging.info(" Creating the data set for the {0} '{1}'.".
195 format(plot.get("type", ""), plot_title))
196 data = input_data.filter_data(plot)
198 logging.error("No data.")
201 # Prepare the data for the plot
207 if y_tmp_vals.get(test["parent"], None) is None:
208 y_tmp_vals[test["parent"]] = [
209 list(), # direction1, min
210 list(), # direction1, avg
211 list(), # direction1, max
212 list(), # direction2, min
213 list(), # direction2, avg
214 list() # direction2, max
216 y_tags[test["parent"]] = test.get("tags", None)
218 if test["type"] in ("NDRPDR", ):
219 if "-pdr" in plot_title.lower():
221 elif "-ndr" in plot_title.lower():
225 y_tmp_vals[test["parent"]][0].append(
226 test["latency"][ttype]["direction1"]["min"])
227 y_tmp_vals[test["parent"]][1].append(
228 test["latency"][ttype]["direction1"]["avg"])
229 y_tmp_vals[test["parent"]][2].append(
230 test["latency"][ttype]["direction1"]["max"])
231 y_tmp_vals[test["parent"]][3].append(
232 test["latency"][ttype]["direction2"]["min"])
233 y_tmp_vals[test["parent"]][4].append(
234 test["latency"][ttype]["direction2"]["avg"])
235 y_tmp_vals[test["parent"]][5].append(
236 test["latency"][ttype]["direction2"]["max"])
239 except (KeyError, TypeError):
243 order = plot.get("sort", None)
245 y_sorted = OrderedDict()
246 y_tags_l = {s: [t.lower() for t in ts] for s, ts in y_tags.items()}
249 for suite, tags in y_tags_l.items():
251 tag = tag.split(" ")[-1]
252 if tag.lower() in tags:
255 if tag.lower() not in tags:
258 y_sorted[suite] = y_tmp_vals.pop(suite)
261 except KeyError as err:
262 logging.error("Not found: {0}".format(err))
266 y_sorted = y_tmp_vals
272 for key, val in y_sorted.items():
273 key = "-".join(key.split("-")[1:-1])
274 x_vals.append(key) # dir 1
275 y_vals.append(mean(val[1]) if val[1] else None)
276 y_mins.append(mean(val[0]) if val[0] else None)
277 y_maxs.append(mean(val[2]) if val[2] else None)
278 x_vals.append(key) # dir 2
279 y_vals.append(mean(val[4]) if val[4] else None)
280 y_mins.append(mean(val[3]) if val[3] else None)
281 y_maxs.append(mean(val[5]) if val[5] else None)
286 for idx in range(len(x_vals)):
287 if not bool(int(idx % 2)):
288 direction = "West - East"
290 direction = "East - West"
291 hovertext = ("Test: {test}<br>"
292 "Direction: {dir}<br>".format(test=x_vals[idx],
294 if isinstance(y_maxs[idx], float):
295 hovertext += "Max: {max:.2f}uSec<br>".format(max=y_maxs[idx])
296 if isinstance(y_vals[idx], float):
297 hovertext += "Avg: {avg:.2f}uSec<br>".format(avg=y_vals[idx])
298 if isinstance(y_mins[idx], float):
299 hovertext += "Min: {min:.2f}uSec".format(min=y_mins[idx])
301 if isinstance(y_maxs[idx], float) and isinstance(y_vals[idx], float):
302 array = [y_maxs[idx] - y_vals[idx], ]
305 if isinstance(y_mins[idx], float) and isinstance(y_vals[idx], float):
306 arrayminus = [y_vals[idx] - y_mins[idx], ]
308 arrayminus = [None, ]
309 traces.append(plgo.Scatter(
313 legendgroup=x_vals[idx],
314 showlegend=bool(int(idx % 2)),
320 arrayminus=arrayminus,
321 color=COLORS[int(idx / 2)]
325 color=COLORS[int(idx / 2)],
330 annotations.append(dict(
337 text="E-W" if bool(int(idx % 2)) else "W-E",
347 logging.info(" Writing file '{0}{1}'.".
348 format(plot["output-file"], plot["output-file-type"]))
349 layout = deepcopy(plot["layout"])
350 if layout.get("title", None):
351 layout["title"] = "<b>Packet Latency:</b> {0}".\
352 format(layout["title"])
353 layout["annotations"] = annotations
354 plpl = plgo.Figure(data=traces, layout=layout)
358 show_link=False, auto_open=False,
359 filename='{0}{1}'.format(plot["output-file"],
360 plot["output-file-type"]))
361 except PlotlyError as err:
362 logging.error(" Finished with error: {}".
363 format(str(err).replace("\n", " ")))
367 def plot_throughput_speedup_analysis(plot, input_data):
368 """Generate the plot(s) with algorithm:
369 plot_throughput_speedup_analysis
370 specified in the specification file.
372 :param plot: Plot to generate.
373 :param input_data: Data to process.
374 :type plot: pandas.Series
375 :type input_data: InputData
379 plot_title = plot.get("title", "")
380 logging.info(" Creating the data set for the {0} '{1}'.".
381 format(plot.get("type", ""), plot_title))
382 data = input_data.filter_data(plot)
384 logging.error("No data.")
392 if y_vals.get(test["parent"], None) is None:
393 y_vals[test["parent"]] = {"1": list(),
396 y_tags[test["parent"]] = test.get("tags", None)
398 if test["type"] in ("NDRPDR",):
399 if "-pdr" in plot_title.lower():
401 elif "-ndr" in plot_title.lower():
405 if "1C" in test["tags"]:
406 y_vals[test["parent"]]["1"]. \
407 append(test["throughput"][ttype]["LOWER"])
408 elif "2C" in test["tags"]:
409 y_vals[test["parent"]]["2"]. \
410 append(test["throughput"][ttype]["LOWER"])
411 elif "4C" in test["tags"]:
412 y_vals[test["parent"]]["4"]. \
413 append(test["throughput"][ttype]["LOWER"])
414 except (KeyError, TypeError):
418 logging.warning("No data for the plot '{}'".
419 format(plot.get("title", "")))
423 for test_name, test_vals in y_vals.items():
424 for key, test_val in test_vals.items():
426 y_vals[test_name][key] = sum(test_val) / len(test_val)
428 y_1c_max[test_name] = max(test_val) / 1000000.0
434 pci_limit = plot["limits"]["pci"]["pci-g3-x8"]
435 for test_name, test_vals in y_vals.items():
437 name = "-".join(test_name.split('-')[1:-1])
440 y_val_1 = test_vals["1"] / 1000000.0
441 y_val_2 = test_vals["2"] / 1000000.0 if test_vals["2"] else None
442 y_val_4 = test_vals["4"] / 1000000.0 if test_vals["4"] else None
444 vals[name]["val"] = [y_val_1, y_val_2, y_val_4]
445 vals[name]["rel"] = [1.0, None, None]
446 vals[name]["ideal"] = [y_1c_max[test_name],
447 y_1c_max[test_name] * 2,
448 y_1c_max[test_name] * 4]
449 vals[name]["diff"] = \
450 [(y_val_1 - y_1c_max[test_name]) * 100 / y_val_1, None, None]
453 val_max = max(max(vals[name]["val"], vals[name]["ideal"]))
454 except ValueError as err:
458 y_max.append(int((val_max / 10) + 1) * 10)
461 vals[name]["rel"][1] = round(y_val_2 / y_val_1, 2)
462 vals[name]["diff"][1] = \
463 (y_val_2 - vals[name]["ideal"][1]) * 100 / y_val_2
465 vals[name]["rel"][2] = round(y_val_4 / y_val_1, 2)
466 vals[name]["diff"][2] = \
467 (y_val_4 - vals[name]["ideal"][2]) * 100 / y_val_4
470 if "x520" in test_name:
471 limit = plot["limits"]["nic"]["x520"]
472 elif "x710" in test_name:
473 limit = plot["limits"]["nic"]["x710"]
474 elif "xxv710" in test_name:
475 limit = plot["limits"]["nic"]["xxv710"]
476 elif "xl710" in test_name:
477 limit = plot["limits"]["nic"]["xl710"]
480 if limit > nic_limit:
483 mul = 2 if "ge2p" in test_name else 1
484 if "10ge" in test_name:
485 limit = plot["limits"]["link"]["10ge"] * mul
486 elif "25ge" in test_name:
487 limit = plot["limits"]["link"]["25ge"] * mul
488 elif "40ge" in test_name:
489 limit = plot["limits"]["link"]["40ge"] * mul
490 elif "100ge" in test_name:
491 limit = plot["limits"]["link"]["100ge"] * mul
494 if limit > lnk_limit:
498 order = plot.get("sort", None)
500 y_sorted = OrderedDict()
501 y_tags_l = {s: [t.lower() for t in ts] for s, ts in y_tags.items()}
503 for test, tags in y_tags_l.items():
504 if tag.lower() in tags:
505 name = "-".join(test.split('-')[1:-1])
507 y_sorted[name] = vals.pop(name)
509 except KeyError as err:
510 logging.error("Not found: {0}".format(err))
522 threshold = 1.1 * max(y_max) # 10%
523 except ValueError as err:
526 nic_limit /= 1000000.0
527 if nic_limit < threshold:
528 traces.append(plgo.Scatter(
530 y=[nic_limit, ] * len(x_vals),
531 name="NIC: {0:.2f}Mpps".format(nic_limit),
540 annotations.append(dict(
547 text="NIC: {0:.2f}Mpps".format(nic_limit),
555 y_max.append(int((nic_limit / 10) + 1) * 10)
557 lnk_limit /= 1000000.0
558 if lnk_limit < threshold:
559 traces.append(plgo.Scatter(
561 y=[lnk_limit, ] * len(x_vals),
562 name="Link: {0:.2f}Mpps".format(lnk_limit),
571 annotations.append(dict(
578 text="Link: {0:.2f}Mpps".format(lnk_limit),
586 y_max.append(int((lnk_limit / 10) + 1) * 10)
588 pci_limit /= 1000000.0
589 if pci_limit < threshold:
590 traces.append(plgo.Scatter(
592 y=[pci_limit, ] * len(x_vals),
593 name="PCIe: {0:.2f}Mpps".format(pci_limit),
602 annotations.append(dict(
609 text="PCIe: {0:.2f}Mpps".format(pci_limit),
617 y_max.append(int((pci_limit / 10) + 1) * 10)
619 # Perfect and measured:
621 for name, val in y_sorted.iteritems():
623 for idx in range(len(val["val"])):
625 if isinstance(val["val"][idx], float):
626 htext += "value: {0:.2f}Mpps<br>".format(val["val"][idx])
627 if isinstance(val["diff"][idx], float):
628 htext += "diff: {0:.0f}%<br>".format(round(val["diff"][idx]))
629 if isinstance(val["rel"][idx], float):
630 htext += "speedup: {0:.2f}".format(val["rel"][idx])
631 hovertext.append(htext)
632 traces.append(plgo.Scatter(x=x_vals,
636 mode="lines+markers",
645 hoverinfo="text+name"
647 traces.append(plgo.Scatter(x=x_vals,
649 name="{0} perfect".format(name),
657 text=["perfect: {0:.2f}Mpps".format(y)
658 for y in val["ideal"]],
665 logging.info(" Writing file '{0}{1}'.".
666 format(plot["output-file"], plot["output-file-type"]))
667 layout = deepcopy(plot["layout"])
668 if layout.get("title", None):
669 layout["title"] = "<b>Speedup Multi-core:</b> {0}". \
670 format(layout["title"])
671 layout["annotations"].extend(annotations)
672 plpl = plgo.Figure(data=traces, layout=layout)
676 show_link=False, auto_open=False,
677 filename='{0}{1}'.format(plot["output-file"],
678 plot["output-file-type"]))
679 except PlotlyError as err:
680 logging.error(" Finished with error: {}".
681 format(str(err).replace("\n", " ")))
685 def plot_http_server_performance_box(plot, input_data):
686 """Generate the plot(s) with algorithm: plot_http_server_performance_box
687 specified in the specification file.
689 :param plot: Plot to generate.
690 :param input_data: Data to process.
691 :type plot: pandas.Series
692 :type input_data: InputData
696 logging.info(" Creating the data set for the {0} '{1}'.".
697 format(plot.get("type", ""), plot.get("title", "")))
698 data = input_data.filter_data(plot)
700 logging.error("No data.")
703 # Prepare the data for the plot
708 if y_vals.get(test["name"], None) is None:
709 y_vals[test["name"]] = list()
711 y_vals[test["name"]].append(test["result"])
712 except (KeyError, TypeError):
713 y_vals[test["name"]].append(None)
715 # Add None to the lists with missing data
717 for val in y_vals.values():
718 if len(val) > max_len:
720 for key, val in y_vals.items():
721 if len(val) < max_len:
722 val.extend([None for _ in range(max_len - len(val))])
726 df = pd.DataFrame(y_vals)
728 for i, col in enumerate(df.columns):
729 name = "{0}. {1}".format(i + 1, col.lower().replace('-cps', '').
731 traces.append(plgo.Box(x=[str(i + 1) + '.'] * len(df[col]),
737 plpl = plgo.Figure(data=traces, layout=plot["layout"])
740 logging.info(" Writing file '{0}{1}'.".
741 format(plot["output-file"], plot["output-file-type"]))
742 ploff.plot(plpl, show_link=False, auto_open=False,
743 filename='{0}{1}'.format(plot["output-file"],
744 plot["output-file-type"]))
745 except PlotlyError as err:
746 logging.error(" Finished with error: {}".
747 format(str(err).replace("\n", " ")))