kernel-tuner 0.1.3__tar.gz → 0.1.4__tar.gz

{kernel_tuner-0.1.3 → kernel_tuner-0.1.4}/PKG-INFO

@@ -1,20 +1,19 @@
 Metadata-Version: 1.1
 Name: kernel_tuner
-Version: 0.1.3
+Version: 0.1.4
 Summary: A simple 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: A simple CUDA/OpenCL kernel tuner in Python
-        ===========================================
+Description: Kernel Tuner: A simple CUDA/OpenCL kernel tuner in Python
+        =========================================================
         
         |Build Status| |Codacy Badge| |Codacy Badge2|
         
-        The goal of this project is to provide a - as simple as possible - tool
-        for tuning CUDA and OpenCL kernels. This implies that any CUDA or OpenCL
-        kernel can be tuned without requiring extensive changes to the original
-        kernel code.
+        The Kernel Tuner is a - as simple as possible - tool for testing and auto-tuning 
+        CUDA and OpenCL kernels. This means that any CUDA or OpenCL kernel can be tuned 
+        without requiring extensive changes to the original kernel code.
         
         A very common problem in GPU programming is that some combination of
         thread block dimensions and other kernel parameters, like tiling or
@@ -22,18 +21,16 @@ Description: A simple CUDA/OpenCL kernel tuner in Python
         kernel configurations. The goal of auto-tuning is to automate the
         process of finding the best performing configuration for a given device.
         
-        This kernel tuner aims that you can directly use the tuned kernel
-        without introducing any new dependencies. The tuned kernels can
-        afterwards be used independently of the programming environment, whether
-        that is using C/C++/Java/Fortran or Python doesn't matter.
+        The Kernel Tuner offers two main functions which are called run\_kernel and 
+        tune\_kernel. With run\_kernel it's very easy to write unit tests for your GPU 
+        kernels in Python. With tune\_kernel you can auto-tune your kernels using only a 
+        simple Python script. These functions are very flexible and come with a lot of 
+        optional parameters, for a complete list see the `documentation website 
+        <http://benvanwerkhoven.github.io/kernel_tuner/user-api.html>`__.
         
-        The kernel\_tuner module currently only contains main one function which
-        is called tune\_kernel to which you pass at least the kernel name, a
-        string containing the kernel code, the problem size, a list of kernel
-        function arguments, and a dictionary of tunable parameters. There are
-        also a lot of optional parameters, for a complete list see the full
-        documentation of
-        `tune\_kernel <http://benvanwerkhoven.github.io/kernel_tuner/details.html>`__.
+        The Kernel Tuner does not introduce any new dependencies in your kernels. The 
+        tuned kernels can afterwards be used independently of the programming environment, 
+        whether that is using C/C++/Java/Fortran or Python doesn't matter.
         
         Documentation
         -------------
@@ -57,7 +54,6 @@ Description: A simple CUDA/OpenCL kernel tuner in Python
         
             git clone https://github.com/benvanwerkhoven/kernel_tuner.git
             cd kernel_tuner
-            pip install -r requirements.txt
             pip install .
             
         To tune CUDA kernels:
@@ -70,7 +66,9 @@ Description: A simple CUDA/OpenCL kernel tuner in Python
           - First, make sure you have an OpenCL compiler for your intended OpenCL platform
           - You can install PyOpenCL using ``pip install pyopencl``
         
-        If you need more information about how to install the Kernel Tuner and all dependencies see the `installation guide <http://benvanwerkhoven.github.io/kernel_tuner/install.html>`__
+        If you need more information about how to install the Kernel Tuner and all 
+        dependencies see the `installation guide 
+        <http://benvanwerkhoven.github.io/kernel_tuner/install.html>`__
         
         Example usage
         -------------
