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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kernel_tuner
-Version: 0.3.1
+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
-Provides-Extra: tutorial
 Provides-Extra: opencl
 Provides-Extra: cuda_opencl
-Provides-Extra: doc
+Provides-Extra: tutorial
+Provides-Extra: dev

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

@@ -90,19 +90,21 @@ 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_instance):

{kernel_tuner-0.3.1 → 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
@@ -349,7 +349,8 @@ class DeviceInterface(object):
             #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.1 → kernel_tuner-0.3.2}/kernel_tuner/interface.py

@@ -318,7 +318,8 @@ _tuning_options = Options([
     ("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([
@@ -366,7 +367,7 @@ def tune_kernel(kernel_name, kernel_string, problem_size, arguments,
                 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)
@@ -450,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")
 

{kernel_tuner-0.3.1 → 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.1 → 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)

{kernel_tuner-0.3.1 → kernel_tuner-0.3.2}/kernel_tuner/util.py

@@ -10,7 +10,7 @@ import logging
 import warnings
 import re
 
-import numpy
+import numpy as np
 
 default_block_size_names = ["block_size_x", "block_size_y", "block_size_z"]
 
@@ -36,7 +36,7 @@ def check_argument_list(kernel_name, kernel_string, args):
     """ raise an exception if a kernel arguments do not match host arguments """
     kernel_arguments = list()
     collected_errors = list()
-    for iterator in re.finditer(kernel_name + "[ \n\t]*" + "\(", kernel_string):
+    for iterator in re.finditer(kernel_name + "[ \n\t]*" + r"\(", kernel_string):
         kernel_start = iterator.end()
         kernel_end = kernel_string.find(")", kernel_start)
         if kernel_start != 0:
@@ -49,11 +49,11 @@ def check_argument_list(kernel_name, kernel_string, args):
         for (i, arg) in enumerate(args):
             kernel_argument = arguments[i]
 
-            if not isinstance(arg, (numpy.ndarray, numpy.generic)):
-                raise TypeError("Argument at position " + str(i) + " of type: " + str(type(arg)) + " should be of type numpy.ndarray or numpy scalar")
+            if not isinstance(arg, (np.ndarray, np.generic)):
+                raise TypeError("Argument at position " + str(i) + " of type: " + str(type(arg)) + " should be of type np.ndarray or numpy scalar")
 
             correct = True
-            if isinstance(arg, numpy.ndarray) and not "*" in kernel_argument:
+            if isinstance(arg, np.ndarray) and not "*" in kernel_argument:
                 correct = False  #array is passed to non-pointer kernel argument
 
             if correct and check_argument_type(str(arg.dtype), kernel_argument):
@@ -131,6 +131,12 @@ def detect_language(kernel_string):
 
 def get_config_string(params, keys=None, units=None):
     """ return a compact string representation of a measurement """
+    def compact_number(v):
+        if isinstance(v, float):
+            return "{:.3f}".format(round(v, 3))
+        else:
+            return str(v)
+
     compact_str_items = []
     if not keys:
         keys = params.keys()
@@ -140,7 +146,7 @@ def get_config_string(params, keys=None, units=None):
             unit = ""
             if isinstance(units, dict): #check if not None not enough, units could be mocked which causes errors
                 unit = units.get(k, "")
-            compact_str_items.append(k + "=" + str(v) + unit)
+            compact_str_items.append(k + "=" + compact_number(v) + unit)
     # and finally join them
     compact_str = ", ".join(compact_str_items)
     return compact_str
@@ -154,9 +160,9 @@ def get_grid_dimensions(current_problem_size, params, grid_div, block_size_names
                 divisor_list = [default]
             else:
                 return 1
-        return numpy.prod([int(eval(replace_param_occurrences(s, params))) for s in divisor_list])
+        return np.prod([int(eval(replace_param_occurrences(s, params))) for s in divisor_list])
     divisors = [get_dimension_divisor(d, block_size_names[i], params) for i, d in enumerate(grid_div)]
-    return tuple(int(numpy.ceil(float(current_problem_size[i]) / float(d))) for i, d in enumerate(divisors))
+    return tuple(int(np.ceil(float(current_problem_size[i]) / float(d))) for i, d in enumerate(divisors))
 
 def get_instance_string(params):
     """ combine the parameters to a string mostly used for debug output
@@ -206,13 +212,13 @@ def get_kernel_string(kernel_source, params=None):
 
 def get_problem_size(problem_size, params):
     """compute current problem size"""
-    if isinstance(problem_size, (str, int, numpy.integer)):
+    if isinstance(problem_size, (str, int, np.integer)):
         problem_size = (problem_size, )
     current_problem_size = [1, 1, 1]
     for i, s in enumerate(problem_size):
         if isinstance(s, str):
             current_problem_size[i] = int(eval(replace_param_occurrences(s, params)))
-        elif isinstance(s, (int, numpy.integer)):
+        elif isinstance(s, (int, np.integer)):
             current_problem_size[i] = s
         else:
             raise TypeError("Error: problem_size should only contain strings or integers")
@@ -234,6 +240,60 @@ def get_thread_block_dimensions(params, block_size_names=None):
     block_size_z = params.get(block_size_names[2], 1)
     return (int(block_size_x), int(block_size_y), int(block_size_z))
 
+def print_config_output(tune_params, params, quiet, metrics, units):
+    """print the configuration string with tunable parameters and benchmark results"""
+    print_keys = list(tune_params.keys())+["time"]
+    if metrics:
+        print_keys += metrics.keys()
+    output_string = get_config_string(params, print_keys, units)
+    if not quiet:
+        print(output_string)
+
+def process_metrics(params, metrics):
+    """ process user-defined metrics for derived benchmark results
+
+    Metrics must be an OrderedDict to support composable metrics. The dictionary keys describe
+    the name given to this user-defined metric and will be used as the key in the results dictionaries
+    return by Kernel Tuner. The values describe how to calculate the user-defined metric, using either a
+    string expression in which the tunable parameters and benchmark results can be used as variables, or
+    as a function that accepts a dictionary as argument.
+    Example:
+    metrics = OrderedDict()
+    metrics["x"] = "10000 / time"
+    metrics["x2"] = "x*x"
+
+    Note that the values in the metric dictionary can also be functions that accept params as argument.
+    Example:
+    metrics = OrderedDict()
+    metrics["GFLOP/s"] = lambda p : 10000 / p["time"]
+
+    :param params: A dictionary with tunable parameters and benchmark results.
+    :type params: dict
+
+    :param metrics: An OrderedDict with user-defined metrics that can be used to create derived benchmark results.
+    :type metrics: OrderedDict
+
+    :returns: An updated params dictionary with the derived metrics inserted along with the benchmark results.
+    :rtype: dict
+
+    """
+    if not isinstance(metrics, OrderedDict):
+        raise ValueError("metrics should be an OrderedDict to preserve order and support composability")
+    for k, v in metrics.items():
+        if isinstance(v, str):
+            value = eval(replace_param_occurrences(v, params))
+        elif callable(v):
+            value = v(params)
+        else:
+            raise ValueError("metric dicts values should be strings or callable")
+        if not k in params:
+            params[k] = value
+        else:
+            raise ValueError("metric dicts keys should not already exist in params")
+    return params
+
+
+
 def looks_like_a_filename(kernel_source):
     """ attempt to detect whether source code or a filename was passed """
     logging.debug('looks_like_a_filename called')
@@ -256,7 +316,7 @@ def looks_like_a_filename(kernel_source):
     logging.debug('kernel_source is a filename: %s' % str(result))
     return result
 
-def prepare_kernel_string(kernel_name, kernel_string, params, grid, threads, block_size_names):
+def prepare_kernel_string(kernel_name, kernel_string, params, grid, threads, block_size_names, lang):
     """ prepare kernel string for compilation
 
     Prepends the kernel with a series of C preprocessor defines specific
@@ -298,11 +358,24 @@ def prepare_kernel_string(kernel_name, kernel_string, params, grid, threads, blo
     for i, g in enumerate(threads):
         kernel_string = "#define " + block_size_names[i] + " " + str(g) + "\n" + kernel_string
     for k, v in params.items():
-        if k not in block_size_names:
+        if "loop_unroll_factor" in k and lang == "CUDA":
+            #this handles the special case that in CUDA
+            #pragma unroll loop_unroll_factor, loop_unroll_factor should be a constant integer expression
+            #in OpenCL this isn't the case and we can just insert "#define loop_unroll_factor N"
+            if v > 0: # using 0 to disable loop unrolling for this loop
+                kernel_string = "const int " + k + " = " + str(v) + ";\n" + kernel_string
+            else:
+                kernel_string = re.sub(r"\n\s*#pragma\s+unroll\s+" + k, "\n", kernel_string)  # + r"[^\S]*"
+        elif k not in block_size_names:
             kernel_string = "#define " + k + " " + str(v) + "\n" + kernel_string
+
     name = kernel_name
+
+    #also insert kernel_tuner token
+    kernel_string = "#define kernel_tuner 1\n" + kernel_string
     #name = kernel_name + "_" + get_instance_string(params)
     #kernel_string = kernel_string.replace(kernel_name, name)
+
     return name, kernel_string
 
 def read_file(filename):
@@ -467,11 +540,23 @@ def close_cache(cache):
 
 
 def store_cache(key, params, tuning_options):
+    """ stores a new entry (key, params) to the cachefile """
+    # create converter for dumping numpy objects to JSON
+    def npconverter(obj):
+        if isinstance(obj, np.integer):
+            return int(obj)
+        elif isinstance(obj, np.floating):
+            return float(obj)
+        elif isinstance(obj, np.ndarray):
+            return obj.tolist()
+        else:
+            return obj.__str__()
+
     logging.debug('store_cache called, cache=%s, cachefile=%s' % (tuning_options.cache, tuning_options.cachefile))
     if isinstance(tuning_options.cache, dict):
         if not key in tuning_options.cache:
             tuning_options.cache[key] = params
             if tuning_options.cachefile:
                 with open(tuning_options.cachefile, "a") as cachefile:
-                    cachefile.write("\n" + json.dumps({key: params})[1:-1] + ",")
+                    cachefile.write("\n" + json.dumps({key: params}, default=npconverter)[1:-1] + ",")
 

{kernel_tuner-0.3.1 → kernel_tuner-0.3.2}/kernel_tuner/wrappers.py

@@ -90,7 +90,7 @@ def cpp(function_name, kernel_source, args, convert_to_array=None):
         for i, arg in enumerate(args):
             if convert_to_array[i]:
                 if not isinstance(arg, np.ndarray):
-                    ValueError("conversion to array reference only supported for arguments that are numpy arrays, use length-1 numpy array to pass a scalar by reference")
+                    raise ValueError("conversion to array reference only supported for arguments that are numpy arrays, use length-1 numpy array to pass a scalar by reference")
                 if np.prod(arg.shape) > 1:
                     #convert pointer to a reference to an array
                     arg_shape = "".join("[%d]" % i for i in arg.shape)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: kernel-tuner
-Version: 0.3.1
+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
-Provides-Extra: tutorial
 Provides-Extra: opencl
 Provides-Extra: cuda_opencl
-Provides-Extra: doc
+Provides-Extra: tutorial
+Provides-Extra: dev

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

@@ -7,7 +7,6 @@ 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-0.3.1 → kernel_tuner-0.3.2}/setup.py

@@ -14,7 +14,7 @@ else:
 
 setup(
     name="kernel_tuner",
-    version="0.3.1",
+    version="0.3.2",
     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.1 → kernel_tuner-0.3.2}/test/test_c_functions.py

@@ -89,9 +89,9 @@ def test_ready_argument_list5():
 
     assert all(output[0].numpy == arg1)
 
-    # test that a copy has been made
+    # test that a copy has not been made
     arg1[0] = arg1[0] + 1
-    assert not all(output[0].numpy == arg1)
+    assert all(output[0].numpy == arg1)
 
 
 def test_byte_array_arguments():

{kernel_tuner-0.3.1 → kernel_tuner-0.3.2}/test/test_core.py

@@ -39,7 +39,7 @@ def env():
     verbose = True
     kernel_options = Options(kernel_name="vector_add", kernel_string=kernel_string, problem_size=args[-1], arguments=args, lang=lang,
                           grid_div_x=None, grid_div_y=None, grid_div_z=None, cmem_args=None, texmem_args=None, block_size_names=None)
-    device_options = Options(device=0, platform=0, lang=lang, quiet=False, compiler=None, compiler_options=None)
+    device_options = Options(device=0, platform=0, quiet=False, compiler=None, compiler_options=None)
     dev = core.DeviceInterface(kernel_source, iterations=7, **device_options)
     instance = dev.create_kernel_instance(kernel_source, kernel_options, params, verbose)
 

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

@@ -29,38 +29,18 @@ def test_ready_argument_list():
 @skip_if_no_cuda
 def test_compile():
 
-    original_kernel = """
+    kernel_string = """
     __global__ void vector_add(float *c, float *a, float *b, int n) {
-        __shared__ float test[shared_size];
         int i = blockIdx.x * blockDim.x + threadIdx.x;
         if (i<n) {
-            test[0] = a[i];
-            c[i] = test[0] + b[i];
+            c[i] = a[i] + b[i];
         }
     }
     """
 
-    kernel_sources = KernelSource(original_kernel, "cuda")
-
-
-    kernel_string = original_kernel.replace("shared_size", str(100*1024*1024))
+    kernel_sources = KernelSource(kernel_string, "cuda")
     kernel_instance = KernelInstance("vector_add", kernel_sources, kernel_string, [], None, None, dict(), [])
-
     dev = cuda.CudaFunctions(0)
-    try:
-        func = dev.compile(kernel_instance)
-        assert isinstance(func, pycuda.driver.Function)
-        print("Expected an exception because too much shared memory is requested")
-        assert False
-    except Exception as e:
-        if "uses too much shared data" in str(e):
-            assert True
-        else:
-            print("Expected a different exception:" + str(e))
-            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( kernel_instance)
         assert True

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

@@ -81,8 +81,7 @@ def test_benchmark(drv, *args):
     drv.Event.return_value.time_since.return_value = 0.1
 
     dev = cuda.CudaFunctions(0)
-    args = [1, 2]
-    res = dev.benchmark(dummy_func, args, (1,2), (1,2))
+    res = dev.benchmark(dummy_func, [1,2], (1,2), (1,2))
     assert res["time"] > 0
 
     assert dev.context.synchronize.call_count == 1

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

@@ -30,8 +30,8 @@ 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)
 
-    dev.compile.assert_called_once()
-    dev.benchmark.assert_called_once_with('compile', 'ready_argument_list', (128, 1, 1), (10, 1, 1))
+    dev.compile.assert_called()
+    dev.benchmark.assert_called_with('compile', 'ready_argument_list', (128, 1, 1), (10, 1, 1))
 
 @patch('kernel_tuner.core.CudaFunctions')
 def test_interface_handles_max_threads(dev_interface):
@@ -45,7 +45,7 @@ def test_interface_handles_max_threads(dev_interface):
     tune_kernel("fake_kernel", kernel_string, (1,1), [numpy.int32(0)], tune_params, lang="CUDA")
 
     # verify that only a single instance of the kernel is compiled
-    dev.compile.assert_called_once()
+    dev.compile.assert_called()
 
 @patch('kernel_tuner.core.CudaFunctions')
 def test_interface_handles_compile_error(dev_interface):
@@ -58,7 +58,7 @@ def test_interface_handles_compile_error(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")
 
-    assert dev.compile.call_count == 1
+    assert dev.compile.call_count == 2
     assert dev.benchmark.called == False
 
 @patch('kernel_tuner.core.CudaFunctions')
@@ -72,8 +72,8 @@ def test_interface_handles_restriction(dev_interface):
     kernel_string = "__global__ void fake_kernel(int number)"
     tune_kernel("fake_kernel", kernel_string, (1,1), [numpy.int32(0)], tune_params, restrictions=restrict, lang="CUDA", verbose=True)
 
-    assert dev.compile.call_count == 1
-    dev.benchmark.assert_called_once_with('compile', 'ready_argument_list', (256, 1, 1), (1, 1, 1))
+    assert dev.compile.call_count == 2
+    dev.benchmark.assert_called_with('compile', 'ready_argument_list', (256, 1, 1), (1, 1, 1))
 
 @patch('kernel_tuner.core.CudaFunctions')
 def test_interface_handles_runtime_error(dev_interface):
@@ -86,8 +86,8 @@ def test_interface_handles_runtime_error(dev_interface):
     kernel_string = "__global__ void fake_kernel(int number)"
     results, _ = tune_kernel("fake_kernel",kernel_string, (1,1), [numpy.int32(0)], tune_params, lang="CUDA")
 
-    assert dev.compile.call_count == 1
-    dev.benchmark.assert_called_once_with('compile', 'ready_argument_list', (256, 1, 1), (1, 1, 1))
+    assert dev.compile.call_count == 2
+    dev.benchmark.assert_called_with('compile', 'ready_argument_list', (256, 1, 1), (1, 1, 1))
     assert len(results) == 0
 
 @patch('kernel_tuner.core.CudaFunctions')
@@ -99,6 +99,6 @@ def test_run_kernel(dev_interface):
     answer = run_kernel(kernel_name, kernel_string, size, args, {"block_size_x": 128})
 
     assert dev.compile.call_count == 1
-    dev.run_kernel.assert_called_once_with('compile', 'ready_argument_list', (128, 1, 1), (10, 1, 1))
+    dev.run_kernel.assert_called_with('compile', 'ready_argument_list', (128, 1, 1), (10, 1, 1))
     assert answer[0] == size
 

{kernel_tuner-0.3.1 → kernel_tuner-0.3.2}/test/test_minimize.py

@@ -16,6 +16,7 @@ def test_get_bounds_x0_eps():
     tune_params['x'] = [0, 1, 2, 3, 4]
 
     tuning_options["tune_params"] = tune_params
+    tuning_options["strategy_options"] = {}
 
     bounds, x0, eps = minimize.get_bounds_x0_eps(tuning_options)
 

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

@@ -126,8 +126,9 @@ def test_prepare_kernel_string():
     params = dict()
     params["is"] = 8
 
-    _, output = prepare_kernel_string("this", kernel, params, (3,7), (1,2,3), block_size_names)
-    expected = "#define is 8\n" \
+    _, output = prepare_kernel_string("this", kernel, params, (3,7), (1,2,3), block_size_names, "")
+    expected = "#define kernel_tuner 1\n" \
+               "#define is 8\n" \
                "#define block_size_z 3\n" \
                "#define block_size_y 2\n" \
                "#define block_size_x 1\n" \
@@ -454,7 +455,7 @@ def test_process_cache():
         assert len(tuning_options.cache) == 0
 
         #store one entry in the cache
-        params = {"x": 4, "time": 0.1234}
+        params = {"x": 4, "time": numpy.float32(0.1234)}
         store_cache("4", params, tuning_options)
         assert len(tuning_options.cache) == 1
 
@@ -487,3 +488,38 @@ def test_process_cache():
     finally:
         delete_temp_file(cache)
         #pass
+
+
+def test_process_metrics():
+    params = {"x": 15, "b": 12}
+    metrics = OrderedDict()
+    metrics["y"] = lambda p : p["x"]
+
+    #test if lambda function is correctly evaluated
+    params = process_metrics(params, metrics)
+    assert params["y"] == params["x"]
+
+    #test if we can do the same with a string
+    params = {"x": 15, "b": 12}
+    metrics["y"] = "x"
+    params = process_metrics(params, metrics)
+    assert params["y"] == params["x"]
+
+    #test if composability works correctly
+    params = {"x": 15, "b": 12}
+    metrics = OrderedDict()
+    metrics["y"] = "x"
+    metrics["z"] = "y"
+    params = process_metrics(params, metrics)
+    assert params["z"] == params["x"]
+
+    #test ValueError is raised when metrics is not an OrderedDict
+    with pytest.raises(ValueError):
+        params = process_metrics(params, {})
+
+    #test ValueError is raised when b already exists in params
+    params = {"x": 15, "b": 12}
+    metrics = OrderedDict()
+    metrics["b"] = "x"
+    with pytest.raises(ValueError):
+        params = process_metrics(params, metrics)

kernel_tuner-0.3.1/kernel_tuner/cupy_backend.py

@@ -1,331 +0,0 @@
-"""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'}