kernel-tuner 1.3.3__tar.gz → 1.4.0__tar.gz

{kernel_tuner-1.3.3 → kernel_tuner-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kernel_tuner
-Version: 1.3.3
+Version: 1.4.0
 Summary: An easy to use CUDA/OpenCL kernel tuner in Python
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -30,6 +30,8 @@ Provides-Extra: cuda-opencl
 Provides-Extra: hip
 Provides-Extra: opencl
 Provides-Extra: tutorial
+Requires-Dist: cuda-python (>=12.6.0) ; extra == "cuda"
+Requires-Dist: cuda-python (>=12.6.0) ; extra == "cuda-opencl"
 Requires-Dist: hip-python ; extra == "hip"
 Requires-Dist: jsonschema
 Requires-Dist: jupyter (>=1.0.0) ; extra == "tutorial"
@@ -39,8 +41,7 @@ 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) ; extra == "cuda-opencl"
-Requires-Dist: pycuda (>=2025.1) ; extra == "cuda"
+Requires-Dist: pymoo (>=0.6.1.6)
 Requires-Dist: pynvml (>=11.4.1) ; extra == "cuda"
 Requires-Dist: pyopencl ; extra == "cuda-opencl"
 Requires-Dist: pyopencl ; extra == "opencl"

kernel_tuner-1.4.0/kernel_tuner/__init__.py

@@ -0,0 +1,22 @@
+from importlib.metadata import version
+
+from kernel_tuner.interface import run_kernel, tune_kernel, tune_kernel_T1, tune_cache
+
+__version__ = version(__package__)
+
+__all__ = [
+    "create_device_targets",
+    "run_kernel",
+    "store_results",
+    "tune_kernel",
+    "tune_cache",
+    "tune_kernel_T1",
+    "__version__",
+]
+
+
+def __getattr__(name):
+    if name in ("store_results", "create_device_targets"):
+        from kernel_tuner import integration
+        return getattr(integration, name)
+    raise AttributeError(f"module 'kernel_tuner' has no attribute {name!r}")

{kernel_tuner-1.3.3 → kernel_tuner-1.4.0}/kernel_tuner/backends/cupy.py

@@ -2,6 +2,7 @@
 from __future__ import print_function
 
 import numpy as np
+import uuid
 
 from kernel_tuner.backends.backend import GPUBackend
 from kernel_tuner.observers.cupy import CupyRuntimeObserver
@@ -61,28 +62,33 @@ class CupyFunctions(GPUBackend):
         # default dynamically allocated shared memory size, can be overwritten using smem_args
         self.smem_size = 0
 
-        # setup observers
-        self.observers = observers or []
-        self.observers.append(CupyRuntimeObserver(self))
-        for obs in self.observers:
-            obs.register_device(self)
-
         # collect environment information
         env = dict()
         cupy_info = str(get_runtime_info()).split("\n")[:-1]
         info_dict = {
-            s.split(":")[0].strip(): s.split(":")[1].strip() for s in cupy_info
+            s.split(":", 1)[0].strip(): s.split(":", 1)[1].strip() for s in cupy_info
         }
         env["device_name"] = info_dict[f"Device {device} Name"]
+        env["pci_bus_id"] = info_dict[f"Device {device} PCI Bus ID"]
 
         env["cuda_version"] = cp.cuda.runtime.driverGetVersion()
         env["compute_capability"] = self.cc
         env["iterations"] = self.iterations
         env["compiler_options"] = compiler_options
         env["device_properties"] = self.devprops
+
+        props = cp.cuda.runtime.getDeviceProperties(device)
+        env["uuid"] = str(uuid.UUID(bytes=props["uuid"]))
+
         self.env = env
         self.name = env["device_name"]
 
