numba-cuda 0.19.1__py3-none-any.whl → 0.20.1__py3-none-any.whl

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

@@ -2,12 +2,273 @@
 # SPDX-License-Identifier: BSD-2-Clause
 
 import functools
+import warnings
 import numpy as np
 import unittest
 
-from numba import config, cuda, types
+from numba import cuda, types, njit, typeof
+from numba.cuda import config
+from numba.np import numpy_support
 from numba.cuda.tests.support import TestCase
-from numba.tests.test_ufuncs import BasicUFuncTest
+from numba.cuda.tests.support import MemoryLeakMixin
+
+
+class BaseUFuncTest(MemoryLeakMixin):
+    def setUp(self):
+        super(BaseUFuncTest, self).setUp()
+        self.inputs = [
+            (np.uint32(0), types.uint32),
+            (np.uint32(1), types.uint32),
+            (np.int32(-1), types.int32),
+            (np.int32(0), types.int32),
+            (np.int32(1), types.int32),
+            (np.uint64(0), types.uint64),
+            (np.uint64(1), types.uint64),
+            (np.int64(-1), types.int64),
+            (np.int64(0), types.int64),
+            (np.int64(1), types.int64),
+            (np.float32(-0.5), types.float32),
+            (np.float32(0.0), types.float32),
+            (np.float32(0.5), types.float32),
+            (np.float64(-0.5), types.float64),
+            (np.float64(0.0), types.float64),
+            (np.float64(0.5), types.float64),
+            (np.array([0, 1], dtype="u4"), types.Array(types.uint32, 1, "C")),
+            (np.array([0, 1], dtype="u8"), types.Array(types.uint64, 1, "C")),
+            (
+                np.array([-1, 0, 1], dtype="i4"),
+                types.Array(types.int32, 1, "C"),
+            ),
+            (
+                np.array([-1, 0, 1], dtype="i8"),
+                types.Array(types.int64, 1, "C"),
+            ),
+            (
+                np.array([-0.5, 0.0, 0.5], dtype="f4"),
+                types.Array(types.float32, 1, "C"),
+            ),
+            (
+                np.array([-0.5, 0.0, 0.5], dtype="f8"),
+                types.Array(types.float64, 1, "C"),
+            ),
+            (np.array([0, 1], dtype=np.int8), types.Array(types.int8, 1, "C")),
+            (
+                np.array([0, 1], dtype=np.int16),
+                types.Array(types.int16, 1, "C"),
+            ),
+            (
+                np.array([0, 1], dtype=np.uint8),
+                types.Array(types.uint8, 1, "C"),
+            ),
+            (
+                np.array([0, 1], dtype=np.uint16),
+                types.Array(types.uint16, 1, "C"),
+            ),
+        ]
+
+    @functools.lru_cache(maxsize=None)
+    def _compile(self, pyfunc, args, nrt=False):
+        # NOTE: to test the implementation of Numpy ufuncs, we disable
+        # rewriting of array expressions.
+        return njit(args, _nrt=nrt, no_rewrites=True)(pyfunc)
+
+    def _determine_output_type(
+        self, input_type, int_output_type=None, float_output_type=None
+    ):
+        ty = input_type
+        if isinstance(ty, types.Array):
+            ndim = ty.ndim
+            ty = ty.dtype
+        else:
+            ndim = 1
+
+        if ty in types.signed_domain:
+            if int_output_type:
+                output_type = types.Array(int_output_type, ndim, "C")
+            else:
+                output_type = types.Array(ty, ndim, "C")
+        elif ty in types.unsigned_domain:
+            if int_output_type:
+                output_type = types.Array(int_output_type, ndim, "C")
+            else:
+                output_type = types.Array(ty, ndim, "C")
+        else:
+            if float_output_type:
+                output_type = types.Array(float_output_type, ndim, "C")
+            else:
+                output_type = types.Array(ty, ndim, "C")
+        return output_type
+
+
+class BasicUFuncTest(BaseUFuncTest):
+    def _make_ufunc_usecase(self, ufunc):
+        return _make_ufunc_usecase(ufunc)
+
+    def basic_ufunc_test(
+        self,
+        ufunc,
+        skip_inputs=[],
+        additional_inputs=[],
+        int_output_type=None,
+        float_output_type=None,
+        kinds="ifc",
+        positive_only=False,
+    ):
+        # Necessary to avoid some Numpy warnings being silenced, despite
+        # the simplefilter() call below.
+        self.reset_module_warnings(__name__)
+
+        pyfunc = self._make_ufunc_usecase(ufunc)
+
+        inputs = list(self.inputs) + additional_inputs
+
+        for input_tuple in inputs:
+            input_operand = input_tuple[0]
+            input_type = input_tuple[1]
+
+            is_tuple = isinstance(input_operand, tuple)
+            if is_tuple:
+                args = input_operand
+            else:
+                args = (input_operand,) * ufunc.nin
+
+            if input_type in skip_inputs:
+                continue
+            if positive_only and np.any(args[0] < 0):
+                continue
+
+            # Some ufuncs don't allow all kinds of arguments
+            if args[0].dtype.kind not in kinds:
+                continue
+
+            output_type = self._determine_output_type(
+                input_type, int_output_type, float_output_type
+            )
+
+            input_types = (input_type,) * ufunc.nin
+            output_types = (output_type,) * ufunc.nout
+            argtys = input_types + output_types
+            cfunc = self._compile(pyfunc, argtys)
+
+            if isinstance(args[0], np.ndarray):
+                results = [
+                    np.zeros(args[0].shape, dtype=out_ty.dtype.name)
+                    for out_ty in output_types
+                ]
+                expected = [
+                    np.zeros(args[0].shape, dtype=out_ty.dtype.name)
+                    for out_ty in output_types
+                ]
+            else:
+                results = [
+                    np.zeros(1, dtype=out_ty.dtype.name)
+                    for out_ty in output_types
+                ]
+                expected = [
+                    np.zeros(1, dtype=out_ty.dtype.name)
+                    for out_ty in output_types
+                ]
+
+            invalid_flag = False
+            with warnings.catch_warnings(record=True) as warnlist:
+                warnings.simplefilter("always")
+                pyfunc(*args, *expected)
+
+                warnmsg = "invalid value encountered"
+                for thiswarn in warnlist:
+                    if issubclass(thiswarn.category, RuntimeWarning) and str(
+                        thiswarn.message
+                    ).startswith(warnmsg):
+                        invalid_flag = True
+
+            cfunc(*args, *results)
+
+            for expected_i, result_i in zip(expected, results):
+                msg = "\n".join(
+                    [
+                        "ufunc '{0}' failed",
+                        "inputs ({1}):",
+                        "{2}",
+                        "got({3})",
+                        "{4}",
+                        "expected ({5}):",
+                        "{6}",
+                    ]
+                ).format(
+                    ufunc.__name__,
+                    input_type,
+                    input_operand,
+                    output_type,
+                    result_i,
+                    expected_i.dtype,
+                    expected_i,
+                )
+                try:
+                    np.testing.assert_array_almost_equal(
+                        expected_i, result_i, decimal=5, err_msg=msg
+                    )
+                except AssertionError:
+                    if invalid_flag:
+                        # Allow output to mismatch for invalid input
+                        print(
+                            "Output mismatch for invalid input",
+                            input_tuple,
+                            result_i,
+                            expected_i,
+                        )
+                    else:
+                        raise
+
+    def signed_unsigned_cmp_test(self, comparison_ufunc):
+        self.basic_ufunc_test(comparison_ufunc)
+
+        if numpy_support.numpy_version < (1, 25):
+            return
+
+        # Test additional implementations that specifically handle signed /
+        # unsigned comparisons added in NumPy 1.25:
+        # https://github.com/numpy/numpy/pull/23713
+        additional_inputs = (
+            (np.int64(-1), np.uint64(0)),
+            (np.int64(-1), np.uint64(1)),
+            (np.int64(0), np.uint64(0)),
+            (np.int64(0), np.uint64(1)),
+            (np.int64(1), np.uint64(0)),
+            (np.int64(1), np.uint64(1)),
+            (np.uint64(0), np.int64(-1)),
+            (np.uint64(0), np.int64(0)),
+            (np.uint64(0), np.int64(1)),
+            (np.uint64(1), np.int64(-1)),
+            (np.uint64(1), np.int64(0)),
+            (np.uint64(1), np.int64(1)),
+            (
+                np.array([-1, -1, 0, 0, 1, 1], dtype=np.int64),
+                np.array([0, 1, 0, 1, 0, 1], dtype=np.uint64),
+            ),
+            (
+                np.array([0, 1, 0, 1, 0, 1], dtype=np.uint64),
+                np.array([-1, -1, 0, 0, 1, 1], dtype=np.int64),
+            ),
+        )
+
+        pyfunc = self._make_ufunc_usecase(comparison_ufunc)
+
+        for a, b in additional_inputs:
+            input_types = (typeof(a), typeof(b))
+            output_type = types.Array(types.bool_, 1, "C")
+            argtys = input_types + (output_type,)
+            cfunc = self._compile(pyfunc, argtys)
+
+            if isinstance(a, np.ndarray):
+                result = np.zeros(a.shape, dtype=np.bool_)
+            else:
+                result = np.zeros(1, dtype=np.bool_)
+
+            expected = np.zeros_like(result)
+
+            pyfunc(a, b, expected)
+            cfunc(a, b, result)
+            np.testing.assert_equal(expected, result)
 
 
 def _make_ufunc_usecase(ufunc):

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

