X-Git-Url: https://gerrit.fd.io/r/gitweb?p=csit.git;a=blobdiff_plain;f=resources%2Ftools%2Fpresentation%2Fgenerator_plots.py;h=7cdcb62e1f7e82d2e4597a8bd871bc0cbf419811;hp=21dd1a0555568dec126d0ddeac617ec31eac3e53;hb=3532ea7e201971b463e6d72ae799a7871c5b3c9f;hpb=339d55392405b435fea92f62c3372b7940c46515

diff --git a/resources/tools/presentation/generator_plots.py b/resources/tools/presentation/generator_plots.py
index 21dd1a0555..7cdcb62e1f 100644
--- a/resources/tools/presentation/generator_plots.py
+++ b/resources/tools/presentation/generator_plots.py
@@ -15,6 +15,7 @@
 """
 
 
+import re
 import logging
 import pandas as pd
 import plotly.offline as ploff
@@ -24,7 +25,7 @@ from plotly.exceptions import PlotlyError
 from collections import OrderedDict
 from copy import deepcopy
 
-from utils import mean
+from utils import mean, stdev
 
 
 COLORS = ["SkyBlue", "Olive", "Purple", "Coral", "Indigo", "Pink",
@@ -1083,3 +1084,309 @@ def plot_http_server_performance_box(plot, input_data):
         logging.error("   Finished with error: {}".
                       format(str(err).replace("\n", " ")))
         return
+
+
+def plot_service_density_heatmap(plot, input_data):
+    """Generate the plot(s) with algorithm: plot_service_density_heatmap
+    specified in the specification file.
+
+    :param plot: Plot to generate.
+    :param input_data: Data to process.
+    :type plot: pandas.Series
+    :type input_data: InputData
+    """
+
+    REGEX_CN = re.compile(r'^(\d*)R(\d*)C$')
+
+    txt_chains = list()
+    txt_nodes = list()
+    vals = dict()
+
+    # Transform the data
+    logging.info("    Creating the data set for the {0} '{1}'.".
+                 format(plot.get("type", ""), plot.get("title", "")))
+    data = input_data.filter_data(plot, continue_on_error=True)
+    if data is None:
+        logging.error("No data.")
+        return
+
+    for job in data:
+        for build in job:
+            for test in build:
+                for tag in test['tags']:
+                    groups = re.search(REGEX_CN, tag)
+                    if groups:
+                        c = str(groups.group(1))
+                        n = str(groups.group(2))
+                        break
+                else:
+                    continue
+                if vals.get(c, None) is None:
+                    vals[c] = dict()
+                if vals[c].get(n, None) is None:
+                    vals[c][n] = dict(name=test["name"],
+                                      vals=list(),
+                                      nr=None,
+                                      mean=None,
+                                      stdev=None)
+                if plot["include-tests"] == "MRR":
+                    result = test["result"]["receive-rate"].avg
+                elif plot["include-tests"] == "PDR":
+                    result = test["throughput"]["PDR"]["LOWER"]
+                elif plot["include-tests"] == "NDR":
+                    result = test["throughput"]["NDR"]["LOWER"]
+                else:
+                    result = None
+
+                if result:
+                    vals[c][n]["vals"].append(result)
+
+    for key_c in vals.keys():
+        txt_chains.append(key_c)
+        for key_n in vals[key_c].keys():
+            txt_nodes.append(key_n)
+            if vals[key_c][key_n]["vals"]:
+                vals[key_c][key_n]["nr"] = len(vals[key_c][key_n]["vals"])
+                vals[key_c][key_n]["mean"] = \
+                    round(mean(vals[key_c][key_n]["vals"]) / 1000000, 2)
+                vals[key_c][key_n]["stdev"] = \
+                    round(stdev(vals[key_c][key_n]["vals"]) / 1000000, 2)
+    txt_nodes = list(set(txt_nodes))
+
+    txt_chains = sorted(txt_chains, key=lambda chain: int(chain))
+    txt_nodes = sorted(txt_nodes, key=lambda node: int(node))
+
+    chains = [i + 1 for i in range(len(txt_chains))]
+    nodes = [i + 1 for i in range(len(txt_nodes))]
+
+    data = [list() for _ in range(len(chains))]
+    for c in chains:
+        for n in nodes:
+            try:
+                val = vals[txt_chains[c - 1]][txt_nodes[n - 1]]["mean"]
+            except (KeyError, IndexError):
+                val = None
+            data[c - 1].append(val)
+
+    hovertext = list()
+    annotations = list()
+
+    text = ("{name}<br>"
+            "No. of Samples: {nr}<br>"
+            "Throughput: {val}<br>"
+            "Stdev: {stdev}")
+
+    for c in range(len(txt_chains)):
+        hover_line = list()
+        for n in range(len(txt_nodes)):
+            if data[c][n] is not None:
+                annotations.append(dict(
+                    x=n+1,
+                    y=c+1,
+                    xref="x",
+                    yref="y",
+                    xanchor="center",
+                    yanchor="middle",
+                    text=str(data[c][n]),
+                    font=dict(
+                        size=14,
+                    ),
+                    align="center",
+                    showarrow=False
+                ))
+                hover_line.append(text.format(
+                    name=vals[txt_chains[c]][txt_nodes[n]]["name"],
+                    nr=vals[txt_chains[c]][txt_nodes[n]]["nr"],
+                    val=data[c][n],
+                    stdev=vals[txt_chains[c]][txt_nodes[n]]["stdev"]))
+        hovertext.append(hover_line)
+
+    traces = [
+        plgo.Heatmap(x=nodes,
+                     y=chains,
+                     z=data,
+                     colorbar=dict(
+                         title="Packet Throughput [Mpps]",
+                         titleside="right",
+                         titlefont=dict(
+                            size=14
+                         ),
+                     ),
+                     showscale=True,
+                     colorscale="Reds",
+                     text=hovertext,
+                     hoverinfo="text")
+    ]
+
+    for idx, item in enumerate(txt_nodes):
+        annotations.append(dict(
+            x=idx+1,
+            y=0,
+            xref="x",
+            yref="y",
+            xanchor="center",
+            yanchor="top",
+            text=item,
+            font=dict(
+                size=16,
+            ),
+            align="center",
+            showarrow=False
+        ))
+    for idx, item in enumerate(txt_chains):
+        annotations.append(dict(
+            x=0.3,
+            y=idx+1,
+            xref="x",
+            yref="y",
+            xanchor="right",
+            yanchor="middle",
+            text=item,
+            font=dict(
+                size=16,
+            ),
+            align="center",
+            showarrow=False
+        ))
+    # X-axis:
+    annotations.append(dict(
+        x=0.55,
+        y=1.05,
+        xref="paper",
+        yref="paper",
+        xanchor="center",
+        yanchor="middle",
+        text="<b>No. of Network Functions per Service Instance</b>",
+        font=dict(
+            size=16,
+        ),
+        align="center",
+        showarrow=False
+    ))
+    # Y-axis:
+    annotations.append(dict(
+        x=-0.04,
+        y=0.5,
+        xref="paper",
+        yref="paper",
+        xanchor="center",
+        yanchor="middle",
+        text="<b>No. of Service Instances</b>",
+        font=dict(
+            size=16,
+        ),
+        align="center",
+        textangle=270,
+        showarrow=False
+    ))
+    updatemenus = list([
+        dict(
+            x=1.0,
+            y=0.0,
+            xanchor='right',
+            yanchor='bottom',
+            direction='up',
+            buttons=list([
+                dict(
+                    args=[{"colorscale": "Reds", "reversescale": False}],
+                    label="Red",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Blues", "reversescale": True}],
+                    label="Blue",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Greys", "reversescale": True}],
+                    label="Grey",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Greens", "reversescale": True}],
+                    label="Green",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "RdBu", "reversescale": False}],
+                    label="RedBlue",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Picnic", "reversescale": False}],
+                    label="Picnic",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Rainbow", "reversescale": False}],
+                    label="Rainbow",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Portland", "reversescale": False}],
+                    label="Portland",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Jet", "reversescale": False}],
+                    label="Jet",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Hot", "reversescale": True}],
+                    label="Hot",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Blackbody", "reversescale": True}],
+                    label="Blackbody",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Earth", "reversescale": True}],
+                    label="Earth",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Electric", "reversescale": True}],
+                    label="Electric",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Viridis", "reversescale": True}],
+                    label="Viridis",
+                    method="update"
+                ),
+                dict(
+                    args=[{"colorscale": "Cividis", "reversescale": True}],
+                    label="Cividis",
+                    method="update"
+                ),
+            ])
+        )
+    ])
+
+    try:
+        layout = deepcopy(plot["layout"])
+    except KeyError as err:
+        logging.error("Finished with error: No layout defined")
+        logging.error(repr(err))
+        return
+
+    layout["annotations"] = annotations
+    layout['updatemenus'] = updatemenus
+
+    try:
+        # Create plot
+        plpl = plgo.Figure(data=traces, layout=layout)
+
+        # Export Plot
+        logging.info("    Writing file '{0}{1}'.".
+                     format(plot["output-file"], plot["output-file-type"]))
+        ploff.plot(plpl, show_link=False, auto_open=False,
+                   filename='{0}{1}'.format(plot["output-file"],
+                                            plot["output-file-type"]))
+    except PlotlyError as err:
+        logging.error("   Finished with error: {}".
+                      format(str(err).replace("\n", " ")))
+        return