@@ -114,17 +112,18 @@ Description: A simple CUDA/OpenCL kernel tuner in Python
             }
             """
         
-        Or even just a C function, see the example
-        `here <https://github.com/benvanwerkhoven/kernel_tuner/blob/master/examples/c/vector_add.py>`__.
-        
-        You can find these and many - more extensive - example codes, in the
-        `examples <https://github.com/benvanwerkhoven/kernel_tuner/blob/master/examples/>`__
-        directory.
-        
-        See the `full
-        documentation <http://benvanwerkhoven.github.io/kernel_tuner/index.html>`__
-        for several highly detailed tutorial-style explanations of example
-        kernels and the scripts to tune them.
+        The Kernel Tuner will detect the kernel language and select the right compiler and 
+        runtime. For every kernel in the parameter space, the Kernel Tuner will insert C 
+        preprocessor defines for the tunable parameters, compile, and benchmark the kernel. The 
+        timing results will be printed to the console, but are also returned by tune_kernel to 
+        allow further analysis. Note that this is just the default behavior, what and how 
+        tune_kernel does exactly is controlled through its many `optional arguments 
+        <http://benvanwerkhoven.github.io/kernel_tuner/user-api.html#kernel_tuner.tune_kernel>`__.
+        
+        You can find many - more extensive - example codes, in the
+        `examples directory <https://github.com/benvanwerkhoven/kernel_tuner/blob/master/examples/>`__
+        and in the `Kernel Tuner
+        documentation pages <http://benvanwerkhoven.github.io/kernel_tuner/index.html>`__.
         
         Tuning host and kernel code
         ---------------------------

{kernel_tuner-0.1.3 → kernel_tuner-0.1.4}/README.rst

@@ -1,12 +1,11 @@
-A simple CUDA/OpenCL kernel tuner in Python
-===========================================
+Kernel Tuner: A simple CUDA/OpenCL kernel tuner in Python
+=========================================================
 
 |Build Status| |Codacy Badge| |Codacy Badge2|
 
-The goal of this project is to provide a - as simple as possible - tool
-for tuning CUDA and OpenCL kernels. This implies that any CUDA or OpenCL
-kernel can be tuned without requiring extensive changes to the original
-kernel code.
+The Kernel Tuner is a - as simple as possible - tool for testing and auto-tuning 
+CUDA and OpenCL kernels. This means that any CUDA or OpenCL kernel can be tuned 
+without requiring extensive changes to the original kernel code.
 
 A very common problem in GPU programming is that some combination of
 thread block dimensions and other kernel parameters, like tiling or
@@ -14,18 +13,16 @@ unrolling factors, results in dramatically better performance than other
 kernel configurations. The goal of auto-tuning is to automate the
 process of finding the best performing configuration for a given device.
 
-This kernel tuner aims that you can directly use the tuned kernel
-without introducing any new dependencies. The tuned kernels can
-afterwards be used independently of the programming environment, whether
-that is using C/C++/Java/Fortran or Python doesn't matter.
+The Kernel Tuner offers two main functions which are called run\_kernel and 
+tune\_kernel. With run\_kernel it's very easy to write unit tests for your GPU 
+kernels in Python. With tune\_kernel you can auto-tune your kernels using only a 
+simple Python script. These functions are very flexible and come with a lot of 
+optional parameters, for a complete list see the `documentation website 
+<http://benvanwerkhoven.github.io/kernel_tuner/user-api.html>`__.
 
-The kernel\_tuner module currently only contains main one function which
-is called tune\_kernel to which you pass at least the kernel name, a
-string containing the kernel code, the problem size, a list of kernel
-function arguments, and a dictionary of tunable parameters. There are
-also a lot of optional parameters, for a complete list see the full
-documentation of
-`tune\_kernel <http://benvanwerkhoven.github.io/kernel_tuner/details.html>`__.
+The Kernel Tuner does not introduce any new dependencies in your kernels. The 
+tuned kernels can afterwards be used independently of the programming environment, 
+whether that is using C/C++/Java/Fortran or Python doesn't matter.
 
 Documentation
 -------------
@@ -49,7 +46,6 @@ examples and the tutorials:
 
     git clone https://github.com/benvanwerkhoven/kernel_tuner.git
     cd kernel_tuner
-    pip install -r requirements.txt
     pip install .
     
 To tune CUDA kernels:
@@ -62,7 +58,9 @@ To tune OpenCL kernels:
   - First, make sure you have an OpenCL compiler for your intended OpenCL platform
   - You can install PyOpenCL using ``pip install pyopencl``
 
-If you need more information about how to install the Kernel Tuner and all dependencies see the `installation guide <http://benvanwerkhoven.github.io/kernel_tuner/install.html>`__
+If you need more information about how to install the Kernel Tuner and all 
+dependencies see the `installation guide 
+<http://benvanwerkhoven.github.io/kernel_tuner/install.html>`__
 
 Example usage
 -------------
@@ -106,17 +104,18 @@ The exact same Python code can be used to tune an OpenCL kernel:
     }
     """
 
