kernel-tuner 1.1.2__tar.gz → 1.2.0__tar.gz

{kernel_tuner-1.1.2 → kernel_tuner-1.2.0}/PKG-INFO

@@ -1,15 +1,15 @@
 Metadata-Version: 2.3
 Name: kernel_tuner
-Version: 1.1.2
+Version: 1.2.0
 Summary: An easy to use CUDA/OpenCL kernel tuner in Python
 License: Apache-2.0
 Keywords: auto-tuning,gpu,computing,pycuda,cuda,pyopencl,opencl
 Author: Ben van Werkhoven
 Author-email: b.vanwerkhoven@esciencecenter.nl
-Requires-Python: >=3.9,<4
-Classifier: Development Status :: 5 - Production/Stable
+Requires-Python: >=3.10,<4
 Classifier: Environment :: Console
 Classifier: Environment :: GPU
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: Science/Research
@@ -17,39 +17,41 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Natural Language :: English
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Classifier: Topic :: System :: Distributed Computing
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Scientific/Engineering
-Classifier: Topic :: Software Development
-Classifier: Topic :: System :: Distributed Computing
 Provides-Extra: cuda
 Provides-Extra: cuda-opencl
 Provides-Extra: hip
 Provides-Extra: opencl
 Provides-Extra: tutorial
-Requires-Dist: hip-python (>=6.3.3.540.31,<7.0.0.0.0) ; extra == "hip"
+Requires-Dist: hip-python ; extra == "hip"
 Requires-Dist: jsonschema
-Requires-Dist: jupyter (>=1.0.0,<2.0.0) ; extra == "tutorial"
-Requires-Dist: matplotlib (>=3.5.0,<4.0.0) ; extra == "tutorial"
-Requires-Dist: numpy (>=2.0.0,<3.0.0)
-Requires-Dist: nvidia-ml-py (>=12.535.108,<13.0.0) ; extra == "cuda" or extra == "tutorial"
+Requires-Dist: jupyter (>=1.0.0) ; extra == "tutorial"
+Requires-Dist: matplotlib (>=3.5.0) ; extra == "tutorial"
+Requires-Dist: numpy (>=2.0.0)
+Requires-Dist: nvidia-ml-py (>=12.535.108) ; extra == "cuda"
+Requires-Dist: nvidia-ml-py (>=12.535.108) ; extra == "tutorial"
 Requires-Dist: packaging
 Requires-Dist: pandas (>=2.0.0)
-Requires-Dist: pycuda (>=2024.1,<2025.0) ; extra == "cuda" or extra == "cuda-opencl"
-Requires-Dist: pynvml (>=11.4.1,<12.0.0) ; extra == "cuda"
-Requires-Dist: pyopencl ; extra == "opencl" or extra == "cuda-opencl"
-Requires-Dist: python-constraint2 (>=2.1.0,<3.0.0)
+Requires-Dist: pycuda (>=2024.1) ; extra == "cuda-opencl"
+Requires-Dist: pycuda (>=2025.1) ; extra == "cuda"
+Requires-Dist: pynvml (>=11.4.1) ; extra == "cuda"
+Requires-Dist: pyopencl ; extra == "cuda-opencl"
+Requires-Dist: pyopencl ; extra == "opencl"
+Requires-Dist: python-constraint2 (>=2.3.1)
 Requires-Dist: scikit-learn (>=1.0.2)
-Requires-Dist: scipy (>=1.11.0)
+Requires-Dist: scipy (>=1.14.1)
 Requires-Dist: xmltodict
 Project-URL: Documentation, https://KernelTuner.github.io/kernel_tuner/
 Project-URL: Homepage, https://KernelTuner.github.io/kernel_tuner/
 Project-URL: Repository, https://github.com/KernelTuner/kernel_tuner
-Project-URL: Tracker, https://github.com/KernelTuner/kernel_tuner/issues
+Project-URL: changelog, https://github.com/KernelTuner/kernel_tuner/blob/master/CHANGELOG.md
+Project-URL: issues, https://github.com/KernelTuner/kernel_tuner/issues
 Description-Content-Type: text/markdown
 
 
@@ -70,7 +72,7 @@ Description-Content-Type: text/markdown
 
 
 Create optimized GPU applications in any mainstream GPU 
-programming language (CUDA, HIP, OpenCL, OpenACC).
+programming language (CUDA, HIP, OpenCL, OpenACC, OpenMP).
 
 What Kernel Tuner does:
 

{kernel_tuner-1.1.2 → kernel_tuner-1.2.0}/README.md