@@ -3,7 +3,7 @@
 
 from numba.cuda.testing import unittest, CUDATestCase
 from numba import cuda
-from numba.core import config
+from numba.cuda.core import config
 
 
 class MyError(Exception):

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

@@ -11,7 +11,7 @@ corresponding vector type from `cuda` module in kernel to use them.
 
 import numpy as np
 
-from numba.core import config
+from numba.cuda.core import config
 from numba.cuda.testing import CUDATestCase
 
 from numba import cuda

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

@@ -2,17 +2,123 @@
 # SPDX-License-Identifier: BSD-2-Clause
 
 import numpy as np
+import math
 
-from numba import vectorize, cuda
-from numba.tests.npyufunc.test_vectorize_decor import (
-    BaseVectorizeDecor,
-    BaseVectorizeNopythonArg,
-    BaseVectorizeUnrecognizedArg,
-)
+from numba import vectorize, cuda, int32, uint32, float32, float64
 from numba.cuda.testing import skip_on_cudasim, CUDATestCase
+from numba.cuda.tests.support import CheckWarningsMixin
+
 import unittest
 
 
+pi = math.pi
+
+
+def sinc(x):
+    if x == 0.0:
+        return 1.0
+    else:
+        return math.sin(x * pi) / (pi * x)
+
+
+def scaled_sinc(x, scale):
+    if x == 0.0:
+        return scale
+    else:
+        return scale * (math.sin(x * pi) / (pi * x))
+
+
+def vector_add(a, b):
+    return a + b
+
+
+class BaseVectorizeDecor(object):
+    target = None
+    wrapper = None
+    funcs = {
+        "func1": sinc,
+        "func2": scaled_sinc,
+        "func3": vector_add,
+    }
+
+    @classmethod
+    def _run_and_compare(cls, func, sig, A, *args, **kwargs):
+        if cls.wrapper is not None:
+            func = cls.wrapper(func)
+        numba_func = vectorize(sig, target=cls.target)(func)
+        numpy_func = np.vectorize(func)
+        result = numba_func(A, *args)
+        gold = numpy_func(A, *args)
+        np.testing.assert_allclose(result, gold, **kwargs)
+
+    def test_1(self):
+        sig = ["float64(float64)", "float32(float32)"]
+        func = self.funcs["func1"]
+        A = np.arange(100, dtype=np.float64)
+        self._run_and_compare(func, sig, A)
+
+    def test_2(self):
+        sig = [float64(float64), float32(float32)]
+        func = self.funcs["func1"]
+        A = np.arange(100, dtype=np.float64)
+        self._run_and_compare(func, sig, A)
+
+    def test_3(self):
+        sig = ["float64(float64, uint32)"]
+        func = self.funcs["func2"]
+        A = np.arange(100, dtype=np.float64)
+        scale = np.uint32(3)
+        self._run_and_compare(func, sig, A, scale, atol=1e-8)
+
+    def test_4(self):
+        sig = [
+            int32(int32, int32),
+            uint32(uint32, uint32),
+            float32(float32, float32),
+            float64(float64, float64),
+        ]
+        func = self.funcs["func3"]
+        A = np.arange(100, dtype=np.float64)
+        self._run_and_compare(func, sig, A, A)
+        A = A.astype(np.float32)
+        self._run_and_compare(func, sig, A, A)
+        A = A.astype(np.int32)
+        self._run_and_compare(func, sig, A, A)
+        A = A.astype(np.uint32)
+        self._run_and_compare(func, sig, A, A)
+
+
+class BaseVectorizeNopythonArg(unittest.TestCase, CheckWarningsMixin):
+    """
+    Test passing the nopython argument to the vectorize decorator.
+    """
+
+    def _test_target_nopython(self, target, warnings, with_sig=True):
+        a = np.array([2.0], dtype=np.float32)
+        b = np.array([3.0], dtype=np.float32)
+        sig = [float32(float32, float32)]
+        args = with_sig and [sig] or []
+        with self.check_warnings(warnings):
+            f = vectorize(*args, target=target, nopython=True)(vector_add)
+            f(a, b)
+
+
+class BaseVectorizeUnrecognizedArg(unittest.TestCase, CheckWarningsMixin):
+    """
+    Test passing an unrecognized argument to the vectorize decorator.
+    """
+
+    def _test_target_unrecognized_arg(self, target, with_sig=True):
+        a = np.array([2.0], dtype=np.float32)
+        b = np.array([3.0], dtype=np.float32)
+        sig = [float32(float32, float32)]
+        args = with_sig and [sig] or []
+        with self.assertRaises(KeyError) as raises:
+            f = vectorize(*args, target=target, nonexistent=2)(vector_add)
+            f(a, b)
+        self.assertIn("Unrecognized options", str(raises.exception))
+
+
 @skip_on_cudasim("ufunc API unsupported in the simulator")
 class TestVectorizeDecor(CUDATestCase, BaseVectorizeDecor):
     """

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

@@ -15,7 +15,7 @@ from numba.cuda.tests.support import (
     run_in_subprocess,
 )
 from numba.core.errors import NumbaPerformanceWarning
-from numba.core import config
+from numba.cuda.core import config
 import warnings
 
 

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

@@ -7,7 +7,7 @@ import numpy as np
 from numba import cuda, int32, int64, float32, float64
 from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
 from numba.cuda.compiler import compile_ptx
-from numba.core import config
+from numba.cuda.core import config
 
 
 def useful_syncwarp(ary):

numba_cuda/numba/cuda/tests/doc_examples/test_cg.py

@@ -10,13 +10,11 @@ from numba.cuda.testing import (
     skip_on_cudasim,
     skip_if_cudadevrt_missing,
     skip_unless_cc_60,
-    skip_if_mvc_enabled,
 )
 
 
 @skip_if_cudadevrt_missing
 @skip_unless_cc_60
-@skip_if_mvc_enabled("CG not supported with MVC")
 @skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
 class TestCooperativeGroups(CUDATestCase):
     def test_ex_grid_sync(self):

numba_cuda/numba/cuda/tests/doc_examples/test_ffi.py

@@ -90,7 +90,8 @@ class TestFFI(CUDATestCase):
 
     def test_ex_extra_includes(self):
         import numpy as np
-        from numba import cuda, config
+        from numba import cuda
+        from numba.cuda import config
         import os
 
         basedir = os.path.dirname(os.path.abspath(__file__))
@@ -103,7 +104,7 @@ class TestFFI(CUDATestCase):
         includedir = ":".join([mul_dir, add_dir])
         with override_config("CUDA_NVRTC_EXTRA_SEARCH_PATHS", includedir):
             # magictoken.ex_extra_search_paths.begin
-            from numba import config
+            from numba.cuda import config
 
             includedir = ":".join([mul_dir, add_dir])
             config.CUDA_NVRTC_EXTRA_SEARCH_PATHS = includedir

numba_cuda/numba/cuda/tests/doc_examples/test_laplace.py

@@ -8,14 +8,12 @@ from numba.cuda.testing import (
     skip_if_cudadevrt_missing,
     skip_on_cudasim,
     skip_unless_cc_60,
-    skip_if_mvc_enabled,
 )
 from numba.cuda.tests.support import captured_stdout
 
 
 @skip_if_cudadevrt_missing
 @skip_unless_cc_60
-@skip_if_mvc_enabled("CG not supported with MVC")
 @skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
 class TestLaplace(CUDATestCase):
     """

