numba-cuda 0.18.1__py3-none-any.whl → 0.19.0__py3-none-any.whl

numba_cuda/numba/cuda/itanium_mangler.py

@@ -0,0 +1,211 @@
+"""
+Itanium CXX ABI Mangler
+
+Reference: https://itanium-cxx-abi.github.io/cxx-abi/abi.html
+
+The basics of the mangling scheme.
+
+We are hijacking the CXX mangling scheme for our use.  We map Python modules
+into CXX namespace.  A `module1.submodule2.foo` is mapped to
+`module1::submodule2::foo`.   For parameterized numba types, we treat them as
+templated types; for example, `array(int64, 1d, C)` becomes an
+`array<int64, 1, C>`.
+
+All mangled names are prefixed with "_Z".  It is followed by the name of the
+entity.  A name contains one or more identifiers.  Each identifier is encoded
+as "<num of char><name>".   If the name is namespaced and, therefore,
+has multiple identifiers, the entire name is encoded as "N<name>E".
+
+For functions, arguments types follow.  There are condensed encodings for basic
+built-in types; e.g. "i" for int, "f" for float.  For other types, the
+previously mentioned name encoding should be used.
+
+For templated types, the template parameters are encoded immediately after the
+name.  If it is namespaced, it should be within the 'N' 'E' marker.  Template
+parameters are encoded in "I<params>E", where each parameter is encoded using
+the mentioned name encoding scheme.  Template parameters can contain literal
+values like the '1' in the array type shown earlier.  There is special encoding
+scheme for them to avoid leading digits.
+"""
+
+import re
+
+from numba.core import types
+
+
+# According the scheme, valid characters for mangled names are [a-zA-Z0-9_].
+# We borrow the '_' as the escape character to encode invalid char into
+# '_xx' where 'xx' is the hex codepoint.
+_re_invalid_char = re.compile(r"[^a-z0-9_]", re.I)
+
+PREFIX = "_Z"
+
+# Numba types to mangled type code. These correspond with the codes listed in
+# https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling-builtin
+N2CODE = {
+    types.void: "v",
+    types.boolean: "b",
+    types.uint8: "h",
+    types.int8: "a",
+    types.uint16: "t",
+    types.int16: "s",
+    types.uint32: "j",
+    types.int32: "i",
+    types.uint64: "y",
+    types.int64: "x",
+    types.float16: "Dh",
+    types.float32: "f",
+    types.float64: "d",
+}
+
+
+def _escape_string(text):
+    """Escape the given string so that it only contains ASCII characters
+    of [a-zA-Z0-9_$].
+
+    The dollar symbol ($) and other invalid characters are escaped into
+    the string sequence of "$xx" where "xx" is the hex codepoint of the char.
+
+    Multibyte characters are encoded into utf8 and converted into the above
+    hex format.
+    """
+
+    def repl(m):
+        return "".join(("_%02x" % ch) for ch in m.group(0).encode("utf8"))
+
+    ret = re.sub(_re_invalid_char, repl, text)
+    # Return str if we got a unicode (for py2)
+    if not isinstance(ret, str):
+        return ret.encode("ascii")
+    return ret
+
+
+def _fix_lead_digit(text):
+    """
+    Fix text with leading digit
+    """
+    if text and text[0].isdigit():
+        return "_" + text
+    else:
+        return text
+
+
+def _len_encoded(string):
+    """
+    Prefix string with digit indicating the length.
+    Add underscore if string is prefixed with digits.
+    """
+    string = _fix_lead_digit(string)
+    return "%u%s" % (len(string), string)
+
+
+def mangle_abi_tag(abi_tag: str) -> str:
+    return "B" + _len_encoded(_escape_string(abi_tag))
+
+
+def mangle_identifier(ident, template_params="", *, abi_tags=(), uid=None):
+    """
+    Mangle the identifier with optional template parameters and abi_tags.
+
+    Note:
+
+    This treats '.' as '::' in C++.
+    """
+    if uid is not None:
+        # Add uid to abi-tags
+        abi_tags = (f"v{uid}", *abi_tags)
+    parts = [_len_encoded(_escape_string(x)) for x in ident.split(".")]
+    enc_abi_tags = list(map(mangle_abi_tag, abi_tags))
+    extras = template_params + "".join(enc_abi_tags)
+    if len(parts) > 1:
+        return "N%s%sE" % ("".join(parts), extras)
+    else:
+        return "%s%s" % (parts[0], extras)
+
+
+def mangle_type_or_value(typ):
+    """
+    Mangle type parameter and arbitrary value.
+    """
+    # Handle numba types
+    if isinstance(typ, types.Type):
+        if typ in N2CODE:
+            return N2CODE[typ]
+        else:
+            return mangle_templated_ident(*typ.mangling_args)
+    # Handle integer literal
+    elif isinstance(typ, int):
+        return "Li%dE" % typ
+    # Handle str as identifier
+    elif isinstance(typ, str):
+        return mangle_identifier(typ)
+    # Otherwise
+    else:
+        enc = _escape_string(str(typ))
+        return _len_encoded(enc)
+
+
+# Alias
+mangle_type = mangle_type_or_value
+mangle_value = mangle_type_or_value
+
+
+def mangle_templated_ident(identifier, parameters):
+    """
+    Mangle templated identifier.
+    """
+    template_params = (
+        "I%sE" % "".join(map(mangle_type_or_value, parameters))
+        if parameters
+        else ""
+    )
+    return mangle_identifier(identifier, template_params)
+
+
+def mangle_args(argtys):
+    """
+    Mangle sequence of Numba type objects and arbitrary values.
+    """
+    return "".join([mangle_type_or_value(t) for t in argtys])
+
+
+def mangle(ident, argtys, *, abi_tags=(), uid=None):
+    """
+    Mangle identifier with Numba type objects and abi-tags.
+    """
+    return "".join(
+        [
+            PREFIX,
+            mangle_identifier(ident, abi_tags=abi_tags, uid=uid),
+            mangle_args(argtys),
+        ]
+    )
+
+
+def prepend_namespace(mangled, ns):
+    """
+    Prepend namespace to mangled name.
+    """
+    if not mangled.startswith(PREFIX):
+        raise ValueError("input is not a mangled name")
+    elif mangled.startswith(PREFIX + "N"):
+        # nested
+        remaining = mangled[3:]
+        ret = PREFIX + "N" + mangle_identifier(ns) + remaining
+    else:
+        # non-nested
+        remaining = mangled[2:]
+        head, tail = _split_mangled_ident(remaining)
+        ret = PREFIX + "N" + mangle_identifier(ns) + head + "E" + tail
+    return ret
+
+
+def _split_mangled_ident(mangled):
+    """
+    Returns `(head, tail)` where `head` is the `<len> + <name>` encoded
+    identifier and `tail` is the remaining.
+    """
+    ct = int(mangled)
+    ctlen = len(str(ct))
+    at = ctlen + ct
+    return mangled[:at], mangled[at:]

