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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kernel_tuner
-Version: 1.3.3
+Version: 1.5.0
 Summary: An easy to use CUDA/OpenCL kernel tuner in Python
 License-Expression: Apache-2.0
 License-File: LICENSE
@@ -25,13 +25,19 @@ 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: Programming Language :: Python :: 3.14
 Provides-Extra: cuda
 Provides-Extra: cuda-opencl
 Provides-Extra: hip
+Provides-Extra: julia
 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: juliacall (>=0.9.31) ; extra == "julia"
+Requires-Dist: juliapkg (>=0.1.23) ; extra == "julia"
 Requires-Dist: jupyter (>=1.0.0) ; extra == "tutorial"
 Requires-Dist: matplotlib (>=3.5.0) ; extra == "tutorial"
 Requires-Dist: numpy (>=2.0.0)
@@ -39,12 +45,11 @@ 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"
-Requires-Dist: python-constraint2 (>=2.4.0)
+Requires-Dist: python-constraint2 (>=2.5.0)
 Requires-Dist: scikit-learn (>=1.0.2)
 Requires-Dist: scipy (>=1.14.1)
 Requires-Dist: xmltodict

kernel_tuner-1.5.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.5.0}/kernel_tuner/accuracy.py

@@ -1,19 +1,25 @@
+"""Module for accuracy measurement and tunable parameters."""
+
+import logging
+import re
 from collections import UserDict
 from typing import Dict
+
 import numpy as np
-import logging
-import re
 
 from kernel_tuner.observers import OutputObserver
 
 
 class Tunable(UserDict):
+    """``Tunable`` can be used as a parameter value dependent input argument when tuning kernels."""
+
     def __init__(self, param_key: str, arrays: Dict):
-        """The ``Tunable`` object can be used as an input argument when tuning
-        kernels. It is a container that holds several arrays internally and
+        """The ``Tunable`` object can be used as an input argument when tuning kernels.
+
+        It is a container that holds several arrays internally and
         selects one array during benchmarking based on the value of a tunable parameter.
 
-        Example
+        Example:
         -------
         Consider this example::
 
@@ -37,6 +43,7 @@ class Tunable(UserDict):
         self.param_key = param_key
 
     def select_for_configuration(self, params):
+        """Select the array for the given configuration."""
         if callable(self.param_key):
             option = self.param_key(params)
         elif self.param_key in params:
@@ -45,14 +52,16 @@ class Tunable(UserDict):
             option = eval(self.param_key, params, params)
 
         if option not in self.data:
-            list = ", ".join(map(str, self.data.keys()))
-            raise KeyError(
-                f"'{option}' is not a valid parameter value, should be one of: {list}"
-            )
+            raise KeyError(f"'{option}' is not a valid parameter value, should be one of: {', '.join(map(str, self.data.keys()))}")
 
-        return self.data[option]
+        # continue recursively until we find a non-Tunable
+        el = self.data[option]
+        if isinstance(el, Tunable):
+            return el.select_for_configuration(params)
+        else:
+            return el
 
-    def __call__(self, params):
+    def __call__(self, params):  # noqa: D102
         return self.select_for_configuration(params)
 
 
@@ -70,6 +79,7 @@ def _find_bfloat16_if_available():
     if dtype is None:
         try:
             from ml_dtypes import bfloat16
+
             dtype = bfloat16
         except ImportError:
             pass
@@ -78,6 +88,7 @@ def _find_bfloat16_if_available():
     if dtype is None:
         try:
             from jax.numpy import bfloat16
+
             dtype = bfloat16
         except ImportError:
             pass
@@ -86,6 +97,7 @@ def _find_bfloat16_if_available():
     if dtype is None:
         try:
             from tensorflow import bfloat16
+
             dtype = bfloat16.as_numpy_dtype
         except ImportError:
             pass
@@ -100,9 +112,9 @@ def _find_bfloat16_if_available():
 
 
 def _to_float_dtype(x: str) -> np.dtype:
-    """Convert a string to a numpy data type (``dtype``). This function recognizes
-    common names (such as ``f16`` or ``kfloat``), and uses ``np.dtype(x)`` as a
-    fallback.
+    """Convert a string to a numpy data type (``dtype``).
+
+    This function recognizes common names (such as ``f16`` or ``kfloat``), and uses ``np.dtype(x)`` as a fallback.
     """
     if isinstance(x, str):
         x = x.lower()
@@ -123,16 +135,17 @@ def _to_float_dtype(x: str) -> np.dtype:
 
 
 class TunablePrecision(Tunable):
-    def __init__(
-        self, param_key: str, array: np.ndarray, dtypes: Dict[str, np.dtype] = None
-    ):
-        """The ``Tunable`` object can be used as an input argument when tuning
-        kernels. It is a container that internally holds several arrays
+    """``TunablePrecision`` can be used as a precision-level dependent input argument when tuning kernels."""
+
+    def __init__(self, param_key: str, array: np.ndarray, dtypes: Dict[str, np.dtype] = None):
+        """The ``Tunable`` object can be used as an input argument when tuning kernels.
+
+        It is a container that internally holds several arrays
         containing the same data, but stored in using different levels of
         precision. During benchamrking, one array is selected based on the value
         of the tunable parameter called ``param_key``.
 
-        Example
+        Example:
         -------
         Consider this example::
 
@@ -156,7 +169,6 @@ class TunablePrecision(Tunable):
             if bfloat16 is not None:
                 dtypes["bfloat16"] = bfloat16
 
-
         # If dtype is a list, convert it to a dictionary
         if isinstance(dtypes, (list, tuple)):
             dtypes = dict((name, _to_float_dtype(name)) for name in dtypes)
@@ -197,7 +209,6 @@ def error_metric_from_name(user_key, EPS=1e-8):
     The value of `EPS` is used for relative errors to prevent division by zero.
     ``
     """
-
     # Prepocess the provided name:
     # - convert to lowercase
     # - remove the word "error"
@@ -278,17 +289,13 @@ def error_metric_from_name(user_key, EPS=1e-8):
         raise ValueError(f"invalid error metric provided: {user_key}")
 
     # cast both arguments to f64 before passing them to the metric
-    return lambda a, b: metric(
-        a.astype(np.float64, copy=False), b.astype(np.float64, copy=False)
-    )
+    return lambda a, b: metric(a.astype(np.float64, copy=False), b.astype(np.float64, copy=False))
 
 
 class AccuracyObserver(OutputObserver):
-    """``AccuracyObserver`` measures the error on the output produced by a kernel
-    by comparing the output against a reference output.
+    """``AccuracyObserver`` measures the error on the output produced by a kernel by comparing to a reference output.
 
-    By default, it uses the root mean-squared error (RMSE) and uses the
-    metric name ``"error"``.
+    By default, it uses the root mean-squared error (RMSE) and uses the metric name ``"error"``.
     """
 
     def __init__(self, metric=None, key="error", *, atol=1e-8):
@@ -303,7 +310,6 @@ class AccuracyObserver(OutputObserver):
         :param atol: The tolerance used in relative metrics to prevent
                      division by zero. It is ignored by absolute error metrics.
         """
-
         # Default metric is RMSE
         if not metric:
             metric = "rmse"
@@ -317,6 +323,7 @@ class AccuracyObserver(OutputObserver):
         self.result = None
 
     def process_output(self, answers, outputs):
+        """Process the output produced by the kernel and compare it to the reference answers."""
         errors = []
 
         for answer, output in zip(answers, outputs):
@@ -326,4 +333,5 @@ class AccuracyObserver(OutputObserver):
         self.result = max(errors)
 
     def get_results(self):
+        """Get the results produced by this observer."""
         return dict([(self.key, self.result)])

{kernel_tuner-1.3.3 → kernel_tuner-1.5.0}/kernel_tuner/backends/compiler.py

@@ -1,13 +1,13 @@
-""" This module contains the functionality for running and compiling C functions """
+"""This module contains the functionality for running and compiling C functions"""
 
