X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Ftools%2Fpresentation%2Fgenerator_plots.py;h=7cdcb62e1f7e82d2e4597a8bd871bc0cbf419811;hp=51b29407c3c6e1a81327ba5261f325d696ab9ae7;hb=3532ea7e201971b463e6d72ae799a7871c5b3c9f;hpb=d77d62178fa257cf84099811b9177b9e224a2dd8 diff --git a/resources/tools/presentation/generator_plots.py b/resources/tools/presentation/generator_plots.py index 51b29407c3..7cdcb62e1f 100644 --- a/resources/tools/presentation/generator_plots.py +++ b/resources/tools/presentation/generator_plots.py @@ -1,4 +1,4 @@ -# Copyright (c) 2018 Cisco and/or its affiliates. +# Copyright (c) 2019 Cisco and/or its affiliates. # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at: @@ -15,6 +15,7 @@ """ +import re import logging import pandas as pd import plotly.offline as ploff @@ -24,7 +25,7 @@ from plotly.exceptions import PlotlyError from collections import OrderedDict from copy import deepcopy -from utils import mean +from utils import mean, stdev COLORS = ["SkyBlue", "Olive", "Purple", "Coral", "Indigo", "Pink", @@ -107,7 +108,7 @@ def plot_performance_box(plot, input_data): y_sorted = OrderedDict() y_tags_l = {s: [t.lower() for t in ts] for s, ts in y_tags.items()} for tag in order: - logging.info(tag) + logging.debug(tag) for suite, tags in y_tags_l.items(): if "not " in tag: tag = tag.split(" ")[-1] @@ -119,9 +120,9 @@ def plot_performance_box(plot, input_data): try: y_sorted[suite] = y_vals.pop(suite) y_tags_l.pop(suite) - logging.info(suite) + logging.debug(suite) except KeyError as err: - logging.error("Not found: {0}".format(err)) + logging.error("Not found: {0}".format(repr(err))) finally: break else: @@ -129,9 +130,11 @@ def plot_performance_box(plot, input_data): # Add None to the lists with missing data max_len = 0 + nr_of_samples = list() for val in y_sorted.values(): if len(val) > max_len: max_len = len(val) + nr_of_samples.append(len(val)) for key, val in y_sorted.items(): if len(val) < max_len: val.extend([None for _ in range(max_len - len(val))]) @@ -142,14 +145,32 @@ def plot_performance_box(plot, input_data): df.head() y_max = list() for i, col in enumerate(df.columns): - name = "{0}. {1}".format(i + 1, col.lower().replace('-ndrpdrdisc', ''). - replace('-ndrpdr', '')) - logging.info(name) + name = "{nr}. ({samples:02d} run{plural}) {name}".\ + format(nr=(i + 1), + samples=nr_of_samples[i], + plural='s' if nr_of_samples[i] > 1 else '', + name=col.lower().replace('-ndrpdr', '')) + if len(name) > 50: + name_lst = name.split('-') + name = "" + split_name = True + for segment in name_lst: + if (len(name) + len(segment) + 1) > 50 and split_name: + name += "
" + split_name = False + name += segment + '-' + name = name[:-1] + + logging.debug(name) traces.append(plgo.Box(x=[str(i + 1) + '.'] * len(df[col]), y=[y / 1000000 if y else None for y in df[col]], name=name, **plot["traces"])) - val_max = max(df[col]) + try: + val_max = max(df[col]) + except ValueError as err: + logging.error(repr(err)) + continue if val_max: y_max.append(int(val_max / 1000000) + 1) @@ -171,7 +192,249 @@ def plot_performance_box(plot, input_data): plot["output-file-type"])) except PlotlyError as err: logging.error(" Finished with error: {}". - format(str(err).replace("\n", " "))) + format(repr(err).replace("\n", " "))) + return + + +def plot_soak_bars(plot, input_data): + """Generate the plot(s) with algorithm: plot_soak_bars + specified in the specification file. + + :param plot: Plot to generate. + :param input_data: Data to process. + :type plot: pandas.Series + :type input_data: InputData + """ + + # Transform the data + plot_title = plot.get("title", "") + logging.info(" Creating the data set for the {0} '{1}'.". + format(plot.get("type", ""), plot_title)) + data = input_data.filter_data(plot) + if data is None: + logging.error("No data.") + return + + # Prepare the data for the plot + y_vals = dict() + y_tags = dict() + for job in data: + for build in job: + for test in build: + if y_vals.get(test["parent"], None) is None: + y_tags[test["parent"]] = test.get("tags", None) + try: + if test["type"] in ("SOAK", ): + y_vals[test["parent"]] = test["throughput"] + else: + continue + except (KeyError, TypeError): + y_vals[test["parent"]] = dict() + + # Sort the tests + order = plot.get("sort", None) + if order and y_tags: + y_sorted = OrderedDict() + y_tags_l = {s: [t.lower() for t in ts] for s, ts in y_tags.items()} + for tag in order: + logging.debug(tag) + for suite, tags in y_tags_l.items(): + if "not " in tag: + tag = tag.split(" ")[-1] + if tag.lower() in tags: + continue + else: + if tag.lower() not in tags: + continue + try: + y_sorted[suite] = y_vals.pop(suite) + y_tags_l.pop(suite) + logging.debug(suite) + except KeyError as err: + logging.error("Not found: {0}".format(repr(err))) + finally: + break + else: + y_sorted = y_vals + + idx = 0 + y_max = 0 + traces = list() + for test_name, test_data in y_sorted.items(): + idx += 1 + name = "{nr}. {name}".\ + format(nr=idx, name=test_name.lower().replace('-soak', '')) + if len(name) > 50: + name_lst = name.split('-') + name = "" + split_name = True + for segment in name_lst: + if (len(name) + len(segment) + 1) > 50 and split_name: + name += "
" + split_name = False + name += segment + '-' + name = name[:-1] + + y_val = test_data.get("LOWER", None) + if y_val: + y_val /= 1000000 + if y_val > y_max: + y_max = y_val + + time = "No Information" + result = "No Information" + hovertext = ("{name}
" + "Packet Throughput: {val:.2f}Mpps
" + "Final Duration: {time}
" + "Result: {result}".format(name=name, + val=y_val, + time=time, + result=result)) + traces.append(plgo.Bar(x=[str(idx) + '.', ], + y=[y_val, ], + name=name, + text=hovertext, + hoverinfo="text")) + try: + # Create plot + layout = deepcopy(plot["layout"]) + if layout.get("title", None): + layout["title"] = "Packet Throughput: {0}". \ + format(layout["title"]) + if y_max: + layout["yaxis"]["range"] = [0, y_max + 1] + plpl = plgo.Figure(data=traces, layout=layout) + # Export Plot + logging.info(" Writing file '{0}{1}'.". + format(plot["output-file"], plot["output-file-type"])) + ploff.plot(plpl, show_link=False, auto_open=False, + filename='{0}{1}'.format(plot["output-file"], + plot["output-file-type"])) + except PlotlyError as err: + logging.error(" Finished with error: {}". + format(repr(err).replace("\n", " "))) + return + + +def plot_soak_boxes(plot, input_data): + """Generate the plot(s) with algorithm: plot_soak_boxes + specified in the specification file. + + :param plot: Plot to generate. + :param input_data: Data to process. + :type plot: pandas.Series + :type input_data: InputData + """ + + # Transform the data + plot_title = plot.get("title", "") + logging.info(" Creating the data set for the {0} '{1}'.". + format(plot.get("type", ""), plot_title)) + data = input_data.filter_data(plot) + if data is None: + logging.error("No data.") + return + + # Prepare the data for the plot + y_vals = dict() + y_tags = dict() + for job in data: + for build in job: + for test in build: + if y_vals.get(test["parent"], None) is None: + y_tags[test["parent"]] = test.get("tags", None) + try: + if test["type"] in ("SOAK", ): + y_vals[test["parent"]] = test["throughput"] + else: + continue + except (KeyError, TypeError): + y_vals[test["parent"]] = dict() + + # Sort the tests + order = plot.get("sort", None) + if order and y_tags: + y_sorted = OrderedDict() + y_tags_l = {s: [t.lower() for t in ts] for s, ts in y_tags.items()} + for tag in order: + logging.debug(tag) + for suite, tags in y_tags_l.items(): + if "not " in tag: + tag = tag.split(" ")[-1] + if tag.lower() in tags: + continue + else: + if tag.lower() not in tags: + continue + try: + y_sorted[suite] = y_vals.pop(suite) + y_tags_l.pop(suite) + logging.debug(suite) + except KeyError as err: + logging.error("Not found: {0}".format(repr(err))) + finally: + break + else: + y_sorted = y_vals + + idx = 0 + y_max = 0 + traces = list() + for test_name, test_data in y_sorted.items(): + idx += 1 + name = "{nr}. {name}".\ + format(nr=idx, name=test_name.lower().replace('-soak', '')) + if len(name) > 50: + name_lst = name.split('-') + name = "" + split_name = True + for segment in name_lst: + if (len(name) + len(segment) + 1) > 50 and split_name: + name += "
" + split_name = False + name += segment + '-' + name = name[:-1] + + y_val = test_data.get("UPPER", None) + if y_val: + y_val /= 1000000 + if y_val > y_max: + y_max = y_val + + y_base = test_data.get("LOWER", None) + if y_base: + y_base /= 1000000 + + hovertext = ("{name}
" + "Upper bound: {upper:.2f}Mpps
" + "Lower bound: {lower:.2f}Mpps".format(name=name, + upper=y_val, + lower=y_base)) + traces.append(plgo.Bar(x=[str(idx) + '.', ], + # +0.05 to see the value in case lower == upper + y=[y_val - y_base + 0.05, ], + base=y_base, + name=name, + text=hovertext, + hoverinfo="text")) + try: + # Create plot + layout = deepcopy(plot["layout"]) + if layout.get("title", None): + layout["title"] = "Soak Tests: {0}". \ + format(layout["title"]) + if y_max: + layout["yaxis"]["range"] = [0, y_max + 1] + plpl = plgo.Figure(data=traces, layout=layout) + # Export Plot + logging.info(" Writing file '{0}{1}'.". + format(plot["output-file"], plot["output-file-type"])) + ploff.plot(plpl, show_link=False, auto_open=False, + filename='{0}{1}'.format(plot["output-file"], + plot["output-file-type"])) + except PlotlyError as err: + logging.error(" Finished with error: {}". + format(repr(err).replace("\n", " "))) return @@ -200,6 +463,11 @@ def plot_latency_error_bars(plot, input_data): for job in data: for build in job: for test in build: + try: + logging.debug("test['latency']: {0}\n". + format(test["latency"])) + except ValueError as err: + logging.warning(repr(err)) if y_tmp_vals.get(test["parent"], None) is None: y_tmp_vals[test["parent"]] = [ list(), # direction1, min @@ -217,6 +485,8 @@ def plot_latency_error_bars(plot, input_data): elif "-ndr" in plot_title.lower(): ttype = "NDR" else: + logging.warning("Invalid test type: {0}". + format(test["type"])) continue y_tmp_vals[test["parent"]][0].append( test["latency"][ttype]["direction1"]["min"]) @@ -231,9 +501,12 @@ def plot_latency_error_bars(plot, input_data): y_tmp_vals[test["parent"]][5].append( test["latency"][ttype]["direction2"]["max"]) else: + logging.warning("Invalid test type: {0}". + format(test["type"])) continue - except (KeyError, TypeError): - pass + except (KeyError, TypeError) as err: + logging.warning(repr(err)) + logging.debug("y_tmp_vals: {0}\n".format(y_tmp_vals)) # Sort the tests order = plot.get("sort", None) @@ -241,48 +514,77 @@ def plot_latency_error_bars(plot, input_data): y_sorted = OrderedDict() y_tags_l = {s: [t.lower() for t in ts] for s, ts in y_tags.items()} for tag in order: + logging.debug(tag) for suite, tags in y_tags_l.items(): - if tag.lower() in tags: - try: - y_sorted[suite] = y_tmp_vals.pop(suite) - y_tags_l.pop(suite) - except KeyError as err: - logging.error("Not found: {0}".format(err)) - finally: - break + if "not " in tag: + tag = tag.split(" ")[-1] + if tag.lower() in tags: + continue + else: + if tag.lower() not in tags: + continue + try: + y_sorted[suite] = y_tmp_vals.pop(suite) + y_tags_l.pop(suite) + logging.debug(suite) + except KeyError as err: + logging.error("Not found: {0}".format(repr(err))) + finally: + break else: y_sorted = y_tmp_vals + logging.debug("y_sorted: {0}\n".format(y_sorted)) x_vals = list() y_vals = list() y_mins = list() y_maxs = list() + nr_of_samples = list() for key, val in y_sorted.items(): - key = "-".join(key.split("-")[1:-1]) - x_vals.append(key) # dir 1 + name = "-".join(key.split("-")[1:-1]) + if len(name) > 50: + name_lst = name.split('-') + name = "" + split_name = True + for segment in name_lst: + if (len(name) + len(segment) + 1) > 50 and split_name: + name += "
" + split_name = False + name += segment + '-' + name = name[:-1] + x_vals.append(name) # dir 1 y_vals.append(mean(val[1]) if val[1] else None) y_mins.append(mean(val[0]) if val[0] else None) y_maxs.append(mean(val[2]) if val[2] else None) - x_vals.append(key) # dir 2 + nr_of_samples.append(len(val[1]) if val[1] else 0) + x_vals.append(name) # dir 2 y_vals.append(mean(val[4]) if val[4] else None) y_mins.append(mean(val[3]) if val[3] else None) y_maxs.append(mean(val[5]) if val[5] else None) + nr_of_samples.append(len(val[3]) if val[3] else 0) + logging.debug("x_vals :{0}\n".format(x_vals)) + logging.debug("y_vals :{0}\n".format(y_vals)) + logging.debug("y_mins :{0}\n".format(y_mins)) + logging.debug("y_maxs :{0}\n".format(y_maxs)) + logging.debug("nr_of_samples :{0}\n".format(nr_of_samples)) traces = list() annotations = list() for idx in range(len(x_vals)): if not bool(int(idx % 2)): - direction = "West - East" + direction = "West-East" else: - direction = "East - West" - hovertext = ("Test: {test}
" + direction = "East-West" + hovertext = ("No. of Runs: {nr}
" + "Test: {test}
" "Direction: {dir}
".format(test=x_vals[idx], - dir=direction)) + dir=direction, + nr=nr_of_samples[idx])) if isinstance(y_maxs[idx], float): hovertext += "Max: {max:.2f}uSec
".format(max=y_maxs[idx]) if isinstance(y_vals[idx], float): - hovertext += "Avg: {avg:.2f}uSec
".format(avg=y_vals[idx]) + hovertext += "Mean: {avg:.2f}uSec
".format(avg=y_vals[idx]) if isinstance(y_mins[idx], float): hovertext += "Min: {min:.2f}uSec".format(min=y_mins[idx]) @@ -294,6 +596,9 @@ def plot_latency_error_bars(plot, input_data): arrayminus = [y_vals[idx] - y_mins[idx], ] else: arrayminus = [None, ] + logging.debug("y_vals[{1}] :{0}\n".format(y_vals[idx], idx)) + logging.debug("array :{0}\n".format(array)) + logging.debug("arrayminus :{0}\n".format(arrayminus)) traces.append(plgo.Scatter( x=[idx, ], y=[y_vals[idx], ], @@ -411,9 +716,11 @@ def plot_throughput_speedup_analysis(plot, input_data): for test_name, test_vals in y_vals.items(): for key, test_val in test_vals.items(): if test_val: - y_vals[test_name][key] = sum(test_val) / len(test_val) - if key == "1": - y_1c_max[test_name] = max(test_val) / 1000000.0 + avg_val = sum(test_val) / len(test_val) + y_vals[test_name][key] = (avg_val, len(test_val)) + ideal = avg_val / (int(key) * 1000000.0) + if test_name not in y_1c_max or ideal > y_1c_max[test_name]: + y_1c_max[test_name] = ideal vals = dict() y_max = list() @@ -421,38 +728,57 @@ def plot_throughput_speedup_analysis(plot, input_data): lnk_limit = 0 pci_limit = plot["limits"]["pci"]["pci-g3-x8"] for test_name, test_vals in y_vals.items(): - if test_vals["1"]: - name = "-".join(test_name.split('-')[1:-1]) - - vals[name] = dict() - y_val_1 = test_vals["1"] / 1000000.0 - y_val_2 = test_vals["2"] / 1000000.0 if test_vals["2"] else None - y_val_4 = test_vals["4"] / 1000000.0 if test_vals["4"] else None - - vals[name]["val"] = [y_val_1, y_val_2, y_val_4] - vals[name]["rel"] = [1.0, None, None] - vals[name]["ideal"] = [y_1c_max[test_name], - y_1c_max[test_name] * 2, - y_1c_max[test_name] * 4] - vals[name]["diff"] = \ - [(y_val_1 - y_1c_max[test_name]) * 100 / y_val_1, None, None] + try: + if test_vals["1"][1]: + name = "-".join(test_name.split('-')[1:-1]) + if len(name) > 50: + name_lst = name.split('-') + name = "" + split_name = True + for segment in name_lst: + if (len(name) + len(segment) + 1) > 50 and split_name: + name += "
" + split_name = False + name += segment + '-' + name = name[:-1] - try: - val_max = max(max(vals[name]["val"], vals[name]["ideal"])) - except ValueError as err: - logging.error(err) - continue - if val_max: - y_max.append(int((val_max / 10) + 1) * 10) - - if y_val_2: - vals[name]["rel"][1] = round(y_val_2 / y_val_1, 2) - vals[name]["diff"][1] = \ - (y_val_2 - vals[name]["ideal"][1]) * 100 / y_val_2 - if y_val_4: - vals[name]["rel"][2] = round(y_val_4 / y_val_1, 2) - vals[name]["diff"][2] = \ - (y_val_4 - vals[name]["ideal"][2]) * 100 / y_val_4 + vals[name] = dict() + y_val_1 = test_vals["1"][0] / 1000000.0 + y_val_2 = test_vals["2"][0] / 1000000.0 if test_vals["2"][0] \ + else None + y_val_4 = test_vals["4"][0] / 1000000.0 if test_vals["4"][0] \ + else None + + vals[name]["val"] = [y_val_1, y_val_2, y_val_4] + vals[name]["rel"] = [1.0, None, None] + vals[name]["ideal"] = [y_1c_max[test_name], + y_1c_max[test_name] * 2, + y_1c_max[test_name] * 4] + vals[name]["diff"] = [(y_val_1 - y_1c_max[test_name]) * 100 / + y_val_1, None, None] + vals[name]["count"] = [test_vals["1"][1], + test_vals["2"][1], + test_vals["4"][1]] + + try: + val_max = max(max(vals[name]["val"], vals[name]["ideal"])) + except ValueError as err: + logging.error(err) + continue + if val_max: + y_max.append(int((val_max / 10) + 1) * 10) + + if y_val_2: + vals[name]["rel"][1] = round(y_val_2 / y_val_1, 2) + vals[name]["diff"][1] = \ + (y_val_2 - vals[name]["ideal"][1]) * 100 / y_val_2 + if y_val_4: + vals[name]["rel"][2] = round(y_val_4 / y_val_1, 2) + vals[name]["diff"][2] = \ + (y_val_4 - vals[name]["ideal"][2]) * 100 / y_val_4 + except IndexError as err: + logging.warning("No data for '{0}'".format(test_name)) + logging.warning(repr(err)) # Limits: if "x520" in test_name: @@ -463,6 +789,8 @@ def plot_throughput_speedup_analysis(plot, input_data): limit = plot["limits"]["nic"]["xxv710"] elif "xl710" in test_name: limit = plot["limits"]["nic"]["xl710"] + elif "x553" in test_name: + limit = plot["limits"]["nic"]["x553"] else: limit = 0 if limit > nic_limit: @@ -608,45 +936,51 @@ def plot_throughput_speedup_analysis(plot, input_data): cidx = 0 for name, val in y_sorted.iteritems(): hovertext = list() - for idx in range(len(val["val"])): - htext = "" - if isinstance(val["val"][idx], float): - htext += "value: {0:.2f}Mpps
".format(val["val"][idx]) - if isinstance(val["diff"][idx], float): - htext += "diff: {0:.0f}%
".format(round(val["diff"][idx])) - if isinstance(val["rel"][idx], float): - htext += "speedup: {0:.2f}".format(val["rel"][idx]) - hovertext.append(htext) - traces.append(plgo.Scatter(x=x_vals, - y=val["val"], - name=name, - legendgroup=name, - mode="lines+markers", - line=dict( - color=COLORS[cidx], - width=2), - marker=dict( - symbol="circle", - size=10 - ), - text=hovertext, - hoverinfo="text+name" - )) - traces.append(plgo.Scatter(x=x_vals, - y=val["ideal"], - name="{0} perfect".format(name), - legendgroup=name, - showlegend=False, - mode="lines", - line=dict( - color=COLORS[cidx], - width=2, - dash="dash"), - text=["perfect: {0:.2f}Mpps".format(y) - for y in val["ideal"]], - hoverinfo="text" - )) - cidx += 1 + try: + for idx in range(len(val["val"])): + htext = "" + if isinstance(val["val"][idx], float): + htext += "No. of Runs: {1}
" \ + "Mean: {0:.2f}Mpps
".format(val["val"][idx], + val["count"][idx]) + if isinstance(val["diff"][idx], float): + htext += "Diff: {0:.0f}%
".format(round(val["diff"][idx])) + if isinstance(val["rel"][idx], float): + htext += "Speedup: {0:.2f}".format(val["rel"][idx]) + hovertext.append(htext) + traces.append(plgo.Scatter(x=x_vals, + y=val["val"], + name=name, + legendgroup=name, + mode="lines+markers", + line=dict( + color=COLORS[cidx], + width=2), + marker=dict( + symbol="circle", + size=10 + ), + text=hovertext, + hoverinfo="text+name" + )) + traces.append(plgo.Scatter(x=x_vals, + y=val["ideal"], + name="{0} perfect".format(name), + legendgroup=name, + showlegend=False, + mode="lines", + line=dict( + color=COLORS[cidx], + width=2, + dash="dash"), + text=["Perfect: {0:.2f}Mpps".format(y) + for y in val["ideal"]], + hoverinfo="text" + )) + cidx += 1 + except (IndexError, ValueError, KeyError) as err: + logging.warning("No data for '{0}'".format(name)) + logging.warning(repr(err)) try: # Create plot @@ -702,9 +1036,11 @@ def plot_http_server_performance_box(plot, input_data): # Add None to the lists with missing data max_len = 0 + nr_of_samples = list() for val in y_vals.values(): if len(val) > max_len: max_len = len(val) + nr_of_samples.append(len(val)) for key, val in y_vals.items(): if len(val) < max_len: val.extend([None for _ in range(max_len - len(val))]) @@ -714,8 +1050,22 @@ def plot_http_server_performance_box(plot, input_data): df = pd.DataFrame(y_vals) df.head() for i, col in enumerate(df.columns): - name = "{0}. {1}".format(i + 1, col.lower().replace('-cps', ''). - replace('-rps', '')) + name = "{nr}. ({samples:02d} run{plural}) {name}".\ + format(nr=(i + 1), + samples=nr_of_samples[i], + plural='s' if nr_of_samples[i] > 1 else '', + name=col.lower().replace('-ndrpdr', '')) + if len(name) > 50: + name_lst = name.split('-') + name = "" + split_name = True + for segment in name_lst: + if (len(name) + len(segment) + 1) > 50 and split_name: + name += "
" + split_name = False + name += segment + '-' + name = name[:-1] + traces.append(plgo.Box(x=[str(i + 1) + '.'] * len(df[col]), y=df[col], name=name, @@ -734,3 +1084,309 @@ def plot_http_server_performance_box(plot, input_data): logging.error(" Finished with error: {}". format(str(err).replace("\n", " "))) return + + +def plot_service_density_heatmap(plot, input_data): + """Generate the plot(s) with algorithm: plot_service_density_heatmap + specified in the specification file. + + :param plot: Plot to generate. + :param input_data: Data to process. + :type plot: pandas.Series + :type input_data: InputData + """ + + REGEX_CN = re.compile(r'^(\d*)R(\d*)C$') + + txt_chains = list() + txt_nodes = list() + vals = dict() + + # Transform the data + logging.info(" Creating the data set for the {0} '{1}'.". + format(plot.get("type", ""), plot.get("title", ""))) + data = input_data.filter_data(plot, continue_on_error=True) + if data is None: + logging.error("No data.") + return + + for job in data: + for build in job: + for test in build: + for tag in test['tags']: + groups = re.search(REGEX_CN, tag) + if groups: + c = str(groups.group(1)) + n = str(groups.group(2)) + break + else: + continue + if vals.get(c, None) is None: + vals[c] = dict() + if vals[c].get(n, None) is None: + vals[c][n] = dict(name=test["name"], + vals=list(), + nr=None, + mean=None, + stdev=None) + if plot["include-tests"] == "MRR": + result = test["result"]["receive-rate"].avg + elif plot["include-tests"] == "PDR": + result = test["throughput"]["PDR"]["LOWER"] + elif plot["include-tests"] == "NDR": + result = test["throughput"]["NDR"]["LOWER"] + else: + result = None + + if result: + vals[c][n]["vals"].append(result) + + for key_c in vals.keys(): + txt_chains.append(key_c) + for key_n in vals[key_c].keys(): + txt_nodes.append(key_n) + if vals[key_c][key_n]["vals"]: + vals[key_c][key_n]["nr"] = len(vals[key_c][key_n]["vals"]) + vals[key_c][key_n]["mean"] = \ + round(mean(vals[key_c][key_n]["vals"]) / 1000000, 2) + vals[key_c][key_n]["stdev"] = \ + round(stdev(vals[key_c][key_n]["vals"]) / 1000000, 2) + txt_nodes = list(set(txt_nodes)) + + txt_chains = sorted(txt_chains, key=lambda chain: int(chain)) + txt_nodes = sorted(txt_nodes, key=lambda node: int(node)) + + chains = [i + 1 for i in range(len(txt_chains))] + nodes = [i + 1 for i in range(len(txt_nodes))] + + data = [list() for _ in range(len(chains))] + for c in chains: + for n in nodes: + try: + val = vals[txt_chains[c - 1]][txt_nodes[n - 1]]["mean"] + except (KeyError, IndexError): + val = None + data[c - 1].append(val) + + hovertext = list() + annotations = list() + + text = ("{name}
" + "No. of Samples: {nr}
" + "Throughput: {val}
" + "Stdev: {stdev}") + + for c in range(len(txt_chains)): + hover_line = list() + for n in range(len(txt_nodes)): + if data[c][n] is not None: + annotations.append(dict( + x=n+1, + y=c+1, + xref="x", + yref="y", + xanchor="center", + yanchor="middle", + text=str(data[c][n]), + font=dict( + size=14, + ), + align="center", + showarrow=False + )) + hover_line.append(text.format( + name=vals[txt_chains[c]][txt_nodes[n]]["name"], + nr=vals[txt_chains[c]][txt_nodes[n]]["nr"], + val=data[c][n], + stdev=vals[txt_chains[c]][txt_nodes[n]]["stdev"])) + hovertext.append(hover_line) + + traces = [ + plgo.Heatmap(x=nodes, + y=chains, + z=data, + colorbar=dict( + title="Packet Throughput [Mpps]", + titleside="right", + titlefont=dict( + size=14 + ), + ), + showscale=True, + colorscale="Reds", + text=hovertext, + hoverinfo="text") + ] + + for idx, item in enumerate(txt_nodes): + annotations.append(dict( + x=idx+1, + y=0, + xref="x", + yref="y", + xanchor="center", + yanchor="top", + text=item, + font=dict( + size=16, + ), + align="center", + showarrow=False + )) + for idx, item in enumerate(txt_chains): + annotations.append(dict( + x=0.3, + y=idx+1, + xref="x", + yref="y", + xanchor="right", + yanchor="middle", + text=item, + font=dict( + size=16, + ), + align="center", + showarrow=False + )) + # X-axis: + annotations.append(dict( + x=0.55, + y=1.05, + xref="paper", + yref="paper", + xanchor="center", + yanchor="middle", + text="No. of Network Functions per Service Instance", + font=dict( + size=16, + ), + align="center", + showarrow=False + )) + # Y-axis: + annotations.append(dict( + x=-0.04, + y=0.5, + xref="paper", + yref="paper", + xanchor="center", + yanchor="middle", + text="No. of Service Instances", + font=dict( + size=16, + ), + align="center", + textangle=270, + showarrow=False + )) + updatemenus = list([ + dict( + x=1.0, + y=0.0, + xanchor='right', + yanchor='bottom', + direction='up', + buttons=list([ + dict( + args=[{"colorscale": "Reds", "reversescale": False}], + label="Red", + method="update" + ), + dict( + args=[{"colorscale": "Blues", "reversescale": True}], + label="Blue", + method="update" + ), + dict( + args=[{"colorscale": "Greys", "reversescale": True}], + label="Grey", + method="update" + ), + dict( + args=[{"colorscale": "Greens", "reversescale": True}], + label="Green", + method="update" + ), + dict( + args=[{"colorscale": "RdBu", "reversescale": False}], + label="RedBlue", + method="update" + ), + dict( + args=[{"colorscale": "Picnic", "reversescale": False}], + label="Picnic", + method="update" + ), + dict( + args=[{"colorscale": "Rainbow", "reversescale": False}], + label="Rainbow", + method="update" + ), + dict( + args=[{"colorscale": "Portland", "reversescale": False}], + label="Portland", + method="update" + ), + dict( + args=[{"colorscale": "Jet", "reversescale": False}], + label="Jet", + method="update" + ), + dict( + args=[{"colorscale": "Hot", "reversescale": True}], + label="Hot", + method="update" + ), + dict( + args=[{"colorscale": "Blackbody", "reversescale": True}], + label="Blackbody", + method="update" + ), + dict( + args=[{"colorscale": "Earth", "reversescale": True}], + label="Earth", + method="update" + ), + dict( + args=[{"colorscale": "Electric", "reversescale": True}], + label="Electric", + method="update" + ), + dict( + args=[{"colorscale": "Viridis", "reversescale": True}], + label="Viridis", + method="update" + ), + dict( + args=[{"colorscale": "Cividis", "reversescale": True}], + label="Cividis", + method="update" + ), + ]) + ) + ]) + + try: + layout = deepcopy(plot["layout"]) + except KeyError as err: + logging.error("Finished with error: No layout defined") + logging.error(repr(err)) + return + + layout["annotations"] = annotations + layout['updatemenus'] = updatemenus + + try: + # Create plot + plpl = plgo.Figure(data=traces, layout=layout) + + # Export Plot + logging.info(" Writing file '{0}{1}'.". + format(plot["output-file"], plot["output-file-type"])) + ploff.plot(plpl, show_link=False, auto_open=False, + filename='{0}{1}'.format(plot["output-file"], + plot["output-file-type"])) + except PlotlyError as err: + logging.error(" Finished with error: {}". + format(str(err).replace("\n", " "))) + return