numba-cuda 0.21.1__cp313-cp313-win_amd64.whl

numba_cuda/numba/cuda/typeconv/__init__.py

@@ -0,0 +1,4 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from .castgraph import Conversion  # noqa F401

numba_cuda/numba/cuda/typeconv/castgraph.py

@@ -0,0 +1,137 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from collections import defaultdict
+import enum
+
+
+class Conversion(enum.IntEnum):
+    """
+    A conversion kind from one type to the other.  The enum members
+    are ordered from stricter to looser.
+    """
+
+    # The two types are identical
+    exact = 1
+    # The two types are of the same kind, the destination type has more
+    # extension or precision than the source type (e.g. float32 -> float64,
+    # or int32 -> int64)
+    promote = 2
+    # The source type can be converted to the destination type without loss
+    # of information (e.g. int32 -> int64).  Note that the conversion may
+    # still fail explicitly at runtime (e.g. Optional(int32) -> int32)
+    safe = 3
+    # The conversion may appear to succeed at runtime while losing information
+    # or precision (e.g. int32 -> uint32, float64 -> float32, int64 -> int32,
+    # etc.)
+    unsafe = 4
+
+    # This value is only used internally
+    nil = 99
+
+
+class CastSet(object):
+    """A set of casting rules.
+
+    There is at most one rule per target type.
+    """
+
+    def __init__(self):
+        self._rels = {}
+
+    def insert(self, to, rel):
+        old = self.get(to)
+        setrel = min(rel, old)
+        self._rels[to] = setrel
+        return old != setrel
+
+    def items(self):
+        return self._rels.items()
+
+    def get(self, item):
+        return self._rels.get(item, Conversion.nil)
+
+    def __len__(self):
+        return len(self._rels)
+
+    def __repr__(self):
+        body = [
+            "{rel}({ty})".format(rel=rel, ty=ty)
+            for ty, rel in self._rels.items()
+        ]
+        return "{" + ", ".join(body) + "}"
+
+    def __contains__(self, item):
+        return item in self._rels
+
+    def __iter__(self):
+        return iter(self._rels.keys())
+
+    def __getitem__(self, item):
+        return self._rels[item]
+
+
+class TypeGraph(object):
+    """A graph that maintains the casting relationship of all types.
+
+    This simplifies the definition of casting rules by automatically
+    propagating the rules.
+    """
+
+    def __init__(self, callback=None):
+        """
+        Args
+        ----
+        - callback: callable or None
+            It is called for each new casting rule with
+            (from_type, to_type, castrel).
+        """
+        assert callback is None or callable(callback)
+        self._forwards = defaultdict(CastSet)
+        self._backwards = defaultdict(set)
+        self._callback = callback
+
+    def get(self, ty):
+        return self._forwards[ty]
+
+    def propagate(self, a, b, baserel):
+        backset = self._backwards[a]
+
+        # Forward propagate the relationship to all nodes that b leads to
+        for child in self._forwards[b]:
+            rel = max(baserel, self._forwards[b][child])
+            if a != child:
+                if self._forwards[a].insert(child, rel):
+                    self._callback(a, child, rel)
+                self._backwards[child].add(a)
+
+            # Propagate the relationship from nodes that connects to a
+            for backnode in backset:
+                if backnode != child:
+                    backrel = max(rel, self._forwards[backnode][a])
+                    if self._forwards[backnode].insert(child, backrel):
+                        self._callback(backnode, child, backrel)
+                    self._backwards[child].add(backnode)
+
+        # Every node that leads to a connects to b
+        for child in self._backwards[a]:
+            rel = max(baserel, self._forwards[child][a])
+            if b != child:
+                if self._forwards[child].insert(b, rel):
+                    self._callback(child, b, rel)
+                self._backwards[b].add(child)
+
+    def insert_rule(self, a, b, rel):
+        self._forwards[a].insert(b, rel)
+        self._callback(a, b, rel)
+        self._backwards[b].add(a)
+        self.propagate(a, b, rel)
+
+    def promote(self, a, b):
+        self.insert_rule(a, b, Conversion.promote)
+
+    def safe(self, a, b):
+        self.insert_rule(a, b, Conversion.safe)
+
+    def unsafe(self, a, b):
+        self.insert_rule(a, b, Conversion.unsafe)

numba_cuda/numba/cuda/typeconv/rules.py

