numba-cuda 0.16.0__py3-none-any.whl → 0.18.0__py3-none-any.whl

numba_cuda/numba/cuda/tests/core/serialize_usecases.py

@@ -0,0 +1,110 @@
+"""
+Separate module with function samples for serialization tests,
+to avoid issues with __main__.
+"""
+
+import math
+from math import sqrt
+import numpy as np
+import numpy.random as nprand
+
+from numba import jit
+from numba.core import types
+
+
+@jit((types.int32, types.int32))
+def add_with_sig(a, b):
+    return a + b
+
+
+@jit
+def add_without_sig(a, b):
+    return a + b
+
+
+@jit(nopython=True)
+def add_nopython(a, b):
+    return a + b
+
+
+@jit(nopython=True)
+def add_nopython_fail(a, b):
+    object()
+    return a + b
+
+
+def closure(a):
+    @jit(nopython=True)
+    def inner(b, c):
+        return a + b + c
+
+    return inner
+
+
+K = 3.0
+
+
+def closure_with_globals(x, **jit_args):
+    @jit(**jit_args)
+    def inner(y):
+        # Exercise a builtin function and a module-level constant
+        k = max(K, K + 1)
+        # Exercise two functions from another module, one accessed with
+        # dotted notation, one imported explicitly.
+        return math.hypot(x, y) + sqrt(k)
+
+    return inner
+
+
+@jit(nopython=True)
+def other_function(x, y):
+    return math.hypot(x, y)
+
+
+@jit(forceobj=True)
+def get_global_objmode(x):
+    return K * x
+
+
+@jit(nopython=True)
+def get_renamed_module(x):
+    nprand.seed(42)
+    return np.cos(x), nprand.random()
+
+
+def closure_calling_other_function(x):
+    @jit(nopython=True)
+    def inner(y, z):
+        return other_function(x, y) + z
+
+    return inner
+
+
+def closure_calling_other_closure(x):
+    @jit(nopython=True)
+    def other_inner(y):
+        return math.hypot(x, y)
+
+    @jit(nopython=True)
+    def inner(y):
+        return other_inner(y) + x
+
+    return inner
+
+
+# A dynamic function calling a builtin function
+def _get_dyn_func(**jit_args):
+    code = """
+        def dyn_func(x):
+            res = 0
+            for i in range(x):
+                res += x
+            return res
+        """
+    ns = {}
+    exec(code.strip(), ns)
+    return jit(**jit_args)(ns["dyn_func"])
+
+
+dyn_func = _get_dyn_func(nopython=True)
+dyn_func_objmode = _get_dyn_func(forceobj=True)

numba_cuda/numba/cuda/tests/core/test_serialize.py

