589 lines
20 KiB
Python
Executable File
589 lines
20 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import argparse
|
|
import sys
|
|
import os
|
|
from json import loads
|
|
from subprocess import Popen, PIPE
|
|
|
|
# Holds code regions statistics.
|
|
class Summary:
|
|
def __init__(
|
|
self,
|
|
name,
|
|
block_rthroughput,
|
|
dispatch_width,
|
|
ipc,
|
|
instructions,
|
|
iterations,
|
|
total_cycles,
|
|
total_uops,
|
|
uops_per_cycle,
|
|
iteration_resource_pressure,
|
|
name_target_info_resources,
|
|
):
|
|
self.name = name
|
|
self.block_rthroughput = block_rthroughput
|
|
self.dispatch_width = dispatch_width
|
|
self.ipc = ipc
|
|
self.instructions = instructions
|
|
self.iterations = iterations
|
|
self.total_cycles = total_cycles
|
|
self.total_uops = total_uops
|
|
self.uops_per_cycle = uops_per_cycle
|
|
self.iteration_resource_pressure = iteration_resource_pressure
|
|
self.name_target_info_resources = name_target_info_resources
|
|
|
|
|
|
# Parse the program arguments.
|
|
def parse_program_args(parser):
|
|
parser.add_argument(
|
|
"file_names",
|
|
nargs="+",
|
|
type=str,
|
|
help="Names of files which llvm-mca tool process.",
|
|
)
|
|
parser.add_argument(
|
|
"--llvm-mca-binary",
|
|
nargs=1,
|
|
required=True,
|
|
type=str,
|
|
action="store",
|
|
metavar="[=<path to llvm-mca>]",
|
|
help="Specified relative path to binary of llvm-mca.",
|
|
)
|
|
parser.add_argument(
|
|
"--args",
|
|
nargs=1,
|
|
type=str,
|
|
action="store",
|
|
metavar="[='-option1=<arg> -option2=<arg> ...']",
|
|
default=["-"],
|
|
help="Forward options to lvm-mca tool.",
|
|
)
|
|
parser.add_argument(
|
|
"-plot",
|
|
action="store_true",
|
|
default=False,
|
|
help="Draw plots of statistics for input files.",
|
|
)
|
|
parser.add_argument(
|
|
"-plot-resource-pressure",
|
|
action="store_true",
|
|
default=False,
|
|
help="Draw plots of resource pressure per iterations for input files.",
|
|
)
|
|
parser.add_argument(
|
|
"--plot-path",
|
|
nargs=1,
|
|
type=str,
|
|
action="store",
|
|
metavar="[=<path>]",
|
|
default=["-"],
|
|
help="Specify relative path where you want to save the plots.",
|
|
)
|
|
parser.add_argument(
|
|
"-v",
|
|
action="store_true",
|
|
default=False,
|
|
help="More details about the running lvm-mca tool.",
|
|
)
|
|
return parser.parse_args()
|
|
|
|
|
|
# Verify that the program inputs meet the requirements.
|
|
def verify_program_inputs(opts):
|
|
if opts.plot_path[0] != "-" and not opts.plot and not opts.plot_resource_pressure:
|
|
print(
|
|
"error: Please specify --plot-path only with the -plot or -plot-resource-pressure options."
|
|
)
|
|
return False
|
|
|
|
return True
|
|
|
|
|
|
# Returns the name of the file to be analyzed from the path it is on.
|
|
def get_filename_from_path(path):
|
|
index_of_slash = path.rfind("/")
|
|
return path[(index_of_slash + 1) : len(path)]
|
|
|
|
|
|
# Returns the results of the running llvm-mca tool for the input file.
|
|
def run_llvm_mca_tool(opts, file_name):
|
|
# Get the path of the llvm-mca binary file.
|
|
llvm_mca_cmd = opts.llvm_mca_binary[0]
|
|
|
|
# The statistics llvm-mca options.
|
|
if opts.args[0] != "-":
|
|
llvm_mca_cmd += " " + opts.args[0]
|
|
llvm_mca_cmd += " -json"
|
|
|
|
# Set file which llvm-mca tool will process.
|
|
llvm_mca_cmd += " " + file_name
|
|
|
|
if opts.v:
|
|
print("run: $ " + llvm_mca_cmd + "\n")
|
|
|
|
# Generate the stats with the llvm-mca.
|
|
subproc = Popen(
|
|
llvm_mca_cmd.split(" "),
|
|
stdin=PIPE,
|
|
stdout=PIPE,
|
|
stderr=PIPE,
|
|
universal_newlines=True,
|
|
)
|
|
|
|
cmd_stdout, cmd_stderr = subproc.communicate()
|
|
|
|
try:
|
|
json_parsed = loads(cmd_stdout)
|
|
except:
|
|
print("error: No valid llvm-mca statistics found.")
|
|
print(cmd_stderr)
|
|
sys.exit(1)
|
|
|
|
if opts.v:
|
|
print("Simulation Parameters: ")
|
|
simulation_parameters = json_parsed["SimulationParameters"]
|
|
for key in simulation_parameters:
|
|
print(key, ":", simulation_parameters[key])
|
|
print("\n")
|
|
|
|
code_regions_len = len(json_parsed["CodeRegions"])
|
|
array_of_code_regions = [None] * code_regions_len
|
|
|
|
for i in range(code_regions_len):
|
|
code_region_instructions_len = len(
|
|
json_parsed["CodeRegions"][i]["Instructions"]
|
|
)
|
|
target_info_resources_len = len(json_parsed["TargetInfo"]["Resources"])
|
|
iteration_resource_pressure = ["-" for k in range(target_info_resources_len)]
|
|
resource_pressure_info = json_parsed["CodeRegions"][i]["ResourcePressureView"][
|
|
"ResourcePressureInfo"
|
|
]
|
|
|
|
name_target_info_resources = json_parsed["TargetInfo"]["Resources"]
|
|
|
|
for s in range(len(resource_pressure_info)):
|
|
obj_of_resource_pressure_info = resource_pressure_info[s]
|
|
if (
|
|
obj_of_resource_pressure_info["InstructionIndex"]
|
|
== code_region_instructions_len
|
|
):
|
|
iteration_resource_pressure[
|
|
obj_of_resource_pressure_info["ResourceIndex"]
|
|
] = str(round(obj_of_resource_pressure_info["ResourceUsage"], 2))
|
|
|
|
array_of_code_regions[i] = Summary(
|
|
file_name,
|
|
json_parsed["CodeRegions"][i]["SummaryView"]["BlockRThroughput"],
|
|
json_parsed["CodeRegions"][i]["SummaryView"]["DispatchWidth"],
|
|
json_parsed["CodeRegions"][i]["SummaryView"]["IPC"],
|
|
json_parsed["CodeRegions"][i]["SummaryView"]["Instructions"],
|
|
json_parsed["CodeRegions"][i]["SummaryView"]["Iterations"],
|
|
json_parsed["CodeRegions"][i]["SummaryView"]["TotalCycles"],
|
|
json_parsed["CodeRegions"][i]["SummaryView"]["TotaluOps"],
|
|
json_parsed["CodeRegions"][i]["SummaryView"]["uOpsPerCycle"],
|
|
iteration_resource_pressure,
|
|
name_target_info_resources,
|
|
)
|
|
|
|
return array_of_code_regions
|
|
|
|
|
|
# Print statistics in console for single file or for multiple files.
|
|
def console_print_results(matrix_of_code_regions, opts):
|
|
try:
|
|
import termtables as tt
|
|
except ImportError:
|
|
print("error: termtables not found.")
|
|
sys.exit(1)
|
|
|
|
headers_names = [None] * (len(opts.file_names) + 1)
|
|
headers_names[0] = " "
|
|
|
|
max_code_regions = 0
|
|
|
|
print("Input files:")
|
|
for i in range(len(matrix_of_code_regions)):
|
|
if max_code_regions < len(matrix_of_code_regions[i]):
|
|
max_code_regions = len(matrix_of_code_regions[i])
|
|
print("[f" + str(i + 1) + "]: " + get_filename_from_path(opts.file_names[i]))
|
|
headers_names[i + 1] = "[f" + str(i + 1) + "]: "
|
|
|
|
print("\nITERATIONS: " + str(matrix_of_code_regions[0][0].iterations) + "\n")
|
|
|
|
for i in range(max_code_regions):
|
|
|
|
print(
|
|
"\n-----------------------------------------\nCode region: "
|
|
+ str(i + 1)
|
|
+ "\n"
|
|
)
|
|
|
|
table_values = [
|
|
[[None] for i in range(len(matrix_of_code_regions) + 1)] for j in range(7)
|
|
]
|
|
|
|
table_values[0][0] = "Instructions: "
|
|
table_values[1][0] = "Total Cycles: "
|
|
table_values[2][0] = "Total uOps: "
|
|
table_values[3][0] = "Dispatch Width: "
|
|
table_values[4][0] = "uOps Per Cycle: "
|
|
table_values[5][0] = "IPC: "
|
|
table_values[6][0] = "Block RThroughput: "
|
|
|
|
for j in range(len(matrix_of_code_regions)):
|
|
if len(matrix_of_code_regions[j]) > i:
|
|
table_values[0][j + 1] = str(matrix_of_code_regions[j][i].instructions)
|
|
table_values[1][j + 1] = str(matrix_of_code_regions[j][i].total_cycles)
|
|
table_values[2][j + 1] = str(matrix_of_code_regions[j][i].total_uops)
|
|
table_values[3][j + 1] = str(
|
|
matrix_of_code_regions[j][i].dispatch_width
|
|
)
|
|
table_values[4][j + 1] = str(
|
|
round(matrix_of_code_regions[j][i].uops_per_cycle, 2)
|
|
)
|
|
table_values[5][j + 1] = str(round(matrix_of_code_regions[j][i].ipc, 2))
|
|
table_values[6][j + 1] = str(
|
|
round(matrix_of_code_regions[j][i].block_rthroughput, 2)
|
|
)
|
|
else:
|
|
table_values[0][j + 1] = "-"
|
|
table_values[1][j + 1] = "-"
|
|
table_values[2][j + 1] = "-"
|
|
table_values[3][j + 1] = "-"
|
|
table_values[4][j + 1] = "-"
|
|
table_values[5][j + 1] = "-"
|
|
table_values[6][j + 1] = "-"
|
|
|
|
tt.print(
|
|
table_values,
|
|
header=headers_names,
|
|
style=tt.styles.ascii_thin_double,
|
|
padding=(0, 1),
|
|
)
|
|
|
|
print("\nResource pressure per iteration: \n")
|
|
|
|
table_values = [
|
|
[
|
|
[None]
|
|
for i in range(
|
|
len(matrix_of_code_regions[0][0].iteration_resource_pressure) + 1
|
|
)
|
|
]
|
|
for j in range(len(matrix_of_code_regions) + 1)
|
|
]
|
|
|
|
table_values[0] = [" "] + matrix_of_code_regions[0][
|
|
0
|
|
].name_target_info_resources
|
|
|
|
for j in range(len(matrix_of_code_regions)):
|
|
if len(matrix_of_code_regions[j]) > i:
|
|
table_values[j + 1] = [
|
|
"[f" + str(j + 1) + "]: "
|
|
] + matrix_of_code_regions[j][i].iteration_resource_pressure
|
|
else:
|
|
table_values[j + 1] = ["[f" + str(j + 1) + "]: "] + len(
|
|
matrix_of_code_regions[0][0].iteration_resource_pressure
|
|
) * ["-"]
|
|
|
|
tt.print(
|
|
table_values,
|
|
style=tt.styles.ascii_thin_double,
|
|
padding=(0, 1),
|
|
)
|
|
print("\n")
|
|
|
|
|
|
# Based on the obtained results (summary view) of llvm-mca tool, draws plots for multiple input files.
|
|
def draw_plot_files_summary(array_of_summary, opts):
|
|
try:
|
|
import matplotlib.pyplot as plt
|
|
except ImportError:
|
|
print("error: matplotlib.pyplot not found.")
|
|
sys.exit(1)
|
|
try:
|
|
from matplotlib.cm import get_cmap
|
|
except ImportError:
|
|
print("error: get_cmap (matplotlib.cm) not found.")
|
|
sys.exit(1)
|
|
|
|
names = [
|
|
"Block RThroughput",
|
|
"Dispatch Width",
|
|
"IPC",
|
|
"uOps Per Cycle",
|
|
"Instructions",
|
|
"Total Cycles",
|
|
"Total uOps",
|
|
]
|
|
|
|
rows, cols = (len(opts.file_names), 7)
|
|
|
|
values = [[0 for x in range(cols)] for y in range(rows)]
|
|
|
|
for i in range(len(opts.file_names)):
|
|
values[i][0] = array_of_summary[i].block_rthroughput
|
|
values[i][1] = array_of_summary[i].dispatch_width
|
|
values[i][2] = array_of_summary[i].ipc
|
|
values[i][3] = array_of_summary[i].uops_per_cycle
|
|
values[i][4] = array_of_summary[i].instructions
|
|
values[i][5] = array_of_summary[i].total_cycles
|
|
values[i][6] = array_of_summary[i].total_uops
|
|
|
|
fig, axs = plt.subplots(4, 2)
|
|
fig.suptitle(
|
|
"Machine code statistics", fontsize=20, fontweight="bold", color="black"
|
|
)
|
|
i = 0
|
|
|
|
for x in range(4):
|
|
for y in range(2):
|
|
cmap = get_cmap("tab20")
|
|
colors = cmap.colors
|
|
if not (x == 0 and y == 1) and i < 7:
|
|
axs[x][y].grid(True, color="grey", linestyle="--")
|
|
maxValue = 0
|
|
if i == 0:
|
|
for j in range(len(opts.file_names)):
|
|
if maxValue < values[j][i]:
|
|
maxValue = values[j][i]
|
|
axs[x][y].bar(
|
|
0.3 * j,
|
|
values[j][i],
|
|
width=0.1,
|
|
color=colors[j],
|
|
label=get_filename_from_path(opts.file_names[j]),
|
|
)
|
|
else:
|
|
for j in range(len(opts.file_names)):
|
|
if maxValue < values[j][i]:
|
|
maxValue = values[j][i]
|
|
axs[x][y].bar(0.3 * j, values[j][i], width=0.1, color=colors[j])
|
|
axs[x][y].set_axisbelow(True)
|
|
axs[x][y].set_xlim([-0.3, len(opts.file_names) / 3])
|
|
axs[x][y].set_ylim([0, maxValue + (maxValue / 2)])
|
|
axs[x][y].set_title(names[i], fontsize=15, fontweight="bold")
|
|
axs[x][y].axes.xaxis.set_visible(False)
|
|
for j in range(len(opts.file_names)):
|
|
axs[x][y].text(
|
|
0.3 * j,
|
|
values[j][i] + (maxValue / 40),
|
|
s=str(values[j][i]),
|
|
color="black",
|
|
fontweight="bold",
|
|
fontsize=4,
|
|
)
|
|
i = i + 1
|
|
|
|
axs[0][1].set_visible(False)
|
|
fig.legend(prop={"size": 15})
|
|
figg = plt.gcf()
|
|
figg.set_size_inches((25, 15), forward=False)
|
|
if opts.plot_path[0] == "-":
|
|
plt.savefig("llvm-mca-plot.png", dpi=500)
|
|
print("The plot was saved within llvm-mca-plot.png")
|
|
else:
|
|
plt.savefig(
|
|
os.path.normpath(os.path.join(opts.plot_path[0], "llvm-mca-plot.png")),
|
|
dpi=500,
|
|
)
|
|
print(
|
|
"The plot was saved within {}.".format(
|
|
os.path.normpath(os.path.join(opts.plot_path[0], "llvm-mca-plot.png"))
|
|
)
|
|
)
|
|
|
|
|
|
# Calculates the average value (summary view) per region.
|
|
def summary_average_code_region(array_of_code_regions, file_name):
|
|
summary = Summary(file_name, 0, 0, 0, 0, 0, 0, 0, 0, None, None)
|
|
for i in range(len(array_of_code_regions)):
|
|
summary.block_rthroughput += array_of_code_regions[i].block_rthroughput
|
|
summary.dispatch_width += array_of_code_regions[i].dispatch_width
|
|
summary.ipc += array_of_code_regions[i].ipc
|
|
summary.instructions += array_of_code_regions[i].instructions
|
|
summary.iterations += array_of_code_regions[i].iterations
|
|
summary.total_cycles += array_of_code_regions[i].total_cycles
|
|
summary.total_uops += array_of_code_regions[i].total_uops
|
|
summary.uops_per_cycle += array_of_code_regions[i].uops_per_cycle
|
|
summary.block_rthroughput = round(
|
|
summary.block_rthroughput / len(array_of_code_regions), 2
|
|
)
|
|
summary.dispatch_width = round(
|
|
summary.dispatch_width / len(array_of_code_regions), 2
|
|
)
|
|
summary.ipc = round(summary.ipc / len(array_of_code_regions), 2)
|
|
summary.instructions = round(summary.instructions / len(array_of_code_regions), 2)
|
|
summary.iterations = round(summary.iterations / len(array_of_code_regions), 2)
|
|
summary.total_cycles = round(summary.total_cycles / len(array_of_code_regions), 2)
|
|
summary.total_uops = round(summary.total_uops / len(array_of_code_regions), 2)
|
|
summary.uops_per_cycle = round(
|
|
summary.uops_per_cycle / len(array_of_code_regions), 2
|
|
)
|
|
return summary
|
|
|
|
|
|
# Based on the obtained results (resource pressure per iter) of llvm-mca tool, draws plots for multiple input files.
|
|
def draw_plot_resource_pressure(
|
|
array_average_resource_pressure_per_file, opts, name_target_info_resources
|
|
):
|
|
try:
|
|
import matplotlib.pyplot as plt
|
|
except ImportError:
|
|
print("error: matplotlib.pyplot not found.")
|
|
sys.exit(1)
|
|
try:
|
|
from matplotlib.cm import get_cmap
|
|
except ImportError:
|
|
print("error: get_cmap (matplotlib.cm) not found.")
|
|
sys.exit(1)
|
|
|
|
fig, axs = plt.subplots()
|
|
fig.suptitle(
|
|
"Resource pressure per iterations",
|
|
fontsize=20,
|
|
fontweight="bold",
|
|
color="black",
|
|
)
|
|
|
|
maxValue = 0
|
|
for j in range(len(opts.file_names)):
|
|
if maxValue < max(array_average_resource_pressure_per_file[j]):
|
|
maxValue = max(array_average_resource_pressure_per_file[j])
|
|
|
|
cmap = get_cmap("tab20")
|
|
colors = cmap.colors
|
|
|
|
xticklabels = [None] * len(opts.file_names) * len(name_target_info_resources)
|
|
index = 0
|
|
|
|
for j in range(len(name_target_info_resources)):
|
|
for i in range(len(opts.file_names)):
|
|
if i == 0:
|
|
axs.bar(
|
|
j * len(opts.file_names) * 10 + i * 10,
|
|
array_average_resource_pressure_per_file[i][j],
|
|
width=1,
|
|
color=colors[j],
|
|
label=name_target_info_resources[j],
|
|
)
|
|
else:
|
|
axs.bar(
|
|
j * len(opts.file_names) * 10 + i * 10,
|
|
array_average_resource_pressure_per_file[i][j],
|
|
width=1,
|
|
color=colors[j],
|
|
)
|
|
axs.text(
|
|
j * len(opts.file_names) * 10 + i * 10,
|
|
array_average_resource_pressure_per_file[i][j] + (maxValue / 40),
|
|
s=str(array_average_resource_pressure_per_file[i][j]),
|
|
color=colors[j],
|
|
fontweight="bold",
|
|
fontsize=3,
|
|
)
|
|
xticklabels[index] = opts.file_names[i]
|
|
index = index + 1
|
|
|
|
axs.set_xticks(
|
|
[
|
|
j * len(opts.file_names) * 10 + i * 10
|
|
for j in range(len(name_target_info_resources))
|
|
for i in range(len(opts.file_names))
|
|
]
|
|
)
|
|
axs.set_xticklabels(xticklabels, rotation=65)
|
|
|
|
axs.set_axisbelow(True)
|
|
axs.set_xlim([-0.5, len(opts.file_names) * len(name_target_info_resources) * 10])
|
|
axs.set_ylim([0, maxValue + maxValue / 10])
|
|
|
|
fig.legend(prop={"size": 15})
|
|
figg = plt.gcf()
|
|
figg.set_size_inches((25, 15), forward=False)
|
|
if opts.plot_path[0] == "-":
|
|
plt.savefig("llvm-mca-plot-resource-pressure.png", dpi=500)
|
|
print("The plot was saved within llvm-mca-plot-resource-pressure.png")
|
|
else:
|
|
plt.savefig(
|
|
os.path.normpath(
|
|
os.path.join(opts.plot_path[0], "llvm-mca-plot-resource-pressure.png")
|
|
),
|
|
dpi=500,
|
|
)
|
|
print(
|
|
"The plot was saved within {}.".format(
|
|
os.path.normpath(
|
|
os.path.join(
|
|
opts.plot_path[0], "llvm-mca-plot-resource-pressure.png"
|
|
)
|
|
)
|
|
)
|
|
)
|
|
|
|
|
|
# Calculates the average value (resource pressure per iter) per region.
|
|
def average_code_region_resource_pressure(array_of_code_regions, file_name):
|
|
resource_pressure_per_iter_one_file = [0] * len(
|
|
array_of_code_regions[0].iteration_resource_pressure
|
|
)
|
|
for i in range(len(array_of_code_regions)):
|
|
for j in range(len(array_of_code_regions[i].iteration_resource_pressure)):
|
|
if array_of_code_regions[i].iteration_resource_pressure[j] != "-":
|
|
resource_pressure_per_iter_one_file[j] += float(
|
|
array_of_code_regions[i].iteration_resource_pressure[j]
|
|
)
|
|
for i in range(len(resource_pressure_per_iter_one_file)):
|
|
resource_pressure_per_iter_one_file[i] = round(
|
|
resource_pressure_per_iter_one_file[i] / len(array_of_code_regions), 2
|
|
)
|
|
return resource_pressure_per_iter_one_file
|
|
|
|
|
|
def Main():
|
|
parser = argparse.ArgumentParser()
|
|
opts = parse_program_args(parser)
|
|
|
|
if not verify_program_inputs(opts):
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
matrix_of_code_regions = [None] * len(opts.file_names)
|
|
|
|
for i in range(len(opts.file_names)):
|
|
matrix_of_code_regions[i] = run_llvm_mca_tool(opts, opts.file_names[i])
|
|
if not opts.plot and not opts.plot_resource_pressure:
|
|
console_print_results(matrix_of_code_regions, opts)
|
|
else:
|
|
if opts.plot:
|
|
array_average_summary_per_file = [None] * len(matrix_of_code_regions)
|
|
for j in range(len(matrix_of_code_regions)):
|
|
array_average_summary_per_file[j] = summary_average_code_region(
|
|
matrix_of_code_regions[j], opts.file_names[j]
|
|
)
|
|
draw_plot_files_summary(array_average_summary_per_file, opts)
|
|
if opts.plot_resource_pressure:
|
|
array_average_resource_pressure_per_file = [None] * len(
|
|
matrix_of_code_regions
|
|
)
|
|
for j in range(len(matrix_of_code_regions)):
|
|
array_average_resource_pressure_per_file[
|
|
j
|
|
] = average_code_region_resource_pressure(
|
|
matrix_of_code_regions[j], opts.file_names[j]
|
|
)
|
|
draw_plot_resource_pressure(
|
|
array_average_resource_pressure_per_file,
|
|
opts,
|
|
matrix_of_code_regions[0][0].name_target_info_resources,
|
|
)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
Main()
|
|
sys.exit(0)
|