X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=resources%2Ftools%2Fpresentation%2Fgenerator_plots.py;h=729c2cc72c4d2378db0f83f470358842edbbdae7;hb=2c06090c7b919783a91d3ca9ca8c8319b5c35b07;hp=8af9a945d12d92d06dbd6085d4361e7830368175;hpb=af940b4664f4778ac4857cbdea6eed16ab2722f7;p=csit.git

diff --git a/resources/tools/presentation/generator_plots.py b/resources/tools/presentation/generator_plots.py
index 8af9a945d1..729c2cc72c 100644
--- a/resources/tools/presentation/generator_plots.py
+++ b/resources/tools/presentation/generator_plots.py
@@ -1,4 +1,4 @@
-# Copyright (c) 2019 Cisco and/or its affiliates.
+# Copyright (c) 2020 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:
@@ -60,7 +60,8 @@ def generate_plots(spec, data):
         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_lat_hdrh_percentile": plot_lat_hdrh_percentile,
+        u"plot_hdrh_lat_by_percentile": plot_hdrh_lat_by_percentile
     }
 
     logging.info(u"Generating the plots ...")
@@ -104,7 +105,7 @@ def plot_lat_hdrh_percentile(plot, input_data):
 
     # Prepare the data for the plot
     directions = [u"W-E", u"E-W"]
-    for test in data[0][0]:
+    for color, test in enumerate(data[0][0]):
         try:
             if test[u"type"] in (u"NDRPDR",):
                 if u"-pdr" in plot_title.lower():
@@ -116,8 +117,7 @@ def plot_lat_hdrh_percentile(plot, input_data):
                     continue
                 name = re.sub(REGEX_NIC, u"", test[u"parent"].
                               replace(u'-ndrpdr', u'').
-                              replace(u'2n1l-', u'').
-                              replace(u'avf-', u''))
+                              replace(u'2n1l-', u''))
                 for idx, direction in enumerate(
                         (u"direction1", u"direction2", )):
                     try:
@@ -137,7 +137,7 @@ def plot_lat_hdrh_percentile(plot, input_data):
                                 hovertext.append(
                                     f"Test: {name}<br>"
                                     f"Direction: {directions[idx]}<br>"
-                                    f"Percentile: {percentile:.5f}<br>%"
+                                    f"Percentile: {percentile:.5f}%<br>"
                                     f"Latency: {item.value_iterated_to}uSec"
                                 )
                         fig.add_trace(
@@ -146,6 +146,11 @@ def plot_lat_hdrh_percentile(plot, input_data):
                                 y=yaxis,
                                 name=name,
                                 mode=u"lines",
+                                legendgroup=name,
+                                showlegend=bool(idx),
+                                line=dict(
+                                    color=COLORS[color]
+                                ),
                                 hovertext=hovertext,
                                 hoverinfo=u"text"
                             )
@@ -179,6 +184,153 @@ def plot_lat_hdrh_percentile(plot, input_data):
         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.
