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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kernel_tuner
-Version: 0.3.0
+Version: 0.3.1
 Summary: An easy to use CUDA/OpenCL kernel tuner in Python
 Home-page: http://benvanwerkhoven.github.io/kernel_tuner/
 Author: Ben van Werkhoven
@@ -202,8 +202,8 @@ 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: tutorial
 Provides-Extra: opencl
+Provides-Extra: cuda_opencl
+Provides-Extra: doc

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

@@ -105,7 +105,7 @@ class CFunctions(object):
             ctype_args[i] = Argument(numpy=data, 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 +118,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 +136,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 +202,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.1}/kernel_tuner/core.py

@@ -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,7 +344,7 @@ 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

{kernel_tuner-0.3.0 → kernel_tuner-0.3.1}/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.1/kernel_tuner/cupy_backend.py

@@ -0,0 +1,331 @@
+"""This module contains all CUDA specific kernel_tuner functions"""
+from __future__ import print_function
+
+import logging
+import time
+import numpy as np
+
+import cupy as cp
+
+import cupy.cuda as cuda
+
+from kernel_tuner.nvml import nvml
+
+
+
+
+class CupyBackend(object):
+    """Class that groups the CUDA functions on maintains state about the device"""
+
+    def __init__(self, device=0, iterations=7, compiler_options=None):
+        """instantiate CudaFunctions object used for interacting with the CUDA device
+
+        Instantiating this object will inspect and store certain device properties at
+        runtime, which are used during compilation and/or execution of kernels by the
+        kernel tuner. It also maintains a reference to the most recently compiled
+        source module for copying data to constant memory before kernel launch.
+
+        :param device: Number of CUDA device to use for this context
+        :type device: int
+
+        :param iterations: Number of iterations used while benchmarking a kernel, 7 by default.
+        :type iterations: int
+        """
+
+        self.allocations = []
+        self.compiler_options = compiler_options
+        self.iterations = iterations
+
+        self.dev = cuda.Device(device)
+        self.dev.use() #make this the current device
+        self.smem_size = 0
+        self.use_nvml = False
+
+        self.stream = cuda.Stream()
+        self.max_threads = self.dev.attributes["MaxThreadsPerBlock"]
+        self.cc = self.dev.compute_capability
+
+        self.env = {"attributes": self.dev.attributes}
+        self.name = "cupy does not name device"
+
+
+
+    def ready_argument_list(self, arguments):
+        """ready argument list to be passed to the kernel, allocates gpu mem
+
+        :param arguments: List of arguments to be passed to the kernel.
+            The order should match the argument list on the CUDA kernel.
+            Allowed values are np.ndarray, and/or np.int32, np.float32, and so on.
+        :type arguments: list(numpy objects)
+
+        :returns: A list of arguments that can be passed to an CUDA kernel.
+        :rtype: list( pycuda.driver.DeviceAllocation, np.int32, ... )
+        """
+        gpu_args = []
+        for arg in arguments:
+            # if arg i is a numpy array copy to device
+            if isinstance(arg, np.ndarray):
+                alloc = cp.asarray(arg)
+                self.allocations.append(alloc)
+                gpu_args.append(alloc)
+            else: # if not an array, just pass argument along
+                #if we remove other checks this might just pass along cupy arrays too
+                gpu_args.append(arg)
+        return gpu_args
+
+
+    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
+            function after compilation.
+        :type kernel_name: string
+
+        :param kernel_string: The CUDA kernel code that contains the function `kernel_name`
+        :type kernel_string: string
+
+        :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:
+            #mimic pycuda behavior for the moment, this can be removed once
+            #https://github.com/cupy/cupy/pull/3319
+            #has been merged
+            no_extern_c = not 'extern "C"' in kernel_string
+            if no_extern_c:
+                kernel_string = 'extern "C" {\n' + kernel_string + '\n}\n'
+
+            #self.current_module = cp.RawModule(code=kernel_string, options=self.compiler_options)
+            self.current_module = cp.RawModule(code=kernel_string)
+
+            func = self.current_module.get_function(kernel_name)
+            return func
+        except Exception as e:
+            if "uses too much shared data" in e.stderr:
+                raise Exception("uses too much shared data")
+            else:
+                raise e
+
+
+    def benchmark(self, func, gpu_args, threads, grid):
+        """runs the kernel and measures time repeatedly, returns average time
+
+        Runs the kernel and measures kernel execution time repeatedly, number of
+        iterations is set during the creation of CudaFunctions. Benchmark returns
+        a robust average, from all measurements the fastest and slowest runs are
+        discarded and the rest is included in the returned average. The reason for
+        this is to be robust against initialization artifacts and other exceptional
+        cases.
+
+        :param func: A PyCuda kernel compiled for this specific kernel configuration
+        :type func: pycuda.driver.Function
+
+        :param gpu_args: A list of arguments to the kernel, order should match the
+            order in the code. Allowed values are either variables in global memory
+            or single values passed by value.
+        :type gpu_args: list( pycuda.driver.DeviceAllocation, np.int32, ...)
+
+        :param threads: A tuple listing the number of threads in each dimension of
+            the thread block
+        :type threads: tuple(int, int, int)
+
+        :param grid: A tuple listing the number of thread blocks in each dimension
+            of the grid
+        :type grid: tuple(int, int)
+
+        :returns: A dictionary with benchmark results.
+        :rtype: dict()
+        """
+        result = dict()
+        result["times"] = []
+        result["power"] = []
+        energy = []
+        start = cuda.Event()
+        end = cuda.Event()
+        self.dev.synchronize()
+        for _ in range(self.iterations):
+            power_readings = []
+            self.stream.record(start)
+            self.run_kernel(func, gpu_args, threads, grid, stream=self.stream)
+            self.stream.record(end)
+            #measure power usage until kernel is done
+            t0 = time.time()
+            while not end.done:
+                if self.use_nvml:
+                    power_readings.append([time.time()-t0, self.nvml.pwr_usage()])
+            end.synchronize()
+            execution_time = cuda.get_elapsed_time(start, end) #ms
+            result["times"].append(execution_time)
+
+            #pre and postfix to start at 0 and end at kernel end
+            if power_readings:
+                power_readings = [[0.0, power_readings[0][1]]] + power_readings
+                power_readings = power_readings + [[execution_time / 1000.0, power_readings[-1][1]]]
+                result["power"].append(power_readings) #time in s, power usage in milliwatts
+
+                #compute energy consumption as area under curve
+                x = [d[0] for d in power_readings]
+                y = [d[1]/1000.0 for d in power_readings] #convert to watts
+                energy.append(np.trapz(y,x)) #in Joule
+
+        result["time"] = np.mean(result["times"])
+        if (self.iterations > 10) and energy:
+            result["energy"] = np.mean(energy[10:])
+        return result
+
+    def copy_constant_memory_args(self, cmem_args):
+        """adds constant memory arguments to the most recently compiled module
+
+        :param cmem_args: A dictionary containing the data to be passed to the
+            device constant memory. The format to be used is as follows: A
+            string key is used to name the constant memory symbol to which the
+            value needs to be copied. Similar to regular arguments, these need
+            to be numpy objects, such as np.ndarray or np.int32, and so on.
+        :type cmem_args: dict( string: np.ndarray, ... )
+        """
+        logging.debug('copy_constant_memory_args called')
+        logging.debug('current module: ' + str(self.current_module))
+        for k, v in cmem_args.items():
+            #symbol = self.current_module.get_global(k)[0]
+            logging.debug('copying to symbol: ' + str(symbol))
+            logging.debug('array to be copied: ')
+            logging.debug(v.nbytes)
+            logging.debug(v.dtype)
+            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
+
+        :param texmem_args: A dictionary containing the data to be passed to the
+            device texture memory. See tune_kernel().
+        :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 }
+
+        logging.debug('copy_texture_memory_args called')
+        logging.debug('current module: ' + str(self.current_module))
+        self.texrefs = []
+        for k, v in texmem_args.items():
+            tex = self.current_module.get_texref(k)
+            self.texrefs.append(tex)
+
+            logging.debug('copying to texture: ' + str(k))
+            if not isinstance(v, dict):
+                data = v
+            else:
+                data = v['array']
+            logging.debug('texture to be copied: ')
+            logging.debug(data.nbytes)
+            logging.debug(data.dtype)
+            logging.debug(data.flags)
+
+            drv.matrix_to_texref(data, tex, order="C")
+
+            if isinstance(v, dict):
+                if 'address_mode' in v and v['address_mode'] is not None:
+                    # address_mode is set per axis
+                    amode = v['address_mode']
+                    if not isinstance(amode, list):
+                        amode = [ amode ] * data.ndim
+                    for i, m in enumerate(amode):
+                        try:
+                            if m is not None:
+                                tex.set_address_mode(i, address_mode_map[m])
+                        except KeyError:
+                            raise ValueError('Unknown address mode: ' + m)
+                if 'filter_mode' in v and v['filter_mode'] is not None:
+                    fmode = v['filter_mode']
+                    try:
+                        tex.set_filter_mode(filter_mode_map[fmode])
+                    except KeyError:
+                        raise ValueError('Unknown filter mode: ' + fmode)
+                if 'normalized_coordinates' in v and v['normalized_coordinates']:
+                    tex.set_flags(tex.get_flags() | drv.TRSF_NORMALIZED_COORDINATES)
+        """
+        pass
+
+
+    def run_kernel(self, func, gpu_args, threads, grid, stream=None):
+        """runs the CUDA kernel passed as 'func'
+
+        :param func: A PyCuda kernel compiled for this specific kernel configuration
+        :type func: pycuda.driver.Function
+
+        :param gpu_args: A list of arguments to the kernel, order should match the
+            order in the code. Allowed values are either variables in global memory
+            or single values passed by value.
+        :type gpu_args: list( pycuda.driver.DeviceAllocation, np.int32, ...)
+
+        :param threads: A tuple listing the number of threads in each dimension of
+            the thread block
+        :type threads: tuple(int, int, int)
+
+        :param grid: A tuple listing the number of thread blocks in each dimension
+            of the grid
+        :type grid: tuple(int, int)
+        """
+        func(grid, threads, gpu_args, shared_mem=self.smem_size)
+
+    def memset(self, allocation, value, size):
+        """set the memory in allocation to the value in value
+
+        :param allocation: A GPU memory allocation unit
+        :type allocation: pycuda.driver.DeviceAllocation
+
+        :param value: The value to set the memory to
+        :type value: a single 8-bit unsigned int
+
+        :param size: The size of to the allocation unit in bytes
+        :type size: int
+
+        """
+        #drv.memset_d8(allocation, value, size)
+        allocation = cp.full_like(allocation, value)
+
+
+    def memcpy_dtoh(self, dest, src):
+        """perform a device to host memory copy
+
+        :param dest: A numpy array in host memory to store the data
+        :type dest: np.ndarray
+
+        :param src: A GPU memory allocation unit
+        :type src: pycuda.driver.DeviceAllocation
+        """
+        if isinstance(src, cp.ndarray):
+            dest = cp.ndarray.get()
+        else:
+            dest = src
+
+    def memcpy_htod(self, dest, src):
+        """perform a host to device memory copy
+
+        :param dest: A GPU memory allocation unit
+        :type dest: pycuda.driver.DeviceAllocation
+
+        :param src: A numpy array in host memory to store the data
+        :type src: np.ndarray
+        """
+        if isinstance(dest, cp.ndarray):
+            cp.copyto(dest, src) #might fail if src is not cupy array
+        else:
+            dest = src
+
+    units = {'time': 'ms',
+             'power': 's,mW',
+             'energy': 'J'}

{kernel_tuner-0.3.0 → kernel_tuner-0.3.1}/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,7 +315,7 @@ _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"))
@@ -357,7 +363,7 @@ _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):
@@ -490,7 +496,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.1/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.1}/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.1}/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.1}/kernel_tuner/util.py

@@ -10,7 +10,6 @@ import logging
 import warnings
 import re
 
-import pytest
 import numpy
 
 default_block_size_names = ["block_size_x", "block_size_y", "block_size_z"]

{kernel_tuner-0.3.0 → kernel_tuner-0.3.1}/kernel_tuner.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kernel-tuner
-Version: 0.3.0
+Version: 0.3.1
 Summary: An easy to use CUDA/OpenCL kernel tuner in Python
 Home-page: http://benvanwerkhoven.github.io/kernel_tuner/
 Author: Ben van Werkhoven
@@ -202,8 +202,8 @@ 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: tutorial
 Provides-Extra: opencl
+Provides-Extra: cuda_opencl
+Provides-Extra: doc

{kernel_tuner-0.3.0 → kernel_tuner-0.3.1}/kernel_tuner.egg-info/SOURCES.txt

@@ -7,7 +7,9 @@ kernel_tuner/__init__.py
 kernel_tuner/c.py
 kernel_tuner/core.py
 kernel_tuner/cuda.py
+kernel_tuner/cupy_backend.py
 kernel_tuner/interface.py
+kernel_tuner/kernelbuilder.py
 kernel_tuner/nvml.py
 kernel_tuner/opencl.py
 kernel_tuner/util.py

{kernel_tuner-0.3.0 → kernel_tuner-0.3.1}/setup.py

@@ -14,7 +14,7 @@ else:
 
 setup(
     name="kernel_tuner",
-    version="0.3.0",
+    version="0.3.1",
     author="Ben van Werkhoven",
     author_email="b.vanwerkhoven@esciencecenter.nl",
     description=("An easy to use CUDA/OpenCL kernel tuner in Python"),

{kernel_tuner-0.3.0 → kernel_tuner-0.3.1}/test/test_c_functions.py

@@ -10,6 +10,7 @@ except ImportError:
     from unittest.mock import patch, Mock
 
 from kernel_tuner.c import CFunctions, Argument
+from kernel_tuner.core import KernelSource, KernelInstance
 
 
 def test_ready_argument_list1():
@@ -119,9 +120,12 @@ def test_compile(npct, subprocess):
 
     kernel_string = "this is a fake C program"
     kernel_name = "blabla"
+    kernel_sources = KernelSource(kernel_string, "C")
+    kernel_instance = KernelInstance(kernel_name, kernel_sources, kernel_string, [], None, None, dict(), [])
 
     cfunc = CFunctions()
-    f = cfunc.compile(kernel_name, kernel_string)
+
+    f = cfunc.compile(kernel_instance)
 
     print(subprocess.mock_calls)
     print(npct.mock_calls)
@@ -141,6 +145,35 @@ def test_compile(npct, subprocess):
     assert not os.path.isfile(filename + ".so")
 
 
+@patch('kernel_tuner.c.subprocess')
+@patch('kernel_tuner.c.numpy.ctypeslib')
+def test_compile_detects_device_code(npct, subprocess):
+
+    kernel_string = "this code clearly contains device code __global__ kernel(float* arg){ return; }"
+    kernel_name = "blabla"
+    kernel_sources = KernelSource(kernel_string, "C")
+    kernel_instance = KernelInstance(kernel_name, kernel_sources, kernel_string, [], None, None, dict(), [])
+
+    cfunc = CFunctions()
+
+    f = cfunc.compile(kernel_instance)
+
+    print(subprocess.check_call.call_args_list)
+
+    #assert the filename suffix used for source compilation is .cu
+    dot_cu_used = False
+    for call in subprocess.check_call.call_args_list:
+        args, kwargs = call
+        args = args[0]
+        print(args)
+        if args[0] == 'nvcc' and args[1] == '-c':
+            assert args[2][-3:] == '.cu'
+            dot_cu_used = True
+
+    assert dot_cu_used
+
+
+
 def test_memset():
     a = [1, 2, 3, 4]
     x = numpy.array(a).astype(numpy.float32)

{kernel_tuner-0.3.0 → kernel_tuner-0.3.1}/test/test_cuda_functions.py

@@ -2,6 +2,7 @@ import numpy
 from .context import skip_if_no_cuda
 
 from kernel_tuner import cuda
+from kernel_tuner.core import KernelSource, KernelInstance
 
 try:
     import pycuda.driver
@@ -39,11 +40,15 @@ def test_compile():
     }
     """
 
