PAL: Add processing of throughput in Gbps

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

2 files changed, 171 insertions, 98 deletions

diff --git a/resources/tools/presentation/generator_plots.py b/resources/tools/presentation/generator_plots.py
index f875d09b94..e79e4de38b 100644
--- a/resources/tools/presentation/generator_plots.py
+++ b/resources/tools/presentation/generator_plots.py
@@ -179,9 +179,16 @@ def plot_hdrh_lat_by_percentile(plot, input_data):
                         f"Percentile: 0.0%<br>"
                         f"Latency: 0.0uSec"
                     ]
-                    decoded = hdrh.histogram.HdrHistogram.decode(
-                        test[u"latency"][graph][direction][u"hdrh"]
-                    )
+                    try:
+                        decoded = hdrh.histogram.HdrHistogram.decode(
+                            test[u"latency"][graph][direction][u"hdrh"]
+                        )
+                    except hdrh.codec.HdrLengthException:
+                        logging.warning(
+                            f"No data for direction {(u'W-E', u'E-W')[idx % 2]}"
+                        )
+                        continue
+
                     for item in decoded.get_recorded_iterator():
                         percentile = item.percentile_level_iterated_to
                         if percentile > 99.9:
@@ -204,7 +211,7 @@ def plot_hdrh_lat_by_percentile(plot, input_data):
                             showlegend=bool(idx),
                             line=dict(
                                 color=COLORS[color],
-                                dash=u"solid" if idx % 2 else u"dash"
+                                dash=u"dash" if idx % 2 else u"solid"
                             ),
                             hovertext=hovertext,
                             hoverinfo=u"text"
@@ -356,7 +363,8 @@ def plot_perf_box_name(plot, input_data):
         f"{plot.get(u'title', u'')}."
     )
     data = input_data.filter_tests_by_name(
-        plot, params=[u"throughput", u"result", u"parent", u"tags", u"type"])
+        plot,
+        params=[u"throughput", u"gbps", u"result", u"parent", u"tags", u"type"])
     if data is None:
         logging.error(u"No data.")
         return
@@ -370,20 +378,33 @@ def plot_perf_box_name(plot, input_data):
                 if y_vals.get(test[u"parent"], None) is None:
                     y_vals[test[u"parent"]] = list()
                 try:
-                    if (test[u"type"] in (u"NDRPDR", ) and
-                            u"-pdr" in plot.get(u"title", u"").lower()):
-                        y_vals[test[u"parent"]].\
-                            append(test[u"throughput"][u"PDR"][u"LOWER"])
-                        test_type = u"NDRPDR"
-                    elif (test[u"type"] in (u"NDRPDR", ) and
-                          u"-ndr" in plot.get(u"title", u"").lower()):
-                        y_vals[test[u"parent"]]. \
-                            append(test[u"throughput"][u"NDR"][u"LOWER"])
+                    if test[u"type"] in (u"NDRPDR", ):
                         test_type = u"NDRPDR"
+                        plot_title = plot.get(u"title", u"").lower()
+
+                        if u"-pdr" in plot_title:
+                            ttype = u"PDR"
+                        elif u"-ndr" in plot_title:
+                            ttype = u"NDR"
+                        else:
+                            continue
+
+                        if u"-gbps" in plot_title:
+                            value = u"gbps"
+                            multiplier = 1e6
+                        else:
+                            value = u"throughput"
+                            multiplier = 1.0
+
+                        y_vals[test[u"parent"]].append(
+                            test[value][ttype][u"LOWER"] * multiplier
+                        )
+
                     elif test[u"type"] in (u"SOAK", ):
                         y_vals[test[u"parent"]].\
                             append(test[u"throughput"][u"LOWER"])
                         test_type = u"SOAK"
+
                     elif test[u"type"] in (u"HOSTSTACK", ):
                         if u"LDPRELOAD" in test[u"tags"]:
                             y_vals[test[u"parent"]].append(
@@ -398,8 +419,10 @@ def plot_perf_box_name(plot, input_data):
                                  2)
                             )
                         test_type = u"HOSTSTACK"