-from collections import namedtuple
-import subprocess
-import platform
+import _ctypes
+import ctypes as C
 import errno
-import re
 import logging
-import ctypes as C
-import _ctypes
+import platform
+import re
+import subprocess
+from collections import namedtuple
 
 import numpy as np
 import numpy.ctypeslib
@@ -15,10 +15,9 @@ import numpy.ctypeslib
 from kernel_tuner.backends.backend import CompilerBackend
 from kernel_tuner.observers.compiler import CompilerRuntimeObserver
 from kernel_tuner.util import (
-    get_temp_filename,
     delete_temp_file,
+    get_temp_filename,
     write_file,
-    SkippableFailure,
 )
 
 try:
@@ -88,7 +87,7 @@ class CompilerFunctions(CompilerBackend):
     """Class that groups the code for running and compiling C functions"""
 
     def __init__(self, iterations=7, compiler_options=None, compiler=None, observers=None):
-        """instantiate CFunctions object used for interacting with C code
+        """Instantiate CFunctions object used for interacting with C code
 
         :param iterations: Number of iterations used while benchmarking a kernel, 7 by default.
         :type iterations: int
@@ -146,7 +145,7 @@ class CompilerFunctions(CompilerBackend):
         self.name = platform.processor()
 
     def ready_argument_list(self, arguments):
-        """ready argument list to be passed to the C function
+        """Ready argument list to be passed to the C function
 
         :param arguments: List of arguments to be passed to the C function.
             The order should match the argument list on the C function.
@@ -181,7 +180,7 @@ class CompilerFunctions(CompilerBackend):
         return ctype_args
 
     def compile(self, kernel_instance):
-        """call the C compiler to compile the kernel, return the function
+        """Call the C compiler to compile the kernel, return the function
 
         :param kernel_instance: An object representing the specific instance of the tunable kernel
             in the parameter space.
@@ -311,29 +310,33 @@ class CompilerFunctions(CompilerBackend):
     def start_event(self):
         """Records the event that marks the start of a measurement
 
-        C backend does not use events"""
+        C backend does not use events
+        """
         pass
 
     def stop_event(self):
         """Records the event that marks the end of a measurement
 
-        C backend does not use events"""
+        C backend does not use events
+        """
         pass
 
     def kernel_finished(self):
         """Returns True if the kernel has finished, False otherwise
 
-        C backend does not support asynchronous launches"""
+        C backend does not support asynchronous launches
+        """
         return True
 
     def synchronize(self):
         """Halts execution until device has finished its tasks
 
-        C backend does not support asynchronous launches"""
+        C backend does not support asynchronous launches
+        """
         pass
 
     def run_kernel(self, func, c_args, threads, grid, stream=None):
-        """runs the kernel once, returns whatever the kernel returns
+        """Runs the kernel once, returns whatever the kernel returns
 
         :param func: A C function compiled for this specific configuration
         :type func: ctypes._FuncPtr
@@ -367,7 +370,7 @@ class CompilerFunctions(CompilerBackend):
         return time
 
     def memset(self, allocation, value, size):
-        """set the memory in allocation to the value in value
+        """Set the memory in allocation to the value in value
 
         :param allocation: An Argument for some memory allocation unit
         :type allocation: Argument
@@ -419,7 +422,7 @@ class CompilerFunctions(CompilerBackend):
                 self.memcpy_dtoh(arg, self.allocations[i])
 
     def cleanup_lib(self):
-        """unload the previously loaded shared library"""
+        """Unload the previously loaded shared library"""
         if self.lib is None:
             return
 

{kernel_tuner-1.3.3 → kernel_tuner-1.5.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.5.0}/kernel_tuner/backends/hip/hip.py

@@ -3,12 +3,14 @@
 import ctypes
 import ctypes.util
 import logging
+import json
+import uuid
 
 import numpy as np
 
 from kernel_tuner.backends.backend import GPUBackend
-from kernel_tuner.observers.hip import HipRuntimeObserver
 from kernel_tuner.backends.hip.util import hip_check
