1 # Copyright (c) 2022 Cisco and/or its affiliates.
2 # Licensed under the Apache License, Version 2.0 (the "License");
3 # you may not use this file except in compliance with the License.
4 # You may obtain a copy of the License at:
6 # http://www.apache.org/licenses/LICENSE-2.0
8 # Unless required by applicable law or agreed to in writing, software
9 # distributed under the License is distributed on an "AS IS" BASIS,
10 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11 # See the License for the specific language governing permissions and
12 # limitations under the License.
18 import plotly.graph_objects as go
21 from copy import deepcopy
28 "mrr": "result_receive_rate_rate_values",
29 "ndr": "result_ndr_lower_rate_value",
30 "pdr": "result_pdr_lower_rate_value",
31 "pdr-lat": "result_latency_forward_pdr_50_avg"
34 "mrr": "result_receive_rate_rate_unit",
35 "ndr": "result_ndr_lower_rate_unit",
36 "pdr": "result_pdr_lower_rate_unit",
37 "pdr-lat": "result_latency_forward_pdr_50_unit"
39 _LAT_HDRH = ( # Do not change the order
40 "result_latency_forward_pdr_0_hdrh",
41 "result_latency_reverse_pdr_0_hdrh",
42 "result_latency_forward_pdr_10_hdrh",
43 "result_latency_reverse_pdr_10_hdrh",
44 "result_latency_forward_pdr_50_hdrh",
45 "result_latency_reverse_pdr_50_hdrh",
46 "result_latency_forward_pdr_90_hdrh",
47 "result_latency_reverse_pdr_90_hdrh",
49 # This value depends on latency stream rate (9001 pps) and duration (5s).
50 # Keep it slightly higher to ensure rounding errors to not remove tick mark.
51 PERCENTILE_MAX = 99.999501
53 _GRAPH_LAT_HDRH_DESC = {
54 u"result_latency_forward_pdr_0_hdrh": u"No-load.",
55 u"result_latency_reverse_pdr_0_hdrh": u"No-load.",
56 u"result_latency_forward_pdr_10_hdrh": u"Low-load, 10% PDR.",
57 u"result_latency_reverse_pdr_10_hdrh": u"Low-load, 10% PDR.",
58 u"result_latency_forward_pdr_50_hdrh": u"Mid-load, 50% PDR.",
59 u"result_latency_reverse_pdr_50_hdrh": u"Mid-load, 50% PDR.",
60 u"result_latency_forward_pdr_90_hdrh": u"High-load, 90% PDR.",
61 u"result_latency_reverse_pdr_90_hdrh": u"High-load, 90% PDR."
63 REG_EX_VPP_VERSION = re.compile(r"^(\d{2}).(\d{2})-(rc0|rc1|rc2|release$)")
66 def _get_color(idx: int) -> str:
70 "#1A1110", "#DA2647", "#214FC6", "#01786F", "#BD8260", "#FFD12A",
71 "#A6E7FF", "#738276", "#C95A49", "#FC5A8D", "#CEC8EF", "#391285",
72 "#6F2DA8", "#FF878D", "#45A27D", "#FFD0B9", "#FD5240", "#DB91EF",
73 "#44D7A8", "#4F86F7", "#84DE02", "#FFCFF1", "#614051"
75 return _COLORS[idx % len(_COLORS)]
78 def get_short_version(version: str, dut_type: str="vpp") -> str:
82 if dut_type in ("trex", "dpdk"):
86 groups = re.search(pattern=REG_EX_VPP_VERSION, string=version)
89 s_version = f"{groups.group(1)}.{groups.group(2)}_{groups.group(3)}"
96 def select_iterative_data(data: pd.DataFrame, itm:dict) -> pd.DataFrame:
100 phy = itm["phy"].split("-")
102 topo, arch, nic, drv = phy
107 drv = drv.replace("_", "-")
111 core = str() if itm["dut"] == "trex" else f"{itm['core']}"
112 ttype = "ndrpdr" if itm["testtype"] in ("ndr", "pdr") else itm["testtype"]
113 dut_v100 = "none" if itm["dut"] == "trex" else itm["dut"]
114 dut_v101 = itm["dut"]
117 (data["release"] == itm["rls"]) &
120 (data["version"] == "1.0.0") &
121 (data["dut_type"].str.lower() == dut_v100)
124 (data["version"] == "1.0.1") &
125 (data["dut_type"].str.lower() == dut_v101)
128 (data["test_type"] == ttype) &
129 (data["passed"] == True)
132 f"^.*[.|-]{nic}.*{itm['framesize']}-{core}-{drv}{itm['test']}-{ttype}$"
134 (df.job.str.endswith(f"{topo}-{arch}")) &
135 (df.dut_version.str.contains(itm["dutver"].replace("_", "-"))) &
136 (df.test_id.str.contains(regex_test, regex=True))
142 def graph_iterative(data: pd.DataFrame, sel:dict, layout: dict) -> tuple:
154 for idx, itm in enumerate(sel):
155 itm_data = select_iterative_data(data, itm)
156 if itm["testtype"] == "mrr":
157 y_data = itm_data[_VALUE[itm["testtype"]]].to_list()[0]
160 max(y_data) if max(y_data) > y_tput_max else y_tput_max
162 y_data = itm_data[_VALUE[itm["testtype"]]].to_list()
165 max(y_data) if max(y_data) > y_tput_max else y_tput_max
166 nr_of_samples = len(y_data)
171 f"({nr_of_samples:02d} "
172 f"run{u's' if nr_of_samples > 1 else u''}) "
178 marker=dict(color=_get_color(idx))
180 tput_traces.append(go.Box(**tput_kwargs))
183 if itm["testtype"] == "pdr":
184 y_lat = itm_data[_VALUE["pdr-lat"]].to_list()
186 y_lat_max = max(y_lat) if max(y_lat) > y_lat_max else y_lat_max
187 nr_of_samples = len(y_lat)
192 f"({nr_of_samples:02d} "
193 f"run{u's' if nr_of_samples > 1 else u''}) "
199 marker=dict(color=_get_color(idx))
201 x_lat.append(idx + 1)
202 lat_traces.append(go.Box(**lat_kwargs))
205 lat_traces.append(go.Box())
207 pl_tput = deepcopy(layout["plot-throughput"])
208 pl_tput[u"xaxis"][u"tickvals"] = [i for i in range(len(sel))]
209 pl_tput[u"xaxis"][u"ticktext"] = [str(i + 1) for i in range(len(sel))]
211 pl_tput[u"yaxis"][u"range"] = [0, (int(y_tput_max / 1e6) + 1) * 1e6]
212 fig_tput = go.Figure(data=tput_traces, layout=pl_tput)
215 pl_lat = deepcopy(layout["plot-latency"])
216 pl_lat[u"xaxis"][u"tickvals"] = [i for i in range(len(x_lat))]
217 pl_lat[u"xaxis"][u"ticktext"] = x_lat
219 pl_lat[u"yaxis"][u"range"] = [0, (int(y_lat_max / 10) + 1) * 10]
220 fig_lat = go.Figure(data=lat_traces, layout=pl_lat)
222 return fig_tput, fig_lat
225 def table_comparison(data: pd.DataFrame, sel:dict) -> pd.DataFrame:
228 table = pd.DataFrame(
231 "64b-2t1c-avf-eth-l2xcbase-eth-2memif-1dcr",
232 "64b-2t1c-avf-eth-l2xcbase-eth-2vhostvr1024-1vm-vppl2xc",
233 "64b-2t1c-avf-ethip4udp-ip4base-iacl50sl-10kflows",
234 "78b-2t1c-avf-ethip6-ip6scale2m-rnd "],
255 "2110.0-9 vs 2110.0-8": [
260 "2202.0-9 vs 2110.0-9": [
268 return pd.DataFrame() #table
271 def graph_hdrh_latency(data: dict, layout: dict) -> go.Figure:
278 for idx, (lat_name, lat_hdrh) in enumerate(data.items()):
280 decoded = hdrh.histogram.HdrHistogram.decode(lat_hdrh)
281 except (hdrh.codec.HdrLengthException, TypeError) as err:
288 for item in decoded.get_recorded_iterator():
289 # The real value is "percentile".
290 # For 100%, we cut that down to "x_perc" to avoid
292 percentile = item.percentile_level_iterated_to
293 x_perc = min(percentile, PERCENTILE_MAX)
294 xaxis.append(previous_x)
295 yaxis.append(item.value_iterated_to)
297 f"<b>{_GRAPH_LAT_HDRH_DESC[lat_name]}</b><br>"
298 f"Direction: {(u'W-E', u'E-W')[idx % 2]}<br>"
299 f"Percentile: {prev_perc:.5f}-{percentile:.5f}%<br>"
300 f"Latency: {item.value_iterated_to}uSec"
302 next_x = 100.0 / (100.0 - x_perc)
304 yaxis.append(item.value_iterated_to)
306 f"<b>{_GRAPH_LAT_HDRH_DESC[lat_name]}</b><br>"
307 f"Direction: {(u'W-E', u'E-W')[idx % 2]}<br>"
308 f"Percentile: {prev_perc:.5f}-{percentile:.5f}%<br>"
309 f"Latency: {item.value_iterated_to}uSec"
312 prev_perc = percentile
318 name=_GRAPH_LAT_HDRH_DESC[lat_name],
320 legendgroup=_GRAPH_LAT_HDRH_DESC[lat_name],
321 showlegend=bool(idx % 2),
323 color=_get_color(int(idx/2)),
325 width=1 if idx % 2 else 2
333 fig.add_traces(traces)
334 layout_hdrh = layout.get("plot-hdrh-latency", None)
336 fig.update_layout(layout_hdrh)