numba-cuda 0.8.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

numba_cuda/numba/cuda/simulator/kernel.py

@@ -41,9 +41,10 @@ def _get_kernel_context():
 
 
 class FakeOverload:
-    '''
+    """
     Used only to provide the max_cooperative_grid_blocks method
-    '''
+    """
+
     def max_cooperative_grid_blocks(self, blockdim):
         # We can only run one block in a cooperative grid because we have no
         # mechanism for synchronization between different blocks
@@ -58,16 +59,16 @@ class FakeOverloadDict(dict):
 
 
 class FakeCUDAKernel(object):
-    '''
+    """
     Wraps a @cuda.jit-ed function.
-    '''
+    """
 
     def __init__(self, fn, device, fastmath=False, extensions=[], debug=False):
         self.fn = fn
         self._device = device
         self._fastmath = fastmath
         self._debug = debug
-        self.extensions = list(extensions) # defensive copy
+        self.extensions = list(extensions)  # defensive copy
         # Initial configuration: grid unconfigured, stream 0, no dynamic shared
         # memory.
         self.grid_dim = None
@@ -82,11 +83,13 @@ class FakeCUDAKernel(object):
                 return self.fn(*args)
 
         # Ensure we've been given a valid grid configuration
-        grid_dim, block_dim = normalize_kernel_dimensions(self.grid_dim,
-                                                          self.block_dim)
+        grid_dim, block_dim = normalize_kernel_dimensions(
+            self.grid_dim, self.block_dim
+        )
 
-        fake_cuda_module = FakeCUDAModule(grid_dim, block_dim,
-                                          self.dynshared_size)
+        fake_cuda_module = FakeCUDAModule(
+            grid_dim, block_dim, self.dynshared_size
+        )
         with _push_kernel_context(fake_cuda_module):
             # fake_args substitutes all numpy arrays for FakeCUDAArrays
             # because they implement some semantics differently
@@ -96,11 +99,10 @@ class FakeCUDAKernel(object):
                 # map the arguments using any extension you've registered
                 _, arg = functools.reduce(
                     lambda ty_val, extension: extension.prepare_args(
-                        *ty_val,
-                        stream=0,
-                        retr=retr),
+                        *ty_val, stream=0, retr=retr
+                    ),
                     self.extensions,
-                    (None, arg)
+                    (None, arg),
                 )
 
                 if isinstance(arg, np.ndarray) and arg.ndim > 0:
@@ -126,8 +128,9 @@ class FakeCUDAKernel(object):
                 wb()
 
     def __getitem__(self, configuration):
-        self.grid_dim, self.block_dim = \
-            normalize_kernel_dimensions(*configuration[:2])
+        self.grid_dim, self.block_dim = normalize_kernel_dimensions(
+            *configuration[:2]
+        )
 
         if len(configuration) == 4:
             self.dynshared_size = configuration[3]
@@ -142,8 +145,9 @@ class FakeCUDAKernel(object):
 
     def forall(self, ntasks, tpb=0, stream=0, sharedmem=0):
         if ntasks < 0:
-            raise ValueError("Can't create ForAll with negative task count: %s"
-                             % ntasks)
+            raise ValueError(
+                "Can't create ForAll with negative task count: %s" % ntasks
+            )
         return self[ntasks, 1, stream, sharedmem]
 
     @property
@@ -157,15 +161,19 @@ class FakeCUDAKernel(object):
 
 # Thread emulation
 
+
 class BlockThread(threading.Thread):
-    '''
+    """
     Manages the execution of a function for a single CUDA thread.
-    '''
+    """
+
     def __init__(self, f, manager, blockIdx, threadIdx, debug):
         if debug:
+
             def debug_wrapper(*args, **kwargs):
-                np.seterr(divide='raise')
+                np.seterr(divide="raise")
                 f(*args, **kwargs)
+
             target = debug_wrapper
         else:
             target = f
@@ -181,27 +189,26 @@ class BlockThread(threading.Thread):
         self.abort = False
         self.debug = debug
         blockDim = Dim3(*self._manager._block_dim)
-        self.thread_id = self.threadIdx.x + (blockDim.x * (self.threadIdx.y +
-                                                           blockDim.y *
-                                                           self.threadIdx.z))
+        self.thread_id = self.threadIdx.x + (
+            blockDim.x * (self.threadIdx.y + blockDim.y * self.threadIdx.z)
+        )
 
     def run(self):
         try:
             super(BlockThread, self).run()
         except Exception as e:
-            tid = 'tid=%s' % list(self.threadIdx)
-            ctaid = 'ctaid=%s' % list(self.blockIdx)
-            if str(e) == '':
-                msg = '%s %s' % (tid, ctaid)
+            tid = "tid=%s" % list(self.threadIdx)
+            ctaid = "ctaid=%s" % list(self.blockIdx)
+            if str(e) == "":
+                msg = "%s %s" % (tid, ctaid)
             else:
-                msg = '%s %s: %s' % (tid, ctaid, e)
+                msg = "%s %s: %s" % (tid, ctaid, e)
             tb = sys.exc_info()[2]
             # Using `with_traceback` here would cause it to be mutated by
             # future raise statements, which may or may not matter.
             self.exception = (type(e)(msg), tb)
 
     def syncthreads(self):
-
         if self.abort:
             raise RuntimeError("abort flag set on syncthreads call")
 
@@ -237,11 +244,11 @@ class BlockThread(threading.Thread):
         return 1 if test else 0
 
     def __str__(self):
-        return 'Thread <<<%s, %s>>>' % (self.blockIdx, self.threadIdx)
+        return "Thread <<<%s, %s>>>" % (self.blockIdx, self.threadIdx)
 
 
 class BlockManager(object):
-    '''
+    """
     Manages the execution of a thread block.
 
     When run() is called, all threads are started. Each thread executes until it
@@ -257,7 +264,8 @@ class BlockManager(object):
 
     The polling continues until no threads are alive, when execution is
     complete.
-    '''
+    """
+
     def __init__(self, f, grid_dim, block_dim, debug):
         self._grid_dim = grid_dim
         self._block_dim = block_dim
@@ -271,8 +279,10 @@ class BlockManager(object):
         livethreads = set()
         blockedthreads = set()
         for block_point in np.ndindex(*self._block_dim):
+
             def target():
                 self._f(*args)
+
             t = BlockThread(target, self, grid_point, block_point, self._debug)
             t.start()
             threads.add(t)
@@ -286,7 +296,6 @@ class BlockManager(object):
                 if t.syncthreads_blocked:
                     blockedthreads.add(t)
                 elif t.exception:
-
                     # Abort all other simulator threads on exception,
                     # do *not* join immediately to facilitate debugging.
                     for t_other in threads:
@@ -300,7 +309,7 @@ class BlockManager(object):
                     t.syncthreads_blocked = False
                     t.syncthreads_event.set()
                 blockedthreads = set()
-            livethreads = set([ t for t in livethreads if t.is_alive() ])
+            livethreads = set([t for t in livethreads if t.is_alive()])
         # Final check for exceptions in case any were set prior to thread
         # finishing, before we could check it
         for t in threads:

numba_cuda/numba/cuda/simulator/kernelapi.py

@@ -1,7 +1,7 @@
-'''
+"""
 Implements the cuda module as called from within an executing kernel
 (@cuda.jit-decorated function).
-'''
+"""
 
 from contextlib import contextmanager
 import sys
@@ -16,19 +16,20 @@ from .vector_types import vector_types
 
 
 class Dim3(object):
-    '''
+    """
     Used to implement thread/block indices/dimensions
-    '''
+    """
+
     def __init__(self, x, y, z):
         self.x = x
         self.y = y
         self.z = z
 
     def __str__(self):
-        return '(%s, %s, %s)' % (self.x, self.y, self.z)
+        return "(%s, %s, %s)" % (self.x, self.y, self.z)
 
     def __repr__(self):
-        return 'Dim3(%s, %s, %s)' % (self.x, self.y, self.z)
+        return "Dim3(%s, %s, %s)" % (self.x, self.y, self.z)
 
     def __iter__(self):
         yield self.x
@@ -37,9 +38,9 @@ class Dim3(object):
 
 
 class GridGroup:
-    '''
+    """
     Used to implement the grid group.
-    '''
+    """
 
     def sync(self):
         # Synchronization of the grid group is equivalent to synchronization of
@@ -49,17 +50,19 @@ class GridGroup:
 
 
 class FakeCUDACg:
-    '''
+    """
     CUDA Cooperative Groups
-    '''
+    """
+
     def this_grid(self):
         return GridGroup()
 
 
 class FakeCUDALocal(object):
-    '''
+    """
     CUDA Local arrays
-    '''
+    """
+
     def array(self, shape, dtype):
         if isinstance(dtype, types.Type):
             dtype = numpy_support.as_dtype(dtype)
@@ -67,21 +70,23 @@ class FakeCUDALocal(object):
 
 
 class FakeCUDAConst(object):
-    '''
+    """
     CUDA Const arrays
-    '''
+    """
+
     def array_like(self, ary):
         return ary
 
 
 class FakeCUDAShared(object):
-    '''
+    """
     CUDA Shared arrays.
 
     Limitations: assumes that only one call to cuda.shared.array is on a line,
     and that that line is only executed once per thread. i.e.::
 
-        a = cuda.shared.array(...); b = cuda.shared.array(...)
+        a = cuda.shared.array(...)
+        b = cuda.shared.array(...)
 
     will erroneously alias a and b, and::
 
@@ -90,7 +95,7 @@ class FakeCUDAShared(object):
 
     will alias all arrays created at that point (though it is not certain that
     this would be supported by Numba anyway).