+        # setup observers
+        self.observers = observers or []
+        self.observers.append(CupyRuntimeObserver(self))
+        for obs in self.observers:
+            obs.register_device(self)
+
     def ready_argument_list(self, arguments):
         """Ready argument list to be passed to the kernel, allocates gpu mem.
 

{kernel_tuner-1.3.3 → kernel_tuner-1.4.0}/kernel_tuner/backends/hip/hip.py

@@ -3,6 +3,8 @@
 import ctypes
 import ctypes.util
 import logging
+import json
+import uuid
 
 import numpy as np
 
@@ -32,8 +34,35 @@ dtype_map = {
 
 hipSuccess = 0
 
+
+def extract_safe_properties(props):
+    """Extract those properties that are 'safe' (i.e, json serializable)"""
+    result = dict()
+
+    for key in props.PROPERTIES():
+        try:
+            value = getattr(props, key)
+            if isinstance(value, (str, int, float)):
+                # These are safe
+                result[key] = value
+            elif isinstance(value, (bytes, bytearray)):
+                # bytes/bytearray is typically a string
+                result[key] = value.decode("utf-8").rstrip("\x00")
+            else:
+                # As last option, try to convert to json
+                result[key] = json.loads(json.dumps(value))
+        except Exception:
+            continue
+
+    # Remove the 'reserved' fields as they are just filled with zeros
+    result.pop("reserved", None)
+    result.pop("hipReserved", None)
+
+    return result
+
+
 class HipFunctions(GPUBackend):
-    """Class that groups the HIP functions on maintains state about the device."""
+    """Class that groups the HIP functions and maintains state about the device."""
 
     def __init__(self, device=0, iterations=7, compiler_options=None, observers=None):
         """Instantiate HipFunctions object used for interacting with the HIP device.
@@ -72,6 +101,13 @@ class HipFunctions(GPUBackend):
         env["device_name"] = self.name
         env["iterations"] = self.iterations
         env["compiler_options"] = compiler_options
+        env["pci_bus_id"] = props.pciBusID
+        env["pci_domain_id"] = props.pciDomainID
+        env["pci_device_id"] = props.pciDeviceID
+        env["uuid"] = str(uuid.UUID(bytes=props.uuid.bytes))
+        env["hip_driver_version"] = hip_check(hip.hipDriverGetVersion())
+        env["hip_runtime_version"] = hip_check(hip.hipRuntimeGetVersion())
+        env["device_properties"] = extract_safe_properties(props)
         self.env = env
 
         # Create stream and events
@@ -149,13 +185,16 @@ class HipFunctions(GPUBackend):
         # Format kernel string
         kernel_string = kernel_instance.kernel_string
         kernel_name = kernel_instance.name
-        if 'extern "C"' not in kernel_string:
-            kernel_string = 'extern "C" {\n' + kernel_string + "\n}"
+        expression_name = kernel_name.encode()
 
         # Create program
         prog = hip_check(hiprtc.hiprtcCreateProgram(kernel_string.encode(), kernel_name.encode(), 0, [], []))
 
         try:
+            # Add the kernel as an expression. This forces hiprtc to instantiate the kernel if it
+            # is templated or if it is in a namespace.
+            hip_check(hiprtc.hiprtcAddNameExpression(prog, expression_name))
+
             # Get device properties
             props = hip.hipDeviceProp_t()
             hip_check(hip.hipGetDeviceProperties(props, 0))
@@ -174,6 +213,10 @@ class HipFunctions(GPUBackend):
                 hip_check(hiprtc.hiprtcGetProgramLog(prog, log))
                 raise RuntimeError(log.decode())
 
+            # Get the lowered name. This is the name that can be used in hipModuleGetFunction to
+            # get the kernel. For templated kernels, this differs from the original kernel name.
+            lowered_name = hip_check(hiprtc.hiprtcGetLoweredName(prog, expression_name))
+
             # Get compiled code
             code_size = hip_check(hiprtc.hiprtcGetCodeSize(prog))
             code = bytearray(code_size)
@@ -182,7 +225,7 @@ class HipFunctions(GPUBackend):
             # Load module and get function
             module = hip_check(hip.hipModuleLoadData(code))
             self.current_module = module
-            kernel = hip_check(hip.hipModuleGetFunction(module, kernel_name.encode()))
+            kernel = hip_check(hip.hipModuleGetFunction(module, lowered_name))
 
         except Exception as e:
             # Cleanup