numba_cuda/numba/cuda/tests/doc_examples/test_sessionize.py

@@ -8,14 +8,12 @@ from numba.cuda.testing import (
     skip_if_cudadevrt_missing,
     skip_on_cudasim,
     skip_unless_cc_60,
-    skip_if_mvc_enabled,
 )
 from numba.cuda.tests.support import captured_stdout
 
 
 @skip_if_cudadevrt_missing
 @skip_unless_cc_60
-@skip_if_mvc_enabled("CG not supported with MVC")
 @skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
 class TestSessionization(CUDATestCase):
     """

numba_cuda/numba/cuda/tests/nocuda/test_import.py

@@ -26,6 +26,9 @@ class TestImport(unittest.TestCase):
             "numba.cpython.mathimpl",
             "numba.cpython.printimpl",
             "numba.cpython.randomimpl",
+            "numba.cuda.cpython.numbers",
+            "numba.cuda.cpython.cmathimpl",
+            "numba.cuda.cpython.mathimpl",
             "numba.core.optional",
             "numba.misc.gdb_hook",
             "numba.misc.literal",
@@ -37,7 +40,6 @@ class TestImport(unittest.TestCase):
             "numba.np.npyimpl",
             "numba.typed.typeddict",
             "numba.typed.typedlist",
-            "numba.experimental.jitclass.base",
         )
 
         code = "import sys; from numba import cuda; print(list(sys.modules))"

numba_cuda/numba/cuda/tests/nocuda/test_library_lookup.py

@@ -6,7 +6,8 @@ import os
 import multiprocessing as mp
 import warnings
 
-from numba.core.config import IS_WIN32, IS_OSX
+
+from numba.cuda.core.config import IS_WIN32
 from numba.core.errors import NumbaWarning
 from numba.cuda.cudadrv import nvvm
 from numba.cuda.testing import (
@@ -19,6 +20,7 @@ from numba.cuda.cuda_paths import (
     _get_nvvm_path_decision,
     _get_cudalib_dir_path_decision,
     get_system_ctk,
+    get_system_ctk_libdir,
 )
 
 
@@ -102,10 +104,12 @@ class TestLibDeviceLookUp(LibraryLookupBase):
         # Check that CUDA_HOME works by removing conda-env
         by, info, warns = self.remote_do(self.do_set_cuda_home)
         self.assertEqual(by, "CUDA_HOME")
-        self.assertEqual(info, os.path.join("mycudahome", "nvvm", "libdevice"))
+        self.assertTrue(
+            info.startswith(os.path.join("mycudahome", "nvvm", "libdevice"))
+        )
         self.assertFalse(warns)
 
-        if get_system_ctk() is None:
+        if get_system_ctk("nvvm", "libdevice") is None:
             # Fake remove conda environment so no cudatoolkit is available
             by, info, warns = self.remote_do(self.do_clear_envs)
             self.assertEqual(by, "<unknown>")
@@ -148,13 +152,16 @@ class TestNvvmLookUp(LibraryLookupBase):
         self.assertEqual(by, "CUDA_HOME")
         self.assertFalse(warns)
         if IS_WIN32:
-            self.assertEqual(info, os.path.join("mycudahome", "nvvm", "bin"))
-        elif IS_OSX:
-            self.assertEqual(info, os.path.join("mycudahome", "nvvm", "lib"))
+            self.assertEqual(
+                os.path.dirname(info), os.path.join("mycudahome", "nvvm", "bin")
+            )
         else:
-            self.assertEqual(info, os.path.join("mycudahome", "nvvm", "lib64"))
+            self.assertEqual(
+                os.path.dirname(info),
+                os.path.join("mycudahome", "nvvm", "lib64"),
+            )
 
-        if get_system_ctk() is None:
+        if get_system_ctk("nvvm") is None:
             # Fake remove conda environment so no cudatoolkit is available
             by, info, warns = self.remote_do(self.do_clear_envs)
             self.assertEqual(by, "<unknown>")
@@ -199,12 +206,17 @@ class TestCudaLibLookUp(LibraryLookupBase):
         self.assertEqual(by, "CUDA_HOME")
         self.assertFalse(warns)
         if IS_WIN32:
-            self.assertEqual(info, os.path.join("mycudahome", "bin"))
-        elif IS_OSX:
-            self.assertEqual(info, os.path.join("mycudahome", "lib"))
+            # I think only wheels don't have the "Library" directory?
+            self.assertTrue(
+                info
+                in (
+                    os.path.join("mycudahome", "bin"),
+                    os.path.join("mycudahome", "Library", "bin"),
+                )
+            )
         else:
             self.assertEqual(info, os.path.join("mycudahome", "lib64"))
-        if get_system_ctk() is None:
+        if get_system_ctk_libdir() is None:
             # Fake remove conda environment so no cudatoolkit is available
             by, info, warns = self.remote_do(self.do_clear_envs)
             self.assertEqual(by, "<unknown>")

numba_cuda/numba/cuda/tests/nrt/test_nrt.py

@@ -10,9 +10,10 @@ from numba.cuda.testing import CUDATestCase, skip_on_cudasim
 from numba.cuda.tests.support import run_in_subprocess, override_config
 from numba.cuda import get_current_device
 from numba.cuda.cudadrv.nvrtc import compile
-from numba import config, types
+from numba import types
 from numba.core.typing import signature
 from numba import cuda
+from numba.cuda import config
 from numba.cuda.typing.templates import AbstractTemplate
 from numba.cuda.cudadrv.linkable_code import (
     CUSource,