[Bench] Add TorchLinearKernelSize benchmark

Author: lukaszstolarczuk

devops/scripts/benchmarks/benches/compute.py

@@ -182,7 +182,7 @@ def benchmarks(self) -> list[Benchmark]:
                 GraphApiSinKernelGraph(self, runtime, with_graphs, num_kernels)
             )
 
-            # Add ULLS benchmarks
+        # Add ULLS benchmarks
         for runtime in list(RUNTIMES):
             if runtime == RUNTIMES.SYCL:
                 benches.append(
@@ -355,6 +355,46 @@ def createTorchMultiQueueBench(variant_name: str, **kwargs):
                 ),
             ]
 
+        # Add LinearKernelSize benchmarks
+        for runtime in filter(lambda x: x != RUNTIMES.UR, RUNTIMES):
+
+            def createLinearKernelSizeBench(variant_name: str, **kwargs):
+                return TorchLinearKernelSize(
+                    self,
+                    runtime,
+                    variant_name,
+                    PROFILERS.TIMER,
+                    **kwargs,
+                )
+
+            benches += [
+                createLinearKernelSizeBench(
+                    "array32",
+                    kernelBatchSize=512,
+                    kernelSize=32,
+                ),
+                createLinearKernelSizeBench(
+                    "array128",
+                    kernelBatchSize=512,
+                    kernelSize=128,
+                ),
+                createLinearKernelSizeBench(
+                    "array512",
+                    kernelBatchSize=512,
+                    kernelSize=512,
+                ),
+                createLinearKernelSizeBench(
+                    "array1024",
+                    kernelBatchSize=512,
+                    kernelSize=1024,
+                ),
+                createLinearKernelSizeBench(
+                    "array5120",
+                    kernelBatchSize=512,
+                    kernelSize=5120,
+                ),
+            ]
+
         # Add UR-specific benchmarks
         benches += [
             # TODO: multithread_benchmark_ur fails with segfault
@@ -810,25 +850,25 @@ def _bin_args(self, run_trace: TracingType = TracingType.NONE) -> list[str]:
         return [f"--{k}={v}" for k, v in self._rr_params.items()]
 
 
-class TorchMultiQueue(ComputeBenchmark):
+class TorchBenchmark(ComputeBenchmark):
     def __init__(
-        self, suite, runtime: RUNTIMES, variant_name: str, profiler_type, **kwargs
+        self, suite, runtime: RUNTIMES, bench_name: str, variant_name: str, profiler_type, **kwargs
     ):
         self._variant_name = variant_name
-        self._smq_params = kwargs
+        self._torch_params = kwargs
         self._iterations_regular = 1000
         self._iterations_trace = 10
         super().__init__(
             suite,
             f"torch_benchmark_{runtime.value}",
-            "KernelSubmitMultiQueue",
+            bench_name,
             runtime,
             profiler_type,
         )
 
     def name(self):
         ret = []
-        for k, v in self._smq_params.items():
+        for k, v in self._torch_params.items():
             ret.append(f"{k} {v}")
         ret.sort()
         return self._bench_name + " " + ", ".join(ret)
@@ -848,10 +888,38 @@ def _supported_runtimes(self) -> list[RUNTIMES]:
     def _bin_args(self, run_trace: TracingType = TracingType.NONE) -> list[str]:
         iters = self._get_iters(run_trace)
         return [f"--iterations={iters}"] + [
-            f"--{k}={v}" for k, v in self._smq_params.items()
+            f"--{k}={v}" for k, v in self._torch_params.items()
         ]
 
 
+class TorchMultiQueue(TorchBenchmark):
+    def __init__(
+        self, suite, runtime: RUNTIMES, variant_name: str, profiler_type, **kwargs
+    ):
+        super().__init__(
+            suite,
+            runtime,
+            "KernelSubmitMultiQueue",
+            variant_name,
+            profiler_type,
+            **kwargs,
+        )
+
+
+class TorchLinearKernelSize(TorchBenchmark):
+    def __init__(
+        self, suite, runtime: RUNTIMES, variant_name: str, profiler_type, **kwargs
+    ):
+        super().__init__(
+            suite,
+            runtime,
+            "KernelSubmitLinearKernelSize",
+            variant_name,
+            profiler_type,
+            **kwargs,
+        )
+
+
 class QueueInOrderMemcpy(ComputeBenchmark):
     def __init__(self, bench, isCopyOnly, source, destination, size, profiler_type):
         self._is_copy_only = isCopyOnly

devops/scripts/benchmarks/tests/test_integration.py

@@ -194,20 +194,36 @@ def test_torch_l0(self):
             "KernelSubmitMultiQueue large",
             {"pytorch", "L0"},
         )
+        self._checkCase(
+            "torch_benchmark_l0 kernelBatchSize 512, kernelSize 32",
+            "KernelSubmitLinearKernelSize array32",
+            {"pytorch", "L0"},
+        )
 
     def test_torch_sycl(self):
         self._checkCase(
             "torch_benchmark_sycl kernelsPerQueue 10, workgroupCount 512, workgroupSize 256",
             "KernelSubmitMultiQueue medium",
             {"pytorch", "SYCL"},
         )
+        self._checkCase(
+            "torch_benchmark_sycl kernelBatchSize 512, kernelSize 5120",
+            "KernelSubmitLinearKernelSize array5120",
+            {"pytorch", "SYCL"},
+        )
 
     def test_torch_syclpreview(self):
         self._checkCase(
             "torch_benchmark_syclpreview kernelsPerQueue 4, workgroupCount 256, workgroupSize 124",
             "KernelSubmitMultiQueue small",
             {"pytorch", "SYCL"},
         )
+        self._checkCase(
+            "torch_benchmark_syclpreview kernelBatchSize 512, kernelSize 512",
+            "KernelSubmitLinearKernelSize array512",
+            {"pytorch", "SYCL"},
+        )
+
 
 if __name__ == "__main__":
     unittest.main()