@@ -0,0 +1,63 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import itertools
+from .typeconv import TypeManager, TypeCastingRules
+from numba.cuda import types
+
+
+default_type_manager = TypeManager()
+
+
+def dump_number_rules():
+    tm = default_type_manager
+    for a, b in itertools.product(types.number_domain, types.number_domain):
+        print(a, "->", b, tm.check_compatible(a, b))
+
+
+def _init_casting_rules(tm):
+    tcr = TypeCastingRules(tm)
+    tcr.safe_unsafe(types.boolean, types.int8)
+    tcr.safe_unsafe(types.boolean, types.uint8)
+
+    tcr.promote_unsafe(types.int8, types.int16)
+    tcr.promote_unsafe(types.uint8, types.uint16)
+
+    tcr.promote_unsafe(types.int16, types.int32)
+    tcr.promote_unsafe(types.uint16, types.uint32)
+
+    tcr.promote_unsafe(types.int32, types.int64)
+    tcr.promote_unsafe(types.uint32, types.uint64)
+
+    tcr.safe_unsafe(types.uint8, types.int16)
+    tcr.safe_unsafe(types.uint16, types.int32)
+    tcr.safe_unsafe(types.uint32, types.int64)
+
+    tcr.safe_unsafe(types.int8, types.float16)
+    tcr.safe_unsafe(types.int16, types.float32)
+    tcr.safe_unsafe(types.int32, types.float64)
+
+    tcr.unsafe_unsafe(types.int16, types.float16)
+    tcr.unsafe_unsafe(types.int32, types.float32)
+    # XXX this is inconsistent with the above; but we want to prefer
+    # float64 over int64 when typing a heterogeneous operation,
+    # e.g. `float64 + int64`.  Perhaps we need more granularity in the
+    # conversion kinds.
+    tcr.safe_unsafe(types.int64, types.float64)
+    tcr.safe_unsafe(types.uint64, types.float64)
+
+    tcr.promote_unsafe(types.float16, types.float32)
+    tcr.promote_unsafe(types.float32, types.float64)
+
+    tcr.safe(types.float32, types.complex64)
+    tcr.safe(types.float64, types.complex128)
+
+    tcr.promote_unsafe(types.complex64, types.complex128)
+
+    # Allow integers to cast ot void*
+    tcr.unsafe_unsafe(types.uintp, types.voidptr)
+
+    return tcr
+
+
+default_casting_rules = _init_casting_rules(default_type_manager)

numba_cuda/numba/cuda/typeconv/typeconv.py

@@ -0,0 +1,121 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+from numba.cuda.cext import _typeconv
+from numba.cuda.typeconv import castgraph, Conversion
+from numba.cuda import types
+
+
+class TypeManager(object):
+    # The character codes used by the C/C++ API (_typeconv.cpp)
+    _conversion_codes = {
+        Conversion.safe: ord("s"),
+        Conversion.unsafe: ord("u"),
+        Conversion.promote: ord("p"),
+    }
+
+    def __init__(self):
+        self._ptr = _typeconv.new_type_manager()
+        self._types = set()
+
+    def select_overload(
+        self, sig, overloads, allow_unsafe, exact_match_required
+    ):
+        sig = [t._code for t in sig]
+        overloads = [[t._code for t in s] for s in overloads]
+        return _typeconv.select_overload(
+            self._ptr, sig, overloads, allow_unsafe, exact_match_required
+        )
+
+    def check_compatible(self, fromty, toty):
+        if not isinstance(toty, types.Type):
+            raise ValueError(
+                "Specified type '%s' (%s) is not a Numba type"
+                % (toty, type(toty))
+            )
+        name = _typeconv.check_compatible(self._ptr, fromty._code, toty._code)
+        conv = Conversion[name] if name is not None else None
+        assert conv is not Conversion.nil
+        return conv
+
+    def set_compatible(self, fromty, toty, by):
+        code = self._conversion_codes[by]
+        _typeconv.set_compatible(self._ptr, fromty._code, toty._code, code)
+        # Ensure the types don't die, otherwise they may be recreated with
+        # other type codes and pollute the hash table.
+        self._types.add(fromty)
+        self._types.add(toty)
+
+    def set_promote(self, fromty, toty):
+        self.set_compatible(fromty, toty, Conversion.promote)
+
+    def set_unsafe_convert(self, fromty, toty):
+        self.set_compatible(fromty, toty, Conversion.unsafe)
+
+    def set_safe_convert(self, fromty, toty):
+        self.set_compatible(fromty, toty, Conversion.safe)
+
+    def get_pointer(self):
+        return _typeconv.get_pointer(self._ptr)
+
+
+class TypeCastingRules(object):
+    """
+    A helper for establishing type casting rules.
+    """
+
+    def __init__(self, tm):
+        self._tm = tm
+        self._tg = castgraph.TypeGraph(self._cb_update)
+
+    def promote(self, a, b):
+        """
+        Set `a` can promote to `b`
+        """
+        self._tg.promote(a, b)
+
+    def unsafe(self, a, b):
+        """
+        Set `a` can unsafe convert to `b`
+        """
+        self._tg.unsafe(a, b)
+
+    def safe(self, a, b):
+        """
+        Set `a` can safe convert to `b`
+        """
+        self._tg.safe(a, b)
+
+    def promote_unsafe(self, a, b):
+        """
+        Set `a` can promote to `b` and `b` can unsafe convert to `a`
+        """
+        self.promote(a, b)
+        self.unsafe(b, a)
+
+    def safe_unsafe(self, a, b):
+        """
+        Set `a` can safe convert to `b` and `b` can unsafe convert to `a`
+        """
+        self._tg.safe(a, b)
+        self._tg.unsafe(b, a)
+
+    def unsafe_unsafe(self, a, b):
+        """
+        Set `a` can unsafe convert to `b` and `b` can unsafe convert to `a`
+        """
+        self._tg.unsafe(a, b)
+        self._tg.unsafe(b, a)
+
+    def _cb_update(self, a, b, rel):
+        """
+        Callback for updating.
+        """
+        if rel == Conversion.promote:
+            self._tm.set_promote(a, b)
+        elif rel == Conversion.safe:
+            self._tm.set_safe_convert(a, b)
+        elif rel == Conversion.unsafe:
+            self._tm.set_unsafe_convert(a, b)
+        else:
+            raise AssertionError(rel)