@@ -0,0 +1,359 @@
+import contextlib
+import gc
+import pickle
+import runpy
+import subprocess
+import sys
+import unittest
+from multiprocessing import get_context
+
+import numba
+from numba.core.errors import TypingError
+from numba.tests.support import TestCase
+from numba.core.target_extension import resolve_dispatcher_from_str
+from numba.cloudpickle import dumps, loads
+
+
+class TestDispatcherPickling(TestCase):
+    def run_with_protocols(self, meth, *args, **kwargs):
+        for proto in range(pickle.HIGHEST_PROTOCOL + 1):
+            meth(proto, *args, **kwargs)
+
+    @contextlib.contextmanager
+    def simulate_fresh_target(self):
+        hwstr = "cpu"
+        dispatcher_cls = resolve_dispatcher_from_str(hwstr)
+        old_descr = dispatcher_cls.targetdescr
+        # Simulate fresh targetdescr
+        dispatcher_cls.targetdescr = type(dispatcher_cls.targetdescr)(hwstr)
+        try:
+            yield
+        finally:
+            # Be sure to reinstantiate old descriptor, otherwise other
+            # objects may be out of sync.
+            dispatcher_cls.targetdescr = old_descr
+
+    def check_call(self, proto, func, expected_result, args):
+        def check_result(func):
+            if isinstance(expected_result, type) and issubclass(
+                expected_result, Exception
+            ):
+                self.assertRaises(expected_result, func, *args)
+            else:
+                self.assertPreciseEqual(func(*args), expected_result)
+
+        # Control
+        check_result(func)
+        pickled = pickle.dumps(func, proto)
+        with self.simulate_fresh_target():
+            new_func = pickle.loads(pickled)
+            check_result(new_func)
+
+    def test_call_with_sig(self):
+        from .serialize_usecases import add_with_sig
+
+        self.run_with_protocols(self.check_call, add_with_sig, 5, (1, 4))
+        # Compilation has been disabled => float inputs will be coerced to int
+        self.run_with_protocols(self.check_call, add_with_sig, 5, (1.2, 4.2))
+
+    def test_call_without_sig(self):
+        from .serialize_usecases import add_without_sig
+
+        self.run_with_protocols(self.check_call, add_without_sig, 5, (1, 4))
+        self.run_with_protocols(
+            self.check_call, add_without_sig, 5.5, (1.2, 4.3)
+        )
+        # Object mode is enabled
+        self.run_with_protocols(
+            self.check_call, add_without_sig, "abc", ("a", "bc")
+        )
+
+    def test_call_nopython(self):
+        from .serialize_usecases import add_nopython
+
+        self.run_with_protocols(self.check_call, add_nopython, 5.5, (1.2, 4.3))
+        # Object mode is disabled
+        self.run_with_protocols(
+            self.check_call, add_nopython, TypingError, (object(), object())
+        )
+
+    def test_call_nopython_fail(self):
+        from .serialize_usecases import add_nopython_fail
+
+        # Compilation fails
+        self.run_with_protocols(
+            self.check_call, add_nopython_fail, TypingError, (1, 2)
+        )
+
+    def test_call_objmode_with_global(self):
+        from .serialize_usecases import get_global_objmode
+
+        self.run_with_protocols(
+            self.check_call, get_global_objmode, 7.5, (2.5,)
+        )
+
+    def test_call_closure(self):
+        from .serialize_usecases import closure
+
+        inner = closure(1)
+        self.run_with_protocols(self.check_call, inner, 6, (2, 3))
+
+    def check_call_closure_with_globals(self, **jit_args):
+        from .serialize_usecases import closure_with_globals
+
+        inner = closure_with_globals(3.0, **jit_args)
+        self.run_with_protocols(self.check_call, inner, 7.0, (4.0,))
+
+    def test_call_closure_with_globals_nopython(self):
+        self.check_call_closure_with_globals(nopython=True)
+
+    def test_call_closure_with_globals_objmode(self):
+        self.check_call_closure_with_globals(forceobj=True)
+
+    def test_call_closure_calling_other_function(self):
+        from .serialize_usecases import closure_calling_other_function
+
+        inner = closure_calling_other_function(3.0)
+        self.run_with_protocols(self.check_call, inner, 11.0, (4.0, 6.0))
+
+    def test_call_closure_calling_other_closure(self):
+        from .serialize_usecases import closure_calling_other_closure
+
+        inner = closure_calling_other_closure(3.0)
+        self.run_with_protocols(self.check_call, inner, 8.0, (4.0,))
+
+    def test_call_dyn_func(self):
+        from .serialize_usecases import dyn_func
+
+        # Check serializing a dynamically-created function
+        self.run_with_protocols(self.check_call, dyn_func, 36, (6,))
+
+    def test_call_dyn_func_objmode(self):
+        from .serialize_usecases import dyn_func_objmode
+
+        # Same with an object mode function
+        self.run_with_protocols(self.check_call, dyn_func_objmode, 36, (6,))
+
+    def test_renamed_module(self):
+        from .serialize_usecases import get_renamed_module
+
+        # Issue #1559: using a renamed module (e.g. `import numpy as np`)
+        # should not fail serializing
+        expected = get_renamed_module(0.0)
+        self.run_with_protocols(
+            self.check_call, get_renamed_module, expected, (0.0,)
+        )
+
+    def test_other_process(self):
+        """
+        Check that reconstructing doesn't depend on resources already
+        instantiated in the original process.
+        """
+        from .serialize_usecases import closure_calling_other_closure
+
+        func = closure_calling_other_closure(3.0)
+        pickled = pickle.dumps(func)
+        code = """if 1:
+            import pickle
+
+            data = {pickled!r}
+            func = pickle.loads(data)
+            res = func(4.0)
+            assert res == 8.0, res
+            """.format(**locals())
+        subprocess.check_call([sys.executable, "-c", code])
+
+    def test_reuse(self):
+        """
+        Check that deserializing the same function multiple times re-uses
+        the same dispatcher object.
+
+        Note that "same function" is intentionally under-specified.
+        """
+        from .serialize_usecases import closure
+
+        func = closure(5)
+        pickled = pickle.dumps(func)
+        func2 = closure(6)
+        pickled2 = pickle.dumps(func2)
+
+        f = pickle.loads(pickled)
+        g = pickle.loads(pickled)
+        h = pickle.loads(pickled2)
+        self.assertIs(f, g)
+        self.assertEqual(f(2, 3), 10)
+        g.disable_compile()
+        self.assertEqual(g(2, 4), 11)
+
+        self.assertIsNot(f, h)
+        self.assertEqual(h(2, 3), 11)
+
+        # Now make sure the original object doesn't exist when deserializing
+        func = closure(7)
+        func(42, 43)
+        pickled = pickle.dumps(func)
+        del func
+        gc.collect()
+
+        f = pickle.loads(pickled)
+        g = pickle.loads(pickled)
+        self.assertIs(f, g)
+        self.assertEqual(f(2, 3), 12)
+        g.disable_compile()
+        self.assertEqual(g(2, 4), 13)
+
+    def test_imp_deprecation(self):
+        """
+        The imp module was deprecated in v3.4 in favour of importlib
+        """
+        code = """if 1:
+            import pickle
+            import warnings
+            with warnings.catch_warnings(record=True) as w:
+                warnings.simplefilter('always', DeprecationWarning)
+                from numba import njit
+                @njit
+                def foo(x):
+                    return x + 1
+                foo(1)
+                serialized_foo = pickle.dumps(foo)
+            for x in w:
+                if 'serialize.py' in x.filename:
+                    assert "the imp module is deprecated" not in x.msg
+        """
+        subprocess.check_call([sys.executable, "-c", code])
+
+
+class TestSerializationMisc(TestCase):
+    def test_numba_unpickle(self):
+        # Test that _numba_unpickle is memorizing its output
+        from numba.core.serialize import _numba_unpickle
+
+        random_obj = object()
+        bytebuf = pickle.dumps(random_obj)
+        hashed = hash(random_obj)
+
+        got1 = _numba_unpickle(id(random_obj), bytebuf, hashed)
+        # not the original object
+        self.assertIsNot(got1, random_obj)
+        got2 = _numba_unpickle(id(random_obj), bytebuf, hashed)
+        # unpickled results are the same objects
+        self.assertIs(got1, got2)
+
+
+class TestCloudPickleIssues(TestCase):
+    """This test case includes issues specific to the cloudpickle implementation."""
+
+    _numba_parallel_test_ = False
+
+    def test_dynamic_class_reset_on_unpickle(self):
+        # a dynamic class
+        class Klass:
+            classvar = None
+
+        def mutator():
+            Klass.classvar = 100
+
+        def check():
+            self.assertEqual(Klass.classvar, 100)
+
+        saved = dumps(Klass)
+        mutator()
+        check()
+        loads(saved)
+        # Without the patch, each `loads(saved)` will reset `Klass.classvar`
+        check()
+        loads(saved)
+        check()
+
+    @unittest.skipIf(
+        __name__ == "__main__", "Test cannot run as when module is __main__"
+    )
+    def test_main_class_reset_on_unpickle(self):
+        mp = get_context("spawn")
+        proc = mp.Process(target=check_main_class_reset_on_unpickle)
+        proc.start()
+        proc.join(timeout=60)
+        self.assertEqual(proc.exitcode, 0)
+
+    def test_dynamic_class_reset_on_unpickle_new_proc(self):
+        # a dynamic class
+        class Klass:
+            classvar = None
+
+        # serialize Klass in this process
+        saved = dumps(Klass)
+
+        # Check the reset problem in a new process
+        mp = get_context("spawn")
+        proc = mp.Process(
+            target=check_unpickle_dyn_class_new_proc, args=(saved,)
+        )
+        proc.start()
+        proc.join(timeout=60)
+        self.assertEqual(proc.exitcode, 0)
+
+    def test_dynamic_class_issue_7356(self):
+        cfunc = numba.njit(issue_7356)
+        self.assertEqual(cfunc(), (100, 100))
+
+
+class DynClass(object):
+    # For testing issue #7356
+    a = None
+
+
+def issue_7356():
+    with numba.objmode(before="intp"):
+        DynClass.a = 100
+        before = DynClass.a
+    with numba.objmode(after="intp"):
+        after = DynClass.a
+    return before, after
+
+
+def check_main_class_reset_on_unpickle():
+    # Load module and get its global dictionary
+    glbs = runpy.run_module(
+        "numba.tests.cloudpickle_main_class",
+        run_name="__main__",
+    )
+    # Get the Klass and check it is from __main__
+    Klass = glbs["Klass"]
+    assert Klass.__module__ == "__main__"
+    assert Klass.classvar != 100
+    saved = dumps(Klass)
+    # mutate
+    Klass.classvar = 100
+    # check
+    _check_dyn_class(Klass, saved)
+
+
+def check_unpickle_dyn_class_new_proc(saved):
+    Klass = loads(saved)
+    assert Klass.classvar != 100
+    # mutate
+    Klass.classvar = 100
+    # check
+    _check_dyn_class(Klass, saved)
+
+
+def _check_dyn_class(Klass, saved):
+    def check():
+        if Klass.classvar != 100:
+            raise AssertionError("Check failed. Klass reset.")
+
+    check()
+    loaded = loads(saved)
+    if loaded is not Klass:
+        raise AssertionError("Expected reuse")
+    # Without the patch, each `loads(saved)` will reset `Klass.classvar`
+    check()
+    loaded = loads(saved)
+    if loaded is not Klass:
+        raise AssertionError("Expected reuse")
+    check()
+
+
+if __name__ == "__main__":
+    unittest.main()