numba_cuda/numba/cuda/libdevicedecl.py

@@ -1,5 +1,5 @@
 from numba.cuda import libdevice, libdevicefuncs
-from numba.core.typing.templates import ConcreteTemplate, Registry
+from numba.cuda.typing.templates import ConcreteTemplate, Registry
 
 registry = Registry()
 register_global = registry.register_global

numba_cuda/numba/cuda/libdevicefuncs.py

@@ -2,7 +2,7 @@ from collections import namedtuple
 from textwrap import indent
 
 from numba.types import float32, float64, int16, int32, int64, void, Tuple
-from numba.core.typing.templates import signature
+from numba.cuda.typing.templates import signature
 
 arg = namedtuple("arg", ("name", "ty", "is_ptr"))
 

numba_cuda/numba/cuda/lowering.py

@@ -14,11 +14,11 @@ from numba.core import (
     funcdesc,
     generators,
     config,
-    ir_utils,
     cgutils,
     removerefctpass,
     targetconfig,
 )
+from numba.cuda.core import ir_utils
 from numba.core.errors import (
     LoweringError,
     new_error_context,

numba_cuda/numba/cuda/simulator/api.py

@@ -17,8 +17,8 @@ from .cudadrv.linkable_code import (
     LTOIR,  # noqa: F401
 )  # noqa: F401
 from .kernel import FakeCUDAKernel
-from numba.core.sigutils import is_signature
 from numba.core import config
+from numba.cuda.core.sigutils import is_signature
 from warnings import warn
 from ..args import In, Out, InOut  # noqa: F401
 

numba_cuda/numba/cuda/simulator/cudadrv/driver.py

@@ -3,8 +3,6 @@ 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])
@@ -63,11 +61,6 @@ def launch_kernel(*args, **kwargs):
 
 USE_NV_BINDING = False
 
-PyNvJitLinker = None
-
-if config.ENABLE_CUDASIM:
-    config.CUDA_ENABLE_PYNVJITLINK = False
-
 
 def _have_nvjitlink():
     return False

numba_cuda/numba/cuda/target.py

@@ -3,11 +3,10 @@ from functools import cached_property
 import llvmlite.binding as ll
 from llvmlite import ir
 import warnings