+    kernel_sources = KernelSource(original_kernel, "cuda")
+
+
     kernel_string = original_kernel.replace("shared_size", str(100*1024*1024))
+    kernel_instance = KernelInstance("vector_add", kernel_sources, kernel_string, [], None, None, dict(), [])
 
     dev = cuda.CudaFunctions(0)
     try:
-        func = dev.compile("vector_add", kernel_string)
+        func = dev.compile(kernel_instance)
         assert isinstance(func, pycuda.driver.Function)
         print("Expected an exception because too much shared memory is requested")
         assert False
@@ -55,15 +60,16 @@ def test_compile():
             assert False
 
     kernel_string = original_kernel.replace("shared_size", str(100))
+    kernel_instance = KernelInstance("vector_add", kernel_sources, kernel_string, [], None, None, dict(), [])
     try:
-        func = dev.compile("vector_add", kernel_string)
+        func = dev.compile( kernel_instance)
         assert True
     except Exception as e:
         print("Did not expect any exception:")
         print(str(e))
         assert False
 
-def dummy_func(a, b, block=0, grid=0, stream=None, texrefs=None):
+def dummy_func(a, b, block=0, grid=0, stream=None, shared=0, texrefs=None):
     pass
 
 @skip_if_no_cuda

{kernel_tuner-0.3.0 → kernel_tuner-0.3.1}/test/test_cuda_mocked.py

