Merge with recent additions to searchspace_experiments

fjwillemsen · fjwillemsen · commit 26914be2ad7a · 2025-04-03T18:36:01.000+02:00
diff --git a/INSTALL.rst b/INSTALL.rst
@@ -125,7 +125,7 @@ Or you could install Kernel Tuner and PyOpenCL together if you haven't done so a
 If this fails, please see the PyOpenCL installation guide (https://wiki.tiker.net/PyOpenCL/Installation)
 
 HIP and HIP Python
--------------
+------------------
 
 Before we can install HIP Python, you'll need to have the HIP runtime and compiler installed on your system.
 The HIP compiler is included as part of the ROCm software stack. Here is AMD's installation guide:
diff --git a/doc/requirements.txt b/doc/requirements.txt
diff --git a/doc/requirements_test.txt b/doc/requirements_test.txt
diff --git a/doc/source/architecture.png b/doc/source/architecture.png
diff --git a/doc/source/design.rst b/doc/source/design.rst
@@ -89,14 +89,8 @@ kernel_tuner.runners.sequential.SimulationRunner
     :members:
 
 
-Device Interfaces
------------------
-
-kernel_tuner.core.DeviceInterface
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-.. autoclass:: kernel_tuner.core.DeviceInterface
-    :special-members: __init__
-    :members:
+Backends
+--------
 
 kernel_tuner.backends.pycuda.PyCudaFunctions
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
diff --git a/kernel_tuner/backends/hip.py b/kernel_tuner/backends/hip.py
@@ -104,6 +104,7 @@ def __init__(self, device=0, iterations=7, compiler_options=None, observers=None
 
     def ready_argument_list(self, arguments):
         """Ready argument list to be passed to the HIP function.
+
         :param arguments: List of arguments to be passed to the HIP function.
             The order should match the argument list on the HIP function.
             Allowed values are np.ndarray, and/or np.int32, np.float32, and so on.
diff --git a/kernel_tuner/interface.py b/kernel_tuner/interface.py
@@ -598,8 +598,8 @@ def tune_kernel(
     # check for forbidden names in tune parameters
     util.check_tune_params_list(tune_params, observers, simulation_mode=simulation_mode)
 
-    # check whether block_size_names are used as expected
-    util.check_block_size_params_names_list(block_size_names, tune_params)
+    # check whether block_size_names are used
+    block_size_names = util.check_block_size_params_names_list(block_size_names, tune_params)
 
     # ensure there is always at least three names
     util.append_default_block_size_names(block_size_names)
@@ -691,8 +691,17 @@ def preprocess_cache(filepath):
     if verbose:
         print(f"Searchspace has {searchspace.size} configurations after restrictions.")
 
-    # call the strategy to execute the tuning process
+    # register the times and raise an exception if the budget is exceeded
+    if "time_limit" in tuning_options:
+        tuning_options["startup_time"] = perf_counter() - start_overhead_time
+        if tuning_options["startup_time"] > tuning_options["time_limit"]:
+            raise RuntimeError(
+                f"The startup time of the tuning process ({tuning_options['startup_time']} seconds) has exceeded the time limit ({tuning_options['time_limit']} seconds). "
+                "Please increase the time limit or decrease the size of the search space."
+            )
     tuning_options["start_time"] = perf_counter()
+
+    # call the strategy to execute the tuning process
     results = strategy.tune(searchspace, runner, tuning_options)
     env = runner.get_environment(tuning_options)
 
diff --git a/kernel_tuner/observers/powersensor.py b/kernel_tuner/observers/powersensor.py
@@ -12,7 +12,7 @@
 class PowerSensorObserver(BenchmarkObserver):
     """Observer that an external PowerSensor2 device to accurately measure power
 
-    Requires PowerSensor2 hardware and powersensor Python bindings.
+    Requires PowerSensor3 hardware and powersensor Python bindings.
 
     :param observables: A list of string, containing any of "ps_energy" or "ps_power".
         To measure energy in Joules or power consumption in Watt.
@@ -51,9 +51,8 @@ def after_finish(self):
             )  # Joules
             self.results["ps_energy"].append(ps_measured_e)
         if "ps_power" in self.observables:
-            ps_measured_t = (
-                    end_state.time_at_read - self.begin_state.time_at_read
-            )  # seconds
+            ps_measured_t = ((end_state.time_at_read - self.begin_state.time_at_read).microseconds / 1e6)    # Seconds
+
             self.results["ps_power"].append(ps_measured_e / ps_measured_t)  # Watt
 
     def get_results(self):
diff --git a/kernel_tuner/util.py b/kernel_tuner/util.py
@@ -194,8 +194,8 @@ def check_stop_criterion(to):
     """Checks if max_fevals is reached or time limit is exceeded."""
     if "max_fevals" in to and len(to.unique_results) >= to.max_fevals:
         raise StopCriterionReached(f"max_fevals reached ({len(to.unique_results)} >= {to.max_fevals})")
-    if "time_limit" in to and (((time.perf_counter() - to.start_time) + (to.simulated_time * 1e-3)) > to.time_limit):
-        raise StopCriterionReached(f"time limit ({to.time_limit}) exceeded")
+    if "time_limit" in to and (((time.perf_counter() - to.start_time) + (to.simulated_time * 1e-3) + to.startup_time) > to.time_limit):
+        raise StopCriterionReached("time limit exceeded")
 
 
 def check_tune_params_list(tune_params, observers, simulation_mode=False):
@@ -236,11 +236,22 @@ def check_block_size_params_names_list(block_size_names, tune_params):
                     "Block size name " + name + " is not specified in the tunable parameters list!", UserWarning
                 )
     else:  # if default block size names are used
