numba-cuda 0.21.1__cp313-cp313-win_amd64.whl

numba_cuda/numba/cuda/core/unsafe/bytes.py

@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+"""
+This file provides internal compiler utilities that support certain special
+operations with bytes and workarounds for limitations enforced in userland.
+"""
+
+from numba.cuda.extending import intrinsic
+from llvmlite import ir
+from numba.cuda import types
+from numba.cuda import cgutils
+
+
+@intrinsic
+def grab_byte(typingctx, data, offset):
+    # returns a byte at a given offset in data
+    def impl(context, builder, signature, args):
+        data, idx = args
+        ptr = builder.bitcast(data, ir.IntType(8).as_pointer())
+        ch = builder.load(builder.gep(ptr, [idx]))
+        return ch
+
+    sig = types.uint8(types.voidptr, types.intp)
+    return sig, impl
+
+
+@intrinsic
+def grab_uint64_t(typingctx, data, offset):
+    # returns a uint64_t at a given offset in data
+    def impl(context, builder, signature, args):
+        data, idx = args
+        ptr = builder.bitcast(data, ir.IntType(64).as_pointer())
+        ch = builder.load(builder.gep(ptr, [idx]))
+        return ch
+
+    sig = types.uint64(types.voidptr, types.intp)
+    return sig, impl
+
+
+@intrinsic
+def memcpy_region(typingctx, dst, dst_offset, src, src_offset, nbytes, align):
+    """Copy nbytes from *(src + src_offset) to *(dst + dst_offset)"""
+
+    def codegen(context, builder, signature, args):
+        [
+            dst_val,
+            dst_offset_val,
+            src_val,
+            src_offset_val,
+            nbytes_val,
+            align_val,
+        ] = args
+        src_ptr = builder.gep(src_val, [src_offset_val])
+        dst_ptr = builder.gep(dst_val, [dst_offset_val])
+        cgutils.raw_memcpy(builder, dst_ptr, src_ptr, nbytes_val, align_val)
+        return context.get_dummy_value()
+
+    sig = types.void(
+        types.voidptr,
+        types.intp,
+        types.voidptr,
+        types.intp,
+        types.intp,
+        types.intp,
+    )
+    return sig, codegen

numba_cuda/numba/cuda/core/unsafe/eh.py

@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+"""
+Exception handling intrinsics.
+"""
+
+from numba.cuda import types
+from numba.cuda.core import errors
+from numba.cuda import cgutils
+from numba.cuda.extending import intrinsic
+
+
+@intrinsic
+def exception_check(typingctx):
+    """An intrinsic to check if an exception is raised"""
+
+    def codegen(context, builder, signature, args):
+        nrt = context.nrt
+        return nrt.eh_check(builder)
+
+    restype = types.boolean
+    return restype(), codegen
+
+
+@intrinsic
+def mark_try_block(typingctx):
+    """An intrinsic to mark the start of a *try* block."""
+
+    def codegen(context, builder, signature, args):
+        nrt = context.nrt
+        nrt.eh_try(builder)
+        return context.get_dummy_value()
+
+    restype = types.none
+    return restype(), codegen
+
+
+@intrinsic
+def end_try_block(typingctx):
+    """An intrinsic to mark the end of a *try* block."""
+
+    def codegen(context, builder, signature, args):
+        nrt = context.nrt
+        nrt.eh_end_try(builder)
+        return context.get_dummy_value()
+
+    restype = types.none
+    return restype(), codegen
+
+
+@intrinsic
+def exception_match(typingctx, exc_value, exc_class):
+    """Basically do ``isinstance(exc_value, exc_class)`` for exception objects.
+    Used in ``except Exception:`` syntax.
+    """
+    # Check for our limitation
+    if exc_class.exc_class is not Exception:
+        msg = "Exception matching is limited to {}"
+        raise errors.UnsupportedError(msg.format(Exception))
+
+    def codegen(context, builder, signature, args):
+        # Intentionally always True.
+        return cgutils.true_bit
+
+    restype = types.boolean
+    return restype(exc_value, exc_class), codegen

numba_cuda/numba/cuda/core/unsafe/refcount.py

@@ -0,0 +1,98 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: BSD-2-Clause
+
+"""
+Helpers to see the refcount information of an object
+"""
+
+from llvmlite import ir
+
+from numba.cuda import types
+from numba.cuda import cgutils
+from numba.cuda.extending import intrinsic
+
+_word_type = ir.IntType(64)
+_pointer_type = ir.PointerType(ir.IntType(8))
+
+_meminfo_struct_type = ir.LiteralStructType(
+    [
+        _word_type,  # size_t refct
+        _pointer_type,  # dtor_function dtor
+        _pointer_type,  # void *dtor_info
+        _pointer_type,  # void *data
+        _word_type,  # size_t size
+    ]
+)
+
+
+@intrinsic
+def dump_refcount(typingctx, obj):
+    """Dump the refcount of an object to stdout.
+
+    Returns True if and only if object is reference-counted and NRT is enabled.
+    """
+
+    def codegen(context, builder, signature, args):
+        [obj] = args
+        [ty] = signature.args
+        # A sequence of (type, meminfo)
+        meminfos = []
+        if context.enable_nrt:
+            tmp_mis = context.nrt.get_meminfos(builder, ty, obj)
+            meminfos.extend(tmp_mis)
+
+        if meminfos:
+            pyapi = context.get_python_api(builder)
+            gil_state = pyapi.gil_ensure()
+            pyapi.print_string("dump refct of {}".format(ty))
+            for ty, mi in meminfos:
+                miptr = builder.bitcast(mi, _meminfo_struct_type.as_pointer())
+                refctptr = cgutils.gep_inbounds(builder, miptr, 0, 0)
+                refct = builder.load(refctptr)
+
+                pyapi.print_string(" | {} refct=".format(ty))
+                # "%zu" is not portable.  just truncate refcount to 32-bit.
+                # that's good enough for a debugging util.
+                refct_32bit = builder.trunc(refct, ir.IntType(32))
+                printed = cgutils.snprintf_stackbuffer(
+                    builder, 30, "%d [%p]", refct_32bit, miptr
+                )
+                pyapi.sys_write_stdout(printed)
+
+            pyapi.print_string(";\n")
+            pyapi.gil_release(gil_state)
+            return cgutils.true_bit
+        else:
+            return cgutils.false_bit
+
+    sig = types.bool_(obj)
+    return sig, codegen
+
+
+@intrinsic
+def get_refcount(typingctx, obj):
+    """Get the current refcount of an object.
+
+    FIXME: only handles the first object
+    """
+
+    def codegen(context, builder, signature, args):
+        [obj] = args
+        [ty] = signature.args
+        # A sequence of (type, meminfo)
+        meminfos = []
+        if context.enable_nrt:
+            tmp_mis = context.nrt.get_meminfos(builder, ty, obj)
+            meminfos.extend(tmp_mis)
+        refcounts = []
+        if meminfos:
+            for ty, mi in meminfos:
+                miptr = builder.bitcast(mi, _meminfo_struct_type.as_pointer())
+                refctptr = cgutils.gep_inbounds(builder, miptr, 0, 0)
+                refct = builder.load(refctptr)
+                refct_32bit = builder.trunc(refct, ir.IntType(32))
+                refcounts.append(refct_32bit)
+        return refcounts[0]
+
+    sig = types.int32(obj)
+    return sig, codegen