numba_cuda/numba/cuda/tests/cudadrv/test_context_stack.py

@@ -25,6 +25,19 @@ class TestContextStack(CUDATestCase):
         gpulist = list(cuda.gpus)
         self.assertGreater(len(gpulist), 0)
 
+    def test_gpus_cudevice_indexing(self):
+        """Test that CUdevice objects can be used to index into cuda.gpus"""
+        # When using the CUDA Python bindings, the device ids are CUdevice
+        # objects, otherwise they are integers. We test that the device id is
+        # usable as an index into cuda.gpus.
+        device_ids = [device.id for device in cuda.list_devices()]
+        for device_id in device_ids:
+            with cuda.gpus[device_id]:
+                # Check that the device is an integer if not using the CUDA
+                # Python bindings, otherwise it's a CUdevice object
+                assert isinstance(device_id, int) != driver.USE_NV_BINDING
+                self.assertEqual(cuda.gpus.current.id, device_id)
+
 
 class TestContextAPI(CUDATestCase):
     def tearDown(self):
@@ -82,7 +95,8 @@ class Test3rdPartyContext(CUDATestCase):
         the_driver = driver.driver
         if driver.USE_NV_BINDING:
             dev = driver.binding.CUdevice(0)
-            hctx = the_driver.cuDevicePrimaryCtxRetain(dev)
+            binding_hctx = the_driver.cuDevicePrimaryCtxRetain(dev)
+            hctx = driver.drvapi.cu_context(int(binding_hctx))
         else:
             dev = 0
             hctx = driver.drvapi.cu_context()