-Or even just a C function, see the example
-`here <https://github.com/benvanwerkhoven/kernel_tuner/blob/master/examples/c/vector_add.py>`__.
-
-You can find these and many - more extensive - example codes, in the
-`examples <https://github.com/benvanwerkhoven/kernel_tuner/blob/master/examples/>`__
-directory.
-
-See the `full
-documentation <http://benvanwerkhoven.github.io/kernel_tuner/index.html>`__
-for several highly detailed tutorial-style explanations of example
-kernels and the scripts to tune them.
+The Kernel Tuner will detect the kernel language and select the right compiler and 
+runtime. For every kernel in the parameter space, the Kernel Tuner will insert C 
+preprocessor defines for the tunable parameters, compile, and benchmark the kernel. The 
+timing results will be printed to the console, but are also returned by tune_kernel to 
+allow further analysis. Note that this is just the default behavior, what and how 
+tune_kernel does exactly is controlled through its many `optional arguments 
+<http://benvanwerkhoven.github.io/kernel_tuner/user-api.html#kernel_tuner.tune_kernel>`__.
+
+You can find many - more extensive - example codes, in the
+`examples directory <https://github.com/benvanwerkhoven/kernel_tuner/blob/master/examples/>`__
+and in the `Kernel Tuner
+documentation pages <http://benvanwerkhoven.github.io/kernel_tuner/index.html>`__.
 
 Tuning host and kernel code
 ---------------------------

{kernel_tuner-0.1.3 → kernel_tuner-0.1.4}/kernel_tuner/c.py

@@ -1,16 +1,17 @@
 """ This module contains the functionality for running and compiling C functions """
 
-import numpy
-import ctypes as C
-import _ctypes
 import subprocess
-import os
+import platform
 import errno
+import logging
+import ctypes as C
+import _ctypes
 
+import numpy
 import numpy.ctypeslib
-from kernel_tuner.util import get_temp_filename, delete_temp_file
 
-import logging
+from kernel_tuner.util import get_temp_filename, delete_temp_file, write_file
+
 
 class CFunctions(object):
     """Class that groups the code for running and compiling C functions"""
@@ -21,20 +22,46 @@ class CFunctions(object):
         :param iterations: Number of iterations used while benchmarking a kernel, 7 by default.
         :type iterations: int
         """
-        self.ITERATIONS = iterations
+        self.iterations = iterations
         self.max_threads = 1024
         self.compiler_options = compiler_options
         self.lib = None
+        self.using_openmp = False
+        self.arg_mapping = dict()
 
-        #test if nvcc is available, otherwise use gcc
-        self.compiler = "nvcc"
+        #use gcc by default
+        self.compiler = "g++"
         try:
-            subprocess.check_call([self.compiler, "--version"], stdout=open(os.devnull, 'w'))
+            gcc_version = str(subprocess.check_output([self.compiler, "--version"]))
+            gcc_version = gcc_version.splitlines()[0].split(" ")[-1]
+        except OSError as e:
+            raise e
+
+        #check if nvcc is available
+        self.nvcc_available = False
+        try:
+            nvcc_version = str(subprocess.check_output(["nvcc", "--version"]))
+            nvcc_version = nvcc_version.splitlines()[-1].split(" ")[-1]
+            self.nvcc_available = True
         except OSError as e:
-            self.compiler = "gcc"
             if e.errno != errno.ENOENT:
                 raise e
 
+        #environment info
+        env = dict()
+        env["GCC Version"] = gcc_version
+        if self.nvcc_available:
+            env["NVCC Version"] = nvcc_version
+        env["iterations"] = self.iterations
+        env["compiler_options"] = compiler_options
+        self.env = env
+        self.name = platform.processor()
+
+    def get_environment(self):
+        """Return dictionary with information about the environment"""
+        return self.env
+
+
     def ready_argument_list(self, arguments):
         """ready argument list to be passed to the C function
 