-    '''
+    """
 
     def __init__(self, dynshared_size):
         self._allocations = {}
@@ -274,13 +279,13 @@ class FakeCUDAFp16(object):
         return np.exp2(x, dtype=np.float16)
 
     def hexp10(self, x):
-        return np.float16(10 ** x)
+        return np.float16(10**x)
 
     def hsqrt(self, x):
         return np.sqrt(x, dtype=np.float16)
 
     def hrsqrt(self, x):
-        return np.float16(x ** -0.5)
+        return np.float16(x**-0.5)
 
     def hceil(self, x):
         return np.ceil(x, dtype=np.float16)
@@ -323,7 +328,7 @@ class FakeCUDAFp16(object):
 
 
 class FakeCUDAModule(object):
-    '''
+    """
     An instance of this class will be injected into the __globals__ for an
     executing function in order to implement calls to cuda.*. This will fail to
     work correctly if the user code does::
@@ -331,7 +336,7 @@ class FakeCUDAModule(object):
         from numba import cuda as something_else
 
     In other words, the CUDA module must be called cuda.
-    '''
+    """
 
     def __init__(self, grid_dim, block_dim, dynshared_size):
         self.gridDim = Dim3(*grid_dim)
@@ -426,11 +431,11 @@ class FakeCUDAModule(object):
         return a ** (1 / 3)
 
     def brev(self, val):
-        return int('{:032b}'.format(val)[::-1], 2)
+        return int("{:032b}".format(val)[::-1], 2)
 
     def clz(self, val):
-        s = '{:032b}'.format(val)
-        return len(s) - len(s.lstrip('0'))
+        s = "{:032b}".format(val)
+        return len(s) - len(s.lstrip("0"))
 
     def ffs(self, val):
         # The algorithm is:
@@ -438,8 +443,8 @@ class FakeCUDAModule(object):
         # 2. Add 1, because the LSB is numbered 1 rather than 0, and so on.
         # 3. If we've counted 32 zeros (resulting in 33), there were no bits
         #    set so we need to return zero.
-        s = '{:032b}'.format(val)
-        r = (len(s) - len(s.rstrip('0')) + 1) % 33
+        s = "{:032b}".format(val)
+        r = (len(s) - len(s.rstrip("0")) + 1) % 33
         return r
 
     def selp(self, a, b, c):

numba_cuda/numba/cuda/simulator/reduction.py

@@ -9,6 +9,7 @@ def Reduce(func):
             return None
         else:
             return r
+
     return reduce_wrapper
 
 

numba_cuda/numba/cuda/simulator/vector_types.py

@@ -3,7 +3,7 @@ from numba.cuda.stubs import _vector_type_stubs
 
 
 class SimulatedVectorType:
-    attributes = ['x', 'y', 'z', 'w']
+    attributes = ["x", "y", "z", "w"]
 
     def __init__(self, *args):
         args_flattened = []
@@ -12,7 +12,7 @@ class SimulatedVectorType:
                 args_flattened += arg.as_list()
             else:
                 args_flattened.append(arg)
-        self._attrs = self.attributes[:len(args_flattened)]
+        self._attrs = self.attributes[: len(args_flattened)]
         if not self.num_elements == len(args_flattened):
             raise TypeError(
                 f"{self.name} expects {self.num_elements}"
@@ -35,11 +35,15 @@ class SimulatedVectorType:
 
 
 def make_simulated_vector_type(num_elements, name):
-    obj = type(name, (SimulatedVectorType,), {
-        "num_elements": num_elements,
-        "base_type": types.float32,
-        "name": name
-    })
+    obj = type(
+        name,
+        (SimulatedVectorType,),
+        {
+            "num_elements": num_elements,
+            "base_type": types.float32,
+            "name": name,
+        },
+    )
     obj.user_facing_object = obj
     return obj
 
@@ -48,8 +52,8 @@ def _initialize():
     _simulated_vector_types = {}
     for stub in _vector_type_stubs:
         num_elements = int(stub.__name__[-1])
-        _simulated_vector_types[stub.__name__] = (
-            make_simulated_vector_type(num_elements, stub.__name__)
+        _simulated_vector_types[stub.__name__] = make_simulated_vector_type(
+            num_elements, stub.__name__
         )
         _simulated_vector_types[stub.__name__].aliases = stub.aliases
     return _simulated_vector_types

numba_cuda/numba/cuda/simulator_init.py

@@ -4,14 +4,12 @@ from .simulator import *  # noqa: F403, F401
 
 
 def is_available():
-    """Returns a boolean to indicate the availability of a CUDA GPU.
-    """
+    """Returns a boolean to indicate the availability of a CUDA GPU."""
     # Simulator is always available
     return True
 
 
 def cuda_error():
-    """Returns None or an exception if the CUDA driver fails to initialize.
-    """
+    """Returns None or an exception if the CUDA driver fails to initialize."""
     # Simulator never fails to initialize
     return None