Trending: NDRPDR dashboard

Change-Id: I7f4c84dd47874c484f34f389b93de635c66a77c1
Signed-off-by: Tibor Frank <tifrank@cisco.com>

1 files changed, 0 insertions, 458 deletions

diff --git a/resources/tools/presentation/generator_plots.py b/resources/tools/presentation/generator_plots.py
index 89eb1c6521..c1e5bed893 100644
--- a/resources/tools/presentation/generator_plots.py
+++ b/resources/tools/presentation/generator_plots.py
@@ -27,7 +27,6 @@ import pandas as pd
 import plotly.offline as ploff
 import plotly.graph_objs as plgo
 
-from plotly.subplots import make_subplots
 from plotly.exceptions import PlotlyError
 
 from pal_utils import mean, stdev
@@ -55,12 +54,9 @@ def generate_plots(spec, data):
     generator = {
         u"plot_nf_reconf_box_name": plot_nf_reconf_box_name,
         u"plot_perf_box_name": plot_perf_box_name,
-        u"plot_lat_err_bars_name": plot_lat_err_bars_name,
         u"plot_tsa_name": plot_tsa_name,
         u"plot_http_server_perf_box": plot_http_server_perf_box,
         u"plot_nf_heatmap": plot_nf_heatmap,
-        u"plot_lat_hdrh_bar_name": plot_lat_hdrh_bar_name,
-        u"plot_lat_hdrh_percentile": plot_lat_hdrh_percentile,
         u"plot_hdrh_lat_by_percentile": plot_hdrh_lat_by_percentile
     }
 
@@ -79,111 +75,6 @@ def generate_plots(spec, data):
     logging.info(u"Done.")
 
 
-def plot_lat_hdrh_percentile(plot, input_data):
-    """Generate the plot(s) with algorithm: plot_lat_hdrh_percentile
-    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(u"title", u"")
-    logging.info(
-        f"    Creating the data set for the {plot.get(u'type', u'')} "
-        f"{plot_title}."
-    )
-    data = input_data.filter_tests_by_name(
-        plot, params=[u"latency", u"parent", u"tags", u"type"])
-    if data is None or len(data[0][0]) == 0:
-        logging.error(u"No data.")
-        return
-
-    fig = plgo.Figure()
-
-    # Prepare the data for the plot
-    directions = [u"W-E", u"E-W"]
-    for color, test in enumerate(data[0][0]):
-        try:
-            if test[u"type"] in (u"NDRPDR",):
-                if u"-pdr" in plot_title.lower():
-                    ttype = u"PDR"
-                elif u"-ndr" in plot_title.lower():
-                    ttype = u"NDR"
-                else:
-                    logging.warning(f"Invalid test type: {test[u'type']}")
-                    continue
-                name = re.sub(REGEX_NIC, u"", test[u"parent"].
-                              replace(u'-ndrpdr', u'').
-                              replace(u'2n1l-', u''))
-                for idx, direction in enumerate(
-                        (u"direction1", u"direction2", )):
-                    try:
-                        hdr_lat = test[u"latency"][ttype][direction][u"hdrh"]
-                        # TODO: Workaround, HDRH data must be aligned to 4
-                        #       bytes, remove when not needed.
-                        hdr_lat += u"=" * (len(hdr_lat) % 4)
-                        xaxis = list()
-                        yaxis = list()
-                        hovertext = list()
-                        decoded = hdrh.histogram.HdrHistogram.decode(hdr_lat)
-                        for item in decoded.get_recorded_iterator():
-                            percentile = item.percentile_level_iterated_to
-                            if percentile != 100.0:
-                                xaxis.append(100.0 / (100.0 - percentile))
-                                yaxis.append(item.value_iterated_to)
-                                hovertext.append(
-                                    f"Test: {name}<br>"
-                                    f"Direction: {directions[idx]}<br>"
-                                    f"Percentile: {percentile:.5f}%<br>"
-                                    f"Latency: {item.value_iterated_to}uSec"
-                                )
-                        fig.add_trace(
-                            plgo.Scatter(
-                                x=xaxis,
-                                y=yaxis,
-                                name=name,
-                                mode=u"lines",
-                                legendgroup=name,
-                                showlegend=bool(idx),
-                                line=dict(
-                                    color=COLORS[color]
-                                ),
-                                hovertext=hovertext,
-                                hoverinfo=u"text"
-                            )
-                        )
-                    except hdrh.codec.HdrLengthException as err:
-                        logging.warning(
-                            f"No or invalid data for HDRHistogram for the test "
-                            f"{name}\n{err}"
-                        )
-                        continue
-            else:
-                logging.warning(f"Invalid test type: {test[u'type']}")
-                continue
-        except (ValueError, KeyError) as err:
-            logging.warning(repr(err))
-
-    layout = deepcopy(plot[u"layout"])
-
-    layout[u"title"][u"text"] = \
-        f"<b>Latency:</b> {plot.get(u'graph-title', u'')}"
-    fig[u"layout"].update(layout)
-
-    # Create plot
-    file_type = plot.get(u"output-file-type", u".html")
-    logging.info(f"    Writing file {plot[u'output-file']}{file_type}.")
-    try:
-        # Export Plot
-        ploff.plot(fig, show_link=False, auto_open=False,
-                   filename=f"{plot[u'output-file']}{file_type}")
-    except PlotlyError as err:
-        logging.error(f"   Finished with error: {repr(err)}")
-
-
 def plot_hdrh_lat_by_percentile(plot, input_data):
     """Generate the plot(s) with algorithm: plot_hdrh_lat_by_percentile
     specified in the specification file.
