suggestion to organize prologue observers differently

Author: benvanwerkhoven

kernel_tuner/core.py

@@ -314,6 +314,7 @@ def __init__(
             )
         else:
             raise ValueError("Sorry, support for languages other than CUDA, OpenCL, HIP, C, and Fortran is not implemented yet")
+        self.dev = dev
 
         # look for NVMLObserver in observers, if present, enable special tunable parameters through nvml
         self.use_nvml = False
@@ -332,53 +333,58 @@ def __init__(
                 if isinstance(obs, PrologueObserver):
                     self.prologue_observers.append(obs)
 
+        # Take list of observers from self.dev because Backends tend to add their own observer
+        self.benchmark_observers = [
+            obs for obs in self.dev.observers if not isinstance(obs, (ContinuousObserver, PrologueObserver))
+        ]
+
         self.iterations = iterations
 
         self.lang = lang
-        self.dev = dev
         self.units = dev.units
         self.name = dev.name
         self.max_threads = dev.max_threads
         if not quiet:
             print("Using: " + self.dev.name)
 
-    def benchmark_default(self, func, gpu_args, threads, grid, result):
-        """Benchmark one kernel execution at a time"""
-        observers = [
-            obs for obs in self.dev.observers if not isinstance(obs, ContinuousObserver)
-        ]
+    def benchmark_prologue(self, func, gpu_args, threads, grid, result):
+        """Benchmark prologue one kernel execution per PrologueObserver"""
 
         for obs in self.prologue_observers:
-            obs.prologue_start()
+            self.dev.synchronize()
+            obs.before_start()
             self.dev.run_kernel(func, gpu_args, threads, grid)
             self.dev.synchronize()
-            obs.prologue_finish()
+            obs.after_finish()
+            result.update(obs.get_results())
+
+    def benchmark_default(self, func, gpu_args, threads, grid, result):
+        """Benchmark one kernel execution for 'iterations' at a time"""
 
         self.dev.synchronize()
         for _ in range(self.iterations):
-            for obs in observers:
+            for obs in self.benchmark_observers:
                 obs.before_start()
             self.dev.synchronize()
             self.dev.start_event()
             self.dev.run_kernel(func, gpu_args, threads, grid)
             self.dev.stop_event()
-            for obs in observers:
+            for obs in self.benchmark_observers:
                 obs.after_start()
             while not self.dev.kernel_finished():
-                for obs in observers:
+                for obs in self.benchmark_observers:
                     obs.during()
                 time.sleep(1e-6)  # one microsecond
             self.dev.synchronize()
-            for obs in observers:
+            for obs in self.benchmark_observers:
                 obs.after_finish()
 
-        for obs in observers:
+        for obs in self.benchmark_observers:
             result.update(obs.get_results())
 
     def benchmark_continuous(self, func, gpu_args, threads, grid, result, duration):
         """Benchmark continuously for at least 'duration' seconds"""
         iterations = int(np.ceil(duration / (result["time"] / 1000)))
-        # print(f"{iterations=} {(result['time']/1000)=}")
         self.dev.synchronize()
         for obs in self.continuous_observers:
             obs.before_start()
@@ -423,9 +429,8 @@ def benchmark(self, func, gpu_args, instance, verbose, objective):
 
         result = {}
         try:
-            self.benchmark_default(
-                func, gpu_args, instance.threads, instance.grid, result
-            )
+            self.benchmark_prologue(func, gpu_args, instance.threads, instance.grid, result)
+            self.benchmark_default(func, gpu_args, instance.threads, instance.grid, result)
 
             if self.continuous_observers:
                 duration = 1

kernel_tuner/observers/ncu.py

@@ -31,10 +31,10 @@ def __init__(self, metrics=None, device=0):
         self.device = device
         self.results = dict()
 
-    def prologue_start(self):
+    def before_start(self):
         nvmetrics.measureMetricsStart(self.metrics, self.device)
 
-    def prologue_finish(self):
+    def after_finish(self):
         self.results = nvmetrics.measureMetricsStop()
 
     def get_results(self):

kernel_tuner/observers/observer.py

@@ -61,11 +61,11 @@ class PrologueObserver(BenchmarkObserver):
     """Observer that measures something in a seperate kernel invocation prior to the normal benchmark."""
 
     @abstractmethod
-    def prologue_start(self):
+    def before_start(self):
         """prologue start is called before the kernel starts"""
         pass
 
     @abstractmethod
-    def prologue_finish(self):
+    def after_finish(self):
         """prologue finish is called after the kernel has finished execution"""
         pass