@@ -6,6 +6,7 @@ except ImportError:
     from unittest.mock import patch, Mock
 
 from kernel_tuner import cuda
+from kernel_tuner.core import KernelSource, KernelInstance
 
 def setup_mock(drv):
     context = Mock()
@@ -53,7 +54,9 @@ def test_compile(drv, *args):
 
     #call compile
     kernel_string = "__global__ void vector_add()"
-    func = dev.compile("vector_add", kernel_string)
+    kernel_sources = KernelSource(kernel_string, "cuda")
+    kernel_instance = KernelInstance("vector_add", kernel_sources, kernel_string, [], None, None, dict(), [])
+    func = dev.compile(kernel_instance)
 
     #verify behavior
     assert dev.source_mod.call_count == 1
@@ -66,7 +69,7 @@ def test_compile(drv, *args):
     assert optional_args['arch'] == 'compute_55'
 
 
-def dummy_func(a, b, block=0, grid=0, stream=None, texrefs=None):
+def dummy_func(a, b, block=0, grid=0, shared=0, stream=None, texrefs=None):
     pass
 
 @patch('kernel_tuner.cuda.nvml')

{kernel_tuner-0.3.0 → kernel_tuner-0.3.1}/test/test_interface.py

@@ -30,8 +30,7 @@ def test_interface_calls_functions(dev_interface):
     kernel_name, kernel_string, size, args, tune_params = get_fake_kernel()
     tune_kernel(kernel_name, kernel_string, size, args, tune_params, verbose=True)
 