@@ -336,182 +227,6 @@ def plot_hdrh_lat_by_percentile(plot, input_data):
             continue
 
 
-def plot_lat_hdrh_bar_name(plot, input_data):
-    """Generate the plot(s) with algorithm: plot_lat_hdrh_bar_name
-    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(u"title", u"")
-    logging.info(
-        f"    Creating the data set for the {plot.get(u'type', u'')} "
-        f"{plot_title}."
-    )
-    data = input_data.filter_tests_by_name(
-        plot, params=[u"latency", u"parent", u"tags", u"type"])
-    if data is None or len(data[0][0]) == 0:
-        logging.error(u"No data.")
-        return
-
-    # Prepare the data for the plot
-    directions = [u"W-E", u"E-W"]
-    tests = list()
-    traces = list()
-    for idx_row, test in enumerate(data[0][0]):
-        try:
-            if test[u"type"] in (u"NDRPDR",):
-                if u"-pdr" in plot_title.lower():
-                    ttype = u"PDR"
-                elif u"-ndr" in plot_title.lower():
-                    ttype = u"NDR"
-                else:
-                    logging.warning(f"Invalid test type: {test[u'type']}")
-                    continue
-                name = re.sub(REGEX_NIC, u"", test[u"parent"].
-                              replace(u'-ndrpdr', u'').
-                              replace(u'2n1l-', u''))
-                histograms = list()
-                for idx_col, direction in enumerate(
-                        (u"direction1", u"direction2", )):
-                    try:
-                        hdr_lat = test[u"latency"][ttype][direction][u"hdrh"]
-                        # TODO: Workaround, HDRH data must be aligned to 4
-                        #       bytes, remove when not needed.
-                        hdr_lat += u"=" * (len(hdr_lat) % 4)
-                        xaxis = list()
-                        yaxis = list()
-                        hovertext = list()
-                        decoded = hdrh.histogram.HdrHistogram.decode(hdr_lat)
-                        total_count = decoded.get_total_count()
-                        for item in decoded.get_recorded_iterator():
-                            xaxis.append(item.value_iterated_to)
-                            prob = float(item.count_added_in_this_iter_step) / \
-                                   total_count * 100
-                            yaxis.append(prob)
-                            hovertext.append(
-                                f"Test: {name}<br>"
-                                f"Direction: {directions[idx_col]}<br>"
-                                f"Latency: {item.value_iterated_to}uSec<br>"
-                                f"Probability: {prob:.2f}%<br>"
-                                f"Percentile: "
-                                f"{item.percentile_level_iterated_to:.2f}"
-                            )
-                        marker_color = [COLORS[idx_row], ] * len(yaxis)
-                        marker_color[xaxis.index(
-                            decoded.get_value_at_percentile(50.0))] = u"red"
-                        marker_color[xaxis.index(
-                            decoded.get_value_at_percentile(90.0))] = u"red"
-                        marker_color[xaxis.index(
-                            decoded.get_value_at_percentile(95.0))] = u"red"
-                        histograms.append(
-                            plgo.Bar(
-                                x=xaxis,
-                                y=yaxis,
-                                showlegend=False,
-                                name=name,
-                                marker={u"color": marker_color},
-                                hovertext=hovertext,
-                                hoverinfo=u"text"
-                            )
-                        )
-                    except hdrh.codec.HdrLengthException as err:
-                        logging.warning(
-                            f"No or invalid data for HDRHistogram for the test "
-                            f"{name}\n{err}"
-                        )
-                        continue
-                if len(histograms) == 2:
-                    traces.append(histograms)
-                    tests.append(name)
-            else:
-                logging.warning(f"Invalid test type: {test[u'type']}")
-                continue
-        except (ValueError, KeyError) as err:
-            logging.warning(repr(err))
-
-    if not tests:
-        logging.warning(f"No data for {plot_title}.")
-        return
-
-    fig = make_subplots(
-        rows=len(tests),
-        cols=2,
-        specs=[
-            [{u"type": u"bar"}, {u"type": u"bar"}] for _ in range(len(tests))
-        ]
-    )
-
-    layout_axes = dict(
-        gridcolor=u"rgb(220, 220, 220)",
-        linecolor=u"rgb(220, 220, 220)",
-        linewidth=1,
-        showgrid=True,
-        showline=True,
-        showticklabels=True,
-        tickcolor=u"rgb(220, 220, 220)",
-    )
-
-    for idx_row, test in enumerate(tests):
-        for idx_col in range(2):
-            fig.add_trace(
-                traces[idx_row][idx_col],
-                row=idx_row + 1,
-                col=idx_col + 1
-            )
-            fig.update_xaxes(
-                row=idx_row + 1,
-                col=idx_col + 1,
-                **layout_axes
-            )
-            fig.update_yaxes(
-                row=idx_row + 1,
-                col=idx_col + 1,
-                **layout_axes
-            )
-
-    layout = deepcopy(plot[u"layout"])
-
-    layout[u"title"][u"text"] = \
-        f"<b>Latency:</b> {plot.get(u'graph-title', u'')}"
-    layout[u"height"] = 250 * len(tests) + 130
-
-    layout[u"annotations"][2][u"y"] = 1.06 - 0.008 * len(tests)
-    layout[u"annotations"][3][u"y"] = 1.06 - 0.008 * len(tests)
-
-    for idx, test in enumerate(tests):
-        layout[u"annotations"].append({
-            u"font": {
-                u"size": 14
-            },
-            u"showarrow": False,
-            u"text": f"<b>{test}</b>",
-            u"textangle": 0,
-            u"x": 0.5,
-            u"xanchor": u"center",
-            u"xref": u"paper",
-            u"y": 1.0 - float(idx) * 1.06 / len(tests),
-            u"yanchor": u"bottom",
-            u"yref": u"paper"
-        })
-
-    fig[u"layout"].update(layout)
-
-    # Create plot
-    file_type = plot.get(u"output-file-type", u".html")
-    logging.info(f"    Writing file {plot[u'output-file']}{file_type}.")
-    try:
-        # Export Plot
-        ploff.plot(fig, show_link=False, auto_open=False,
-                   filename=f"{plot[u'output-file']}{file_type}")
-    except PlotlyError as err:
-        logging.error(f"   Finished with error: {repr(err)}")
-
-
 def plot_nf_reconf_box_name(plot, input_data):
     """Generate the plot(s) with algorithm: plot_nf_reconf_box_name
     specified in the specification file.
