path: root/csit.infra.dash/app/cdash/report/graphs.py

# Copyright (c) 2024 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.

"""Implementation of graphs for iterative data.
"""

import plotly.graph_objects as go
import pandas as pd

from copy import deepcopy
from numpy import percentile

from ..utils.constants import Constants as C
from ..utils.utils import get_color, get_hdrh_latencies


def select_iterative_data(data: pd.DataFrame, itm:dict) -> pd.DataFrame:
    """Select the data for graphs and tables from the provided data frame.

    :param data: Data frame with data for graphs and tables.
    :param itm: Item (in this case job name) which data will be selected from
        the input data frame.
    :type data: pandas.DataFrame
    :type itm: str
    :returns: A data frame with selected data.
    :rtype: pandas.DataFrame
    """

    phy = itm["phy"].split("-")
    if len(phy) == 4:
        topo, arch, nic, drv = phy
        if drv == "dpdk":
            drv = ""
        else:
            drv += "-"
            drv = drv.replace("_", "-")
    else:
        return None

    if itm["testtype"] in ("ndr", "pdr"):
        test_type = "ndrpdr"
    elif itm["testtype"] == "mrr":
        test_type = "mrr"
    elif itm["testtype"] == "soak":
        test_type = "soak"
    elif itm["area"] == "hoststack":
        test_type = "hoststack"
    df = data.loc[(
        (data["release"] == itm["rls"]) &
        (data["test_type"] == test_type) &
        (data["passed"] == True)
    )]

    core = str() if itm["dut"] == "trex" else f"{itm['core']}"
    ttype = "ndrpdr" if itm["testtype"] in ("ndr", "pdr") else itm["testtype"]
    regex_test = \
        f"^.*[.|-]{nic}.*{itm['framesize']}-{core}-{drv}{itm['test']}-{ttype}$"
    df = df[
        (df.job.str.endswith(f"{topo}-{arch}")) &
        (df.dut_version.str.contains(itm["dutver"].replace(".r", "-r").\
            replace("rls", "release"))) &
        (df.test_id.str.contains(regex_test, regex=True))
    ]

    return df


def graph_iterative(data: pd.DataFrame, sel: list, layout: dict,
        normalize: bool=False, remove_outliers: bool=False) -> tuple:
    """Generate the statistical box graph with iterative data (MRR, NDR and PDR,
    for PDR also Latencies).

    :param data: Data frame with iterative data.
    :param sel: Selected tests.
    :param layout: Layout of plot.ly graph.
    :param normalize: If True, the data is normalized to CPU frequency
        Constants.NORM_FREQUENCY.
    :param remove_outliers: If True the outliers are removed before
        generating the table.
    :type data: pandas.DataFrame
    :type sel: list
    :type layout: dict
    :type normalize: bool
    :type remove_outliers: bool
    :returns: Tuple of graphs - throughput and latency.
    :rtype: tuple(plotly.graph_objects.Figure, plotly.graph_objects.Figure)
    """

    def get_y_values(data, y_data_max, param, norm_factor, release=str(),
                     remove_outliers=False):
        if param == "result_receive_rate_rate_values":
            if release in ("rls2402", "rls2406", "rls2410"):
                y_vals_raw = data["result_receive_rate_rate_avg"].to_list()
            else:
                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]

        if remove_outliers:
            try:
                q1 = percentile(y_data, 25, method=C.COMP_PERCENTILE_METHOD)
                q3 = percentile(y_data, 75, method=C.COMP_PERCENTILE_METHOD)
                irq = q3 - q1
                lif = q1 - C.COMP_OUTLIER_TYPE * irq
                uif = q3 + C.COMP_OUTLIER_TYPE * irq
                y_data = [i for i in y_data if i >= lif and i <= uif]
            except TypeError:
                pass
        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()

    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)
        if itm_data.empty:
            continue

        phy = itm["phy"].split("-")
        topo_arch = f"{phy[0]}-{phy[1]}" if len(phy) == 4 else str()
        norm_factor = (C.NORM_FREQUENCY / C.FREQUENCY[topo_arch]) \
            if normalize else 1.0

        if itm["area"] == "hoststack":
            ttype = f"hoststack-{itm['testtype']}"
        else:
            ttype = itm["testtype"]

        y_units.update(itm_data[C.UNIT[ttype]].unique().tolist())

        y_data, y_tput_max = get_y_values(
            itm_data,
            y_tput_max,
            C.VALUE_ITER[ttype],
            norm_factor,
            itm["rls"],
            remove_outliers
        )

        nr_of_samples = len(y_data)

        customdata = list()
        metadata = {
            "csit release": itm["rls"],
            "dut": itm["dut"],
            "dut version": itm["dutver"],
            "infra": itm["phy"],
            "test": (
                f"{itm['area']}-{itm['framesize']}-{itm['core']}-"
                f"{itm['test']}-{itm['testtype']}"
            )
        }

        if itm["testtype"] == "mrr" and itm["rls"] == "rls2310":
            trial_run = "trial"
            metadata["csit-ref"] = (
                f"{itm_data['job'].to_list()[0]}/",
                f"{itm_data['build'].to_list()[0]}"
            )
            customdata = [{"metadata": metadata}, ] * nr_of_samples
        else:
            trial_run = "run"
            for _, row in itm_data.iterrows():
                metadata["csit-ref"] = f"{row['job']}/{row['build']}"
                try:
                    metadata["hosts"] = ", ".join(row["hosts"])
                except (KeyError, TypeError):
                    pass
                customdata.append({"metadata": deepcopy(metadata)})
        tput_kwargs = dict(
            y=y_data,
            name=(
                f"{idx + 1}. "
                f"({nr_of_samples:02d} "
                f"{trial_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
        )
        tput_traces.append(go.Box(**tput_kwargs))

        if ttype in C.TESTS_WITH_BANDWIDTH:
            y_band, y_band_max = get_y_values(
                itm_data,
                y_band_max,
                C.VALUE_ITER[f"{ttype}-bandwidth"],
                norm_factor,
                remove_outliers=remove_outliers
            )
            if not all(pd.isna(y_band)):
                y_band_units.update(
                    itm_data[C.UNIT[f"{ttype}-bandwidth"]].unique().\
                        dropna().tolist()
                )
                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 in C.TESTS_WITH_LATENCY:
            y_lat, y_lat_max = get_y_values(
                itm_data,
                y_lat_max,
                C.VALUE_ITER["latency"],
                1 / norm_factor,
                remove_outliers=remove_outliers
            )
            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 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) * 1.1]
        fig_tput = go.Figure(data=tput_traces, layout=pl_tput)

    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) * 1.1]
        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) + 5]
        fig_lat = go.Figure(data=lat_traces, layout=pl_lat)

    return fig_tput, fig_band, fig_lat