kernel-tuner 0.4.0__tar.gz → 0.4.1__tar.gz

{kernel_tuner-0.4.0 → kernel_tuner-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kernel_tuner
-Version: 0.4.0
+Version: 0.4.1
 Summary: An easy to use CUDA/OpenCL kernel tuner in Python
 Home-page: http://benvanwerkhoven.github.io/kernel_tuner/
 Author: Ben van Werkhoven
@@ -172,8 +172,9 @@ Description: Kernel Tuner
         You may also like `CLTune <https://github.com/CNugteren/CLTune>`__ by
         Cedric Nugteren. CLTune is a C++ library for kernel tuning.
         
-        .. |Build Status| image:: https://api.travis-ci.org/benvanwerkhoven/kernel_tuner.svg?branch=master
-           :target: https://travis-ci.org/benvanwerkhoven/kernel_tuner
+        
+        .. |Build Status| image:: https://github.com/benvanwerkhoven/kernel_tuner/actions/workflows/python-app.yml/badge.svg
+           :target: https://github.com/benvanwerkhoven/kernel_tuner/actions/workflows/python-app.yml
         .. |CodeCov Badge| image:: https://codecov.io/gh/benvanwerkhoven/kernel_tuner/branch/master/graph/badge.svg
            :target: https://codecov.io/gh/benvanwerkhoven/kernel_tuner
         .. |PyPi Badge| image:: https://img.shields.io/pypi/v/kernel_tuner.svg?colorB=blue 

{kernel_tuner-0.4.0 → kernel_tuner-0.4.1}/README.rst

@@ -164,8 +164,9 @@ Related work
 You may also like `CLTune <https://github.com/CNugteren/CLTune>`__ by
 Cedric Nugteren. CLTune is a C++ library for kernel tuning.
 
-.. |Build Status| image:: https://api.travis-ci.org/benvanwerkhoven/kernel_tuner.svg?branch=master
-   :target: https://travis-ci.org/benvanwerkhoven/kernel_tuner
+
+.. |Build Status| image:: https://github.com/benvanwerkhoven/kernel_tuner/actions/workflows/python-app.yml/badge.svg
+   :target: https://github.com/benvanwerkhoven/kernel_tuner/actions/workflows/python-app.yml
 .. |CodeCov Badge| image:: https://codecov.io/gh/benvanwerkhoven/kernel_tuner/branch/master/graph/badge.svg
    :target: https://codecov.io/gh/benvanwerkhoven/kernel_tuner
 .. |PyPi Badge| image:: https://img.shields.io/pypi/v/kernel_tuner.svg?colorB=blue 

{kernel_tuner-0.4.0 → kernel_tuner-0.4.1}/kernel_tuner/core.py

@@ -19,6 +19,14 @@ from kernel_tuner.c import CFunctions
 from kernel_tuner.nvml import NVMLObserver
 import kernel_tuner.util as util
 
+
+try:
+    import torch
+except ImportError:
+    torch = util.TorchPlaceHolder()
+
+
+
 _KernelInstance = namedtuple("_KernelInstance", ["name", "kernel_source", "kernel_string", "temp_files", "threads", "grid", "params", "arguments"])
 
 
@@ -230,7 +238,7 @@ class DeviceInterface(object):
         elif lang == "C":
             dev = CFunctions(compiler=compiler, compiler_options=compiler_options, iterations=iterations)
         else:
-            raise Exception("Sorry, support for languages other than CUDA, OpenCL, or C is not implemented yet")
+            raise ValueError("Sorry, support for languages other than CUDA, OpenCL, or C is not implemented yet")
 
         #look for NVMLObserver in observers, if present, enable special tunable parameters through nvml
         self.use_nvml = False
@@ -244,6 +252,7 @@ class DeviceInterface(object):
         self.dev = dev
         self.units = dev.units
         self.name = dev.name
+        self.max_threads = dev.max_threads
         if not quiet:
             print("Using: " + self.dev.name)
 
@@ -282,7 +291,7 @@ class DeviceInterface(object):
             if any([skip_str in str(e) for skip_str in skippable_exceptions]):
                 logging.debug('benchmark fails due to runtime failure too many resources required')
                 if verbose:
-                    print("skipping config", instance.name, "reason: too many resources requested for launch")
+                    print(f"skipping config {util.get_instance_string(instance.params)} reason: too many resources requested for launch")
             else:
                 logging.debug('benchmark encountered runtime failure: ' + str(e))
                 print("Error while benchmarking:", instance.name)
@@ -300,7 +309,7 @@ class DeviceInterface(object):
         #re-copy original contents of output arguments to GPU memory, to overwrite any changes
         #by earlier kernel runs
         for i, arg in enumerate(instance.arguments):
-            if verify or answer[i] is not None and isinstance(arg, (np.ndarray, cp.ndarray)):
+            if (verify or answer[i] is not None) and isinstance(arg, (np.ndarray, cp.ndarray, torch.Tensor)):
                 self.dev.memcpy_htod(gpu_args[i], arg)
 
         #run the kernel
@@ -314,6 +323,13 @@ class DeviceInterface(object):
             if (verify or answer[i] is not None) and isinstance(arg, (np.ndarray, cp.ndarray)):
                 result_host.append(np.zeros_like(arg))
                 self.dev.memcpy_dtoh(result_host[-1], gpu_args[i])
+            elif isinstance(arg, torch.Tensor) and isinstance(answer[i], torch.Tensor):
+                if not answer[i].is_cuda:
+                    #if the answer is on the host, copy gpu output to host as well
+                    result_host.append(torch.zeros_like(answer[i]))
+                    self.dev.memcpy_dtoh(result_host[-1], gpu_args[i].tensor)
+                else:
+                    result_host.append(gpu_args[i].tensor)
             else:
                 result_host.append(None)
 
@@ -324,7 +340,7 @@ class DeviceInterface(object):
             correct = _default_verify_function(instance, answer, result_host, atol, verbose)
 
         if not correct:
-            raise Exception("Kernel result verification failed for: " + util.get_config_string(instance.params))
+            raise RuntimeError("Kernel result verification failed for: " + util.get_config_string(instance.params))
         return True
 
     def compile_and_benchmark(self, kernel_source, gpu_args, params, kernel_options, tuning_options):
@@ -348,9 +364,9 @@ class DeviceInterface(object):
             if func is None:
                 return None
 
-            #add constant memory arguments to compiled module
+            #add shared memory arguments to compiled module
             if kernel_options.smem_args is not None:
-                self.dev.copy_shared_memory_args(kernel_options.smem_args)
+                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)
@@ -392,30 +408,36 @@ class DeviceInterface(object):
             if any(msg in str(e) for msg in shared_mem_error_messages):
                 logging.debug('compile_kernel failed due to kernel using too much shared memory')
                 if verbose:
-                    print("skipping config", instance.name, "reason: too much shared memory used")
+                    print(f"skipping config {util.get_instance_string(instance.params)} reason: too much shared memory used")
             else:
                 logging.debug('compile_kernel failed due to error: ' + str(e))
                 print("Error while compiling:", instance.name)
                 raise e
         return func
 
+    def copy_shared_memory_args(self, smem_args):
+        """adds shared memory arguments to the most recently compiled module, if using CUDA"""
+        if self.lang == "CUDA":
+            self.dev.copy_shared_memory_args(smem_args)
+        else:
+            raise RuntimeError("Error cannot copy shared memory arguments when language is not CUDA")
+
     def copy_constant_memory_args(self, cmem_args):
         """adds constant memory arguments to the most recently compiled module, if using CUDA"""
         if self.lang == "CUDA":
             self.dev.copy_constant_memory_args(cmem_args)
         else:
-            raise Exception("Error cannot copy constant memory arguments when language is not CUDA")
+            raise RuntimeError("Error cannot copy constant memory arguments when language is not CUDA")
 
     def copy_texture_memory_args(self, texmem_args):
         """adds texture memory arguments to the most recently compiled module, if using CUDA"""
         if self.lang == "CUDA":
             self.dev.copy_texture_memory_args(texmem_args)
         else:
-            raise Exception("Error cannot copy texture memory arguments when language is not CUDA")
+            raise RuntimeError("Error cannot copy texture memory arguments when language is not CUDA")
 
     def create_kernel_instance(self, kernel_source, kernel_options, params, verbose):
         """create kernel instance from kernel source, parameters, problem size, grid divisors, and so on"""
-        instance_string = util.get_instance_string(params)
         grid_div = (kernel_options.grid_div_x, kernel_options.grid_div_y, kernel_options.grid_div_z)
 
         #insert default block_size_names if needed
@@ -426,7 +448,7 @@ class DeviceInterface(object):
         threads, grid = util.setup_block_and_grid(kernel_options.problem_size, grid_div, params, kernel_options.block_size_names)
         if np.prod(threads) > self.dev.max_threads:
             if verbose:
-                print("skipping config", instance_string, "reason: too many threads per block")
+                print(f"skipping config {util.get_instance_string(params)} reason: too many threads per block")
             return None
 
         #obtain the kernel_string and prepare additional files, if any
@@ -485,21 +507,29 @@ def _default_verify_function(instance, answer, result_host, atol, verbose):
         if answer[i] is not None:    #skip None elements in the answer list
             if isinstance(answer[i], (np.ndarray, cp.ndarray)) and isinstance(arg, (np.ndarray, cp.ndarray)):
                 if answer[i].dtype != arg.dtype:
-                    raise TypeError("Element " + str(i) + " of the expected results list is not of the same dtype as the kernel output: " +
+                    raise TypeError(f"Element {i} of the expected results list is not of the same dtype as the kernel output: " +
                                     str(answer[i].dtype) + " != " + str(arg.dtype) + ".")
                 if answer[i].size != arg.size:
-                    raise TypeError("Element " + str(i) + " of the expected results list has a size different from " + "the kernel argument: " +
+                    raise TypeError(f"Element {i} of the expected results list has a size different from " + "the kernel argument: " +
                                     str(answer[i].size) + " != " + str(arg.size) + ".")
+            elif isinstance(answer[i], torch.Tensor) and isinstance(arg, torch.Tensor):
+                if answer[i].dtype != arg.dtype:
+                    raise TypeError(f"Element {i} of the expected results list is not of the same dtype as the kernel output: " +
+                                    str(answer[i].dtype) + " != " + str(arg.dtype) + ".")
+                if answer[i].size() != arg.size():
+                    raise TypeError(f"Element {i} of the expected results list has a size different from " + "the kernel argument: " +
+                                    str(answer[i].size) + " != " + str(arg.size) + ".")
+
             elif isinstance(answer[i], np.number) and isinstance(arg, np.number):
                 if answer[i].dtype != arg.dtype:
-                    raise TypeError("Element " + str(i) + " of the expected results list is not the same as the kernel output: " + str(answer[i].dtype) +
+                    raise TypeError(f"Element {i} of the expected results list is not the same as the kernel output: " + str(answer[i].dtype) +
                                     " != " + str(arg.dtype) + ".")
             else:
                 #either answer[i] and argument have different types or answer[i] is not a numpy type
-                if not isinstance(answer[i], np.ndarray) or not isinstance(answer[i], np.number):
-                    raise TypeError("Element " + str(i) + " of expected results list is not a numpy array or numpy scalar.")
+                if not isinstance(answer[i], (np.ndarray, cp.ndarray, torch.Tensor)) or not isinstance(answer[i], np.number):
+                    raise TypeError(f"Element {i} of expected results list is not a numpy/cupy ndarray, torch Tensor or numpy scalar.")
                 else:
-                    raise TypeError("Element " + str(i) + " of expected results list and kernel arguments have different types.")
+                    raise TypeError(f"Element {i} of expected results list and kernel arguments have different types.")
 
     def _ravel(a):
         if hasattr(a, 'ravel') and len(a.shape) > 1:
@@ -520,6 +550,8 @@ def _default_verify_function(instance, answer, result_host, atol, verbose):
             expected = _flatten(expected)
             if any([isinstance(array, cp.ndarray) for array in [expected, result]]):
                 output_test = cp.allclose(expected, result, atol=atol)
+            elif isinstance(expected, torch.Tensor) and isinstance(result, torch.Tensor):
+                output_test = torch.allclose(expected, result, atol=atol)
             else:
                 output_test = np.allclose(expected, result, atol=atol)
 

{kernel_tuner-0.4.0 → kernel_tuner-0.4.1}/kernel_tuner/cuda.py

@@ -7,13 +7,23 @@ import numpy as np
 
 from kernel_tuner.observers import BenchmarkObserver
 from kernel_tuner.nvml import nvml
+from kernel_tuner.util import TorchPlaceHolder
 
 #embedded in try block to be able to generate documentation
 #and run tests without pycuda installed
 try:
     import pycuda.driver as drv
+    pycuda_available = True
 except ImportError:
-    drv = None
+
+    class PyCudaPlaceHolder():
+
+        def __init__(self):
+            self.PointerHolderBase = object
+
+    drv = PyCudaPlaceHolder()
+    pycuda_available = False
+
 try:
     from pycuda.compiler import SourceModule
 except ImportError:
@@ -23,9 +33,27 @@ try:
 except ImportError:
     DynamicSourceModule = None
 
+try:
+    import torch
+except ImportError:
+    torch = TorchPlaceHolder()
+
+
+class Holder(drv.PointerHolderBase):
+    """ class to interoperate torch device memory allocations with PyCUDA """
+
+    def __init__(self, tensor):
+        super(Holder, self).__init__()
+        self.tensor = tensor
+        self.gpudata = tensor.data_ptr()
+
+    def get_pointer(self):
+        return self.t.data_ptr()
+
 
 class CudaRuntimeObserver(BenchmarkObserver):
     """ Observer that measures time using CUDA events during benchmarking """
+
     def __init__(self, dev):
         self.dev = dev
         self.stream = dev.stream
@@ -34,10 +62,13 @@ class CudaRuntimeObserver(BenchmarkObserver):
         self.times = []
 
     def after_finish(self):
-        self.times.append(self.end.time_since(self.start)) #ms
+        self.times.append(self.end.time_since(self.start))    #ms
 
     def get_results(self):
-        results = {"time": np.average(self.times), "times": self.times.copy()}
+        results = {
+            "time": np.average(self.times),
+            "times": self.times.copy()
+        }
         self.times = []
         return results
 
@@ -61,19 +92,20 @@ class CudaFunctions(object):
         """
         self.allocations = []
         self.texrefs = []
-        if not drv:
+        if not pycuda_available and isinstance(drv, PyCudaPlaceHolder):    #and part to allow mocking
             raise ImportError("Error: pycuda not installed, please install e.g. using 'pip install pycuda'.")
 
         drv.init()
         self.context = drv.Device(device).make_context()
 
         #inspect device properties
-        devprops = {str(k): v for (k, v) in self.context.get_device().get_attributes().items()}
+        devprops = {str(k): v
+                    for (k, v) in self.context.get_device().get_attributes().items()}
         self.max_threads = devprops['MAX_THREADS_PER_BLOCK']
         cc = str(devprops.get('COMPUTE_CAPABILITY_MAJOR', '0')) + str(devprops.get('COMPUTE_CAPABILITY_MINOR', '0'))
         if cc == "00":
             cc = self.context.get_device().compute_capability()
-        self.cc = str(cc[0])+str(cc[1])
+        self.cc = str(cc[0]) + str(cc[1])
         self.iterations = iterations
         self.current_module = None
         self.func = None
@@ -85,7 +117,8 @@ class CudaFunctions(object):
         else:
             self.source_mod = SourceModule
         if not self.source_mod:
-            raise ImportError("Error: pycuda not correctly installed, please ensure pycuda is installed on the same CUDA installation as you're using right now")
+            raise ImportError(
+                "Error: pycuda not correctly installed, please ensure pycuda is installed on the same CUDA installation as you're using right now")
 
         #create a stream and events
         self.stream = drv.Stream()
@@ -117,7 +150,7 @@ class CudaFunctions(object):
 
     def __exit__(self, *exc):
         for gpu_mem in self.allocations:
-            if hasattr(gpu_mem, 'free'): #if needed for when using mocks during testing
+            if hasattr(gpu_mem, 'free'):    #if needed for when using mocks during testing
                 gpu_mem.free()
         if hasattr(self, 'context'):
             self.context.pop()
@@ -141,11 +174,15 @@ class CudaFunctions(object):
                 self.allocations.append(alloc)
                 gpu_args.append(alloc)
                 drv.memcpy_htod(gpu_args[-1], arg)
-            else: # if not an array, just pass argument along
+            elif isinstance(arg, torch.Tensor):
+                if arg.is_cuda:
+                    gpu_args.append(Holder(arg))
+                else:
+                    gpu_args.append(Holder(arg.cuda()))
+            else:    # if not an array, just pass argument along
                 gpu_args.append(arg)
         return gpu_args
 
-
     def compile(self, kernel_instance):
         """call the CUDA compiler to compile the kernel, return the device function
 
@@ -170,9 +207,8 @@ class CudaFunctions(object):
                 compiler_options += self.compiler_options
 
             self.current_module = self.source_mod(kernel_string, options=compiler_options + ["-e", kernel_name],
-                                             arch=('compute_' + self.cc) if self.cc != "00" else None,
-                                             code=('sm_' + self.cc) if self.cc != "00" else None,
-                                             cache_dir=False, no_extern_c=no_extern_c)
+                                                  arch=('compute_' + self.cc) if self.cc != "00" else None, code=('sm_' + self.cc) if self.cc != "00" else None,
+                                                  cache_dir=False, no_extern_c=no_extern_c)
 
             self.func = self.current_module.get_function(kernel_name)
             return self.func
@@ -182,7 +218,6 @@ class CudaFunctions(object):
             else:
                 raise e
 
-
     def benchmark(self, func, gpu_args, threads, grid):
         """runs the kernel and measures time repeatedly, returns average time
 
@@ -215,9 +250,10 @@ class CudaFunctions(object):
         result = dict()
         self.context.synchronize()
         for _ in range(self.iterations):
-            self.start.record(stream=self.stream)
             for obs in self.observers:
                 obs.before_start()
+            self.context.synchronize()
+            self.start.record(stream=self.stream)
             self.run_kernel(func, gpu_args, threads, grid, stream=self.stream)
             self.end.record(stream=self.stream)
             for obs in self.observers:
@@ -225,6 +261,7 @@ class CudaFunctions(object):
             while not self.end.query():
                 for obs in self.observers:
                     obs.during()
+                time.sleep(1e-6)    #one microsecond
             self.end.synchronize()
             for obs in self.observers:
                 obs.after_finish()
@@ -267,13 +304,16 @@ class CudaFunctions(object):
         :type texmem_args: dict
         """
 
-
-        filter_mode_map = { 'point': drv.filter_mode.POINT,
-                            'linear': drv.filter_mode.LINEAR }
-        address_mode_map = { 'border': drv.address_mode.BORDER,
-                             'clamp': drv.address_mode.CLAMP,
-                             'mirror': drv.address_mode.MIRROR,
-                             'wrap': drv.address_mode.WRAP }
+        filter_mode_map = {
+            'point': drv.filter_mode.POINT,
+            'linear': drv.filter_mode.LINEAR
+        }
+        address_mode_map = {
+            'border': drv.address_mode.BORDER,
+            'clamp': drv.address_mode.CLAMP,
+            'mirror': drv.address_mode.MIRROR,
+            'wrap': drv.address_mode.WRAP
+        }
 
         logging.debug('copy_texture_memory_args called')
         logging.debug('current module: ' + str(self.current_module))
@@ -299,7 +339,7 @@ class CudaFunctions(object):
                     # address_mode is set per axis
                     amode = v['address_mode']
                     if not isinstance(amode, list):
-                        amode = [ amode ] * data.ndim
+                        amode = [amode] * data.ndim
                     for i, m in enumerate(amode):
                         try:
                             if m is not None:
@@ -351,7 +391,6 @@ class CudaFunctions(object):
         """
         drv.memset_d8(allocation, value, size)
 
-
     def memcpy_dtoh(self, dest, src):
         """perform a device to host memory copy
 
@@ -363,6 +402,8 @@ class CudaFunctions(object):
         """
         if isinstance(src, drv.DeviceAllocation):
             drv.memcpy_dtoh(dest, src)
+        elif isinstance(src, torch.Tensor):
+            dest[:] = src
         else:
             dest = src
 
@@ -380,6 +421,8 @@ class CudaFunctions(object):
         else:
             dest = src
 
-    units = {'time': 'ms',
-             'power': 's,mW',
-             'energy': 'J'}
+    units = {
+        'time': 'ms',
+        'power': 's,mW',
+        'energy': 'J'
+    }

{kernel_tuner-0.4.0 → kernel_tuner-0.4.1}/kernel_tuner/cupy.py

@@ -1,14 +1,12 @@
 """This module contains all Cupy specific kernel_tuner functions"""
 from __future__ import print_function
 
-import re
 
 import logging
 import time
 import numpy as np
 
 from kernel_tuner.observers import BenchmarkObserver
-from kernel_tuner.nvml import nvml
 
 #embedded in try block to be able to generate documentation
 #and run tests without cupy installed
@@ -36,7 +34,7 @@ class CupyRuntimeObserver(BenchmarkObserver):
         return results
 
 
-class CupyFunctions(object):
+class CupyFunctions:
     """Class that groups the Cupy functions on maintains state about the device"""
 
     def __init__(self, device=0, iterations=7, compiler_options=None, observers=None):
@@ -56,7 +54,8 @@ class CupyFunctions(object):
         self.allocations = []
         self.texrefs = []
         if not cp:
-            raise ImportError("Error: cupy not installed, please install e.g. using 'pip install cupy-cuda111', please check https://github.com/cupy/cupy.")
+            raise ImportError("Error: cupy not installed, please install e.g. " +
+                            "using 'pip install cupy-cuda111', please check https://github.com/cupy/cupy.")
 
         #select device
         self.dev = dev = cp.cuda.Device(device).__enter__()
@@ -68,6 +67,7 @@ class CupyFunctions(object):
 
         self.iterations = iterations
         self.current_module = None
+        self.func = None
         self.compiler_options = compiler_options or []
 
         #create a stream and events
@@ -189,9 +189,10 @@ class CupyFunctions(object):
         result = dict()
         self.dev.synchronize()
         for _ in range(self.iterations):
-            self.start.record(stream=self.stream)
             for obs in self.observers:
                 obs.before_start()
+            self.dev.synchronize()
+            self.start.record(stream=self.stream)
             self.run_kernel(func, gpu_args, threads, grid, stream=self.stream)
             self.end.record(stream=self.stream)
             for obs in self.observers:
@@ -199,6 +200,7 @@ class CupyFunctions(object):
             while not self.end.done:
                 for obs in self.observers:
                     obs.during()
+                time.sleep(1e-6)
             for obs in self.observers:
                 obs.after_finish()
 

kernel_tuner-0.4.1/kernel_tuner/hyper.py

@@ -0,0 +1,90 @@
+""" Module for functions related to hyperparameter optimization """
+
+import itertools
+import numpy as np
+import kernel_tuner
+import warnings
+
+from kernel_tuner.util import get_config_string
+
+
+def tune_hyper_params(target_strategy, hyper_params, *args, **kwargs):
+    """ Tune hyperparameters for a given strategy and kernel
+
+    This function is to be called just like tune_kernel, except that you specify a strategy
+    and a dictionary with hyperparameters in front of the arguments you pass to tune_kernel.
+
+    The arguments to tune_kernel should contain a cachefile. To compute the optimum the hyperparameter
+    tuner first tunes the kernel with a brute force search. If your cachefile is not yet complete
+    this may take very long.
+
+    :param target_strategy: Specify the strategy for which to tune hyperparameters
+    :type target_strategy: string
+
+    :param hyper_params: A dictionary containing the hyperparameters as keys and
+        lists the possible values per key
+    :type hyper_params: dict(string: list)
+
+    :param args: all positional arguments used to call tune_kernel
+    :type args: various
+
+    :param kwargs: other keyword arguments to pass to tune_kernel
+    :type kwargs: dict
+
+    """
+    if not "cache" in kwargs:
+        raise ValueError("Please specify a cachefile to store benchmarking data when tuning hyperparameters")
+
+    def put_if_not_present(d, key, value):
+        d[key] = value if not key in d else d[key]
+
+    put_if_not_present(kwargs, "verbose", False)
+    put_if_not_present(kwargs, "quiet", True)
+    put_if_not_present(kwargs, "simulation_mode", True)
+    kwargs['strategy'] = 'brute_force'
+
+    #last position argument is tune_params
+    tune_params = args[-1]
+
+    #find optimum
+    kwargs["strategy"] = "brute_force"
+    results, env = kernel_tuner.tune_kernel(*args, **kwargs)
+    optimum = min(results, key=lambda p: p["time"])["time"]
+
+    #could throw a warning for the kwargs that will be overwritten, strategy(_options)
+    kwargs["strategy"] = target_strategy
+
+    parameter_space = itertools.product(*hyper_params.values())
+    all_results = []
+
+    for params in parameter_space:
+        strategy_options = dict(zip(hyper_params.keys(), params))
+
+        kwargs["strategy_options"] = strategy_options
+
+        fevals = []
+        p_of_opt = []
+        for _ in range(100):
+            #measure
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                results, env = kernel_tuner.tune_kernel(*args, **kwargs)
+
+            #get unique function evaluations
+            unique_fevals = {",".join([str(v) for k, v in record.items() if k in tune_params])
+                             for record in results}
+
+            fevals.append(len(unique_fevals))
+            # p_of_opt.append(optimum / min(results, key=lambda p: p["time"])["time"] * 100)
+            p_of_opt.append(min(results, key=lambda p: p["time"])["time"] / optimum * 100)
+
+        strategy_options["fevals"] = np.average(fevals)
+        strategy_options["fevals_std"] = np.std(fevals)
+
+        strategy_options["p_of_opt"] = np.average(p_of_opt)
+        strategy_options["p_of_opt_std"] = np.std(p_of_opt)
+
+        print(get_config_string(strategy_options))
+        all_results.append(strategy_options)
+
+    return all_results

{kernel_tuner-0.4.0 → kernel_tuner-0.4.1}/kernel_tuner/integration.py

@@ -197,8 +197,11 @@ def store_results(results_filename, kernel_name, kernel_string, tune_params, pro
         meta = {}
         meta["version_number"] = "1.0"
         meta["kernel_name"] = kernel_name
-        if kernel_string:
-            meta["kernel_string"] = kernel_string
+        if kernel_string and not callable(kernel_string) and not isinstance(kernel_string, list):
+            if util.looks_like_a_filename(kernel_string):
+                meta["kernel_string"] = util.read_file(kernel_string)
+            else:
+                meta["kernel_string"] = kernel_string
         meta["objective"] = objective
         meta["objective_higher_is_better"] = objective_higher_is_better
         meta["tunable_parameters"] = list(tune_params.keys())
@@ -229,7 +232,7 @@ def store_results(results_filename, kernel_name, kernel_string, tune_params, pro
     #write output file
     meta["data"] = data
     with open(results_filename, 'w') as fh:
-        fh.write(json.dumps(meta))
+        fh.write(json.dumps(meta, indent=""))
 
 
 def create_device_targets(header_filename, results_filename, objective=None, objective_higher_is_better=None):