@@ -46,39 +73,30 @@ class CFunctions(object):
         :returns: A list of arguments that can be passed to the C function.
         :rtype: list()
         """
-        self.arg_mapping = dict()
         ctype_args = []
+
+        dtype_map = {"int32": C.c_int32,
+                     "int64": C.c_int64,
+                     "float32": C.c_float,
+                     "float64": C.c_double}
+        np_to_c_type_map = {numpy.int32: C.c_int32,
+                            numpy.int64: C.c_int64,
+                            numpy.float32: C.c_float,
+                            numpy.float64: C.c_double}
+
         for arg in arguments:
             if isinstance(arg, numpy.ndarray):
-                if arg.dtype == 'float32':
-                    ctype_args.append(arg.ctypes.data_as(C.POINTER(C.c_float)))
-                elif arg.dtype == 'float64':
-                    ctype_args.append(arg.ctypes.data_as(C.POINTER(C.c_double)))
-                elif arg.dtype == 'int32':
-                    ctype_args.append(arg.ctypes.data_as(C.POINTER(C.c_int)))
+                dtype_str = str(arg.dtype)
+                if dtype_str in dtype_map.keys():
+                    ctype_args.append(arg.ctypes.data_as(C.POINTER(dtype_map[dtype_str])))
                 else:
                     raise TypeError("unknown dtype for ndarray")
                 self.arg_mapping[str(ctype_args[-1])] = arg.shape
-            elif numpy.isscalar(arg):
-                if hasattr(arg, 'dtype'):
-                    np_to_c_type_map = { numpy.int32: C.c_int32,
-                            numpy.int64: C.c_int64,
-                            numpy.float32: C.c_float,
-                            numpy.float64: C.c_double }
-                    if type(arg) in np_to_c_type_map:
-                        ctype_args.append(np_to_c_type_map[type(arg)](arg))
-                    else:
-                        raise TypeError("Argument is scalar with a dtype, but does not start with int or float")
-                else:
-                    if isinstance(arg, int):
-                        ctype_args.append(C.c_int(arg))
-                    elif isinstance(arg, float):
-                        ctype_args.append(C.c_float(arg))
-                    else:
-                        raise TypeError("Argument is scalar without dtype, and is not instance of int or float")
+            elif isinstance(arg, tuple(np_to_c_type_map.keys())):
+                ctype_args.append(np_to_c_type_map[type(arg)](arg))
                 self.arg_mapping[str(ctype_args[-1])] = ()
             else:
-                raise TypeError("Argument is not a numpy.ndarray and is not a scalar %s" % type(arg))
+                raise TypeError("Argument is not numpy ndarray or numpy scalar %s" % type(arg))
 
         return ctype_args
 
@@ -103,12 +121,20 @@ class CFunctions(object):
 
         filename = get_temp_filename()
         source_file = filename+".cc"
-        kernel_string = "extern \"C\" {\n" + kernel_string + "\n}"
+
+        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:
+            logging.debug('set using_openmp to true')
+            self.using_openmp = True
             compiler_options.append("-fopenmp")
 
+        if ("#include <cuda" in kernel_string) or ("__global__" in kernel_string):
+            if self.nvcc_available:
+                self.compiler = "nvcc"
+
         if self.compiler == "nvcc":
             source_file = source_file[:-1] + "u"
             compiler_options = ["-Xcompiler=" + c for c in compiler_options]
@@ -120,12 +146,15 @@ class CFunctions(object):
         if "CL/cl.h" in kernel_string:
             lib_args = ["-lOpenCL"]
 
+        logging.debug('using compiler ' + self.compiler)
+        logging.debug('compiler_options ' + " ".join(compiler_options))
+        logging.debug('lib_args ' + " ".join(lib_args))
+
         try:
-            with open(source_file, 'w') as f:
-                f.write(kernel_string)
+            write_file(source_file, kernel_string)
 
             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+".so"] + lib_args)
+            subprocess.check_call([self.compiler, filename+".o"] + compiler_options + ["-shared", "-o", filename+".so"] + lib_args)
 
             self.lib = numpy.ctypeslib.load_library(filename, '.')
 
@@ -175,8 +204,19 @@ class CFunctions(object):
         :rtype: float
         """
         results = []
-        for _ in range(self.ITERATIONS):
+        for _ in range(self.iterations):
             value = self.run_kernel(func, c_args, threads, grid)
+
+            #I would like to replace the following with actually capturing
+            #stderr and detecting the error directly in Python, it proved
+            #however that capturing stderr for non-Python functions from Python
+            #is a rather difficult thing to do
+            #
+            #The current, less than ideal, scheme uses the convention that a
+            #negative time indicates a 'too many resources requested for launch'
+            if value < 0.0:
+                raise Exception("too many resources requested for launch")
+
             results.append(value)
         results = sorted(results)
         return numpy.mean(results[1:-1])