@@ -16,7 +16,7 @@
 
 
 Create optimized GPU applications in any mainstream GPU 
-programming language (CUDA, HIP, OpenCL, OpenACC).
+programming language (CUDA, HIP, OpenCL, OpenACC, OpenMP).
 
 What Kernel Tuner does:
 

{kernel_tuner-1.1.2 → kernel_tuner-1.2.0}/kernel_tuner/__init__.py

@@ -1,5 +1,5 @@
 from kernel_tuner.integration import store_results, create_device_targets
-from kernel_tuner.interface import tune_kernel, run_kernel
+from kernel_tuner.interface import tune_kernel, tune_kernel_T1, run_kernel
 
 from importlib.metadata import version
 

{kernel_tuner-1.1.2 → kernel_tuner-1.2.0}/kernel_tuner/backends/backend.py

@@ -1,16 +1,16 @@
-"""This module contains the interface of all kernel_tuner backends"""
+"""This module contains the interface of all kernel_tuner backends."""
 from __future__ import print_function
 
 from abc import ABC, abstractmethod
 
 
 class Backend(ABC):
-    """Base class for kernel_tuner backends"""
+    """Base class for kernel_tuner backends."""
 
     @abstractmethod
     def ready_argument_list(self, arguments):
         """This method must implement the allocation of the arguments on device memory."""
-        pass
+        return arguments
 
     @abstractmethod
     def compile(self, kernel_instance):
@@ -57,9 +57,14 @@ class Backend(ABC):
         """This method must implement a host to device copy."""
         pass
 
+    @abstractmethod
+    def refresh_memory(self, device_memory, host_arguments, should_sync):
+        """This method must implement refreshing the device memory with a clean copy."""
+        pass
+
 
 class GPUBackend(Backend):
-    """Base class for GPU backends"""
+    """Base class for GPU backends."""
 
     @abstractmethod
     def __init__(self, device, iterations, compiler_options, observers):
@@ -80,10 +85,21 @@ class GPUBackend(Backend):
         """This method must implement the allocation and copy of texture memory to the GPU."""
         pass
 
+    def refresh_memory(self, gpu_memory, host_arguments, should_sync):
+        """Refresh the GPU memory with the untouched host arguments."""
+        for i, arg in enumerate(host_arguments):
+            if should_sync[i]:
+                self.memcpy_htod(gpu_memory[i], arg)
+
 
 class CompilerBackend(Backend):
-    """Base class for compiler backends"""
+    """Base class for compiler backends."""
 
     @abstractmethod
     def __init__(self, iterations, compiler_options, compiler):
         pass
+
+    @abstractmethod
+    def cleanup_lib(self):
+        """Unload the previously loaded shared library"""
+        pass

{kernel_tuner-1.1.2 → kernel_tuner-1.2.0}/kernel_tuner/backends/compiler.py

@@ -34,7 +34,7 @@ except ImportError:
 try:
     from hip._util.types import DeviceArray
 except ImportError:
-    Pointer = Exception # using Exception here as a type that will never be among kernel arguments
+    Pointer = Exception  # using Exception here as a type that will never be among kernel arguments
     DeviceArray = Exception
 
 
