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

numba_cuda/numba/cuda/libdeviceimpl.py

@@ -49,8 +49,9 @@ def libdevice_implement_multiple_returns(func, retty, prototype_args):
         for arg in prototype_args:
             if arg.is_ptr:
                 # Allocate space for return value and add to args
-                tmp_arg = cgutils.alloca_once(builder,
-                                              context.get_value_type(arg.ty))
+                tmp_arg = cgutils.alloca_once(
+                    builder, context.get_value_type(arg.ty)
+                )
                 actual_args.append(tmp_arg)
                 virtual_args.append(tmp_arg)
             else:

numba_cuda/numba/cuda/locks.py

@@ -0,0 +1,16 @@
+from threading import Lock
+from functools import wraps
+
+# Thread safety guard for module initialization.
+_module_init_lock = Lock()
+
+
+def module_init_lock(func):
+    """Decorator to make sure initialization is invoked once for all threads."""
+
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        with _module_init_lock:
+            return func(*args, **kwargs)
+
+    return wrapper

numba_cuda/numba/cuda/mathimpl.py

@@ -12,57 +12,57 @@ lower = registry.lower
 
 
 booleans = []
-booleans += [('isnand', 'isnanf', math.isnan)]
-booleans += [('isinfd', 'isinff', math.isinf)]
-booleans += [('isfinited', 'finitef', math.isfinite)]
+booleans += [("isnand", "isnanf", math.isnan)]
+booleans += [("isinfd", "isinff", math.isinf)]
+booleans += [("isfinited", "finitef", math.isfinite)]
 
 unarys = []
-unarys += [('ceil', 'ceilf', math.ceil)]
-unarys += [('floor', 'floorf', math.floor)]
-unarys += [('fabs', 'fabsf', math.fabs)]
-unarys += [('exp', 'expf', math.exp)]
-unarys += [('expm1', 'expm1f', math.expm1)]
-unarys += [('erf', 'erff', math.erf)]
-unarys += [('erfc', 'erfcf', math.erfc)]
-unarys += [('tgamma', 'tgammaf', math.gamma)]
-unarys += [('lgamma', 'lgammaf', math.lgamma)]
-unarys += [('sqrt', 'sqrtf', math.sqrt)]
-unarys += [('log', 'logf', math.log)]
-unarys += [('log2', 'log2f', math.log2)]
-unarys += [('log10', 'log10f', math.log10)]
-unarys += [('log1p', 'log1pf', math.log1p)]
-unarys += [('acosh', 'acoshf', math.acosh)]
-unarys += [('acos', 'acosf', math.acos)]
-unarys += [('cos', 'cosf', math.cos)]
-unarys += [('cosh', 'coshf', math.cosh)]
-unarys += [('asinh', 'asinhf', math.asinh)]
-unarys += [('asin', 'asinf', math.asin)]
-unarys += [('sin', 'sinf', math.sin)]
-unarys += [('sinh', 'sinhf', math.sinh)]
-unarys += [('atan', 'atanf', math.atan)]
-unarys += [('atanh', 'atanhf', math.atanh)]
-unarys += [('tan', 'tanf', math.tan)]
-unarys += [('trunc', 'truncf', math.trunc)]
+unarys += [("ceil", "ceilf", math.ceil)]
+unarys += [("floor", "floorf", math.floor)]
+unarys += [("fabs", "fabsf", math.fabs)]
+unarys += [("exp", "expf", math.exp)]
+unarys += [("expm1", "expm1f", math.expm1)]
+unarys += [("erf", "erff", math.erf)]
+unarys += [("erfc", "erfcf", math.erfc)]
+unarys += [("tgamma", "tgammaf", math.gamma)]
+unarys += [("lgamma", "lgammaf", math.lgamma)]
+unarys += [("sqrt", "sqrtf", math.sqrt)]
+unarys += [("log", "logf", math.log)]
+unarys += [("log2", "log2f", math.log2)]
+unarys += [("log10", "log10f", math.log10)]
+unarys += [("log1p", "log1pf", math.log1p)]
+unarys += [("acosh", "acoshf", math.acosh)]
+unarys += [("acos", "acosf", math.acos)]
+unarys += [("cos", "cosf", math.cos)]
+unarys += [("cosh", "coshf", math.cosh)]
+unarys += [("asinh", "asinhf", math.asinh)]
+unarys += [("asin", "asinf", math.asin)]
+unarys += [("sin", "sinf", math.sin)]
+unarys += [("sinh", "sinhf", math.sinh)]
+unarys += [("atan", "atanf", math.atan)]
+unarys += [("atanh", "atanhf", math.atanh)]
+unarys += [("tan", "tanf", math.tan)]
+unarys += [("trunc", "truncf", math.trunc)]
 
 unarys_fastmath = {}
