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

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

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: kernel_tuner
-Version: 0.2.0
-Summary: A simple CUDA/OpenCL kernel tuner in Python
+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
 Author-email: b.vanwerkhoven@esciencecenter.nl
@@ -9,7 +9,7 @@ License: Apache 2.0
 Description: Kernel Tuner
         ============
         
-        |Build Status| |Codacy Badge| |Codacy Badge2| |PyPi Badge|
+        |Build Status| |CodeCov Badge| |PyPi 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.
         
@@ -112,8 +112,8 @@ Description: Kernel Tuner
             :align: center
         
         Using a search strategy is easy, you only need to specify to ``tune_kernel`` which strategy and method 
-        you would like to use, for example ``strategy="genetic_algorithm"`` or ``strategy="basinhopping", 
-        method="Powell"``. For a full overview of the supported search strategies and methods please see the `user 
+        you would like to use, for example ``strategy="genetic_algorithm"`` or ``strategy="basinhopping"``. 
+        For a full overview of the supported search strategies and methods please see the `user 
         api documentation <http://benvanwerkhoven.github.io/kernel_tuner/user-api.html>`__.
         
         Tuning host and kernel code
@@ -151,7 +151,7 @@ Description: Kernel Tuner
         
         Citation
         --------
-        A scientific paper about Kernel Tuner has been accepted for publication, please cite
+        The paper about `Kernel Tuner is published (Open Access) <https://www.sciencedirect.com/science/article/pii/S0167739X18313359>`__, please cite
         Kernel Tuner as follows:
         
         .. code:: latex
@@ -174,13 +174,17 @@ Description: Kernel Tuner
         
         .. |Build Status| image:: https://api.travis-ci.org/benvanwerkhoven/kernel_tuner.svg?branch=master
            :target: https://travis-ci.org/benvanwerkhoven/kernel_tuner
-        .. |Codacy Badge| image:: https://api.codacy.com/project/badge/grade/016dc85044ab4d57b777449d93275608
-           :target: https://www.codacy.com/app/b-vanwerkhoven/kernel_tuner
-        .. |Codacy Badge2| image:: https://api.codacy.com/project/badge/coverage/016dc85044ab4d57b777449d93275608
-           :target: https://www.codacy.com/app/b-vanwerkhoven/kernel_tuner
+        .. |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 
            :target: https://pypi.python.org/pypi/kernel_tuner/
         
+        
+        
+        
+        
+        
+        
 Keywords: auto-tuning gpu computing pycuda cuda pyopencl opencl
 Platform: UNKNOWN
 Classifier: Environment :: Console
@@ -190,15 +194,16 @@ Classifier: Intended Audience :: Education
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Natural Language :: English
 Classifier: Operating System :: POSIX :: Linux
-Classifier: Programming Language :: Python :: 2.7
 Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Classifier: Topic :: System :: Distributed Computing
 Classifier: Development Status :: 4 - Beta
-Provides-Extra: cuda_opencl
-Provides-Extra: cuda
 Provides-Extra: dev
+Provides-Extra: cuda
 Provides-Extra: tutorial
 Provides-Extra: opencl
+Provides-Extra: cuda_opencl
 Provides-Extra: doc

{kernel_tuner-0.2.0 → kernel_tuner-0.3.1}/README.rst

@@ -1,7 +1,7 @@
 Kernel Tuner
 ============
 
-|Build Status| |Codacy Badge| |Codacy Badge2| |PyPi Badge|
+|Build Status| |CodeCov Badge| |PyPi 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.
 
@@ -104,8 +104,8 @@ Optimization, the Firefly Algorithm, and Simulated Annealing.
     :align: center
 
 Using a search strategy is easy, you only need to specify to ``tune_kernel`` which strategy and method 
-you would like to use, for example ``strategy="genetic_algorithm"`` or ``strategy="basinhopping", 
-method="Powell"``. For a full overview of the supported search strategies and methods please see the `user 
+you would like to use, for example ``strategy="genetic_algorithm"`` or ``strategy="basinhopping"``. 
+For a full overview of the supported search strategies and methods please see the `user 
 api documentation <http://benvanwerkhoven.github.io/kernel_tuner/user-api.html>`__.
 
 Tuning host and kernel code
