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

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

@@ -1,20 +1,19 @@
 Metadata-Version: 1.1
 Name: kernel_tuner
-Version: 0.1.2
+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
         -------------
@@ -44,41 +41,35 @@ Description: A simple CUDA/OpenCL kernel tuner in Python
         Installation
         ------------
         
-        To install from PyPi:  
+        The easiest way to install the Kernel Tuner is using pip:
         
-        - ``pip install kernel_tuner``  
+        .. code-block:: bash
         
-        To install from the source (and get the tutorial and examples):  
+            pip install kernel_tuner
         
-        - 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  
+        But you can also install from the git repository. This way you also get the
+        examples and the tutorials:
         
-          - ``cd kernel_tuner``  
-           
-        - install using  
-         
-          - ``pip install .``  
+        .. code-block:: bash
         
-        Dependencies
-        ------------
-        Python 2.7 or Python 3.5
-        
-        PyCuda and/or PyOpenCL (https://mathema.tician.de/software/)
-        
-        - To tune CUDA kernels
+            git clone https://github.com/benvanwerkhoven/kernel_tuner.git
+            cd kernel_tuner
+            pip install .
+            
+        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`` 
+          - First, 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
+        To tune OpenCL kernels:
         
-          - Make sure you have an OpenCL compiler for your intended OpenCL platform
+          - 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>`__
+        
         Example usage
         -------------
         
@@ -104,7 +95,7 @@ Description: A simple CUDA/OpenCL kernel tuner in Python
             args = [c, a, b, n]
         
             tune_params = dict()
-            tune_params["block_size_x"] = [128+64*i for i in range(15)]
+            tune_params["block_size_x"] = [32, 64, 128, 256, 512]
         
             tune_kernel("vector_add", kernel_string, size, args, tune_params)
         
@@ -121,22 +112,23 @@ 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.
+        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>`__.
         
-        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.
+        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
         ---------------------------
         
-        It is also possible to tune for combinations of tunable parameters in
+        It is 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
@@ -160,33 +152,10 @@ Description: A simple CUDA/OpenCL kernel tuner in 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:
+        Contributing
+        ------------
         
-        * Ben van Werkhoven
-        * Berend Weel
+        Please see the `Contributions Guide <http://benvanwerkhoven.github.io/kernel_tuner/contributing.html>`__.
         
         Citation
         --------

{kernel_tuner-0.1.2 → 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
 -------------
@@ -36,41 +33,35 @@ The full documentation is available
 Installation
 ------------
 
-To install from PyPi:  
+The easiest way to install the Kernel Tuner is using pip:
 
-- ``pip install kernel_tuner``  
+.. code-block:: bash
 
-To install from the source (and get the tutorial and examples):  
+    pip install kernel_tuner
 
-- 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  
+But you can also install from the git repository. This way you also get the
+examples and the tutorials:
 
-  - ``cd kernel_tuner``  
-   
-- install using  
- 
-  - ``pip install .``  
+.. code-block:: bash
 
-Dependencies
-------------
-Python 2.7 or Python 3.5
-
-PyCuda and/or PyOpenCL (https://mathema.tician.de/software/)
-
-- To tune CUDA kernels
+    git clone https://github.com/benvanwerkhoven/kernel_tuner.git
+    cd kernel_tuner
+    pip install .
+    
+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`` 
+  - First, 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
+To tune OpenCL kernels:
 
-  - Make sure you have an OpenCL compiler for your intended OpenCL platform
+  - 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>`__
+
 Example usage
 -------------
 
@@ -96,7 +87,7 @@ The following shows a simple example for tuning a CUDA kernel:
     args = [c, a, b, n]
 
     tune_params = dict()
-    tune_params["block_size_x"] = [128+64*i for i in range(15)]
+    tune_params["block_size_x"] = [32, 64, 128, 256, 512]
 
     tune_kernel("vector_add", kernel_string, size, args, tune_params)
 
@@ -113,22 +104,23 @@ 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.
+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>`__.
 
-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.
+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
 ---------------------------
 
-It is also possible to tune for combinations of tunable parameters in
+It is 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
@@ -152,33 +144,10 @@ expected output of the kernel. Input arguments are replaced with None.
     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:
+Contributing
+------------
 
-* Ben van Werkhoven
-* Berend Weel
+Please see the `Contributions Guide <http://benvanwerkhoven.github.io/kernel_tuner/contributing.html>`__.
 
 Citation
 --------

{kernel_tuner-0.1.2 → 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,31 +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'):
-                    if str(arg.dtype).startswith('int'):
-                        ctype_args.append(int(arg))
-                    elif str(arg.dtype).startswith('float'):
-                        ctype_args.append(float(arg))
-                    else:
-                        raise TypeError("Argument is scalar with a dtype, but does not start with int or float")
-                else:
-                    ctype_args.append(arg)
+            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
 
@@ -95,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]
@@ -112,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, '.')
 
@@ -167,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])
@@ -196,17 +244,10 @@ class CFunctions(object):
         :returns: A robust average of values returned by the C function.
         :rtype: float
         """
-        time = func(*c_args)
+        logging.debug("run_kernel")
+        logging.debug("arguments=" + str([str(arg) for arg in 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")
+        time = func(*c_args)
 
         return time
 
@@ -240,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)