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

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

@@ -1,22 +1,12 @@
 from numba.cuda.testing import unittest
 from numba.cuda.testing import skip_on_cudasim
 from numba.cuda.testing import CUDATestCase
-from numba.cuda.cudadrv.driver import PyNvJitLinker
 from numba.cuda import get_current_device
+from numba.cuda.cudadrv.driver import _Linker, _have_nvjitlink
 
 from numba import cuda
 from numba import config
-from numba.tests.support import run_in_subprocess, override_config
 
-try:
-    import pynvjitlink  # noqa: F401
-
-    PYNVJITLINK_INSTALLED = True
-except ImportError:
-    PYNVJITLINK_INSTALLED = False
-
-
-import itertools
 import os
 import io
 import contextlib
@@ -52,85 +42,13 @@ if TEST_BIN_DIR:
 
 
 @unittest.skipIf(
-    not config.CUDA_ENABLE_PYNVJITLINK or not TEST_BIN_DIR,
-    "pynvjitlink not enabled",
+    not config.CUDA_USE_NVIDIA_BINDING
+    or not TEST_BIN_DIR
+    or not _have_nvjitlink(),
+    "NVIDIA cuda bindings not enabled or nvJitLink not installed or new enough (>12.3)",
 )
 @skip_on_cudasim("Linking unsupported in the simulator")
 class TestLinker(CUDATestCase):
-    def test_nvjitlink_create(self):
-        patched_linker = PyNvJitLinker(cc=(7, 5))
-        assert "-arch=sm_75" in patched_linker.options
-
-    def test_nvjitlink_create_no_cc_error(self):
-        # nvJitLink expects at least the architecture to be specified.
-        with self.assertRaisesRegex(
-            RuntimeError, "PyNvJitLinker requires CC to be specified"
-        ):
-            PyNvJitLinker()
-
-    def test_nvjitlink_invalid_arch_error(self):
-        from pynvjitlink.api import NvJitLinkError
-
-        # CC 0.0 is not a valid compute capability
-        with self.assertRaisesRegex(
-            NvJitLinkError, "NVJITLINK_ERROR_UNRECOGNIZED_OPTION error"
-        ):
-            PyNvJitLinker(cc=(0, 0))
-
-    def test_nvjitlink_invalid_cc_type_error(self):
-        with self.assertRaisesRegex(
-            TypeError, "`cc` must be a list or tuple of length 2"
-        ):
-            PyNvJitLinker(cc=0)
-
-    def test_nvjitlink_ptx_compile_options(self):
-        max_registers = (None, 32)
-        lineinfo = (False, True)
-        lto = (False, True)
-        additional_flags = (None, ("-g",), ("-g", "-time"))
-        for (
-            max_registers_i,
-            line_info_i,
-            lto_i,
-            additional_flags_i,
-        ) in itertools.product(max_registers, lineinfo, lto, additional_flags):
-            with self.subTest(
-                max_registers=max_registers_i,
-                lineinfo=line_info_i,
-                lto=lto_i,
-                additional_flags=additional_flags_i,
-            ):
-                patched_linker = PyNvJitLinker(
-                    cc=(7, 5),
-                    max_registers=max_registers_i,
-                    lineinfo=line_info_i,
-                    lto=lto_i,
-                    additional_flags=additional_flags_i,
-                )
-                assert "-arch=sm_75" in patched_linker.options
-
-                if max_registers_i:
-                    assert (
-                        f"-maxrregcount={max_registers_i}"
-                        in patched_linker.options
-                    )
-                else:
-                    assert "-maxrregcount" not in patched_linker.options
-
-                if line_info_i:
-                    assert "-lineinfo" in patched_linker.options
-                else:
-                    assert "-lineinfo" not in patched_linker.options
-
-                if lto_i:
-                    assert "-lto" in patched_linker.options
-                else:
-                    assert "-lto" not in patched_linker.options
-
-                if additional_flags_i:
-                    for flag in additional_flags_i:
-                        assert flag in patched_linker.options
-
     def test_nvjitlink_add_file_guess_ext_linkable_code(self):
         files = (
             test_device_functions_a,
@@ -142,24 +60,20 @@ class TestLinker(CUDATestCase):
         )
         for file in files:
             with self.subTest(file=file):
-                patched_linker = PyNvJitLinker(
-                    cc=get_current_device().compute_capability
-                )
-                patched_linker.add_file_guess_ext(file)
+                linker = _Linker(cc=get_current_device().compute_capability)
+                linker.add_file_guess_ext(file)
 
     def test_nvjitlink_test_add_file_guess_ext_invalid_input(self):
         with open(test_device_functions_cubin, "rb") as f:
             content = f.read()
 