@@ -143,7 +143,7 @@ Please see the `Contributions Guide <http://benvanwerkhoven.github.io/kernel_tun
 
 Citation
 --------
-A scientific paper about Kernel Tuner has been accepted for publication, please cite
+The paper about `Kernel Tuner is published (Open Access) <https://www.sciencedirect.com/science/article/pii/S0167739X18313359>`__, please cite
 Kernel Tuner as follows:
 
 .. code:: latex
@@ -166,9 +166,13 @@ 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
-.. |Codacy Badge| image:: https://api.codacy.com/project/badge/grade/016dc85044ab4d57b777449d93275608
-   :target: https://www.codacy.com/app/b-vanwerkhoven/kernel_tuner
-.. |Codacy Badge2| image:: https://api.codacy.com/project/badge/coverage/016dc85044ab4d57b777449d93275608
-   :target: https://www.codacy.com/app/b-vanwerkhoven/kernel_tuner
+.. |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 
    :target: https://pypi.python.org/pypi/kernel_tuner/
+
+
+
+
+
+

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

@@ -18,10 +18,17 @@ dtype_map = {"int8": C.c_int8,
              "int16": C.c_int16,
              "int32": C.c_int32,
              "int64": C.c_int64,
+             "uint8": C.c_uint8,
+             "uint16": C.c_uint16,
+             "uint32": C.c_uint32,
+             "uint64": C.c_uint64,
              "float32": C.c_float,
              "float64": C.c_double}
 
-Argument = namedtuple("Argument", ["type", "shape"])
+# This represents an individual kernel argument.
+# It contains a numpy object (ndarray or number) and a ctypes object with a copy
+# of the argument data. For an ndarray, the ctypes object is a wrapper for the ndarray's data.
+Argument = namedtuple("Argument", ["numpy", "ctypes"])
 
 
 class CFunctions(object):
@@ -39,7 +46,6 @@ class CFunctions(object):
         self.compiler = compiler or "g++"  # use gcc by default
         self.lib = None
         self.using_openmp = False
-        self.arg_mapping = dict()
 
         try:
             cc_version = str(subprocess.check_output([self.compiler, "--version"]))
@@ -76,29 +82,30 @@ class CFunctions(object):
         :type arguments: list(numpy objects)
 
         :returns: A list of arguments that can be passed to the C function.
-        :rtype: list()
+        :rtype: list(Argument)
         """
-        ctype_args = [None for _ in arguments]
-        self.arg_mapping = dict()
+        ctype_args = [ None for _ in arguments]
 
         for i, arg in enumerate(arguments):
-            if not isinstance(arg, (numpy.ndarray, numpy.generic)):
+            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)
-            arg_info = Argument(dtype_str, arg.shape)
+            data = arg.copy()
             if isinstance(arg, numpy.ndarray):
                 if dtype_str in dtype_map.keys():
-                    ctype_args[i] = arg.ctypes.data_as(C.POINTER(dtype_map[dtype_str]))
+                    # 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]))
                 else:
                     raise TypeError("unknown dtype for ndarray")
-                self.arg_mapping[str(ctype_args[i])] = arg_info
             elif isinstance(arg, numpy.generic):
-                ctype_args[i] = dtype_map[dtype_str](arg)
-                self.arg_mapping[str(i)] = arg_info
+                data_ctypes = dtype_map[dtype_str](arg)
+            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
@@ -111,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()
@@ -127,19 +136,31 @@ class CFunctions(object):
             else:
                 compiler_options.append("-fopenmp")
 
+        #if filename is known, use that one
+        suffix = kernel_instance.kernel_source.get_user_suffix()
+
+        #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 ("__global__" 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"
 
-        #select right suffix based on compiler
-        suffix = ".cc"
-        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":
-            suffix = suffix[:-1] + "u"
             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}"
@@ -169,7 +190,6 @@ class CFunctions(object):
             elif self.compiler == "pgfortran":
                 kernel_name = match.group(1) + "_" + kernel_name + "_"
 
-
         try:
             write_file(source_file, kernel_string)
 
@@ -182,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:
@@ -194,7 +214,7 @@ class CFunctions(object):
         return func
 
 
-    def benchmark(self, func, c_args, threads, grid, times):
+    def benchmark(self, func, c_args, threads, grid):
         """runs the kernel repeatedly, returns averaged returned value
 
         The C function tuning is a little bit more flexible than direct CUDA
