numba-cuda 0.8.0__py3-none-any.whl → 0.9.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

@@ -4,4 +4,4 @@ Added for symmetry with the core API
 
 from numba.core.extending import intrinsic as _intrinsic
 
-intrinsic = _intrinsic(target='cuda')
+intrinsic = _intrinsic(target="cuda")

numba_cuda/numba/cuda/initialize.py

@@ -4,9 +4,11 @@ def initialize_all():
 
     from numba.cuda.decorators import jit
     from numba.cuda.dispatcher import CUDADispatcher
-    from numba.core.target_extension import (target_registry,
-                                             dispatcher_registry,
-                                             jit_registry)
+    from numba.core.target_extension import (
+        target_registry,
+        dispatcher_registry,
+        jit_registry,
+    )
 
     cuda_target = target_registry["cuda"]
     jit_registry[cuda_target] = jit

numba_cuda/numba/cuda/intrinsic_wrapper.py

@@ -45,7 +45,7 @@ def shfl_sync(mask, value, src_lane):
     from src_lane. If this is outside the warp, then the
     given value is returned.
     """
-    return numba.cuda.shfl_sync_intrinsic(mask, 0, value, src_lane, 0x1f)[0]
+    return numba.cuda.shfl_sync_intrinsic(mask, 0, value, src_lane, 0x1F)[0]
 
 
 @jit(device=True)
@@ -65,7 +65,7 @@ def shfl_down_sync(mask, value, delta):
     from (laneid + delta). If this is outside the warp, then the
     given value is returned.
     """
-    return numba.cuda.shfl_sync_intrinsic(mask, 2, value, delta, 0x1f)[0]
+    return numba.cuda.shfl_sync_intrinsic(mask, 2, value, delta, 0x1F)[0]
 
 
 @jit(device=True)
@@ -74,4 +74,4 @@ def shfl_xor_sync(mask, value, lane_mask):
     Shuffles value across the masked warp and returns the value
     from (laneid ^ lane_mask).
     """
-    return numba.cuda.shfl_sync_intrinsic(mask, 3, value, lane_mask, 0x1f)[0]
+    return numba.cuda.shfl_sync_intrinsic(mask, 3, value, lane_mask, 0x1F)[0]

numba_cuda/numba/cuda/intrinsics.py

@@ -9,9 +9,10 @@ from numba.cuda import nvvmutils
 from numba.cuda.extending import intrinsic
 
 
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 # Grid functions
 
+
 def _type_grid_function(ndim):
     val = ndim.literal_value
     if val == 1:
@@ -19,14 +20,14 @@ def _type_grid_function(ndim):
     elif val in (2, 3):
         restype = types.UniTuple(types.int64, val)
     else:
-        raise ValueError('argument can only be 1, 2, 3')
+        raise ValueError("argument can only be 1, 2, 3")
 
     return signature(restype, types.int32)
 
 
 @intrinsic
 def grid(typingctx, ndim):
-    '''grid(ndim)
+    """grid(ndim)
 
     Return the absolute position of the current thread in the entire grid of
     blocks.  *ndim* should correspond to the number of dimensions declared when
@@ -39,7 +40,7 @@ def grid(typingctx, ndim):
 
     and is similar for the other two indices, but using the ``y`` and ``z``
     attributes.
-    '''
+    """
 
     if not isinstance(ndim, types.IntegerLiteral):
         raise RequireLiteralValue(ndim)
@@ -59,7 +60,7 @@ def grid(typingctx, ndim):
 
 @intrinsic
 def gridsize(typingctx, ndim):
-    '''gridsize(ndim)
+    """gridsize(ndim)
 
     Return the absolute size (or shape) in threads of the entire grid of
     blocks. *ndim* should correspond to the number of dimensions declared when
@@ -72,7 +73,7 @@ def gridsize(typingctx, ndim):
 
     and is similar for the other two indices, but using the ``y`` and ``z``
     attributes.
-    '''
+    """
 
     if not isinstance(ndim, types.IntegerLiteral):
         raise RequireLiteralValue(ndim)
@@ -87,17 +88,17 @@ def gridsize(typingctx, ndim):
 
     def codegen(context, builder, sig, args):
         restype = sig.return_type
-        nx = _nthreads_for_dim(builder, 'x')
+        nx = _nthreads_for_dim(builder, "x")
 
         if restype == types.int64:
             return nx
         elif isinstance(restype, types.UniTuple):
-            ny = _nthreads_for_dim(builder, 'y')
+            ny = _nthreads_for_dim(builder, "y")
 
             if restype.count == 2:
                 return cgutils.pack_array(builder, (nx, ny))
             elif restype.count == 3:
-                nz = _nthreads_for_dim(builder, 'z')
+                nz = _nthreads_for_dim(builder, "z")
                 return cgutils.pack_array(builder, (nx, ny, nz))
 
     return sig, codegen
@@ -108,37 +109,40 @@ def _warpsize(typingctx):
     sig = signature(types.int32)
 
     def codegen(context, builder, sig, args):
-        return nvvmutils.call_sreg(builder, 'warpsize')
+        return nvvmutils.call_sreg(builder, "warpsize")
 
     return sig, codegen
 
 
-@overload_attribute(types.Module(cuda), 'warpsize', target='cuda')
+@overload_attribute(types.Module(cuda), "warpsize", target="cuda")
 def cuda_warpsize(mod):
-    '''
+    """
     The size of a warp. All architectures implemented to date have a warp size
     of 32.
-    '''
+    """
+
     def get(mod):
         return _warpsize()
+
     return get
 
 
-#-------------------------------------------------------------------------------
+# -------------------------------------------------------------------------------
 # syncthreads
 
+
 @intrinsic
 def syncthreads(typingctx):
-    '''
+    """
     Synchronize all threads in the same thread block.  This function implements
     the same pattern as barriers in traditional multi-threaded programming: this
     function waits until all threads in the block call it, at which point it
     returns control to all its callers.
