numba-cuda 0.12.1__tar.gz → 0.13.0__tar.gz

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: numba-cuda
-Version: 0.12.1
+Version: 0.13.0
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause

numba_cuda-0.13.0/numba_cuda/VERSION

@@ -0,0 +1 @@
+0.13.0

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/codegen.py

@@ -5,7 +5,7 @@ from numba.core.codegen import Codegen, CodeLibrary
 from .cudadrv import devices, driver, nvvm, runtime
 from numba.cuda.cudadrv.libs import get_cudalib
 from numba.cuda.cudadrv.linkable_code import LinkableCode
-from numba.cuda.runtime.nrt import NRT_LIBRARY
+from numba.cuda.memory_management.nrt import NRT_LIBRARY
 
 import os
 import subprocess

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/cudadrv/nvrtc.py

@@ -397,7 +397,7 @@ def compile(src, name, cc, ltoir=False):
     else:
         extra_includes = []
 
-    nrt_path = os.path.join(numba_cuda_path, "runtime")
+    nrt_path = os.path.join(numba_cuda_path, "memory_management")
     nrt_include = f"-I{nrt_path}"
 
     options = [

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/dispatcher.py

@@ -27,8 +27,8 @@ from numba.cuda.errors import (
     normalize_kernel_dimensions,
 )
 from numba.cuda import types as cuda_types
-from numba.cuda.runtime.nrt import rtsys, NRT_LIBRARY
 from numba.cuda.locks import module_init_lock
+from numba.cuda.memory_management.nrt import rtsys, NRT_LIBRARY
 
 from numba import cuda
 from numba import _dispatcher

numba_cuda-0.13.0/numba_cuda/numba/cuda/memory_management/__init__.py

@@ -0,0 +1 @@
+from numba.cuda.memory_management.nrt import rtsys  # noqa: F401

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/simulator/__init__.py

@@ -38,11 +38,20 @@ if config.ENABLE_CUDASIM:
     sys.modules["numba.cuda.cudadrv.devicearray"] = cudadrv.devicearray
     sys.modules["numba.cuda.cudadrv.devices"] = cudadrv.devices
     sys.modules["numba.cuda.cudadrv.driver"] = cudadrv.driver
+    sys.modules["numba.cuda.cudadrv.linkable_code"] = cudadrv.linkable_code
     sys.modules["numba.cuda.cudadrv.runtime"] = cudadrv.runtime
     sys.modules["numba.cuda.cudadrv.drvapi"] = cudadrv.drvapi
     sys.modules["numba.cuda.cudadrv.error"] = cudadrv.error
     sys.modules["numba.cuda.cudadrv.nvvm"] = cudadrv.nvvm
 
-    from . import compiler
+    from . import bf16, compiler, _internal
 
+    sys.modules["numba.cuda.bf16"] = bf16
     sys.modules["numba.cuda.compiler"] = compiler
+    sys.modules["numba.cuda._internal"] = _internal
+    sys.modules["numba.cuda._internal.cuda_bf16"] = _internal.cuda_bf16
+
+    from numba.cuda.simulator import memory_management
+
+    sys.modules["numba.cuda.memory_management"] = memory_management
+    sys.modules["numba.cuda.memory_management.nrt"] = memory_management.nrt

numba_cuda-0.13.0/numba_cuda/numba/cuda/simulator/_internal/__init__.py

@@ -0,0 +1 @@
+from numba.cuda.simulator._internal import cuda_bf16  # noqa: F401

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/simulator/api.py

@@ -7,6 +7,15 @@ Contains CUDA API functions
 from contextlib import contextmanager
 
 from .cudadrv.devices import require_context, reset, gpus  # noqa: F401
+from .cudadrv.linkable_code import (
+    PTXSource,  # noqa: F401
+    CUSource,  # noqa: F401
+    Cubin,  # noqa: F401
+    Fatbin,  # noqa: F401
+    Archive,  # noqa: F401
+    Object,  # noqa: F401
+    LTOIR,  # noqa: F401
+)  # noqa: F401
 from .kernel import FakeCUDAKernel
 from numba.core.sigutils import is_signature
 from numba.core import config
@@ -22,6 +31,10 @@ def is_float16_supported():
     return True
 
 
+def is_bfloat16_supported():
+    return False
+
+
 class stream(object):
     """
     The stream API is supported in the simulator - however, all execution
@@ -72,6 +85,10 @@ def list_devices():
     return gpus
 
 
+def get_current_device():
+    return gpus[0].device
+
+
 # Events
 
 

numba_cuda-0.13.0/numba_cuda/numba/cuda/simulator/bf16.py

@@ -0,0 +1 @@
+bfloat16 = None

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/simulator/compiler.py

@@ -7,3 +7,4 @@ compile = None
 compile_for_current_device = None
 compile_ptx = None
 compile_ptx_for_current_device = None
+declare_device_function = None

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/simulator/cudadrv/driver.py

@@ -3,6 +3,8 @@ Most of the driver API is unsupported in the simulator, but some stubs are
 provided to allow tests to import correctly.
 """
 
+from numba import config
+
 
 def device_memset(dst, val, size, stream=0):
     dst.view("u1")[:size].fill(bytes([val])[0])
@@ -60,3 +62,8 @@ def launch_kernel(*args, **kwargs):
 
 
 USE_NV_BINDING = False
+
+PyNvJitLinker = None
+
+if config.ENABLE_CUDASIM:
+    config.CUDA_ENABLE_PYNVJITLINK = False

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/simulator/cudadrv/libs.py

@@ -1,2 +1,6 @@
 def check_static_lib(lib):
     raise FileNotFoundError("Linking libraries not supported by cudasim")
+
+
+def get_cuda_include_dir():
+    raise FileNotFoundError("CUDA includes not supported by cudasim")

numba_cuda-0.13.0/numba_cuda/numba/cuda/simulator/cudadrv/linkable_code.py

@@ -0,0 +1,57 @@
+class LinkableCode:
+    """An object that holds code to be linked from memory.
+
+    :param data: A buffer containing the data to link.
+    :param name: The name of the file to be referenced in any compilation or
+                 linking errors that may be produced.
+    """
+
+    def __init__(self, data, name=None):
+        self.data = data
+        self._name = name
+
+    @property
+    def name(self):
+        return self._name or self.default_name
+
+
+class PTXSource(LinkableCode):
+    """PTX source code in memory."""
+
+    default_name = "<unnamed-ptx>"
+
+
+class CUSource(LinkableCode):
+    """CUDA C/C++ source code in memory."""
+
+    default_name = "<unnamed-cu>"
+
+
+class Fatbin(LinkableCode):
+    """An ELF Fatbin in memory."""
+
+    default_name = "<unnamed-fatbin>"
+
+
+class Cubin(LinkableCode):
+    """An ELF Cubin in memory."""
+
+    default_name = "<unnamed-cubin>"
+
+
+class Archive(LinkableCode):
+    """An archive of objects in memory."""
+
+    default_name = "<unnamed-archive>"
+
+
+class Object(LinkableCode):
+    """An object file in memory."""
+
+    default_name = "<unnamed-object>"
+
+
+class LTOIR(LinkableCode):
+    """An LTOIR file in memory."""
+
+    default_name = "<unnamed-ltoir>"

numba_cuda-0.13.0/numba_cuda/numba/cuda/simulator/cudadrv/nvrtc.py

@@ -0,0 +1,8 @@
+"""
+NVVM is not supported in the simulator, but stubs are provided to allow tests
+to import correctly.
+"""
+
+
+def compile(src, name, cc, ltoir=False):
+    raise RuntimeError("NVRTC is not supported in the simulator")

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/simulator/kernel.py

@@ -78,7 +78,7 @@ class FakeCUDAKernel(object):
         functools.update_wrapper(self, fn)
 
     def __call__(self, *args):
-        if self._device:
+        if self._device or _kernel_context:
             with swapped_cuda_module(self.fn, _get_kernel_context()):
                 return self.fn(*args)
 

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/simulator/kernelapi.py

@@ -63,7 +63,10 @@ class FakeCUDALocal(object):
     CUDA Local arrays
     """
 
-    def array(self, shape, dtype):
+    def array(self, shape, dtype, alignment=None):
+        if alignment is not None:
+            raise RuntimeError("Array alignment is not supported in cudasim")
+
         if isinstance(dtype, types.Type):
             dtype = numpy_support.as_dtype(dtype)
         return np.empty(shape, dtype)
@@ -102,7 +105,10 @@ class FakeCUDAShared(object):
         self._dynshared_size = dynshared_size
         self._dynshared = np.zeros(dynshared_size, dtype=np.byte)
 
-    def array(self, shape, dtype):
+    def array(self, shape, dtype, alignment=None):
+        if alignment is not None:
+            raise RuntimeError("Array alignment is not supported in cudasim")
+
         if isinstance(dtype, types.Type):
             dtype = numpy_support.as_dtype(dtype)
         # Dynamic shared memory is requested with size 0 - this all shares the

numba_cuda-0.13.0/numba_cuda/numba/cuda/simulator/memory_management/__init__.py

@@ -0,0 +1 @@
+from .nrt import rtsys  # noqa: F401

numba_cuda-0.13.0/numba_cuda/numba/cuda/simulator/memory_management/nrt.py

@@ -0,0 +1,6 @@
+from numba import config
+
+rtsys = None
+
+config.CUDA_NRT_STATS = False
+config.CUDA_ENABLE_NRT = False

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/testing.py

@@ -116,20 +116,26 @@ def skip_on_arm(reason):
 def skip_if_cuda_includes_missing(fn):
     # Skip when cuda.h is not available - generally this should indicate
     # whether the CUDA includes are available or not
-    cuda_include_path = libs.get_cuda_include_dir()
+    reason = "CUDA include dir not available on this system"
+    try:
+        cuda_include_path = libs.get_cuda_include_dir()
+    except FileNotFoundError:
+        return unittest.skip(reason)(fn)
     cuda_h = os.path.join(cuda_include_path, "cuda.h")
     cuda_h_file = os.path.exists(cuda_h) and os.path.isfile(cuda_h)
-    reason = "CUDA include dir not available on this system"
     return unittest.skipUnless(cuda_h_file, reason)(fn)
 
 
 def skip_if_curand_kernel_missing(fn):
-    cuda_include_path = libs.get_cuda_include_dir()
+    reason = "curand_kernel.h not available on this system"
+    try:
+        cuda_include_path = libs.get_cuda_include_dir()
+    except FileNotFoundError:
+        return unittest.skip(reason)(fn)
     curand_kernel_h = os.path.join(cuda_include_path, "curand_kernel.h")
     curand_kernel_h_file = os.path.exists(curand_kernel_h) and os.path.isfile(
         curand_kernel_h
     )
-    reason = "curand_kernel.h not available on this system"
     return unittest.skipUnless(curand_kernel_h_file, reason)(fn)
 
 

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/tests/cudadrv/test_cuda_ndarray.py

@@ -476,12 +476,14 @@ class TestArrayMethod(CUDATestCase):
             host_array, dev_array.copy_to_host().astype(dtype)
         )
 
+    @skip_on_cudasim("Simulator does not use __array__()")
     @unittest.skipUnless(IS_NUMPY_2, "NumPy 1.x does not pass copy kwarg")
     def test_np_array_copy_false(self):
         dev_array = cuda.to_device(np.asarray([1.0, 2.0, 3.0]))
         with self.assertRaisesRegex(ValueError, "`copy=False` is not"):
             np.array(dev_array, copy=False)
 
+    @skip_on_cudasim("Simulator does not use __array__()")
     @unittest.skipUnless(IS_NUMPY_2, "NumPy 1.x does not pass copy kwarg")
     def test_np_array_copy_true(self):
         dev_array = cuda.to_device(np.asarray([1.0, 2.0, 3.0]))

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/tests/cudadrv/test_module_callbacks.py

@@ -5,14 +5,19 @@ import numpy as np
 
 from numba import cuda, config
 from numba.cuda.cudadrv.linkable_code import CUSource
-from numba.cuda.testing import CUDATestCase, ContextResettingTestCase
+from numba.cuda.testing import (
+    CUDATestCase,
+    ContextResettingTestCase,
+    skip_on_cudasim,
+)
 
-from cuda.bindings.driver import cuModuleGetGlobal, cuMemcpyHtoD
+if not config.ENABLE_CUDASIM:
+    from cuda.bindings.driver import cuModuleGetGlobal, cuMemcpyHtoD
 
-if config.CUDA_USE_NVIDIA_BINDING:
-    from cuda.cuda import CUmodule as cu_module_type
-else:
-    from numba.cuda.cudadrv.drvapi import cu_module as cu_module_type
+    if config.CUDA_USE_NVIDIA_BINDING:
+        from cuda.cuda import CUmodule as cu_module_type
+    else:
+        from numba.cuda.cudadrv.drvapi import cu_module as cu_module_type
 
 
 def wipe_all_modules_in_context():
@@ -32,6 +37,7 @@ def get_hashable_handle_value(handle):
     return handle
 
 
+@skip_on_cudasim("Module loading not implemented in the simulator")
 class TestModuleCallbacksBasic(ContextResettingTestCase):
     def test_basic(self):
         counter = 0
@@ -136,6 +142,7 @@ class TestModuleCallbacksBasic(ContextResettingTestCase):
         self.assertEqual(len(teardown_seen), 2)
 
 
+@skip_on_cudasim("Module loading not implemented in the simulator")
 class TestModuleCallbacksAPICompleteness(CUDATestCase):
     def test_api(self):
         def setup(handle):
@@ -164,6 +171,7 @@ class TestModuleCallbacksAPICompleteness(CUDATestCase):
                 kernel[1, 1]()
 
 
+@skip_on_cudasim("Module loading not implemented in the simulator")
 class TestModuleCallbacks(CUDATestCase):
     def setUp(self):
         super().setUp()
@@ -213,6 +221,7 @@ __device__ int get_num(int &retval) {
         self.assertEqual(arr[0], 42)
 
 
+@skip_on_cudasim("Module loading not implemented in the simulator")
 class TestMultithreadedCallbacks(CUDATestCase):
     def test_concurrent_initialization(self):
         seen_mods = set()

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/tests/cudadrv/test_nvjitlink.py

@@ -267,6 +267,7 @@ class TestLinker(CUDATestCase):
     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.

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/tests/cudapy/test_array.py

@@ -310,9 +310,6 @@ class TestCudaArray(CUDATestCase):
             check(array_reshape, array_reshape1d, arr, 0)
             check(array_reshape, array_reshape1d, arr, (0,))
             check(array_reshape, array_reshape3d, arr, (1, 0, 2))
-            check_only_shape(array_reshape2d, arr, (0, -1), (0, 0))
-            check_only_shape(array_reshape2d, arr, (4, -1), (4, 0))
-            check_only_shape(array_reshape3d, arr, (-1, 0, 4), (0, 0, 4))
 
         # C-contiguous
         arr = np.arange(24)

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/tests/cudapy/test_array_alignment.py

@@ -3,7 +3,11 @@ import itertools
 import numpy as np
 from numba import cuda
 from numba.core.errors import TypingError
-from numba.cuda.testing import CUDATestCase
+from numba.cuda.testing import (
+    CUDATestCase,
+    skip_on_cudasim,
+    skip_unless_cudasim,
+)
 import unittest
 
 
@@ -65,6 +69,7 @@ for align in (True, False):
 #      with the test_alignment.TestArrayAlignment class.
 
 
+@skip_on_cudasim("Array alignment not supported on cudasim")
 class TestArrayAddressAlignment(CUDATestCase):
     """
     Test cuda.local.array and cuda.shared.array support for an alignment
@@ -232,5 +237,24 @@ class TestArrayAddressAlignment(CUDATestCase):
                     print(".", end="", flush=True)
 
 
+@skip_unless_cudasim("Only check for alignment unsupported in the simulator")
+class TestCudasimUnsupportedAlignment(CUDATestCase):
+    def test_local_unsupported(self):
+        @cuda.jit
+        def f():
+            cuda.local.array(1, dtype=np.uint8, alignment=16)
+
+        with self.assertRaisesRegex(RuntimeError, "not supported in cudasim"):
+            f[1, 1]()
+
+    def test_shared_unsupported(self):
+        @cuda.jit
+        def f():
+            cuda.shared.array(1, dtype=np.uint8, alignment=16)
+
+        with self.assertRaisesRegex(RuntimeError, "not supported in cudasim"):
+            f[1, 1]()
+
+
 if __name__ == "__main__":
     unittest.main()

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/tests/cudapy/test_bfloat16.py

@@ -23,6 +23,15 @@ class TestBfloat16HighLevelBindings(CUDATestCase):
 
     def test_math_bindings(self):
         self.skip_unsupported()
+
+        exp_functions = [math.exp]
+        try:
+            from math import exp2
+
+            exp_functions += [exp2]
+        except ImportError:
+            pass
+
         functions = [
             math.trunc,
             math.ceil,
@@ -33,9 +42,7 @@ class TestBfloat16HighLevelBindings(CUDATestCase):
             math.cos,
             math.sin,
             math.tanh,
-            math.exp,
-            math.exp2,
-        ]
+        ] + exp_functions
 
         for f in functions:
             with self.subTest(func=f):
