X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Ftools%2Fpresentation%2Fgenerator_plots.py;h=4bdb84739f8f2f3d941e2be25021ed18f10fff3b;hp=815f45884f8e6c90b05de9aea5f5237f546591ab;hb=466ebbe92072c3b525a199b6f6601e8ece82e0d4;hpb=98a94315dae63bd19c7bc16ce50b3219386aa34c

diff --git a/resources/tools/presentation/generator_plots.py b/resources/tools/presentation/generator_plots.py
index 815f45884f..4bdb84739f 100644
--- a/resources/tools/presentation/generator_plots.py
+++ b/resources/tools/presentation/generator_plots.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2020 Cisco and/or its affiliates.
+# Copyright (c) 2021 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:
@@ -61,6 +61,10 @@ COLORS = (
 
 REGEX_NIC = re.compile(r'(\d*ge\dp\d\D*\d*[a-z]*)-')
 
+# This value depends on latency stream rate (9001 pps) and duration (5s).
+# Keep it slightly higher to ensure rounding errors to not remove tick mark.
+PERCENTILE_MAX = 99.999501
+
 
 def generate_plots(spec, data):
     """Generate all plots specified in the specification file.
@@ -77,7 +81,10 @@ def generate_plots(spec, data):
         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_hdrh_lat_by_percentile": plot_hdrh_lat_by_percentile
+        u"plot_hdrh_lat_by_percentile": plot_hdrh_lat_by_percentile,
+        u"plot_hdrh_lat_by_percentile_x_log": plot_hdrh_lat_by_percentile_x_log,
+        u"plot_mrr_error_bars_name": plot_mrr_error_bars_name,
+        u"plot_mrr_box_name": plot_mrr_box_name
     }
 
     logging.info(u"Generating the plots ...")
@@ -172,14 +179,10 @@ def plot_hdrh_lat_by_percentile(plot, input_data):
 
             for color, graph in enumerate(graphs):
                 for idx, direction in enumerate((u"direction1", u"direction2")):
-                    xaxis = [0.0, ]
-                    yaxis = [0.0, ]
-                    hovertext = [
-                        f"<b>{desc[graph]}</b><br>"
-                        f"Direction: {(u'W-E', u'E-W')[idx % 2]}<br>"
-                        f"Percentile: 0.0%<br>"
-                        f"Latency: 0.0uSec"
-                    ]
+                    previous_x = 0.0
+                    xaxis = list()
+                    yaxis = list()
+                    hovertext = list()
                     try:
                         decoded = hdrh.histogram.HdrHistogram.decode(
                             test[u"latency"][graph][direction][u"hdrh"]
@@ -192,16 +195,23 @@ def plot_hdrh_lat_by_percentile(plot, input_data):
 
                     for item in decoded.get_recorded_iterator():
                         percentile = item.percentile_level_iterated_to
-                        if percentile > 99.9:
-                            continue
+                        xaxis.append(previous_x)
+                        yaxis.append(item.value_iterated_to)
+                        hovertext.append(
+                            f"<b>{desc[graph]}</b><br>"
+                            f"Direction: {(u'W-E', u'E-W')[idx % 2]}<br>"
+                            f"Percentile: {previous_x:.5f}-{percentile:.5f}%<br>"
+                            f"Latency: {item.value_iterated_to}uSec"
+                        )
                         xaxis.append(percentile)
                         yaxis.append(item.value_iterated_to)
                         hovertext.append(
                             f"<b>{desc[graph]}</b><br>"
                             f"Direction: {(u'W-E', u'E-W')[idx % 2]}<br>"
-                            f"Percentile: {percentile:.5f}%<br>"
+                            f"Percentile: {previous_x:.5f}-{percentile:.5f}%<br>"
                             f"Latency: {item.value_iterated_to}uSec"
                         )
+                        previous_x = percentile
                     fig.add_trace(
                         plgo.Scatter(
                             x=xaxis,
@@ -212,7 +222,8 @@ def plot_hdrh_lat_by_percentile(plot, input_data):
                             showlegend=bool(idx),
                             line=dict(
                                 color=COLORS[color],
-                                dash=u"dash" if idx % 2 else u"solid"
+                                dash=u"solid",
+                                width=1 if idx % 2 else 2
                             ),
                             hovertext=hovertext,
                             hoverinfo=u"text"
@@ -328,10 +339,11 @@ def plot_hdrh_lat_by_percentile_x_log(plot, input_data):
 
             fig = plgo.Figure()
             layout = deepcopy(plot[u"layout"])
-            xaxis_max = 0
 
             for color, graph in enumerate(graphs):
                 for idx, direction in enumerate((u"direction1", u"direction2")):
+                    previous_x = 0.0
+                    prev_perc = 0.0
                     xaxis = list()
                     yaxis = list()
                     hovertext = list()
@@ -346,17 +358,30 @@ def plot_hdrh_lat_by_percentile_x_log(plot, input_data):
                         continue
 
                     for item in decoded.get_recorded_iterator():
+                        # The real value is "percentile".
+                        # For 100%, we cut that down to "x_perc" to avoid
+                        # infinity.
                         percentile = item.percentile_level_iterated_to
-                        if percentile > 99.9999999:
-                            continue
-                        xaxis.append(100.0 / (100.0 - percentile))
+                        x_perc = min(percentile, PERCENTILE_MAX)
+                        xaxis.append(previous_x)
+                        yaxis.append(item.value_iterated_to)
+                        hovertext.append(
+                            f"<b>{desc[graph]}</b><br>"
+                            f"Direction: {(u'W-E', u'E-W')[idx % 2]}<br>"
+                            f"Percentile: {prev_perc:.5f}-{percentile:.5f}%<br>"
+                            f"Latency: {item.value_iterated_to}uSec"
+                        )
+                        next_x = 100.0 / (100.0 - x_perc)
+                        xaxis.append(next_x)
                         yaxis.append(item.value_iterated_to)
                         hovertext.append(
                             f"<b>{desc[graph]}</b><br>"
                             f"Direction: {(u'W-E', u'E-W')[idx % 2]}<br>"
-                            f"Percentile: {percentile:.5f}%<br>"
+                            f"Percentile: {prev_perc:.5f}-{percentile:.5f}%<br>"
                             f"Latency: {item.value_iterated_to}uSec"
                         )
+                        previous_x = next_x
+                        prev_perc = percentile
                     fig.add_trace(
                         plgo.Scatter(
                             x=xaxis,
@@ -367,17 +392,17 @@ def plot_hdrh_lat_by_percentile_x_log(plot, input_data):
                             showlegend=not(bool(idx)),
                             line=dict(
                                 color=COLORS[color],
-                                dash=u"dash" if idx % 2 else u"solid"
+                                dash=u"solid",
+                                width=1 if idx % 2 else 2
                             ),
                             hovertext=hovertext,
                             hoverinfo=u"text"
                         )
                     )
-                    xaxis_max = max(xaxis) if xaxis_max < max(
-                        xaxis) else xaxis_max
 
             layout[u"title"][u"text"] = f"<b>Latency:</b> {name}"
-            layout[u"xaxis"][u"range"] = [0, int(log(xaxis_max, 10)) + 1]
+            x_max = log(100.0 / (100.0 - PERCENTILE_MAX), 10)
+            layout[u"xaxis"][u"range"] = [0, x_max]
             fig.update_layout(layout)
 
             # Create plot
@@ -465,19 +490,21 @@ def plot_nf_reconf_box_name(plot, input_data):
     df_y = pd.DataFrame(y_vals)
     df_y.head()
     for i, col in enumerate(df_y.columns):
+
         tst_name = re.sub(REGEX_NIC, u"",
-                          col.lower().replace(u'-ndrpdr', u'').
-                          replace(u'2n1l-', u''))
+                          col.lower().replace(u'-reconf', u'').
+                          replace(u'2n1l-', u'').replace(u'2n-', u'').
+                          replace(u'-testpmd', u''))
 
         traces.append(plgo.Box(
             x=[str(i + 1) + u'.'] * len(df_y[col]),
-            y=[y if y else None for y in df_y[col]],
+            y=df_y[col],
             name=(
                 f"{i + 1}. "
                 f"({nr_of_samples[i]:02d} "
                 f"run{u's' if nr_of_samples[i] > 1 else u''}, "
                 f"packets lost average: {mean(loss[col]):.1f}) "
-                f"{u'-'.join(tst_name.split(u'-')[3:-2])}"
+                f"{u'-'.join(tst_name.split(u'-')[2:])}"
             ),
             hoverinfo=u"y+name"
         ))
@@ -673,6 +700,197 @@ def plot_perf_box_name(plot, input_data):
         return
 
 
+def plot_mrr_box_name(plot, input_data):
+    """Generate the plot(s) with algorithm: plot_mrr_box_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
+    logging.info(
+        f"    Creating data set for the {plot.get(u'type', u'')} "
+        f"{plot.get(u'title', u'')}."
+    )
+    data = input_data.filter_tests_by_name(
+        plot,
+        params=[u"result", u"parent", u"tags", u"type"])
+    if data is None:
+        logging.error(u"No data.")
+        return
+
+    # Prepare the data for the plot
+    data_x = list()
+    data_names = list()
+    data_y = list()
+    data_y_max = list()
+    idx = 1
+    for item in plot.get(u"include", tuple()):
+        reg_ex = re.compile(str(item).lower())
+        for job in data:
+            for build in job:
+                for test_id, test in build.iteritems():
+                    if not re.match(reg_ex, str(test_id).lower()):
+                        continue
+                    try:
+                        data_x.append(idx)
+                        name = re.sub(REGEX_NIC, u'', test[u'parent'].lower().
+                                      replace(u'-mrr', u'').
+                                      replace(u'2n1l-', u''))
+                        data_y.append(test[u"result"][u"samples"])
+                        data_names.append(
+                            f"{idx}."
+                            f"({len(data_y[-1]):02d} "
+                            f"run{u's' if len(data_y[-1]) > 1 else u''}) "
+                            f"{name}"
+                        )
+                        data_y_max.append(max(test[u"result"][u"samples"]))
+                        idx += 1
+                    except (KeyError, TypeError):
+                        pass
+
+    # Add plot traces
+    traces = list()
+    for idx in range(len(data_x)):
+        traces.append(
+            plgo.Box(
+                x=[data_x[idx], ] * len(data_y[idx]),
+                y=data_y[idx],
+                name=data_names[idx],
+                hoverinfo=u"y+name"
+            )
+        )
+
+    try:
+        # Create plot
+        layout = deepcopy(plot[u"layout"])
+        if layout.get(u"title", None):
+            layout[u"title"] = f"<b>Throughput:</b> {layout[u'title']}"
+        if data_y_max:
+            layout[u"yaxis"][u"range"] = [0, max(data_y_max) + 1]
+        plpl = plgo.Figure(data=traces, layout=layout)
+
+        # Export Plot
+        logging.info(f"    Writing file {plot[u'output-file']}.html.")
+        ploff.plot(
+            plpl,
+            show_link=False,
+            auto_open=False,
+            filename=f"{plot[u'output-file']}.html"
+        )
+    except PlotlyError as err:
+        logging.error(
+            f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
+        )
+        return
+
+
+def plot_mrr_error_bars_name(plot, input_data):
+    """Generate the plot(s) with algorithm: plot_mrr_error_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
+    logging.info(
+        f"    Creating data set for the {plot.get(u'type', u'')} "
+        f"{plot.get(u'title', u'')}."
+    )
+    data = input_data.filter_tests_by_name(
+        plot,
+        params=[u"result", u"parent", u"tags", u"type"])
+    if data is None:
+        logging.error(u"No data.")
+        return
+
+    # Prepare the data for the plot
+    data_x = list()
+    data_names = list()
+    data_y_avg = list()
+    data_y_stdev = list()
+    data_y_max = 0
+    hover_info = list()
+    idx = 1
+    for item in plot.get(u"include", tuple()):
+        reg_ex = re.compile(str(item).lower())
+        for job in data:
+            for build in job:
+                for test_id, test in build.iteritems():
+                    if not re.match(reg_ex, str(test_id).lower()):
+                        continue
+                    try:
+                        data_x.append(idx)
+                        name = re.sub(REGEX_NIC, u'', test[u'parent'].lower().
+                                      replace(u'-mrr', u'').
+                                      replace(u'2n1l-', u''))
+                        data_names.append(f"{idx}. {name}")
+                        data_y_avg.append(
+                            round(test[u"result"][u"receive-rate"], 3)
+                        )
+                        data_y_stdev.append(
+                            round(test[u"result"][u"receive-stdev"], 3)
+                        )
+                        hover_info.append(
+                            f"{data_names[-1]}<br>"
+                            f"average [Gbps]: {data_y_avg[-1]}<br>"
+                            f"stdev [Gbps]: {data_y_stdev[-1]}"
+                        )
+                        if data_y_avg[-1] + data_y_stdev[-1] > data_y_max:
+                            data_y_max = data_y_avg[-1] + data_y_stdev[-1]
+                        idx += 1
+                    except (KeyError, TypeError):
+                        pass
+
+    # Add plot traces
+    traces = list()
+    for idx in range(len(data_x)):
+        traces.append(
+            plgo.Scatter(
+                x=[data_x[idx], ],
+                y=[data_y_avg[idx], ],
+                error_y=dict(
+                    type=u"data",
+                    array=[data_y_stdev[idx], ],
+                    visible=True
+                ),
+                name=data_names[idx],
+                mode=u"markers",
+                text=hover_info[idx],
+                hoverinfo=u"text"
+            )
+        )
+
+    try:
+        # Create plot
+        layout = deepcopy(plot[u"layout"])
+        if layout.get(u"title", None):
+            layout[u"title"] = f"<b>Throughput:</b> {layout[u'title']}"
+        if data_y_max:
+            layout[u"yaxis"][u"range"] = [0, int(data_y_max) + 1]
+        plpl = plgo.Figure(data=traces, layout=layout)
+
+        # Export Plot
+        logging.info(f"    Writing file {plot[u'output-file']}.html.")
+        ploff.plot(
+            plpl,
+            show_link=False,
+            auto_open=False,
+            filename=f"{plot[u'output-file']}.html"
+        )
+    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