numba-cuda 0.4.0__tar.gz → 0.5.0__tar.gz

{numba_cuda-0.4.0 → numba_cuda-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: numba-cuda
-Version: 0.4.0
+Version: 0.5.0
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -27,7 +27,19 @@ tracker](https://github.com/NVIDIA/numba-cuda/issues).
 To raise questions or initiate discussions, please use the [Numba Discourse
 forum](https://numba.discourse.group).
 
-## Building from source
+## Installation with pip
+
+```shell
+pip install numba-cuda
+```
+
+## Installation with Conda
+
+```shell
+conda install -c conda-forge numba-cuda
+```
+
+## Installation from source
 
 Install as an editable install:
 
@@ -53,3 +65,9 @@ which will show a path like:
 ```
 <path to numba-cuda repo>/numba_cuda/numba/cuda/__init__.py
 ```
+
+## Contributing Guide
+
+Review the
+[CONTRIBUTING.md](https://github.com/NVIDIA/numba-cuda/blob/main/CONTRIBUTING.md)
+file for information on how to contribute code and issues to the project.

{numba_cuda-0.4.0 → numba_cuda-0.5.0}/README.md

@@ -12,7 +12,19 @@ tracker](https://github.com/NVIDIA/numba-cuda/issues).
 To raise questions or initiate discussions, please use the [Numba Discourse
 forum](https://numba.discourse.group).
 
-## Building from source
+## Installation with pip
+
+```shell
+pip install numba-cuda
+```
+
+## Installation with Conda
+
+```shell
+conda install -c conda-forge numba-cuda
+```
+
+## Installation from source
 
 Install as an editable install:
 
@@ -38,3 +50,9 @@ which will show a path like:
 ```
 <path to numba-cuda repo>/numba_cuda/numba/cuda/__init__.py
 ```
+
+## Contributing Guide
+
+Review the
+[CONTRIBUTING.md](https://github.com/NVIDIA/numba-cuda/blob/main/CONTRIBUTING.md)
+file for information on how to contribute code and issues to the project.

numba_cuda-0.5.0/numba_cuda/VERSION

@@ -0,0 +1 @@
+0.5.0

{numba_cuda-0.4.0 → numba_cuda-0.5.0}/numba_cuda/numba/cuda/compiler.py

@@ -570,16 +570,16 @@ def compile_ptx_for_current_device(pyfunc, sig, debug=None, lineinfo=False,
                        abi=abi, abi_info=abi_info)
 
 
-def declare_device_function(name, restype, argtypes):
-    return declare_device_function_template(name, restype, argtypes).key
+def declare_device_function(name, restype, argtypes, link):
+    return declare_device_function_template(name, restype, argtypes, link).key
 
 
-def declare_device_function_template(name, restype, argtypes):
+def declare_device_function_template(name, restype, argtypes, link):
     from .descriptor import cuda_target
     typingctx = cuda_target.typing_context
     targetctx = cuda_target.target_context
     sig = typing.signature(restype, *argtypes)
-    extfn = ExternFunction(name, sig)
+    extfn = ExternFunction(name, sig, link)
 
     class device_function_template(ConcreteTemplate):
         key = extfn
@@ -593,7 +593,8 @@ def declare_device_function_template(name, restype, argtypes):
     return device_function_template
 
 
-class ExternFunction(object):
-    def __init__(self, name, sig):
+class ExternFunction:
+    def __init__(self, name, sig, link):
         self.name = name
         self.sig = sig
+        self.link = link

{numba_cuda-0.4.0 → numba_cuda-0.5.0}/numba_cuda/numba/cuda/cudadecl.py

@@ -403,16 +403,20 @@ _genfp16_binary_operator(operator.itruediv)
 
 
 def _resolve_wrapped_unary(fname):
+    link = tuple()
     decl = declare_device_function_template(f'__numba_wrapper_{fname}',
                                             types.float16,
-                                            (types.float16,))
+                                            (types.float16,),
+                                            link)
     return types.Function(decl)
 
 
 def _resolve_wrapped_binary(fname):
+    link = tuple()
     decl = declare_device_function_template(f'__numba_wrapper_{fname}',
                                             types.float16,
-                                            (types.float16, types.float16,))
+                                            (types.float16, types.float16,),
+                                            link)
     return types.Function(decl)
 
 

{numba_cuda-0.4.0 → numba_cuda-0.5.0}/numba_cuda/numba/cuda/cudadrv/linkable_code.py

@@ -2,8 +2,12 @@ from .mappings import FILE_EXTENSION_MAP
 
 
 class LinkableCode:
-    """An object that can be passed in the `link` list argument to `@cuda.jit`
-    kernels to supply code to be linked from memory."""
+    """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
@@ -15,49 +19,49 @@ class LinkableCode:
 
 
 class PTXSource(LinkableCode):
-    """PTX Source code in memory"""
+    """PTX source code in memory."""
 
     kind = FILE_EXTENSION_MAP["ptx"]
     default_name = "<unnamed-ptx>"
 
 
 class CUSource(LinkableCode):
-    """CUDA C/C++ Source code in memory"""
+    """CUDA C/C++ source code in memory."""
 
     kind = "cu"
     default_name = "<unnamed-cu>"
 
 
 class Fatbin(LinkableCode):
-    """A fatbin ELF in memory"""
+    """An ELF Fatbin in memory."""
 
     kind = FILE_EXTENSION_MAP["fatbin"]
     default_name = "<unnamed-fatbin>"
 
 
 class Cubin(LinkableCode):
-    """A cubin ELF in memory"""
+    """An ELF Cubin in memory."""
 
     kind = FILE_EXTENSION_MAP["cubin"]
     default_name = "<unnamed-cubin>"
 
 
 class Archive(LinkableCode):
-    """An archive of objects in memory"""
+    """An archive of objects in memory."""
 
     kind = FILE_EXTENSION_MAP["a"]
     default_name = "<unnamed-archive>"
 
 
 class Object(LinkableCode):
-    """An object file in memory"""
+    """An object file in memory."""
 
     kind = FILE_EXTENSION_MAP["o"]
     default_name = "<unnamed-object>"
 
 
 class LTOIR(LinkableCode):
-    """An LTOIR file in memory"""
+    """An LTOIR file in memory."""
 
     kind = "ltoir"
     default_name = "<unnamed-ltoir>"

{numba_cuda-0.4.0 → numba_cuda-0.5.0}/numba_cuda/numba/cuda/cudadrv/nvvm.py

@@ -314,7 +314,9 @@ COMPUTE_CAPABILITIES = (
     (6, 0), (6, 1), (6, 2),
     (7, 0), (7, 2), (7, 5),
     (8, 0), (8, 6), (8, 7), (8, 9),
-    (9, 0)
+    (9, 0),
+    (10, 0), (10, 1),
+    (12, 0),
 )
 
 # Maps CTK version -> (min supported cc, max supported cc) inclusive
@@ -331,6 +333,9 @@ CTK_SUPPORTED = {
     (12, 2): ((5, 0), (9, 0)),
     (12, 3): ((5, 0), (9, 0)),
     (12, 4): ((5, 0), (9, 0)),
+    (12, 5): ((5, 0), (9, 0)),
+    (12, 6): ((5, 0), (9, 0)),
+    (12, 8): ((5, 0), (12, 0)),
 }
 
 

{numba_cuda-0.4.0 → numba_cuda-0.5.0}/numba_cuda/numba/cuda/decorators.py

@@ -173,7 +173,7 @@ def jit(func_or_sig=None, device=False, inline=False, link=[], debug=None,
                 return disp
 
 
-def declare_device(name, sig):
+def declare_device(name, sig, link=None):
     """
     Declare the signature of a foreign function. Returns a descriptor that can
     be used to call the function from a Python kernel.
@@ -181,10 +181,17 @@ def declare_device(name, sig):
     :param name: The name of the foreign function.
     :type name: str
     :param sig: The Numba signature of the function.
+    :param link: External code to link when calling the function.
     """
+    if link is None:
+        link = tuple()
+    else:
+        if not isinstance(link, (list, tuple, set)):
+            link = (link,)
+
     argtypes, restype = sigutils.normalize_signature(sig)
     if restype is None:
         msg = 'Return type must be provided for device declarations'
         raise TypeError(msg)
 
-    return declare_device_function(name, restype, argtypes)
+    return declare_device_function(name, restype, argtypes, link)

{numba_cuda-0.4.0 → numba_cuda-0.5.0}/numba_cuda/numba/cuda/dispatcher.py

@@ -11,10 +11,11 @@ from numba.core.compiler_lock import global_compiler_lock
 from numba.core.dispatcher import Dispatcher
 from numba.core.errors import NumbaPerformanceWarning
 from numba.core.typing.typeof import Purpose, typeof
-
+from numba.core.types.functions import Function
 from numba.cuda.api import get_current_device
 from numba.cuda.args import wrap_arg
-from numba.cuda.compiler import compile_cuda, CUDACompiler, kernel_fixup
+from numba.cuda.compiler import (compile_cuda, CUDACompiler, kernel_fixup,
+                                 ExternFunction)
 from numba.cuda.cudadrv import driver
 from numba.cuda.cudadrv.devices import get_context
 from numba.cuda.descriptor import cuda_target
@@ -158,6 +159,16 @@ class _Kernel(serialize.ReduceMixin):
 
         self.maybe_link_nrt(link, tgt_ctx, asm)
 
+        for k, v in cres.fndesc.typemap.items():
+            if not isinstance(v, Function):
+                continue
+
+            if not isinstance(v.typing_key, ExternFunction):
+                continue
+
+            for obj in v.typing_key.link:
+                lib.add_linking_file(obj)
+
         for filepath in link:
             lib.add_linking_file(filepath)
 

{numba_cuda-0.4.0 → numba_cuda-0.5.0}/numba_cuda/numba/cuda/testing.py

@@ -115,12 +115,22 @@ 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_h = os.path.join(config.CUDA_INCLUDE_PATH, 'cuda.h')
+    cuda_include_path = libs.get_cuda_include_dir()
+    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()
+    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)
+
+
 def skip_if_mvc_enabled(reason):
     """Skip a test if Minor Version Compatibility is enabled"""
     return unittest.skipIf(config.CUDA_ENABLE_MINOR_VERSION_COMPATIBILITY,

{numba_cuda-0.4.0 → numba_cuda-0.5.0}/numba_cuda/numba/cuda/tests/cudapy/test_device_func.py

@@ -1,11 +1,14 @@
 import re
-import types
+import cffi
 
 import numpy as np
 
-from numba.cuda.testing import unittest, skip_on_cudasim, CUDATestCase
-from numba import cuda, jit, float32, int32
+from numba.cuda.testing import (skip_if_curand_kernel_missing, skip_on_cudasim,
+                                test_data_dir, unittest, CUDATestCase)
+from numba import cuda, jit, float32, int32, types
 from numba.core.errors import TypingError
+from numba.tests.support import skip_unless_cffi
+from types import ModuleType
 
 
 class TestDeviceFunc(CUDATestCase):
@@ -92,7 +95,7 @@ class TestDeviceFunc(CUDATestCase):
         def add(a, b):
             return a + b
 
-        mymod = types.ModuleType(name='mymod')
+        mymod = ModuleType(name='mymod')
         mymod.add = add
         del add
 
@@ -192,31 +195,162 @@ class TestDeviceFunc(CUDATestCase):
 
         self.assertEqual(0x04010203, x[0])
 
-    def _test_declare_device(self, decl):
+
+times2_cu = cuda.CUSource("""
+extern "C" __device__
+int times2(int *out, int a)
+{
+  *out = a * 2;
+  return 0;
+}
+""")
+
+
+times4_cu = cuda.CUSource("""
+extern "C" __device__
+int times2(int *out, int a);
+
+extern "C" __device__
+int times4(int *out, int a)
+{
+  int tmp;
+  times2(&tmp, a);
+  *out = tmp * 2;
+  return 0;
+}
+""")
+
+jitlink_user_cu = cuda.CUSource("""
+extern "C" __device__
+int array_mutator(void *out, int *a);
+
+extern "C" __device__
+int use_array_mutator(void *out, int *a) {
+  array_mutator(out, a);
+  return 0;
+}
+""")
+
+rng_cu = cuda.CUSource("""
+#include <curand_kernel.h>
+
+extern "C" __device__
+int random_number(unsigned int *out, unsigned long long seed)
+{
+  // Initialize state
+  curandStateXORWOW_t state;
+  unsigned long long sequence = 1;
+  unsigned long long offset = 0;
+  curand_init(seed, sequence, offset, &state);
+
+  // Generate one random number
+  *out = curand(&state);
+
+  // Report no exception
+  return 0;
+}""")
+
+
+@skip_on_cudasim('External functions unsupported in the simulator')
+class TestDeclareDevice(CUDATestCase):
+
+    def check_api(self, decl):
         self.assertEqual(decl.name, 'f1')
         self.assertEqual(decl.sig.args, (float32[:],))
         self.assertEqual(decl.sig.return_type, int32)
 
-    @skip_on_cudasim('cudasim does not check signatures')
     def test_declare_device_signature(self):
         f1 = cuda.declare_device('f1', int32(float32[:]))
-        self._test_declare_device(f1)
+        self.check_api(f1)
 
-    @skip_on_cudasim('cudasim does not check signatures')
     def test_declare_device_string(self):
         f1 = cuda.declare_device('f1', 'int32(float32[:])')
-        self._test_declare_device(f1)
+        self.check_api(f1)
 
-    @skip_on_cudasim('cudasim does not check signatures')
     def test_bad_declare_device_tuple(self):
         with self.assertRaisesRegex(TypeError, 'Return type'):
             cuda.declare_device('f1', (float32[:],))
 
-    @skip_on_cudasim('cudasim does not check signatures')
     def test_bad_declare_device_string(self):
         with self.assertRaisesRegex(TypeError, 'Return type'):
             cuda.declare_device('f1', '(float32[:],)')
 
+    def test_link_cu_source(self):
+        times2 = cuda.declare_device('times2', 'int32(int32)', link=times2_cu)
+
+        @cuda.jit
+        def kernel(r, x):
+            i = cuda.grid(1)
+            if i < len(r):
+                r[i] = times2(x[i])
+
+        x = np.arange(10, dtype=np.int32)
+        r = np.empty_like(x)
+
+        kernel[1, 32](r, x)
+
+        np.testing.assert_equal(r, x * 2)
+
+    def _test_link_multiple_sources(self, link_type):
+        link = link_type([times2_cu, times4_cu])
+        times4 = cuda.declare_device('times4', 'int32(int32)', link=link)
+
+        @cuda.jit
+        def kernel(r, x):
+            i = cuda.grid(1)
+            if i < len(r):
+                r[i] = times4(x[i])
+
+        x = np.arange(10, dtype=np.int32)
+        r = np.empty_like(x)
+
+        kernel[1, 32](r, x)
+
+        np.testing.assert_equal(r, x * 4)
+
+    def test_link_multiple_sources_set(self):
+        self._test_link_multiple_sources(set)
+
+    def test_link_multiple_sources_tuple(self):
+        self._test_link_multiple_sources(tuple)
+
+    def test_link_multiple_sources_list(self):
+        self._test_link_multiple_sources(list)
+
+    @skip_unless_cffi
+    def test_link_sources_in_memory_and_on_disk(self):
+        jitlink_cu = str(test_data_dir / "jitlink.cu")
+        link = [jitlink_cu, jitlink_user_cu]
+        sig = types.void(types.CPointer(types.int32))
+        ext_fn = cuda.declare_device("use_array_mutator", sig, link=link)
+
+        ffi = cffi.FFI()
+
+        @cuda.jit
+        def kernel(x):
+            ptr = ffi.from_buffer(x)
+            ext_fn(ptr)
+
+        x = np.arange(2, dtype=np.int32)
+        kernel[1, 1](x)
+
+        expected = np.ones(2, dtype=np.int32)
+        np.testing.assert_equal(x, expected)
+
+    @skip_if_curand_kernel_missing
+    def test_include_cuda_header(self):
+        sig = types.int32(types.uint64)
+        link = [rng_cu]
+        random_number = cuda.declare_device("random_number", sig, link=link)
+
+        @cuda.jit
+        def kernel(x, seed):
+            x[0] = random_number(seed)
+
+        x = np.zeros(1, dtype=np.uint32)
+        kernel[1, 1](x, 1)
+        np.testing.assert_equal(x[0], 323845807)
+
 
 if __name__ == '__main__':
     unittest.main()

{numba_cuda-0.4.0 → numba_cuda-0.5.0}/numba_cuda/numba/cuda/tests/doc_examples/test_ffi.py

@@ -15,16 +15,18 @@ class TestFFI(CUDATestCase):
         import numpy as np
         import os
 
-        # Declaration of the foreign function
-        mul = cuda.declare_device('mul_f32_f32', 'float32(float32, float32)')
-
         # Path to the source containing the foreign function
         # (here assumed to be in a subdirectory called "ffi")
         basedir = os.path.dirname(os.path.abspath(__file__))
         functions_cu = os.path.join(basedir, 'ffi', 'functions.cu')
 
-        # Kernel that links in functions.cu and calls mul
-        @cuda.jit(link=[functions_cu])
+        # Declaration of the foreign function
+        mul = cuda.declare_device('mul_f32_f32', 'float32(float32, float32)',
+                                  link=functions_cu)
+
+        # A kernel that calls mul; functions.cu is linked automatically due to
+        # the call to mul.
+        @cuda.jit
         def multiply_vectors(r, x, y):
             i = cuda.grid(1)
 
@@ -54,14 +56,15 @@ class TestFFI(CUDATestCase):
 
         # magictoken.ex_from_buffer_decl.begin
         signature = 'float32(CPointer(float32), int32)'
-        sum_reduce = cuda.declare_device('sum_reduce', signature)
+        sum_reduce = cuda.declare_device('sum_reduce', signature,
+                                         link=functions_cu)
         # magictoken.ex_from_buffer_decl.end
 
         # magictoken.ex_from_buffer_kernel.begin
         import cffi
         ffi = cffi.FFI()
 
-        @cuda.jit(link=[functions_cu])
+        @cuda.jit
         def reduction_caller(result, array):
             array_ptr = ffi.from_buffer(array)
             result[()] = sum_reduce(array_ptr, len(array))

{numba_cuda-0.4.0 → numba_cuda-0.5.0}/numba_cuda.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: numba-cuda
-Version: 0.4.0
+Version: 0.5.0
 Summary: CUDA target for Numba
 Author: Anaconda Inc., NVIDIA Corporation
 License: BSD 2-clause
@@ -27,7 +27,19 @@ tracker](https://github.com/NVIDIA/numba-cuda/issues).
 To raise questions or initiate discussions, please use the [Numba Discourse
 forum](https://numba.discourse.group).
 
-## Building from source
+## Installation with pip
+
+```shell
+pip install numba-cuda
+```
+
+## Installation with Conda
+
+```shell
+conda install -c conda-forge numba-cuda
+```
+
+## Installation from source
 
 Install as an editable install:
 
@@ -53,3 +65,9 @@ which will show a path like:
 ```
 <path to numba-cuda repo>/numba_cuda/numba/cuda/__init__.py
 ```
+
+## Contributing Guide
+
+Review the
+[CONTRIBUTING.md](https://github.com/NVIDIA/numba-cuda/blob/main/CONTRIBUTING.md)
+file for information on how to contribute code and issues to the project.

numba_cuda-0.4.0/numba_cuda/VERSION

@@ -1 +0,0 @@
-0.4.0