numba-cuda 0.12.1__py3-none-any.whl → 0.14.0__py3-none-any.whl

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_enums.py

@@ -116,6 +116,7 @@ class EnumTest(CUDATestCase):
         got = cuda_func(arr)
         self.assertPreciseEqual(expected, got)
 
+    @skip_on_cudasim("No typing context in CUDA simulator")
     def test_int_enum_no_conversion(self):
         # Ported from Numba PR #10047: "Fix IntEnumMember.can_convert_to() when
         # no conversions found", https://github.com/numba/numba/pull/10047.

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

@@ -191,7 +191,9 @@ if TEST_BIN_DIR:
     )
 
 
+@skip_on_cudasim("Extensions not supported in the simulator")
 class TestExtendingLinkage(CUDATestCase):
+    @unittest.skipUnless(TEST_BIN_DIR, "Necessary binaries are not available")
     def test_extension_adds_linkable_code(self):
         cuda_major_version = cuda.runtime.get_version()[0]
 

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_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/nrt/test_nrt.py

@@ -3,16 +3,13 @@ import os
 
 import numpy as np
 import unittest
-from numba.cuda.testing import CUDATestCase
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
 from numba.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 types
-from numba.cuda.cudadecl import registry as cuda_decl_registry
+from numba import config, types
 from numba.core.typing import signature
-from numba.cuda.cudaimpl import lower as cuda_lower
 from numba import cuda
