numba-cuda 0.0.1__py3-none-any.whl → 0.0.12__py3-none-any.whl

numba_cuda/numba/cuda/target.py

@@ -0,0 +1,440 @@
+import re
+from functools import cached_property
+import llvmlite.binding as ll
+from llvmlite import ir
+
+from numba.core import (cgutils, config, debuginfo, itanium_mangler, types,
+                        typing, utils)
+from numba.core.dispatcher import Dispatcher
+from numba.core.base import BaseContext
+from numba.core.callconv import BaseCallConv, MinimalCallConv
+from numba.core.typing import cmathdecl
+from numba.core import datamodel
+
+from .cudadrv import nvvm
+from numba.cuda import codegen, nvvmutils, ufuncs
+from numba.cuda.models import cuda_data_manager
+
+# -----------------------------------------------------------------------------
+# Typing
+
+
+class CUDATypingContext(typing.BaseContext):
+    def load_additional_registries(self):
+        from . import cudadecl, cudamath, libdevicedecl, vector_types
+        from numba.core.typing import enumdecl, cffi_utils
+
+        self.install_registry(cudadecl.registry)
+        self.install_registry(cffi_utils.registry)
+        self.install_registry(cudamath.registry)
+        self.install_registry(cmathdecl.registry)
+        self.install_registry(libdevicedecl.registry)
+        self.install_registry(enumdecl.registry)
+        self.install_registry(vector_types.typing_registry)
+
+    def resolve_value_type(self, val):
+        # treat other dispatcher object as another device function
+        from numba.cuda.dispatcher import CUDADispatcher
+        if (isinstance(val, Dispatcher) and not
+                isinstance(val, CUDADispatcher)):
+            try:
+                # use cached device function
+                val = val.__dispatcher
+            except AttributeError:
+                if not val._can_compile:
+                    raise ValueError('using cpu function on device '
+                                     'but its compilation is disabled')
+                targetoptions = val.targetoptions.copy()
+                targetoptions['device'] = True
+                targetoptions['debug'] = targetoptions.get('debug', False)
+                targetoptions['opt'] = targetoptions.get('opt', True)
+                disp = CUDADispatcher(val.py_func, targetoptions)
+                # cache the device function for future use and to avoid
+                # duplicated copy of the same function.
+                val.__dispatcher = disp
+                val = disp
+
+        # continue with parent logic
+        return super(CUDATypingContext, self).resolve_value_type(val)
+
+# -----------------------------------------------------------------------------
+# Implementation
+
+
+VALID_CHARS = re.compile(r'[^a-z0-9]', re.I)
+
+
+class CUDATargetContext(BaseContext):
+    implement_powi_as_math_call = True
+    strict_alignment = True
+
+    def __init__(self, typingctx, target='cuda'):
+        super().__init__(typingctx, target)
+        self.data_model_manager = cuda_data_manager.chain(
+            datamodel.default_manager
+        )
+
+    @property
+    def DIBuilder(self):
+        return debuginfo.DIBuilder
+
+    @property
+    def enable_boundscheck(self):
+        # Unconditionally disabled
+        return False
+
+    # Overrides
+    def create_module(self, name):
+        return self._internal_codegen._create_empty_module(name)
+
+    def init(self):
+        self._internal_codegen = codegen.JITCUDACodegen("numba.cuda.jit")
+        self._target_data = None
+
+    def load_additional_registries(self):
+        # side effect of import needed for numba.cpython.*, the builtins
+        # registry is updated at import time.
+        from numba.cpython import numbers, tupleobj, slicing # noqa: F401
+        from numba.cpython import rangeobj, iterators, enumimpl # noqa: F401
+        from numba.cpython import unicode, charseq # noqa: F401
+        from numba.cpython import cmathimpl
+        from numba.misc import cffiimpl
+        from numba.np import arrayobj # noqa: F401
+        from numba.np import npdatetime # noqa: F401
+        from . import (
+            cudaimpl, printimpl, libdeviceimpl, mathimpl, vector_types
+        )
+        # fix for #8940
+        from numba.np.unsafe import ndarray # noqa F401
+
+        self.install_registry(cudaimpl.registry)
+        self.install_registry(cffiimpl.registry)
+        self.install_registry(printimpl.registry)
+        self.install_registry(libdeviceimpl.registry)
+        self.install_registry(cmathimpl.registry)
+        self.install_registry(mathimpl.registry)
+        self.install_registry(vector_types.impl_registry)
+
+    def codegen(self):
+        return self._internal_codegen
+
+    @property
+    def target_data(self):
+        if self._target_data is None:
+            self._target_data = ll.create_target_data(nvvm.NVVM().data_layout)
+        return self._target_data
+
+    @cached_property
+    def nonconst_module_attrs(self):
+        """
+        Some CUDA intrinsics are at the module level, but cannot be treated as
+        constants, because they are loaded from a special register in the PTX.
+        These include threadIdx, blockDim, etc.
+        """
+        from numba import cuda
+        nonconsts = ('threadIdx', 'blockDim', 'blockIdx', 'gridDim', 'laneid',
+                     'warpsize')
+        nonconsts_with_mod = tuple([(types.Module(cuda), nc)
+                                    for nc in nonconsts])
+        return nonconsts_with_mod
+
+    @cached_property
+    def call_conv(self):
+        return CUDACallConv(self)
+
+    def mangler(self, name, argtypes, *, abi_tags=(), uid=None):
+        return itanium_mangler.mangle(name, argtypes, abi_tags=abi_tags,
+                                      uid=uid)
+
+    def prepare_cuda_kernel(self, codelib, fndesc, debug, lineinfo,
+                            nvvm_options, filename, linenum,
+                            max_registers=None):
+        """
+        Adapt a code library ``codelib`` with the numba compiled CUDA kernel
+        with name ``fname`` and arguments ``argtypes`` for NVVM.
+        A new library is created with a wrapper function that can be used as
+        the kernel entry point for the given kernel.
+
+        Returns the new code library and the wrapper function.
+
+        Parameters:
+
+        codelib:       The CodeLibrary containing the device function to wrap
+                       in a kernel call.
+        fndesc:        The FunctionDescriptor of the source function.
+        debug:         Whether to compile with debug.
+        lineinfo:      Whether to emit line info.
+        nvvm_options:  Dict of NVVM options used when compiling the new library.
+        filename:      The source filename that the function is contained in.
+        linenum:       The source line that the function is on.
+        max_registers: The max_registers argument for the code library.
+        """
+        kernel_name = itanium_mangler.prepend_namespace(
+            fndesc.llvm_func_name, ns='cudapy',
+        )
+        library = self.codegen().create_library(f'{codelib.name}_kernel_',
+                                                entry_name=kernel_name,
+                                                nvvm_options=nvvm_options,
+                                                max_registers=max_registers)
+        library.add_linking_library(codelib)
+        wrapper = self.generate_kernel_wrapper(library, fndesc, kernel_name,
+                                               debug, lineinfo, filename,
+                                               linenum)
+        return library, wrapper
+
+    def generate_kernel_wrapper(self, library, fndesc, kernel_name, debug,
+                                lineinfo, filename, linenum):
+        """
+        Generate the kernel wrapper in the given ``library``.
+        The function being wrapped is described by ``fndesc``.
+        The wrapper function is returned.
+        """
+
+        argtypes = fndesc.argtypes
+        arginfo = self.get_arg_packer(argtypes)
+        argtys = list(arginfo.argument_types)
+        wrapfnty = ir.FunctionType(ir.VoidType(), argtys)
+        wrapper_module = self.create_module("cuda.kernel.wrapper")
+        fnty = ir.FunctionType(ir.IntType(32),
+                               [self.call_conv.get_return_type(types.pyobject)]
+                               + argtys)
+        func = ir.Function(wrapper_module, fnty, fndesc.llvm_func_name)
+
+        prefixed = itanium_mangler.prepend_namespace(func.name, ns='cudapy')
+        wrapfn = ir.Function(wrapper_module, wrapfnty, prefixed)
+        builder = ir.IRBuilder(wrapfn.append_basic_block(''))
+
+        if debug or lineinfo:
+            directives_only = lineinfo and not debug
+            debuginfo = self.DIBuilder(module=wrapper_module,
+                                       filepath=filename,
+                                       cgctx=self,
+                                       directives_only=directives_only)
+            debuginfo.mark_subprogram(
+                wrapfn, kernel_name, fndesc.args, argtypes, linenum,
+            )
+            debuginfo.mark_location(builder, linenum)
+
+        # Define error handling variable
+        def define_error_gv(postfix):
+            name = wrapfn.name + postfix
+            gv = cgutils.add_global_variable(wrapper_module, ir.IntType(32),
+                                             name)
+            gv.initializer = ir.Constant(gv.type.pointee, None)
+            return gv
+
+        gv_exc = define_error_gv("__errcode__")
+        gv_tid = []
+        gv_ctaid = []
+        for i in 'xyz':
+            gv_tid.append(define_error_gv("__tid%s__" % i))
+            gv_ctaid.append(define_error_gv("__ctaid%s__" % i))
+
+        callargs = arginfo.from_arguments(builder, wrapfn.args)
+        status, _ = self.call_conv.call_function(
+            builder, func, types.void, argtypes, callargs)
+
+        if debug:
+            # Check error status
+            with cgutils.if_likely(builder, status.is_ok):
+                builder.ret_void()
+
+            with builder.if_then(builder.not_(status.is_python_exc)):
+                # User exception raised
+                old = ir.Constant(gv_exc.type.pointee, None)
+
+                # Use atomic cmpxchg to prevent rewriting the error status
+                # Only the first error is recorded
+
+                xchg = builder.cmpxchg(gv_exc, old, status.code,
+                                       'monotonic', 'monotonic')
+                changed = builder.extract_value(xchg, 1)
+
+                # If the xchange is successful, save the thread ID.
+                sreg = nvvmutils.SRegBuilder(builder)
+                with builder.if_then(changed):
+                    for dim, ptr, in zip("xyz", gv_tid):
+                        val = sreg.tid(dim)
+                        builder.store(val, ptr)
+
+                    for dim, ptr, in zip("xyz", gv_ctaid):
+                        val = sreg.ctaid(dim)
+                        builder.store(val, ptr)
+
+        builder.ret_void()
+
+        nvvm.set_cuda_kernel(wrapfn)
+        library.add_ir_module(wrapper_module)
+        if debug or lineinfo:
+            debuginfo.finalize()
+        library.finalize()
+
+        if config.DUMP_LLVM:
+            utils.dump_llvm(fndesc, wrapper_module)
+
+        return library.get_function(wrapfn.name)
+
+    def make_constant_array(self, builder, aryty, arr):
+        """
+        Unlike the parent version.  This returns a a pointer in the constant
+        addrspace.
+        """
+
+        lmod = builder.module
+
+        constvals = [
+            self.get_constant(types.byte, i)
+            for i in iter(arr.tobytes(order='A'))
+        ]
+        constaryty = ir.ArrayType(ir.IntType(8), len(constvals))
+        constary = ir.Constant(constaryty, constvals)
+
+        addrspace = nvvm.ADDRSPACE_CONSTANT
+        gv = cgutils.add_global_variable(lmod, constary.type, "_cudapy_cmem",
+                                         addrspace=addrspace)
+        gv.linkage = 'internal'
+        gv.global_constant = True
+        gv.initializer = constary
+
+        # Preserve the underlying alignment
+        lldtype = self.get_data_type(aryty.dtype)
+        align = self.get_abi_sizeof(lldtype)
+        gv.align = 2 ** (align - 1).bit_length()
+
+        # Convert to generic address-space
+        ptrty = ir.PointerType(ir.IntType(8))
+        genptr = builder.addrspacecast(gv, ptrty, 'generic')
+
+        # Create array object
+        ary = self.make_array(aryty)(self, builder)
+        kshape = [self.get_constant(types.intp, s) for s in arr.shape]
+        kstrides = [self.get_constant(types.intp, s) for s in arr.strides]
+        self.populate_array(ary, data=builder.bitcast(genptr, ary.data.type),
+                            shape=kshape,
+                            strides=kstrides,
+                            itemsize=ary.itemsize, parent=ary.parent,
+                            meminfo=None)
+
+        return ary._getvalue()
+
+    def insert_const_string(self, mod, string):
+        """
+        Unlike the parent version.  This returns a a pointer in the constant
+        addrspace.
+        """
+        text = cgutils.make_bytearray(string.encode("utf-8") + b"\x00")
+        name = '$'.join(["__conststring__",
+                         itanium_mangler.mangle_identifier(string)])
+        # Try to reuse existing global
+        gv = mod.globals.get(name)
+        if gv is None:
+            # Not defined yet
+            gv = cgutils.add_global_variable(mod, text.type, name,
+                                             addrspace=nvvm.ADDRSPACE_CONSTANT)
+            gv.linkage = 'internal'
+            gv.global_constant = True
+            gv.initializer = text
+
+        # Cast to a i8* pointer
+        charty = gv.type.pointee.element
+        return gv.bitcast(charty.as_pointer(nvvm.ADDRSPACE_CONSTANT))
+
+    def insert_string_const_addrspace(self, builder, string):
+        """
+        Insert a constant string in the constant addresspace and return a
+        generic i8 pointer to the data.
+
+        This function attempts to deduplicate.
+        """
+        lmod = builder.module
+        gv = self.insert_const_string(lmod, string)
+        charptrty = ir.PointerType(ir.IntType(8))
+        return builder.addrspacecast(gv, charptrty, 'generic')
+
+    def optimize_function(self, func):
+        """Run O1 function passes
+        """
+        pass
+        ## XXX skipped for now
+        # fpm = lp.FunctionPassManager.new(func.module)
+        #
+        # lp.PassManagerBuilder.new().populate(fpm)
+        #
+        # fpm.initialize()
+        # fpm.run(func)
+        # fpm.finalize()
+
+    def get_ufunc_info(self, ufunc_key):
+        return ufuncs.get_ufunc_info(ufunc_key)
+
+
+class CUDACallConv(MinimalCallConv):
+    pass
+
+
+class CUDACABICallConv(BaseCallConv):
+    """
+    Calling convention aimed at matching the CUDA C/C++ ABI. The implemented
+    function signature is:
+
+        <Python return type> (<Python arguments>)
+
+    Exceptions are unsupported in this convention.
+    """
+
+    def _make_call_helper(self, builder):
+        # Call helpers are used to help report exceptions back to Python, so
+        # none is required here.
+        return None
+
+    def return_value(self, builder, retval):
+        return builder.ret(retval)
+
+    def return_user_exc(self, builder, exc, exc_args=None, loc=None,
+                        func_name=None):
+        msg = "Python exceptions are unsupported in the CUDA C/C++ ABI"
+        raise NotImplementedError(msg)
+
+    def return_status_propagate(self, builder, status):
+        msg = "Return status is unsupported in the CUDA C/C++ ABI"
+        raise NotImplementedError(msg)
+
+    def get_function_type(self, restype, argtypes):
+        """
+        Get the LLVM IR Function type for *restype* and *argtypes*.
+        """
+        arginfo = self._get_arg_packer(argtypes)
+        argtypes = list(arginfo.argument_types)
+        fnty = ir.FunctionType(self.get_return_type(restype), argtypes)
+        return fnty
+
+    def decorate_function(self, fn, args, fe_argtypes, noalias=False):
+        """
+        Set names and attributes of function arguments.
+        """
+        assert not noalias
+        arginfo = self._get_arg_packer(fe_argtypes)
+        arginfo.assign_names(self.get_arguments(fn),
+                             ['arg.' + a for a in args])
+
+    def get_arguments(self, func):
+        """
+        Get the Python-level arguments of LLVM *func*.
+        """
+        return func.args
+
+    def call_function(self, builder, callee, resty, argtys, args):
+        """
+        Call the Numba-compiled *callee*.
+        """
+        arginfo = self._get_arg_packer(argtys)
+        realargs = arginfo.as_arguments(builder, args)
+        code = builder.call(callee, realargs)
+        # No status required as we don't support exceptions or a distinct None
+        # value in a C ABI.
+        status = None
+        out = self.context.get_returned_value(builder, resty, code)
+        return status, out
+
+    def get_return_type(self, ty):
+        return self.context.data_model_manager[ty].get_return_type()