-        patched_linker = PyNvJitLinker(
-            cc=get_current_device().compute_capability
-        )
+        linker = _Linker(cc=get_current_device().compute_capability)
         with self.assertRaisesRegex(
             TypeError, "Expected path to file or a LinkableCode"
         ):
             # Feeding raw data as bytes to add_file_guess_ext should raise,
             # because there's no way to know what kind of file to treat it as
-            patched_linker.add_file_guess_ext(content)
+            linker.add_file_guess_ext(content)
 
     def test_nvjitlink_jit_with_linkable_code(self):
         files = (
@@ -261,77 +175,5 @@ class TestLinker(CUDATestCase):
                 pass
 
 
-@unittest.skipIf(
-    not PYNVJITLINK_INSTALLED or not TEST_BIN_DIR,
-    reason="pynvjitlink not enabled",
-)
-@skip_on_cudasim("Linking unsupported in the simulator")
-class TestLinkerUsage(CUDATestCase):
-    """Test that whether pynvjitlink can be enabled by both environment variable
-    and modification of config at runtime.
-    """
-
-    src = """if 1:
-        import os
-        from numba import cuda, config
-
-        {config}
-
-        TEST_BIN_DIR = os.getenv("NUMBA_CUDA_TEST_BIN_DIR")
-        if TEST_BIN_DIR:
-            test_device_functions_cubin = os.path.join(
-                TEST_BIN_DIR, "test_device_functions.cubin"
-            )
-
-        sig = "uint32(uint32, uint32)"
-        add_from_numba = cuda.declare_device("add_from_numba", sig)
-
-        @cuda.jit(link=[test_device_functions_cubin], lto=True)
-        def kernel(result):
-            result[0] = add_from_numba(1, 2)
-
-        result = cuda.device_array(1)
-        kernel[1, 1](result)
-        assert result[0] == 3
-        """
-
-    def test_linker_enabled_envvar(self):
-        env = os.environ.copy()
-        env.pop("NUMBA_CUDA_ENABLE_PYNVJITLINK", None)
-        run_in_subprocess(self.src.format(config=""), env=env)
-
-    def test_linker_disabled_envvar(self):
-        env = os.environ.copy()
-        env["NUMBA_CUDA_ENABLE_PYNVJITLINK"] = "0"
-        with self.assertRaisesRegex(
-            AssertionError, "LTO and additional flags require PyNvJitLinker"
-        ):
-            # Actual error raised is `ValueError`, but `run_in_subprocess`
-            # reraises as AssertionError.
-            run_in_subprocess(self.src.format(config=""), env=env)
-
-    def test_linker_enabled_config(self):
-        env = os.environ.copy()
-        env.pop("NUMBA_CUDA_ENABLE_PYNVJITLINK", None)
-        run_in_subprocess(
-            self.src.format(config="config.CUDA_ENABLE_PYNVJITLINK = True"),
-            env=env,
-        )
-
-    def test_linker_disabled_config(self):
-        env = os.environ.copy()
-        env.pop("NUMBA_CUDA_ENABLE_PYNVJITLINK", None)
-        with override_config("CUDA_ENABLE_PYNVJITLINK", False):
-            with self.assertRaisesRegex(
-                AssertionError, "LTO and additional flags require PyNvJitLinker"
-            ):
-                run_in_subprocess(
-                    self.src.format(
-                        config="config.CUDA_ENABLE_PYNVJITLINK = False"
-                    ),
-                    env=env,
-                )
-
-
 if __name__ == "__main__":
     unittest.main()

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

@@ -0,0 +1,27 @@
+from numba.cuda.cudadrv import nvrtc
+from numba.cuda.testing import skip_on_cudasim
+
+import unittest
+
+
+@skip_on_cudasim("NVVM Driver unsupported in the simulator")
+class TestArchOption(unittest.TestCase):
+    def test_get_arch_option(self):
+        # Test returning the nearest lowest arch.
+        self.assertEqual(nvrtc.get_arch_option(7, 5), "compute_75")
+        self.assertEqual(nvrtc.get_arch_option(7, 7), "compute_75")
+        self.assertEqual(nvrtc.get_arch_option(8, 5), "compute_80")
+        self.assertEqual(nvrtc.get_arch_option(9, 1), "compute_90")
+        # Test known arch.
+        supported_cc = nvrtc.NVRTC().get_supported_archs()
+        for arch in supported_cc:
+            self.assertEqual(
+                nvrtc.get_arch_option(*arch), "compute_%d%d" % arch
+            )
+        self.assertEqual(
+            nvrtc.get_arch_option(1000, 0), "compute_%d%d" % supported_cc[-1]
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -1,7 +1,7 @@
 import warnings
 
 from llvmlite import ir
-from numba.cuda.cudadrv import nvvm, runtime
+from numba.cuda.cudadrv import nvrtc, nvvm, runtime
 from numba.cuda.testing import unittest
 from numba.cuda.cudadrv.nvvm import LibDevice, NvvmError, NVVM
 from numba.cuda.testing import skip_on_cudasim
@@ -30,7 +30,7 @@ class TestNvvmDriver(unittest.TestCase):
             self.skipTest("-gen-lto unavailable in this toolkit version")
 
         nvvmir = self.get_nvvmir()
-        arch = "compute_%d%d" % nvvm.LOWEST_CURRENT_CC
+        arch = "compute_%d%d" % nvrtc.get_lowest_supported_cc()
         ltoir = nvvm.compile_ir(nvvmir, opt=3, gen_lto=None, arch=arch)
 
         # Verify we correctly passed the option by checking if we got LTOIR
@@ -110,7 +110,7 @@ class TestNvvmDriver(unittest.TestCase):
 
     def test_nvvm_support(self):
         """Test supported CC by NVVM"""
-        for arch in nvvm.get_supported_ccs():
+        for arch in nvrtc.get_supported_ccs():
             self._test_nvvm_support(arch=arch)
 
     def test_nvvm_warning(self):
@@ -135,22 +135,6 @@ class TestNvvmDriver(unittest.TestCase):
         self.assertIn("overriding noinline attribute", str(w[0]))
 
 
-@skip_on_cudasim("NVVM Driver unsupported in the simulator")
-class TestArchOption(unittest.TestCase):
-    def test_get_arch_option(self):
-        # Test returning the nearest lowest arch.
-        self.assertEqual(nvvm.get_arch_option(7, 5), "compute_75")
-        self.assertEqual(nvvm.get_arch_option(7, 7), "compute_75")
-        self.assertEqual(nvvm.get_arch_option(8, 8), "compute_87")
-        # Test known arch.
-        supported_cc = nvvm.get_supported_ccs()
-        for arch in supported_cc:
-            self.assertEqual(nvvm.get_arch_option(*arch), "compute_%d%d" % arch)
-        self.assertEqual(
-            nvvm.get_arch_option(1000, 0), "compute_%d%d" % supported_cc[-1]
-        )
-
-
 @skip_on_cudasim("NVVM Driver unsupported in the simulator")
 class TestLibDevice(unittest.TestCase):
     def test_libdevice_load(self):

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

@@ -1,9 +1,6 @@
 import multiprocessing
 import os
-from numba.core import config
-from numba.cuda.cudadrv.runtime import runtime
-from numba.cuda.testing import unittest, SerialMixin, skip_on_cudasim
-from unittest.mock import patch
+from numba.cuda.testing import unittest, SerialMixin
 
 
 def set_visible_devices_and_check(q):
@@ -18,39 +15,6 @@ def set_visible_devices_and_check(q):
         q.put(-1)
 
 
-if config.ENABLE_CUDASIM:
-    SUPPORTED_VERSIONS = ((-1, -1),)
-else:
-    SUPPORTED_VERSIONS = (
-        (11, 0),
-        (11, 1),
-        (11, 2),
-        (11, 3),
-        (11, 4),
-        (11, 5),
-        (11, 6),
-        (11, 7),
-    )
-
-
-class TestRuntime(unittest.TestCase):
-    def test_is_supported_version_true(self):
-        for v in SUPPORTED_VERSIONS:
-            with patch.object(runtime, "get_version", return_value=v):
-                self.assertTrue(runtime.is_supported_version())
-
-    @skip_on_cudasim("The simulator always simulates a supported runtime")
-    def test_is_supported_version_false(self):
-        # Check with an old unsupported version and some potential future
-        # versions
-        for v in ((10, 2), (11, 8), (12, 0)):
-            with patch.object(runtime, "get_version", return_value=v):
-                self.assertFalse(runtime.is_supported_version())
-
-    def test_supported_versions(self):
-        self.assertEqual(SUPPORTED_VERSIONS, runtime.supported_versions)
-
-
 class TestVisibleDevices(unittest.TestCase, SerialMixin):
     def test_visible_devices_set_after_import(self):
         # See Issue #6149. This test checks that we can set

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

@@ -1,8 +1,6 @@
-from numba.cuda.testing import ensure_supported_ccs_initialized
 from numba.cuda.tests import load_testsuite
 import os
 
 
 def load_tests(loader, tests, pattern):
-    ensure_supported_ccs_initialized()
     return load_testsuite(loader, os.path.dirname(__file__))

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

@@ -265,7 +265,7 @@ class TestCompileForCurrentDevice(CUDATestCase):
         # Check we target the current device's compute capability, or the
         # closest compute capability supported by the current toolkit.
         device_cc = cuda.get_current_device().compute_capability
-        cc = cuda.cudadrv.nvvm.find_closest_arch(device_cc)
+        cc = cuda.cudadrv.nvrtc.find_closest_arch(device_cc)
         target = f".target sm_{cc[0]}{cc[1]}"
         self.assertIn(target, ptx)
 

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

@@ -14,15 +14,6 @@ class TestCudaDebugInfo(CUDATestCase):
     These tests only checks the compiled PTX for debuginfo section
     """
 
-    def setUp(self):
-        super().setUp()
-        # If we're using LTO then we can't check the PTX in these tests,
-        # because we produce LTO-IR, which is opaque to the user.
-        # Additionally, LTO optimizes away the exception status due to an
-        # oversight in the way we generate it (it is not added to the used
-        # list).
-        self.skip_if_lto("Exceptions not supported with LTO")
-
     def _getasm(self, fn, sig):
         fn.compile(sig)
         return fn.inspect_asm(sig)

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

@@ -1,6 +1,7 @@
 from numba import cuda
 from numba.core.errors import TypingError
 from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
+from numba import config
 
 
 def noop(x):
@@ -89,6 +90,19 @@ class TestJitErrors(CUDATestCase):
         self.assertIn("resolving callee type: type(CUDADispatcher", excstr)
         self.assertIn("NameError: name 'floor' is not defined", excstr)
 
+    @skip_on_cudasim("Simulator does not use pynvjitlink")
+    @unittest.skipIf(
+        config.CUDA_USE_NVIDIA_BINDING, "NVIDIA cuda bindings enabled"
+    )
+    def test_lto_without_nvjitlink_error(self):
+        with self.assertRaisesRegex(RuntimeError, "LTO requires nvjitlink"):
+
+            @cuda.jit(lto=True)
+            def f():
+                pass
+
+            f[1, 1]()
+
 
 if __name__ == "__main__":
     unittest.main()

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

@@ -6,12 +6,6 @@ from numba.core import config
 
 
 class TestException(CUDATestCase):
-    def setUp(self):
-        super().setUp()
-        # LTO optimizes away the exception status due to an oversight
-        # in the way we generate it (it is not added to the used list).
-        self.skip_if_lto("Exceptions not supported with LTO")
-
     def test_exception(self):
         def foo(ary):
             x = cuda.threadIdx.x

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

@@ -1,4 +1,5 @@
 from numba.cuda.testing import skip_on_cudasim, unittest, CUDATestCase
+from numba.cuda.cudadrv.driver import _have_nvjitlink
 from llvmlite import ir
 
 import numpy as np
@@ -210,7 +211,7 @@ class TestExtendingLinkage(CUDATestCase):
             (test_device_functions_ltoir, cuda.LTOIR),
         )
 
-        lto = config.CUDA_ENABLE_PYNVJITLINK
+        lto = _have_nvjitlink()
 
         for path, ctor in files:
             if ctor == cuda.LTOIR and not lto:

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

@@ -188,10 +188,6 @@ class TestFastMathOption(CUDATestCase):
         )
 
     def test_divf_exception(self):
-        # LTO optimizes away the exception status due to an oversight
-        # in the way we generate it (it is not added to the used list).
-        self.skip_if_lto("Exceptions not supported with LTO")
-
         def f10(r, x, y):
             r[0] = x / y
 

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

@@ -198,6 +198,24 @@ class TestCudaLineInfo(CUDATestCase):
             "debug and lineinfo are mutually exclusive", str(w[0].message)
         )
 
+    def test_lineinfo_with_compile_internal(self):
+        # Calling a function implemented using compile_internal should not
+        # enable full debug info generation. See Numba-CUDA Issue #271,
+        # https://github.com/NVIDIA/numba-cuda/issues/271
+
+        @cuda.jit("void(complex128[::1], complex128[::1])", lineinfo=True)
+        def complex_abs_use(r, x):
+            r[0] = abs(x[0])
+
+        cc = cuda.get_current_device().compute_capability
+        ov = complex_abs_use.overloads[complex_abs_use.signatures[0]]
+        ptx = ov.inspect_asm(cc)
+
+        target = ".target sm_%s%s" % cc
+        target_debug = f"{target}, debug"
+        self.assertIn(target, ptx)
+        self.assertNotIn(target_debug, ptx)
+
 
 if __name__ == "__main__":
     unittest.main()

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

@@ -13,13 +13,6 @@ regex_pattern = (
 
 
 class TestUserExc(CUDATestCase):
-    def setUp(self):
-        super().setUp()
-        # LTO optimizes away the exception status due to an oversight
-        # in the way we generate it (it is not added to the used list).
-        # See https://github.com/numba/numba/issues/9526.
-        self.skip_if_lto("Exceptions not supported with LTO")
-
     def test_user_exception(self):
         @cuda.jit("void(int32)", debug=True, opt=False)
         def test_exc(x):

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

@@ -1,8 +1,6 @@
-from numba.cuda.testing import ensure_supported_ccs_initialized
 from numba.cuda.tests import load_testsuite
 import os
 
 
 def load_tests(loader, tests, pattern):
-    ensure_supported_ccs_initialized()
     return load_testsuite(loader, os.path.dirname(__file__))

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

@@ -1,8 +1,6 @@
-from numba.cuda.testing import ensure_supported_ccs_initialized
 from numba.cuda.tests import load_testsuite
 import os
 
 
 def load_tests(loader, tests, pattern):
-    ensure_supported_ccs_initialized()
     return load_testsuite(loader, os.path.dirname(__file__))

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

@@ -169,7 +169,16 @@ class TestNrtLinking(CUDATestCase):
         cc = get_current_device().compute_capability
         ptx, _ = compile(src, "external_nrt.cu", cc)
 
-        @cuda.jit(link=[PTXSource(ptx.encode(), nrt=True)])
+        @cuda.jit(
+            link=[
+                PTXSource(
+                    ptx.code
+                    if config.CUDA_USE_NVIDIA_BINDING
+                    else ptx.encode(),
+                    nrt=True,
+                )
+            ]
+        )
         def kernel():
             allocate_deallocate_handle()
 

{numba_cuda-0.15.1.dist-info → numba_cuda-0.16.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numba-cuda
-Version: 0.15.1
+Version: 0.16.0
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -14,16 +14,19 @@ License-File: LICENSE
 Requires-Dist: numba>=0.59.1
 Provides-Extra: cu11
 Requires-Dist: cuda-bindings==11.8.*; extra == "cu11"
+Requires-Dist: cuda-core==0.3.*; extra == "cu11"
 Requires-Dist: cuda-python==11.8.*; extra == "cu11"
 Requires-Dist: nvidia-cuda-nvcc-cu11; extra == "cu11"
 Requires-Dist: nvidia-cuda-runtime-cu11; extra == "cu11"
 Requires-Dist: nvidia-cuda-nvrtc-cu11; extra == "cu11"
 Provides-Extra: cu12
 Requires-Dist: cuda-bindings==12.9.*; extra == "cu12"
+Requires-Dist: cuda-core==0.3.*; extra == "cu12"
 Requires-Dist: cuda-python==12.9.*; extra == "cu12"
 Requires-Dist: nvidia-cuda-nvcc-cu12; extra == "cu12"
 Requires-Dist: nvidia-cuda-runtime-cu12; extra == "cu12"
 Requires-Dist: nvidia-cuda-nvrtc-cu12; extra == "cu12"
+Requires-Dist: nvidia-nvjitlink-cu12; extra == "cu12"
 Provides-Extra: test
 Requires-Dist: psutil; extra == "test"
 Requires-Dist: cffi; extra == "test"
@@ -51,17 +54,10 @@ tracker](https://github.com/NVIDIA/numba-cuda/issues).
 To raise questions or initiate discussions, please use the [Numba Discourse
 forum](https://numba.discourse.group).
 
-## Installation with pip
+## Installation with pip or conda
 
-```shell
-pip install numba-cuda
-```
-
-## Installation with Conda
+Please refer to the [Installation documentation](https://nvidia.github.io/numba-cuda/user/installation.html#installation-with-a-python-package-manager).
 
-```shell
-conda install -c conda-forge numba-cuda
-```
 
 ## Installation from source
 
@@ -71,6 +67,8 @@ Install as an editable install:
 pip install -e .
 ```
 
+If you want to manage all run-time dependencies yourself, also pass the `--no-deps` flag.
+
 ## Running tests
 
 ```