C-Dash: Add bandwidth to iterative graphs

- ndr and pdr only for now

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

3 files changed, 193 insertions, 79 deletions

diff --git a/csit.infra.dash/app/cdash/report/graphs.py b/csit.infra.dash/app/cdash/report/graphs.py
index d1cd1427a1..ff1428eef1 100644
--- a/csit.infra.dash/app/cdash/report/graphs.py
+++ b/csit.infra.dash/app/cdash/report/graphs.py
@@ -91,17 +91,35 @@ def graph_iterative(data: pd.DataFrame, sel:dict, layout: dict,
     :rtype: tuple(plotly.graph_objects.Figure, plotly.graph_objects.Figure)
     """
 
+    def get_y_values(data, y_data_max, param, norm_factor):
+        if "receive_rate" in param:
+            y_vals_raw = data[param].to_list()[0]
+        else:
+            y_vals_raw = data[param].to_list()
+        y_data = [(y * norm_factor) for y in y_vals_raw]
+        try:
+            y_data_max = max(max(y_data), y_data_max)
+        except TypeError:
+            y_data_max = 0
+        return y_data, y_data_max
+
     fig_tput = None
+    fig_band = None
     fig_lat = None
 
     tput_traces = list()
     y_tput_max = 0
+    y_units = set()
+
     lat_traces = list()
     y_lat_max = 0
     x_lat = list()
-    y_units = set()
-    show_latency = False
-    show_tput = False
+
+    band_traces = list()
+    y_band_max = 0
+    y_band_units = set()
+    x_band = list()
+
     for idx, itm in enumerate(sel):
 
         itm_data = select_iterative_data(data, itm)
@@ -120,13 +138,8 @@ def graph_iterative(data: pd.DataFrame, sel:dict, layout: dict,
 
         y_units.update(itm_data[C.UNIT[ttype]].unique().tolist())
 
-        if itm["testtype"] == "mrr":
-            y_data_raw = itm_data[C.VALUE_ITER[ttype]].to_list()[0]
-        else:
-            y_data_raw = itm_data[C.VALUE_ITER[ttype]].to_list()
-        y_data = [(y * norm_factor) for y in y_data_raw]
-        if y_data:
-            y_tput_max = max(max(y_data), y_tput_max)
+        y_data, y_tput_max = \
+            get_y_values(itm_data, y_tput_max, C.VALUE_ITER[ttype], norm_factor)
 
         nr_of_samples = len(y_data)
 
@@ -167,64 +180,98 @@ def graph_iterative(data: pd.DataFrame, sel:dict, layout: dict,
             customdata=customdata
         )
         tput_traces.append(go.Box(**tput_kwargs))
-        show_tput = True
 
-        if ttype == "pdr":
-            customdata = list()
-            for _, row in itm_data.iterrows():
-                hdrh = get_hdrh_latencies(
-                    row,
-                    f"{metadata['infra']}-{metadata['test']}"
+        if ttype in ("ndr", "pdr"):
+            y_band, y_band_max = get_y_values(
+                itm_data,
+                y_band_max,
+                C.VALUE_ITER[f"{ttype}-bandwidth"],
+                norm_factor
+            )
+            if not all(pd.isna(y_band)):
+                y_band_units.update(
+                    itm_data[C.UNIT[f"{ttype}-bandwidth"]].unique().\
+                        dropna().tolist()
                 )
-                metadata["csit-ref"] = f"{row['job']}/{row['build']}"
-                customdata.append({
-                    "metadata": deepcopy(metadata),
-                    "hdrh": hdrh
-                })
-
-            y_lat_row = itm_data[C.VALUE_ITER["latency"]].to_list()
-            y_lat = [(y / norm_factor) for y in y_lat_row]
-            if y_lat:
-                try:
-                    y_lat_max = max(max(y_lat), y_lat_max)
-                except TypeError:
-                    continue
-            nr_of_samples = len(y_lat)
-            lat_kwargs = dict(
-                y=y_lat,
-                name=(
-                    f"{idx + 1}. "
-                    f"({nr_of_samples:02d} "
-                    f"run{u's' if nr_of_samples > 1 else u''}) "
-                    f"{itm['id']}"
-                ),
-                hoverinfo="all",
-                boxpoints="all",
-                jitter=0.3,
-                marker=dict(color=get_color(idx)),
-                customdata=customdata
+                band_kwargs = dict(
+                    y=y_band,
+                    name=(
+                        f"{idx + 1}. "
+                        f"({nr_of_samples:02d} "
+                        f"run{'s' if nr_of_samples > 1 else ''}) "
+                        f"{itm['id']}"
+                    ),
+                    hoverinfo=u"y+name",
+                    boxpoints="all",
+                    jitter=0.3,
+                    marker=dict(color=get_color(idx)),
+                    customdata=customdata
+                )
+                x_band.append(idx + 1)
+                band_traces.append(go.Box(**band_kwargs))
+
+        if ttype == "pdr":
+            y_lat, y_lat_max = get_y_values(
+                itm_data,
+                y_lat_max,
+                C.VALUE_ITER["latency"],
+                1 / norm_factor
             )
-            x_lat.append(idx + 1)
-            lat_traces.append(go.Box(**lat_kwargs))
-            show_latency = True
-        else:
-            lat_traces.append(go.Box())
+            if not all(pd.isna(y_lat)):
+                customdata = list()
+                for _, row in itm_data.iterrows():
+                    hdrh = get_hdrh_latencies(
+                        row,
+                        f"{metadata['infra']}-{metadata['test']}"
+                    )
+                    metadata["csit-ref"] = f"{row['job']}/{row['build']}"
+                    customdata.append({
+                        "metadata": deepcopy(metadata),
+                        "hdrh": hdrh
+                    })
+                nr_of_samples = len(y_lat)
+                lat_kwargs = dict(
+                    y=y_lat,
+                    name=(
+                        f"{idx + 1}. "
+                        f"({nr_of_samples:02d} "
+                        f"run{u's' if nr_of_samples > 1 else u''}) "
+                        f"{itm['id']}"
+                    ),
+                    hoverinfo="all",
+                    boxpoints="all",
+                    jitter=0.3,
+                    marker=dict(color=get_color(idx)),
+                    customdata=customdata
+                )
+                x_lat.append(idx + 1)
+                lat_traces.append(go.Box(**lat_kwargs))
 
-    if show_tput:
+    if tput_traces:
         pl_tput = deepcopy(layout["plot-throughput"])
         pl_tput["xaxis"]["tickvals"] = [i for i in range(len(sel))]
         pl_tput["xaxis"]["ticktext"] = [str(i + 1) for i in range(len(sel))]
         pl_tput["yaxis"]["title"] = f"Throughput [{'|'.join(sorted(y_units))}]"
         if y_tput_max:
-            pl_tput["yaxis"]["range"] = [0, (int(y_tput_max / 1e6) + 2) * 1e6]
+            pl_tput["yaxis"]["range"] = [0, int(y_tput_max) + 2e6]
         fig_tput = go.Figure(data=tput_traces, layout=pl_tput)
 
-    if show_latency:
+    if band_traces:
+        pl_band = deepcopy(layout["plot-bandwidth"])
+        pl_band["xaxis"]["tickvals"] = [i for i in range(len(x_band))]
+        pl_band["xaxis"]["ticktext"] = x_band
+        pl_band["yaxis"]["title"] = \
+            f"Bandwidth [{'|'.join(sorted(y_band_units))}]"
+        if y_band_max:
+            pl_band["yaxis"]["range"] = [0, int(y_band_max) + 2e9]
+        fig_band = go.Figure(data=band_traces, layout=pl_band)
+
+    if lat_traces:
         pl_lat = deepcopy(layout["plot-latency"])
         pl_lat["xaxis"]["tickvals"] = [i for i in range(len(x_lat))]
         pl_lat["xaxis"]["ticktext"] = x_lat
         if y_lat_max:
-            pl_lat["yaxis"]["range"] = [0, (int(y_lat_max / 10) + 1) * 10]
+            pl_lat["yaxis"]["range"] = [0, int(y_lat_max) + 5]
         fig_lat = go.Figure(data=lat_traces, layout=pl_lat)
 
-    return fig_tput, fig_lat
+    return fig_tput, fig_band, fig_lat
diff --git a/csit.infra.dash/app/cdash/report/layout.py b/csit.infra.dash/app/cdash/report/layout.py
index 81cc913903..cbcc6e88b1 100644
--- a/csit.infra.dash/app/cdash/report/layout.py
+++ b/csit.infra.dash/app/cdash/report/layout.py
@@ -758,38 +758,55 @@ class Layout:
         if not tests:
             return C.PLACEHOLDER
 
-        figs = graph_iterative(self._data, tests, self._graph_layout, normalize)
+        graphs = \
+            graph_iterative(self._data, tests, self._graph_layout, normalize)
 
-        if not figs[0]:
+        if not graphs[0]:
             return C.PLACEHOLDER
-
-        row_items = [
-            dbc.Col(
+        
+        tab_items = [
+            dbc.Tab(
                 children=dcc.Graph(
                     id={"type": "graph", "index": "tput"},
-                    figure=figs[0]
+                    figure=graphs[0]
                 ),
-                class_name="g-0 p-1",
-                width=6
+                label="Throughput",
+                tab_id="tab-tput"
             )
         ]
 
-        if figs[1]:
-            row_items.append(
-                dbc.Col(
+        if graphs[1]:
+            tab_items.append(
+                dbc.Tab(
+                    children=dcc.Graph(
+                        id={"type": "graph", "index": "bandwidth"},
+                        figure=graphs[1]
+                    ),
+                    label="Bandwidth",
+                    tab_id="tab-bandwidth"
+                )
+            )
+
+        if graphs[2]:
+            tab_items.append(
+                dbc.Tab(
                     children=dcc.Graph(
                         id={"type": "graph", "index": "lat"},
-                        figure=figs[1]
+                        figure=graphs[2]
                     ),
-                    class_name="g-0 p-1",
-                    width=6
+                    label="Latency",
+                    tab_id="tab-lat"
                 )
             )
 
         return [
             dbc.Row(
-                children=row_items,
-                class_name="g-0 p-0",
+                dbc.Tabs(
+                    children=tab_items,
+                    id="tabs",
+                    active_tab="tab-tput",
+                ),
+                class_name="g-0 p-0"
             ),
             dbc.Row(
                 [
@@ -1364,8 +1381,16 @@ class Layout:
 
             trigger = Trigger(callback_context.triggered)
 
+            if trigger.idx == "tput":
+                idx = 0
+            elif trigger.idx == "bandwidth":
+                idx = 1
+            elif trigger.idx == "lat":
+                idx = len(graph_data) - 1
+            else:
+                return list(), list(), False
+
             try:
-                idx = 0 if trigger.idx == "tput" else 1
                 graph_data = graph_data[idx]["points"]
             except (IndexError, KeyError, ValueError, TypeError):
                 raise PreventUpdate
@@ -1391,6 +1416,8 @@ class Layout:
                 elif len(data) == 1:
                     if param == "lat":
                         stats = ("average latency at 50% PDR", )
+                    elif param == "bandwidth":
+                        stats = ("bandwidth", )
                     else:
                         stats = ("throughput", )
                 else:
@@ -1419,6 +1446,8 @@ class Layout:
             graph = list()
             if trigger.idx == "tput":
                 title = "Throughput"
+            elif trigger.idx == "bandwidth":
+                title = "Bandwidth"
             elif trigger.idx == "lat":
                 title = "Latency"
                 if len(graph_data) == 1:
diff --git a/csit.infra.dash/app/cdash/report/layout.yaml b/csit.infra.dash/app/cdash/report/layout.yaml
index 0be2898dea..9e30642111 100644
--- a/csit.infra.dash/app/cdash/report/layout.yaml
+++ b/csit.infra.dash/app/cdash/report/layout.yaml
@@ -11,7 +11,7 @@ plot-throughput:
     showticklabels: True
     tickcolor: "rgb(220, 220, 220)"
     tickmode: "array"
-    zeroline: False
+    zeroline: True
   yaxis:
     title: "Throughput [pps|cps|rps|bps]"
     gridcolor: "rgb(230, 230, 230)"
@@ -23,8 +23,48 @@ plot-throughput:
     showline: True
     showticklabels: True
     tickcolor: "rgb(220, 220, 220)"
-    zeroline: False
-    range: [0, 50]
+    zeroline: True
+    range: [0, 100]
+  autosize: True
+  margin:
+    t: 50
+    b: 0
+    l: 80
+    r: 20
+  showlegend: False
+  height: 800
+  paper_bgcolor: "#fff"
+  plot_bgcolor: "#fff"
+  hoverlabel:
+    namelength: -1
+
+plot-bandwidth:
+  xaxis:
+    title: "Test Cases [Index]"
+    autorange: True
+    fixedrange: False
+    gridcolor: "rgb(230, 230, 230)"
+    linecolor: "rgb(220, 220, 220)"
+    linewidth: 1
+    showgrid: True
+    showline: True
+    showticklabels: True
+    tickcolor: "rgb(220, 220, 220)"
+    tickmode: "array"
+    zeroline: True
+  yaxis:
+    title: "Bandwidth [bps]"
+    gridcolor: "rgb(230, 230, 230)"
+    hoverformat: ".3s"
+    tickformat: ".3s"
+    linecolor: "rgb(220, 220, 220)"
+    linewidth: 1
+    showgrid: True
+    showline: True
+    showticklabels: True
+    tickcolor: "rgb(220, 220, 220)"
+    zeroline: True
+    range: [0, 200]
   autosize: True
   margin:
     t: 50
@@ -32,7 +72,6 @@ plot-throughput:
     l: 80
     r: 20
   showlegend: False
-  # width: 700
   height: 800
   paper_bgcolor: "#fff"
   plot_bgcolor: "#fff"
@@ -52,7 +91,7 @@ plot-latency:
     showticklabels: True
     tickcolor: "rgb(220, 220, 220)"
     tickmode: "array"
-    zeroline: False
+    zeroline: True
   yaxis:
     title: "Average Latency at 50% PDR [us]"
     gridcolor: "rgb(230, 230, 230)"
@@ -64,8 +103,8 @@ plot-latency:
     showline: True
     showticklabels: True
     tickcolor: "rgb(220, 220, 220)"
-    zeroline: False
-    range: [0, 50]
+    zeroline: True
+    range: [0, 200]
   autosize: True
   margin:
     t: 50
@@ -73,7 +112,6 @@ plot-latency:
     l: 80
     r: 20
   showlegend: False
-  # width: 700
   height: 800
   paper_bgcolor: "#fff"
   plot_bgcolor: "#fff"