numba_cuda/numba/cuda/testing.py

@@ -0,0 +1,202 @@
+import os
+import platform
+import shutil
+
+from numba.tests.support import SerialMixin
+from numba.cuda.cuda_paths import get_conda_ctk
+from numba.cuda.cudadrv import driver, devices, libs
+from numba.core import config
+from numba.tests.support import TestCase
+from pathlib import Path
+import unittest
+
+numba_cuda_dir = Path(__file__).parent
+test_data_dir = numba_cuda_dir / 'tests' / 'data'
+
+
+class CUDATestCase(SerialMixin, TestCase):
+    """
+    For tests that use a CUDA device. Test methods in a CUDATestCase must not
+    be run out of module order, because the ContextResettingTestCase may reset
+    the context and destroy resources used by a normal CUDATestCase if any of
+    its tests are run between tests from a CUDATestCase.
+    """
+
+    def setUp(self):
+        self._low_occupancy_warnings = config.CUDA_LOW_OCCUPANCY_WARNINGS
+        self._warn_on_implicit_copy = config.CUDA_WARN_ON_IMPLICIT_COPY
+
+        # Disable warnings about low gpu utilization in the test suite
+        config.CUDA_LOW_OCCUPANCY_WARNINGS = 0
+        # Disable warnings about host arrays in the test suite
+        config.CUDA_WARN_ON_IMPLICIT_COPY = 0
+
+    def tearDown(self):
+        config.CUDA_LOW_OCCUPANCY_WARNINGS = self._low_occupancy_warnings
+        config.CUDA_WARN_ON_IMPLICIT_COPY = self._warn_on_implicit_copy
+
+    def skip_if_lto(self, reason):
+        # Some linkers need the compute capability to be specified, so we
+        # always specify it here.
+        cc = devices.get_context().device.compute_capability
+        linker = driver.Linker.new(cc=cc)
+        if linker.lto:
+            self.skipTest(reason)
+
+
+class ContextResettingTestCase(CUDATestCase):
+    """
+    For tests where the context needs to be reset after each test. Typically
+    these inspect or modify parts of the context that would usually be expected
+    to be internal implementation details (such as the state of allocations and
+    deallocations, etc.).
+    """
+
+    def tearDown(self):
+        super().tearDown()
+        from numba.cuda.cudadrv.devices import reset
+        reset()
+
+
+def ensure_supported_ccs_initialized():
+    from numba.cuda import is_available as cuda_is_available
+    from numba.cuda.cudadrv import nvvm
+
+    if cuda_is_available():
+        # Ensure that cudart.so is loaded and the list of supported compute
+        # capabilities in the nvvm module is populated before a fork. This is
+        # needed because some compilation tests don't require a CUDA context,
+        # but do use NVVM, and it is required that libcudart.so should be
+        # loaded before a fork (note that the requirement is not explicitly
+        # documented).
+        nvvm.get_supported_ccs()
+
+
+def skip_on_cudasim(reason):
+    """Skip this test if running on the CUDA simulator"""
+    return unittest.skipIf(config.ENABLE_CUDASIM, reason)
+
+
+def skip_unless_cudasim(reason):
+    """Skip this test if running on CUDA hardware"""
+    return unittest.skipUnless(config.ENABLE_CUDASIM, reason)
+
+
+def skip_unless_conda_cudatoolkit(reason):
+    """Skip test if the CUDA toolkit was not installed by Conda"""
+    return unittest.skipUnless(get_conda_ctk() is not None, reason)
+
+
+def skip_if_external_memmgr(reason):
+    """Skip test if an EMM Plugin is in use"""
+    return unittest.skipIf(config.CUDA_MEMORY_MANAGER != 'default', reason)
+
+
+def skip_under_cuda_memcheck(reason):
+    return unittest.skipIf(os.environ.get('CUDA_MEMCHECK') is not None, reason)
+
+
+def skip_without_nvdisasm(reason):
+    nvdisasm_path = shutil.which('nvdisasm')
+    return unittest.skipIf(nvdisasm_path is None, reason)
+
+
+def skip_with_nvdisasm(reason):
+    nvdisasm_path = shutil.which('nvdisasm')
+    return unittest.skipIf(nvdisasm_path is not None, reason)
+
+
+def skip_on_arm(reason):
+    cpu = platform.processor()
+    is_arm = cpu.startswith('arm') or cpu.startswith('aarch')
+    return unittest.skipIf(is_arm, reason)
+
+
+def skip_if_cuda_includes_missing(fn):
+    # Skip when cuda.h is not available - generally this should indicate
+    # whether the CUDA includes are available or not
+    cuda_h = os.path.join(config.CUDA_INCLUDE_PATH, 'cuda.h')
+    cuda_h_file = (os.path.exists(cuda_h) and os.path.isfile(cuda_h))
+    reason = 'CUDA include dir not available on this system'
+    return unittest.skipUnless(cuda_h_file, reason)(fn)
+
+
+def skip_if_mvc_enabled(reason):
+    """Skip a test if Minor Version Compatibility is enabled"""
+    return unittest.skipIf(config.CUDA_ENABLE_MINOR_VERSION_COMPATIBILITY,
+                           reason)
+
+
+def skip_if_mvc_libraries_unavailable(fn):
+    libs_available = False
+    try:
+        import cubinlinker  # noqa: F401
+        import ptxcompiler  # noqa: F401
+        libs_available = True
+    except ImportError:
+        pass
+
+    return unittest.skipUnless(libs_available,
+                               "Requires cubinlinker and ptxcompiler")(fn)
+
+
+def cc_X_or_above(major, minor):
+    if not config.ENABLE_CUDASIM:
+        cc = devices.get_context().device.compute_capability
+        return cc >= (major, minor)
+    else:
+        return True
+
+
+def skip_unless_cc_50(fn):
+    return unittest.skipUnless(cc_X_or_above(5, 0), "requires cc >= 5.0")(fn)
+
+
+def skip_unless_cc_53(fn):
+    return unittest.skipUnless(cc_X_or_above(5, 3), "requires cc >= 5.3")(fn)
+
+
+def skip_unless_cc_60(fn):
+    return unittest.skipUnless(cc_X_or_above(6, 0), "requires cc >= 6.0")(fn)
+
+
+def skip_unless_cc_75(fn):
+    return unittest.skipUnless(cc_X_or_above(7, 5), "requires cc >= 7.5")(fn)
+
+
+def xfail_unless_cudasim(fn):
+    if config.ENABLE_CUDASIM:
+        return fn
+    else:
+        return unittest.expectedFailure(fn)
+
+
+def skip_with_cuda_python(reason):
+    return unittest.skipIf(driver.USE_NV_BINDING, reason)
+
+
+def cudadevrt_missing():
+    if config.ENABLE_CUDASIM:
+        return False
+    try:
+        path = libs.get_cudalib('cudadevrt', static=True)
+        libs.check_static_lib(path)
+    except FileNotFoundError:
+        return True
+    return False
+
+
+def skip_if_cudadevrt_missing(fn):
+    return unittest.skipIf(cudadevrt_missing(), 'cudadevrt missing')(fn)
+
+
+class ForeignArray(object):
+    """
+    Class for emulating an array coming from another library through the CUDA
+    Array interface. This just hides a DeviceNDArray so that it doesn't look
+    like a DeviceNDArray.
+    """
+
+    def __init__(self, arr):
+        self._arr = arr
+        self.__cuda_array_interface__ = arr.__cuda_array_interface__

