numba-cuda 0.13.0__py3-none-any.whl → 0.14.1__py3-none-any.whl

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

@@ -1,5 +1,5 @@
 from math import sqrt
-from numba import cuda, float32, int16, int32, int64, uint32, void
+from numba import cuda, float32, int16, int32, int64, types, uint32, void
 from numba.cuda import (
     compile,
     compile_for_current_device,
@@ -288,7 +288,7 @@ class TestCompileOnlyTests(unittest.TestCase):
             # Sleep for a variable time
             cuda.nanosleep(x)
 
-        ptx, resty = compile_ptx(use_nanosleep, (uint32,), cc=(7, 0))
+        ptx, resty = compile_ptx(use_nanosleep, (uint32,))
 
         nanosleep_count = 0
         for line in ptx.split("\n"):
@@ -306,5 +306,65 @@ class TestCompileOnlyTests(unittest.TestCase):
         )
 
 
+@skip_on_cudasim("Compilation unsupported in the simulator")
+class TestCompileWithLaunchBounds(unittest.TestCase):
+    def _test_launch_bounds_common(self, launch_bounds):
+        def f():
+            pass
+
+        sig = "void()"
+        ptx, resty = cuda.compile_ptx(f, sig, launch_bounds=launch_bounds)
+        self.assertIsInstance(resty, types.NoneType)
+        self.assertRegex(ptx, r".maxntid\s+128,\s+1,\s+1")
+        return ptx
+
+    def test_launch_bounds_scalar(self):
+        launch_bounds = 128
+        ptx = self._test_launch_bounds_common(launch_bounds)
+
+        self.assertNotIn(".minnctapersm", ptx)
+        self.assertNotIn(".maxclusterrank", ptx)
+
+    def test_launch_bounds_tuple(self):
+        launch_bounds = (128,)
+        ptx = self._test_launch_bounds_common(launch_bounds)
+
+        self.assertNotIn(".minnctapersm", ptx)
+        self.assertNotIn(".maxclusterrank", ptx)
+
+    def test_launch_bounds_with_min_cta(self):
+        launch_bounds = (128, 2)
+        ptx = self._test_launch_bounds_common(launch_bounds)
+
+        self.assertRegex(ptx, r".minnctapersm\s+2")
+        self.assertNotIn(".maxclusterrank", ptx)
+
+    def test_launch_bounds_with_max_cluster_rank(self):
+        def f():
+            pass
+
+        launch_bounds = (128, 2, 4)
+        cc = (9, 0)
+        sig = "void()"
+        ptx, resty = cuda.compile_ptx(
+            f, sig, launch_bounds=launch_bounds, cc=cc
+        )
+        self.assertIsInstance(resty, types.NoneType)
+        self.assertRegex(ptx, r".maxntid\s+128,\s+1,\s+1")
+
+        self.assertRegex(ptx, r".minnctapersm\s+2")
+        self.assertRegex(ptx, r".maxclusterrank\s+4")
+
+    def test_too_many_launch_bounds(self):
+        def f():
+            pass
+
+        sig = "void()"
+        launch_bounds = (128, 2, 4, 8)
+
+        with self.assertRaisesRegex(ValueError, "Got 4 launch bounds:"):
+            cuda.compile_ptx(f, sig, launch_bounds=launch_bounds)
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -332,10 +332,10 @@ class TestCudaDebugInfo(CUDATestCase):
 
         @cuda.jit("void(int32, int32)", debug=True, opt=False)
         def f(x, y):
-            z = x  # noqa: F841
-            z = 100  # noqa: F841
-            z = y  # noqa: F841
-            z = True  # noqa: F841
+            z1 = x  # noqa: F841
+            z2 = 100  # noqa: F841
+            z3 = y  # noqa: F841
+            z4 = True  # noqa: F841
 
         llvm_ir = f.inspect_llvm(sig)
         # Verify the call to llvm.dbg.declare is replaced by llvm.dbg.value