numba_cuda/numba/cuda/types/__init__.py

@@ -0,0 +1,233 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+import struct
+
+import numpy as np
+from numba.cuda import utils
+
+from .abstract import *
+from .containers import *
+from .functions import *
+from .iterators import *
+from .misc import *
+from .npytypes import *
+from .scalars import *
+from .function_type import *
+from .ext_types import bfloat16, dim3, grid_group, GridGroup, Dim3
+
+numpy_version = tuple(map(int, np.__version__.split(".")[:2]))
+
+# Short names
+
+pyobject = PyObject("pyobject")
+ffi_forced_object = Opaque("ffi_forced_object")
+ffi = Opaque("ffi")
+none = NoneType("none")
+ellipsis = EllipsisType("...")
+Any = Phantom("any")
+undefined = Undefined("undefined")
+py2_string_type = Opaque("str")
+unicode_type = UnicodeType("unicode_type")
+string = unicode_type
+unknown = Dummy("unknown")
+npy_rng = NumPyRandomGeneratorType("rng")
+npy_bitgen = NumPyRandomBitGeneratorType("bitgen")
+
+# _undef_var is used to represent undefined variables in the type system.
+_undef_var = UndefVar("_undef_var")
+
+code_type = Opaque("code")
+pyfunc_type = Opaque("pyfunc")
+
+# No operation is defined on voidptr
+# Can only pass it around
+voidptr = RawPointer("void*")
+
+# optional types
+optional = Optional
+deferred_type = DeferredType
+slice2_type = SliceType("slice<a:b>", 2)
+slice3_type = SliceType("slice<a:b:c>", 3)
+void = none
+
+# Need to ignore mypy errors because mypy cannot unify types for both
+# the type systems even if they're logically mutually exclusive.
+# mypy: ignore-errors
+
+boolean = bool_ = Boolean("bool")
+if numpy_version >= (2, 0):
+    bool = bool_
+
+byte = uint8 = Integer("uint8")
+uint16 = Integer("uint16")
+uint32 = Integer("uint32")
+uint64 = Integer("uint64")
+
+int8 = Integer("int8")
+int16 = Integer("int16")
+int32 = Integer("int32")
+int64 = Integer("int64")
+intp = int32 if utils.MACHINE_BITS == 32 else int64
+uintp = uint32 if utils.MACHINE_BITS == 32 else uint64
+intc = int32 if struct.calcsize("i") == 4 else int64
+uintc = uint32 if struct.calcsize("I") == 4 else uint64
+ssize_t = int32 if struct.calcsize("n") == 4 else int64
+size_t = uint32 if struct.calcsize("N") == 4 else uint64
+
+float32 = Float("float32")
+float64 = Float("float64")
+float16 = Float("float16")
+
+complex64 = Complex("complex64", float32)
+complex128 = Complex("complex128", float64)
+
+range_iter32_type = RangeIteratorType(int32)
+range_iter64_type = RangeIteratorType(int64)
+unsigned_range_iter64_type = RangeIteratorType(uint64)
+range_state32_type = RangeType(int32)
+range_state64_type = RangeType(int64)
+unsigned_range_state64_type = RangeType(uint64)
+
+signed_domain = frozenset([int8, int16, int32, int64])
+unsigned_domain = frozenset([uint8, uint16, uint32, uint64])
+integer_domain = signed_domain | unsigned_domain
+real_domain = frozenset([float32, float64])
+complex_domain = frozenset([complex64, complex128])
+number_domain = real_domain | integer_domain | complex_domain
+
+# Integer Aliases
+c_bool = py_bool = np_bool_ = boolean
+
+c_uint8 = np_uint8 = uint8
+c_uint16 = np_uint16 = uint16
+c_uint32 = np_uint32 = uint32
+c_uint64 = np_uint64 = uint64
+c_uintp = np_uintp = uintp
+
+c_int8 = np_int8 = int8
+c_int16 = np_int16 = int16
+c_int32 = np_int32 = int32
+c_int64 = np_int64 = int64
+c_intp = py_int = np_intp = intp
+
+c_float16 = np_float16 = float16
+c_float32 = np_float32 = float32
+c_float64 = py_float = np_float64 = float64
+
+np_complex64 = complex64
+py_complex = np_complex128 = complex128
+
+# Domain Aliases
+py_signed_domain = np_signed_domain = signed_domain
+np_unsigned_domain = unsigned_domain
+py_integer_domain = np_integer_domain = integer_domain
+py_real_domain = np_real_domain = real_domain
+py_complex_domain = np_complex_domain = complex_domain
+py_number_domain = np_number_domain = number_domain
+
+# Aliases to NumPy type names
+
+b1 = bool_
+i1 = int8
+i2 = int16
+i4 = int32
+i8 = int64
+u1 = uint8
+u2 = uint16
+u4 = uint32
+u8 = uint64
+
+f2 = float16
+f4 = float32
+f8 = float64
+
+c8 = complex64
+c16 = complex128
+
+np_float_ = float32
+np_double = double = float64
+if numpy_version < (2, 0):
+    float_ = float32
+
+_make_signed = lambda x: globals()["int%d" % (np.dtype(x).itemsize * 8)]
+_make_unsigned = lambda x: globals()["uint%d" % (np.dtype(x).itemsize * 8)]
+
+char = np_char = _make_signed(np.byte)
+uchar = np_uchar = byte = _make_unsigned(np.byte)
+short = np_short = _make_signed(np.short)
+ushort = np_ushort = _make_unsigned(np.short)
+int_ = np_int_ = _make_signed(np.int_)
+uint = np_uint = _make_unsigned(np.int_)
+intc = np_intc = _make_signed(np.intc)  # C-compat int
+uintc = np_uintc = _make_unsigned(np.uintc)  # C-compat uint
+long_ = np_long = _make_signed(np.int_)  # C-compat long
+ulong = np_ulong = _make_unsigned(np.int_)  # C-compat ulong
+longlong = np_longlong = _make_signed(np.longlong)
+ulonglong = np_ulonglong = _make_unsigned(np.longlong)
+
+all_str = """
+    int8
+    int16
+    int32
+    int64
+    uint8
+    uint16
+    uint32
+    uint64
+    intp
+    uintp
+    intc
+    uintc
+    ssize_t
+    size_t
+    boolean
+    float32
+    float64
+    complex64
+    complex128
+    bool_
+    byte
+    char
+    uchar
+    short
+    ushort
+    int_
+    uint
+    long_
+    ulong
+    longlong
+    ulonglong
+    float_
+    double
+    void
+    none
+    b1
+    i1
+    i2
+    i4
+    i8
+    u1
+    u2
+    u4
+    u8
+    f4
+    f8
+    c8
+    c16
+    optional
+    ffi_forced_object
+    ffi
+    deferred_type
+    bfloat16
+    dim3
+    grid_group
+    Dim3
+    GridGroup
+"""
+
+
+__all__ = all_str.split()
+if numpy_version >= (2, 0):
+    __all__.remove("float_")
+    __all__.append("bool")