@@ -93,10 +107,7 @@ class Test3rdPartyContext(CUDATestCase):
             # Check that the context from numba matches the created primary
             # context.
             my_ctx = cuda.current_context()
-            if driver.USE_NV_BINDING:
-                self.assertEqual(int(my_ctx.handle), int(ctx.handle))
-            else:
-                self.assertEqual(my_ctx.handle.value, ctx.handle.value)
+            self.assertEqual(my_ctx.handle.value, ctx.handle.value)
 
             extra_work()
         finally:

numba_cuda/numba/cuda/tests/cudadrv/test_cuda_driver.py

@@ -129,6 +129,10 @@ class TestCudaDriver(CUDATestCase):
 
             ptr = memory.device_ctypes_pointer
 
+            stream_handle = stream.handle
+            if _driver.USE_NV_BINDING:
+                stream_handle = stream_handle.value
+
             launch_kernel(
                 function.handle,  # Kernel
                 1,
@@ -138,7 +142,7 @@ class TestCudaDriver(CUDATestCase):
                 1,
                 1,  # bx, by, bz
                 0,  # dynamic shared mem
-                stream.handle,  # stream
+                stream_handle,  # stream
                 [ptr],
             )  # arguments
 

numba_cuda/numba/cuda/tests/cudadrv/test_cuda_ndarray.py