@@ -93,8 +93,12 @@ class CompilerFunctions(CompilerBackend):
         :param iterations: Number of iterations used while benchmarking a kernel, 7 by default.
         :type iterations: int
         """
+        # allocations contains a clean copy of the memory
+        self.allocations = []
         self.observers = observers or []
         self.observers.append(CompilerRuntimeObserver(self))
+        for obs in self.observers:
+            obs.register_device(self)
 
         self.iterations = iterations
         self.max_threads = 1024
@@ -104,7 +108,6 @@ class CompilerFunctions(CompilerBackend):
         self.lib = None
         self.using_openmp = False
         self.using_openacc = False
-        self.observers = [CompilerRuntimeObserver(self)]
         self.last_result = None
 
         if self.compiler == "g++":
@@ -157,30 +160,24 @@ class CompilerFunctions(CompilerBackend):
 
         for i, arg in enumerate(arguments):
             if not (isinstance(arg, (np.ndarray, np.number, DeviceArray)) or is_cupy_array(arg)):
-                raise TypeError(f"Argument is not numpy or cupy ndarray or numpy scalar or HIP Python DeviceArray but a {type(arg)}")
+                raise TypeError(
+                    f"Argument is not numpy or cupy ndarray or numpy scalar or HIP Python DeviceArray but a {type(arg)}"
+                )
             dtype_str = arg.typestr if isinstance(arg, DeviceArray) else str(arg.dtype)
             if isinstance(arg, np.ndarray):
                 if dtype_str in dtype_map.keys():
-                    # In numpy <= 1.15, ndarray.ctypes.data_as does not itself keep a reference
-                    # to its underlying array, so we need to store a reference to arg.copy()
-                    # in the Argument object manually to avoid it being deleted.
-                    # (This changed in numpy > 1.15.)
-                    # data_ctypes = data.ctypes.data_as(C.POINTER(dtype_map[dtype_str]))
                     data_ctypes = arg.ctypes.data_as(C.POINTER(dtype_map[dtype_str]))
-                    numpy_arg = arg
                 else:
                     raise TypeError("unknown dtype for ndarray")
             elif isinstance(arg, np.generic):
                 data_ctypes = dtype_map[dtype_str](arg)
-                numpy_arg = arg
             elif is_cupy_array(arg):
                 data_ctypes = C.c_void_p(arg.data.ptr)
-                numpy_arg = arg
             elif isinstance(arg, DeviceArray):
                 data_ctypes = arg.as_c_void_p()
-                numpy_arg = None
 
-            ctype_args[i] = Argument(numpy=numpy_arg, ctypes=data_ctypes)
+            ctype_args[i] = Argument(numpy=arg, ctypes=data_ctypes)
+            self.allocations.append(Argument(numpy=arg.copy(), ctypes=data_ctypes))
         return ctype_args
 
     def compile(self, kernel_instance):
@@ -204,16 +201,13 @@ class CompilerFunctions(CompilerBackend):
         compiler_options = ["-fPIC"]
 
         # detect openmp
-        if "#include <omp.h>" in kernel_string or "use omp_lib" in kernel_string:
+        if "#pragma omp" in kernel_string or "!$omp" in kernel_string:
             logging.debug("set using_openmp to true")
             self.using_openmp = True
-            if self.compiler in ["nvc", "nvc++", "nvfortran"]:
-                compiler_options.append("-mp")
-            else:
-                compiler_options.append("-fopenmp")
 
         # detect openacc
         if "#pragma acc" in kernel_string or "!$acc" in kernel_string:
+            logging.debug("set using_openacc to true")
             self.using_openacc = True
 
         # if filename is known, use that one
@@ -288,7 +282,7 @@ class CompilerFunctions(CompilerBackend):
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 text=True,
-                check=True
+                check=True,
             )
 
             subprocess.run(
@@ -299,7 +293,7 @@ class CompilerFunctions(CompilerBackend):
                 stdout=subprocess.PIPE,
                 stderr=subprocess.PIPE,
                 text=True,
-                check=True
+                check=True,
             )
 
             self.lib = np.ctypeslib.load_library(filename, ".")
@@ -390,7 +384,8 @@ class CompilerFunctions(CompilerBackend):
             C.memset(allocation.ctypes, value, size)
 
     def memcpy_dtoh(self, dest, src):
-        """a simple memcpy copying from an Argument to a numpy array
+        """This method implements the semantic of a device to host copy for the Compiler backend.
+        There is no actual copy from device to host happening, but host to host.
 
         :param dest: A numpy or cupy array to store the data
         :type dest: np.ndarray or cupy.ndarray
@@ -404,6 +399,7 @@ class CompilerFunctions(CompilerBackend):
             # This is because DeviceArray manages its own memory and donesn't need
             # explicit copies like numpy arrays do
             return
+        # there is no real copy from device to host, but host to host
         if isinstance(dest, np.ndarray) and is_cupy_array(src.numpy):
             # Implicit conversion to a NumPy array is not allowed.
             value = src.numpy.get()
@@ -413,33 +409,20 @@ class CompilerFunctions(CompilerBackend):
         dest[:] = xp.asarray(value)
 
     def memcpy_htod(self, dest, src):
-        """a simple memcpy copying from a numpy array to an Argument
-
-        :param dest: An Argument for some memory allocation
-        :type dest: Argument
+        """There is no memcpy_htod implemented for the compiler backend."""
+        pass
 