+
+    :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 the 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"latency", u"throughput", u"parent", u"tags", u"type"])
+    if data is None or len(data[0][0]) == 0:
+        logging.error(u"No data.")
+        return
+
+    graphs = [
+        u"LAT0",
+        u"PDR10",
+        u"PDR50",
+        u"PDR90",
+        u"NDR",
+        u"PDR"
+    ]
+
+    for test in data[0][0]:
+        try:
+            if test[u"type"] not in (u"NDRPDR",):
+                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''))
+
+            logging.info(f"    Generating the graph: {name}")
+
+            pdr = test[u"throughput"][u"PDR"][u"LOWER"]
+            ndr = test[u"throughput"][u"NDR"][u"LOWER"]
+
+            desc = {
+                u"LAT0": u"No load",
+                u"PDR10": f"10% PDR background traffic ({(pdr*1e-7):.2f}Mpps)",
+                u"PDR50": f"50% PDR background traffic ({(pdr*5e-7):.2f}Mpps)",
+                u"PDR90": f"90% PDR background traffic ({(pdr*9e-7):.2f}Mpps)",
+                u"PDR": f"100% PDR background traffic ({(pdr*1e-6):.2f}Mpps)",
+                u"NDR10": f"10% NDR background traffic ({(ndr*1e-7):.2f}Mpps)",
+                u"NDR50": f"50% NDR background traffic ({(ndr*5e-7):.2f}Mpps)",
+                u"NDR90": f"90% NDR background traffic ({(ndr*9e-7):.2f}Mpps)",
+                u"NDR": f"100% NDR background traffic ({(ndr*1e-6):.2f}Mpps)"
+            }
+
+            fig = make_subplots(
+                rows=1,
+                cols=2,
+                column_widths=[0.5, 0.5],
+                shared_xaxes=True,
+                subplot_titles=(
+                    u"<b>Direction: W-E</b>",
+                    u"<b>Direction: E-W</b>"
+                ),
+                specs=[[{"type": "scatter"}, {"type": "scatter"}], ]
+            )
+            layout = deepcopy(plot[u"layout"])
+
+            for color, graph in enumerate(graphs):
+                for idx, direction in enumerate((u"direction1", u"direction2")):
+                    xaxis = list()
+                    yaxis = list()
+                    hovertext = list()
+                    decoded = hdrh.histogram.HdrHistogram.decode(
+                        test[u"latency"][graph][direction][u"hdrh"]
+                    )
+                    for item in decoded.get_recorded_iterator():
+                        percentile = item.percentile_level_iterated_to
+                        xaxis.append((100.0 / (100.0 - percentile))
+                                     if percentile != 100.0 else 1e6)
+                        yaxis.append(item.value_iterated_to)
+                        hovertext.append(
+                            f"<b>{desc[graph]}</b><br>"
+                            f"Percentile: {percentile:.5f}%<br>"
+                            f"Latency: {item.value_iterated_to}uSec"
+                        )
+                    fig.add_trace(
+                        plgo.Scatter(
+                            x=xaxis,
+                            y=yaxis,
+                            name=desc[graph],
+                            mode=u"lines",
+                            legendgroup=desc[graph],
+                            showlegend=bool(idx),
+                            line=dict(
+                                color=COLORS[color]
+                            ),
+                            hovertext=hovertext,
+                            hoverinfo=u"text"
+                        ),
+                        row=1,
+                        col=idx + 1,
+                    )
+                    fig.update_xaxes(
+                        row=1,
+                        col=idx + 1,
+                        **layout[u"xaxis"]
+                    )
+                    fig.update_yaxes(
+                        row=1,
+                        col=idx + 1,
+                        **layout[u"yaxis"]
+                    )
+            try:
+                del layout[u"xaxis"]
+            except KeyError:
+                pass
+            try:
+                del layout[u"yaxis"]
+            except KeyError:
+                pass
+
+            layout[u"title"][u"text"] = f"<b>Latency:</b> {name}"
+            fig.update_layout(layout)
+
+            # Create plot
+            file_name = (f"{plot[u'output-file']}-"
+                         f"{name}"
+                         f"{plot.get(u'output-file-type', u'.html')}")
+            logging.info(f"    Writing file {file_name}")
+
+            try:
+                # Export Plot
+                ploff.plot(fig, show_link=False, auto_open=False,
+                           filename=file_name)
+            except PlotlyError as err:
+                logging.error(f"   Finished with error: {repr(err)}")
+
+        except hdrh.codec.HdrLengthException as err:
+            logging.warning(repr(err))
+            continue
+
+        except (ValueError, KeyError) as err:
+            logging.warning(repr(err))
+            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.
@@ -1472,15 +1624,12 @@ def plot_nf_heatmap(plot, input_data):
         plpl = plgo.Figure(data=traces, layout=layout)
 
         # Export Plot
-        logging.info(
-            f"    Writing file {plot[u'output-file']}"
-            f"{plot[u'output-file-type']}."
-        )
+        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']}{plot[u'output-file-type']}"
+            filename=f"{plot[u'output-file']}.html"
         )
     except PlotlyError as err:
         logging.error(