@@ -45,6 +45,39 @@ class TestCudaNDArray(CUDATestCase):
         self.assertEqual(ary.shape, dary.shape)
         self.assertEqual(ary.shape[1:], dary.shape[1:])
 
+    def test_device_array_float(self):
+        # Ensure that a float shape raises an TypeError
+        with self.assertRaises(TypeError):
+            cuda.device_array(shape=1.23)
+        with self.assertRaises(TypeError):
+            cuda.device_array(shape=np.float64(1.23))
+        with self.assertRaises(TypeError):
+            cuda.device_array(shape=np.array(1.23))
+
+    def test_device_array_float_vectors(self):
+        # Ensure that np.array, list or tuple inputs with
+        # non-ints raise an TypeError
+        with self.assertRaises(TypeError):
+            cuda.device_array(shape=np.array([1.1]))
+        with self.assertRaises(TypeError):
+            cuda.device_array(shape=[1.1])
+        with self.assertRaises(TypeError):
+            cuda.device_array(shape=(1.1,))
+        with self.assertRaises(TypeError):
+            cuda.device_array(shape=np.array([1.1, 2.2]))
+        with self.assertRaises(TypeError):
+            cuda.device_array(shape=[1.1, 2.2])
+        with self.assertRaises(TypeError):
+            cuda.device_array(shape=(1.1, 2.2))
+
+    def test_device_array_vectors(self):
+        # Ensure that np.array or list of inputs with
+        # ints still work
+        dary = cuda.device_array(shape=np.array([10, 10]), dtype=np.bool)
+        self.assertEqual(dary.shape, (10, 10))
+        dary = cuda.device_array(shape=[10, 10], dtype=np.bool)
+        self.assertEqual(dary.shape, (10, 10))
+
     def test_devicearray(self):
         array = np.arange(100, dtype=np.int32)
         original = array.copy()

numba_cuda/numba/cuda/tests/cudadrv/test_emm_plugins.py

@@ -84,7 +84,7 @@ if not config.ENABLE_CUDASIM:
             # the tests don't try to do too much with it (e.g. open / close
             # it).
             self.get_ipc_handle_called = True
-            return "Dummy IPC handle for alloc %s" % memory.device_pointer.value
+            return "Dummy IPC handle for alloc %s" % memory.device_pointer_value
 
         @property
         def interface_version(self):

numba_cuda/numba/cuda/tests/cudadrv/test_runtime.py

@@ -1,6 +1,6 @@
 import multiprocessing
 import os
-from numba.cuda.testing import unittest, SerialMixin
+from numba.cuda.testing import unittest
 
 
 def set_visible_devices_and_check(q):
@@ -15,7 +15,7 @@ def set_visible_devices_and_check(q):
         q.put(-1)
 
 
-class TestVisibleDevices(unittest.TestCase, SerialMixin):
+class TestVisibleDevices(unittest.TestCase):
     def test_visible_devices_set_after_import(self):
         # See Issue #6149. This test checks that we can set
         # CUDA_VISIBLE_DEVICES after importing Numba and have the value

numba_cuda/numba/cuda/tests/cudadrv/test_streams.py