+from kernel_tuner.observers.hip import HipRuntimeObserver
 
 try:
     from hip import hip, hiprtc
@@ -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.5.0}/kernel_tuner/backends/hypertuner.py

@@ -27,12 +27,14 @@ class ScoreObserver(BenchmarkObserver):
         self.scores.append(self.dev.last_score)
 
     def get_results(self):
-        results = {'score': mean(self.scores), 'scores': self.scores.copy()}
+        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, compiler_options=None):
@@ -51,30 +53,30 @@ class HypertunerFunctions(Backend):
                 "name": "dedispersion_milo",
                 "folder": folder,
                 "input_file": "dedispersion_milo.json",
-                "objective_performance_keys": ["time"]
+                "objective_performance_keys": ["time"],
             },
             {
                 "name": "hotspot_milo",
                 "folder": folder,
                 "input_file": "hotspot_milo.json",
-                "objective_performance_keys": ["GFLOP/s"]
+                "objective_performance_keys": ["GFLOP/s"],
             },
             {
                 "name": "convolution_milo",
                 "folder": folder,
                 "input_file": "convolution_milo.json",
-                "objective_performance_keys": ["time"]
+                "objective_performance_keys": ["time"],
             },
             {
                 "name": "gemm_milo",
                 "folder": folder,
                 "input_file": "gemm_milo.json",
-                "objective_performance_keys": ["time"]
-            }
+                "objective_performance_keys": ["time"],
+            },
         ]
         # any additional settings
-        self.override = { 
-            "experimental_groups_defaults": { 
+        self.override = {
+            "experimental_groups_defaults": {
                 "repeats": 25,
                 "samples": self.iterations,
                 "minimum_fraction_of_budget_valid": 0.1,
@@ -84,10 +86,8 @@ class HypertunerFunctions(Backend):
                 "cutoff_percentile": 0.95,
                 "cutoff_percentile_start": 0.01,
                 "cutoff_type": "time",
-                "objective_time_keys": [
-                    "all"
-                ]
-            }
+                "objective_time_keys": ["all"],
+            },
         }
 
         # override the defaults with compiler options if provided
@@ -113,7 +113,7 @@ class HypertunerFunctions(Backend):
         if arglist is None:
             arglist = []
         return arglist
-    
+
     def compile(self, kernel_instance):
         super().compile(kernel_instance)
         path = Path(__file__).parent.parent.parent / "hyperparamtuning"
@@ -121,37 +121,47 @@ class HypertunerFunctions(Backend):
 
         # strategy settings
         strategy: str = kernel_instance.arguments[0]
-        hyperparams = [{'name': k, 'value': v} for k, v in kernel_instance.params.items()]
+        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
-        }]
+        searchspace_strategies = [
+            {
+                "autotuner": "KernelTuner",
+                "name": f"{strategy.lower()}_{hyperparams_string}",
+                "display_name": strategy.replace("_", " ").capitalize(),
+                "search_method": strategy.lower(),
+                "search_method_hyperparameters": hyperparams,
+            }
+        ]
 
         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, self.applications, self.gpus, 
-                                                        override=self.override, generate_unique_file=True, overwrite_existing_file=True)
+        experiments_filepath = generate_experiment_file(
+            name,
+            path,
+            searchspace_strategies,
+            self.applications,
+            self.gpus,
+            override=self.override,
+            generate_unique_file=True,
+            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):
         # from cProfile import Profile
-    
+
         # # generate the experiments file
         # experiments_filepath = Path(func)
 
@@ -161,23 +171,23 @@ class HypertunerFunctions(Backend):
         #     pr.dump_stats('diff_evo_hypertune_hotspot.prof')
         # self.last_score = scores[list(scores.keys())[0]]['score']
         # raise ValueError(scores)
-    
+
         # 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), full_validate_on_load=False)
-        self.last_score = scores[list(scores.keys())[0]]['score']
+        self.last_score = scores[list(scores.keys())[0]]["score"]
 
         # remove the experiments file
         experiments_filepath.unlink()
-    
+
     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)