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

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

@@ -1,15 +1,15 @@
-Metadata-Version: 1.1
+Metadata-Version: 2.1
 Name: kernel_tuner
-Version: 0.1.9
-Summary: A simple CUDA/OpenCL kernel tuner in Python
+Version: 0.3.0
+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
 License: Apache 2.0
-Description: Kernel Tuner: A Search-Optimizing GPU Code Auto-Tuner
-        =========================================================
+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.
         
@@ -99,6 +99,23 @@ Description: Kernel Tuner: A Search-Optimizing GPU Code Auto-Tuner
         and in the `Kernel Tuner
         documentation pages <http://benvanwerkhoven.github.io/kernel_tuner/index.html>`__.
         
+        Search strategies for tuning
+        ----------------------------
+        
+        Kernel Tuner supports many optimization algorithms to accelerate the auto-tuning process. Currently 
+        implemented search algorithms are: Brute Force (default), Nelder-Mead, Powell, CG, BFGS, L-BFGS-B, TNC, 
+        COBYLA, SLSQP, Random Search, Basinhopping, Differential Evolution, a Genetic Algorithm, Particle Swarm 
+        Optimization, the Firefly Algorithm, and Simulated Annealing.
+        
+        .. image:: doc/gemm-amd-summary.png
+            :width: 100%
+            :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"``. 
+        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
         ---------------------------
         
@@ -113,12 +130,6 @@ Description: Kernel Tuner: A Search-Optimizing GPU Code Auto-Tuner
         `documentation <http://benvanwerkhoven.github.io/kernel_tuner/hostcode.html>`__
         for a detailed explanation of the kernel tuner Python script.
         
-        Search strategies for tuning
-        ----------------------------
-        
-        Kernel Tuner supports several strategies: brute_force (default), random_sample, minimize, basinhopping, and diff_evo (differential
-        evolution). Using different strategies is easy, you only need to specify to ``tune_kernel`` which strategy you would like to use, for example: ``strategy="basinhopping", method="TNC"``. For a full overview of the supported search strategies and methods please see the
-        `user api <http://benvanwerkhoven.github.io/kernel_tuner/user-api.html>`__.
         
         Correctness verification
         ------------------------
@@ -140,33 +151,40 @@ Description: Kernel Tuner: A Search-Optimizing GPU Code Auto-Tuner
         
         Citation
         --------
-        A scientific paper about the Kernel Tuner is in preparation, in the meantime please cite the Kernel Tuner as follows:
+        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
         