-    '''
+    """
     sig = signature(types.none)
 
     def codegen(context, builder, sig, args):
-        fname = 'llvm.nvvm.barrier0'
+        fname = "llvm.nvvm.barrier0"
         lmod = builder.module
         fnty = ir.FunctionType(ir.VoidType(), ())
         sync = cgutils.get_or_insert_function(lmod, fnty, fname)
@@ -164,40 +168,40 @@ def _syncthreads_predicate(typingctx, predicate, fname):
 
 @intrinsic
 def syncthreads_count(typingctx, predicate):
-    '''
+    """
     syncthreads_count(predicate)
 
     An extension to numba.cuda.syncthreads where the return value is a count
     of the threads where predicate is true.
-    '''
-    fname = 'llvm.nvvm.barrier0.popc'
+    """
+    fname = "llvm.nvvm.barrier0.popc"
     return _syncthreads_predicate(typingctx, predicate, fname)
 
 
 @intrinsic
 def syncthreads_and(typingctx, predicate):
-    '''
+    """
     syncthreads_and(predicate)
 
     An extension to numba.cuda.syncthreads where 1 is returned if predicate is
     true for all threads or 0 otherwise.
-    '''
-    fname = 'llvm.nvvm.barrier0.and'
+    """
+    fname = "llvm.nvvm.barrier0.and"
     return _syncthreads_predicate(typingctx, predicate, fname)
 
 
 @intrinsic
 def syncthreads_or(typingctx, predicate):
-    '''
+    """
     syncthreads_or(predicate)
 
     An extension to numba.cuda.syncthreads where 1 is returned if predicate is
     true for any thread or 0 otherwise.
-    '''
-    fname = 'llvm.nvvm.barrier0.or'
+    """
+    fname = "llvm.nvvm.barrier0.or"
     return _syncthreads_predicate(typingctx, predicate, fname)
 
 
-@overload_method(types.Integer, 'bit_count', target='cuda')
+@overload_method(types.Integer, "bit_count", target="cuda")
 def integer_bit_count(i):
     return lambda i: cuda.popc(i)

numba_cuda/numba/cuda/kernels/reduction.py

@@ -13,7 +13,7 @@ def _gpu_reduce_factory(fn, nbtype):
     from numba import cuda
 
     reduce_op = cuda.jit(device=True)(fn)
-    inner_sm_size = _WARPSIZE + 1   # plus one to avoid SM collision
+    inner_sm_size = _WARPSIZE + 1  # plus one to avoid SM collision
     max_blocksize = _NUMWARPS * _WARPSIZE
 
     @cuda.jit(device=True)
@@ -86,8 +86,9 @@ def _gpu_reduce_factory(fn, nbtype):
         # warning: this is assuming 4 warps.
         # assert numwarps == 4
         if tid < 2:
-            sm_partials[tid, 0] = reduce_op(sm_partials[tid, 0],
-                                            sm_partials[tid + 2, 0])
+            sm_partials[tid, 0] = reduce_op(
+                sm_partials[tid, 0], sm_partials[tid + 2, 0]
+            )
             cuda.syncwarp()
         if tid == 0:
             partials[blkid] = reduce_op(sm_partials[0, 0], sm_partials[1, 0])
@@ -148,8 +149,9 @@ def _gpu_reduce_factory(fn, nbtype):
         """
         tid = cuda.threadIdx.x
 
-        sm_partials = cuda.shared.array((_NUMWARPS, inner_sm_size),
-                                        dtype=nbtype)
+        sm_partials = cuda.shared.array(
+            (_NUMWARPS, inner_sm_size), dtype=nbtype
+        )
         if cuda.blockDim.x == max_blocksize:
             device_reduce_full_block(arr, partials, sm_partials)
         else:
@@ -238,17 +240,15 @@ class Reduce(object):
 
         if size_full:
             # kernel for the fully populated threadblocks
-            kernel[full_blockct, blocksize, stream](arr[:size_full],
-                                                    partials[:full_blockct],
-                                                    init,
-                                                    True)
+            kernel[full_blockct, blocksize, stream](
+                arr[:size_full], partials[:full_blockct], init, True
+            )
 
         if size_partial:
             # kernel for partially populated threadblocks
-            kernel[1, size_partial, stream](arr[size_full:],
-                                            partials[full_blockct:],
-                                            init,
-                                            not full_blockct)
+            kernel[1, size_partial, stream](
+                arr[size_full:], partials[full_blockct:], init, not full_blockct
+            )
 
         if partials.size > 1:
             # finish up

numba_cuda/numba/cuda/kernels/transpose.py

@@ -18,16 +18,14 @@ def transpose(a, b=None):
     """
 
     # prefer `a`'s stream if
-    stream = getattr(a, 'stream', 0)
+    stream = getattr(a, "stream", 0)
 
     if not b:
         cols, rows = a.shape
         strides = a.dtype.itemsize * cols, a.dtype.itemsize
         b = cuda.cudadrv.devicearray.DeviceNDArray(
-            (rows, cols),
-            strides,
-            dtype=a.dtype,
-            stream=stream)
+            (rows, cols), strides, dtype=a.dtype, stream=stream
+        )
 
     dt = nps.from_dtype(a.dtype)
 
@@ -40,7 +38,6 @@ def transpose(a, b=None):
 
     @cuda.jit
     def kernel(input, output):
-
         tile = cuda.shared.array(shape=tile_shape, dtype=dt)
 
         tx = cuda.threadIdx.x