@@ -373,6 +373,45 @@ class TestCudaDebugInfo(CUDATestCase):
         match = re.compile(pat).search(llvm_ir)
         self.assertIsNone(match, msg=llvm_ir)
 
+    def test_union_poly_types(self):
+        sig = (types.int32, types.int32)
+
+        @cuda.jit("void(int32, int32)", debug=True, opt=False)
+        def f(x, y):
+            foo = 100  # noqa: F841
+            foo = 2.34  # noqa: F841
+            foo = True  # noqa: F841
+            foo = 200  # noqa: F841
+
+        llvm_ir = f.inspect_llvm(sig)
+        # Extract the type node id
+        pat1 = r'!DILocalVariable\(.*name: "foo".*type: !(\d+)\)'
+        match = re.compile(pat1).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        mdnode_id = match.group(1)
+        # Verify the union type and extract the elements node id
+        pat2 = rf"!{mdnode_id} = distinct !DICompositeType\(elements: !(\d+),.*size: 64, tag: DW_TAG_union_type\)"  # noqa: E501
+        match = re.compile(pat2).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        mdnode_id = match.group(1)
+        # Extract the member node ids
+        pat3 = r"!{ !(\d+), !(\d+), !(\d+) }"
+        match = re.compile(pat3).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        mdnode_id1 = match.group(1)
+        mdnode_id2 = match.group(2)
+        mdnode_id3 = match.group(3)
+        # Verify the member nodes
+        pat4 = rf'!{mdnode_id1} = !DIDerivedType(.*name: "_bool", size: 8, tag: DW_TAG_member)'  # noqa: E501
+        match = re.compile(pat4).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        pat5 = rf'!{mdnode_id2} = !DIDerivedType(.*name: "_float64", size: 64, tag: DW_TAG_member)'  # noqa: E501
+        match = re.compile(pat5).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+        pat6 = rf'!{mdnode_id3} = !DIDerivedType(.*name: "_int64", size: 64, tag: DW_TAG_member)'  # noqa: E501
+        match = re.compile(pat6).search(llvm_ir)
+        self.assertIsNotNone(match, msg=llvm_ir)
+
 
 if __name__ == "__main__":
     unittest.main()

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

@@ -1,9 +1,26 @@
+from numba.cuda.cudadrv.driver import CudaAPIError
 import numpy as np
 import threading
 
-from numba import boolean, config, cuda, float32, float64, int32, int64, void
+from numba import (
+    boolean,
+    config,
+    cuda,
+    float32,
+    float64,
+    int32,
+    int64,
+    types,
+    uint32,
+    void,
+)
 from numba.core.errors import TypingError
-from numba.cuda.testing import skip_on_cudasim, unittest, CUDATestCase
+from numba.cuda.testing import (
+    cc_X_or_above,
+    skip_on_cudasim,
+    unittest,
+    CUDATestCase,
+)
 import math
 
 
@@ -466,6 +483,35 @@ class TestDispatcher(CUDATestCase):
         self.assertEqual("Add two integers, kernel version", add_kernel.__doc__)
         self.assertEqual("Add two integers, device version", add_device.__doc__)
 
+    @skip_on_cudasim("Cudasim does not have device pointers")
+    def test_dispatcher_cpointer_arguments(self):
+        ptr = types.CPointer(types.int32)
+        sig = void(ptr, int32, ptr, ptr, uint32)
+
+        @cuda.jit(sig)
+        def axpy(r, a, x, y, n):
+            i = cuda.grid(1)
+            if i < n:
+                r[i] = a * x[i] + y[i]
+
+        N = 16
+        a = 5
+        hx = np.arange(10, dtype=np.int32)
+        hy = np.arange(10, dtype=np.int32) * 2
+        dx = cuda.to_device(hx)
+        dy = cuda.to_device(hy)
+        dr = cuda.device_array_like(dx)
+
+        r_ptr = dr.__cuda_array_interface__["data"][0]
+        x_ptr = dx.__cuda_array_interface__["data"][0]
+        y_ptr = dy.__cuda_array_interface__["data"][0]
+
+        axpy[1, 32](r_ptr, a, x_ptr, y_ptr, N)
+
+        expected = a * hx + hy
+        actual = dr.copy_to_host()
+        np.testing.assert_equal(expected, actual)
+
 
 @skip_on_cudasim("CUDA simulator doesn't implement kernel properties")
 class TestDispatcherKernelProperties(CUDATestCase):