{kernel_tuner-1.3.3 → kernel_tuner-1.4.0}/kernel_tuner/backends/nvcuda.py

@@ -2,11 +2,13 @@
 from warnings import warn
 
 import numpy as np
+import uuid
+import os
 
 from kernel_tuner.backends.backend import GPUBackend
 from kernel_tuner.observers.nvcuda import CudaRuntimeObserver
 from kernel_tuner.util import SkippableFailure
-from kernel_tuner.utils.nvcuda import cuda_error_check, to_valid_nvrtc_gpu_arch_cc
+from kernel_tuner.utils.nvcuda import cuda_error_check, to_valid_nvrtc_gpu_arch_cc, find_cuda_home, _check
 
 # embedded in try block to be able to generate documentation
 # and run tests without cuda-python installed
@@ -74,9 +76,6 @@ class CudaFunctions(GPUBackend):
         self.current_module = None
         self.func = None
         self.compiler_options = compiler_options or []
-        self.compiler_options_bytes = []
-        for option in self.compiler_options:
-            self.compiler_options_bytes.append(str(option).encode("UTF-8"))
 
         # create a stream and events
         err, self.stream = driver.cuStreamCreate(0)
@@ -85,34 +84,119 @@ class CudaFunctions(GPUBackend):
         cuda_error_check(err)
         err, self.end = driver.cuEventCreate(0)
         cuda_error_check(err)
+        self.current_sm_percentage = 100
+        self.green_ctx_cache = {}
+        self.green_ctx = None
 
         # default dynamically allocated shared memory size, can be overwritten using smem_args
         self.smem_size = 0
 
-        # setup observers
-        self.observers = observers or []
-        self.observers.append(CudaRuntimeObserver(self))
-        for observer in self.observers:
-            observer.register_device(self)
-
         # collect environment information
         err, device_properties = runtime.cudaGetDeviceProperties(device)
         cuda_error_check(err)
         env = dict()
+        env["uuid"] = str(uuid.UUID(bytes=device_properties.uuid.bytes))
         env["device_name"] = device_properties.name.decode()
         env["cuda_version"] = driver.CUDA_VERSION
         env["compute_capability"] = self.cc
         env["iterations"] = self.iterations
         env["compiler_options"] = self.compiler_options
         env["device_properties"] = str(device_properties).replace("\n", ", ")
+
+        # We must use `cudaDeviceGetPCIBusId` to get the PCI bus string
+        # It returns a series of bytes containing a null byte, not a `str`
+        err, pci_bus = runtime.cudaDeviceGetPCIBusId(32, device) # 32 = length?
+        cuda_error_check(err)
+        env["pci_bus_id"] = pci_bus.decode("ascii").split("\x00", 1)[0]
+
         self.env = env
         self.name = env["device_name"]
 
+        # setup observers
+        self.observers = observers or []
+        self.observers.append(CudaRuntimeObserver(self))
+        for observer in self.observers:
+            observer.register_device(self)
+
     def __del__(self):
+        # Cleanup streams and green contexts, if any
+        if self.green_ctx_cache:
+            for val in self.green_ctx_cache.values():
+                green_ctx, stream, _ = val
+                _check(driver.cuStreamDestroy(stream))
+                _check(driver.cuGreenCtxDestroy(green_ctx))
+
+        # Cleanup
         for device_memory in self.allocations:
             if isinstance(device_memory, driver.CUdeviceptr):