-from numba.cuda import cgutils
+from numba.cuda import cgutils, itanium_mangler
 from numba.core import (
     compiler,
     config,
-    itanium_mangler,
     targetconfig,
     types,
     typing,

numba_cuda/numba/cuda/testing.py

@@ -8,7 +8,7 @@ from numba.cuda.cuda_paths import get_conda_ctk
 from numba.cuda.cudadrv import driver, devices, libs
 from numba.cuda.dispatcher import CUDADispatcher
 from numba.core import config
-from numba.tests.support import TestCase
+from numba.cuda.tests.support import TestCase
 from pathlib import Path
 
 from typing import Iterable, Union
@@ -154,7 +154,6 @@ class CUDATestCase(TestCase):
         matcher.stderr = StringIO()
         result = matcher.run()
         if result != 0:
-            dump_instructions = ""
             if self._dump_failed_filechecks:
                 dump_directory = Path(
                     datetime.now().strftime("numba-ir-%Y_%m_%d_%H_%M_%S")
@@ -172,13 +171,12 @@ class CUDATestCase(TestCase):
                 ):
                     _ = ir_file.write(ir_content + "\n")
                     _ = checks_file.write(check_patterns)
-                    dump_instructions = f"Reproduce with:\n\nfilecheck --check-prefixes={','.join(check_prefixes)} {checks_dump} --input-file={ir_dump}"
+                    dump_instructions = f"Reproduce with:\n\nfilecheck --check-prefixes={','.join(check_prefixes)} {checks_dump} --input-file {ir_dump}"
+            else:
+                dump_instructions = "Rerun with --dump-failed-filechecks to generate a reproducer."
 
             self.fail(
                 f"FileCheck failed:\n{matcher.stderr.getvalue()}\n\n"
-                + f"Check prefixes:\n{check_prefixes}\n\n"
-                + f"Check patterns:\n{check_patterns}\n"
-                + f"IR:\n{ir_content}\n\n"
                 + dump_instructions
             )
 

numba_cuda/numba/cuda/tests/core/test_itanium_mangler.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+from numba import int32, int64, uint32, uint64, float32, float64
+from numba.core.types import range_iter32_type
+from numba.cuda import itanium_mangler
+import unittest
+
+
+class TestItaniumManager(unittest.TestCase):
+    def test_ident(self):
+        got = itanium_mangler.mangle_identifier("apple")
+        expect = "5apple"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_identifier("ap_ple")
+        expect = "6ap_ple"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_identifier("apple213")
+        expect = "8apple213"
+        self.assertEqual(expect, got)
+
+    def test_types(self):
+        got = itanium_mangler.mangle_type(int32)
+        expect = "i"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_type(int64)
+        expect = "x"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_type(uint32)
+        expect = "j"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_type(uint64)
+        expect = "y"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_type(float32)
+        expect = "f"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle_type(float64)
+        expect = "d"
+        self.assertEqual(expect, got)
+
+    def test_function(self):
+        got = itanium_mangler.mangle("what", [int32, float32])
+        expect = "_Z4whatif"
+        self.assertEqual(expect, got)
+
+        got = itanium_mangler.mangle(
+            "a_little_brown_fox", [uint64, uint32, float64]
+        )
+        expect = "_Z18a_little_brown_foxyjd"
+        self.assertEqual(expect, got)
+
+    def test_custom_type(self):
+        got = itanium_mangler.mangle_type(range_iter32_type)
+        name = str(range_iter32_type)
+        expect = "{n}{name}".format(n=len(name), name=name)
+        self.assertEqual(expect, got)
+
+    def test_mangle_literal(self):
+        # check int
+        got = itanium_mangler.mangle_value(123)
+        expect = "Li123E"
+        self.assertEqual(expect, got)
+        # check float (not handled using standard)
+        got = itanium_mangler.mangle_value(12.3)
+        self.assertRegex(got, r"^\d+_12_[0-9a-z][0-9a-z]3$")
+
+    def test_mangle_unicode(self):
+        name = "f∂ƒ©z"
+        got = itanium_mangler.mangle_identifier(name)
+        self.assertRegex(got, r"^\d+f(_[a-z0-9][a-z0-9])+z$")
+
+
+if __name__ == "__main__":
+    unittest.main()

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

@@ -4,7 +4,7 @@ from numba.cuda.cudadrv import devicearray
 from numba import cuda
 from numba.cuda.testing import unittest, CUDATestCase
 from numba.cuda.testing import skip_on_cudasim
-from numba.tests.support import IS_NUMPY_2
+from numba.cuda.tests.support import IS_NUMPY_2
 
 
 class TestCudaNDArray(CUDATestCase):

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

@@ -9,7 +9,7 @@ from numba.cuda.testing import (
     skip_if_external_memmgr,
     CUDATestCase,
 )
-from numba.tests.support import captured_stderr
+from numba.cuda.tests.support import captured_stderr
 from numba.core import config
 
 

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

@@ -9,7 +9,7 @@ from numba.cuda.testing import (
     skip_on_cudasim,
     skip_under_cuda_memcheck,
 )
-from numba.tests.support import captured_stdout
+from numba.cuda.tests.support import captured_stdout
 
 
 class TestCudaDetect(CUDATestCase):

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

@@ -5,7 +5,7 @@ import weakref
 from numba import cuda
 from numba.core import config
 from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
-from numba.tests.support import linux_only
+from numba.cuda.tests.support import linux_only
 
 if not config.ENABLE_CUDASIM:
 

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

@@ -6,7 +6,7 @@ from numba.cuda.testing import skip_on_cudasim, skip_if_cuda_includes_missing
 from numba.cuda.testing import CUDATestCase, test_data_dir
 from numba.cuda.cudadrv.driver import CudaAPIError, _Linker, LinkerError
 from numba.cuda import require_context
-from numba.tests.support import ignore_internal_warnings
+from numba.cuda.tests.support import ignore_internal_warnings
 from numba import cuda, void, float64, int64, int32, typeof, float32
 from numba.cuda.cudadrv.error import NvrtcError
 

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

@@ -4,7 +4,7 @@ from numba.cuda.cudadrv.driver import device_memset, driver, USE_NV_BINDING
 from numba import cuda
 from numba.cuda.testing import unittest, ContextResettingTestCase
 from numba.cuda.testing import skip_on_cudasim, skip_on_arm
-from numba.tests.support import linux_only
+from numba.cuda.tests.support import linux_only
 
 
 @skip_on_cudasim("CUDA Driver API unsupported in the simulator")

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

@@ -6,7 +6,7 @@ from numba.cuda.testing import (
     skip_under_cuda_memcheck,
     skip_if_mvc_libraries_unavailable,
 )
-from numba.tests.support import linux_only
+from numba.cuda.tests.support import linux_only
 
 
 def child_test():

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

@@ -13,13 +13,11 @@ class TestArchOption(unittest.TestCase):
         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
-            )
+        supported_ccs = nvrtc.get_supported_ccs()
+        for cc in supported_ccs:
+            self.assertEqual(nvrtc.get_arch_option(*cc), "compute_%d%d" % cc)
         self.assertEqual(
-            nvrtc.get_arch_option(1000, 0), "compute_%d%d" % supported_cc[-1]
+            nvrtc.get_arch_option(1000, 0), "compute_%d%d" % supported_ccs[-1]
         )
 
 

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

