colramos-amd
388 строки
13 KiB
Python
388 строки
13 KiB
Python
##############################################################################bl
|
|
# MIT License
|
|
#
|
|
# Copyright (c) 2021 - 2024 Advanced Micro Devices, Inc. All Rights Reserved.
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
# of this software and associated documentation files (the "Software"), to deal
|
|
# in the Software without restriction, including without limitation the rights
|
|
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
# copies of the Software, and to permit persons to whom the Software is
|
|
# furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included in all
|
|
# copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
# SOFTWARE.
|
|
##############################################################################el
|
|
|
|
import sys
|
|
import pandas as pd
|
|
from dash import html, dash_table
|
|
import plotly.express as px
|
|
import colorlover
|
|
|
|
from utils import schema
|
|
from utils.utils import console_error
|
|
|
|
pd.set_option(
|
|
"mode.chained_assignment", None
|
|
) # ignore SettingWithCopyWarning pandas warning
|
|
|
|
IS_DARK = True # TODO: Remove hardcoded in favor of class property
|
|
|
|
|
|
##################
|
|
# HELPER FUNCTIONS
|
|
##################
|
|
def filter_df(column, df, filt):
|
|
filt_df = df
|
|
if filt != []:
|
|
filt_df = df.loc[df[schema.pmc_perf_file_prefix][column].astype(str).isin(filt)]
|
|
return filt_df
|
|
|
|
|
|
def multi_bar_chart(table_id, display_df):
|
|
if table_id == 1604:
|
|
nested_bar = {"NC": {}, "UC": {}, "RW": {}, "CC": {}}
|
|
for index, row in display_df.iterrows():
|
|
nested_bar[row["Coherency"]][row["Xfer"]] = row["Avg"]
|
|
if table_id == 1704:
|
|
nested_bar = {"Read": {}, "Write": {}}
|
|
for index, row in display_df.iterrows():
|
|
nested_bar[row["Transaction"]][row["Type"]] = row["Avg"]
|
|
|
|
return nested_bar
|
|
|
|
|
|
def discrete_background_color_bins(df, n_bins=5, columns="all"):
|
|
bounds = [i * (1.0 / n_bins) for i in range(n_bins + 1)]
|
|
if columns == "all":
|
|
if "id" in df:
|
|
df_numeric_columns = df.select_dtypes("number").drop(["id"], axis=1)
|
|
else:
|
|
df_numeric_columns = df.select_dtypes("number")
|
|
else:
|
|
df_numeric_columns = df[columns]
|
|
df_max = df_numeric_columns.max().max()
|
|
df_min = df_numeric_columns.min().min()
|
|
ranges = [((df_max - df_min) * i) + df_min for i in bounds]
|
|
styles = []
|
|
legend = []
|
|
for i in range(1, len(bounds)):
|
|
min_bound = ranges[i - 1]
|
|
max_bound = ranges[i]
|
|
backgroundColor = colorlover.scales[str(n_bins)]["seq"]["Blues"][i - 1]
|
|
color = "white" if i > len(bounds) / 2.0 else "inherit"
|
|
|
|
for column in df_numeric_columns:
|
|
styles.append(
|
|
{
|
|
"if": {
|
|
"filter_query": (
|
|
"{{{column}}} >= {min_bound}"
|
|
+ (
|
|
" && {{{column}}} < {max_bound}"
|
|
if (i < len(bounds) - 1)
|
|
else ""
|
|
)
|
|
).format(column=column, min_bound=min_bound, max_bound=max_bound),
|
|
"column_id": column,
|
|
},
|
|
"backgroundColor": backgroundColor,
|
|
"color": color,
|
|
}
|
|
)
|
|
legend.append(
|
|
html.Div(
|
|
style={"display": "inline-block", "width": "60px"},
|
|
children=[
|
|
html.Div(
|
|
style={
|
|
"backgroundColor": backgroundColor,
|
|
"borderLeft": "1px rgb(50, 50, 50) solid",
|
|
"height": "10px",
|
|
}
|
|
),
|
|
html.Small(round(min_bound, 2), style={"paddingLeft": "2px"}),
|
|
],
|
|
)
|
|
)
|
|
|
|
return (styles, html.Div(legend, style={"padding": "5px 0 5px 0"}))
|
|
|
|
|
|
####################
|
|
# GRAPHICAL ELEMENTS
|
|
####################
|
|
def build_bar_chart(display_df, table_config, barchart_elements, norm_filt):
|
|
"""
|
|
Read data into a bar chart. ID will determine which subtype of barchart.
|
|
"""
|
|
d_figs = []
|
|
|
|
# Insr Mix bar chart
|
|
if table_config["id"] in barchart_elements["instr_mix"]:
|
|
display_df["Avg"] = [
|
|
x.astype(int) if x != "" else int(0) for x in display_df["Avg"]
|
|
]
|
|
df_unit = display_df["Unit"][0]
|
|
d_figs.append(
|
|
px.bar(
|
|
display_df,
|
|
x="Avg",
|
|
y="Metric",
|
|
color="Avg",
|
|
labels={"Avg": "# of {}".format(df_unit.lower())},
|
|
height=400,
|
|
orientation="h",
|
|
)
|
|
)
|
|
|
|
# Multi bar chart
|
|
elif table_config["id"] in barchart_elements["multi_bar"]:
|
|
display_df["Avg"] = [
|
|
x.astype(int) if x != "" else int(0) for x in display_df["Avg"]
|
|
]
|
|
df_unit = display_df["Unit"][0]
|
|
nested_bar = multi_bar_chart(table_config["id"], display_df)
|
|
# generate chart for each coherency
|
|
for group, metric in nested_bar.items():
|
|
d_figs.append(
|
|
px.bar(
|
|
title=group,
|
|
x=metric.values(),
|
|
y=metric.keys(),
|
|
labels={"x": df_unit, "y": ""},
|
|
text=metric.values(),
|
|
orientation="h",
|
|
height=200,
|
|
)
|
|
.update_xaxes(showgrid=False, rangemode="nonnegative")
|
|
.update_yaxes(showgrid=False)
|
|
.update_layout(title_x=0.5)
|
|
)
|
|
# L2 Cache per channel
|
|
# elif table_config["id"] in barchart_elements["l2_cache_per_chan"]:
|
|
# nested_bar = {}
|
|
# channels = []
|
|
# for colName, colData in display_df.items():
|
|
# if colName == "Channel":
|
|
# channels = list(colData.values)
|
|
# else:
|
|
# display_df[colName] = [
|
|
# x.astype(float) if x != "" and x != None else float(0)
|
|
# for x in display_df[colName]
|
|
# ]
|
|
# nested_bar[colName] = list(display_df[colName])
|
|
# for group, metric in nested_bar.items():
|
|
# d_figs.append(
|
|
# px.bar(
|
|
# title=group[0 : group.rfind("(")],
|
|
# x=channels,
|
|
# y=metric,
|
|
# labels={
|
|
# "x": "Channel",
|
|
# "y": group[group.rfind("(") + 1 : len(group) - 1].replace(
|
|
# "per", norm_filt
|
|
# ),
|
|
# },
|
|
# ).update_yaxes(rangemode="nonnegative")
|
|
# )
|
|
|
|
# Speed-of-light bar chart
|
|
elif table_config["id"] in barchart_elements["sol"]:
|
|
display_df["Avg"] = [
|
|
x.astype(float) if x != "" else float(0) for x in display_df["Avg"]
|
|
]
|
|
if table_config["id"] == 1701:
|
|
# special layout for L2 Cache SOL
|
|
d_figs.append(
|
|
px.bar(
|
|
display_df[display_df["Unit"] == "Pct"],
|
|
x="Avg",
|
|
y="Metric",
|
|
color="Avg",
|
|
range_color=[0, 100],
|
|
labels={"Avg": "%"},
|
|
height=220,
|
|
orientation="h",
|
|
).update_xaxes(range=[0, 110], ticks="inside", title="%")
|
|
) # append first % chart
|
|
d_figs.append(
|
|
px.bar(
|
|
display_df[display_df["Unit"] == "Gb/s"],
|
|
x="Avg",
|
|
y="Metric",
|
|
color="Avg",
|
|
range_color=[0, 1638],
|
|
labels={"Avg": "GB/s"},
|
|
height=220,
|
|
orientation="h",
|
|
).update_xaxes(range=[0, 1638])
|
|
) # append second GB/s chart
|
|
else:
|
|
key = "Avg"
|
|
if table_config["id"] in [1101]:
|
|
key = "Pct of Peak"
|
|
d_figs.append(
|
|
px.bar(
|
|
display_df,
|
|
x=key,
|
|
y="Metric",
|
|
color="Avg",
|
|
range_color=[0, 100],
|
|
labels={"Avg": "%"},
|
|
height=400,
|
|
orientation="h",
|
|
).update_xaxes(range=[0, 110])
|
|
)
|
|
else:
|
|
console_error("Table id %s. Cannot determine barchart type." % table_config["id"])
|
|
|
|
# update layout for each of the charts
|
|
for fig in d_figs:
|
|
fig.update_layout(
|
|
margin=dict(l=50, r=50, b=50, t=50, pad=4),
|
|
paper_bgcolor="rgba(0,0,0,0)",
|
|
plot_bgcolor="rgba(0,0,0,0)",
|
|
font={"color": "#ffffff"},
|
|
)
|
|
return d_figs
|
|
|
|
|
|
def build_table_chart(
|
|
display_df, table_config, original_df, display_columns, comparable_columns, decimal
|
|
):
|
|
"""
|
|
Read data into a DashTable
|
|
"""
|
|
d_figs = []
|
|
# build comlumns/header with formatting
|
|
formatted_columns = []
|
|
for col in display_df.columns:
|
|
if (
|
|
str(col).lower() == "pct"
|
|
or str(col).lower() == "pop"
|
|
or str(col).lower() == "percentage"
|
|
):
|
|
formatted_columns.append(
|
|
dict(
|
|
id=col,
|
|
name=col,
|
|
type="numeric",
|
|
format={"specifier": ".{}f".format(decimal)},
|
|
)
|
|
)
|
|
elif col in comparable_columns:
|
|
formatted_columns.append(
|
|
dict(
|
|
id=col,
|
|
name=col,
|
|
type="numeric",
|
|
format={"specifier": ".{}f".format(decimal)},
|
|
)
|
|
)
|
|
else:
|
|
formatted_columns.append(dict(id=col, name=col, type="text"))
|
|
|
|
# tooltip shows only on the 1st col for now if 'Tips' available
|
|
table_tooltip = (
|
|
[
|
|
{
|
|
column: {
|
|
"value": (
|
|
str(row["Tips"])
|
|
if column == display_columns[0] and row["Tips"]
|
|
else ""
|
|
),
|
|
"type": "markdown",
|
|
}
|
|
for column, value in row.items()
|
|
}
|
|
for row in original_df.to_dict("records")
|
|
]
|
|
if "Tips" in original_df.columns.values.tolist()
|
|
else None
|
|
)
|
|
|
|
# build data table with columns, tooltip, df and other properties
|
|
d_t = dash_table.DataTable(
|
|
id=str(table_config["id"]),
|
|
sort_action="native",
|
|
sort_mode="multi",
|
|
columns=formatted_columns,
|
|
tooltip_data=table_tooltip,
|
|
# left-aligning the text of the 1st col
|
|
style_cell_conditional=[
|
|
{"if": {"column_id": display_columns[0]}, "textAlign": "left"}
|
|
],
|
|
# style cell
|
|
style_cell={"maxWidth": "500px"},
|
|
# display style
|
|
style_header=(
|
|
{
|
|
"backgroundColor": "rgb(30, 30, 30)",
|
|
"color": "white",
|
|
"fontWeight": "bold",
|
|
}
|
|
if IS_DARK
|
|
else {}
|
|
),
|
|
style_data=(
|
|
{
|
|
"backgroundColor": "rgb(50, 50, 50)",
|
|
"color": "white",
|
|
"whiteSpace": "normal",
|
|
"height": "auto",
|
|
}
|
|
if IS_DARK
|
|
else {}
|
|
),
|
|
style_data_conditional=(
|
|
[
|
|
{"if": {"row_index": "odd"}, "backgroundColor": "rgb(60, 60, 60)"},
|
|
{
|
|
"if": {"column_id": "PoP", "filter_query": "{PoP} > 50"},
|
|
"backgroundColor": "#ffa90a",
|
|
"color": "white",
|
|
},
|
|
{
|
|
"if": {"column_id": "PoP", "filter_query": "{PoP} > 80"},
|
|
"backgroundColor": "#ff120a",
|
|
"color": "white",
|
|
},
|
|
{
|
|
"if": {
|
|
"column_id": "Avg",
|
|
"filter_query": "{Unit} = Pct && {Avg} > 50",
|
|
},
|
|
"backgroundColor": "#ffa90a",
|
|
"color": "white",
|
|
},
|
|
{
|
|
"if": {
|
|
"column_id": "Avg",
|
|
"filter_query": "{Unit} = Pct && {Avg} > 80",
|
|
},
|
|
"backgroundColor": "#ff120a",
|
|
"color": "white",
|
|
},
|
|
]
|
|
if IS_DARK
|
|
else []
|
|
),
|
|
# the df to display
|
|
data=display_df.to_dict("records"),
|
|
)
|
|
# print("DATA: \n", display_df.to_dict('records'))
|
|
d_figs.append(d_t)
|
|
return d_figs
|
|
# print(d_t.columns)
|