#!/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)
Codebase Browser
llvm