-unarys_fastmath['cosf'] = 'fast_cosf'
-unarys_fastmath['sinf'] = 'fast_sinf'
-unarys_fastmath['tanf'] = 'fast_tanf'
-unarys_fastmath['expf'] = 'fast_expf'
-unarys_fastmath['log2f'] = 'fast_log2f'
-unarys_fastmath['log10f'] = 'fast_log10f'
-unarys_fastmath['logf'] = 'fast_logf'
+unarys_fastmath["cosf"] = "fast_cosf"
+unarys_fastmath["sinf"] = "fast_sinf"
+unarys_fastmath["tanf"] = "fast_tanf"
+unarys_fastmath["expf"] = "fast_expf"
+unarys_fastmath["log2f"] = "fast_log2f"
+unarys_fastmath["log10f"] = "fast_log10f"
+unarys_fastmath["logf"] = "fast_logf"
 
 binarys = []
-binarys += [('copysign', 'copysignf', math.copysign)]
-binarys += [('atan2', 'atan2f', math.atan2)]
-binarys += [('pow', 'powf', math.pow)]
-binarys += [('fmod', 'fmodf', math.fmod)]
-binarys += [('hypot', 'hypotf', math.hypot)]
-binarys += [('remainder', 'remainderf', math.remainder)]
+binarys += [("copysign", "copysignf", math.copysign)]
+binarys += [("atan2", "atan2f", math.atan2)]
+binarys += [("pow", "powf", math.pow)]
+binarys += [("fmod", "fmodf", math.fmod)]
+binarys += [("hypot", "hypotf", math.hypot)]
+binarys += [("remainder", "remainderf", math.remainder)]
 
 binarys_fastmath = {}
-binarys_fastmath['powf'] = 'fast_powf'
+binarys_fastmath["powf"] = "fast_powf"
 
 
 @lower(math.isinf, types.Integer)
@@ -179,8 +179,9 @@ def fp16_trunc_impl(context, builder, sig, args):
 
 def impl_boolean(key, ty, libfunc):
     def lower_boolean_impl(context, builder, sig, args):
-        libfunc_impl = context.get_function(libfunc,
-                                            typing.signature(types.int32, ty))
+        libfunc_impl = context.get_function(
+            libfunc, typing.signature(types.int32, ty)
+        )
         result = libfunc_impl(builder, args)
         return context.cast(builder, result, types.int32, types.boolean)
 
@@ -197,9 +198,11 @@ def get_lower_unary_impl(key, ty, libfunc):
         if fast_replacement is not None:
             actual_libfunc = getattr(libdevice, fast_replacement)
 
-        libfunc_impl = context.get_function(actual_libfunc,
-                                            typing.signature(ty, ty))
+        libfunc_impl = context.get_function(
+            actual_libfunc, typing.signature(ty, ty)
+        )
         return libfunc_impl(builder, args)
+
     return lower_unary_impl
 
 