-        if not any([k in default_block_size_names for k in tune_params.keys()]):
+        if not any([k.lower() in default_block_size_names for k in tune_params.keys()]):
             warnings.warn(
                 "None of the tunable parameters specify thread block dimensions!",
                 UserWarning,
             )
+        else:
+            # check for alternative case spelling of defaults such as BLOCK_SIZE_X or block_Size_X etc
+            result = []
+            for k in tune_params.keys():
+                if k.lower() in default_block_size_names and k not in default_block_size_names:
+                    result.append(k)
+            # ensure order of block_size_names is correct regardless of case used
+            block_size_names = sorted(result, key=str.casefold)
+
+    return block_size_names
+
 
 
 def check_restriction(restrict, params: dict) -> bool:
diff --git a/pyproject.toml b/pyproject.toml
@@ -5,7 +5,7 @@ build-backend = "poetry.core.masonry.api"
 [project]
 name = "kernel_tuner"
 description = "An easy to use CUDA/OpenCL kernel tuner in Python"
-version = "1.2.0" # adhere to PEP440 versioning: https://packaging.python.org/en/latest/guides/distributing-packages-using-setuptools/#id55
+version = "1.3.0" # adhere to PEP440 versioning: https://packaging.python.org/en/latest/guides/distributing-packages-using-setuptools/#id55
 readme = "README.md"
 license = "Apache-2.0"
 authors = [
@@ -48,13 +48,13 @@ classifiers = [
 ]
 
 # ATTENTION: if anything is changed here, run `poetry update`
-requires-python = ">=3.10,<4" # <4 is because of hip-python-fork  # NOTE when changing the Python versions, also change the test versions in the Noxfile and GitHub Actions
+requires-python = ">=3.10,<4" # <4 is because of hip-python  # NOTE when changing the Python versions, also change the test versions in the Noxfile and GitHub Actions
 dependencies = [
     "numpy (>=1.26.0,<2.0.0)",    # Python 3.12 requires numpy at least 1.26, CuPy does not support 2.0
     "scipy>=1.14.1",
     "packaging",        # required by file_utils
     "jsonschema",
-    "python-constraint2>=2.2.0",
+    "python-constraint2>=2.2.2",
     "xmltodict",
     "pandas>=2.0.0",
     "scikit-learn>=1.0.2",
@@ -83,11 +83,20 @@ include = [
 # cupy-cuda11x = { version = "*", optional = true }    # NOTE: these are completely optional dependencies as described in CONTRIBUTING.rst
 # cupy-cuda12x = { version = "*", optional = true }
 # cuda-python = { version = "*", optional = true }
+
+[[tool.poetry.source]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+priority = "explicit"
+
+[tool.poetry.dependencies]
+hip-python = { version = "^6.3.3.540.31", source = "testpypi", optional = true }  # Note: when released, switch this package to pypi and remove tool.poetry.source and move this to [project.optional-dependencies]
+
 [project.optional-dependencies]
 cuda = ["pycuda>=2025.1", "nvidia-ml-py>=12.535.108", "pynvml>=11.4.1"] # Attention: if pycuda is changed here, also change `session.install("pycuda")` in the Noxfile
 opencl = ["pyopencl"]                                                   # Attention: if pyopencl is changed here, also change `session.install("pyopencl")` in the Noxfile
 cuda_opencl = ["pycuda>=2024.1", "pyopencl"]                            # Attention: if pycuda is changed here, also change `session.install("pycuda")` in the Noxfile
-hip = ["hip-python-fork"]
+hip = ["hip-python"]
 tutorial = ["jupyter>=1.0.0", "matplotlib>=3.5.0", "nvidia-ml-py>=12.535.108"]
 
 # ATTENTION: if anything is changed here, run `poetry update` and `poetry export --with docs --without-hashes --format=requirements.txt --output doc/requirements.txt`
diff --git a/test/test_compiler_functions.py b/test/test_compiler_functions.py
@@ -1,21 +1,21 @@
-from datetime import datetime
 
-import numpy as np
 import ctypes as C
+
+import numpy as np
 import pytest
 from pytest import raises
 
 try:
-    from mock import patch, Mock
+    from mock import Mock, patch
 except ImportError:
-    from unittest.mock import patch, Mock
+    from unittest.mock import Mock, patch
 
 import kernel_tuner
-from kernel_tuner.backends.compiler import CompilerFunctions, Argument, is_cupy_array, get_array_module
-from kernel_tuner.core import KernelSource, KernelInstance
+from kernel_tuner.backends.compiler import Argument, CompilerFunctions, get_array_module, is_cupy_array
+from kernel_tuner.core import KernelInstance, KernelSource
 from kernel_tuner.util import delete_temp_file
 
-from .context import skip_if_no_gfortran, skip_if_no_gcc, skip_if_no_openmp, skip_if_no_cupy
+from .context import skip_if_no_cupy, skip_if_no_gcc, skip_if_no_gfortran, skip_if_no_openmp
 from .test_runners import env as cuda_env  # noqa: F401
 
 
diff --git a/test/test_time_budgets.py b/test/test_time_budgets.py
@@ -0,0 +1,77 @@
+from itertools import product
+from time import perf_counter
+
+import numpy as np
+import pytest
+from pytest import raises
+
+from kernel_tuner import tune_kernel
+
+from .context import skip_if_no_gcc
+
+
+@pytest.fixture
+def env():
+    kernel_name = "vector_add"
+    kernel_string = """
+        #include <time.h>
+
+        float vector_add(float *c, float *a, float *b, int n) {
+            struct timespec start, end;
+            clock_gettime(CLOCK_MONOTONIC, &start);
+            
+            for (int i = 0; i < n; i++) {
+                c[i] = a[i] + b[i];
+            }
+            
+            clock_gettime(CLOCK_MONOTONIC, &end);
+            double elapsed = (end.tv_sec - start.tv_sec) * 1e3 + (end.tv_nsec - start.tv_nsec) / 1e6;
+            return (float) elapsed;
+        }"""
+
+    size = 100
+    a = np.random.randn(size).astype(np.float32)
+    b = np.random.randn(size).astype(np.float32)
+    c = np.zeros_like(b)
+    n = np.int32(size)
+
+    args = [c, a, b, n]
+    tune_params = {"nthreads": [1, 2, 4]}
+
+    return kernel_name, kernel_string, size, args, tune_params
+
+
+@skip_if_no_gcc
+def test_no_time_budget(env):
+    """Ensure that a RuntimeError is raised if the startup takes longer than the time budget."""
+    with raises(RuntimeError, match='startup time of the tuning process'):
+        tune_kernel(*env, strategy="random_sample", strategy_options={"strategy": "random_sample", "time_limit": 0.0})
+
+@skip_if_no_gcc
+def test_some_time_budget(env):
+    """Ensure that the time limit is respected."""
+    time_limit = 1.0
+    kernel_name, kernel_string, size, args, tune_params = env
+    tune_params["bogus"] = list(range(1000))
+    env = kernel_name, kernel_string, size, args, tune_params
+
+    # Ensure that if the tuning takes longer than the time budget, the results are returned early.
+    start_time = perf_counter()
+    res, _ = tune_kernel(*env, strategy="random_sample", strategy_options={"time_limit": time_limit})
+
+    # Ensure that there are at least some results, but not all.
+    size_all = len(list(product(*tune_params.values())))
+    assert 0 < len(res) < size_all
+
+    # Ensure that the time limit was respected by some margin.
+    assert perf_counter() - start_time < time_limit * 2
+
+@skip_if_no_gcc
+def test_full_time_budget(env):
+    """Ensure that given ample time budget, the entire space is explored."""
+    res, _ = tune_kernel(*env, strategy="brute_force", strategy_options={"time_limit": 10.0})
+
+    # Ensure that the entire space is explored.
+    tune_params = env[-1]
+    size_all = len(list(product(*tune_params.values())))
+    assert len(res) == size_all
