numba-cuda 0.8.1__py3-none-any.whl → 0.10.0__py3-none-any.whl

numba_cuda/numba/cuda/errors.py

@@ -7,8 +7,7 @@ class KernelRuntimeError(RuntimeError):
         self.tid = tid
         self.ctaid = ctaid
         self.msg = msg
-        t = ("An exception was raised in thread=%s block=%s\n"
-             "\t%s")
+        t = "An exception was raised in thread=%s block=%s\n\t%s"
         msg = t % (self.tid, self.ctaid, self.msg)
         super(KernelRuntimeError, self).__init__(msg)
 
@@ -17,8 +16,9 @@ class CudaLoweringError(LoweringError):
     pass
 
 
-_launch_help_url = ("https://numba.readthedocs.io/en/stable/cuda/"
-                    "kernels.html#kernel-invocation")
+_launch_help_url = (
+    "https://numba.readthedocs.io/en/stable/cuda/kernels.html#kernel-invocation"
+)
 missing_launch_config_msg = """
 Kernel launch configuration was not specified. Use the syntax:
 
@@ -40,12 +40,15 @@ def normalize_kernel_dimensions(griddim, blockdim):
         else:
             dim = list(dim)
         if len(dim) > 3:
-            raise ValueError('%s must be a sequence of 1, 2 or 3 integers, '
-                             'got %r' % (name, dim))
+            raise ValueError(
+                "%s must be a sequence of 1, 2 or 3 integers, "
+                "got %r" % (name, dim)
+            )
         for v in dim:
             if not isinstance(v, numbers.Integral):
-                raise TypeError('%s must be a sequence of integers, got %r'
-                                % (name, dim))
+                raise TypeError(
+                    "%s must be a sequence of integers, got %r" % (name, dim)
+                )
         while len(dim) < 3:
             dim.append(1)
         return tuple(dim)
@@ -53,7 +56,7 @@ def normalize_kernel_dimensions(griddim, blockdim):
     if None in (griddim, blockdim):
         raise ValueError(missing_launch_config_msg)
 
-    griddim = check_dim(griddim, 'griddim')
-    blockdim = check_dim(blockdim, 'blockdim')
+    griddim = check_dim(griddim, "griddim")
+    blockdim = check_dim(blockdim, "blockdim")
 
     return griddim, blockdim

numba_cuda/numba/cuda/extending.py

@@ -3,5 +3,59 @@ Added for symmetry with the core API
 """
 
 from numba.core.extending import intrinsic as _intrinsic
+from numba.cuda.models import register_model  # noqa: F401
+from numba.cuda import models  # noqa: F401
 
-intrinsic = _intrinsic(target='cuda')
+intrinsic = _intrinsic(target="cuda")
+
+
+def make_attribute_wrapper(typeclass, struct_attr, python_attr):
+    """
+    Make an automatic attribute wrapper exposing member named *struct_attr*
+    as a read-only attribute named *python_attr*.
+    The given *typeclass*'s model must be a StructModel subclass.
+
+    Vendored from numba.core.extending with a change to consider the CUDA data
+    model manager.
+    """
+    from numba.core.typing.templates import AttributeTemplate
+
+    from numba.core.datamodel import default_manager
+    from numba.core.datamodel.models import StructModel
+    from numba.core.imputils import impl_ret_borrowed
+    from numba.core import cgutils, types
+
+    from numba.cuda.models import cuda_data_manager
+    from numba.cuda.cudadecl import registry as cuda_registry
+    from numba.cuda.cudaimpl import registry as cuda_impl_registry
+
+    data_model_manager = cuda_data_manager.chain(default_manager)
+
+    if not isinstance(typeclass, type) or not issubclass(typeclass, types.Type):
+        raise TypeError(f"typeclass should be a Type subclass, got {typeclass}")
+
+    def get_attr_fe_type(typ):
+        """
+        Get the Numba type of member *struct_attr* in *typ*.
+        """
+        model = data_model_manager.lookup(typ)
+        if not isinstance(model, StructModel):
+            raise TypeError(
+                f"make_attribute_wrapper() needs a type with a StructModel, but got {model}"
+            )
+        return model.get_member_fe_type(struct_attr)
+
+    @cuda_registry.register_attr
+    class StructAttribute(AttributeTemplate):
+        key = typeclass
+
+        def generic_resolve(self, typ, attr):
+            if attr == python_attr:
+                return get_attr_fe_type(typ)
+
+    @cuda_impl_registry.lower_getattr(typeclass, python_attr)
+    def struct_getattr_impl(context, builder, typ, val):
+        val = cgutils.create_struct_proxy(typ)(context, builder, value=val)
+        attrty = get_attr_fe_type(typ)
+        attrval = getattr(val, struct_attr)
+        return impl_ret_borrowed(context, builder, attrty, attrval)