updates for running benchmarks with HIP on AMD

Author: MiloLurati

kernel_tuner/backends/hip.py

@@ -58,7 +58,7 @@ def __init__(self, device=0, iterations=7, compiler_options=None, observers=None
         self.name = self.hipProps._name.decode('utf-8')
         self.max_threads = self.hipProps.maxThreadsPerBlock
         self.device = device
-        self.compiler_options = compiler_options
+        self.compiler_options = compiler_options or []
         self.iterations = iterations
 
         env = dict()
@@ -122,7 +122,7 @@ def ready_argument_list(self, arguments):
         class ArgListStructure(ctypes.Structure):
             _fields_ = [(f'field{i}', t) for i, t in enumerate(field_types)]
             def __getitem__(self, key):
-                return self._fields_[key]
+                return getattr(self, self._fields_[key][0])
 
         return ArgListStructure(*ctype_args)
 
@@ -146,19 +146,28 @@ def compile(self, kernel_instance):
             kernel_string = 'extern "C" {\n' + kernel_string + "\n}"
         kernel_ptr = hiprtc.hiprtcCreateProgram(kernel_string, kernel_name, [], [])
 
-        #Compile based on device (Not yet tested for non-AMD devices)
-        plat = hip.hipGetPlatformName()
-        if plat == "amd":
-            hiprtc.hiprtcCompileProgram(
-                kernel_ptr, [f'--offload-arch={self.hipProps.gcnArchName}'])
-        else:
-            hiprtc.hiprtcCompileProgram(kernel_ptr, [])
-        
-        #Get module and kernel from compiled kernel string
-        code = hiprtc.hiprtcGetCode(kernel_ptr)
-        module = hip.hipModuleLoadData(code)
-        self.current_module = module
-        kernel = hip.hipModuleGetFunction(module, kernel_name)
+        try:
+            #Compile based on device (Not yet tested for non-AMD devices)
+            plat = hip.hipGetPlatformName()
+            if plat == "amd":
+                options_list = [f'--offload-arch={self.hipProps.gcnArchName}']
+                options_list.extend(self.compiler_options)
+                hiprtc.hiprtcCompileProgram(kernel_ptr, options_list)
+            else:
+                options_list = []
+                options_list.extend(self.compiler_options)
+                hiprtc.hiprtcCompileProgram(kernel_ptr, options_list)
+            
+            #Get module and kernel from compiled kernel string
+            code = hiprtc.hiprtcGetCode(kernel_ptr)
+            module = hip.hipModuleLoadData(code)
+            self.current_module = module
+            kernel = hip.hipModuleGetFunction(module, kernel_name)
+
+        except Exception as e:
+            log = hiprtc.hiprtcGetProgramLog(kernel_ptr)
+            print(log)
+            raise e
 
         return kernel
 

kernel_tuner/core.py

@@ -425,48 +425,48 @@ def compile_and_benchmark(self, kernel_source, gpu_args, params, kernel_options,
 
         instance = self.create_kernel_instance(kernel_source, kernel_options, params, verbose)
         if isinstance(instance, util.ErrorConfig):
-            return instance
-
-        try:
-            # compile the kernel
-            start_compilation = time.perf_counter()
-            func = self.compile_kernel(instance, verbose)
-            if not func:
-                result[to.objective] = util.CompilationFailedConfig()
-            else:
-                # add shared memory arguments to compiled module
-                if kernel_options.smem_args is not None:
-                    self.dev.copy_shared_memory_args(util.get_smem_args(kernel_options.smem_args, params))
-                # add constant memory arguments to compiled module
-                if kernel_options.cmem_args is not None:
-                    self.dev.copy_constant_memory_args(kernel_options.cmem_args)
-                # add texture memory arguments to compiled module
-                if kernel_options.texmem_args is not None:
-                    self.dev.copy_texture_memory_args(kernel_options.texmem_args)
-
-            # stop compilation stopwatch and convert to miliseconds
-            last_compilation_time = 1000 * (time.perf_counter() - start_compilation)
-
-            # test kernel for correctness
-            if func and (to.answer or to.verify):
-                start_verification = time.perf_counter()
-                self.check_kernel_output(func, gpu_args, instance, to.answer, to.atol, to.verify, verbose)
-                last_verification_time = 1000 * (time.perf_counter() - start_verification)
-
-            # benchmark
-            if func:
-                start_benchmark = time.perf_counter()
-                result.update(self.benchmark(func, gpu_args, instance, verbose, to.objective))
-                last_benchmark_time = 1000 * (time.perf_counter() - start_benchmark)
-
-        except Exception as e:
-            # dump kernel sources to temp file
-            temp_filenames = instance.prepare_temp_files_for_error_msg()
-            print("Error while compiling or benchmarking, see source files: " + " ".join(temp_filenames))
-            raise e
+            result[to.objective] = util.InvalidConfig()
+        else:
+            try:
+                # compile the kernel
+                start_compilation = time.perf_counter()
+                func = self.compile_kernel(instance, verbose)
+                if not func:
+                    result[to.objective] = util.CompilationFailedConfig()
+                else:
+                    # add shared memory arguments to compiled module
+                    if kernel_options.smem_args is not None:
+                        self.dev.copy_shared_memory_args(util.get_smem_args(kernel_options.smem_args, params))
+                    # add constant memory arguments to compiled module
+                    if kernel_options.cmem_args is not None:
+                        self.dev.copy_constant_memory_args(kernel_options.cmem_args)
+                    # add texture memory arguments to compiled module
+                    if kernel_options.texmem_args is not None:
+                        self.dev.copy_texture_memory_args(kernel_options.texmem_args)
+
+                # stop compilation stopwatch and convert to miliseconds
+                last_compilation_time = 1000 * (time.perf_counter() - start_compilation)
+
+                # test kernel for correctness
+                if func and (to.answer or to.verify):
+                    start_verification = time.perf_counter()
+                    self.check_kernel_output(func, gpu_args, instance, to.answer, to.atol, to.verify, verbose)
+                    last_verification_time = 1000 * (time.perf_counter() - start_verification)
+
+                # benchmark
+                if func:
+                    start_benchmark = time.perf_counter()
+                    result.update(self.benchmark(func, gpu_args, instance, verbose, to.objective))
+                    last_benchmark_time = 1000 * (time.perf_counter() - start_benchmark)
+
+            except Exception as e:
+                # dump kernel sources to temp file
+                temp_filenames = instance.prepare_temp_files_for_error_msg()
+                print("Error while compiling or benchmarking, see source files: " + " ".join(temp_filenames))
+                raise e
 
-        #clean up any temporary files, if no error occured
-        instance.delete_temp_files()
+            #clean up any temporary files, if no error occured
+            instance.delete_temp_files()
 
         result['compile_time'] = last_compilation_time or 0
         result['verification_time'] = last_verification_time or 0

test/test_c_functions.py

@@ -143,7 +143,7 @@ def test_compile(npct, subprocess):
     print(npct.mock_calls)
     print(f)
 
-    assert len(subprocess.mock_calls) == 6
+    assert len(subprocess.mock_calls) == 8
     assert npct.load_library.called == 1
 
     args, _ = npct.load_library.call_args_list[0]

test/test_hip_functions.py

@@ -55,7 +55,7 @@ class ArgListStructure(ctypes.Structure):
                     ("field2", ctypes.POINTER(ctypes.c_float)),
                     ("field3", ctypes.c_bool)]
         def __getitem__(self, key):
-                return self._fields_[key]
+                return getattr(self, self._fields_[key][0])
 
     dev = kt_hip.HipFunctions(0)
     gpu_args = dev.ready_argument_list(arguments)