@@ -740,179 +455,6 @@ def plot_perf_box_name(plot, input_data):
         return
 
 
-def plot_lat_err_bars_name(plot, input_data):
-    """Generate the plot(s) with algorithm: plot_lat_err_bars_name
-    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(u"title", u"")
-    logging.info(
-        f"    Creating data set for the {plot.get(u'type', u'')} {plot_title}."
-    )
-    data = input_data.filter_tests_by_name(
-        plot, params=[u"latency", u"parent", u"tags", u"type"])
-    if data is None:
-        logging.error(u"No data.")
-        return
-
-    # Prepare the data for the plot
-    y_tmp_vals = OrderedDict()
-    for job in data:
-        for build in job:
-            for test in build:
-                try:
-                    logging.debug(f"test[u'latency']: {test[u'latency']}\n")
-                except ValueError as err:
-                    logging.warning(repr(err))
-                if y_tmp_vals.get(test[u"parent"], None) is None:
-                    y_tmp_vals[test[u"parent"]] = [
-                        list(),  # direction1, min
-                        list(),  # direction1, avg
-                        list(),  # direction1, max
-                        list(),  # direction2, min
-                        list(),  # direction2, avg
-                        list()   # direction2, max
-                    ]
-                try:
-                    if test[u"type"] not in (u"NDRPDR", ):
-                        logging.warning(f"Invalid test type: {test[u'type']}")
-                        continue
-                    if u"-pdr" in plot_title.lower():
-                        ttype = u"PDR"
-                    elif u"-ndr" in plot_title.lower():
-                        ttype = u"NDR"
-                    else:
-                        logging.warning(
-                            f"Invalid test type: {test[u'type']}"
-                        )
-                        continue
-                    y_tmp_vals[test[u"parent"]][0].append(
-                        test[u"latency"][ttype][u"direction1"][u"min"])
-                    y_tmp_vals[test[u"parent"]][1].append(
-                        test[u"latency"][ttype][u"direction1"][u"avg"])
-                    y_tmp_vals[test[u"parent"]][2].append(
-                        test[u"latency"][ttype][u"direction1"][u"max"])
-                    y_tmp_vals[test[u"parent"]][3].append(
-                        test[u"latency"][ttype][u"direction2"][u"min"])
-                    y_tmp_vals[test[u"parent"]][4].append(
-                        test[u"latency"][ttype][u"direction2"][u"avg"])
-                    y_tmp_vals[test[u"parent"]][5].append(
-                        test[u"latency"][ttype][u"direction2"][u"max"])
-                except (KeyError, TypeError) as err:
-                    logging.warning(repr(err))
-
-    x_vals = list()
-    y_vals = list()
-    y_mins = list()
-    y_maxs = list()
-    nr_of_samples = list()
-    for key, val in y_tmp_vals.items():
-        name = re.sub(REGEX_NIC, u"", key.replace(u'-ndrpdr', u'').
-                      replace(u'2n1l-', u''))
-        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)
-        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)
-
-    traces = list()
-    annotations = list()
-
-    for idx, _ in enumerate(x_vals):
-        if not bool(int(idx % 2)):
-            direction = u"West-East"
-        else:
-            direction = u"East-West"
-        hovertext = (
-            f"No. of Runs: {nr_of_samples[idx]}<br>"
-            f"Test: {x_vals[idx]}<br>"
-            f"Direction: {direction}<br>"
-        )
-        if isinstance(y_maxs[idx], float):
-            hovertext += f"Max: {y_maxs[idx]:.2f}uSec<br>"
-        if isinstance(y_vals[idx], float):
-            hovertext += f"Mean: {y_vals[idx]:.2f}uSec<br>"
-        if isinstance(y_mins[idx], float):
-            hovertext += f"Min: {y_mins[idx]:.2f}uSec"
-
-        if isinstance(y_maxs[idx], float) and isinstance(y_vals[idx], float):
-            array = [y_maxs[idx] - y_vals[idx], ]
-        else:
-            array = [None, ]
-        if isinstance(y_mins[idx], float) and isinstance(y_vals[idx], float):
-            arrayminus = [y_vals[idx] - y_mins[idx], ]
-        else:
-            arrayminus = [None, ]
-        traces.append(plgo.Scatter(
-            x=[idx, ],
-            y=[y_vals[idx], ],
-            name=x_vals[idx],
-            legendgroup=x_vals[idx],
-            showlegend=bool(int(idx % 2)),
-            mode=u"markers",
-            error_y=dict(
-                type=u"data",
-                symmetric=False,
-                array=array,
-                arrayminus=arrayminus,
-                color=COLORS[int(idx / 2)]
-            ),
-            marker=dict(
-                size=10,
-                color=COLORS[int(idx / 2)],
-            ),
-            text=hovertext,
-            hoverinfo=u"text",
-        ))
-        annotations.append(dict(
-            x=idx,
-            y=0,
-            xref=u"x",
-            yref=u"y",
-            xanchor=u"center",
-            yanchor=u"top",
-            text=u"E-W" if bool(int(idx % 2)) else u"W-E",
-            font=dict(
-                size=16,
-            ),
-            align=u"center",
-            showarrow=False
-        ))
-
-    try:
-        # Create plot
-        file_type = plot.get(u"output-file-type", u".html")
-        logging.info(f"    Writing file {plot[u'output-file']}{file_type}.")
-        layout = deepcopy(plot[u"layout"])
-        if layout.get(u"title", None):
-            layout[u"title"] = f"<b>Latency:</b> {layout[u'title']}"
-        layout[u"annotations"] = annotations
-        plpl = plgo.Figure(data=traces, layout=layout)
-
-        # Export Plot
-        ploff.plot(
-            plpl,
-            show_link=False, auto_open=False,
-            filename=f"{plot[u'output-file']}{file_type}"
-        )
-    except PlotlyError as err:
-        logging.error(
-            f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
-        )
-        return
-
-
 def plot_tsa_name(plot, input_data):
     """Generate the plot(s) with algorithm:
     plot_tsa_name