@@ -19,6 +19,7 @@ def with_asyncio_loop(f):
     return runner
 
 
+@unittest.skip("Disabled temporarily due to Issue #317")
 @skip_on_cudasim("CUDA Driver API unsupported in the simulator")
 class TestCudaStream(CUDATestCase):
     def test_add_callback(self):

numba_cuda/numba/cuda/tests/cudapy/extensions_usecases.py

@@ -28,7 +28,7 @@ if not config.ENABLE_CUDASIM:
         make_attribute_wrapper,
     )
     from numba.cuda.cudaimpl import lower
-    from numba.core import cgutils
+    from numba.cuda import cgutils
 
     @typeof_impl.register(TestStruct)
     def typeof_teststruct(val, c):

numba_cuda/numba/cuda/tests/cudapy/test_caching.py

@@ -14,7 +14,6 @@ from numba.cuda.testing import (
     skip_if_mvc_enabled,
     test_data_dir,
 )
-from numba.tests.support import SerialMixin
 from numba.tests.test_caching import (
     DispatcherCacheUsecasesTest,
     skip_bad_access,
@@ -22,7 +21,7 @@ from numba.tests.test_caching import (
 
 
 @skip_on_cudasim("Simulator does not implement caching")
-class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
+class CUDACachingTest(DispatcherCacheUsecasesTest):
     here = os.path.dirname(__file__)
     usecases_file = os.path.join(here, "cache_usecases.py")
     modname = "cuda_caching_test_fodder"
@@ -225,7 +224,7 @@ class CUDACachingTest(SerialMixin, DispatcherCacheUsecasesTest):
 
 
 @skip_on_cudasim("Simulator does not implement caching")
-class CUDACooperativeGroupTest(SerialMixin, DispatcherCacheUsecasesTest):
+class CUDACooperativeGroupTest(DispatcherCacheUsecasesTest):
     # See Issue #9432: https://github.com/numba/numba/issues/9432
     # If a cached function using CG sync was the first thing to compile,
     # the compile would fail.
@@ -259,7 +258,7 @@ class CUDACooperativeGroupTest(SerialMixin, DispatcherCacheUsecasesTest):
 
 
 @skip_on_cudasim("Simulator does not implement caching")
-class CUDAAndCPUCachingTest(SerialMixin, DispatcherCacheUsecasesTest):
+class CUDAAndCPUCachingTest(DispatcherCacheUsecasesTest):
     here = os.path.dirname(__file__)
     usecases_file = os.path.join(here, "cache_with_cpu_usecases.py")
     modname = "cuda_and_cpu_caching_test_fodder"
@@ -350,7 +349,7 @@ def get_different_cc_gpus():
 
 
 @skip_on_cudasim("Simulator does not implement caching")
-class TestMultiCCCaching(SerialMixin, DispatcherCacheUsecasesTest):
+class TestMultiCCCaching(DispatcherCacheUsecasesTest):
     here = os.path.dirname(__file__)
     usecases_file = os.path.join(here, "cache_usecases.py")
     modname = "cuda_multi_cc_caching_test_fodder"
@@ -484,11 +483,7 @@ def child_initializer():
 
 
 @skip_on_cudasim("Simulator does not implement caching")
-class TestMultiprocessCache(SerialMixin, DispatcherCacheUsecasesTest):
-    # Nested multiprocessing.Pool raises AssertionError:
-    # "daemonic processes are not allowed to have children"
-    _numba_parallel_test_ = False
-
+class TestMultiprocessCache(DispatcherCacheUsecasesTest):
     here = os.path.dirname(__file__)
     usecases_file = os.path.join(here, "cache_usecases.py")
     modname = "cuda_mp_caching_test_fodder"

numba_cuda/numba/cuda/tests/cudapy/test_complex.py

@@ -6,7 +6,7 @@ import numpy as np
 from numba.cuda.testing import unittest, CUDATestCase
 from numba.core import types
 from numba import cuda
-from numba.tests.complex_usecases import (
+from numba.cuda.tests.complex_usecases import (
     real_usecase,
     imag_usecase,
     conjugate_usecase,