-        :param src: A numpy or cupy array containing the source data
-        :type src: np.ndarray or cupy.ndarray
-        """
-        # If src.numpy is None, it means we're dealing with a HIP Python DeviceArray
-        if dest.numpy is None:
-            # Skip memory copies for HIP Python DeviceArray
-            # This is because DeviceArray manages its own memory and donesn't need
-            # explicit copies like numpy arrays do
-            return
-        if isinstance(dest.numpy, np.ndarray) and is_cupy_array(src):
-            # Implicit conversion to a NumPy array is not allowed.
-            value = src.get()
-        else:
-            value = src
-        xp = get_array_module(dest.numpy)
-        dest.numpy[:] = xp.asarray(value)
+    def refresh_memory(self, _, arguments, should_sync):
+        """Copy the preserved content of the output memory to used arrays."""
+        for i, arg in enumerate(arguments):
+            if should_sync[i]:
+                self.memcpy_dtoh(arg, self.allocations[i])
 
     def cleanup_lib(self):
         """unload the previously loaded shared library"""
         if self.lib is None:
             return
-        
+
         if not self.using_openmp and not self.using_openacc:
             # this if statement is necessary because shared libraries that use
             # OpenMP will core dump when unloaded, this is a well-known issue with OpenMP

{kernel_tuner-1.1.2 → kernel_tuner-1.2.0}/kernel_tuner/backends/hip.py

@@ -19,7 +19,6 @@ dtype_map = {
     "bool": ctypes.c_bool,
     "int8": ctypes.c_int8,
     "int16": ctypes.c_int16,
-    "float16": ctypes.c_int16,
     "int32": ctypes.c_int32,
     "int64": ctypes.c_int64,
     "uint8": ctypes.c_uint8,
@@ -40,7 +39,9 @@ def hip_check(call_result):
     if len(result) == 1:
         result = result[0]
     if isinstance(err, hip.hipError_t) and err != hip.hipError_t.hipSuccess:
-        raise RuntimeError(str(err))
+        _, error_name = hip.hipGetErrorName(err)
+        _, error_str = hip.hipGetErrorString(err)
+        raise RuntimeError(f"{error_name}: {error_str}")
     return result
 
 
@@ -120,25 +121,29 @@ class HipFunctions(GPUBackend):
 
             # Handle numpy arrays
             if isinstance(arg, np.ndarray):
-                if dtype_str in dtype_map.keys():
-                    # Allocate device memory
-                    device_ptr = hip_check(hip.hipMalloc(arg.nbytes))
+                # Allocate device memory
+                device_ptr = hip_check(hip.hipMalloc(arg.nbytes))
 
-                    # Copy data to device using hipMemcpy
-                    hip_check(hip.hipMemcpy(device_ptr, arg, arg.nbytes, hip.hipMemcpyKind.hipMemcpyHostToDevice))
+                # Copy data to device using hipMemcpy
+                hip_check(hip.hipMemcpy(device_ptr, arg, arg.nbytes, hip.hipMemcpyKind.hipMemcpyHostToDevice))
 
-                    prepared_args.append(device_ptr)
-                else:
-                    raise TypeError(f"Unknown dtype {dtype_str} for ndarray")
+                prepared_args.append(device_ptr)
 
             # Handle numpy scalar types
             elif isinstance(arg, np.generic):
                 # Convert numpy scalar to corresponding ctypes
-                ctype_arg = dtype_map[dtype_str](arg)
-                prepared_args.append(ctype_arg)
+                if dtype_str in dtype_map:
+                    ctype_arg = dtype_map[dtype_str](arg)
+                    prepared_args.append(ctype_arg)
+                # 16-bit float is not supported, view it as uint16
+                elif dtype_str in ("float16", "bfloat16"):
+                    ctype_arg = ctypes.c_uint16(arg.view(np.uint16))
+                    prepared_args.append(ctype_arg)
+                else:
+                    raise ValueError(f"Invalid argument type {dtype_str}: {arg}")
 
             else:
-                raise ValueError(f"Invalid argument type {type(arg)}, {arg}")
+                raise ValueError(f"Invalid argument type {type(arg)}: {arg}")
 
         return prepared_args
 

kernel_tuner-1.2.0/kernel_tuner/backends/hypertuner.py

@@ -0,0 +1,131 @@
+"""This module contains a 'device' for hyperparameter tuning using the autotuning methodology."""
+
+import platform
+from pathlib import Path
+
+from numpy import mean
+
+from kernel_tuner.backends.backend import Backend
+from kernel_tuner.observers.observer import BenchmarkObserver
+
+try:
+    methodology_available = True
+    from autotuning_methodology.experiments import generate_experiment_file
+    from autotuning_methodology.report_experiments import get_strategy_scores
+except ImportError:
+    methodology_available = False
+
+
+class ScoreObserver(BenchmarkObserver):
+    def __init__(self, dev):
+        self.dev = dev
+        self.scores = []
+
+    def after_finish(self):
+        self.scores.append(self.dev.last_score)
+
+    def get_results(self):
+        results = {'score': mean(self.scores), 'scores': self.scores.copy()}
+        self.scores = []
+        return results
+
+class HypertunerFunctions(Backend):
+    """Class for executing hyperparameter tuning."""
+    units = {}
+
+    def __init__(self, iterations):
+        self.iterations = iterations
+        self.observers = [ScoreObserver(self)]
+        self.name = platform.processor()
+        self.max_threads = 1024
+        self.last_score = None
+
+        # set the environment options
+        env = dict()
+        env["iterations"] = self.iterations
+        self.env = env
+
+        # check for the methodology package
+        if methodology_available is not True:
+            raise ImportError("Unable to import the autotuning methodology, run `pip install autotuning_methodology`.")
+
+    def ready_argument_list(self, arguments):
+        arglist = super().ready_argument_list(arguments)
+        if arglist is None:
+            arglist = []
+        return arglist
+    
+    def compile(self, kernel_instance):
+        super().compile(kernel_instance)
+        path = Path(__file__).parent.parent.parent / "hyperparamtuning"
+        path.mkdir(exist_ok=True)
+
+        # TODO get applications & GPUs args from benchmark
+        gpus = ["RTX_3090", "RTX_2080_Ti"]
+        applications = None
+        # applications = [
+        #     {
+        #         "name": "convolution",
+        #         "folder": "./cached_data_used/kernels",
+        #         "input_file": "convolution.json"
+        #     },
+        #     {
+        #         "name": "pnpoly",
+        #         "folder": "./cached_data_used/kernels",
+        #         "input_file": "pnpoly.json"
+        #     }
+        # ]
+
+        # strategy settings
+        strategy: str = kernel_instance.arguments[0]
+        hyperparams = [{'name': k, 'value': v} for k, v in kernel_instance.params.items()]
+        hyperparams_string = "_".join(f"{k}={str(v)}" for k, v in kernel_instance.params.items())
+        searchspace_strategies = [{
+            "autotuner": "KernelTuner",
+            "name": f"{strategy.lower()}_{hyperparams_string}",
+            "display_name": strategy.replace('_', ' ').capitalize(),
+            "search_method": strategy.lower(),
+            'search_method_hyperparameters': hyperparams
+        }]
+
+        # any additional settings
+        override = { 
+            "experimental_groups_defaults": { 
+                "samples": self.iterations 
+            }
+        }
+
+        name = kernel_instance.name if len(kernel_instance.name) > 0 else kernel_instance.kernel_source.kernel_name
+        experiments_filepath = generate_experiment_file(name, path, searchspace_strategies, applications, gpus, 
+                                                        override=override, overwrite_existing_file=True)
+        return str(experiments_filepath)
+    
+    def start_event(self):
+        return super().start_event()
+    
+    def stop_event(self):
+        return super().stop_event()
+    
+    def kernel_finished(self):
+        super().kernel_finished()
+        return True
+    
+    def synchronize(self):
+        return super().synchronize()
+    
+    def run_kernel(self, func, gpu_args=None, threads=None, grid=None, stream=None):
+        # generate the experiments file
+        experiments_filepath = Path(func)
+
+        # run the methodology to get a fitness score for this configuration
+        scores = get_strategy_scores(str(experiments_filepath))
+        self.last_score = scores[list(scores.keys())[0]]['score']
+    
+    def memset(self, allocation, value, size):
+        return super().memset(allocation, value, size)
+    
+    def memcpy_dtoh(self, dest, src):
+        return super().memcpy_dtoh(dest, src)
+    
+    def memcpy_htod(self, dest, src):
+        return super().memcpy_htod(dest, src)

{kernel_tuner-1.1.2 → kernel_tuner-1.2.0}/kernel_tuner/backends/pycuda.py

@@ -106,7 +106,7 @@ class PyCudaFunctions(GPUBackend):
         )
         if cc == "00":
             cc = self.context.get_device().compute_capability()
-        self.cc = str(cc[0]) + str(cc[1])
+        self.cc = str(cc)
         self.iterations = iterations
         self.current_module = None
         self.func = None
@@ -180,6 +180,9 @@ class PyCudaFunctions(GPUBackend):
             # pycuda does not support bool, convert to uint8 instead
             elif isinstance(arg, np.bool_):
                 gpu_args.append(arg.astype(np.uint8))
+            # pycuda does not support 16-bit formats, view them as uint16
+            elif isinstance(arg, np.generic) and str(arg.dtype) in ("float16", "bfloat16"):
+                gpu_args.append(arg.view(np.uint16))
             # if not an array, just pass argument along
             else:
                 gpu_args.append(arg)