-    expected = "#define block_size_z 1\n#define block_size_y 1\n#define block_size_x 128\n#define grid_size_z 1\n#define grid_size_y 1\n#define grid_size_x 10\n__global__ void fake_kernel(int number)"
-    dev.compile.assert_called_once_with("fake_kernel", expected)
+    dev.compile.assert_called_once()
     dev.benchmark.assert_called_once_with('compile', 'ready_argument_list', (128, 1, 1), (10, 1, 1))
 
 @patch('kernel_tuner.core.CudaFunctions')
@@ -45,7 +44,8 @@ def test_interface_handles_max_threads(dev_interface):
     kernel_string = "__global__ void fake_kernel(int number)"
     tune_kernel("fake_kernel", kernel_string, (1,1), [numpy.int32(0)], tune_params, lang="CUDA")
 
-    dev.compile.assert_called_once_with("fake_kernel", "#define block_size_z 1\n#define block_size_y 1\n#define block_size_x 256\n#define grid_size_z 1\n#define grid_size_y 1\n#define grid_size_x 1\n__global__ void fake_kernel(int number)")
+    # verify that only a single instance of the kernel is compiled
+    dev.compile.assert_called_once()
 
 @patch('kernel_tuner.core.CudaFunctions')
 def test_interface_handles_compile_error(dev_interface):

