numba-cuda 0.22.0__cp312-cp312-manylinux_2_24_aarch64.manylinux_2_28_aarch64.whl

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

@@ -0,0 +1,83 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+# -*- coding: utf-8 -*-
+from numba.cuda import int32, int64, uint32, uint64, float32, float64
+from numba.cuda.types import range_iter32_type
+from numba.cuda import itanium_mangler
+import unittest
+
+
+class TestItaniumManager(unittest.TestCase):
+    def test_ident(self):
+        got = itanium_mangler.mangle_identifier("apple")
+        expect = "5apple"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_identifier("ap_ple")
+        expect = "6ap_ple"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_identifier("apple213")
+        expect = "8apple213"
+        self.assertEqual(expect, got)
+
+    def test_types(self):
+        got = itanium_mangler.mangle_type(int32)
+        expect = "i"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_type(int64)
+        expect = "x"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_type(uint32)
+        expect = "j"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_type(uint64)
+        expect = "y"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_type(float32)
+        expect = "f"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_type(float64)
+        expect = "d"
+        self.assertEqual(expect, got)
+
+    def test_function(self):
+        got = itanium_mangler.mangle("what", [int32, float32])
+        expect = "_Z4whatif"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle(
+            "a_little_brown_fox", [uint64, uint32, float64]
+        )
+        expect = "_Z18a_little_brown_foxyjd"
+        self.assertEqual(expect, got)
+
+    def test_custom_type(self):
+        got = itanium_mangler.mangle_type(range_iter32_type)
+        name = str(range_iter32_type)
+        expect = "{n}{name}".format(n=len(name), name=name)
+        self.assertEqual(expect, got)
+
+    def test_mangle_literal(self):
+        # check int
+        got = itanium_mangler.mangle_value(123)
+        expect = "Li123E"
+        self.assertEqual(expect, got)
+        # check float (not handled using standard)
+        got = itanium_mangler.mangle_value(12.3)
+        self.assertRegex(got, r"^\d+_12_[0-9a-z][0-9a-z]3$")
+
+    def test_mangle_unicode(self):
+        name = "f∂ƒ©z"
+        got = itanium_mangler.mangle_identifier(name)
+        self.assertRegex(got, r"^\d+f(_[a-z0-9][a-z0-9])+z$")
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,371 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import contextlib
+import gc
+import pickle
+import runpy
+import subprocess
+import sys
+import unittest
+from multiprocessing import get_context
+
+from numba.cuda import HAS_NUMBA
+import numba
+
+if HAS_NUMBA:
+    from numba.core.errors import TypingError
+    from numba.core.target_extension import resolve_dispatcher_from_str
+else:
+    from numba.cuda.core.errors import TypingError
+from numba.cuda.tests.support import TestCase
+from numba.cuda.cloudpickle import dumps, loads
+from numba.cuda.testing import skip_on_standalone_numba_cuda
+
+
+@skip_on_standalone_numba_cuda
+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.cuda.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):
+        import numba
+
+        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.cuda.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/__init__.py

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from numba.cuda.tests import load_testsuite
+import os
+
+
+def load_tests(loader, tests, pattern):
+    return load_testsuite(loader, os.path.dirname(__file__))

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