-                err = driver.cuMemFree(device_memory)
-                cuda_error_check(err)
+                _check(driver.cuMemFree(device_memory))
+
+
+    def set_sm_percentage(self, sm_percentage):
+        """ Set the active SM percentage
+
+        Create a CUDA green context owning ~`sm_percentage` of the device's SMs
+        and a stream bound to it. Kernels launched afterwards are restricted
+        to that SM partition. Green contexts are cached in self.green_ctx_cache.
+        The actual number of SMs in the partition may not exactly match the
+        requested percentage. An observer may be used to query:
+
+         *   Currently assigned number of SMs: self.assigned_sm_count
+         *   Currently requested SM percentage: self.current_sm_percentage
+
+        Requires: CUDA >= 12.4 and a GPU that supports SM partitioning.
+        """
+
+        if not 0 < sm_percentage <= 100:
+            raise ValueError("sm_percentage must be in (0, 100]")
+
+        # Check if sm_percentage is already applied
+        if sm_percentage == self.current_sm_percentage:
+            return
+
+        # Check if this sm_percentage has been requested before
+        if sm_percentage in self.green_ctx_cache:
+            self.green_ctx, self.stream, self.assigned_sm_count = self.green_ctx_cache[sm_percentage]
+            self.current_sm_percentage = sm_percentage
+            return
+
+        # Get total SMs and desired percentage
+        total_sms = _check(driver.cuDeviceGetAttribute(
+            driver.CUdevice_attribute.CU_DEVICE_ATTRIBUTE_MULTIPROCESSOR_COUNT, self.device))
+        want = max(1, round(total_sms * sm_percentage / 100.0))
+
+        # Full SM resource pool of the device.
+        sm_resource = _check(driver.cuDeviceGetDevResource(
+            self.device, driver.CUdevResourceType.CU_DEV_RESOURCE_TYPE_SM))
+
+        # Split off one group of at least `want` SMs. The driver rounds up to the
+        # device's partitioning granularity, so the actual count may be larger.
+        groups, _nb, _remaining = _check(driver.cuDevSmResourceSplitByCount(
+            1,            # number of groups requested
+            sm_resource,  # input resource
+            0,            # useFlags (0 = default)
+            want,         # minCount of SMs per group
+        ))
+        group = groups[0]
+        assigned = group.sm.smCount
+
+        # Descriptor -> green context.
+        desc = _check(driver.cuDevResourceGenerateDesc([group], 1))
+        green_ctx = _check(driver.cuGreenCtxCreate(
+            desc, self.device, driver.CUgreenCtxCreate_flags.CU_GREEN_CTX_DEFAULT_STREAM))
+
+        # A stream from the green context confines launches to its SMs.
+        stream = _check(driver.cuGreenCtxStreamCreate(
+            green_ctx,
+            driver.CUstream_flags.CU_STREAM_NON_BLOCKING,
+            0,  # priority
+        ))
+        self.green_ctx_cache[sm_percentage] = (green_ctx, stream, assigned)
+        self.green_ctx = green_ctx
+        self.stream = stream
+        self.assigned_sm_count = assigned
+        self.current_sm_percentage = sm_percentage
+
 
     def ready_argument_list(self, arguments):
         """Ready argument list to be passed to the kernel, allocates gpu mem.
@@ -139,6 +223,7 @@ class CudaFunctions(GPUBackend):
                 gpu_args.append(arg)
         return gpu_args
 
+
     def compile(self, kernel_instance):
         """Call the CUDA compiler to compile the kernel, return the device function.
 
