numba-cuda 0.21.1__cp313-cp313-win_amd64.whl

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

@@ -0,0 +1,277 @@
+# 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 import int32, float32
+from numba.cuda.testing import skip_on_cudasim, unittest, CUDATestCase
+from numba.cuda.core.config import ENABLE_CUDASIM
+
+
+def useless_syncthreads(ary):
+    i = cuda.grid(1)
+    cuda.syncthreads()
+    ary[i] = i
+
+
+def useless_syncwarp(ary):
+    i = cuda.grid(1)
+    cuda.syncwarp()
+    ary[i] = i
+
+
+def useless_syncwarp_with_mask(ary):
+    i = cuda.grid(1)
+    cuda.syncwarp(0xFFFF)
+    ary[i] = i
+
+
+def coop_syncwarp(res):
+    sm = cuda.shared.array(32, int32)
+    i = cuda.grid(1)
+
+    sm[i] = i
+    cuda.syncwarp()
+
+    if i < 16:
+        sm[i] = sm[i] + sm[i + 16]
+        cuda.syncwarp(0xFFFF)
+
+    if i < 8:
+        sm[i] = sm[i] + sm[i + 8]
+        cuda.syncwarp(0xFF)
+
+    if i < 4:
+        sm[i] = sm[i] + sm[i + 4]
+        cuda.syncwarp(0xF)
+
+    if i < 2:
+        sm[i] = sm[i] + sm[i + 2]
+        cuda.syncwarp(0x3)
+
+    if i == 0:
+        res[0] = sm[0] + sm[1]
+
+
+def simple_smem(ary):
+    N = 100
+    sm = cuda.shared.array(N, int32)
+    i = cuda.grid(1)
+    if i == 0:
+        for j in range(N):
+            sm[j] = j
+    cuda.syncthreads()
+    ary[i] = sm[i]
+
+
+def coop_smem2d(ary):
+    i, j = cuda.grid(2)
+    sm = cuda.shared.array((10, 20), float32)
+    sm[i, j] = (i + 1) / (j + 1)
+    cuda.syncthreads()
+    ary[i, j] = sm[i, j]
+
+
+def dyn_shared_memory(ary):
+    i = cuda.grid(1)
+    sm = cuda.shared.array(0, float32)
+    sm[i] = i * 2
+    cuda.syncthreads()
+    ary[i] = sm[i]
+
+
+def use_threadfence(ary):
+    ary[0] += 123
+    cuda.threadfence()
+    ary[0] += 321
+
+
+def use_threadfence_block(ary):
+    ary[0] += 123
+    cuda.threadfence_block()
+    ary[0] += 321
+
+
+def use_threadfence_system(ary):
+    ary[0] += 123
+    cuda.threadfence_system()
+    ary[0] += 321
+
+
+def use_syncthreads_count(ary_in, ary_out):
+    i = cuda.grid(1)
+    ary_out[i] = cuda.syncthreads_count(ary_in[i])
+
+
+def use_syncthreads_and(ary_in, ary_out):
+    i = cuda.grid(1)
+    ary_out[i] = cuda.syncthreads_and(ary_in[i])
+
+
+def use_syncthreads_or(ary_in, ary_out):
+    i = cuda.grid(1)
+    ary_out[i] = cuda.syncthreads_or(ary_in[i])
+
+
+def _safe_cc_check(cc):
+    if ENABLE_CUDASIM:
+        return True
+    else:
+        return cuda.get_current_device().compute_capability >= cc
+
+
+class TestCudaSync(CUDATestCase):
+    def _test_useless(self, kernel):
+        compiled = cuda.jit("void(int32[::1])")(kernel)
+        nelem = 10
+        ary = np.empty(nelem, dtype=np.int32)
+        exp = np.arange(nelem, dtype=np.int32)
+        compiled[1, nelem](ary)
+        np.testing.assert_equal(ary, exp)
+
+    def test_useless_syncthreads(self):
+        self._test_useless(useless_syncthreads)
+
+    @skip_on_cudasim("syncwarp not implemented on cudasim")
+    def test_useless_syncwarp(self):
+        self._test_useless(useless_syncwarp)
+
+    @skip_on_cudasim("syncwarp not implemented on cudasim")
+    @unittest.skipUnless(
+        _safe_cc_check((7, 0)), "Partial masks require CC 7.0 or greater"
+    )
+    def test_useless_syncwarp_with_mask(self):
+        self._test_useless(useless_syncwarp_with_mask)
+
+    @skip_on_cudasim("syncwarp not implemented on cudasim")
+    @unittest.skipUnless(
+        _safe_cc_check((7, 0)), "Partial masks require CC 7.0 or greater"
+    )
+    def test_coop_syncwarp(self):
+        # coop_syncwarp computes the sum of all integers from 0 to 31 (496)
+        # using a single warp
+        expected = 496
+        nthreads = 32
+        nblocks = 1
+
+        compiled = cuda.jit("void(int32[::1])")(coop_syncwarp)
+        res = np.zeros(1, dtype=np.int32)
+        compiled[nblocks, nthreads](res)
+        np.testing.assert_equal(expected, res[0])
+
+    def test_simple_smem(self):
+        compiled = cuda.jit("void(int32[::1])")(simple_smem)
+        nelem = 100
+        ary = np.empty(nelem, dtype=np.int32)
+        compiled[1, nelem](ary)
+        self.assertTrue(np.all(ary == np.arange(nelem, dtype=np.int32)))
+
+    def test_coop_smem2d(self):
+        compiled = cuda.jit("void(float32[:,::1])")(coop_smem2d)
+        shape = 10, 20
+        ary = np.empty(shape, dtype=np.float32)
+        compiled[1, shape](ary)
+        exp = np.empty_like(ary)
+        for i in range(ary.shape[0]):
+            for j in range(ary.shape[1]):
+                exp[i, j] = (i + 1) / (j + 1)
+        self.assertTrue(np.allclose(ary, exp))
+
+    def test_dyn_shared_memory(self):
+        compiled = cuda.jit("void(float32[::1])")(dyn_shared_memory)
+        shape = 50
+        ary = np.empty(shape, dtype=np.float32)
+        compiled[1, shape, 0, ary.size * 4](ary)
+        self.assertTrue(np.all(ary == 2 * np.arange(ary.size, dtype=np.int32)))
+
+    def test_threadfence_codegen(self):
+        # Does not test runtime behavior, just the code generation.
+        sig = (int32[:],)
+        compiled = cuda.jit(sig)(use_threadfence)
+        ary = np.zeros(10, dtype=np.int32)
+        compiled[1, 1](ary)
+        self.assertEqual(123 + 321, ary[0])
+        if not ENABLE_CUDASIM:
+            self.assertIn("membar.gl;", compiled.inspect_asm(sig))
+
+    def test_threadfence_block_codegen(self):
+        # Does not test runtime behavior, just the code generation.
+        sig = (int32[:],)
+        compiled = cuda.jit(sig)(use_threadfence_block)
+        ary = np.zeros(10, dtype=np.int32)
+        compiled[1, 1](ary)
+        self.assertEqual(123 + 321, ary[0])
+        if not ENABLE_CUDASIM:
+            self.assertIn("membar.cta;", compiled.inspect_asm(sig))
+
+    def test_threadfence_system_codegen(self):
+        # Does not test runtime behavior, just the code generation.
+        sig = (int32[:],)
+        compiled = cuda.jit(sig)(use_threadfence_system)
+        ary = np.zeros(10, dtype=np.int32)
+        compiled[1, 1](ary)
+        self.assertEqual(123 + 321, ary[0])
+        if not ENABLE_CUDASIM:
+            self.assertIn("membar.sys;", compiled.inspect_asm(sig))
+
+    def _test_syncthreads_count(self, in_dtype):
+        compiled = cuda.jit(use_syncthreads_count)
+        ary_in = np.ones(72, dtype=in_dtype)
+        ary_out = np.zeros(72, dtype=np.int32)
+        ary_in[31] = 0
+        ary_in[42] = 0
+        compiled[1, 72](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 70))
+
+    def test_syncthreads_count(self):
+        self._test_syncthreads_count(np.int32)
+
+    def test_syncthreads_count_upcast(self):
+        self._test_syncthreads_count(np.int16)
+
+    def test_syncthreads_count_downcast(self):
+        self._test_syncthreads_count(np.int64)
+
+    def _test_syncthreads_and(self, in_dtype):
+        compiled = cuda.jit(use_syncthreads_and)
+        nelem = 100
+        ary_in = np.ones(nelem, dtype=in_dtype)
+        ary_out = np.zeros(nelem, dtype=np.int32)
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 1))
+        ary_in[31] = 0
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 0))
+
+    def test_syncthreads_and(self):
+        self._test_syncthreads_and(np.int32)
+
+    def test_syncthreads_and_upcast(self):
+        self._test_syncthreads_and(np.int16)
+
+    def test_syncthreads_and_downcast(self):
+        self._test_syncthreads_and(np.int64)
+
+    def _test_syncthreads_or(self, in_dtype):
+        compiled = cuda.jit(use_syncthreads_or)
+        nelem = 100
+        ary_in = np.zeros(nelem, dtype=in_dtype)
+        ary_out = np.zeros(nelem, dtype=np.int32)
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 0))
+        ary_in[31] = 1
+        compiled[1, nelem](ary_in, ary_out)
+        self.assertTrue(np.all(ary_out == 1))
+
+    def test_syncthreads_or(self):
+        self._test_syncthreads_or(np.int32)
+
+    def test_syncthreads_or_upcast(self):
+        self._test_syncthreads_or(np.int16)
+
+    def test_syncthreads_or_downcast(self):
+        self._test_syncthreads_or(np.int64)
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,200 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from io import StringIO
+import logging
+
+import unittest
+from numba.cuda.core import tracing
+
+logger = logging.getLogger("trace")
+logger.setLevel(logging.INFO)
+
+# Make sure tracing is enabled
+orig_trace = tracing.trace
+tracing.trace = tracing.dotrace
+
+
+class CapturedTrace:
+    """Capture the trace temporarily for validation."""
+
+    def __init__(self):
+        self.buffer = StringIO()
+        self.handler = logging.StreamHandler(self.buffer)
+
+    def __enter__(self):
+        self._handlers = logger.handlers
+        self.buffer = StringIO()
+        logger.handlers = [logging.StreamHandler(self.buffer)]
+
+    def __exit__(self, type, value, traceback):
+        logger.handlers = self._handlers
+
+    def getvalue(self):
+        # Depending on how the tests are run, object names may be
+        # qualified by their containing module.
+        # Remove that to make the trace output independent from the testing mode.
+        log = self.buffer.getvalue()
+        log = log.replace(__name__ + ".", "")
+        return log
+
+
+class Class(object):
+    @tracing.trace
+    @classmethod
+    def class_method(cls):
+        pass
+
+    @tracing.trace
+    @staticmethod
+    def static_method():
+        pass
+
+    __test = None
+
+    def _test_get(self):
+        return self.__test
+
+    def _test_set(self, value):
+        self.__test = value
+
+    test = tracing.trace(property(_test_get, _test_set))
+
+    @tracing.trace
+    def method(self, some, other="value", *args, **kwds):
+        pass
+
+    def __repr__(self):
+        """Generate a deterministic string for testing."""
+        return "<Class instance>"
+
+
+class Class2(object):
+    @classmethod
+    def class_method(cls):
+        pass
+
+    @staticmethod
+    def static_method():
+        pass
+
+    __test = None
+
+    @property
+    def test(self):
+        return self.__test
+
+    @test.setter
+    def test(self, value):
+        self.__test = value
+
+    def method(self):
+        pass
+
+    def __str__(self):
+        return "Test(" + str(self.test) + ")"
+
+    def __repr__(self):
+        """Generate a deterministic string for testing."""
+        return "<Class2 instance>"
+
+
+@tracing.trace
+def test_traced_function():
+    # Test the tracing functionality with fixed values
+    x, y = 5, 5
+    z = True
+
+    a = x + y
+    b = x * y
+    if z:
+        result = a
+    else:
+        result = b
+
+    # The function should return 10 (5 + 5) when z is True
+    assert result == 10
+
+
+class TestTracing(unittest.TestCase):
+    def __init__(self, *args):
+        super(TestTracing, self).__init__(*args)
+
+    def setUp(self):
+        self.capture = CapturedTrace()
+
+    def tearDown(self):
+        del self.capture
+
+    def test_method(self):
+        with self.capture:
+            Class().method("foo", bar="baz")
+        self.assertEqual(
+            self.capture.getvalue(),
+            ">> Class.method(self=<Class instance>, some='foo', other='value', bar='baz')\n"
+            + "<< Class.method\n",
+        )
+
+    def test_class_method(self):
+        with self.capture:
+            Class.class_method()
+        self.assertEqual(
+            self.capture.getvalue(),
+            ">> Class.class_method(cls=<class 'Class'>)\n"
+            + "<< Class.class_method\n",
+        )
+
+    def test_static_method(self):
+        with self.capture:
+            Class.static_method()
+        self.assertEqual(
+            self.capture.getvalue(),
+            ">> static_method()\n" + "<< static_method\n",
+        )
+
+    def test_property(self):
+        with self.capture:
+            test = Class()
+            test.test = 1
+            assert 1 == test.test
+        self.assertEqual(
+            self.capture.getvalue(),
+            ">> Class._test_set(self=<Class instance>, value=1)\n"
+            + "<< Class._test_set\n"
+            + ">> Class._test_get(self=<Class instance>)\n"
+            + "<< Class._test_get -> 1\n",
+        )
+
+    def test_function(self):
+        with self.capture:
+            test_traced_function()
+        # The test function should be traced when called
+        trace_output = self.capture.getvalue()
+        self.assertIn(">> test_traced_function()", trace_output)
+        self.assertIn("<< test_traced_function", trace_output)
+
+    @unittest.skip("recursive decoration not yet implemented")
+    def test_injected(self):
+        with self.capture:
+            tracing.trace(Class2, recursive=True)
+            Class2.class_method()
+            Class2.static_method()
+            test = Class2()
+            test.test = 1
+            assert 1 == test.test
+            test.method()
+
+            self.assertEqual(
+                self.capture.getvalue(),
+                ">> Class2.class_method(cls=<type 'Class2'>)\n"
+                + "<< Class2.class_method\n"
+                ">> static_method()\n"
+                "<< static_method\n",
+            )
+
+
+# Reset tracing to its original value
+tracing.trace = orig_trace
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -0,0 +1,90 @@
+# 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.kernels.transpose import transpose
+from numba.cuda.testing import unittest
+from numba.cuda.testing import skip_on_cudasim, CUDATestCase
+
+
+recordwith2darray = np.dtype([("i", np.int32), ("j", np.float32, (3, 2))])
+
+
+@skip_on_cudasim("Device Array API unsupported in the simulator")
+class TestTranspose(CUDATestCase):
+    def test_transpose(self):
+        variants = (
+            (5, 6, np.float64),
+            (128, 128, np.complex128),
+            (1025, 512, np.float64),
+        )
+
+        for rows, cols, dtype in variants:
+            with self.subTest(rows=rows, cols=cols, dtype=dtype):
+                x = np.arange(rows * cols, dtype=dtype).reshape(cols, rows)
+                y = np.zeros(rows * cols, dtype=dtype).reshape(rows, cols)
+                dx = cuda.to_device(x)
+                dy = cuda.cudadrv.devicearray.from_array_like(y)
+                transpose(dx, dy)
+                dy.copy_to_host(y)
+                np.testing.assert_array_equal(x.transpose(), y)
+
+    small_variants = (
+        (2, 3),
+        (16, 16),
+        (16, 17),
+        (17, 16),
+        (14, 15),
+        (15, 14),
+        (14, 14),
+    )
+
+    def test_transpose_record(self):
+        for rows, cols in self.small_variants:
+            with self.subTest(rows=rows, cols=cols):
+                arr = np.recarray((rows, cols), dtype=recordwith2darray)
+                for x in range(rows):
+                    for y in range(cols):
+                        arr[x, y].i = x**2 + y
+                        j = np.arange(3 * 2, dtype=np.float32)
+                        arr[x, y].j = j.reshape(3, 2) * x + y
+
+                transposed = arr.T
+                d_arr = cuda.to_device(arr)
+                d_transposed = cuda.device_array_like(transposed)
+                transpose(d_arr, d_transposed)
+                host_transposed = d_transposed.copy_to_host()
+                np.testing.assert_array_equal(transposed, host_transposed)
+
+    def test_transpose_bool(self):
+        for rows, cols in self.small_variants:
+            with self.subTest(rows=rows, cols=cols):
+                arr = np.random.randint(2, size=(rows, cols), dtype=np.bool_)
+                transposed = arr.T
+
+                d_arr = cuda.to_device(arr)
+                d_transposed = cuda.device_array_like(transposed)
+                transpose(d_arr, d_transposed)
+
+                host_transposed = d_transposed.copy_to_host()
+                np.testing.assert_array_equal(transposed, host_transposed)
+
+    def test_transpose_view(self):
+        # Because the strides of transposes of views differ to those in NumPy
+        # (see issue #4974), we test the shape and strides of a transpose.
+        a = np.arange(120, dtype=np.int64).reshape((10, 12))
+        a_view_t = a[::2, ::2].T
+
+        d_a = cuda.to_device(a)
+        d_a_view_t = d_a[::2, ::2].T
+
+        self.assertEqual(d_a_view_t.shape, (6, 5))
+        self.assertEqual(d_a_view_t.strides, (40, 8))
+
+        h_a_view_t = d_a_view_t.copy_to_host()
+        np.testing.assert_array_equal(a_view_t, h_a_view_t)
+
+
+if __name__ == "__main__":
+    unittest.main()