@@ -0,0 +1,147 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import numpy as np
+from numba import cuda
+from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
+
+
+class TestArrayAttr(CUDATestCase):
+    def test_contigous_2d(self):
+        ary = np.arange(10)
+        cary = ary.reshape(2, 5)
+        fary = np.asfortranarray(cary)
+
+        dcary = cuda.to_device(cary)
+        dfary = cuda.to_device(fary)
+        self.assertTrue(dcary.is_c_contiguous())
+        self.assertTrue(not dfary.is_c_contiguous())
+        self.assertTrue(not dcary.is_f_contiguous())
+        self.assertTrue(dfary.is_f_contiguous())
+
+    def test_contigous_3d(self):
+        ary = np.arange(20)
+        cary = ary.reshape(2, 5, 2)
+        fary = np.asfortranarray(cary)
+
+        dcary = cuda.to_device(cary)
+        dfary = cuda.to_device(fary)
+        self.assertTrue(dcary.is_c_contiguous())
+        self.assertTrue(not dfary.is_c_contiguous())
+        self.assertTrue(not dcary.is_f_contiguous())
+        self.assertTrue(dfary.is_f_contiguous())
+
+    def test_contigous_4d(self):
+        ary = np.arange(60)
+        cary = ary.reshape(2, 5, 2, 3)
+        fary = np.asfortranarray(cary)
+
+        dcary = cuda.to_device(cary)
+        dfary = cuda.to_device(fary)
+        self.assertTrue(dcary.is_c_contiguous())
+        self.assertTrue(not dfary.is_c_contiguous())
+        self.assertTrue(not dcary.is_f_contiguous())
+        self.assertTrue(dfary.is_f_contiguous())
+
+    def test_ravel_1d(self):
+        ary = np.arange(60)
+        dary = cuda.to_device(ary)
+        for order in "CFA":
+            expect = ary.ravel(order=order)
+            dflat = dary.ravel(order=order)
+            flat = dflat.copy_to_host()
+            self.assertTrue(dary is not dflat)  # ravel returns new array
+            self.assertEqual(flat.ndim, 1)
+            self.assertPreciseEqual(expect, flat)
+
+    @skip_on_cudasim("CUDA Array Interface is not supported in the simulator")
+    def test_ravel_stride_1d(self):
+        ary = np.arange(60)
+        dary = cuda.to_device(ary)
+        # No-copy stride device array
+        darystride = dary[::2]
+        dary_data = dary.__cuda_array_interface__["data"][0]
+        ddarystride_data = darystride.__cuda_array_interface__["data"][0]
+        self.assertEqual(dary_data, ddarystride_data)
+        # Fail on ravel on non-contiguous array
+        with self.assertRaises(NotImplementedError):
+            darystride.ravel()
+
+    def test_ravel_c(self):
+        ary = np.arange(60)
+        reshaped = ary.reshape(2, 5, 2, 3)
+
+        expect = reshaped.ravel(order="C")
+        dary = cuda.to_device(reshaped)
+        dflat = dary.ravel()
+        flat = dflat.copy_to_host()
+        self.assertTrue(dary is not dflat)
+        self.assertEqual(flat.ndim, 1)
+        self.assertPreciseEqual(expect, flat)
+
+        # explicit order kwarg
+        for order in "CA":
+            expect = reshaped.ravel(order=order)
+            dary = cuda.to_device(reshaped)
+            dflat = dary.ravel(order=order)
+            flat = dflat.copy_to_host()
+            self.assertTrue(dary is not dflat)
+            self.assertEqual(flat.ndim, 1)
+            self.assertPreciseEqual(expect, flat)
+
+    @skip_on_cudasim("CUDA Array Interface is not supported in the simulator")
+    def test_ravel_stride_c(self):
+        ary = np.arange(60)
+        reshaped = ary.reshape(2, 5, 2, 3)
+
+        dary = cuda.to_device(reshaped)
+        darystride = dary[::2, ::2, ::2, ::2]
+        dary_data = dary.__cuda_array_interface__["data"][0]
+        ddarystride_data = darystride.__cuda_array_interface__["data"][0]
+        self.assertEqual(dary_data, ddarystride_data)
+        with self.assertRaises(NotImplementedError):
+            darystride.ravel()
+
+    def test_ravel_f(self):
+        ary = np.arange(60)
+        reshaped = np.asfortranarray(ary.reshape(2, 5, 2, 3))
+        for order in "FA":
+            expect = reshaped.ravel(order=order)
+            dary = cuda.to_device(reshaped)
+            dflat = dary.ravel(order=order)
+            flat = dflat.copy_to_host()
+            self.assertTrue(dary is not dflat)
+            self.assertEqual(flat.ndim, 1)
+            self.assertPreciseEqual(expect, flat)
+
+    @skip_on_cudasim("CUDA Array Interface is not supported in the simulator")
+    def test_ravel_stride_f(self):
+        ary = np.arange(60)
+        reshaped = np.asfortranarray(ary.reshape(2, 5, 2, 3))
+        dary = cuda.to_device(reshaped)
+        darystride = dary[::2, ::2, ::2, ::2]
+        dary_data = dary.__cuda_array_interface__["data"][0]
+        ddarystride_data = darystride.__cuda_array_interface__["data"][0]
+        self.assertEqual(dary_data, ddarystride_data)
+        with self.assertRaises(NotImplementedError):
+            darystride.ravel()
+
+    def test_reshape_c(self):
+        ary = np.arange(10)
+        expect = ary.reshape(2, 5)
+        dary = cuda.to_device(ary)
+        dary_reshaped = dary.reshape(2, 5)
+        got = dary_reshaped.copy_to_host()
+        self.assertPreciseEqual(expect, got)
+
+    def test_reshape_f(self):
+        ary = np.arange(10)
+        expect = ary.reshape(2, 5, order="F")
+        dary = cuda.to_device(ary)
+        dary_reshaped = dary.reshape(2, 5, order="F")
+        got = dary_reshaped.copy_to_host()
+        self.assertPreciseEqual(expect, got)
+
+
+if __name__ == "__main__":
+    unittest.main()