@@ -154,37 +239,60 @@ class CudaFunctions(GPUBackend):
         """
         kernel_string = kernel_instance.kernel_string
         kernel_name = kernel_instance.name
+        expression_name = str.encode(kernel_name)
+        compiler_options = list(self.compiler_options)
+
+        # Add -std=c++11
+        if not any(opt.startswith(("-std=", "--std=")) for opt in self.compiler_options):
+            compiler_options.append("--std=c++11")
 
-        # mimic pycuda behavior to wrap kernel_string in extern "C" if not in kernel_string already
-        if 'extern "C"' not in kernel_string:
-            kernel_string = 'extern "C" {\n' + kernel_string + "\n}"
+        # Add -arch
+        if not any(opt.startswith(("-arch", "--arch", "--gpu-architecture=")) for opt in self.compiler_options):
+            arch_val = to_valid_nvrtc_gpu_arch_cc(self.cc)
+            compiler_options.append(f"--gpu-architecture=compute_{arch_val}")
 
-        compiler_options = self.compiler_options_bytes
-        if not any([b"--std=" in opt for opt in compiler_options]):
-            compiler_options.append(b"--std=c++11")
-        if not any(["--std=" in opt for opt in self.compiler_options]):
-            self.compiler_options.append("--std=c++11")
-        if not any([b"--gpu-architecture=" in opt or b"-arch" in opt for opt in compiler_options]):
-            compiler_options.append(f"--gpu-architecture=compute_{to_valid_nvrtc_gpu_arch_cc(self.cc)}".encode("UTF-8"))
-        if not any(["--gpu-architecture=" in opt or "-arch" in opt for opt in self.compiler_options]):
-            self.compiler_options.append(f"--gpu-architecture=compute_{to_valid_nvrtc_gpu_arch_cc(self.cc)}")
+        # Add CUDA home to include path
+        cuda_home = find_cuda_home()
+        if cuda_home:
+            cuda_include = os.path.join(cuda_home, "include")
+            compiler_options.append(f"-I{cuda_include}")
+
+        # nvrtcCompileProgram requires bytes instead of str
+        compiler_options = [str(opt).encode("UTF-8") for opt in compiler_options]
 
         err, program = nvrtc.nvrtcCreateProgram(str.encode(kernel_string), b"CUDAProgram", 0, [], [])
         try:
+            # Add the kernel as an expression. This is necessary for templated kernels to ensure that the
+            # compiler actually instantiates the kernel that we want to compile.
+            cuda_error_check(err)
+            err = nvrtc.nvrtcAddNameExpression(program, expression_name)
+
+            # Compile the program
             cuda_error_check(err)
             err = nvrtc.nvrtcCompileProgram(program, len(compiler_options), compiler_options)
+
+            # Get the PTX
             cuda_error_check(err)
             err, size = nvrtc.nvrtcGetPTXSize(program)
             cuda_error_check(err)
             buff = b" " * size
             err = nvrtc.nvrtcGetPTX(program, buff)
             cuda_error_check(err)
+
+            # Load the module
             err, self.current_module = driver.cuModuleLoadData(np.char.array(buff))
             if err == driver.CUresult.CUDA_ERROR_INVALID_PTX:
                 raise SkippableFailure("uses too much shared data")
             else:
                 cuda_error_check(err)
-            err, self.func = driver.cuModuleGetFunction(self.current_module, str.encode(kernel_name))
+
+            # First, get the "lowered" name of the kernel (i.e., the name inside the PTX).
+            # After, we can use the lowered name to lookup the kernel in the module.
+            err, lowered_name = nvrtc.nvrtcGetLoweredName(program, expression_name)
+            cuda_error_check(err)
+            err, self.func = driver.cuModuleGetFunction(
+                self.current_module, lowered_name
+            )
             cuda_error_check(err)
 
             # get the number of registers per thread used in this kernel

{kernel_tuner-1.3.3 → kernel_tuner-1.4.0}/kernel_tuner/backends/pycuda.py

@@ -130,15 +130,10 @@ class PyCudaFunctions(GPUBackend):
         # default dynamically allocated shared memory size, can be overwritten using smem_args
         self.smem_size = 0
 
-        # setup observers
-        self.observers = observers or []
-        self.observers.append(PyCudaRuntimeObserver(self))
-        for obs in self.observers:
-            obs.register_device(self)
-
         # collect environment information
         env = dict()
         env["device_name"] = self.context.get_device().name()
+        env["pci_bus_id"] = self.context.get_device().pci_bus_id()
         env["cuda_version"] = ".".join([str(i) for i in drv.get_version()])
         env["compute_capability"] = self.cc
         env["iterations"] = self.iterations
@@ -147,6 +142,12 @@ class PyCudaFunctions(GPUBackend):
         self.env = env
         self.name = env["device_name"]
 
+        # setup observers
+        self.observers = observers or []
+        self.observers.append(PyCudaRuntimeObserver(self))
+        for obs in self.observers:
+            obs.register_device(self)
+
     def __del__(self):
         for gpu_mem in self.allocations:
             # if needed for when using mocks during testing