kernel-tuner 0.1.1__tar.gz → 0.1.2__tar.gz

{kernel_tuner-0.1.1 → kernel_tuner-0.1.2}/MANIFEST.in

@@ -1,3 +1,3 @@
 include setup.py
 include LICENSE
-include README.md
+include README.rst

kernel_tuner-0.1.2/PKG-INFO

@@ -0,0 +1,232 @@
+Metadata-Version: 1.1
+Name: kernel_tuner
+Version: 0.1.2
+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
+        ===========================================
+        
+        |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.
+        
+        A very common problem in GPU programming is that some combination of
+        thread block dimensions and other kernel parameters, like tiling or
+        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 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>`__.
+        
+        Documentation
+        -------------
+        
+        The full documentation is available
+        `here <http://benvanwerkhoven.github.io/kernel_tuner/index.html>`__.
+        
+        Installation
+        ------------
+        
+        To install from PyPi:  
+        
+        - ``pip install kernel_tuner``  
+        
+        To install from the source (and get the tutorial and examples):  
+        
+        - clone the repository  
+         
+          - With a GitHub account: ``git clone git@github.com:benvanwerkhoven/kernel_tuner.git``  
+          - Without GitHub account: ``git clone https://github.com/benvanwerkhoven/kernel_tuner.git``  
+           
+        - change into the top-level directory  
+        
+          - ``cd kernel_tuner``  
+           
+        - install using  
+         
+          - ``pip install .``  
+        
+        Dependencies
+        ------------
+        Python 2.7 or Python 3.5
+        
+        PyCuda and/or PyOpenCL (https://mathema.tician.de/software/)
+        
+        - To tune CUDA kernels
+        
+          - Make sure you have the `CUDA Toolkit <https://developer.nvidia.com/cuda-toolkit>`_ installed 
+          - You can install PyCuda using ``pip install pycuda`` 
+        
+        - To tune OpenCL kernels
+        
+          - Make sure you have an OpenCL compiler for your intended OpenCL platform
+          - You can install PyOpenCL using ``pip install pyopencl``
+        
+        Example usage
+        -------------
+        
+        The following shows a simple example for tuning a CUDA kernel:
+        
+        .. code:: python
+        
+            kernel_string = """
+            __global__ void vector_add(float *c, float *a, float *b, int n) {
+                int i = blockIdx.x * block_size_x + threadIdx.x;
+                if (i<n) {
+                    c[i] = a[i] + b[i];
+                }
+            }
+            """
+        
+            size = 10000000
+        
+            a = numpy.random.randn(size).astype(numpy.float32)
+            b = numpy.random.randn(size).astype(numpy.float32)
+            c = numpy.zeros_like(b)
+            n = numpy.int32(size)
+            args = [c, a, b, n]
+        
+            tune_params = dict()
+            tune_params["block_size_x"] = [128+64*i for i in range(15)]
+        
+            tune_kernel("vector_add", kernel_string, size, args, tune_params)
+        
+        The exact same Python code can be used to tune an OpenCL kernel:
+        
+        .. code:: python
+        
+            kernel_string = """
+            __kernel void vector_add(__global float *c, __global float *a, __global float *b, int n) {
+                int i = get_global_id(0);
+                if (i<n) {
+                    c[i] = a[i] + b[i];
+                }
+            }
+            """
+        
+        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.
+        
+        Tuning host and kernel code
+        ---------------------------
+        
+        It is also possible to tune for combinations of tunable parameters in
+        both host and kernel code. This allows for a number of powerfull things,
+        such as tuning the number of streams for a kernel that uses CUDA Streams
+        or OpenCL Command Queues to overlap transfers between host and device
+        with kernel execution. This can be done in combination with tuning the
+        parameters inside the kernel code. See the `convolution\_streams example
+        code <https://github.com/benvanwerkhoven/kernel_tuner/blob/master/examples/>`__
+        and the
+        `documentation <http://benvanwerkhoven.github.io/kernel_tuner/hostcode.html>`__
+        for a detailed explanation of the kernel tuner Python script.
+        
+        Correctness verification
+        ------------------------
+        
+        Optionally, you can let the kernel tuner verify the output of every
+        kernel it compiles and benchmarks, by passing an ``answer`` list. This
+        list matches the list of arguments to the kernel, but contains the
+        expected output of the kernel. Input arguments are replaced with None.
+        
+        .. code:: python
+        
+            answer = [a+b, None, None]  # the order matches the arguments (in args) to the kernel
+            tune_kernel("vector_add", kernel_string, size, args, tune_params, answer=answer)
+        
+        Contribution guide
+        ------------------
+        
+        The kernel tuner follows the Google Python style guide, with Sphinxdoc
+        docstrings for module public functions. If you want to contribute to the
+        project please fork it, create a branch including your addition, and
+        create a pull request.
+        
+        The tests use relative imports and can be run directly after making
+        changes to the code. To run all tests use ``nosetests`` in the main
+        directory. To run the examples after code changes, you need to run
+        ``pip install --upgrade .`` in the main directory. Documentation is
+        generated by typing ``make html`` in the doc directory, the contents of
+        ``doc/build/html/`` should then be copied to ``sphinxdoc`` directory of
+        the ``gh-pages`` branch.
+        
+        Before creating a pull request please ensure the following:
+        
+        * You have written unit tests to test your additions and all unit tests pass
+        * The examples still work and produce the same (or better) results
+        * The code is compatible with both Python 2.7 and Python 3.5
+        * An entry about the change or addition is created in CHANGELOG.md
+        
+        Contributing authors so far:
+        
+        * Ben van Werkhoven
+        * Berend Weel
+        
+        Citation
+        --------
+        A scientific paper about the Kernel Tuner is in preparation, in the meantime please cite the Kernel Tuner as follows:
+        
+        .. code:: latex
+        
+            @misc{
+              author = {Ben van Werkhoven},
+              title = {Kernel Tuner: A simple CUDA/OpenCL Kernel Tuner in Python},
+              year = {2017}
+            }
+        
+        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.
+        
+        .. |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
+        
+Keywords: auto-tuning gpu computing pycuda cuda pyopencl opencl
+Platform: UNKNOWN
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+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: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Classifier: Topic :: System :: Distributed Computing
+Classifier: Development Status :: 4 - Beta

kernel_tuner-0.1.2/README.rst

@@ -0,0 +1,208 @@
+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.
+
+A very common problem in GPU programming is that some combination of
+thread block dimensions and other kernel parameters, like tiling or
+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 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>`__.
+
+Documentation
+-------------
+
+The full documentation is available
+`here <http://benvanwerkhoven.github.io/kernel_tuner/index.html>`__.
+
+Installation
+------------
+
+To install from PyPi:  
+
+- ``pip install kernel_tuner``  
+
+To install from the source (and get the tutorial and examples):  
+
+- clone the repository  
+ 
+  - With a GitHub account: ``git clone git@github.com:benvanwerkhoven/kernel_tuner.git``  
+  - Without GitHub account: ``git clone https://github.com/benvanwerkhoven/kernel_tuner.git``  
+   
+- change into the top-level directory  
+
+  - ``cd kernel_tuner``  
+   
+- install using  
+ 
+  - ``pip install .``  
+
+Dependencies
+------------
+Python 2.7 or Python 3.5
+
+PyCuda and/or PyOpenCL (https://mathema.tician.de/software/)
+
+- To tune CUDA kernels
+
+  - Make sure you have the `CUDA Toolkit <https://developer.nvidia.com/cuda-toolkit>`_ installed 
+  - You can install PyCuda using ``pip install pycuda`` 
+
+- To tune OpenCL kernels
+
+  - Make sure you have an OpenCL compiler for your intended OpenCL platform
+  - You can install PyOpenCL using ``pip install pyopencl``
+
+Example usage
+-------------
+
+The following shows a simple example for tuning a CUDA kernel:
+
+.. code:: python
+
+    kernel_string = """
+    __global__ void vector_add(float *c, float *a, float *b, int n) {
+        int i = blockIdx.x * block_size_x + threadIdx.x;
+        if (i<n) {
+            c[i] = a[i] + b[i];
+        }
+    }
+    """
+
+    size = 10000000
+
+    a = numpy.random.randn(size).astype(numpy.float32)
+    b = numpy.random.randn(size).astype(numpy.float32)
+    c = numpy.zeros_like(b)
+    n = numpy.int32(size)
+    args = [c, a, b, n]
+
+    tune_params = dict()
+    tune_params["block_size_x"] = [128+64*i for i in range(15)]
+
+    tune_kernel("vector_add", kernel_string, size, args, tune_params)
+
+The exact same Python code can be used to tune an OpenCL kernel:
+
+.. code:: python
+
+    kernel_string = """
+    __kernel void vector_add(__global float *c, __global float *a, __global float *b, int n) {
+        int i = get_global_id(0);
+        if (i<n) {
+            c[i] = a[i] + b[i];
+        }
+    }
+    """
+
+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.
+
+Tuning host and kernel code
+---------------------------
+
+It is also possible to tune for combinations of tunable parameters in
+both host and kernel code. This allows for a number of powerfull things,
+such as tuning the number of streams for a kernel that uses CUDA Streams
+or OpenCL Command Queues to overlap transfers between host and device
+with kernel execution. This can be done in combination with tuning the
+parameters inside the kernel code. See the `convolution\_streams example
+code <https://github.com/benvanwerkhoven/kernel_tuner/blob/master/examples/>`__
+and the
+`documentation <http://benvanwerkhoven.github.io/kernel_tuner/hostcode.html>`__
+for a detailed explanation of the kernel tuner Python script.
+
+Correctness verification
+------------------------
+
+Optionally, you can let the kernel tuner verify the output of every
+kernel it compiles and benchmarks, by passing an ``answer`` list. This
+list matches the list of arguments to the kernel, but contains the
+expected output of the kernel. Input arguments are replaced with None.
+
+.. code:: python
+
+    answer = [a+b, None, None]  # the order matches the arguments (in args) to the kernel
+    tune_kernel("vector_add", kernel_string, size, args, tune_params, answer=answer)
+
+Contribution guide
+------------------
+
+The kernel tuner follows the Google Python style guide, with Sphinxdoc
+docstrings for module public functions. If you want to contribute to the
+project please fork it, create a branch including your addition, and
+create a pull request.
+
+The tests use relative imports and can be run directly after making
+changes to the code. To run all tests use ``nosetests`` in the main
+directory. To run the examples after code changes, you need to run
+``pip install --upgrade .`` in the main directory. Documentation is
+generated by typing ``make html`` in the doc directory, the contents of
+``doc/build/html/`` should then be copied to ``sphinxdoc`` directory of
+the ``gh-pages`` branch.
+
+Before creating a pull request please ensure the following:
+
+* You have written unit tests to test your additions and all unit tests pass
+* The examples still work and produce the same (or better) results
+* The code is compatible with both Python 2.7 and Python 3.5
+* An entry about the change or addition is created in CHANGELOG.md
+
+Contributing authors so far:
+
+* Ben van Werkhoven
+* Berend Weel
+
+Citation
+--------
+A scientific paper about the Kernel Tuner is in preparation, in the meantime please cite the Kernel Tuner as follows:
+
+.. code:: latex
+
+    @misc{
+      author = {Ben van Werkhoven},
+      title = {Kernel Tuner: A simple CUDA/OpenCL Kernel Tuner in Python},
+      year = {2017}
+    }
+
+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.
+
+.. |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

{kernel_tuner-0.1.1 → kernel_tuner-0.1.2}/kernel_tuner/c.py

@@ -2,14 +2,16 @@
 
 import numpy
 import ctypes as C
+import _ctypes
 import subprocess
 import os
 import errno
 
 import numpy.ctypeslib
-
 from kernel_tuner.util import get_temp_filename, delete_temp_file
 
+import logging
+
 class CFunctions(object):
     """Class that groups the code for running and compiling C functions"""
 
@@ -22,6 +24,7 @@ class CFunctions(object):
         self.ITERATIONS = iterations
         self.max_threads = 1024
         self.compiler_options = compiler_options
+        self.lib = None
 
         #test if nvcc is available, otherwise use gcc
         self.compiler = "nvcc"
@@ -85,6 +88,11 @@ class CFunctions(object):
         :returns: An ctypes function that can be called directly.
         :rtype: ctypes._FuncPtr
         """
+        logging.debug('compiling ' + kernel_name)
+
+        if self.lib != None:
+            self.cleanup_lib()
+
         filename = get_temp_filename()
         source_file = filename+".cc"
         kernel_string = "extern \"C\" {\n" + kernel_string + "\n}"
@@ -96,8 +104,6 @@ class CFunctions(object):
         if self.compiler == "nvcc":
             source_file = source_file[:-1] + "u"
             compiler_options = ["-Xcompiler=" + c for c in compiler_options]
-            #might be better to have an optional argument to pass the desired compute capability
-            compiler_options += ["-arch=compute_52"]
 
         if self.compiler_options:
             compiler_options += self.compiler_options
@@ -115,13 +121,14 @@ class CFunctions(object):
 
             self.lib = numpy.ctypeslib.load_library(filename, '.')
 
+            func = getattr(self.lib, kernel_name)
+            func.restype = C.c_float
+
         finally:
             delete_temp_file(source_file)
             delete_temp_file(filename+".o")
             delete_temp_file(filename+".so")
 
-        func = getattr(self.lib, kernel_name)
-        func.restype = C.c_float
 
         return func
 
@@ -189,7 +196,19 @@ class CFunctions(object):
         :returns: A robust average of values returned by the C function.
         :rtype: float
         """
-        return func(*c_args)
+        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
 
 
     def memset(self, allocation, value, size):
@@ -219,3 +238,6 @@ class CFunctions(object):
         dest[:] = numpy.ctypeslib.as_array(src, shape=self.arg_mapping[str(src)])
 
 
+    def cleanup_lib(self):
+        """ unload the previously loaded shared library """
+        _ctypes.dlclose(self.lib._handle)

{kernel_tuner-0.1.1 → kernel_tuner-0.1.2}/kernel_tuner/core.py

@@ -1,6 +1,9 @@
 """ Module for grouping the core functionality needed by most runners """
 from __future__ import print_function
 
+import resource
+import logging
+
 from kernel_tuner.cuda import CudaFunctions
 from kernel_tuner.opencl import OpenCLFunctions
 from kernel_tuner.c import CFunctions
@@ -19,6 +22,8 @@ def get_device_interface(lang, device, platform, compiler_options=None):
 
 def check_kernel_correctness(dev, func, gpu_args, threads, grid, answer, params, verbose, atol=1e-6):
     """runs the kernel once and checks the result against answer"""
+    logging.debug('check_kernel_correctness')
+
     for result, expected in zip(gpu_args, answer):
         if expected is not None:
             dev.memset(result, 0, expected.nbytes)
@@ -27,8 +32,10 @@ def check_kernel_correctness(dev, func, gpu_args, threads, grid, answer, params,
     except Exception as e:
         if "too many resources requested for launch" in str(e) or "OUT_OF_RESOURCES" in str(e):
             #ignore this error for now, it will show up when benchmarking the kernel
+            logging.debug('correctness check ignores runtime failure due to too many resources required')
             return True
         else:
+            logging.debug('correctness check encountered runtime failure: ' + str(e))
             raise e
     correct = True
     for result,expected in zip(gpu_args,answer):
@@ -45,12 +52,15 @@ def check_kernel_correctness(dev, func, gpu_args, threads, grid, answer, params,
                 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: " + get_config_string(params) + " failed correctness check")
     return correct
 
 def compile_kernel(dev, kernel_name, kernel_string, params, grid, instance_string, verbose):
     """compile the kernel for this specific instance"""
+    logging.debug('compile_kernel ' + instance_string)
 
     #prepare kernel_string for compilation
     name, kernel_string = setup_kernel_strings(kernel_name, kernel_string, params, grid, instance_string)
@@ -64,15 +74,21 @@ def compile_kernel(dev, kernel_name, kernel_string, params, grid, instance_strin
         #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_string, "reason: too much shared memory used")
         else:
+            logging.debug('compile_kernel failed due to error: ' + str(e))
             print("Error while compiling:", instance_string)
             raise e
     return func
 
 def benchmark(dev, func, gpu_args, threads, grid, instance_string, verbose):
     """benchmark the kernel instance"""
+    logging.debug('benchmark ' + instance_string)
+    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)
@@ -82,18 +98,23 @@ def benchmark(dev, func, gpu_args, threads, grid, instance_string, verbose):
         #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_string, "reason: too many resources requested for launch")
         else:
+            logging.debug('benchmark encountered runtime failure: ' + str(e))
             print("Error while benchmarking:", instance_string)
             raise e
     return time
 
 def compile_and_benchmark(dev, gpu_args, kernel_name, original_kernel, params,
-        problem_size, grid_div_y, grid_div_x, cmem_args, answer, atol, instance_string, verbose):
+        problem_size, grid_div_z, grid_div_y, grid_div_x, cmem_args, answer, atol, instance_string, verbose):
+
+    logging.debug('compile_and_benchmark ' + instance_string)
+    logging.debug('Memory usage         : %2.2f MB', round(resource.getrusage(resource.RUSAGE_SELF).ru_maxrss/1024.0,1) )
 
     #setup thread block and grid dimensions
-    threads, grid = setup_block_and_grid(dev, problem_size, grid_div_y, grid_div_x, params, instance_string, verbose)
+    threads, grid = setup_block_and_grid(dev, problem_size, grid_div_z, grid_div_y, grid_div_x, params, instance_string, verbose)
     if threads is None:
         return None
 

{kernel_tuner-0.1.1 → kernel_tuner-0.1.2}/kernel_tuner/cuda.py

@@ -1,5 +1,7 @@
 """This module contains all CUDA specific kernel_tuner functions"""
+from __future__ import print_function
 import numpy
+import logging
 
 #embedded in try block to be able to generate documentation
 #and run tests without pycuda installed
@@ -41,7 +43,7 @@ class CudaFunctions(object):
         self.ITERATIONS = iterations
         self.current_module = None
         self.compiler_options = compiler_options or []
-
+        print("Using: " + str(self.context.get_device().name()))
 
     def __del__(self):
         if hasattr(self, 'context'):
@@ -154,8 +156,15 @@ class CudaFunctions(object):
             to be numpy objects, such as numpy.ndarray or numpy.int32, and so on.
         :type cmem_args: dict( string: numpy.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 run_kernel(self, func, gpu_args, threads, grid):