@@ -215,7 +235,7 @@ class CFunctions(object):
         :param c_args: A list of arguments to the function, order should match the
             order in the code. The list should be prepared using
             ready_argument_list().
-        :type c_args: list()
+        :type c_args: list(Argument)
 
         :param threads: Ignored, but left as argument for now to have the same
             interface as CudaFunctions and OpenCLFunctions.
@@ -225,14 +245,11 @@ class CFunctions(object):
             interface as CudaFunctions and OpenCLFunctions.
         :type grid: any
 
-        :param times: Return the execution time of all iterations.
-        :type times: bool
-
-        :returns: All execution times, if times=True, or a robust average for the
-            kernel execution time.
-        :rtype: float
+        :returns: All execution times.
+        :rtype: dict()
         """
-        time = []
+        result = dict()
+        result["times"] = []
         for _ in range(self.iterations):
             value = self.run_kernel(func, c_args, threads, grid)
 
@@ -243,19 +260,13 @@ class CFunctions(object):
             #
             #The current, less than ideal, scheme uses the convention that a
             #negative time indicates a 'too many resources requested for launch'
+            #which Kernel Tuner can silently ignore
             if value < 0.0:
                 raise Exception("too many resources requested for launch")
 
-            time.append(value)
-        time = sorted(time)
-        if times:
-            return time
-        else:
-            if self.iterations > 4:
-                return numpy.mean(time[1:-1])
-            else:
-                return numpy.mean(time)
-
+            result["times"].append(value)
+        result["time"] = numpy.mean(result["times"])
+        return result
 
     def run_kernel(self, func, c_args, threads, grid):
         """runs the kernel once, returns whatever the kernel returns
@@ -266,7 +277,7 @@ class CFunctions(object):
         :param c_args: A list of arguments to the function, order should match the
             order in the code. The list should be prepared using
             ready_argument_list().
-        :type c_args: list()
+        :type c_args: list(Argument)
 
         :param threads: Ignored, but left as argument for now to have the same
             interface as CudaFunctions and OpenCLFunctions.
@@ -280,40 +291,47 @@ class CFunctions(object):
         :rtype: float
         """
         logging.debug("run_kernel")
-        logging.debug("arguments=" + str([str(arg) for arg in c_args]))
+        logging.debug("arguments=" + str([str(arg.ctypes) for arg in c_args]))
 
-        time = func(*c_args)
+        time = func(*[arg.ctypes for arg in c_args])
 
         return time
 
-
     def memset(self, allocation, value, size):
         """set the memory in allocation to the value in value
 
-        :param allocation: A memory allocation unit
-        :type allocation: pycuda.driver.DeviceAllocation
+        :param allocation: An Argument for some memory allocation unit
+        :type allocation: Argument
 
         :param value: The value to set the memory to
-        :type value: a single 32-bit float or int
+        :type value: a single 8-bit unsigned int
 
         :param size: The size of to the allocation unit in bytes
         :type size: int
         """
-        C.memset(allocation, value, size)
-
+        C.memset(allocation.ctypes, value, size)
 
     def memcpy_dtoh(self, dest, src):
-        """a simple memcpy expects a ctypes pointer, returns a numpy array
+        """a simple memcpy copying from an Argument to a numpy array
 
         :param dest: A numpy array to store the data
         :type dest: numpy.ndarray
 
-        :param src: A ctypes pointer to some memory allocation
-        :type src: ctypes.pointer
+        :param src: An Argument for some memory allocation
+        :type src: Argument
         """
-        arginfo = self.arg_mapping[str(src)]
-        dest[:] = numpy.ctypeslib.as_array(src, shape=arginfo.shape)
+        dest[:] = src.numpy
+
+    def memcpy_htod(self, dest, src):
+        """a simple memcpy copying from a numpy array to an Argument
 
+        :param dest: An Argument for some memory allocation
+        :type dst: Argument
+
+        :param src: A numpy array containing the source data
+        :type src: numpy.ndarray
+        """
+        dest.numpy[:] = src
 
     def cleanup_lib(self):
         """ unload the previously loaded shared library """