Update profiling parser for pre/post-kernel cycles

- ProfilingTraceParser: parse the new "Pre-Kernel"/"Post-Kernel" trace
  format (replacing Input/Output DMA) and track per-layer tile count.
- profiling2csv: report pre/post-kernel cycles, total cycles, ops/cycle,
  and tile count; append a "Total" row; default the output CSV path to
  the trace path with a .csv suffix.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Xeratec

DeeployTest/profiling2csv.py

@@ -16,40 +16,62 @@ class LayerInfo:
     bufferingMode: str
     ops: int
     totalKernelCycles: int
-    totalInputDmaCycles: int
-    totalOutputDmaCycles: int
+    totalPreKernelCycles: int
+    totalPostKernelCycles: int
+    totalCycles: int
+    opsperCycle: float
+    tiles: int = 0
 
 
 def layerInfoFromProfiling(name: str, profiling: LayerProfiling) -> LayerInfo:
+    totalKernelCycles = sum(profiling.kernelCycles)
+    totalPreKernelCycles = sum(profiling.preKernelCycles)
+    totalPostKernelCycles = sum(profiling.postKernelCycles)
+    totalCycles = totalKernelCycles + totalPreKernelCycles + totalPostKernelCycles
+    opsperCycle = profiling.ops / totalCycles if totalCycles > 0 else 0.0
     return LayerInfo(name = name,
                      bufferingMode = profiling.bufferingMode,
                      ops = profiling.ops,
-                     totalKernelCycles = sum(profiling.kernelCycles),
-                     totalInputDmaCycles = sum(profiling.inputDmaCycles),
-                     totalOutputDmaCycles = sum(profiling.outputDmaCycles))
+                     totalKernelCycles = totalKernelCycles,
+                     totalPreKernelCycles = totalPreKernelCycles,
+                     totalPostKernelCycles = totalPostKernelCycles,
+                     totalCycles = totalCycles,
+                     opsperCycle = opsperCycle,
+                     tiles = profiling.tiles)
 
 
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(description = 'Parse and visualize profiling results')
     parser.add_argument('trace_path', type = str, help = 'Path to the profiling trace file')
-    parser.add_argument('-o',
-                        '--output_path',
-                        type = str,
-                        default = "profile.csv",
-                        help = 'Path to the output CSV file')
+    parser.add_argument('-o', '--output_path', type = str, help = 'Path to the output CSV file')
     parser.add_argument('--table',
                         action = 'store_true',
                         default = False,
                         help = 'Print a table of the profiled results.')
     args = parser.parse_args()
 
+    if not args.output_path:
+        args.output_path = args.trace_path.rsplit('.', 1)[0] + '.csv'
+
     profilingParser = ProfilingTraceParser()
 
     with open(args.trace_path, "r") as f:
         layerProfilings = profilingParser.parse(f.read())
 
     fieldnames = [field.name for field in dataclasses.fields(LayerInfo)]
     layerInfos = [layerInfoFromProfiling(name, profiling) for name, profiling in layerProfilings.items()]
+    layerInfos += [
+        LayerInfo(name = "Total",
+                  bufferingMode = "",
+                  ops = sum(info.ops for info in layerInfos),
+                  totalKernelCycles = sum(info.totalKernelCycles for info in layerInfos),
+                  totalPreKernelCycles = sum(info.totalPreKernelCycles for info in layerInfos),
+                  totalPostKernelCycles = sum(info.totalPostKernelCycles for info in layerInfos),
+                  totalCycles = sum(info.totalCycles for info in layerInfos),
+                  opsperCycle = sum(info.ops for info in layerInfos) /
+                  sum(info.totalCycles for info in layerInfos) if sum(
+                      info.totalCycles for info in layerInfos) > 0 else 0.0)
+    ]
 
     with open(args.output_path, 'w', newline = '') as csvfile:
         writer = csv.DictWriter(csvfile, fieldnames = fieldnames)

DeeployTest/testUtils/ProfilingTraceParser.py

@@ -14,14 +14,15 @@ class LayerProfiling:
     bufferingMode: BufferingMode
     ops: int
     kernelCycles: List[int]
-    inputDmaCycles: List[int]
-    outputDmaCycles: List[int]
+    preKernelCycles: List[int]
+    postKernelCycles: List[int]
+    tiles: int = 0
 
 
 class ProfilingTraceParser:
 
     lineRegex = re.compile(
-        r"\[(\w+)\]\[(SB|DB)\]\[(\d+) ops\]\[Tile \d+\] (Input DMA|Output DMA|Kernel) took (\d+) cycles\n")
+        r"\[(\w+)\]\[(SB|DB)\]\[(\d+) ops\]\[Tile \d+\] (Pre-Kernel|Kernel|Post-Kernel)\s*:\s*(\d+) cycles")
 
     def parse(self, trace: str) -> Dict[str, LayerProfiling]:
         layerProfilings: Dict[str, LayerProfiling] = {}
@@ -34,16 +35,18 @@ def parse(self, trace: str) -> Dict[str, LayerProfiling]:
                     bufferingMode = bufferingMode,  # type: ignore
                     ops = int(ops),
                     kernelCycles = [],
-                    inputDmaCycles = [],
-                    outputDmaCycles = [])
+                    preKernelCycles = [],
+                    postKernelCycles = [])
 
             if measurementName == "Kernel":
                 layerProfilings[layerName].kernelCycles.append(int(cycles))
-            elif measurementName == "Input DMA":
-                layerProfilings[layerName].inputDmaCycles.append(int(cycles))
-            elif measurementName == "Output DMA":
-                layerProfilings[layerName].outputDmaCycles.append(int(cycles))
+            elif measurementName == "Pre-Kernel":
+                layerProfilings[layerName].preKernelCycles.append(int(cycles))
+            elif measurementName == "Post-Kernel":
+                layerProfilings[layerName].postKernelCycles.append(int(cycles))
             else:
                 raise RuntimeError(f"Unsupported measurement name: {measurementName}")
 
+            layerProfilings[layerName].tiles = len(layerProfilings[layerName].kernelCycles)
+
         return layerProfilings