- dut_version
- hosts
- tg_type
- # - tg_version
- result_bandwidth_unit
- result_bandwidth_value
- result_rate_unit
- result_rate_value
- result_latency_unit
- result_latency_value
- # - result_failed_requests_unit
- # - result_failed_requests_value
- # - result_completed_requests_unit
- # - result_completed_requests_value
- # - result_retransmits_unit
- # - result_retransmits_value
- # - result_duration_unit
- # - result_duration_value
- # - result_type
- start_time
- passed
- telemetry
- dut_version
- hosts
- tg_type
- # - tg_version
- result_bandwidth_unit
- result_bandwidth_value
- result_rate_unit
- result_rate_value
- - result_latency_unit
- - result_latency_value
- # - result_failed_requests_unit
- # - result_failed_requests_value
- # - result_completed_requests_unit
- # - result_completed_requests_value
- # - result_retransmits_unit
- # - result_retransmits_value
- # - result_duration_unit
- # - result_duration_value
+ # - result_latency_unit
+ # - result_latency_value
- start_time
- passed
- telemetry
lat_traces = list()
y_lat_max = 0
x_lat = list()
+ y_units = set()
show_latency = False
show_tput = False
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())
+
if itm["testtype"] == "mrr":
- y_data_raw = itm_data[C.VALUE_ITER[itm["testtype"]]].to_list()[0]
+ y_data_raw = itm_data[C.VALUE_ITER[ttype]].to_list()[0]
y_data = [(y * norm_factor) for y in y_data_raw]
if len(y_data) > 0:
y_tput_max = \
max(y_data) if max(y_data) > y_tput_max else y_tput_max
else:
- y_data_raw = itm_data[C.VALUE_ITER[itm["testtype"]]].to_list()
+ 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(y_data) if max(y_data) > y_tput_max else y_tput_max
+
nr_of_samples = len(y_data)
tput_kwargs = dict(
y=y_data,
tput_traces.append(go.Box(**tput_kwargs))
show_tput = True
- if itm["testtype"] == "pdr":
+ if ttype == "pdr":
y_lat_row = itm_data[C.VALUE_ITER["pdr-lat"]].to_list()
y_lat = [(y / norm_factor) for y in y_lat_row]
if y_lat:
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) + 1) * 1e6]
+ pl_tput["yaxis"]["range"] = [0, (int(y_tput_max / 1e6) + 2) * 1e6]
fig_tput = go.Figure(data=tput_traces, layout=pl_tput)
if show_latency:
df = df.dropna(subset=[C.VALUE[ttype], ])
if df.empty:
- return list()
+ return list(), list()
x_axis = df["start_time"].tolist()
if ttype == "pdr-lat":
y_data = [(v / norm_factor) for v in df[C.VALUE[ttype]].tolist()]
else:
y_data = [(v * norm_factor) for v in df[C.VALUE[ttype]].tolist()]
+ units = df[C.UNIT[ttype]].unique().tolist()
anomalies, trend_avg, trend_stdev = classify_anomalies(
{k: v for k, v in zip(x_axis, y_data)}
f"date: {row['start_time'].strftime('%Y-%m-%d %H:%M:%S')}<br>"
f"<prop> [{row[C.UNIT[ttype]]}]: {y_data[idx]:,.0f}<br>"
f"<stdev>"
+ f"<additional-info>"
f"{d_type}-ref: {row['dut_version']}<br>"
f"csit-ref: {row['job']}/{row['build']}<br>"
f"hosts: {', '.join(row['hosts'])}"
f"{row['result_receive_rate_rate_stdev']:,.0f}<br>"
)
else:
- stdev = ""
+ stdev = str()
+ if ttype in ("hoststack-cps", "hoststack-rps"):
+ add_info = (
+ f"bandwidth [{row[C.UNIT['hoststack-bps']]}]: "
+ f"{row[C.VALUE['hoststack-bps']]:,.0f}<br>"
+ f"latency [{row[C.UNIT['hoststack-lat']]}]: "
+ f"{row[C.VALUE['hoststack-lat']]:,.0f}<br>"
+ )
+ else:
+ add_info = str()
hover_itm = hover_itm.replace(
"<prop>", "latency" if ttype == "pdr-lat" else "average"
- ).replace("<stdev>", stdev)
+ ).replace("<stdev>", stdev).replace("<additional-info>", add_info)
hover.append(hover_itm)
if ttype == "pdr-lat":
customdata_samples.append(_get_hdrh_latencies(row, name))
d_type = "trex" if row["dut_type"] == "none" else row["dut_type"]
hover_itm = (
f"date: {row['start_time'].strftime('%Y-%m-%d %H:%M:%S')}<br>"
- f"trend [pps]: {avg:,.0f}<br>"
- f"stdev [pps]: {stdev:,.0f}<br>"
+ f"trend [{row[C.UNIT[ttype]]}]: {avg:,.0f}<br>"
+ f"stdev [{row[C.UNIT[ttype]]}]: {stdev:,.0f}<br>"
f"{d_type}-ref: {row['dut_version']}<br>"
f"csit-ref: {row['job']}/{row['build']}<br>"
f"hosts: {', '.join(row['hosts'])}"
)
)
- return traces
+ return traces, units
fig_tput = None
fig_lat = None
+ y_units = set()
for idx, itm in enumerate(sel):
df = select_trending_data(data, itm)
if df is None or df.empty:
if topo_arch else 1.0
else:
norm_factor = 1.0
- traces = _generate_trending_traces(itm["testtype"], itm["id"], df,
- get_color(idx), norm_factor)
+
+ if itm["area"] == "hoststack":
+ ttype = f"hoststack-{itm['testtype']}"
+ else:
+ ttype = itm["testtype"]
+
+ traces, units = _generate_trending_traces(
+ ttype,
+ itm["id"],
+ df,
+ get_color(idx),
+ norm_factor
+ )
if traces:
if not fig_tput:
fig_tput = go.Figure()
fig_tput.add_traces(traces)
if itm["testtype"] == "pdr":
- traces = _generate_trending_traces("pdr-lat", itm["id"], df,
- get_color(idx), norm_factor)
+ traces, _ = _generate_trending_traces(
+ "pdr-lat",
+ itm["id"],
+ df,
+ get_color(idx),
+ norm_factor
+ )
if traces:
if not fig_lat:
fig_lat = go.Figure()
fig_lat.add_traces(traces)
+ y_units.update(units)
+
if fig_tput:
- fig_tput.update_layout(layout.get("plot-trending-tput", dict()))
+ fig_layout = layout.get("plot-trending-tput", dict())
+ fig_layout["yaxis"]["title"] = \
+ f"Throughput [{'|'.join(sorted(y_units))}]"
+ fig_tput.update_layout(fig_layout)
if fig_lat:
fig_lat.update_layout(layout.get("plot-trending-lat", dict()))
"ndr": "result_ndr_lower_rate_value",
"pdr": "result_pdr_lower_rate_value",
"pdr-lat": "result_latency_forward_pdr_50_avg",
- "cps": "result_bandwidth_value",
- "rps": "result_bandwidth_value",
- "bps": "result_bandwidth_value"
+ "hoststack-cps": "result_rate_value",
+ "hoststack-rps": "result_rate_value",
+ "hoststack-bps": "result_bandwidth_value",
+ "hoststack-lat": "result_latency_value"
}
VALUE_ITER = {
"ndr": "result_ndr_lower_rate_value",
"pdr": "result_pdr_lower_rate_value",
"pdr-lat": "result_latency_forward_pdr_50_avg",
- "cps": "result_bandwidth_value",
- "rps": "result_bandwidth_value",
- "bps": "result_bandwidth_value"
+ "hoststack-cps": "result_rate_value",
+ "hoststack-rps": "result_rate_value",
+ "hoststack-bps": "result_bandwidth_value",
+ "hoststack-lat": "result_latency_value"
}
UNIT = {
"ndr": "result_ndr_lower_rate_unit",
"pdr": "result_pdr_lower_rate_unit",
"pdr-lat": "result_latency_forward_pdr_50_unit",
- "cps": "result_bandwidth_unit",
- "rps": "result_bandwidth_unit",
- "bps": "result_bandwidth_unit"
+ "hoststack-cps": "result_rate_unit",
+ "hoststack-rps": "result_rate_unit",
+ "hoststack-bps": "result_bandwidth_unit",
+ "hoststack-lat": "result_latency_unit"
}
# Latencies.
Code Review / csit.git / commitdiff