{kernel_tuner-0.3.0 → kernel_tuner-0.3.1}/test/test_opencl_functions.py

@@ -2,12 +2,15 @@ import numpy as np
 from .context import skip_if_no_opencl
 
 from kernel_tuner import opencl
+from kernel_tuner.core import KernelSource, KernelInstance
+
 try:
     import pyopencl
 except Exception:
     pass
 
 
+
 @skip_if_no_opencl
 def test_ready_argument_list():
 
@@ -41,10 +44,12 @@ def test_compile():
     }
     """
 
+    kernel_sources = KernelSource(original_kernel, "opencl")
     kernel_string = original_kernel.replace("shared_size", str(1024))
+    kernel_instance = KernelInstance("sum", kernel_sources, kernel_string, [], None, None, dict(), [])
 
     dev = opencl.OpenCLFunctions(0)
-    func = dev.compile("sum", kernel_string)
+    func = dev.compile(kernel_instance)
 
     assert isinstance(func, pyopencl.Kernel)
 

{kernel_tuner-0.3.0 → kernel_tuner-0.3.1}/test/test_util_functions.py

@@ -4,6 +4,7 @@ import json
 import warnings
 
 import numpy
+import pytest
 from pytest import raises
 
 from .context import skip_if_no_cuda, skip_if_no_opencl