numba_cuda/numba/cuda/tests/__init__.py

@@ -0,0 +1,58 @@
+from fnmatch import fnmatch
+from numba.cuda.testing import ensure_supported_ccs_initialized
+from numba.testing import unittest
+from numba import cuda
+from os.path import dirname, isfile, join, normpath, relpath, splitext
+
+import os
+import sys
+import traceback
+
+
+# Copied and modified from numba/testing/__init__.py, to handle the difference
+# between the top dirs for Numba and the CUDA target
+def load_testsuite(loader, dir):
+    """Find tests in 'dir'."""
+    top_level_dir = dirname(dirname(dirname(dirname(__file__))))
+    try:
+        suite = unittest.TestSuite()
+        files = []
+        for f in os.listdir(dir):
+            path = join(dir, f)
+            if isfile(path) and fnmatch(f, 'test_*.py'):
+                files.append(f)
+            elif isfile(join(path, '__init__.py')):
+                suite.addTests(loader.discover(path,
+                                               top_level_dir=top_level_dir))
+        for f in files:
+            # turn 'f' into a filename relative to the toplevel dir and
+            # translate it to a module name. This differs from the
+            # implementation in Numba, because the toplevel dir is the
+            # numba_cuda module location, not the numba one.
+            f = relpath(join(dir, f), top_level_dir)
+            f = splitext(normpath(f.replace(os.path.sep, '.')))[0]
+            suite.addTests(loader.loadTestsFromName(f))
+        return suite
+    except Exception:
+        traceback.print_exc(file=sys.stderr)
+        sys.exit(-1)
+
+
+def load_tests(loader, tests, pattern):
+    suite = unittest.TestSuite()
+    this_dir = dirname(__file__)
+    ensure_supported_ccs_initialized()
+    suite.addTests(load_testsuite(loader, join(this_dir, 'nocuda')))
+    if cuda.is_available():
+        suite.addTests(load_testsuite(loader, join(this_dir, 'cudasim')))
+        gpus = cuda.list_devices()
+        if gpus and gpus[0].compute_capability >= (2, 0):
+            suite.addTests(load_testsuite(loader, join(this_dir, 'cudadrv')))
+            suite.addTests(load_testsuite(loader, join(this_dir, 'cudapy')))
+            suite.addTests(load_testsuite(loader, join(this_dir,
+                                                       'doc_examples')))
+        else:
+            print("skipped CUDA tests because GPU CC < 2.0")
+    else:
+        print("skipped CUDA tests")
+    return suite