From: Marek Olšák <marek.ol...@amd.com>
---
si-report.py | 43 ++++++++++++++++++++++++++++++-------------
1 file changed, 30 insertions(+), 13 deletions(-)
diff --git a/si-report.py b/si-report.py
index 17b7c66..093fb39 100755
--- a/si-report.py
+++ b/si-report.py
@@ -75,20 +75,21 @@ def cmp_max_per(current, comp):
def cmp_min_per(current, comp):
return calculate_percent_change(comp[1], comp[2]) <
calculate_percent_change(current[1], current[2])
class si_stats:
metrics = [
('sgprs', 'SGPRS', ''),
('vgprs', 'VGPRS', ''),
('spilled_sgprs', 'Spilled SGPRs', ''),
('spilled_vgprs', 'Spilled VGPRs', ''),
+ ('privmem_vgprs', 'Private memory VGPRs', ''),
('scratch_size', 'Scratch size', 'dwords per thread'),
('code_size', 'Code Size', 'bytes'),
('lds', 'LDS', 'blocks'),
('maxwaves', 'Max Waves', ''),
('waitstates', 'Wait states', ''),
]
def __init__(self):
self.error = False
@@ -181,49 +182,61 @@ class si_stats:
for name in self.get_metrics():
x = self.__dict__[name]
if type(x) == tuple and x[0] is not 0:
return False
if type(x) != tuple and x is not 0:
return False
return True
class si_parser(object):
- re_stats = re.compile(
- r"^Shader Stats: SGPRS: ([0-9]+) VGPRS: ([0-9]+) Code Size: ([0-9]+) "+
- r"LDS: ([0-9]+) Scratch: ([0-9]+) Max Waves: ([0-9]+) Spilled SGPRs: "+
- r"([0-9]+) Spilled VGPRs: ([0-9]+)")
+ re_stats = [
+ re.compile(
+ r"^Shader Stats: SGPRS: ([0-9]+) VGPRS: ([0-9]+) Code Size:
([0-9]+) "+
+ r"LDS: ([0-9]+) Scratch: ([0-9]+) Max Waves: ([0-9]+) Spilled
SGPRs: "+
+ r"([0-9]+) Spilled VGPRs: ([0-9]+) PrivMem VGPRs: ([0-9]+)"),
+ re.compile(
+ r"^Shader Stats: SGPRS: ([0-9]+) VGPRS: ([0-9]+) Code Size:
([0-9]+) "+
+ r"LDS: ([0-9]+) Scratch: ([0-9]+) Max Waves: ([0-9]+) Spilled
SGPRs: "+
+ r"([0-9]+) Spilled VGPRs: ([0-9]+)"),
+ ]
+
re_nop = re.compile("^\ts_nop ([0-9]+)")
def __init__(self):
self._stats = None
self._in_disasm = False
def finish(self):
return self._stats
def parse(self, msg):
if not self._in_disasm:
if msg == "Shader Disassembly Begin":
old_stats = self._stats
self._stats = si_stats()
self._in_disasm = True
return old_stats
- match = si_parser.re_stats.match(msg)
+ for re in si_parser.re_stats:
+ match = re.match(msg)
+ if match is not None:
+ break
+
if match is not None:
if self._stats == None:
self._stats = si_stats()
self._stats.sgprs = int(match.group(1))
self._stats.vgprs = int(match.group(2))
self._stats.spilled_sgprs = int(match.group(7))
self._stats.spilled_vgprs = int(match.group(8))
+ self._stats.privmem_vgprs = int(match.group(9)) if
match.lastindex >= 9 else 0
self._stats.code_size = int(match.group(3))
self._stats.lds = int(match.group(4))
self._stats.scratch_size = int(match.group(5)) / (64 * 4)
self._stats.maxwaves = int(match.group(6))
old_stats = self._stats
self._stats = None
return old_stats
if msg == "LLVM compile failed":
old_stats = self._stats
@@ -470,59 +483,62 @@ class grouped_stats:
self.before.add(before)
self.after.add(after)
def set_one_shader(self, before, after):
self.before = before
self.after = after
self.diff = subtract_stats(after, before)
def print_vgpr_spilling_app(self, name):
if (self.after.spilled_vgprs > 0 or
- self.after.scratch_size > 0):
- print " {:22}{:6}{:10}{:10}".format(
+ self.after.privmem_vgprs > 0):
+ print " {:22}{:6}{:10}{:10}{:10}".format(
name,
self.num_shaders,
self.after.spilled_vgprs,
+ self.after.privmem_vgprs,
self.after.scratch_size)
def print_one_shader_vgpr_spill(self, name):
if (self.after.spilled_vgprs > 0 or
- self.after.scratch_size > 0):
- print " {:65}{:10}{:10}{:10}".format(
+ self.after.privmem_vgprs > 0):
+ print " {:65}{:10}{:10}{:10}{:10}".format(
name,
self.after.vgprs,
self.after.spilled_vgprs,
+ self.after.privmem_vgprs,
self.after.scratch_size)
def print_sgpr_spilling_app(self, name):
if self.after.spilled_sgprs > 0:
print " {:22}{:6}{:10}{:>9.1f}".format(
name,
self.num_shaders,
self.after.spilled_sgprs,
float(self.after.spilled_sgprs) / float(self.num_shaders))
def print_one_shader_sgpr_spill(self, name):
if self.after.spilled_sgprs > 0:
print " {:65}{:10}{:10}".format(
name,
self.after.sgprs,
self.after.spilled_sgprs)
def print_percentages(self, name):
- print " {:22}{:6}{}{}{}{}{}{}{}{}".format(
+ print " {:22}{:6}{}{}{}{}{}{}{}{}{}".format(
name,
self.num_shaders,
format_percent_change(self.before.sgprs, self.after.sgprs),
format_percent_change(self.before.vgprs, self.after.vgprs),
format_percent_change(self.before.spilled_sgprs,
self.after.spilled_sgprs),
format_percent_change(self.before.spilled_vgprs,
self.after.spilled_vgprs),
+ format_percent_change(self.before.privmem_vgprs,
self.after.privmem_vgprs),
format_percent_change(self.before.scratch_size,
self.after.scratch_size),
format_percent_change(self.before.code_size, self.after.code_size),
format_percent_change(self.before.maxwaves, self.after.maxwaves,
more_is_better = True),
format_percent_change(self.before.waitstates,
self.after.waitstates))
def print_regression(self, name, field):
more_is_better = field == "maxwaves"
print " {:65}{:10}{:10}{}{}".format(
name,
self.before.__dict__[field],
@@ -584,40 +600,41 @@ def print_tables(before_all_results, after_all_results):
total.add(before, after)
if not subtract_stats(before, after).is_empty():
total_affected.add(before, after)
# we don't have to add all shaders, just those that we may need
# to display
if (is_regression(before, after) or
after.scratch_size > 0 or
after.spilled_vgprs > 0 or
+ after.privmem_vgprs > 0 or
after.spilled_sgprs > 0):
name = get_shader_name(shaders, file)
shaders[name].set_one_shader(before, after)
# worst VGPR spills
num = 0
sort_key = lambda v: -v[1].after.scratch_size
for name, stats in sorted(shaders.items(), key = sort_key):
if num == 0:
print_yellow(" WORST VGPR SPILLS (not deltas)" + (" " * 40) +
- "VGPRs SpillVGPR ScratchSize")
+ "VGPRs SpillVGPR PrivVGPR ScratchSize")
stats.print_one_shader_vgpr_spill(name)
num += 1
if num == num_listed:
break
if num > 0:
print
# VGPR spilling apps
- print_yellow(" VGPR SPILLING APPS Shaders SpillVGPR ScratchSize")
+ print_yellow(" VGPR SPILLING APPS Shaders SpillVGPR PrivVGPR
ScratchSize")
for name, stats in sorted(apps.items()):
stats.print_vgpr_spilling_app(name)
print
# worst SGPR spills
num = 0
sort_key = lambda v: -v[1].after.spilled_sgprs
for name, stats in sorted(shaders.items(), key = sort_key):
if num == 0:
print_yellow(" WORST SGPR SPILLS (not deltas)" + (" " * 40) +
@@ -659,21 +676,21 @@ def print_tables(before_all_results, after_all_results):
print_yellow(" WORST REGRESSIONS -
{:49}".format(metrics[i][1]) +
"Before After Delta Percentage")
stats.print_regression(name, field)
num += 1
if num == num_listed:
break
if num > 0:
print
# percentages
- legend = "Shaders SGPRs VGPRs SpillSGPR SpillVGPR Scratch
CodeSize MaxWaves Waits"
+ legend = "Shaders SGPRs VGPRs SpillSGPR SpillVGPR PrivVGPR
Scratch CodeSize MaxWaves Waits"
print_yellow(" PERCENTAGE DELTAS " + legend)
for name, stats in sorted(apps.items()):
stats.print_percentages(name)
print " " + ("-" * (21 + len(legend)))
total_affected.print_percentages("All affected")
print " " + ("-" * (21 + len(legend)))
total.print_percentages("Total")
print
def main():
--
2.7.4
_______________________________________________
mesa-dev mailing list
mesa-dev@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/mesa-dev