+
                     else:
                         continue
+
                 except (KeyError, TypeError):
                     y_vals[test[u"parent"]].append(None)
 
@@ -491,11 +514,15 @@ def plot_tsa_name(plot, input_data):
         f"    Creating data set for the {plot.get(u'type', u'')} {plot_title}."
     )
     data = input_data.filter_tests_by_name(
-        plot, params=[u"throughput", u"parent", u"tags", u"type"])
+        plot,
+        params=[u"throughput", u"gbps", u"parent", u"tags", u"type"]
+    )
     if data is None:
         logging.error(u"No data.")
         return
 
+    plot_title = plot_title.lower()
+
     y_vals = OrderedDict()
     for job in data:
         for build in job:
@@ -510,22 +537,29 @@ def plot_tsa_name(plot, input_data):
                     if test[u"type"] not in (u"NDRPDR",):
                         continue
 
-                    if u"-pdr" in plot_title.lower():
+                    if u"-pdr" in plot_title:
                         ttype = u"PDR"
-                    elif u"-ndr" in plot_title.lower():
+                    elif u"-ndr" in plot_title:
                         ttype = u"NDR"
                     else:
                         continue
 
+                    if u"-gbps" in plot_title:
+                        value = u"gbps"
+                        multiplier = 1e6
+                    else:
+                        value = u"throughput"
+                        multiplier = 1.0
+
                     if u"1C" in test[u"tags"]:
                         y_vals[test[u"parent"]][u"1"]. \
-                            append(test[u"throughput"][ttype][u"LOWER"])
+                            append(test[value][ttype][u"LOWER"] * multiplier)
                     elif u"2C" in test[u"tags"]:
                         y_vals[test[u"parent"]][u"2"]. \
-                            append(test[u"throughput"][ttype][u"LOWER"])
+                            append(test[value][ttype][u"LOWER"] * multiplier)
                     elif u"4C" in test[u"tags"]:
                         y_vals[test[u"parent"]][u"4"]. \
-                            append(test[u"throughput"][ttype][u"LOWER"])
+                            append(test[value][ttype][u"LOWER"] * multiplier)
                 except (KeyError, TypeError):
                     pass
 
@@ -636,103 +670,104 @@ def plot_tsa_name(plot, input_data):
     x_vals = [1, 2, 4]
 
     # Limits:
-    try:
-        threshold = 1.1 * max(y_max)  # 10%
-    except ValueError as err:
-        logging.error(err)
-        return
-    nic_limit /= 1e6
-    traces.append(plgo.Scatter(
-        x=x_vals,
-        y=[nic_limit, ] * len(x_vals),
-        name=f"NIC: {nic_limit:.2f}Mpps",
-        showlegend=False,
-        mode=u"lines",
-        line=dict(
-            dash=u"dot",
-            color=COLORS[-1],
-            width=1),
-        hoverinfo=u"none"
-    ))
-    annotations.append(dict(
-        x=1,
-        y=nic_limit,
-        xref=u"x",
-        yref=u"y",
-        xanchor=u"left",
-        yanchor=u"bottom",
-        text=f"NIC: {nic_limit:.2f}Mpps",
-        font=dict(
-            size=14,
-            color=COLORS[-1],
-        ),
-        align=u"left",
-        showarrow=False
-    ))
-    y_max.append(nic_limit)
-
-    lnk_limit /= 1e6
-    if lnk_limit < threshold:
-        traces.append(plgo.Scatter(
-            x=x_vals,
-            y=[lnk_limit, ] * len(x_vals),
-            name=f"Link: {lnk_limit:.2f}Mpps",
-            showlegend=False,
-            mode=u"lines",
-            line=dict(
-                dash=u"dot",
-                color=COLORS[-2],
-                width=1),
-            hoverinfo=u"none"
-        ))
-        annotations.append(dict(
-            x=1,
-            y=lnk_limit,
-            xref=u"x",
-            yref=u"y",
-            xanchor=u"left",
-            yanchor=u"bottom",
-            text=f"Link: {lnk_limit:.2f}Mpps",
-            font=dict(
-                size=14,
-                color=COLORS[-2],
-            ),
-            align=u"left",
-            showarrow=False
-        ))
-        y_max.append(lnk_limit)
-
-    pci_limit /= 1e6
-    if (pci_limit < threshold and
-            (pci_limit < lnk_limit * 0.95 or lnk_limit > lnk_limit * 1.05)):
+    if u"-gbps" not in plot_title:
+        try:
+            threshold = 1.1 * max(y_max)  # 10%
+        except ValueError as err:
+            logging.error(err)
+            return
+        nic_limit /= 1e6
         traces.append(plgo.Scatter(
             x=x_vals,
-            y=[pci_limit, ] * len(x_vals),
-            name=f"PCIe: {pci_limit:.2f}Mpps",
+            y=[nic_limit, ] * len(x_vals),
+            name=f"NIC: {nic_limit:.2f}Mpps",
             showlegend=False,
             mode=u"lines",
             line=dict(
                 dash=u"dot",
-                color=COLORS[-3],
+                color=COLORS[-1],
                 width=1),
             hoverinfo=u"none"
         ))
         annotations.append(dict(
             x=1,
-            y=pci_limit,
+            y=nic_limit,
             xref=u"x",
             yref=u"y",
             xanchor=u"left",
             yanchor=u"bottom",
-            text=f"PCIe: {pci_limit:.2f}Mpps",
+            text=f"NIC: {nic_limit:.2f}Mpps",
             font=dict(
                 size=14,
-                color=COLORS[-3],
+                color=COLORS[-1],
             ),
             align=u"left",
             showarrow=False
         ))
-        y_max.append(pci_limit)
+        y_max.append(nic_limit)
+
+        lnk_limit /= 1e6
+        if lnk_limit < threshold:
+            traces.append(plgo.Scatter(
+                x=x_vals,
+                y=[lnk_limit, ] * len(x_vals),
+                name=f"Link: {lnk_limit:.2f}Mpps",
+                showlegend=False,
+                mode=u"lines",
+                line=dict(
+                    dash=u"dot",
+                    color=COLORS[-2],
+                    width=1),
+                hoverinfo=u"none"
+            ))
+            annotations.append(dict(
+                x=1,
+                y=lnk_limit,
+                xref=u"x",
+                yref=u"y",
+                xanchor=u"left",
+                yanchor=u"bottom",
+                text=f"Link: {lnk_limit:.2f}Mpps",
+                font=dict(
+                    size=14,
+                    color=COLORS[-2],
+                ),
+                align=u"left",
+                showarrow=False
+            ))
+            y_max.append(lnk_limit)
+
+        pci_limit /= 1e6
+        if (pci_limit < threshold and
+                (pci_limit < lnk_limit * 0.95 or lnk_limit > lnk_limit * 1.05)):
+            traces.append(plgo.Scatter(
+                x=x_vals,
+                y=[pci_limit, ] * len(x_vals),
+                name=f"PCIe: {pci_limit:.2f}Mpps",
+                showlegend=False,
+                mode=u"lines",
+                line=dict(
+                    dash=u"dot",
+                    color=COLORS[-3],
+                    width=1),
+                hoverinfo=u"none"
+            ))
+            annotations.append(dict(
+                x=1,
+                y=pci_limit,
+                xref=u"x",
+                yref=u"y",
+                xanchor=u"left",
+                yanchor=u"bottom",
+                text=f"PCIe: {pci_limit:.2f}Mpps",
+                font=dict(
+                    size=14,
+                    color=COLORS[-3],
+                ),
+                align=u"left",
+                showarrow=False
+            ))
+            y_max.append(pci_limit)
 
     # Perfect and measured:
     cidx = 0