@@ -25,10 +25,6 @@ class TestNvvmDriver(unittest.TestCase):
         # ("-gen-lto") - all other NVVM options are of the form
         # "-<name>=<value>"
 
-        # -gen-lto is not available prior to CUDA 11.5
-        if runtime.get_version() < (11, 5):
-            self.skipTest("-gen-lto unavailable in this toolkit version")
-
         nvvmir = self.get_nvvmir()
         arch = "compute_%d%d" % nvrtc.get_lowest_supported_cc()
         ltoir = nvvm.compile_ir(nvvmir, opt=3, gen_lto=None, arch=arch)

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

@@ -7,7 +7,7 @@ from numba.cuda.testing import (
     skip_with_cuda_python,
     skip_under_cuda_memcheck,
 )
-from numba.tests.support import linux_only
+from numba.cuda.tests.support import linux_only
 
 
 def child_test():

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

@@ -8,9 +8,7 @@ import math
 class TestBfloat16HighLevelBindings(CUDATestCase):
     def skip_unsupported(self):
         if not cuda.is_bfloat16_supported():
-            self.skipTest(
-                "bfloat16 requires compute capability 8.0+ and CUDA version>= 12.0"
-            )
+            self.skipTest("bfloat16 requires compute capability 8.0+")
 
     def test_use_type_in_kernel(self):
         self.skip_unsupported()

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

@@ -43,9 +43,7 @@ dtypes = [int16, int32, int64, uint16, uint32, uint64, float32]
 class Bfloat16Test(CUDATestCase):
     def skip_unsupported(self):
         if not cuda.is_bfloat16_supported():
-            self.skipTest(
-                "bfloat16 requires compute capability 8.0+ and CUDA version>= 12.0"
-            )
+            self.skipTest("bfloat16 requires compute capability 8.0+")
 
     def test_ctor(self):
         self.skip_unsupported()