-from numba.cuda.runtime.nrt import rtsys, get_include
 from numba.core.typing.templates import AbstractTemplate
 from numba.cuda.cudadrv.linkable_code import (
     CUSource,
@@ -23,67 +20,68 @@ from numba.cuda.cudadrv.linkable_code import (
     Object,
 )
 
-
 TEST_BIN_DIR = os.getenv("NUMBA_CUDA_TEST_BIN_DIR")
 
-if TEST_BIN_DIR:
-
-    def make_linkable_code(name, kind, mode):
-        path = os.path.join(TEST_BIN_DIR, name)
-        with open(path, mode) as f:
-            contents = f.read()
-        return kind(contents, nrt=True)
-
-    nrt_extern_a = make_linkable_code("nrt_extern.a", Archive, "rb")
-    nrt_extern_cubin = make_linkable_code("nrt_extern.cubin", Cubin, "rb")
-    nrt_extern_cu = make_linkable_code(
-        "nrt_extern.cu",
-        CUSource,
-        "rb",
-    )
-    nrt_extern_fatbin = make_linkable_code("nrt_extern.fatbin", Fatbin, "rb")
-    nrt_extern_fatbin_multi = make_linkable_code(
-        "nrt_extern_multi.fatbin", Fatbin, "rb"
-    )
-    nrt_extern_o = make_linkable_code("nrt_extern.o", Object, "rb")
-    nrt_extern_ptx = make_linkable_code("nrt_extern.ptx", PTXSource, "rb")
+if not config.ENABLE_CUDASIM:
+    from numba.cuda.memory_management.nrt import rtsys, get_include
+    from numba.cuda.cudadecl import registry as cuda_decl_registry
+    from numba.cuda.cudaimpl import lower as cuda_lower
 
+    def allocate_deallocate_handle():
+        """
+        Handle to call NRT_Allocate and NRT_Free
+        """
+        pass
 
-def allocate_deallocate_handle():
-    """
-    Handle to call NRT_Allocate and NRT_Free
-    """
-    pass
-
-
-@cuda_decl_registry.register_global(allocate_deallocate_handle)
-class AllocateShimImpl(AbstractTemplate):
-    def generic(self, args, kws):
-        return signature(types.void)
-
+    @cuda_decl_registry.register_global(allocate_deallocate_handle)
+    class AllocateShimImpl(AbstractTemplate):
+        def generic(self, args, kws):
+            return signature(types.void)
 
-device_fun_shim = cuda.declare_device(
-    "device_allocate_deallocate", types.int32()
-)
+    device_fun_shim = cuda.declare_device(
+        "device_allocate_deallocate", types.int32()
+    )
 
+    # wrapper to turn the above into a python callable
+    def call_device_fun_shim():
+        return device_fun_shim()
+
+    @cuda_lower(allocate_deallocate_handle)
+    def allocate_deallocate_impl(context, builder, sig, args):
+        sig_ = types.int32()
+        # call the external function, passing the pointer
+        result = context.compile_internal(
+            builder,
+            call_device_fun_shim,
+            sig_,
+            (),
+        )
 
-# wrapper to turn the above into a python callable
-def call_device_fun_shim():
-    return device_fun_shim()
+        return result
 
+    if TEST_BIN_DIR:
 
-@cuda_lower(allocate_deallocate_handle)
-def allocate_deallocate_impl(context, builder, sig, args):
-    sig_ = types.int32()
-    # call the external function, passing the pointer
-    result = context.compile_internal(
-        builder,
-        call_device_fun_shim,
-        sig_,
-        (),
-    )
+        def make_linkable_code(name, kind, mode):
+            path = os.path.join(TEST_BIN_DIR, name)
+            with open(path, mode) as f:
+                contents = f.read()
+            return kind(contents, nrt=True)
 
-    return result
+        nrt_extern_a = make_linkable_code("nrt_extern.a", Archive, "rb")
+        nrt_extern_cubin = make_linkable_code("nrt_extern.cubin", Cubin, "rb")
+        nrt_extern_cu = make_linkable_code(
+            "nrt_extern.cu",
+            CUSource,
+            "rb",
+        )
+        nrt_extern_fatbin = make_linkable_code(
+            "nrt_extern.fatbin", Fatbin, "rb"
+        )
+        nrt_extern_fatbin_multi = make_linkable_code(
+            "nrt_extern_multi.fatbin", Fatbin, "rb"
+        )
+        nrt_extern_o = make_linkable_code("nrt_extern.o", Object, "rb")
+        nrt_extern_ptx = make_linkable_code("nrt_extern.ptx", PTXSource, "rb")
 
 
 class TestNrtBasic(CUDATestCase):
@@ -104,6 +102,7 @@ class TestNrtBasic(CUDATestCase):
         g[1, 1]()
         cuda.synchronize()
 
+    @skip_on_cudasim("CUDA Simulator does not produce PTX")
     def test_nrt_ptx_contains_refcount(self):
         @cuda.jit
         def f(x):
@@ -157,6 +156,7 @@ class TestNrtLinking(CUDATestCase):
         with override_config("CUDA_ENABLE_NRT", True):
             super(TestNrtLinking, self).run(result)
 
+    @skip_on_cudasim("CUDA Simulator does not link PTX")
     def test_nrt_detect_linked_ptx_file(self):
         src = f"#include <{get_include()}/nrt.cuh>"
         src += """
@@ -176,6 +176,7 @@ class TestNrtLinking(CUDATestCase):
         kernel[1, 1]()
 
     @unittest.skipIf(not TEST_BIN_DIR, "necessary binaries not generated.")
+    @skip_on_cudasim("CUDA Simulator does not link code")
     def test_nrt_detect_linkable_code(self):
         codes = (
             nrt_extern_a,
@@ -196,6 +197,7 @@ class TestNrtLinking(CUDATestCase):
                 kernel[1, 1]()
 
 
+@skip_on_cudasim("CUDASIM does not have NRT statistics")
 class TestNrtStatistics(CUDATestCase):
     def setUp(self):
         self._stream = cuda.default_stream()
@@ -213,7 +215,7 @@ class TestNrtStatistics(CUDATestCase):
         # Checks that explicitly turning the stats on via the env var works.
         src = """if 1:
         from numba import cuda
-        from numba.cuda.runtime import rtsys
+        from numba.cuda.memory_management import rtsys
         import numpy as np
 
         @cuda.jit
@@ -252,7 +254,7 @@ class TestNrtStatistics(CUDATestCase):
         src = """if 1:
         from numba import cuda
         import numpy as np
-        from numba.cuda.runtime import rtsys
+        from numba.cuda.memory_management import rtsys
 
         @cuda.jit
         def foo():

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

@@ -1,13 +1,14 @@
 import numpy as np
 import unittest
 from numba.tests.support import override_config
-from numba.cuda.runtime import rtsys
+from numba.cuda.memory_management import rtsys
 from numba.cuda.tests.support import EnableNRTStatsMixin
-from numba.cuda.testing import CUDATestCase
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
 
 from numba import cuda
 
 
+@skip_on_cudasim("No refcounting in the simulator")
 class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
     def setUp(self):
         super(TestNrtRefCt, self).setUp()

numba_cuda/numba/cuda/tests/support.py

@@ -1,4 +1,4 @@
-from numba.cuda.runtime.nrt import rtsys
+from numba.cuda.memory_management.nrt import rtsys
 
 
 class EnableNRTStatsMixin(object):

numba_cuda/numba/cuda/tests/test_binary_generation/Makefile

@@ -40,7 +40,7 @@ LTOIR_FLAGS := $(LTOIR_GENCODE) -dc
 
 OUTPUT_DIR := ./
 
-NRT_INCLUDE_DIR := $(shell python -c "from numba.cuda.runtime.nrt import get_include; print(get_include())")
+NRT_INCLUDE_DIR := $(shell python -c "from numba.cuda.memory_management.nrt import get_include; print(get_include())")
 
 all:
 	@echo "GPU CC: $(GPU_CC)"

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

@@ -7,7 +7,7 @@ import subprocess
 import sys
 
 from cuda import nvrtc
-from numba.cuda.runtime.nrt import get_include
+from numba.cuda.memory_management.nrt import get_include
 
 # Magic number found at the start of an LTO-IR file
 LTOIR_MAGIC = 0x7F4E43ED

{numba_cuda-0.12.1.dist-info → numba_cuda-0.14.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numba-cuda
-Version: 0.12.1
+Version: 0.14.0
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -12,6 +12,27 @@ 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"
+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>