@@ -708,5 +754,63 @@ class TestDispatcherKernelProperties(CUDATestCase):
         self.assertGreaterEqual(local_mem_per_thread, N * 4)
 
 
+@skip_on_cudasim("Simulator does not support launch bounds")
+class TestLaunchBounds(CUDATestCase):
+    def _test_launch_bounds_common(self, launch_bounds):
+        @cuda.jit(launch_bounds=launch_bounds)
+        def f():
+            pass
+
+        # Test successful launch
+        f[1, 128]()
+
+        # Test launch bound exceeded
+        msg = "Call to cuLaunchKernel results in CUDA_ERROR_INVALID_VALUE"
+        with self.assertRaisesRegex(CudaAPIError, msg):
+            f[1, 256]()
+
+        sig = f.signatures[0]
+        ptx = f.inspect_asm(sig)
+        self.assertRegex(ptx, r".maxntid\s+128,\s+1,\s+1")
+
+        return ptx
+
+    def test_launch_bounds_scalar(self):
+        launch_bounds = 128
+        ptx = self._test_launch_bounds_common(launch_bounds)
+
+        self.assertNotIn(".minnctapersm", ptx)
+        self.assertNotIn(".maxclusterrank", ptx)
+
+    def test_launch_bounds_tuple(self):
+        launch_bounds = (128,)
+        ptx = self._test_launch_bounds_common(launch_bounds)
+
+        self.assertNotIn(".minnctapersm", ptx)
+        self.assertNotIn(".maxclusterrank", ptx)
+
+    def test_launch_bounds_with_min_cta(self):
+        launch_bounds = (128, 2)
+        ptx = self._test_launch_bounds_common(launch_bounds)
+
+        self.assertRegex(ptx, r".minnctapersm\s+2")
+        self.assertNotIn(".maxclusterrank", ptx)
+
+    @unittest.skipUnless(
+        cc_X_or_above(9, 0), "CC 9.0 needed for max cluster rank"
+    )
+    def test_launch_bounds_with_max_cluster_rank(self):
+        launch_bounds = (128, 2, 4)
+        ptx = self._test_launch_bounds_common(launch_bounds)
+
+        self.assertRegex(ptx, r".minnctapersm\s+2")
+        self.assertRegex(ptx, r".maxclusterrank\s+4")
+
+    def test_too_many_launch_bounds(self):
+        launch_bounds = (128, 2, 4, 8)
+        with self.assertRaisesRegex(ValueError, "Got 4 launch bounds:"):
+            cuda.jit("void()", launch_bounds=launch_bounds)(lambda: None)
+
+
 if __name__ == "__main__":
     unittest.main()

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

@@ -118,31 +118,18 @@ class TestFastMathOption(CUDATestCase):
         def tanh_kernel(r, x):
             r[0] = tanh(x)
 