@@ -49,7 +56,7 @@ class TestBfloat16HighLevelBindings(CUDATestCase):
                 arr = cuda.device_array((1,), dtype="float32")
                 kernel[1, 1](arr)
 
-                if f in (math.exp, math.exp2):
+                if f in exp_functions:
                     self.assertAlmostEqual(arr[0], f(3.14), delta=1e-1)
                 else:
                     self.assertAlmostEqual(arr[0], f(3.14), delta=1e-2)

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/tests/cudapy/test_bfloat16_bindings.py

@@ -2,29 +2,40 @@ import numba.cuda as cuda
 from numba.cuda.testing import unittest, CUDATestCase
 import numpy as np
 
-from numba import int16, int32, int64, uint16, uint32, uint64, float32, float64
+from numba import (
+    config,
+    int16,
+    int32,
+    int64,
+    uint16,
+    uint32,
+    uint64,
+    float32,
+    float64,
+)
 from numba.types import float16
 
-from numba.cuda._internal.cuda_bf16 import (
-    nv_bfloat16,
-    htrunc,
-    hceil,
-    hfloor,
-    hrint,
-    hsqrt,
-    hrsqrt,
-    hrcp,
-    hlog,
-    hlog2,
-    hlog10,
-    hcos,
-    hsin,
-    hexp,
-    hexp2,
-    hexp10,
-    htanh,
-    htanh_approx,
-)
+if not config.ENABLE_CUDASIM:
+    from numba.cuda._internal.cuda_bf16 import (
+        nv_bfloat16,
+        htrunc,
+        hceil,
+        hfloor,
+        hrint,
+        hsqrt,
+        hrsqrt,
+        hrcp,
+        hlog,
+        hlog2,
+        hlog10,
+        hcos,
+        hsin,
+        hexp,
+        hexp2,
+        hexp10,
+        htanh,
+        htanh_approx,
+    )
 
 dtypes = [int16, int32, int64, uint16, uint32, uint64, float32]
 