@@ -208,7 +211,7 @@ def get_unary_impl_for_fn_and_ty(fn, ty):
     # unary implementations, it does not appear in the unarys list. However,
     # its implementation can be looked up by key like the other
     # implementations, so we add it to the list we search here.
-    tanh_impls = ('tanh', 'tanhf', math.tanh)
+    tanh_impls = ("tanh", "tanhf", math.tanh)
     for fname64, fname32, key in unarys + [tanh_impls]:
         if fn == key:
             if ty == float32:
@@ -233,7 +236,7 @@ def impl_unary_int(key, ty, libfunc):
         elif sig.args[0] == uint64:
             convert = builder.uitofp
         else:
-            m = 'Only 64-bit integers are supported for generic unary int ops'
+            m = "Only 64-bit integers are supported for generic unary int ops"
             raise TypeError(m)
 
         arg = convert(args[0], ir.DoubleType())
@@ -254,9 +257,11 @@ def get_lower_binary_impl(key, ty, libfunc):
         if fast_replacement is not None:
             actual_libfunc = getattr(libdevice, fast_replacement)
 
-        libfunc_impl = context.get_function(actual_libfunc,
-                                            typing.signature(ty, ty, ty))
+        libfunc_impl = context.get_function(
+            actual_libfunc, typing.signature(ty, ty, ty)
+        )
         return libfunc_impl(builder, args)
+
     return lower_binary_impl
 
 
@@ -285,7 +290,7 @@ def impl_binary_int(key, ty, libfunc):
         elif sig.args[0] == uint64:
             convert = builder.uitofp
         else:
-            m = 'Only 64-bit integers are supported for generic binary int ops'
+            m = "Only 64-bit integers are supported for generic binary int ops"
             raise TypeError(m)
 
         args = [convert(arg, ir.DoubleType()) for arg in args]
@@ -390,12 +395,12 @@ def impl_tanh(ty, libfunc):
 
         def tanhf_impl_fastmath():
             fnty = ir.FunctionType(ir.FloatType(), [ir.FloatType()])
-            asm = ir.InlineAsm(fnty, 'tanh.approx.f32 $0, $1;', '=f,f')
+            asm = ir.InlineAsm(fnty, "tanh.approx.f32 $0, $1;", "=f,f")
             return builder.call(asm, args)
 
         if ty == float32 and context.fastmath:
             cc = get_compute_capability()
-            if cc >= (7,5):
+            if cc >= (7, 5):
                 return tanhf_impl_fastmath()
 
         return tanh_impl_libdevice()
@@ -420,7 +425,6 @@ impl_unary_int(math.tanh, uint64, libdevice.tanh)
 def cpow_implement(fty, cty):
     def core(context, builder, sig, args):
         def cpow_internal(a, b):
-
             if b.real == fty(0.0) and b.imag == fty(0.0):
                 return cty(1.0) + cty(0.0j)
             elif a.real == fty(0.0) and b.real == fty(0.0):
@@ -434,8 +438,9 @@ def cpow_implement(fty, cty):
                 len /= math.exp(at * b.imag)
                 phase += b.imag * math.log(vabs)
 
-            return len * (cty(math.cos(phase)) +
-                          cty(math.sin(phase) * cty(1.0j)))
+            return len * (
+                cty(math.cos(phase)) + cty(math.sin(phase) * cty(1.0j))
+            )
 
         return context.compile_internal(builder, cpow_internal, sig, args)
 

numba_cuda/numba/cuda/models.py

@@ -16,11 +16,7 @@ register_model = functools.partial(register, cuda_data_manager)
 @register_model(Dim3)
 class Dim3Model(models.StructModel):
     def __init__(self, dmm, fe_type):
-        members = [
-            ('x', types.int32),
-            ('y', types.int32),
-            ('z', types.int32)
-        ]
+        members = [("x", types.int32), ("y", types.int32), ("z", types.int32)]
         super().__init__(dmm, fe_type, members)
 
 

numba_cuda/numba/cuda/nvvmutils.py