-        def tanh_common_test(cc, criterion):
-            fastptx, _ = compile_ptx(
-                tanh_kernel, (float32[::1], float32), fastmath=True, cc=cc
-            )
-            precptx, _ = compile_ptx(
-                tanh_kernel, (float32[::1], float32), cc=cc
-            )
-            criterion.check(self, fastptx, precptx)
-
-        tanh_common_test(
-            cc=(7, 5),
-            criterion=FastMathCriterion(
-                fast_expected=["tanh.approx.f32 "],
-                prec_unexpected=["tanh.approx.f32 "],
-            ),
+        fastptx, _ = compile_ptx(
+            tanh_kernel, (float32[::1], float32), fastmath=True
         )
+        precptx, _ = compile_ptx(tanh_kernel, (float32[::1], float32))
 
-        tanh_common_test(
-            cc=(7, 0),
-            criterion=FastMathCriterion(
-                fast_expected=["ex2.approx.ftz.f32 ", "rcp.approx.ftz.f32 "],
-                prec_unexpected=["tanh.approx.f32 "],
-            ),
+        criterion = FastMathCriterion(
+            fast_expected=["tanh.approx.f32 "],
+            prec_unexpected=["tanh.approx.f32 "],
         )
 
+        criterion.check(self, fastptx, precptx)
+
     def test_expf(self):
         self._test_fast_math_unary(
             exp,

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

@@ -16,6 +16,14 @@ class TestInspect(CUDATestCase):
     def cc(self):
         return cuda.current_context().device.compute_capability
 
+    def skip_on_cuda_version_issues(self):
+        # FIXME: This should be unskipped once the cause of certain nvdisasm
+        # versions failing to dump SASS with certain driver / nvJitLink
+        # versions is understood
+        self.skipTest(
+            "Relocation information required for analysis not preserved"
+        )
+
     def test_monotyped(self):
         sig = (float32, int32)
 
@@ -110,6 +118,8 @@ class TestInspect(CUDATestCase):
 
     @skip_without_nvdisasm("nvdisasm needed for inspect_sass()")
     def test_inspect_sass_eager(self):
+        self.skip_on_cuda_version_issues()
+
         sig = (float32[::1], int32[::1])
 
         @cuda.jit(sig, lineinfo=True)
@@ -122,6 +132,8 @@ class TestInspect(CUDATestCase):
 
     @skip_without_nvdisasm("nvdisasm needed for inspect_sass()")
     def test_inspect_sass_lazy(self):
+        self.skip_on_cuda_version_issues()
+
         @cuda.jit(lineinfo=True)
         def add(x, y):
             i = cuda.grid(1)
@@ -139,6 +151,8 @@ class TestInspect(CUDATestCase):
         "Missing nvdisasm exception only generated when it is not present"
     )
     def test_inspect_sass_nvdisasm_missing(self):
+        self.skip_on_cuda_version_issues()
+
         @cuda.jit((float32[::1],))
         def f(x):
             x[0] = 0
@@ -150,6 +164,8 @@ class TestInspect(CUDATestCase):
 
     @skip_without_nvdisasm("nvdisasm needed for inspect_sass_cfg()")
     def test_inspect_sass_cfg(self):
+        self.skip_on_cuda_version_issues()
+
         sig = (float32[::1], int32[::1])
 
         @cuda.jit(sig)

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

@@ -641,7 +641,7 @@ class TestCudaIntrinsic(CUDATestCase):
     @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_hadd_ptx(self):
         args = (f2[:], f2, f2)
-        ptx, _ = compile_ptx(simple_hadd_scalar, args, cc=(5, 3))
+        ptx, _ = compile_ptx(simple_hadd_scalar, args)
         self.assertIn("add.f16", ptx)
 
     @skip_unless_cc_53
@@ -668,7 +668,7 @@ class TestCudaIntrinsic(CUDATestCase):
     @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_hfma_ptx(self):
         args = (f2[:], f2, f2, f2)
-        ptx, _ = compile_ptx(simple_hfma_scalar, args, cc=(5, 3))
+        ptx, _ = compile_ptx(simple_hfma_scalar, args)
         self.assertIn("fma.rn.f16", ptx)
 
     @skip_unless_cc_53
@@ -693,7 +693,7 @@ class TestCudaIntrinsic(CUDATestCase):
     @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_hsub_ptx(self):
         args = (f2[:], f2, f2)
-        ptx, _ = compile_ptx(simple_hsub_scalar, args, cc=(5, 3))
+        ptx, _ = compile_ptx(simple_hsub_scalar, args)
         self.assertIn("sub.f16", ptx)
 
     @skip_unless_cc_53
@@ -718,7 +718,7 @@ class TestCudaIntrinsic(CUDATestCase):
     @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_hmul_ptx(self):
         args = (f2[:], f2, f2)
-        ptx, _ = compile_ptx(simple_hmul_scalar, args, cc=(5, 3))
+        ptx, _ = compile_ptx(simple_hmul_scalar, args)
         self.assertIn("mul.f16", ptx)
 
     @skip_unless_cc_53
@@ -763,7 +763,7 @@ class TestCudaIntrinsic(CUDATestCase):
     @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_hneg_ptx(self):
         args = (f2[:], f2)
-        ptx, _ = compile_ptx(simple_hneg_scalar, args, cc=(5, 3))
+        ptx, _ = compile_ptx(simple_hneg_scalar, args)
         self.assertIn("neg.f16", ptx)
 
     @skip_unless_cc_53
@@ -786,7 +786,7 @@ class TestCudaIntrinsic(CUDATestCase):
     @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_habs_ptx(self):
         args = (f2[:], f2)
-        ptx, _ = compile_ptx(simple_habs_scalar, args, cc=(5, 3))
+        ptx, _ = compile_ptx(simple_habs_scalar, args)
         self.assertIn("abs.f16", ptx)
 
     @skip_unless_cc_53

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

@@ -178,7 +178,7 @@ class TestOperatorModule(CUDATestCase):
         args = (f2[:], f2, f2)
         for fn, instr in zip(functions, instrs):
             with self.subTest(instr=instr):
-                ptx, _ = compile_ptx(fn, args, cc=(5, 3))
+                ptx, _ = compile_ptx(fn, args)
                 self.assertIn(instr, ptx)
 
     @skip_unless_cc_53
@@ -212,7 +212,7 @@ class TestOperatorModule(CUDATestCase):
 
         for fn, instr in zip(functions, instrs):
             with self.subTest(instr=instr):
-                ptx, _ = compile_ptx(fn, args, cc=(5, 3))
+                ptx, _ = compile_ptx(fn, args)
                 self.assertIn(instr, ptx)
 
     @skip_unless_cc_53
@@ -255,13 +255,13 @@ class TestOperatorModule(CUDATestCase):
     @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_fp16_neg_ptx(self):
         args = (f2[:], f2)
-        ptx, _ = compile_ptx(simple_fp16neg, args, cc=(5, 3))
+        ptx, _ = compile_ptx(simple_fp16neg, args)
         self.assertIn("neg.f16", ptx)
 
     @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_fp16_abs_ptx(self):
         args = (f2[:], f2)
-        ptx, _ = compile_ptx(simple_fp16abs, args, cc=(5, 3))
+        ptx, _ = compile_ptx(simple_fp16abs, args)
 
         self.assertIn("abs.f16", ptx)
 
@@ -396,7 +396,7 @@ class TestOperatorModule(CUDATestCase):
 
         for fn, op, s in zip(functions, ops, opstring):
             with self.subTest(op=op):
-                ptx, _ = compile_ptx(fn, args, cc=(5, 3))
+                ptx, _ = compile_ptx(fn, args)
                 self.assertIn(s, ptx)
 
     @skip_on_cudasim("Compilation unsupported in the simulator")
@@ -431,7 +431,7 @@ class TestOperatorModule(CUDATestCase):
         for fn, op in zip(functions, ops):
             with self.subTest(op=op):
                 args = (b1[:], f2, from_dtype(np.int8))
-                ptx, _ = compile_ptx(fn, args, cc=(5, 3))
+                ptx, _ = compile_ptx(fn, args)
                 self.assertIn(opstring[op], ptx)
 
     @skip_on_cudasim("Compilation unsupported in the simulator")
@@ -475,7 +475,7 @@ class TestOperatorModule(CUDATestCase):
             with self.subTest(op=op, ty=ty):
                 arg2_ty = np.result_type(np.float16, ty)
                 args = (b1[:], f2, from_dtype(arg2_ty))
-                ptx, _ = compile_ptx(fn, args, cc=(5, 3))
+                ptx, _ = compile_ptx(fn, args)
 
                 ops = opstring[op] + opsuffix[arg2_ty]
                 self.assertIn(ops, ptx)

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

@@ -0,0 +1,64 @@
+import unittest
+
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
+from numba.tests.support import captured_stdout
+
+
+@skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
+class TestCPointer(CUDATestCase):
+    """
+    Test simple vector addition
+    """
+
+    def setUp(self):
+        # Prevent output from this test showing
+        # up when running the test suite
+        self._captured_stdout = captured_stdout()
+        self._captured_stdout.__enter__()
+        super().setUp()
+
+    def tearDown(self):
+        # No exception type, value, or traceback
+        self._captured_stdout.__exit__(None, None, None)
+        super().tearDown()
+
+    def test_ex_cpointer(self):
+        # ex_cpointer.sig.begin
+        import numpy as np
+        from numba import cuda, types
+
+        # The first kernel argument is a pointer to a uint8 array.
+        # The second argument holds the length as a uint32.
+        # The return type of a kernel is always void.
+        sig = types.void(types.CPointer(types.uint8), types.uint32)
+        # ex_cpointer.sig.end
+
+        # ex_cpointer.kernel.begin
+        @cuda.jit(sig)
+        def add_one(x, n):
+            i = cuda.grid(1)
+            if i < n:
+                x[i] += 1
+
+        # ex_cpointer.kernel.end
+
+        # ex_cpointer.launch.begin
+        x = cuda.to_device(np.arange(10, dtype=np.uint8))
+
+        # Print initial values of x
+        print(x.copy_to_host())  # [0 1 2 3 4 5 6 7 8 9]
+
+        # Obtain a pointer to the data from from the CUDA Array Interface
+        x_ptr = x.__cuda_array_interface__["data"][0]
+        x_len = len(x)
+
+        # Launch the kernel with the pointer and length
+        add_one[1, 32](x_ptr, x_len)
+
+        # Demonstrate that the data was updated by the kernel
+        print(x.copy_to_host())  # [ 1  2  3  4  5  6  7  8  9 10]
+        # ex_cpointer.launch.end
+
+
+if __name__ == "__main__":
+    unittest.main()

numba_cuda/numba/cuda/tests/test_binary_generation/generate_raw_ltoir.py

@@ -6,7 +6,7 @@ import platform
 import subprocess
 import sys
 
-from cuda import nvrtc
+from cuda.bindings import nvrtc
 from numba.cuda.memory_management.nrt import get_include
 
 # Magic number found at the start of an LTO-IR file

{numba_cuda-0.13.0.dist-info → numba_cuda-0.14.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numba-cuda
-Version: 0.13.0
+Version: 0.14.1
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -12,6 +12,28 @@ Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numba>=0.59.1
+Provides-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-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-cuda-cccl-cu12; extra == "cu12"
+Provides-Extra: test
+Requires-Dist: psutil; extra == "test"
+Requires-Dist: cffi; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Provides-Extra: test-cu11
+Requires-Dist: numba-cuda[test]; extra == "test-cu11"
+Requires-Dist: nvidia-curand-cu11; extra == "test-cu11"
+Provides-Extra: test-cu12
+Requires-Dist: numba-cuda[test]; extra == "test-cu12"
+Requires-Dist: nvidia-curand-cu12; extra == "test-cu12"
+Requires-Dist: pynvjitlink-cu12; extra == "test-cu12"
 Dynamic: license-file
 
 <div align="center"><img src="docs/source/_static/numba-green-icon-rgb.svg" width="200"/></div>