stack.c.gen: INFRA: Have analyze() return thread counts instead of a sum

1 files changed, 25 insertions, 20 deletions

diff --git a/build-aux/stack.c.gen b/build-aux/stack.c.gen
index 095a992..05ca842 100755
--- a/build-aux/stack.c.gen
+++ b/build-aux/stack.c.gen
@@ -131,10 +131,13 @@ def synthetic_node(
     return n
 
 
+class AnalyzeResultVal(typing.NamedTuple):
+    nstatic: int
+    cnt: int
+
+
 class AnalyzeResultGroup(typing.NamedTuple):
-    rows: dict[str, int]
-    nmax: int
-    nsum: int
+    rows: dict[str, AnalyzeResultVal]
 
 
 class AnalyzeResult(typing.NamedTuple):
@@ -304,17 +307,14 @@ def analyze(
 
     groups: dict[str, AnalyzeResultGroup] = dict()
     for grp_name, grp_filter in app_func_filters.items():
-        nmax = 0
-        nsum = 0
-        rows: dict[str, int] = {}
+        rows: dict[str, AnalyzeResultVal] = {}
         for funcname in graph:
             if cnt := grp_filter(funcname):
                 n = nstatic(funcname)
-                rows[app.location_xform(funcname)] = n
-                if n > nmax:
-                    nmax = n
-                nsum += cnt * n
-        groups[grp_name] = AnalyzeResultGroup(rows=rows, nmax=nmax, nsum=nsum)
+                rows[app.location_xform(funcname)] = AnalyzeResultVal(
+                    nstatic=n, cnt=cnt
+                )
+        groups[grp_name] = AnalyzeResultGroup(rows=rows)
 
     return AnalyzeResult(
         groups=groups, missing=missing, dynamic=dynamic, included_funcs=included_funcs
@@ -1210,21 +1210,24 @@ def main(
     def print_group(grp_name: str) -> None:
         grp = result.groups[grp_name]
 
+        nsum = sum(v.nstatic * v.cnt for v in grp.rows.values())
+        nmax = max(v.nstatic for v in grp.rows.values())
+
         # Figure sizes.
         namelen = max([len(k) for k in grp.rows.keys()] + [len(grp_name) + 4])
-        numlen = len(str(grp.nsum))
+        numlen = len(str(nsum))
         sep1 = ("=" * namelen) + " " + "=" * numlen
         sep2 = ("-" * namelen) + " " + "-" * numlen
 
         # Print.
         print("= " + grp_name + " " + sep1[len(grp_name) + 3 :])
-        for name, num in sorted(grp.rows.items()):
-            if num == 0:
+        for name, val in sorted(grp.rows.items()):
+            if val.nstatic == 0:
                 continue
-            print(f"{name.ljust(namelen)} {str(num).rjust(numlen)}")
+            print(f"{name.ljust(namelen)} {str(val.nstatic).rjust(numlen)}")
         print(sep2)
-        print(f"{'Total'.ljust(namelen)} {str(grp.nsum).rjust(numlen)}")
-        print(f"{'Maximum'.ljust(namelen)} {str(grp.nmax).rjust(numlen)}")
+        print(f"{'Total'.ljust(namelen)} {str(nsum).rjust(numlen)}")
+        print(f"{'Maximum'.ljust(namelen)} {str(nmax).rjust(numlen)}")
         print(sep1)
 
     def next_power_of_2(x: int) -> int:
@@ -1236,10 +1239,12 @@ def main(
     print_group("Threads")
     print_group("Interrupt handlers")
     print("*/")
-    overhead = result.groups["Interrupt handlers"].nmax
+    overhead = max(v.nstatic for v in result.groups["Interrupt handlers"].rows.values())
     rows: list[tuple[str, int, int]] = []
-    for funcname, base in result.groups["Threads"].rows.items():
-        rows.append((funcname.split(":")[-1], base, next_power_of_2(base + overhead)))
+    for funcname, val in result.groups["Threads"].rows.items():
+        base = val.nstatic
+        size = next_power_of_2(base + overhead)
+        rows.append((funcname.split(":")[-1], base, size))
     namelen = max(len(r[0]) for r in rows)
     baselen = max(len(str(r[1])) for r in rows)
     sizelen = max(len(str(r[2])) for r in rows)