kernel-tuner 0.3.0__tar.gz → 0.3.2__tar.gz

{kernel_tuner-0.3.0 → kernel_tuner-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kernel_tuner
-Version: 0.3.0
+Version: 0.3.2
 Summary: An easy to use CUDA/OpenCL kernel tuner in Python
 Home-page: http://benvanwerkhoven.github.io/kernel_tuner/
 Author: Ben van Werkhoven
@@ -9,7 +9,7 @@ License: Apache 2.0
 Description: Kernel Tuner
         ============
         
-        |Build Status| |CodeCov Badge| |PyPi Badge|
+        |Build Status| |CodeCov Badge| |PyPi Badge| |Zenodo Badge| |SonarCloud Badge| |FairSoftware Badge|
         
         Kernel Tuner simplifies the software development of optimized and auto-tuned GPU programs, by enabling Python-based unit testing of GPU code and making it easy to develop scripts for auto-tuning GPU kernels. This also means no extensive changes and no new dependencies are required in the kernel code. The kernels can still be compiled and used as normal from any host programming language.
         
@@ -178,12 +178,12 @@ Description: Kernel Tuner
            :target: https://codecov.io/gh/benvanwerkhoven/kernel_tuner
         .. |PyPi Badge| image:: https://img.shields.io/pypi/v/kernel_tuner.svg?colorB=blue 
            :target: https://pypi.python.org/pypi/kernel_tuner/
-        
-        
-        
-        
-        
-        
+        .. |Zenodo Badge| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.1220113.svg
+           :target: https://doi.org/10.5281/zenodo.1220113
+        .. |SonarCloud Badge| image:: https://sonarcloud.io/api/project_badges/measure?project=benvanwerkhoven_kernel_tuner&metric=alert_status
+           :target: https://sonarcloud.io/dashboard?id=benvanwerkhoven_kernel_tuner
+        .. |FairSoftware Badge| image:: https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F-green
+           :target: https://fair-software.eu
         
 Keywords: auto-tuning gpu computing pycuda cuda pyopencl opencl
 Platform: UNKNOWN
@@ -201,9 +201,9 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Classifier: Topic :: System :: Distributed Computing
 Classifier: Development Status :: 4 - Beta
-Provides-Extra: dev
 Provides-Extra: doc
-Provides-Extra: cuda_opencl
-Provides-Extra: tutorial
 Provides-Extra: cuda
 Provides-Extra: opencl
+Provides-Extra: cuda_opencl
+Provides-Extra: tutorial
+Provides-Extra: dev

{kernel_tuner-0.3.0 → kernel_tuner-0.3.2}/README.rst

@@ -1,7 +1,7 @@
 Kernel Tuner
 ============
 
-|Build Status| |CodeCov Badge| |PyPi Badge|
+|Build Status| |CodeCov Badge| |PyPi Badge| |Zenodo Badge| |SonarCloud Badge| |FairSoftware Badge|
 
 Kernel Tuner simplifies the software development of optimized and auto-tuned GPU programs, by enabling Python-based unit testing of GPU code and making it easy to develop scripts for auto-tuning GPU kernels. This also means no extensive changes and no new dependencies are required in the kernel code. The kernels can still be compiled and used as normal from any host programming language.
 
@@ -170,9 +170,9 @@ Cedric Nugteren. CLTune is a C++ library for kernel tuning.
    :target: https://codecov.io/gh/benvanwerkhoven/kernel_tuner
 .. |PyPi Badge| image:: https://img.shields.io/pypi/v/kernel_tuner.svg?colorB=blue 
    :target: https://pypi.python.org/pypi/kernel_tuner/
-
-
-
-
-
-
+.. |Zenodo Badge| image:: https://zenodo.org/badge/DOI/10.5281/zenodo.1220113.svg
+   :target: https://doi.org/10.5281/zenodo.1220113
+.. |SonarCloud Badge| image:: https://sonarcloud.io/api/project_badges/measure?project=benvanwerkhoven_kernel_tuner&metric=alert_status
+   :target: https://sonarcloud.io/dashboard?id=benvanwerkhoven_kernel_tuner
+.. |FairSoftware Badge| image:: https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F-green
+   :target: https://fair-software.eu

{kernel_tuner-0.3.0 → kernel_tuner-0.3.2}/kernel_tuner/c.py

@@ -90,22 +90,24 @@ class CFunctions(object):
             if not isinstance(arg, (numpy.ndarray, numpy.number)):
                 raise TypeError("Argument is not numpy ndarray or numpy scalar %s" % type(arg))
             dtype_str = str(arg.dtype)
-            data = arg.copy()
+            #data = arg.copy()
             if isinstance(arg, numpy.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 = data.ctypes.data_as(C.POINTER(dtype_map[dtype_str]))
+                    data_ctypes = arg.ctypes.data_as(C.POINTER(dtype_map[dtype_str]))
                 else:
                     raise TypeError("unknown dtype for ndarray")
             elif isinstance(arg, numpy.generic):
                 data_ctypes = dtype_map[dtype_str](arg)
-            ctype_args[i] = Argument(numpy=data, ctypes=data_ctypes)
+            #ctype_args[i] = Argument(numpy=data, ctypes=data_ctypes)
+            ctype_args[i] = Argument(numpy=arg, ctypes=data_ctypes)
         return ctype_args
 
-    def compile(self, kernel_name, kernel_string):
+    def compile(self, kernel_instance):
         """call the C compiler to compile the kernel, return the function
 
         :param kernel_name: The name of the kernel to be compiled, used to lookup the
@@ -118,7 +120,9 @@ class CFunctions(object):
         :returns: An ctypes function that can be called directly.
         :rtype: ctypes._FuncPtr
         """
-        logging.debug('compiling ' + kernel_name)
+        logging.debug('compiling ' + kernel_instance.name)
+
+        kernel_string = kernel_instance.kernel_string
 
         if self.lib != None:
             self.cleanup_lib()
@@ -134,25 +138,31 @@ class CFunctions(object):
             else:
                 compiler_options.append("-fopenmp")
 
-        # TODO: Get suffix from KernelSources, and adapt the logic below
+        #if filename is known, use that one
+        suffix = kernel_instance.kernel_source.get_user_suffix()
 
-        #select right suffix based on compiler
-        suffix = ".cc"
+        #if code contains device code, suffix .cu is required
+        device_code_signals = ["__global", "__syncthreads()", "threadIdx"]
+        if any([snippet in kernel_string for snippet in device_code_signals]):
+            suffix = ".cu"
 
         #detect whether to use nvcc as default instead of g++, may overrule an explicitly passed g++
-        if ("#include <cuda" in kernel_string) or ("cudaMemcpy" in kernel_string):
+        if (suffix == ".cu") or ("#include <cuda" in kernel_string) or ("cudaMemcpy" in kernel_string):
             if self.compiler == "g++" and self.nvcc_available:
                 self.compiler = "nvcc"
 
-        #if contains device code suffix .cu is required by nvcc
-        if self.compiler == "nvcc" and "__global__" in kernel_string:
-            suffix = ".cu"
-        if self.compiler in ["gfortran", "pgfortran", "ftn", "ifort"]:
-            suffix = ".F90"
+        if suffix is None:
+            #select right suffix based on compiler
+            suffix = ".cc"
+
+            if self.compiler in ["gfortran", "pgfortran", "ftn", "ifort"]:
+                suffix = ".F90"
 
         if self.compiler == "nvcc":
             compiler_options = ["-Xcompiler=" + c for c in compiler_options]
 
+        #this basically checks if we aren't compiling Fortran
+        #at the moment any C, C++, or CUDA code is assumed to use extern "C" linkage
         if ".c" in suffix:
             if not "extern \"C\"" in kernel_string:
                 kernel_string = "extern \"C\" {\n" + kernel_string + "\n}"
@@ -194,7 +204,7 @@ class CFunctions(object):
 
 
             self.lib = numpy.ctypeslib.load_library(filename, '.')
-            func = getattr(self.lib, kernel_name)
+            func = getattr(self.lib, kernel_instance.name)
             func.restype = C.c_float
 
         finally:

{kernel_tuner-0.3.0 → kernel_tuner-0.3.2}/kernel_tuner/core.py

@@ -115,7 +115,7 @@ class KernelSource(object):
 
             ks = self.get_kernel_string(i, params)
             # add preprocessor statements
-            n, ks = util.prepare_kernel_string(kernel_name, ks, params, grid, threads, block_size_names)
+            n, ks = util.prepare_kernel_string(kernel_name, ks, params, grid, threads, block_size_names, self.lang)
 
             if i == 0:
                 # primary kernel source
@@ -175,7 +175,7 @@ class KernelSource(object):
 class DeviceInterface(object):
     """Class that offers a High-Level Device Interface to the rest of the Kernel Tuner"""
 
-    def __init__(self, kernel_source, device=0, platform=0, lang=None, quiet=False, compiler=None, compiler_options=None, iterations=7):
+    def __init__(self, kernel_source, device=0, platform=0, quiet=False, compiler=None, compiler_options=None, iterations=7):
         """ Instantiate the DeviceInterface, based on language in kernel source
 
         :param kernel_source The kernel sources
@@ -310,6 +310,9 @@ class DeviceInterface(object):
                 return None
 
             #add constant memory arguments to compiled module
+            if kernel_options.smem_args is not None:
+                self.dev.copy_shared_memory_args(kernel_options.smem_args)
+            #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)
             #add texture memory arguments to compiled module
@@ -341,12 +344,13 @@ class DeviceInterface(object):
         #compile kernel_string into device func
         func = None
         try:
-            func = self.dev.compile(instance.name, instance.kernel_string)
+            func = self.dev.compile(instance)
         except Exception as e:
             #compiles may fail because certain kernel configurations use too
             #much shared memory for example, the desired behavior is to simply
             #skip over this configuration and try the next one
-            if "uses too much shared data" in str(e):
+            shared_mem_error_messages = ["uses too much shared data", "local memory limit exceeded"]
+            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")

{kernel_tuner-0.3.0 → kernel_tuner-0.3.2}/kernel_tuner/cuda.py

@@ -47,7 +47,13 @@ class CudaFunctions(object):
 
         drv.init()
         self.context = drv.Device(device).make_context()
-        self.nvml = nvml(device)
+
+        try:
+            self.nvml = nvml(device)
+            self.nvml.pwr_usage()
+            self.use_nvml = True
+        except:
+            self.use_nvml = False
 
         #inspect device properties
         devprops = {str(k): v for (k, v) in self.context.get_device().get_attributes().items()}
@@ -71,6 +77,9 @@ class CudaFunctions(object):
         #create a stream
         self.stream = drv.Stream()
 
+        #default dynamically allocated shared memory size, can be overwritten using smem_args
+        self.smem_size = 0
+
         #collect environment information
         env = dict()
         env["device_name"] = self.context.get_device().name()
@@ -113,7 +122,7 @@ class CudaFunctions(object):
         return gpu_args
 
 
-    def compile(self, kernel_name, kernel_string):
+    def compile(self, kernel_instance):
         """call the CUDA compiler to compile the kernel, return the device function
 
         :param kernel_name: The name of the kernel to be compiled, used to lookup the
@@ -126,6 +135,9 @@ class CudaFunctions(object):
         :returns: An CUDA kernel that can be called directly.
         :rtype: pycuda.driver.Function
         """
+        kernel_string = kernel_instance.kernel_string
+        kernel_name = kernel_instance.name
+
         try:
             no_extern_c = 'extern "C"' in kernel_string
 
@@ -191,7 +203,8 @@ class CudaFunctions(object):
             #measure power usage until kernel is done
             t0 = time.time()
             while not end.query():
-                power_readings.append([time.time()-t0, self.nvml.pwr_usage()])
+                if self.use_nvml:
+                    power_readings.append([time.time()-t0, self.nvml.pwr_usage()])
             end.synchronize()
             execution_time = end.time_since(start) #ms
             result["times"].append(execution_time)
@@ -233,6 +246,10 @@ class CudaFunctions(object):
             logging.debug(v.flags)
             drv.memcpy_htod(symbol, v)
 
+    def copy_shared_memory_args(self, smem_args):
+        """add shared memory arguments to the kernel"""
+        self.smem_size = smem_args["size"]
+
     def copy_texture_memory_args(self, texmem_args):
         """adds texture memory arguments to the most recently compiled module
 
@@ -308,7 +325,7 @@ class CudaFunctions(object):
             of the grid
         :type grid: tuple(int, int)
         """
-        func(*gpu_args, block=threads, grid=grid, stream=stream, texrefs=self.texrefs)
+        func(*gpu_args, block=threads, grid=grid, stream=stream, shared=self.smem_size, texrefs=self.texrefs)
 
     def memset(self, allocation, value, size):
         """set the memory in allocation to the value in value

{kernel_tuner-0.3.0 → kernel_tuner-0.3.2}/kernel_tuner/interface.py

@@ -80,13 +80,12 @@ _kernel_options = Options([
             parameters. This function should take one positional argument,
             which will be used to pass a dict containing the parameters.
             The function should return a string with the source code for
-            the kernel.""",
-            "string or list and/or callable")),
-     ("lang", ("""Specifies the language used for GPU kernels. The kernel_tuner
+            the kernel.""", "string or list and/or callable")),
+    ("lang", ("""Specifies the language used for GPU kernels. The kernel_tuner
         automatically detects the language, but if it fails, you may specify
         the language using this argument, currently supported: "CUDA",
         "OpenCL", or "C".""", "string")),
-     ("problem_size", ("""An int or string, or 1,2,3-dimensional tuple
+    ("problem_size", ("""An int or string, or 1,2,3-dimensional tuple
             containing the size from which the grid dimensions of the kernel
             will be computed.
 
@@ -129,6 +128,12 @@ _kernel_options = Options([
             the grid dimensions in the z-direction, ["block_size_z"] by default.
             If you do not want to divide the problem_size, you should pass an empty list.
             See grid_div_x for more details.""", "list")),
+    ("smem_args", ("""CUDA-specific feature for specifying shared memory options
+            to the kernel. At the moment only 'size' is supported, but setting the
+            shared memory configuration on Kepler GPUs for example could be added
+            in the future. Size should denote the number of bytes for to use when
+            dynamically allocating shared memory.""",
+            "dict(string: numpy object)")),
     ("cmem_args", ("""CUDA-specific feature for specifying constant memory
             arguments to the kernel. In OpenCL these are handled as normal
             kernel arguments, but in CUDA you can copy to a symbol. The way you
@@ -142,7 +147,8 @@ _kernel_options = Options([
             the texture contents. These contents can be either simply a numpy object,
             or a dictionary containing the numpy object under the key 'array' plus the
             configuration options 'filter_mode' ('point' or 'linear), 'address_mode'
-            (a list of 'border', 'clamp', 'mirror', 'wrap' per axis), 'normalized_coordinates' (True/False).""",
+            (a list of 'border', 'clamp', 'mirror', 'wrap' per axis),
+            'normalized_coordinates' (True/False).""",
             "dict(string: numpy object or dict)")),
     ("block_size_names", ("""A list of strings that replace the defaults for the names
             that denote the thread block dimensions. If not passed, the behavior
@@ -309,10 +315,11 @@ _tuning_options = Options([
             * too many resources requested for launch
 
         verbose is False by default.""", "bool")),
-    ("cache",("""filename for caching/logging benchmarked instances
+    ("cache", ("""filename for caching/logging benchmarked instances
         filename uses suffix ".json"
         if the file exists it is read and tuning continues from this file
-        """, "string"))
+        """, "string")),
+    ("metrics", ("specifies user-defined metrics", "OrderedDict"))
     ])
 
 _device_options = Options([
@@ -357,10 +364,10 @@ _tune_kernel_docstring = """ Tune a CUDA kernel given a set of tunable parameter
 def tune_kernel(kernel_name, kernel_string, problem_size, arguments,
                 tune_params, grid_div_x=None, grid_div_y=None, grid_div_z=None,
                 restrictions=None, answer=None, atol=1e-6, verify=None, verbose=False,
-                lang=None, device=0, platform=0, cmem_args=None, texmem_args=None,
+                lang=None, device=0, platform=0, smem_args=None, cmem_args=None, texmem_args=None,
                 compiler=None, compiler_options=None, log=None,
                 iterations=7, block_size_names=None, quiet=False, strategy=None, strategy_options=None,
-                cache=None):
+                cache=None, metrics=None):
 
     if log:
         logging.basicConfig(filename=kernel_name + datetime.now().strftime('%Y%m%d-%H:%M:%S') + '.log', level=log)
@@ -444,7 +451,8 @@ def tune_kernel(kernel_name, kernel_string, problem_size, arguments,
         if results:     #checks if results is not empty
             best_config = min(results, key=lambda x: x['time'])
             units = getattr(runner, "units", None)
-            print("best performing configuration:", util.get_config_string(best_config, list(tune_params.keys()) + ['time'], units=units))
+            print("best performing configuration:")
+            util.print_config_output(tune_params, best_config, device_options.quiet, metrics, units)
         else:
             print("no results to report")
 
@@ -490,7 +498,7 @@ _run_kernel_docstring = """Compile and run a single kernel
 
 def run_kernel(kernel_name, kernel_string, problem_size, arguments,
                params, grid_div_x=None, grid_div_y=None, grid_div_z=None,
-               lang=None, device=0, platform=0, cmem_args=None, texmem_args=None, compiler=None, compiler_options=None,
+               lang=None, device=0, platform=0, smem_args=None, cmem_args=None, texmem_args=None, compiler=None, compiler_options=None,
                block_size_names=None, quiet=False, log=None):
 
     if log:

kernel_tuner-0.3.2/kernel_tuner/kernelbuilder.py

@@ -0,0 +1,98 @@
+import numpy as np
+
+from kernel_tuner import core
+from kernel_tuner.interface import Options, _kernel_options
+
+class PythonKernel(object):
+
+    def __init__(self, kernel_name, kernel_string, problem_size, arguments, params, inputs=None, outputs=None, device=0, platform=0,
+                 block_size_names=None, grid_div_x=None, grid_div_y=None, grid_div_z=None, verbose=True, lang=None):
+        """ Construct Python helper object to compile and call the kernel from Python
+
+            This object compiles a GPU kernel parameterized using the parameters in params.
+            GPU memory is allocated for each argument using its size and type as listed in arguments.
+            The object can be called directly as a function with the kernel arguments as function arguments.
+            Kernel arguments marked as inputs will be copied to the GPU on every kernel launch.
+            Only the kernel arguments marked as outputs will be returned, note that the result is always
+            returned in a list, even when there is only one output.
+
+            Most of the arguments to this function are the same as with tune_kernel or run_kernel in Kernel Tuner,
+            and are therefore not duplicated here. The two new arguments are:
+
+            :param inputs: a boolean list of length arguments to signal whether an argument is input to the kernel
+            :type inputs: list(bool)
+
+            :param outputs: a boolean list of length arguments to signal whether an argument is output of the kernel
+            :type outputs: list(bool)
+
+        """
+        #construct device interface
+        kernel_source = core.KernelSource(kernel_string, lang)
+        self.dev = core.DeviceInterface(kernel_source, device=device)
+
+        #construct kernel_options to hold information about the kernel
+        opts = locals()
+        kernel_options = Options([(k, opts[k]) for k in _kernel_options.keys() if k in opts.keys()])
+
+        #instantiate the kernel given the parameters in params
+        self.kernel_instance = self.dev.create_kernel_instance(kernel_source, kernel_options, params, verbose)
+
+        #compile the kernel
+        self.func = self.dev.compile_kernel(self.kernel_instance, verbose)
+
+        #setup GPU memory
+        self.gpu_args = self.dev.ready_argument_list(arguments)
+        if inputs:
+            self.inputs = inputs
+        else:
+            self.inputs = [True for _ in arguments]
+        if outputs:
+            self.outputs = outputs
+        else:
+            self.outputs = [True for _ in arguments]
+
+    def update_gpu_args(self, args):
+        for i, arg in enumerate(args):
+            if self.inputs[i]:
+                if isinstance(args[i], np.ndarray):
+                    self.dev.dev.memcpy_htod(self.gpu_args[i], arg)
+                else:
+                    self.gpu_args[i] = arg
+        return self.gpu_args
+
+    def get_gpu_result(self, args):
+        results = []
+        for i, _ in enumerate(self.gpu_args):
+            if self.outputs[i] and isinstance(args[i], np.ndarray):
+                res = np.zeros_like(args[i])
+                self.dev.memcpy_dtoh(res, self.gpu_args[i])
+                results.append(res)
+        return results
+
+    def run_kernel(self, args):
+        """Run the GPU kernel
+
+        Copy the arguments marked as inputs to the GPU
+        Call the GPU kernel
+        Copy the arguments marked as outputs from the GPU
+        Return the outputs in a list of numpy arrays
+
+        :param args: A list with the kernel arguments as numpy arrays or numpy scalars
+        :type args: list(np.ndarray or np.generic)
+        """
+        self.update_gpu_args(args)
+        self.dev.run_kernel(self.func, self.gpu_args, self.kernel_instance)
+        return self.get_gpu_result(args)
+
+    def __call__(self, *args):
+        """Run the GPU kernel
+
+        Copy the arguments marked as inputs to the GPU
+        Call the GPU kernel
+        Copy the arguments marked as outputs from the GPU
+        Return the outputs in a list of numpy arrays
+
+        :param *args: A variable number of kernel arguments as numpy arrays or numpy scalars
+        :type *args: np.ndarray or np.generic
+        """
+        return self.run_kernel(args)

{kernel_tuner-0.3.0 → kernel_tuner-0.3.2}/kernel_tuner/opencl.py

@@ -69,7 +69,7 @@ class OpenCLFunctions(object):
                 gpu_args.append(arg)
         return gpu_args
 
-    def compile(self, kernel_name, kernel_string):
+    def compile(self, kernel_instance):
         """call the OpenCL compiler to compile the kernel, return the device function
 
         :param kernel_name: The name of the kernel to be compiled, used to lookup the
@@ -82,8 +82,8 @@ class OpenCLFunctions(object):
         :returns: An OpenCL kernel that can be called directly.
         :rtype: pyopencl.Kernel
         """
-        prg = cl.Program(self.ctx, kernel_string).build(options=self.compiler_options)
-        func = getattr(prg, kernel_name)
+        prg = cl.Program(self.ctx, kernel_instance.kernel_string).build(options=self.compiler_options)
+        func = getattr(prg, kernel_instance.name)
         return func
 
     def benchmark(self, func, gpu_args, threads, grid):

{kernel_tuner-0.3.0 → kernel_tuner-0.3.2}/kernel_tuner/runners/sequential.py

@@ -4,7 +4,7 @@ from __future__ import print_function
 from collections import OrderedDict
 import logging
 
-from kernel_tuner.util import get_config_string, store_cache
+from kernel_tuner.util import get_config_string, store_cache, process_metrics, print_config_output
 from kernel_tuner.core import DeviceInterface
 
 
@@ -35,6 +35,8 @@ class SequentialRunner(object):
         self.quiet = device_options.quiet
         self.kernel_source = kernel_source
 
+        self.warmed_up = False
+
         #move data to the GPU
         self.gpu_args = self.dev.ready_argument_list(kernel_options.arguments)
 
@@ -66,6 +68,11 @@ class SequentialRunner(object):
         for element in parameter_space:
             params = OrderedDict(zip(tuning_options.tune_params.keys(), element))
 
+            #attempt to warmup the GPU by running the first config in the parameter space and ignoring the result
+            if not self.warmed_up:
+                self.dev.compile_and_benchmark(self.kernel_source, self.gpu_args, params, kernel_options, tuning_options)
+                self.warmed_up = True
+
             #check if element is in the cache
             x_int = ",".join([str(i) for i in element])
             if tuning_options.cache:
@@ -87,14 +94,16 @@ class SequentialRunner(object):
                 time = result
 
             params['time'] = time
-            output_string = get_config_string(params, params.keys(), self.units)
-            logging.debug(output_string)
-            if not self.quiet:
-                print(output_string)
 
             if isinstance(result, dict):
                 params.update(result)
 
+
+            if tuning_options.metrics:
+                params = process_metrics(params, tuning_options.metrics)
+
+            print_config_output(tuning_options.tune_params, params, self.quiet, tuning_options.metrics, self.units)
+
             store_cache(x_int, params, tuning_options)
             results.append(params)
 
@@ -104,3 +113,7 @@ class SequentialRunner(object):
     def __del__(self):
         if hasattr(self, 'dev'):
             del self.dev
+
+
+
+

{kernel_tuner-0.3.0 → kernel_tuner-0.3.2}/kernel_tuner/strategies/bayes_opt.py

@@ -2,7 +2,15 @@
 from __future__ import print_function
 
 from collections import OrderedDict
-from bayes_opt import BayesianOptimization
+
+try:
+    from bayes_opt import BayesianOptimization
+    bayes_opt_present=True
+except Exception:
+    BayesianOptimization = None
+    bayes_opt_present=False
+
+
 
 from kernel_tuner.strategies import minimize
 
@@ -47,6 +55,9 @@ def tune(runner, kernel_options, device_options, tuning_options):
     #   acq="ei", xi=1e-1
     #   acq="ucb", kappa=10
 
+    if not bayes_opt_present:
+        raise ImportError("Error: optional dependency Bayesian Optimization not installed")
+
     #defaults as used by Bayesian Optimization Python package
     acq = tuning_options.strategy_options.get("method", "poi")
     kappa = tuning_options.strategy_options.get("kappa", 2.576)

{kernel_tuner-0.3.0 → kernel_tuner-0.3.2}/kernel_tuner/strategies/minimize.py

@@ -98,19 +98,28 @@ def _cost_func(x, kernel_options, tuning_options, runner, results):
 
 def get_bounds_x0_eps(tuning_options):
     """compute bounds, x0 (the initial guess), and eps"""
-    values = tuning_options.tune_params.values()
+    values = list(tuning_options.tune_params.values())
+
+    if "x0" in tuning_options.strategy_options:
+        x0 = tuning_options.strategy_options.x0
+    else:
+        x0 = None
 
     if tuning_options.scaling:
-        #bounds = [(0, 1) for _ in values]
-        #x0 = [0.5 for _ in bounds]
         eps = numpy.amin([1.0/len(v) for v in values])
 
         #reducing interval from [0, 1] to [0, eps*len(v)]
         bounds = [(0, eps*len(v)) for v in values]
-        x0 = [0.5*eps*len(v) for v in values]
+        if x0:
+            #x0 has been supplied by the user, map x0 into [0, eps*len(v)]
+            for i, e in enumerate(values):
+                x0[i] = eps*values[i].index(x0[i])
+        else:
+            x0 = [0.5*eps*len(v) for v in values]
     else:
         bounds = get_bounds(tuning_options.tune_params)
-        x0 = [(min_v+max_v)/2.0 for (min_v, max_v) in bounds]
+        if not x0:
+            x0 = [(min_v+max_v)/2.0 for (min_v, max_v) in bounds]
         eps = 1e9
         for v_list in values:
             vals = numpy.sort(v_list)