diff --git a/resources/tools/presentation/input_data_parser.py b/resources/tools/presentation/input_data_parser.py
index fc640875ce..0a6efc7b18 100644
--- a/resources/tools/presentation/input_data_parser.py
+++ b/resources/tools/presentation/input_data_parser.py
@@ -216,6 +216,12 @@ class ExecutionChecker(ResultVisitor):
         r'PDR_LOWER:\s(\d+.\d+).*\n.*\n'
         r'PDR_UPPER:\s(\d+.\d+)'
     )
+    REGEX_NDRPDR_GBPS = re.compile(
+        r'NDR_LOWER:.*,\s(\d+.\d+).*\n.*\n'
+        r'NDR_UPPER:.*,\s(\d+.\d+).*\n'
+        r'PDR_LOWER:.*,\s(\d+.\d+).*\n.*\n'
+        r'PDR_UPPER:.*,\s(\d+.\d+)'
+    )
     REGEX_PERF_MSG_INFO = re.compile(
         r'NDR_LOWER:\s(\d+.\d+)\s.*\s(\d+.\d+)\s.*\n.*\n.*\n'
         r'PDR_LOWER:\s(\d+.\d+)\s.*\s(\d+.\d+)\s.*\n.*\n.*\n'
@@ -713,6 +719,35 @@ class ExecutionChecker(ResultVisitor):
 
         return throughput, status
 
+    def _get_ndrpdr_throughput_gbps(self, msg):
+        """Get NDR_LOWER, NDR_UPPER, PDR_LOWER and PDR_UPPER in Gbps from the
+        test message.
+
+        :param msg: The test message to be parsed.
+        :type msg: str
+        :returns: Parsed data as a dict and the status (PASS/FAIL).
+        :rtype: tuple(dict, str)
+        """
+
+        gbps = {
+            u"NDR": {u"LOWER": -1.0, u"UPPER": -1.0},
+            u"PDR": {u"LOWER": -1.0, u"UPPER": -1.0}
+        }
+        status = u"FAIL"
+        groups = re.search(self.REGEX_NDRPDR_GBPS, msg)
+
+        if groups is not None:
+            try:
+                gbps[u"NDR"][u"LOWER"] = float(groups.group(1))
+                gbps[u"NDR"][u"UPPER"] = float(groups.group(2))
+                gbps[u"PDR"][u"LOWER"] = float(groups.group(3))
+                gbps[u"PDR"][u"UPPER"] = float(groups.group(4))
+                status = u"PASS"
+            except (IndexError, ValueError):
+                pass
+
+        return gbps, status
+
     def _get_plr_throughput(self, msg):
         """Get PLRsearch lower bound and PLRsearch upper bound from the test
         message.
@@ -1071,6 +1106,8 @@ class ExecutionChecker(ResultVisitor):
                 test_result[u"type"] = u"NDRPDR"
                 test_result[u"throughput"], test_result[u"status"] = \
                     self._get_ndrpdr_throughput(test.message)
+                test_result[u"gbps"], test_result[u"status"] = \
+                    self._get_ndrpdr_throughput_gbps(test.message)
                 test_result[u"latency"], test_result[u"status"] = \
                     self._get_ndrpdr_latency(test.message)
             elif u"SOAK" in tags:
@@ -1095,8 +1132,9 @@ class ExecutionChecker(ResultVisitor):
                 groups = re.search(self.REGEX_BMRR, test.message)
                 if groups is not None:
                     items_str = groups.group(1)
-                    items_float = [float(item.strip()) for item
-                                   in items_str.split(",")]
+                    items_float = [
+                        float(item.strip()) for item in items_str.split(",")
+                    ]
                     # Use whole list in CSIT-1180.
                     stats = jumpavg.AvgStdevStats.for_runs(items_float)
                     test_result[u"result"][u"receive-rate"] = stats.avg