-# Copyright (c) 2023 Cisco and/or its affiliates.
+# 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:
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
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[(
return df
-def graph_iterative(data: pd.DataFrame, sel:dict, layout: dict,
- normalize: bool) -> tuple:
+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 layout: Layout of plot.ly graph.
:param normalize: If True, the data is normalized to CPU frequency
Constants.NORM_FREQUENCY.
- :param data: pandas.DataFrame
- :param sel: dict
- :param layout: dict
- :param normalize: bool
+ :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()
- y_units = set()
- show_latency = False
- show_tput = False
+
+ band_traces = list()
+ y_band_max = 0
+ y_band_units = set()
+ x_band = list()
+
for idx, itm in enumerate(sel):
itm_data = select_iterative_data(data, itm)
y_units.update(itm_data[C.UNIT[ttype]].unique().tolist())
- if itm["testtype"] == "mrr":
- y_data_raw = itm_data[C.VALUE_ITER[ttype]].to_list()[0]
- else:
- y_data_raw = itm_data[C.VALUE_ITER[ttype]].to_list()
- y_data = [(y * norm_factor) for y in y_data_raw]
- if y_data:
- y_tput_max = max(max(y_data), y_tput_max)
+ y_data, y_tput_max = get_y_values(
+ itm_data,
+ y_tput_max,
+ C.VALUE_ITER[ttype],
+ norm_factor,
+ 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"run{'s' if nr_of_samples > 1 else ''}) "
+ 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))
+ marker=dict(color=get_color(idx)),
+ customdata=customdata
)
tput_traces.append(go.Box(**tput_kwargs))
- show_tput = True
- if ttype == "pdr":
- customdata = list()
- for _, row in itm_data.iterrows():
- customdata.append(
- get_hdrh_latencies(row, f"{row['job']}/{row['build']}")
+ 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))
- y_lat_row = itm_data[C.VALUE_ITER["latency"]].to_list()
- y_lat = [(y / norm_factor) for y in y_lat_row]
- if y_lat:
- try:
- y_lat_max = max(max(y_lat), y_lat_max)
- except TypeError:
- continue
- nr_of_samples = len(y_lat)
- lat_kwargs = dict(
- y=y_lat,
- name=(
- f"{idx + 1}. "
- f"({nr_of_samples:02d} "
- f"run{u's' if nr_of_samples > 1 else u''}) "
- f"{itm['id']}"
- ),
- hoverinfo="all",
- boxpoints="all",
- jitter=0.3,
- marker=dict(color=get_color(idx)),
- customdata=customdata
+ 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
)
- x_lat.append(idx + 1)
- lat_traces.append(go.Box(**lat_kwargs))
- show_latency = True
- else:
- lat_traces.append(go.Box())
+ if not all(pd.isna(y_lat)):
+ customdata = list()
+ for _, row in itm_data.iterrows():
+ hdrh = get_hdrh_latencies(
+ row,
+ f"{metadata['infra']}-{metadata['test']}"
+ )
+ metadata["csit-ref"] = f"{row['job']}/{row['build']}"
+ customdata.append({
+ "metadata": deepcopy(metadata),
+ "hdrh": hdrh
+ })
+ nr_of_samples = len(y_lat)
+ lat_kwargs = dict(
+ y=y_lat,
+ name=(
+ f"{idx + 1}. "
+ f"({nr_of_samples:02d} "
+ f"run{u's' if nr_of_samples > 1 else u''}) "
+ f"{itm['id']}"
+ ),
+ hoverinfo="all",
+ boxpoints="all",
+ jitter=0.3,
+ marker=dict(color=get_color(idx)),
+ customdata=customdata
+ )
+ x_lat.append(idx + 1)
+ lat_traces.append(go.Box(**lat_kwargs))
- if show_tput:
+ if tput_traces:
pl_tput = deepcopy(layout["plot-throughput"])
pl_tput["xaxis"]["tickvals"] = [i for i in range(len(sel))]
pl_tput["xaxis"]["ticktext"] = [str(i + 1) for i in range(len(sel))]
pl_tput["yaxis"]["title"] = f"Throughput [{'|'.join(sorted(y_units))}]"
if y_tput_max:
- pl_tput["yaxis"]["range"] = [0, (int(y_tput_max / 1e6) + 2) * 1e6]
+ pl_tput["yaxis"]["range"] = [0, int(y_tput_max) * 1.1]
fig_tput = go.Figure(data=tput_traces, layout=pl_tput)
- if show_latency:
+ if band_traces:
+ pl_band = deepcopy(layout["plot-bandwidth"])
+ pl_band["xaxis"]["tickvals"] = [i for i in range(len(x_band))]
+ pl_band["xaxis"]["ticktext"] = x_band
+ pl_band["yaxis"]["title"] = \
+ f"Bandwidth [{'|'.join(sorted(y_band_units))}]"
+ if y_band_max:
+ pl_band["yaxis"]["range"] = [0, int(y_band_max) * 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 / 10) + 1) * 10]
+ pl_lat["yaxis"]["range"] = [0, int(y_lat_max) + 5]
fig_lat = go.Figure(data=lat_traces, layout=pl_lat)
- return fig_tput, fig_lat
+ return fig_tput, fig_band, fig_lat
Code Review / csit.git / blobdiff