-            @misc{vanwerkhoven2018kerneltuner,
-              author = {Ben van Werkhoven},
-              title = {Kernel Tuner: A Search-Optimizing GPU Code Auto-Tuner},
-              year = {2018}
+            @article{kerneltuner,
+              author  = {Ben van Werkhoven},
+              title   = {Kernel Tuner: A search-optimizing GPU code auto-tuner},
+              journal = {Future Generation Computer Systems},
+              year = {2019},
+              volume  = {90},
+              pages = {347-358},
+              doi = {https://doi.org/10.1016/j.future.2018.08.004},
             }
         
         Related work
         ------------
         
         You may also like `CLTune <https://github.com/CNugteren/CLTune>`__ by
-        Cedric Nugteren. CLTune is a C++ library for kernel tuning and supports
-        various advanced features like machine learning to optimize the time
-        spent on tuning kernels.
+        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/
         
+        
+        
+        
+        
+        
+        
 Keywords: auto-tuning gpu computing pycuda cuda pyopencl opencl
 Platform: UNKNOWN
 Classifier: Environment :: Console
@@ -176,9 +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: dev
+Provides-Extra: doc
+Provides-Extra: cuda_opencl
+Provides-Extra: tutorial
+Provides-Extra: cuda
+Provides-Extra: opencl

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

@@ -1,7 +1,7 @@
-Kernel Tuner: A Search-Optimizing GPU Code Auto-Tuner
-=========================================================
+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.
 
@@ -91,6 +91,23 @@ You can find many - more extensive - example codes, in the
 and in the `Kernel Tuner
 documentation pages <http://benvanwerkhoven.github.io/kernel_tuner/index.html>`__.
 
+Search strategies for tuning
+----------------------------
+
+Kernel Tuner supports many optimization algorithms to accelerate the auto-tuning process. Currently 
+implemented search algorithms are: Brute Force (default), Nelder-Mead, Powell, CG, BFGS, L-BFGS-B, TNC, 
+COBYLA, SLSQP, Random Search, Basinhopping, Differential Evolution, a Genetic Algorithm, Particle Swarm 
+Optimization, the Firefly Algorithm, and Simulated Annealing.
+
+.. image:: doc/gemm-amd-summary.png
+    :width: 100%
+    :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"``. 
+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
 ---------------------------
 
@@ -105,12 +122,6 @@ and the
 `documentation <http://benvanwerkhoven.github.io/kernel_tuner/hostcode.html>`__
 for a detailed explanation of the kernel tuner Python script.
 
-Search strategies for tuning
-----------------------------
-
-Kernel Tuner supports several strategies: brute_force (default), random_sample, minimize, basinhopping, and diff_evo (differential
-evolution). Using different strategies is easy, you only need to specify to ``tune_kernel`` which strategy you would like to use, for example: ``strategy="basinhopping", method="TNC"``. For a full overview of the supported search strategies and methods please see the
-`user api <http://benvanwerkhoven.github.io/kernel_tuner/user-api.html>`__.
 
 Correctness verification
 ------------------------
@@ -132,29 +143,36 @@ Please see the `Contributions Guide <http://benvanwerkhoven.github.io/kernel_tun
 
 Citation
 --------
-A scientific paper about the Kernel Tuner is in preparation, in the meantime please cite the Kernel Tuner as follows:
+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
 
-    @misc{vanwerkhoven2018kerneltuner,
-      author = {Ben van Werkhoven},
-      title = {Kernel Tuner: A Search-Optimizing GPU Code Auto-Tuner},
-      year = {2018}
+    @article{kerneltuner,
+      author  = {Ben van Werkhoven},
+      title   = {Kernel Tuner: A search-optimizing GPU code auto-tuner},
+      journal = {Future Generation Computer Systems},
+      year = {2019},
+      volume  = {90},
+      pages = {347-358},
+      doi = {https://doi.org/10.1016/j.future.2018.08.004},
     }
 
 Related work
 ------------
 
 You may also like `CLTune <https://github.com/CNugteren/CLTune>`__ by
-Cedric Nugteren. CLTune is a C++ library for kernel tuning and supports
-various advanced features like machine learning to optimize the time
-spent on tuning kernels.
+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.1.9 → kernel_tuner-0.3.0}/kernel_tuner/c.py

@@ -4,6 +4,7 @@ from collections import namedtuple
 import subprocess
 import platform
 import errno
+import re
 import logging
 import ctypes as C
 import _ctypes
@@ -17,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):
@@ -38,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"]))
@@ -75,28 +82,29 @@ 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):
         """call the C compiler to compile the kernel, return the function
 
@@ -115,25 +123,41 @@ class CFunctions(object):
         if self.lib != None:
             self.cleanup_lib()
 
-        suffix = ".cc"
-
-        if not "extern \"C\"" in kernel_string:
-            kernel_string = "extern \"C\" {\n" + kernel_string + "\n}"
-
         compiler_options = ["-fPIC"]
-        if "#include <omp.h>" in kernel_string:
+
+        #detect openmp
+        if "#include <omp.h>" in kernel_string or "use omp_lib" in kernel_string:
             logging.debug('set using_openmp to true')
             self.using_openmp = True
-            compiler_options.append("-fopenmp")
+            if self.compiler == "pgfortran":
+                compiler_options.append("-mp")
+            else:
+                compiler_options.append("-fopenmp")
 
-        if ("#include <cuda" in kernel_string) or ("__global__" in kernel_string):
-            if self.nvcc_available:
+        # TODO: Get suffix from KernelSources, and adapt the logic below
+
+        #select right suffix based on compiler
+        suffix = ".cc"
+
+        #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 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 self.compiler == "nvcc":
-            suffix = suffix[:-1] + "u"
             compiler_options = ["-Xcompiler=" + c for c in compiler_options]
 
+        if ".c" in suffix:
+            if not "extern \"C\"" in kernel_string:
+                kernel_string = "extern \"C\" {\n" + kernel_string + "\n}"
+
+        #copy user specified compiler options to current list
         if self.compiler_options:
             compiler_options += self.compiler_options
 
@@ -148,6 +172,16 @@ class CFunctions(object):
         source_file = get_temp_filename(suffix=suffix)
         filename = ".".join(source_file.split(".")[:-1])
 
+        #detect Fortran modules
+        match = re.search(r"\s*module\s+([a-zA-Z_]*)", kernel_string)
+        if match:
+            if self.compiler == "gfortran":
+                kernel_name = "__" + match.group(1) + "_MOD_" + kernel_name
+            elif self.compiler in ["ftn", "ifort"]:
+                kernel_name = match.group(1) + "_mp_" + kernel_name + "_"
+            elif self.compiler == "pgfortran":
+                kernel_name = match.group(1) + "_" + kernel_name + "_"
+
         try:
             write_file(source_file, kernel_string)
 
@@ -158,8 +192,8 @@ class CFunctions(object):
             subprocess.check_call([self.compiler, "-c", source_file] + compiler_options + ["-o", filename + ".o"])
             subprocess.check_call([self.compiler, filename + ".o"] + compiler_options + ["-shared", "-o", filename + lib_extension] + lib_args)
 
-            self.lib = numpy.ctypeslib.load_library(filename, '.')
 
+            self.lib = numpy.ctypeslib.load_library(filename, '.')
             func = getattr(self.lib, kernel_name)
             func.restype = C.c_float
 
@@ -172,7 +206,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
@@ -193,7 +227,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.
@@ -203,14 +237,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)
 
@@ -221,19 +252,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
@@ -244,7 +269,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.
@@ -258,40 +283,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 """