remove(tools): presentation, docs

Signed-off-by: pmikus <peter.mikus@protonmail.ch>
Change-Id: Icc07d18b9c0bd00af157bb817205e5b54824d525

1 files changed, 0 insertions, 1868 deletions

diff --git a/resources/tools/presentation/generator_plots.py b/resources/tools/presentation/generator_plots.py
deleted file mode 100644
index cc9d880398..0000000000
--- a/resources/tools/presentation/generator_plots.py
+++ /dev/null
@@ -1,1868 +0,0 @@
-# Copyright (c) 2023 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:
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Algorithms to generate plots.
-"""
-
-
-import re
-import logging
-
-from collections import OrderedDict
-from datetime import datetime
-from copy import deepcopy
-from math import log
-
-import hdrh.histogram
-import hdrh.codec
-import pandas as pd
-import plotly.offline as ploff
-import plotly.graph_objs as plgo
-import plotly.exceptions as plerr
-
-from plotly.exceptions import PlotlyError
-
-from pal_utils import mean, stdev
-
-
-COLORS = (
-    u"#1A1110",
-    u"#DA2647",
-    u"#214FC6",
-    u"#01786F",
-    u"#BD8260",
-    u"#FFD12A",
-    u"#A6E7FF",
-    u"#738276",
-    u"#C95A49",
-    u"#FC5A8D",
-    u"#CEC8EF",
-    u"#391285",
-    u"#6F2DA8",
-    u"#FF878D",
-    u"#45A27D",
-    u"#FFD0B9",
-    u"#FD5240",
-    u"#DB91EF",
-    u"#44D7A8",
-    u"#4F86F7",
-    u"#84DE02",
-    u"#FFCFF1",
-    u"#614051"
-)
-
-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.
-
-    :param spec: Specification read from the specification file.
-    :param data: Data to process.
-    :type spec: Specification
-    :type data: InputData
-    """
-
-    generator = {
-        u"plot_nf_reconf_box_name": plot_nf_reconf_box_name,
-        u"plot_perf_box_name": plot_perf_box_name,
-        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_x_log": plot_hdrh_lat_by_percentile_x_log,
-        u"plot_mrr_box_name": plot_mrr_box_name,
-        u"plot_ndrpdr_box_name": plot_ndrpdr_box_name,
-        u"plot_statistics": plot_statistics
-    }
-
-    logging.info(u"Generating the plots ...")
-    for index, plot in enumerate(spec.plots):
-        try:
-            logging.info(f"  Plot nr {index + 1}: {plot.get(u'title', u'')}")
-            plot[u"limits"] = spec.environment[u"limits"]
-            generator[plot[u"algorithm"]](plot, data)
-            logging.info(u"  Done.")
-        except NameError as err:
-            logging.error(
-                f"Probably algorithm {plot[u'algorithm']} is not defined: "
-                f"{repr(err)}"
-            )
-    logging.info(u"Done.")
-
-
-def plot_statistics(plot, input_data):
-    """Generate the plot(s) with algorithm: plot_statistics
-    specified in the specification file.
-
-    :param plot: Plot to generate.
-    :param input_data: Data to process.
-    :type plot: pandas.Series
-    :type input_data: InputData
-    """
-
-    data_x = list()
-    data_y_pass = list()
-    data_y_fail = list()
-    data_y_duration = list()
-    hover_text = list()
-    hover_str = (
-        u"date: {date}<br>"
-        u"passed: {passed}<br>"
-        u"failed: {failed}<br>"
-        u"duration: {duration}<br>"
-        u"{sut}-ref: {build}<br>"
-        u"csit-ref: {test}-{period}-build-{build_nr}<br>"
-        u"testbed: {testbed}"
-    )
-    for job, builds in plot[u"data"].items():
-        for build_nr in builds:
-            try:
-                meta = input_data.metadata(job, str(build_nr))
-                generated = meta[u"generated"]
-                date = datetime(
-                    int(generated[0:4]),
-                    int(generated[4:6]),
-                    int(generated[6:8]),
-                    int(generated[9:11]),
-                    int(generated[12:])
-                )
-                d_y_pass = meta[u"tests_passed"]
-                d_y_fail = meta[u"tests_failed"]
-                minutes = meta[u"elapsedtime"] // 60000
-                duration = f"{(minutes // 60):02d}:{(minutes % 60):02d}"
-                version = meta.get(u"version", u"")
-            except (KeyError, IndexError, ValueError, AttributeError):
-                continue
-            data_x.append(date)
-            data_y_pass.append(d_y_pass)
-            data_y_fail.append(d_y_fail)
-            data_y_duration.append(minutes)
-            if u"vpp" in job:
-                sut = u"vpp"
-            elif u"dpdk" in job:
-                sut = u"dpdk"
-            elif u"trex" in job:
-                sut = u"trex"
-            else:
-                sut = u""
-            hover_text.append(hover_str.format(
-                date=date,
-                passed=d_y_pass,
-                failed=d_y_fail,
-                duration=duration,
-                sut=sut,
-                build=version,
-                test=u"mrr" if u"mrr" in job else u"ndrpdr",
-                period=u"daily" if u"daily" in job else u"weekly",
-                build_nr=build_nr,
-                testbed=meta.get(u"testbed", u"")
-            ))
-
-    traces = [
-        plgo.Bar(
-            x=data_x,
-            y=data_y_pass,
-            name=u"Passed",
-            text=hover_text,
-            hoverinfo=u"text"
-        ),
-        plgo.Bar(
-            x=data_x,
-            y=data_y_fail,
-            name=u"Failed",
-            text=hover_text,
-            hoverinfo=u"text"),
-        plgo.Scatter(
-            x=data_x,
-            y=data_y_duration,
-            name=u"Duration",
-            yaxis=u"y2",
-            text=hover_text,
-            hoverinfo=u"text"
-        )
-    ]
-
-    name_file = f"{plot[u'output-file']}.html"
-
-    logging.info(f"    Writing the file {name_file}")
-    plpl = plgo.Figure(data=traces, layout=plot[u"layout"])
-    tickvals = [0, (max(data_y_duration) // 60) * 60]
-    step = tickvals[1] / 5
-    for i in range(5):
-        tickvals.append(int(tickvals[0] + step * (i + 1)))
-    plpl.update_layout(
-        yaxis2=dict(
-            title=u"Duration [hh:mm]",
-            anchor=u"x",
-            overlaying=u"y",
-            side=u"right",
-            rangemode="tozero",
-            tickmode=u"array",
-            tickvals=tickvals,
-            ticktext=[f"{(val // 60):02d}:{(val % 60):02d}" for val in tickvals]
-        )
-    )
-    plpl.update_layout(barmode=u"stack")
-    try:
-        ploff.plot(
-            plpl,
-            show_link=False,
-            auto_open=False,
-            filename=name_file
-        )
-    except plerr.PlotlyEmptyDataError:
-        logging.warning(u"No data for the plot. Skipped.")
-
-
-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'')}."
-    )
-    if plot.get(u"include", None):
-        data = input_data.filter_tests_by_name(
-            plot,
-            params=[u"name", u"latency", u"parent", u"tags", u"type"]
-        )[0][0]
-    elif plot.get(u"filter", None):
-        data = input_data.filter_data(
-            plot,
-            params=[u"name", u"latency", u"parent", u"tags", u"type"],
-            continue_on_error=True
-        )[0][0]
-    else:
-        job = list(plot[u"data"].keys())[0]
-        build = str(plot[u"data"][job][0])
-        data = input_data.tests(job, build)
-
-    if data is None or len(data) == 0:
-        logging.error(u"No data.")
-        return
-
-    desc = {
-        u"LAT0": u"No-load.",
-        u"PDR10": u"Low-load, 10% PDR.",
-        u"PDR50": u"Mid-load, 50% PDR.",
-        u"PDR90": u"High-load, 90% PDR.",
-        u"PDR": u"Full-load, 100% PDR.",
-        u"NDR10": u"Low-load, 10% NDR.",
-        u"NDR50": u"Mid-load, 50% NDR.",
-        u"NDR90": u"High-load, 90% NDR.",
-        u"NDR": u"Full-load, 100% NDR."
-    }
-
-    graphs = [
-        u"LAT0",
-        u"PDR10",
-        u"PDR50",
-        u"PDR90"
-    ]
-
-    file_links = plot.get(u"output-file-links", None)
-    target_links = plot.get(u"target-links", None)
-
-    for test in data:
-        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''))
-            try:
-                nic = re.search(REGEX_NIC, test[u"parent"]).group(1)
-            except (IndexError, AttributeError, KeyError, ValueError):
-                nic = u""
-            name_link = f"{nic}-{test[u'name']}".replace(u'-ndrpdr', u'')
-
-            logging.info(f"    Generating the graph: {name_link}")
-
-            fig = plgo.Figure()
-            layout = deepcopy(plot[u"layout"])
-
-            for color, graph in enumerate(graphs):
-                for idx, direction in enumerate((u"direction1", u"direction2")):
-                    previous_x = 0.0
-                    xaxis = list()
-                    yaxis = list()
-                    hovertext = list()
-                    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
-                        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: "
-                            f"{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: "
-                            f"{previous_x:.5f}-{percentile:.5f}%<br>"
-                            f"Latency: {item.value_iterated_to}uSec"
-                        )
-                        previous_x = percentile
-                    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],
-                                dash=u"solid",
-                                width=1 if idx % 2 else 2
-                            ),
-                            hovertext=hovertext,
-                            hoverinfo=u"text"
-                        )
-                    )
-
-            layout[u"title"][u"text"] = f"<b>Latency:</b> {name}"
-            fig.update_layout(layout)
-
-            # Create plot
-            file_name = f"{plot[u'output-file']}-{name_link}.html"
-            logging.info(f"    Writing file {file_name}")
-
-            try:
-                # Export Plot
-                ploff.plot(fig, show_link=False, auto_open=False,
-                           filename=file_name)
-                # Add link to the file:
-                if file_links and target_links:
-                    with open(file_links, u"a") as file_handler:
-                        file_handler.write(
-                            f"- `{name_link} "
-                            f"<{target_links}/{file_name.split(u'/')[-1]}>`_\n"
-                        )
-            except FileNotFoundError as err:
-                logging.error(
-                    f"Not possible to write the link to the file "
-                    f"{file_links}\n{err}"
-                )
-            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_hdrh_lat_by_percentile_x_log(plot, input_data):
-    """Generate the plot(s) with algorithm: plot_hdrh_lat_by_percentile_x_log
-    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'')}."
-    )
-    if plot.get(u"include", None):
-        data = input_data.filter_tests_by_name(
-            plot,
-            params=[u"name", u"latency", u"parent", u"tags", u"type"]
-        )[0][0]
-    elif plot.get(u"filter", None):
-        data = input_data.filter_data(
-            plot,
-            params=[u"name", u"latency", u"parent", u"tags", u"type"],
-            continue_on_error=True
-        )[0][0]
-    else:
-        job = list(plot[u"data"].keys())[0]
-        build = str(plot[u"data"][job][0])
-        data = input_data.tests(job, build)
-
-    if data is None or len(data) == 0:
-        logging.error(u"No data.")
-        return
-
-    desc = {
-        u"LAT0": u"No-load.",
-        u"PDR10": u"Low-load, 10% PDR.",
-        u"PDR50": u"Mid-load, 50% PDR.",
-        u"PDR90": u"High-load, 90% PDR.",
-        u"PDR": u"Full-load, 100% PDR.",
-        u"NDR10": u"Low-load, 10% NDR.",
-        u"NDR50": u"Mid-load, 50% NDR.",
-        u"NDR90": u"High-load, 90% NDR.",
-        u"NDR": u"Full-load, 100% NDR."
-    }
-
-    graphs = [
-        u"LAT0",
-        u"PDR10",
-        u"PDR50",
-        u"PDR90"
-    ]
-
-    file_links = plot.get(u"output-file-links", None)
-    target_links = plot.get(u"target-links", None)
-
-    for test in data:
-        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''))
-            try:
-                nic = re.search(REGEX_NIC, test[u"parent"]).group(1)
-            except (IndexError, AttributeError, KeyError, ValueError):
-                nic = u""
-            name_link = f"{nic}-{test[u'name']}".replace(u'-ndrpdr', u'')
-
-            logging.info(f"    Generating the graph: {name_link}")
-
-            fig = plgo.Figure()
-            layout = deepcopy(plot[u"layout"])
-
-            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()
-                    try:
-                        decoded = hdrh.histogram.HdrHistogram.decode(
-                            test[u"latency"][graph][direction][u"hdrh"]
-                        )
-                    except (hdrh.codec.HdrLengthException, TypeError):
-                        logging.warning(
-                            f"No data for direction {(u'W-E', u'E-W')[idx % 2]}"
-                        )
-                        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
-                        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: {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,
-                            y=yaxis,
-                            name=desc[graph],
-                            mode=u"lines",
-                            legendgroup=desc[graph],
-                            showlegend=not(bool(idx)),
-                            line=dict(
-                                color=COLORS[color],
-                                dash=u"solid",
-                                width=1 if idx % 2 else 2
-                            ),
-                            hovertext=hovertext,
-                            hoverinfo=u"text"
-                        )
-                    )
-
-            layout[u"title"][u"text"] = f"<b>Latency:</b> {name}"
-            x_max = log(100.0 / (100.0 - PERCENTILE_MAX), 10)
-            layout[u"xaxis"][u"range"] = [0, x_max]
-            fig.update_layout(layout)
-
-            # Create plot
-            file_name = f"{plot[u'output-file']}-{name_link}.html"
-            logging.info(f"    Writing file {file_name}")
-
-            try:
-                # Export Plot
-                ploff.plot(fig, show_link=False, auto_open=False,
-                           filename=file_name)
-                # Add link to the file:
-                if file_links and target_links:
-                    with open(file_links, u"a") as file_handler:
-                        file_handler.write(
-                            f"- `{name_link} "
-                            f"<{target_links}/{file_name.split(u'/')[-1]}>`_\n"
-                        )
-            except FileNotFoundError as err:
-                logging.error(
-                    f"Not possible to write the link to the file "
-                    f"{file_links}\n{err}"
-                )
-            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_nf_reconf_box_name(plot, input_data):
-    """Generate the plot(s) with algorithm: plot_nf_reconf_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 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"result", u"parent", u"tags", u"type"]
-    )
-    if data is None:
-        logging.error(u"No data.")
-        return
-
-    for core in plot.get(u"core", tuple()):
-        # Prepare the data for the plot
-        y_vals = OrderedDict()
-        loss = dict()
-        for item in plot.get(u"include", tuple()):
-            reg_ex = re.compile(str(item.format(core=core)).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
-                        if y_vals.get(test[u"parent"], None) is None:
-                            y_vals[test[u"parent"]] = list()
-                            loss[test[u"parent"]] = list()
-                        try:
-                            y_vals[test[u"parent"]].append(
-                                test[u"result"][u"time"]
-                            )
-                            loss[test[u"parent"]].append(
-                                test[u"result"][u"loss"]
-                            )
-                        except (KeyError, TypeError):
-                            y_vals[test[u"parent"]].append(None)
-
-        # Add None to the lists with missing data
-        max_len = 0
-        nr_of_samples = list()
-        for val in y_vals.values():
-            if len(val) > max_len:
-                max_len = len(val)
-            nr_of_samples.append(len(val))
-        for val in y_vals.values():
-            if len(val) < max_len:
-                val.extend([None for _ in range(max_len - len(val))])
-
-        # Add plot traces
-        traces = list()
-        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'-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=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'-')[2:])}"
-                ),
-                hoverinfo=u"y+name"
-            ))
-        try:
-            # Create plot
-            layout = deepcopy(plot[u"layout"])
-            layout[u"title"] = f"<b>Time Lost:</b> {layout[u'title']}"
-            layout[u"yaxis"][u"title"] = u"<b>Effective Blocked Time [s]</b>"
-            layout[u"legend"][u"font"][u"size"] = 14
-            layout[u"yaxis"].pop(u"range")
-            plpl = plgo.Figure(data=traces, layout=layout)
-
-            # Export Plot
-            file_name = f"{plot[u'output-file'].format(core=core)}.html"
-            logging.info(f"    Writing file {file_name}")
-            ploff.plot(
-                plpl,
-                show_link=False,
-                auto_open=False,
-                filename=file_name
-            )
-        except PlotlyError as err:
-            logging.error(
-                f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
-            )
-
-
-def plot_perf_box_name(plot, input_data):
-    """Generate the plot(s) with algorithm: plot_perf_box_name
-    specified in the specification file.
-
-    Use only for soak and hoststack tests.
-
-    :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"throughput", u"gbps", u"result", u"parent", u"tags", u"type"])
-    if data is None:
-        logging.error(u"No data.")
-        return
-
-    # Prepare the data for the plot
-    y_vals = OrderedDict()
-    test_type = u""
-
-    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
-                    if y_vals.get(test[u"parent"], None) is None:
-                        y_vals[test[u"parent"]] = list()
-                    try:
-                        if 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(
-                                    float(
-                                        test[u"result"][u"bits_per_second"]
-                                    ) / 1e3
-                                )
-                            elif u"VPPECHO" in test[u"tags"]:
-                                y_vals[test[u"parent"]].append(
-                                    (float(
-                                        test[u"result"][u"client"][u"tx_data"]
-                                    ) * 8 / 1e3) /
-                                    ((float(
-                                        test[u"result"][u"client"][u"time"]
-                                    ) +
-                                      float(
-                                          test[u"result"][u"server"][u"time"])
-                                      ) / 2)
-                                )
-                            test_type = u"HOSTSTACK"
-
-                        elif test[u"type"] in (u"LDP_NGINX",):
-                            if u"TCP_CPS" in test[u"tags"]:
-                                test_type = u"VSAP_CPS"
-                                y_vals[test[u"parent"]].append(
-                                    test[u"result"][u"cps"]
-                                )
-                            elif u"TCP_RPS" in test[u"tags"]:
-                                test_type = u"VSAP_RPS"
-                                y_vals[test[u"parent"]].append(
-                                    test[u"result"][u"rps"]
-                                )
-                            else:
-                                continue
-                        else:
-                            continue
-
-                    except (KeyError, TypeError):
-                        y_vals[test[u"parent"]].append(None)
-
-    # Add None to the lists with missing data
-    max_len = 0
-    nr_of_samples = list()
-    for val in y_vals.values():
-        if len(val) > max_len:
-            max_len = len(val)
-        nr_of_samples.append(len(val))
-    for val in y_vals.values():
-        if len(val) < max_len:
-            val.extend([None for _ in range(max_len - len(val))])
-
-    # Add plot traces
-    traces = list()
-    df_y = pd.DataFrame(y_vals)
-    df_y.head()
-    y_max = list()
-    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''))
-        if test_type in (u"VSAP_CPS", u"VSAP_RPS"):
-            data_y = [y if y else None for y in df_y[col]]
-        else:
-            data_y = [y / 1e6 if y else None for y in df_y[col]]
-        kwargs = dict(
-            y=data_y,
-            name=(
-                f"{i + 1}. "
-                f"({nr_of_samples[i]:02d} "
-                f"run{u's' if nr_of_samples[i] > 1 else u''}) "
-                f"{tst_name}"
-            ),
-            hoverinfo=u"y+name"
-        )
-        if test_type in (u"SOAK", ):
-            kwargs[u"boxpoints"] = u"all"
-            kwargs[u"jitter"] = 0.3
-
-        traces.append(plgo.Box(**kwargs))
-
-        try:
-            val_max = max(df_y[col])
-            if val_max:
-                if test_type in (u"VSAP_CPS", u"VSAP_RPS"):
-                    y_max.append(int(val_max))
-                else:
-                    y_max.append(int(val_max / 1e6))
-        except (ValueError, TypeError) as err:
-            logging.error(repr(err))
-            continue
-
-    try:
-        # Create plot
-        layout = deepcopy(plot[u"layout"])
-        layout[u"xaxis"][u"tickvals"] = [i for i in range(len(y_vals))]
-        layout[u"xaxis"][u"ticktext"] = [str(i + 1) for i in range(len(y_vals))]
-        if layout.get(u"title", None):
-            if test_type in (u"HOSTSTACK", ):
-                layout[u"title"] = f"<b>Bandwidth:</b> {layout[u'title']}"
-            elif test_type == u"VSAP_CPS":
-                layout[u"title"] = f"<b>CPS:</b> {layout[u'title']}"
-                layout[u"yaxis"][u"title"] = u"<b>Connection Rate [cps]</b>"
-            elif test_type == u"VSAP_RPS":
-                layout[u"title"] = f"<b>RPS:</b> {layout[u'title']}"
-                layout[u"yaxis"][u"title"] = u"<b>Connection Rate [rps]</b>"
-            else:
-                layout[u"title"] = f"<b>Tput:</b> {layout[u'title']}"
-        if y_max and max(y_max) > 1:
-            layout[u"yaxis"][u"range"] = [0, max(y_max) + 2]
-        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_ndrpdr_box_name(plot, input_data):
-    """Generate the plot(s) with algorithm: plot_ndrpdr_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"throughput", u"gbps", u"parent", u"tags", u"type"]
-    )
-    if data is None:
-        logging.error(u"No data.")
-        return
-
-    if u"-gbps" in plot.get(u"title", u"").lower():
-        value = u"gbps"
-        multiplier = 1e6
-    else:
-        value = u"throughput"
-        multiplier = 1.0
-
-    test_type = u""
-
-    for ttype in plot.get(u"test-type", (u"ndr", u"pdr")):
-        for core in plot.get(u"core", tuple()):
-            # Prepare the data for the plot
-            data_x = list()
-            data_y = OrderedDict()
-            data_y_max = list()
-            idx = 1
-            for item in plot.get(u"include", tuple()):
-                reg_ex = re.compile(str(item.format(core=core)).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
-                            if data_y.get(test[u"parent"], None) is None:
-                                data_y[test[u"parent"]] = list()
-                                test_type = test[u"type"]
-                                data_x.append(idx)
-                                idx += 1
-                            try:
-                                data_y[test[u"parent"]].append(
-                                    test[value][ttype.upper()][u"LOWER"] *
-                                    multiplier
-                                )
-                            except (KeyError, TypeError):
-                                pass
-
-            # Add plot traces
-            traces = list()
-            for idx, (key, vals) in enumerate(data_y.items()):
-                name = re.sub(
-                    REGEX_NIC, u'', key.lower().replace(u'-ndrpdr', u'').
-                    replace(u'2n1l-', u'')
-                )
-                kwargs = dict(
-                    y=[y / 1e6 if y else None for y in vals],
-                    name=(
-                        f"{idx + 1}."
-                        f"({len(vals):02d} "
-                        f"run"
-                        f"{u's' if len(vals) > 1 else u''}) "
-                        f"{name}"
-                    ),
-                    hoverinfo=u"y+name"
-                )
-                box_points = plot.get(u"boxpoints", u"all")
-                if box_points in \
-                        (u"all", u"outliers", u"suspectedoutliers", False):
-                    kwargs[u"boxpoints"] = box_points
-                    kwargs[u"jitter"] = 0.3
-                traces.append(plgo.Box(**kwargs))
-                try:
-                    data_y_max.append(max(vals))
-                except ValueError as err:
-                    logging.warning(f"No values to use.\n{err!r}")
-            try:
-                # Create plot
-                layout = deepcopy(plot[u"layout"])
-                layout[u"xaxis"][u"tickvals"] = [i for i in range(len(data_y))]
-                layout[u"xaxis"][u"ticktext"] = \
-                    [str(i + 1) for i in range(len(data_y))]
-                if layout.get(u"title", None):
-                    layout[u"title"] = \
-                        layout[u'title'].format(core=core, test_type=ttype)
-                    if test_type in (u"CPS", ):
-                        layout[u"title"] = f"<b>CPS:</b> {layout[u'title']}"
-                    else:
-                        layout[u"title"] = \
-                            f"<b>Tput:</b> {layout[u'title']}"
-                if data_y_max:
-                    layout[u"yaxis"][u"range"] = [0, max(data_y_max) / 1e6 + 1]
-                plpl = plgo.Figure(data=traces, layout=layout)
-
-                # Export Plot
-                file_name = (
-                    f"{plot[u'output-file'].format(core=core, test_type=ttype)}"
-                    f".html"
-                )
-                logging.info(f"    Writing file {file_name}")
-                ploff.plot(
-                    plpl,
-                    show_link=False,
-                    auto_open=False,
-                    filename=file_name
-                )
-            except PlotlyError as err:
-                logging.error(
-                    f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
-                )
-
-
-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
-
-    for core in plot.get(u"core", tuple()):
-        # 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.format(core=core)).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(data_y[-1]))
-                            idx += 1
-                        except (KeyError, TypeError):
-                            pass
-
-        # Add plot traces
-        traces = list()
-        for idx, x_item in enumerate(data_x):
-            kwargs = dict(
-                y=data_y[idx],
-                name=data_names[idx],
-                hoverinfo=u"y+name"
-            )
-            box_points = plot.get(u"boxpoints", u"all")
-            if box_points in (u"all", u"outliers", u"suspectedoutliers", False):
-                kwargs[u"boxpoints"] = box_points
-                kwargs["jitter"] = 0.3
-            traces.append(plgo.Box(**kwargs))
-
-        try:
-            # Create plot
-            layout = deepcopy(plot[u"layout"])
-            layout[u"xaxis"][u"tickvals"] = [i for i in range(len(data_y))]
-            layout[u"xaxis"][u"ticktext"] = \
-                [str(i + 1) for i in range(len(data_y))]
-            if layout.get(u"title", None):
-                layout[u"title"] = (
-                    f"<b>Tput:</b> {layout[u'title'].format(core=core)}"
-                )
-            if data_y_max:
-                layout[u"yaxis"][u"range"] = [0, max(data_y_max) + 1]
-            plpl = plgo.Figure(data=traces, layout=layout)
-
-            # Export Plot
-            file_name = f"{plot[u'output-file'].format(core=core)}.html"
-            logging.info(f"    Writing file {file_name}")
-            ploff.plot(
-                plpl,
-                show_link=False,
-                auto_open=False,
-                filename=file_name
-            )
-        except PlotlyError as err:
-            logging.error(
-                f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
-            )
-
-
-def plot_tsa_name(plot, input_data):
-    """Generate the plot(s) with algorithm:
-    plot_tsa_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
-    plot_title = plot.get(u"title", u"")
-    logging.info(
-        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"gbps", u"parent", u"tags", u"type"]
-    )
-    if data is None:
-        logging.error(u"No data.")
-        return
-
-    plot_title = plot_title.lower()
-
-    if u"-gbps" in plot_title:
-        value = u"gbps"
-        h_unit = u"Gbps"
-        multiplier = 1e6
-    else:
-        value = u"throughput"
-        h_unit = u"Mpps"
-        multiplier = 1.0
-
-    for ttype in plot.get(u"test-type", (u"ndr", u"pdr")):
-        y_vals = OrderedDict()
-        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 re.match(reg_ex, str(test_id).lower()):
-                            if y_vals.get(test[u"parent"], None) is None:
-                                y_vals[test[u"parent"]] = {
-                                    u"1": list(),
-                                    u"2": list(),
-                                    u"4": list()
-                                }
-                            try:
-                                if test[u"type"] not in (u"NDRPDR", u"CPS"):
-                                    continue
-
-                                if u"1C" in test[u"tags"]:
-                                    y_vals[test[u"parent"]][u"1"].append(
-                                        test[value][ttype.upper()][u"LOWER"] *
-                                        multiplier
-                                    )
-                                elif u"2C" in test[u"tags"]:
-                                    y_vals[test[u"parent"]][u"2"].append(
-                                        test[value][ttype.upper()][u"LOWER"] *
-                                        multiplier
-                                    )
-                                elif u"4C" in test[u"tags"]:
-                                    y_vals[test[u"parent"]][u"4"].append(
-                                        test[value][ttype.upper()][u"LOWER"] *
-                                        multiplier
-                                    )
-                            except (KeyError, TypeError):
-                                pass
-
-        if not y_vals:
-            logging.warning(f"No data for the plot {plot.get(u'title', u'')}")
-            return
-
-        y_1c_max = dict()
-        for test_name, test_vals in y_vals.items():
-            for key, test_val in test_vals.items():
-                if test_val:
-                    avg_val = sum(test_val) / len(test_val)
-                    y_vals[test_name][key] = [avg_val, len(test_val)]
-                    ideal = avg_val / (int(key) * 1e6)
-                    if test_name not in y_1c_max or ideal > y_1c_max[test_name]:
-                        y_1c_max[test_name] = ideal
-
-        vals = OrderedDict()
-        y_max = list()
-        nic_limit = 0
-        lnk_limit = 0
-        pci_limit = 0
-        for test_name, test_vals in y_vals.items():
-            try:
-                if test_vals[u"1"][1]:
-                    name = re.sub(
-                        REGEX_NIC,
-                        u"",
-                        test_name.replace(u'-ndrpdr', u'').
-                        replace(u'2n1l-', u'')
-                    )
-                    vals[name] = OrderedDict()
-                    y_val_1 = test_vals[u"1"][0] / 1e6
-                    y_val_2 = test_vals[u"2"][0] / 1e6 if test_vals[u"2"][0] \
-                        else None
-                    y_val_4 = test_vals[u"4"][0] / 1e6 if test_vals[u"4"][0] \
-                        else None
-
-                    vals[name][u"val"] = [y_val_1, y_val_2, y_val_4]
-                    vals[name][u"rel"] = [1.0, None, None]
-                    vals[name][u"ideal"] = [
-                        y_1c_max[test_name],
-                        y_1c_max[test_name] * 2,
-                        y_1c_max[test_name] * 4
-                    ]
-                    vals[name][u"diff"] = [
-                        (y_val_1 - y_1c_max[test_name]) * 100 / y_val_1,
-                        None,
-                        None
-                    ]
-                    vals[name][u"count"] = [
-                        test_vals[u"1"][1],
-                        test_vals[u"2"][1],
-                        test_vals[u"4"][1]
-                    ]
-
-                    try:
-                        val_max = max(vals[name][u"val"])
-                    except ValueError as err:
-                        logging.error(repr(err))
-                        continue
-                    if val_max:
-                        y_max.append(val_max)
-
-                    if y_val_2:
-                        vals[name][u"rel"][1] = round(y_val_2 / y_val_1, 2)
-                        vals[name][u"diff"][1] = \
-                            (y_val_2 - vals[name][u"ideal"][1]) * 100 / y_val_2
-                    if y_val_4:
-                        vals[name][u"rel"][2] = round(y_val_4 / y_val_1, 2)
-                        vals[name][u"diff"][2] = \
-                            (y_val_4 - vals[name][u"ideal"][2]) * 100 / y_val_4
-            except IndexError as err:
-                logging.warning(f"No data for {test_name}")
-                logging.warning(repr(err))
-
-            # Limits:
-            if u"x520" in test_name:
-                limit = plot[u"limits"][u"nic"][u"x520"]
-            elif u"x710" in test_name:
-                limit = plot[u"limits"][u"nic"][u"x710"]
-            elif u"xxv710" in test_name:
-                limit = plot[u"limits"][u"nic"][u"xxv710"]
-            elif u"xl710" in test_name:
-                limit = plot[u"limits"][u"nic"][u"xl710"]
-            elif u"x553" in test_name:
-                limit = plot[u"limits"][u"nic"][u"x553"]
-            elif u"cx556a" in test_name:
-                limit = plot[u"limits"][u"nic"][u"cx556a"]
-            elif u"e810cq" in test_name:
-                limit = plot[u"limits"][u"nic"][u"e810cq"]
-            elif u"e810xxv" in test_name:
-                limit = plot[u"limits"][u"nic"][u"e810xxv"]
-            elif u"e822cq" in test_name:
-                limit = plot[u"limits"][u"nic"][u"e822cq"]
-            else:
-                limit = 0
-            if limit > nic_limit:
-                nic_limit = limit
-
-            mul = 2 if u"ge2p" in test_name else 1
-            if u"10ge" in test_name:
-                limit = plot[u"limits"][u"link"][u"10ge"] * mul
-            elif u"25ge" in test_name:
-                limit = plot[u"limits"][u"link"][u"25ge"] * mul
-            elif u"40ge" in test_name:
-                limit = plot[u"limits"][u"link"][u"40ge"] * mul
-            elif u"100ge" in test_name:
-                limit = plot[u"limits"][u"link"][u"100ge"] * mul
-            else:
-                limit = 0
-            if limit > lnk_limit:
-                lnk_limit = limit
-
-            if u"cx556a" in test_name:
-                limit = plot[u"limits"][u"pci"][u"pci-g3-x8"]
-            else:
-                limit = plot[u"limits"][u"pci"][u"pci-g3-x16"]
-            if limit > pci_limit:
-                pci_limit = limit
-
-        traces = list()
-        annotations = list()
-        x_vals = [1, 2, 4]
-
-        # Limits:
-        if u"-gbps" not in plot_title and u"-cps-" not in plot_title:
-            nic_limit /= 1e6
-            lnk_limit /= 1e6
-            pci_limit /= 1e6
-            min_limit = min((nic_limit, lnk_limit, pci_limit))
-            if nic_limit == min_limit:
-                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)
-            elif lnk_limit == min_limit:
-                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[-1],
-                        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[-1],
-                    ),
-                    align=u"left",
-                    showarrow=False
-                ))
-                y_max.append(lnk_limit)
-            elif pci_limit == min_limit:
-                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[-1],
-                        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[-1],
-                    ),
-                    align=u"left",
-                    showarrow=False
-                ))
-                y_max.append(pci_limit)
-
-        # Perfect and measured:
-        cidx = 0
-        for name, val in vals.items():
-            hovertext = list()
-            try:
-                for idx in range(len(val[u"val"])):
-                    htext = ""
-                    if isinstance(val[u"val"][idx], float):
-                        htext += (
-                            f"No. of Runs: {val[u'count'][idx]}<br>"
-                            f"Mean: {val[u'val'][idx]:.2f}{h_unit}<br>"
-                        )
-                    if isinstance(val[u"diff"][idx], float):
-                        htext += f"Diff: {round(val[u'diff'][idx]):.0f}%<br>"
-                    if isinstance(val[u"rel"][idx], float):
-                        htext += f"Speedup: {val[u'rel'][idx]:.2f}"
-                    hovertext.append(htext)
-                traces.append(
-                    plgo.Scatter(
-                        x=x_vals,
-                        y=val[u"val"],
-                        name=name,
-                        legendgroup=name,
-                        mode=u"lines+markers",
-                        line=dict(
-                            color=COLORS[cidx],
-                            width=2),
-                        marker=dict(
-                            symbol=u"circle",
-                            size=10
-                        ),
-                        text=hovertext,
-                        hoverinfo=u"text+name"
-                    )
-                )
-                traces.append(
-                    plgo.Scatter(
-                        x=x_vals,
-                        y=val[u"ideal"],
-                        name=f"{name} perfect",
-                        legendgroup=name,
-                        showlegend=False,
-                        mode=u"lines",
-                        line=dict(
-                            color=COLORS[cidx],
-                            width=2,
-                            dash=u"dash"),
-                        text=[f"Perfect: {y:.2f}Mpps" for y in val[u"ideal"]],
-                        hoverinfo=u"text"
-                    )
-                )
-                cidx += 1
-            except (IndexError, ValueError, KeyError) as err:
-                logging.warning(f"No data for {name}\n{repr(err)}")
-
-        try:
-            # Create plot
-            file_name = f"{plot[u'output-file'].format(test_type=ttype)}.html"
-            logging.info(f"    Writing file {file_name}")
-            layout = deepcopy(plot[u"layout"])
-            if layout.get(u"title", None):
-                layout[u"title"] = (
-                    f"<b>Speedup Multi-core:</b> "
-                    f"{layout[u'title'].format(test_type=ttype)}"
-                )
-            layout[u"yaxis"][u"range"] = [0, int(max(y_max) * 1.1)]
-            layout[u"annotations"].extend(annotations)
-            plpl = plgo.Figure(data=traces, layout=layout)
-
-            # Export Plot
-            ploff.plot(
-                plpl,
-                show_link=False,
-                auto_open=False,
-                filename=file_name
-            )
-        except PlotlyError as err:
-            logging.error(
-                f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
-            )
-
-
-def plot_http_server_perf_box(plot, input_data):
-    """Generate the plot(s) with algorithm: plot_http_server_perf_box
-    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_data(plot)
-    if data is None:
-        logging.error(u"No data.")
-        return
-
-    # Prepare the data for the plot
-    y_vals = dict()
-    for job in data:
-        for build in job:
-            for test in build:
-                if y_vals.get(test[u"name"], None) is None:
-                    y_vals[test[u"name"]] = list()
-                try:
-                    y_vals[test[u"name"]].append(test[u"result"])
-                except (KeyError, TypeError):
-                    y_vals[test[u"name"]].append(None)
-
-    # Add None to the lists with missing data
-    max_len = 0
-    nr_of_samples = list()
-    for val in y_vals.values():
-        if len(val) > max_len:
-            max_len = len(val)
-        nr_of_samples.append(len(val))
-    for val in y_vals.values():
-        if len(val) < max_len:
-            val.extend([None for _ in range(max_len - len(val))])
-
-    # Add plot traces
-    traces = list()
-    df_y = pd.DataFrame(y_vals)
-    df_y.head()
-    for i, col in enumerate(df_y.columns):
-        name = \
-            f"{i + 1}. " \
-            f"({nr_of_samples[i]:02d} " \
-            f"run{u's' if nr_of_samples[i] > 1 else u''}) " \
-            f"{col.lower().replace(u'-ndrpdr', u'')}"
-        if len(name) > 50:
-            name_lst = name.split(u'-')
-            name = u""
-            split_name = True
-            for segment in name_lst:
-                if (len(name) + len(segment) + 1) > 50 and split_name:
-                    name += u"<br>    "
-                    split_name = False
-                name += segment + u'-'
-            name = name[:-1]
-
-        traces.append(plgo.Box(x=[str(i + 1) + u'.'] * len(df_y[col]),
-                               y=df_y[col],
-                               name=name,
-                               **plot[u"traces"]))
-    try:
-        # Create plot
-        plpl = plgo.Figure(data=traces, layout=plot[u"layout"])
-
-        # Export Plot
-        logging.info(
-            f"    Writing file {plot[u'output-file']}"
-            f"{plot[u'output-file-type']}."
-        )
-        ploff.plot(
-            plpl,
-            show_link=False,
-            auto_open=False,
-            filename=f"{plot[u'output-file']}{plot[u'output-file-type']}"
-        )
-    except PlotlyError as err:
-        logging.error(
-            f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
-        )
-        return
-
-
-def plot_nf_heatmap(plot, input_data):
-    """Generate the plot(s) with algorithm: plot_nf_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
-    """
-
-    def sort_by_int(value):
-        """Makes possible to sort a list of strings which represent integers.
-
-        :param value: Integer as a string.
-        :type value: str
-        :returns: Integer representation of input parameter 'value'.
-        :rtype: int
-        """
-        return int(value)
-
-    regex_cn = re.compile(r'^(\d*)R(\d*)C$')
-    regex_test_name = re.compile(r'^.*-(\d+ch|\d+pl)-'
-                                 r'(\d+mif|\d+vh)-'
-                                 r'(\d+vm\d+t|\d+dcr\d+t|\d+dcr\d+c).*$')
-    # Transform the data
-    logging.info(
-        f"    Creating the data set for the {plot.get(u'type', u'')} "
-        f"{plot.get(u'title', u'')}."
-    )
-    in_data = input_data.filter_tests_by_name(
-        plot,
-        continue_on_error=True,
-        params=[u"throughput", u"result", u"name", u"tags", u"type"]
-    )
-    if in_data is None or in_data.empty:
-        logging.error(u"No data.")
-        return
-
-    for ttype in plot.get(u"test-type", (u"ndr", u"pdr")):
-        for core in plot.get(u"core", tuple()):
-            vals = dict()
-            for item in plot.get(u"include", tuple()):
-                reg_ex = re.compile(str(item.format(core=core)).lower())
-                for job in in_data:
-                    for build in job:
-                        for test_id, test in build.iteritems():
-                            if not re.match(reg_ex, str(test_id).lower()):
-                                continue
-                            for tag in test[u"tags"]:
-                                groups = re.search(regex_cn, tag)
-                                if groups:
-                                    chain = str(groups.group(1))
-                                    node = str(groups.group(2))
-                                    break
-                            else:
-                                continue
-                            groups = re.search(regex_test_name, test[u"name"])
-                            if groups and len(groups.groups()) == 3:
-                                hover_name = (
-                                    f"{str(groups.group(1))}-"
-                                    f"{str(groups.group(2))}-"
-                                    f"{str(groups.group(3))}"
-                                )
-                            else:
-                                hover_name = u""
-                            if vals.get(chain, None) is None:
-                                vals[chain] = dict()
-                            if vals[chain].get(node, None) is None:
-                                vals[chain][node] = dict(
-                                    name=hover_name,
-                                    vals=list(),
-                                    nr=None,
-                                    mean=None,
-                                    stdev=None
-                                )
-                            try:
-                                if ttype == u"mrr":
-                                    result = test[u"result"][u"receive-rate"]
-                                elif ttype == u"pdr":
-                                    result = \
-                                        test[u"throughput"][u"PDR"][u"LOWER"]
-                                elif ttype == u"ndr":
-                                    result = \
-                                        test[u"throughput"][u"NDR"][u"LOWER"]
-                                else:
-                                    result = None
-                            except TypeError:
-                                result = None
-
-                            if result:
-                                vals[chain][node][u"vals"].append(result)
-
-            if not vals:
-                logging.error(u"No data.")
-                return
-
-            txt_chains = list()
-            txt_nodes = list()
-            for key_c in vals:
-                txt_chains.append(key_c)
-                for key_n in vals[key_c].keys():
-                    txt_nodes.append(key_n)
-                    if vals[key_c][key_n][u"vals"]:
-                        vals[key_c][key_n][u"nr"] = \
-                            len(vals[key_c][key_n][u"vals"])
-                        vals[key_c][key_n][u"mean"] = \
-                            round(mean(vals[key_c][key_n][u"vals"]) / 1e6, 1)
-                        vals[key_c][key_n][u"stdev"] = \
-                            round(stdev(vals[key_c][key_n][u"vals"]) / 1e6, 1)
-            txt_nodes = list(set(txt_nodes))
-
-            txt_chains = sorted(txt_chains, key=sort_by_int)
-            txt_nodes = sorted(txt_nodes, key=sort_by_int)
-
-            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 chain in chains:
-                for node in nodes:
-                    try:
-                        val = vals[txt_chains[chain - 1]] \
-                            [txt_nodes[node - 1]][u"mean"]
-                    except (KeyError, IndexError):
-                        val = None
-                    data[chain - 1].append(val)
-
-            # Color scales:
-            my_green = [[0.0, u"rgb(235, 249, 242)"],
-                        [1.0, u"rgb(45, 134, 89)"]]
-
-            my_blue = [[0.0, u"rgb(236, 242, 248)"],
-                       [1.0, u"rgb(57, 115, 172)"]]
-
-            my_grey = [[0.0, u"rgb(230, 230, 230)"],
-                       [1.0, u"rgb(102, 102, 102)"]]
-
-            hovertext = list()
-            annotations = list()
-
-            text = (u"Test: {name}<br>"
-                    u"Runs: {nr}<br>"
-                    u"Thput: {val}<br>"
-                    u"StDev: {stdev}")
-
-            for chain, _ in enumerate(txt_chains):
-                hover_line = list()
-                for node, _ in enumerate(txt_nodes):
-                    if data[chain][node] is not None:
-                        annotations.append(
-                            dict(
-                                x=node+1,
-                                y=chain+1,
-                                xref=u"x",
-                                yref=u"y",
-                                xanchor=u"center",
-                                yanchor=u"middle",
-                                text=str(data[chain][node]),
-                                font=dict(
-                                    size=14,
-                                ),
-                                align=u"center",
-                                showarrow=False
-                            )
-                        )
-                        hover_line.append(text.format(
-                            name=vals[txt_chains[chain]][txt_nodes[node]]
-                            [u"name"],
-                            nr=vals[txt_chains[chain]][txt_nodes[node]][u"nr"],
-                            val=data[chain][node],
-                            stdev=vals[txt_chains[chain]][txt_nodes[node]]
-                            [u"stdev"]
-                        ))
-                hovertext.append(hover_line)
-
-            traces = [
-                plgo.Heatmap(
-                    x=nodes,
-                    y=chains,
-                    z=data,
-                    colorbar=dict(
-                        title=plot.get(u"z-axis", u"{test_type}").
-                        format(test_type=ttype.upper()),
-                        titleside=u"right",
-                        titlefont=dict(
-                            size=16
-                        ),
-                        tickfont=dict(
-                            size=16,
-                        ),
-                        tickformat=u".1f",
-                        yanchor=u"bottom",
-                        y=-0.02,
-                        len=0.925,
-                    ),
-                    showscale=True,
-                    colorscale=my_green,
-                    text=hovertext,
-                    hoverinfo=u"text"
-                )
-            ]
-
-            for idx, item in enumerate(txt_nodes):
-                # X-axis, numbers:
-                annotations.append(
-                    dict(
-                        x=idx+1,
-                        y=0.05,
-                        xref=u"x",
-                        yref=u"y",
-                        xanchor=u"center",
-                        yanchor=u"top",
-                        text=item,
-                        font=dict(
-                            size=16,
-                        ),
-                        align=u"center",
-                        showarrow=False
-                    )
-                )
-            for idx, item in enumerate(txt_chains):
-                # Y-axis, numbers:
-                annotations.append(
-                    dict(
-                        x=0.35,
-                        y=idx+1,
-                        xref=u"x",
-                        yref=u"y",
-                        xanchor=u"right",
-                        yanchor=u"middle",
-                        text=item,
-                        font=dict(
-                            size=16,
-                        ),
-                        align=u"center",
-                        showarrow=False
-                    )
-                )
-            # X-axis, title:
-            annotations.append(
-                dict(
-                    x=0.55,
-                    y=-0.15,
-                    xref=u"paper",
-                    yref=u"y",
-                    xanchor=u"center",
-                    yanchor=u"bottom",
-                    text=plot.get(u"x-axis", u""),
-                    font=dict(
-                        size=16,
-                    ),
-                    align=u"center",
-                    showarrow=False
-                )
-            )
-            # Y-axis, title:
-            annotations.append(
-                dict(
-                    x=-0.1,
-                    y=0.5,
-                    xref=u"x",
-                    yref=u"paper",
-                    xanchor=u"center",
-                    yanchor=u"middle",
-                    text=plot.get(u"y-axis", u""),
-                    font=dict(
-                        size=16,
-                    ),
-                    align=u"center",
-                    textangle=270,
-                    showarrow=False
-                )
-            )
-            updatemenus = list([
-                dict(
-                    x=1.0,
-                    y=0.0,
-                    xanchor=u"right",
-                    yanchor=u"bottom",
-                    direction=u"up",
-                    buttons=list([
-                        dict(
-                            args=[
-                                {
-                                    u"colorscale": [my_green, ],
-                                    u"reversescale": False
-                                }
-                            ],
-                            label=u"Green",
-                            method=u"update"
-                        ),
-                        dict(
-                            args=[
-                                {
-                                    u"colorscale": [my_blue, ],
-                                    u"reversescale": False
-                                }
-                            ],
-                            label=u"Blue",
-                            method=u"update"
-                        ),
-                        dict(
-                            args=[
-                                {
-                                    u"colorscale": [my_grey, ],
-                                    u"reversescale": False
-                                }
-                            ],
-                            label=u"Grey",
-                            method=u"update"
-                        )
-                    ])
-                )
-            ])
-
-            try:
-                layout = deepcopy(plot[u"layout"])
-            except KeyError as err:
-                logging.error(
-                    f"Finished with error: No layout defined\n{repr(err)}"
-                )
-                return
-
-            layout[u"annotations"] = annotations
-            layout[u'updatemenus'] = updatemenus
-            if layout.get(u"title", None):
-                layout[u"title"] = layout[u'title'].replace(u"test_type", ttype)
-
-            try:
-                # Create plot
-                plpl = plgo.Figure(data=traces, layout=layout)
-
-                # Export Plot
-                file_name = (
-                    f"{plot[u'output-file'].format(core=core, test_type=ttype)}"
-                    f".html"
-                )
-                logging.info(f"    Writing file {file_name}")
-                ploff.plot(
-                    plpl,
-                    show_link=False,
-                    auto_open=False,
-                    filename=file_name
-                )
-            except PlotlyError as err:
-                logging.error(
-                    f"   Finished with error: {repr(err)}".replace(u"\n", u" ")
-                )