@@ -209,16 +249,6 @@ class CFunctions(object):
 
         time = func(*c_args)
 
-        #I would like to replace the following with actually capturing
-        #stderr and detecting the error directly in Python, it proved
-        #however that capturing stderr for non-Python functions from Python
-        #is a rather difficult thing to do
-        #
-        #The current, less than ideal, scheme uses the convention that a
-        #negative time indicates a 'too many resources requested for launch'
-        if time < 0.0:
-            raise Exception("too many resources requested for launch")
-
         return time
 
 
@@ -251,4 +281,8 @@ class CFunctions(object):
 
     def cleanup_lib(self):
         """ unload the previously loaded shared library """
-        _ctypes.dlclose(self.lib._handle)
+        if not self.using_openmp:
+            #this if statement is necessary because shared libraries that use
+            #OpenMP will core dump when unloaded, this is a well-known issue with OpenMP
+            logging.debug('unloading shared library')
+            _ctypes.dlclose(self.lib._handle)

kernel_tuner-0.1.4/kernel_tuner/core.py

@@ -0,0 +1,198 @@
+""" Module for grouping the core functionality needed by most runners """
+from __future__ import print_function
+
+import resource
+import logging
+import numpy
+
+from kernel_tuner.cuda import CudaFunctions
+from kernel_tuner.opencl import OpenCLFunctions
+from kernel_tuner.c import CFunctions
+import kernel_tuner.util as util
+
+def get_device_interface(lang, device, platform, compiler_options=None):
+    """ Instantiate the device functions interface, based on language """
+    if lang == "CUDA":
+        dev = CudaFunctions(device, compiler_options=compiler_options)
+    elif lang == "OpenCL":
+        dev = OpenCLFunctions(device, platform, compiler_options=compiler_options)
+    elif lang == "C":
+        dev = CFunctions(compiler_options=compiler_options)
+    else:
+        raise Exception("Sorry, support for languages other than CUDA, OpenCL, or C is not implemented yet")
+    return dev
+
+def run_kernel(dev, func, gpu_args, instance):
+    """ Run a compiled kernel instance on a device """
+    threads = instance["threads"]
+    grid = instance["grid"]
+    try:
+        dev.run_kernel(func, gpu_args, threads, grid)
+    except Exception as e:
+        if "too many resources requested for launch" in str(e) or "OUT_OF_RESOURCES" in str(e):
+            logging.debug('ignoring runtime failure due to too many resources required')
+            return False
+        else:
+            logging.debug('encountered unexpected runtime failure: ' + str(e))
+            raise e
+    return True
+
+def check_kernel_correctness(dev, func, gpu_args, instance, answer, verbose, atol=1e-6):
+    """runs the kernel once and checks the result against answer"""
+    logging.debug('check_kernel_correctness')
+    params = instance["params"]
+
+    #zero GPU memory for output arguments
+    for result, expected in zip(gpu_args, answer):
+        if expected is not None:
+            dev.memset(result, 0, expected.nbytes)
+
+    #run the kernel
+    if not run_kernel(dev, func, gpu_args, instance):
+        return True #runtime failure occured that should be ignored, skip correctness check
+
+    #check correctness of each output argument
+    correct = True
+    for result, expected in zip(gpu_args, answer):
+        if expected is not None:
+            result_host = numpy.zeros_like(expected)
+            dev.memcpy_dtoh(result_host, result)
+            output_test = numpy.allclose(result_host.ravel(), expected.ravel(), atol=atol)
+            if not output_test and verbose:
+                print("Error: " + util.get_config_string(params) + " detected during correctness check")
+                print("Printing kernel output and expected result, set verbose=False to suppress this debug print")
+                numpy.set_printoptions(edgeitems=50)
+                print("Kernel output:")
+                print(result_host)
+                print("Expected:")
+                print(expected)
+            correct = correct and output_test
+            del result_host
+    if not correct:
+        logging.debug('correctness check has found a correctness issue')
+        raise Exception("Error: " + util.get_config_string(params) + " failed correctness check")
+    return correct
+
+def compile_kernel(dev, instance, verbose):
+    """compile the kernel for this specific instance"""
+    logging.debug('compile_kernel ' + instance["name"])
+
+    #compile kernel_string into device func
+    func = None
+    try:
+        func = dev.compile(instance["name"], instance["kernel_string"])
+    except Exception as e:
+        #compiles may fail because certain kernel configurations use too
+        #much shared memory for example, the desired behavior is to simply
+        #skip over this configuration and try the next one
+        if "uses too much shared data" in str(e):
+            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")
+        else:
+            logging.debug('compile_kernel failed due to error: ' + str(e))
+            print("Error while compiling:", instance["name"])
+            raise e
+    return func
+
+def benchmark(dev, func, gpu_args, instance, verbose):
+    """benchmark the kernel instance"""
+    logging.debug('benchmark ' + instance["name"])
+    threads = instance["threads"]
+    grid = instance["grid"]
+    logging.debug('thread block dimensions x,y,z=%d,%d,%d', *threads)
+    logging.debug('grid dimensions x,y,z=%d,%d,%d', *grid)
+
+    time = None
+    try:
+        time = dev.benchmark(func, gpu_args, threads, grid)
+    except Exception as e:
+        #some launches may fail because too many registers are required
+        #to run the kernel given the current thread block size
+        #the desired behavior is to simply skip over this configuration
+        #and proceed to try the next one
+        if "too many resources requested for launch" in str(e) or "OUT_OF_RESOURCES" in str(e):
+            logging.debug('benchmark fails due to runtime failure too many resources required')
+            if verbose:
+                print("skipping config", instance["name"], "reason: too many resources requested for launch")
+        else:
+            logging.debug('benchmark encountered runtime failure: ' + str(e))
+            print("Error while benchmarking:", instance["name"])
+            raise e
+    return time
+
+def create_kernel_instance(dev, kernel_name, original_kernel, problem_size, grid_div, params, verbose):
+    """create kernel instance from kernel strings, parameters, problem size, grid divisors, and so on"""
+    instance_string = util.get_instance_string(params)
+
+    #setup thread block and grid dimensions
+    threads, grid = util.setup_block_and_grid(problem_size, grid_div, params)
+    if numpy.prod(threads) > dev.max_threads:
+        if verbose:
+            print("skipping config", instance_string, "reason: too many threads per block")
+        return None
+
+    temp_files = dict()
+    #obtain the kernel_string and prepare additional files, if any
+    if isinstance(original_kernel, list):
+        kernel_string, temp_files = util.prepare_list_of_files(original_kernel, params, grid)
+    else:
+        kernel_string = util.get_kernel_string(original_kernel)
+
+    #prepare kernel_string for compilation
+    name, kernel_string = util.setup_kernel_strings(kernel_name, kernel_string, params, grid)
+
+    #collect everything we know about this instance in a dict and return it
+    instance = dict()
+    instance["name"] = name
+    instance["kernel_string"] = kernel_string
+    instance["temp_files"] = temp_files
+    instance["threads"] = threads
+    instance["grid"] = grid
+    instance["params"] = params
+    return instance
+
+
+def compile_and_benchmark(dev, gpu_args, kernel_name, original_kernel, params,
+                          problem_size, grid_div, cmem_args, answer, atol, verbose):
+    """ Compile and benchmark a kernel instance based on kernel strings and parameters """
+
+    instance_string = util.get_instance_string(params)
+
+    logging.debug('compile_and_benchmark ' + instance_string)
+    mem_usage = round(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024.0, 1)
+    logging.debug('Memory usage : %2.2f MB', mem_usage)
+
+    instance = create_kernel_instance(dev, kernel_name, original_kernel, problem_size, grid_div, params, verbose)
+    if instance is None:
+        return None
+
+    try:
+        #compile the kernel
+        func = compile_kernel(dev, instance, verbose)
+        if func is None:
+            return None
+
+        #add constant memory arguments to compiled module
+        if cmem_args is not None:
+            dev.copy_constant_memory_args(cmem_args)
+
+        #test kernel for correctness and benchmark
+        if answer is not None:
+            check_kernel_correctness(dev, func, gpu_args, instance, answer, verbose, atol)
+
+        #benchmark
+        time = benchmark(dev, func, gpu_args, instance, verbose)
+
+    except Exception as e:
+        #dump kernel_string to temp file
+        temp_filename = util.get_temp_filename() + ".c"
+        util.write_file(temp_filename, instance["kernel_string"])
+        print("Error while compiling or benchmarking, see source files: " + temp_filename + " ".join(instance["temp_files"].values()))
+        raise e
+
+    #clean up any temporary files, if no error occured
+    for v in instance["temp_files"].values():
+        util.delete_temp_file(v)
+
+    return time