@@ -263,6 +274,8 @@ class Bfloat16Test(CUDATestCase):
         np.testing.assert_allclose(arr, [8], atol=1e-2)
 
     def test_use_binding_inside_dfunc(self):
+        self.skip_unsupported()
+
         @cuda.jit(device=True)
         def f(arr):
             pi = nv_bfloat16(3.14)

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/numba_cuda/numba/cuda/tests/cudapy/test_cooperative_groups.py

@@ -157,6 +157,7 @@ class TestCudaCooperativeGroups(CUDATestCase):
         self.assertEqual(blocks1d, blocks2d)
         self.assertEqual(blocks1d, blocks3d)
 
+    @skip_on_cudasim("External code unsupported on cudasim")
     @skip_unless_cc_60
     def test_external_cooperative_func(self):
         cudapy_test_path = os.path.dirname(__file__)
@@ -171,12 +172,13 @@ class TestCudaCooperativeGroups(CUDATestCase):
             "cta_barrier", sig=sig, link=[src], use_cooperative=True
         )
 
-        @cuda.jit
+        @cuda.jit("void()")
         def kernel():
             cta_barrier()
 
+        overload = kernel.overloads[()]
         block_size = 32
-        grid_size = 1024
+        grid_size = overload.max_cooperative_grid_blocks(block_size)
 
         kernel[grid_size, block_size]()
 

{numba_cuda-0.12.1 → numba_cuda-0.13.0}/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-0.12.1 → numba_cuda-0.13.0}/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]