@@ -5,159 +5,178 @@ from .cudadrv import nvvm
 
 
 def declare_atomic_cas_int(lmod, isize):
-    fname = '___numba_atomic_i' + str(isize) + '_cas_hack'
-    fnty = ir.FunctionType(ir.IntType(isize),
-                           (ir.PointerType(ir.IntType(isize)),
-                            ir.IntType(isize),
-                            ir.IntType(isize)))
+    fname = "___numba_atomic_i" + str(isize) + "_cas_hack"
+    fnty = ir.FunctionType(
+        ir.IntType(isize),
+        (
+            ir.PointerType(ir.IntType(isize)),
+            ir.IntType(isize),
+            ir.IntType(isize),
+        ),
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def atomic_cmpxchg(builder, lmod, isize, ptr, cmp, val):
-    out = builder.cmpxchg(ptr, cmp, val, 'monotonic', 'monotonic')
+    out = builder.cmpxchg(ptr, cmp, val, "monotonic", "monotonic")
     return builder.extract_value(out, 0)
 
 
 def declare_atomic_add_float32(lmod):
-    fname = 'llvm.nvvm.atomic.load.add.f32.p0f32'
-    fnty = ir.FunctionType(ir.FloatType(),
-                           (ir.PointerType(ir.FloatType(), 0), ir.FloatType()))
+    fname = "llvm.nvvm.atomic.load.add.f32.p0f32"
+    fnty = ir.FunctionType(
+        ir.FloatType(), (ir.PointerType(ir.FloatType(), 0), ir.FloatType())
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_add_float64(lmod):
     flags = targetconfig.ConfigStack().top()
     if flags.compute_capability >= (6, 0):
-        fname = 'llvm.nvvm.atomic.load.add.f64.p0f64'
+        fname = "llvm.nvvm.atomic.load.add.f64.p0f64"
     else:
-        fname = '___numba_atomic_double_add'
-    fnty = ir.FunctionType(ir.DoubleType(),
-                           (ir.PointerType(ir.DoubleType()), ir.DoubleType()))
+        fname = "___numba_atomic_double_add"
+    fnty = ir.FunctionType(
+        ir.DoubleType(), (ir.PointerType(ir.DoubleType()), ir.DoubleType())
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_sub_float32(lmod):
-    fname = '___numba_atomic_float_sub'
-    fnty = ir.FunctionType(ir.FloatType(),
-                           (ir.PointerType(ir.FloatType()), ir.FloatType()))
+    fname = "___numba_atomic_float_sub"
+    fnty = ir.FunctionType(
+        ir.FloatType(), (ir.PointerType(ir.FloatType()), ir.FloatType())
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_sub_float64(lmod):
-    fname = '___numba_atomic_double_sub'
-    fnty = ir.FunctionType(ir.DoubleType(),
-                           (ir.PointerType(ir.DoubleType()), ir.DoubleType()))
+    fname = "___numba_atomic_double_sub"
+    fnty = ir.FunctionType(
+        ir.DoubleType(), (ir.PointerType(ir.DoubleType()), ir.DoubleType())
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_inc_int32(lmod):
-    fname = 'llvm.nvvm.atomic.load.inc.32.p0i32'
-    fnty = ir.FunctionType(ir.IntType(32),
-                           (ir.PointerType(ir.IntType(32)), ir.IntType(32)))
+    fname = "llvm.nvvm.atomic.load.inc.32.p0i32"
+    fnty = ir.FunctionType(
+        ir.IntType(32), (ir.PointerType(ir.IntType(32)), ir.IntType(32))
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_inc_int64(lmod):
-    fname = '___numba_atomic_u64_inc'
-    fnty = ir.FunctionType(ir.IntType(64),
-                           (ir.PointerType(ir.IntType(64)), ir.IntType(64)))
+    fname = "___numba_atomic_u64_inc"
+    fnty = ir.FunctionType(
+        ir.IntType(64), (ir.PointerType(ir.IntType(64)), ir.IntType(64))
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_dec_int32(lmod):
-    fname = 'llvm.nvvm.atomic.load.dec.32.p0i32'
-    fnty = ir.FunctionType(ir.IntType(32),
-                           (ir.PointerType(ir.IntType(32)), ir.IntType(32)))
+    fname = "llvm.nvvm.atomic.load.dec.32.p0i32"
+    fnty = ir.FunctionType(
+        ir.IntType(32), (ir.PointerType(ir.IntType(32)), ir.IntType(32))
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_dec_int64(lmod):
-    fname = '___numba_atomic_u64_dec'
-    fnty = ir.FunctionType(ir.IntType(64),
-                           (ir.PointerType(ir.IntType(64)), ir.IntType(64)))
+    fname = "___numba_atomic_u64_dec"
+    fnty = ir.FunctionType(
+        ir.IntType(64), (ir.PointerType(ir.IntType(64)), ir.IntType(64))
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_max_float32(lmod):
-    fname = '___numba_atomic_float_max'
-    fnty = ir.FunctionType(ir.FloatType(),
-                           (ir.PointerType(ir.FloatType()), ir.FloatType()))
+    fname = "___numba_atomic_float_max"
+    fnty = ir.FunctionType(
+        ir.FloatType(), (ir.PointerType(ir.FloatType()), ir.FloatType())
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_max_float64(lmod):
-    fname = '___numba_atomic_double_max'
-    fnty = ir.FunctionType(ir.DoubleType(),
-                           (ir.PointerType(ir.DoubleType()), ir.DoubleType()))
+    fname = "___numba_atomic_double_max"
+    fnty = ir.FunctionType(
+        ir.DoubleType(), (ir.PointerType(ir.DoubleType()), ir.DoubleType())
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_min_float32(lmod):
-    fname = '___numba_atomic_float_min'
-    fnty = ir.FunctionType(ir.FloatType(),
-                           (ir.PointerType(ir.FloatType()), ir.FloatType()))
+    fname = "___numba_atomic_float_min"
+    fnty = ir.FunctionType(
+        ir.FloatType(), (ir.PointerType(ir.FloatType()), ir.FloatType())
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_min_float64(lmod):
-    fname = '___numba_atomic_double_min'
-    fnty = ir.FunctionType(ir.DoubleType(),
-                           (ir.PointerType(ir.DoubleType()), ir.DoubleType()))
+    fname = "___numba_atomic_double_min"
+    fnty = ir.FunctionType(
+        ir.DoubleType(), (ir.PointerType(ir.DoubleType()), ir.DoubleType())
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_nanmax_float32(lmod):
-    fname = '___numba_atomic_float_nanmax'
-    fnty = ir.FunctionType(ir.FloatType(),
-                           (ir.PointerType(ir.FloatType()), ir.FloatType()))
+    fname = "___numba_atomic_float_nanmax"
+    fnty = ir.FunctionType(
+        ir.FloatType(), (ir.PointerType(ir.FloatType()), ir.FloatType())
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_nanmax_float64(lmod):
-    fname = '___numba_atomic_double_nanmax'
-    fnty = ir.FunctionType(ir.DoubleType(),
-                           (ir.PointerType(ir.DoubleType()), ir.DoubleType()))
+    fname = "___numba_atomic_double_nanmax"
+    fnty = ir.FunctionType(
+        ir.DoubleType(), (ir.PointerType(ir.DoubleType()), ir.DoubleType())
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_nanmin_float32(lmod):
-    fname = '___numba_atomic_float_nanmin'
-    fnty = ir.FunctionType(ir.FloatType(),
-                           (ir.PointerType(ir.FloatType()), ir.FloatType()))
+    fname = "___numba_atomic_float_nanmin"
+    fnty = ir.FunctionType(
+        ir.FloatType(), (ir.PointerType(ir.FloatType()), ir.FloatType())
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_atomic_nanmin_float64(lmod):
-    fname = '___numba_atomic_double_nanmin'
-    fnty = ir.FunctionType(ir.DoubleType(),
-                           (ir.PointerType(ir.DoubleType()), ir.DoubleType()))
+    fname = "___numba_atomic_double_nanmin"
+    fnty = ir.FunctionType(
+        ir.DoubleType(), (ir.PointerType(ir.DoubleType()), ir.DoubleType())
+    )
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_cudaCGGetIntrinsicHandle(lmod):
-    fname = 'cudaCGGetIntrinsicHandle'
-    fnty = ir.FunctionType(ir.IntType(64),
-                           (ir.IntType(32),))
+    fname = "cudaCGGetIntrinsicHandle"
+    fnty = ir.FunctionType(ir.IntType(64), (ir.IntType(32),))
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_cudaCGSynchronize(lmod):
-    fname = 'cudaCGSynchronize'
-    fnty = ir.FunctionType(ir.IntType(32),
-                           (ir.IntType(64), ir.IntType(32)))
+    fname = "cudaCGSynchronize"
+    fnty = ir.FunctionType(ir.IntType(32), (ir.IntType(64), ir.IntType(32)))
     return cgutils.get_or_insert_function(lmod, fnty, fname)
 
 
 def declare_string(builder, value):
     lmod = builder.basic_block.function.module
     cval = cgutils.make_bytearray(value.encode("utf-8") + b"\x00")
-    gl = cgutils.add_global_variable(lmod, cval.type, name="_str",
-                                     addrspace=nvvm.ADDRSPACE_CONSTANT)
-    gl.linkage = 'internal'
+    gl = cgutils.add_global_variable(
+        lmod, cval.type, name="_str", addrspace=nvvm.ADDRSPACE_CONSTANT
+    )
+    gl.linkage = "internal"
     gl.global_constant = True
     gl.initializer = cval
 
-    return builder.addrspacecast(gl, ir.PointerType(ir.IntType(8)), 'generic')
+    return builder.addrspacecast(gl, ir.PointerType(ir.IntType(8)), "generic")
 
 
 def declare_vprint(lmod):
@@ -172,24 +191,20 @@ def declare_vprint(lmod):
 # -----------------------------------------------------------------------------
 
 SREG_MAPPING = {
-    'tid.x': 'llvm.nvvm.read.ptx.sreg.tid.x',
-    'tid.y': 'llvm.nvvm.read.ptx.sreg.tid.y',
-    'tid.z': 'llvm.nvvm.read.ptx.sreg.tid.z',
-
-    'ntid.x': 'llvm.nvvm.read.ptx.sreg.ntid.x',
-    'ntid.y': 'llvm.nvvm.read.ptx.sreg.ntid.y',
-    'ntid.z': 'llvm.nvvm.read.ptx.sreg.ntid.z',
-
-    'ctaid.x': 'llvm.nvvm.read.ptx.sreg.ctaid.x',
-    'ctaid.y': 'llvm.nvvm.read.ptx.sreg.ctaid.y',
-    'ctaid.z': 'llvm.nvvm.read.ptx.sreg.ctaid.z',
-
-    'nctaid.x': 'llvm.nvvm.read.ptx.sreg.nctaid.x',
-    'nctaid.y': 'llvm.nvvm.read.ptx.sreg.nctaid.y',
-    'nctaid.z': 'llvm.nvvm.read.ptx.sreg.nctaid.z',
-
-    'warpsize': 'llvm.nvvm.read.ptx.sreg.warpsize',
-    'laneid': 'llvm.nvvm.read.ptx.sreg.laneid',
+    "tid.x": "llvm.nvvm.read.ptx.sreg.tid.x",
+    "tid.y": "llvm.nvvm.read.ptx.sreg.tid.y",
+    "tid.z": "llvm.nvvm.read.ptx.sreg.tid.z",
+    "ntid.x": "llvm.nvvm.read.ptx.sreg.ntid.x",
+    "ntid.y": "llvm.nvvm.read.ptx.sreg.ntid.y",
+    "ntid.z": "llvm.nvvm.read.ptx.sreg.ntid.z",
+    "ctaid.x": "llvm.nvvm.read.ptx.sreg.ctaid.x",
+    "ctaid.y": "llvm.nvvm.read.ptx.sreg.ctaid.y",
+    "ctaid.z": "llvm.nvvm.read.ptx.sreg.ctaid.z",
+    "nctaid.x": "llvm.nvvm.read.ptx.sreg.nctaid.x",
+    "nctaid.y": "llvm.nvvm.read.ptx.sreg.nctaid.y",
+    "nctaid.z": "llvm.nvvm.read.ptx.sreg.nctaid.z",
+    "warpsize": "llvm.nvvm.read.ptx.sreg.warpsize",
+    "laneid": "llvm.nvvm.read.ptx.sreg.laneid",
 }
 
 
@@ -205,16 +220,16 @@ class SRegBuilder(object):
         self.builder = builder
 
     def tid(self, xyz):
-        return call_sreg(self.builder, 'tid.%s' % xyz)
+        return call_sreg(self.builder, "tid.%s" % xyz)
 
     def ctaid(self, xyz):
-        return call_sreg(self.builder, 'ctaid.%s' % xyz)
+        return call_sreg(self.builder, "ctaid.%s" % xyz)
 
     def ntid(self, xyz):
-        return call_sreg(self.builder, 'ntid.%s' % xyz)
+        return call_sreg(self.builder, "ntid.%s" % xyz)
 
     def nctaid(self, xyz):
-        return call_sreg(self.builder, 'nctaid.%s' % xyz)
+        return call_sreg(self.builder, "nctaid.%s" % xyz)
 
     def getdim(self, xyz):
         i64 = ir.IntType(64)
@@ -227,7 +242,7 @@ class SRegBuilder(object):
 
 def get_global_id(builder, dim):
     sreg = SRegBuilder(builder)
-    it = (sreg.getdim(xyz) for xyz in 'xyz')
+    it = (sreg.getdim(xyz) for xyz in "xyz")
     seq = list(itertools.islice(it, None, dim))
     if dim == 1:
         return seq[0]

numba_cuda/numba/cuda/printimpl.py

@@ -15,6 +15,7 @@ voidptr = ir.PointerType(ir.IntType(8))
 
 # NOTE: we don't use @lower here since print_item() doesn't return a LLVM value
 
+
 @singledispatch
 def print_item(ty, context, builder, val):
     """
@@ -22,8 +23,9 @@ def print_item(ty, context, builder, val):
     A (format string, [list of arguments]) is returned that will allow
     forming the final printf()-like call.
     """
-    raise NotImplementedError("printing unimplemented for values of type %s"
-                              % (ty,))
+    raise NotImplementedError(
+        "printing unimplemented for values of type %s" % (ty,)
+    )
 
 
 @print_item.register(types.Integer)
@@ -92,11 +94,13 @@ def print_varargs(context, builder, sig, args):
 
     rawfmt = " ".join(formats) + "\n"
     if len(args) > 32:
-        msg = ('CUDA print() cannot print more than 32 items. '
-               'The raw format string will be emitted by the kernel instead.')
+        msg = (
+            "CUDA print() cannot print more than 32 items. "
+            "The raw format string will be emitted by the kernel instead."
+        )
         warn(msg, NumbaWarning)
 
-        rawfmt = rawfmt.replace('%', '%%')
+        rawfmt = rawfmt.replace("%", "%%")
     fmt = context.insert_string_const_addrspace(builder, rawfmt)
     array = cgutils.make_anonymous_struct(builder, values)
     arrayptr = cgutils.alloca_once_value(builder, array)