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

numba_cuda/numba/cuda/tests/cudapy/test_warp_ops.py

@@ -1,6 +1,9 @@
+import re
+
 import numpy as np
 from numba import cuda, int32, int64, float32, float64
 from numba.cuda.testing import unittest, CUDATestCase, skip_on_cudasim
+from numba.cuda.compiler import compile_ptx
 from numba.core import config
 
 
@@ -8,73 +11,73 @@ def useful_syncwarp(ary):
     i = cuda.grid(1)
     if i == 0:
         ary[0] = 42
-    cuda.syncwarp(0xffffffff)
+    cuda.syncwarp(0xFFFFFFFF)
     ary[i] = ary[0]
 
 
 def use_shfl_sync_idx(ary, idx):
     i = cuda.grid(1)
-    val = cuda.shfl_sync(0xffffffff, i, idx)
+    val = cuda.shfl_sync(0xFFFFFFFF, i, idx)
     ary[i] = val
 
 
 def use_shfl_sync_up(ary, delta):
     i = cuda.grid(1)
-    val = cuda.shfl_up_sync(0xffffffff, i, delta)
+    val = cuda.shfl_up_sync(0xFFFFFFFF, i, delta)
     ary[i] = val
 
 
 def use_shfl_sync_down(ary, delta):
     i = cuda.grid(1)
-    val = cuda.shfl_down_sync(0xffffffff, i, delta)
+    val = cuda.shfl_down_sync(0xFFFFFFFF, i, delta)
     ary[i] = val
 
 
 def use_shfl_sync_xor(ary, xor):
     i = cuda.grid(1)
-    val = cuda.shfl_xor_sync(0xffffffff, i, xor)
+    val = cuda.shfl_xor_sync(0xFFFFFFFF, i, xor)
     ary[i] = val
 
 
 def use_shfl_sync_with_val(ary, into):
     i = cuda.grid(1)
-    val = cuda.shfl_sync(0xffffffff, into, 0)
+    val = cuda.shfl_sync(0xFFFFFFFF, into, 0)
     ary[i] = val
 
 
 def use_vote_sync_all(ary_in, ary_out):
     i = cuda.grid(1)
-    pred = cuda.all_sync(0xffffffff, ary_in[i])
+    pred = cuda.all_sync(0xFFFFFFFF, ary_in[i])
     ary_out[i] = pred
 
 
 def use_vote_sync_any(ary_in, ary_out):
     i = cuda.grid(1)
-    pred = cuda.any_sync(0xffffffff, ary_in[i])
+    pred = cuda.any_sync(0xFFFFFFFF, ary_in[i])
     ary_out[i] = pred
 
 
 def use_vote_sync_eq(ary_in, ary_out):
     i = cuda.grid(1)
-    pred = cuda.eq_sync(0xffffffff, ary_in[i])
+    pred = cuda.eq_sync(0xFFFFFFFF, ary_in[i])
     ary_out[i] = pred
 
 
 def use_vote_sync_ballot(ary):
     i = cuda.threadIdx.x
-    ballot = cuda.ballot_sync(0xffffffff, True)
+    ballot = cuda.ballot_sync(0xFFFFFFFF, True)
     ary[i] = ballot
 
 
 def use_match_any_sync(ary_in, ary_out):
     i = cuda.grid(1)
-    ballot = cuda.match_any_sync(0xffffffff, ary_in[i])
+    ballot = cuda.match_any_sync(0xFFFFFFFF, ary_in[i])
     ary_out[i] = ballot
 
 
 def use_match_all_sync(ary_in, ary_out):
     i = cuda.grid(1)
-    ballot, pred = cuda.match_all_sync(0xffffffff, ary_in[i])
+    ballot, pred = cuda.match_all_sync(0xFFFFFFFF, ary_in[i])
     ary_out[i] = ballot if pred else 0
 
 
@@ -144,16 +147,62 @@ class TestCudaWarpOperations(CUDATestCase):
         compiled[1, nelem](ary, xor)
         self.assertTrue(np.all(ary == exp))
 
+    def test_shfl_sync_const_mode_val(self):
+        # Test `mode` argument is constant in shfl_sync calls.
+        # Related to https://github.com/NVIDIA/numba-cuda/pull/231
+        subtest = [
+            (use_shfl_sync_idx, 4),
+            (use_shfl_sync_up, 4),
+            (use_shfl_sync_down, 4),
+            (use_shfl_sync_xor, 16),
+        ]
+
+        args_re = r"\((.*)\)"
+        m = re.compile(args_re)
+
+        for func, value in subtest:
+            with self.subTest(func=func.__name__):
+                compiled = cuda.jit("void(int32[:], int32)")(func)
+                nelem = 32
+                ary = np.empty(nelem, dtype=np.int32)
+                compiled[1, nelem](ary, value)
+                irs = next(iter(compiled.inspect_llvm().values()))
+
+                for ir in irs.split("\n"):
+                    if "call" in ir and "llvm.nvvm.shfl.sync.i32" in ir:
+                        args = m.search(ir).group(0)
+                        arglist = args.split(",")
+                        mode_arg = arglist[1]
+                        self.assertNotIn("%", mode_arg)
+
+    def test_shfl_sync_const_mode_val_sm100(self):
+        # Test shfl_sync compiles with cc=(10, 0)
+        subtest = [
+            use_shfl_sync_idx,
+            use_shfl_sync_up,
+            use_shfl_sync_down,
+            use_shfl_sync_xor,
+        ]
+
+        for func in subtest:
+            with self.subTest(func=func.__name__):
+                compile_ptx(func, (int32[:], int32), cc=(10, 0))
+
     def test_shfl_sync_types(self):
         types = int32, int64, float32, float64
-        values = (np.int32(-1), np.int64(1 << 42),
-                  np.float32(np.pi), np.float64(np.pi))
+        values = (
+            np.int32(-1),
+            np.int64(1 << 42),
+            np.float32(np.pi),
+            np.float64(np.pi),
+        )
         for typ, val in zip(types, values):
-            compiled = cuda.jit((typ[:], typ))(use_shfl_sync_with_val)
-            nelem = 32
-            ary = np.empty(nelem, dtype=val.dtype)
-            compiled[1, nelem](ary, val)
-            self.assertTrue(np.all(ary == val))
+            with self.subTest(typ=typ):
+                compiled = cuda.jit((typ[:], typ))(use_shfl_sync_with_val)
+                nelem = 32
+                ary = np.empty(nelem, dtype=val.dtype)
+                compiled[1, nelem](ary, val)
+                self.assertTrue(np.all(ary == val))
 
     def test_vote_sync_all(self):
         compiled = cuda.jit("void(int32[:], int32[:])")(use_vote_sync_all)
@@ -197,10 +246,11 @@ class TestCudaWarpOperations(CUDATestCase):
         nelem = 32
         ary = np.empty(nelem, dtype=np.uint32)
         compiled[1, nelem](ary)
-        self.assertTrue(np.all(ary == np.uint32(0xffffffff)))
+        self.assertTrue(np.all(ary == np.uint32(0xFFFFFFFF)))
 
-    @unittest.skipUnless(_safe_cc_check((7, 0)),
-                         "Matching requires at least Volta Architecture")
+    @unittest.skipUnless(
+        _safe_cc_check((7, 0)), "Matching requires at least Volta Architecture"
+    )
     def test_match_any_sync(self):
         compiled = cuda.jit("void(int32[:], int32[:])")(use_match_any_sync)
         nelem = 10
@@ -210,8 +260,9 @@ class TestCudaWarpOperations(CUDATestCase):
         compiled[1, nelem](ary_in, ary_out)
         self.assertTrue(np.all(ary_out == exp))
 
-    @unittest.skipUnless(_safe_cc_check((7, 0)),
-                         "Matching requires at least Volta Architecture")
+    @unittest.skipUnless(
+        _safe_cc_check((7, 0)), "Matching requires at least Volta Architecture"
+    )
     def test_match_all_sync(self):
         compiled = cuda.jit("void(int32[:], int32[:])")(use_match_all_sync)
         nelem = 10
@@ -223,9 +274,10 @@ class TestCudaWarpOperations(CUDATestCase):
         compiled[1, nelem](ary_in, ary_out)
         self.assertTrue(np.all(ary_out == 0))
 
-    @unittest.skipUnless(_safe_cc_check((7, 0)),
-                         "Independent scheduling requires at least Volta "
-                         "Architecture")
+    @unittest.skipUnless(
+        _safe_cc_check((7, 0)),
+        "Independent scheduling requires at least Volta Architecture",
+    )
     def test_independent_scheduling(self):
         compiled = cuda.jit("void(uint32[:])")(use_independent_scheduling)
         arr = np.empty(32, dtype=np.uint32)
@@ -267,10 +319,9 @@ class TestCudaWarpOperations(CUDATestCase):
         # 0, 1, 3, 7, F, 1F, 3F, 7F, FF, 1FF, etc.
         # or in binary:
         # ...0001, ....0011, ...0111, etc.
-        expected = np.asarray([(2 ** i) - 1 for i in range(32)],
-                              dtype=np.uint32)
+        expected = np.asarray([(2**i) - 1 for i in range(32)], dtype=np.uint32)
         np.testing.assert_equal(expected, out)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudasim/test_cudasim_issues.py

@@ -10,12 +10,16 @@ import unittest
 
 class TestCudaSimIssues(CUDATestCase):
     def test_record_access(self):
-        backyard_type = [('statue', np.float64),
-                         ('newspaper', np.float64, (6,))]
+        backyard_type = [
+            ("statue", np.float64),
+            ("newspaper", np.float64, (6,)),
+        ]
 
-        goose_type = [('garden', np.float64, (12,)),
-                      ('town', np.float64, (42,)),
-                      ('backyard', backyard_type)]
+        goose_type = [
+            ("garden", np.float64, (12,)),
+            ("town", np.float64, (42,)),
+            ("backyard", backyard_type),
+        ]
 
         goose_np_type = np.dtype(goose_type, align=True)
 
@@ -27,20 +31,22 @@ class TestCudaSimIssues(CUDATestCase):
 
         item = np.recarray(1, dtype=goose_np_type)
         simple_kernel[1, 1](item[0])
-        np.testing.assert_equal(item[0]['garden'][0], 45)
-        np.testing.assert_equal(item[0]['backyard']['newspaper'][3], 5)
+        np.testing.assert_equal(item[0]["garden"][0], 45)
+        np.testing.assert_equal(item[0]["backyard"]["newspaper"][3], 5)
 
     def test_recarray_setting(self):
-        recordwith2darray = np.dtype([('i', np.int32),
-                                      ('j', np.float32, (3, 2))])
+        recordwith2darray = np.dtype(
+            [("i", np.int32), ("j", np.float32, (3, 2))]
+        )
         rec = np.recarray(2, dtype=recordwith2darray)
-        rec[0]['i'] = 45
+        rec[0]["i"] = 45
 
         @cuda.jit
         def simple_kernel(f):
             f[1] = f[0]
+
         simple_kernel[1, 1](rec)
-        np.testing.assert_equal(rec[0]['i'], rec[1]['i'])
+        np.testing.assert_equal(rec[0]["i"], rec[1]["i"])
 
     def test_cuda_module_in_device_function(self):
         """
@@ -63,7 +69,7 @@ class TestCudaSimIssues(CUDATestCase):
         expected = np.arange(arr.size, dtype=np.int32)
         np.testing.assert_equal(expected, arr)
 
-    @skip_unless_cudasim('Only works on CUDASIM')
+    @skip_unless_cudasim("Only works on CUDASIM")
     def test_deadlock_on_exception(self):
         def assert_no_blockthreads():
             blockthreads = []
@@ -98,5 +104,5 @@ class TestCudaSimIssues(CUDATestCase):
         assert_no_blockthreads()
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/data/jitlink.cu

@@ -20,4 +20,4 @@ int array_mutator(void *out, int *a)
 {
   a[0] = a[1];
   return 0;
-}  
+}

numba_cuda/numba/cuda/tests/data/jitlink.ptx

@@ -47,5 +47,3 @@
 	st.param.b32	[func_retval0+0], %r2;
 	ret;
 }
-
-

numba_cuda/numba/cuda/tests/doc_examples/test_cg.py

@@ -2,14 +2,18 @@
 # "magictoken" is used for markers as beginning and ending of example text.
 
 import unittest
-from numba.cuda.testing import (CUDATestCase, skip_on_cudasim,
-                                skip_if_cudadevrt_missing, skip_unless_cc_60,
-                                skip_if_mvc_enabled)
+from numba.cuda.testing import (
+    CUDATestCase,
+    skip_on_cudasim,
+    skip_if_cudadevrt_missing,
+    skip_unless_cc_60,
+    skip_if_mvc_enabled,
+)
 
 
 @skip_if_cudadevrt_missing
 @skip_unless_cc_60
-@skip_if_mvc_enabled('CG not supported with MVC')
+@skip_if_mvc_enabled("CG not supported with MVC")
 @skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
 class TestCooperativeGroups(CUDATestCase):
     def test_ex_grid_sync(self):
@@ -17,7 +21,7 @@ class TestCooperativeGroups(CUDATestCase):
         from numba import cuda, int32
         import numpy as np
 
-        sig = (int32[:,::1],)
+        sig = (int32[:, ::1],)
 
         @cuda.jit(sig)
         def sequential_rows(M):
@@ -34,6 +38,7 @@ class TestCooperativeGroups(CUDATestCase):
                 # Wait until all threads have written their column element,
                 # and that the write is visible to all other threads
                 g.sync()
+
         # magictoken.ex_grid_sync_kernel.end
 
         # magictoken.ex_grid_sync_data.begin
@@ -48,9 +53,11 @@ class TestCooperativeGroups(CUDATestCase):
 
         # Skip this test if the grid size used in the example is too large for
         # a cooperative launch on the current GPU
-        mb = sequential_rows.overloads[sig].max_cooperative_grid_blocks(blockdim)
+        mb = sequential_rows.overloads[sig].max_cooperative_grid_blocks(
+            blockdim
+        )
         if mb < griddim:
-            self.skipTest('Device does not support a large enough coop grid')
+            self.skipTest("Device does not support a large enough coop grid")
 
         # magictoken.ex_grid_sync_launch.begin
         # Kernel launch - this is implicitly a cooperative launch
@@ -73,5 +80,5 @@ class TestCooperativeGroups(CUDATestCase):
         np.testing.assert_equal(A, reference)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/doc_examples/test_cpu_gpu_compat.py

@@ -41,6 +41,7 @@ class TestCpuGpuCompat(CUDATestCase):
         @numba.jit
         def business_logic(x, y, z):
             return 4 * z * (2 * x - (4 * y) / 2 * pi)
+
         # ex_cpu_gpu_compat.define.end
 
         # ex_cpu_gpu_compat.cpurun.begin
@@ -54,6 +55,7 @@ class TestCpuGpuCompat(CUDATestCase):
             if tid < len(xarr):
                 # The function decorated with numba.jit may be directly reused
                 res[tid] = business_logic(xarr[tid], yarr[tid], zarr[tid])
+
         # ex_cpu_gpu_compat.usegpu.end
 
         # ex_cpu_gpu_compat.launch.begin
@@ -62,14 +64,9 @@ class TestCpuGpuCompat(CUDATestCase):
         # [-126.79644737231007, 416.28324559588634, -218912930.2987788]
         # ex_cpu_gpu_compat.launch.end
 
-        expect = [
-            business_logic(x, y, z) for x, y, z in zip(X, Y, Z)
-        ]
+        expect = [business_logic(x, y, z) for x, y, z in zip(X, Y, Z)]
 
-        np.testing.assert_equal(
-            expect,
-            results.copy_to_host()
-        )
+        np.testing.assert_equal(expect, results.copy_to_host())
 
 
 if __name__ == "__main__":

numba_cuda/numba/cuda/tests/doc_examples/test_ffi.py

@@ -2,7 +2,7 @@
 # "magictoken" is used for markers as beginning and ending of example text.
 
 import unittest
-from numba.cuda.testing import (CUDATestCase, skip_on_cudasim)
+from numba.cuda.testing import CUDATestCase, skip_on_cudasim
 from numba.tests.support import skip_unless_cffi
 
 
@@ -18,11 +18,12 @@ class TestFFI(CUDATestCase):
         # Path to the source containing the foreign function
         # (here assumed to be in a subdirectory called "ffi")
         basedir = os.path.dirname(os.path.abspath(__file__))
-        functions_cu = os.path.join(basedir, 'ffi', 'functions.cu')
+        functions_cu = os.path.join(basedir, "ffi", "functions.cu")
 
         # Declaration of the foreign function
-        mul = cuda.declare_device('mul_f32_f32', 'float32(float32, float32)',
-                                  link=functions_cu)
+        mul = cuda.declare_device(
+            "mul_f32_f32", "float32(float32, float32)", link=functions_cu
+        )
 
         # A kernel that calls mul; functions.cu is linked automatically due to
         # the call to mul.
@@ -52,25 +53,29 @@ class TestFFI(CUDATestCase):
         import os
 
         basedir = os.path.dirname(os.path.abspath(__file__))
-        functions_cu = os.path.join(basedir, 'ffi', 'functions.cu')
+        functions_cu = os.path.join(basedir, "ffi", "functions.cu")
 
         # magictoken.ex_from_buffer_decl.begin
-        signature = 'float32(CPointer(float32), int32)'
-        sum_reduce = cuda.declare_device('sum_reduce', signature,
-                                         link=functions_cu)
+        signature = "float32(CPointer(float32), int32)"
+        sum_reduce = cuda.declare_device(
+            "sum_reduce", signature, link=functions_cu
+        )
         # magictoken.ex_from_buffer_decl.end
 
         # magictoken.ex_from_buffer_kernel.begin
         import cffi
+
         ffi = cffi.FFI()
 
         @cuda.jit
         def reduction_caller(result, array):
             array_ptr = ffi.from_buffer(array)
             result[()] = sum_reduce(array_ptr, len(array))
+
         # magictoken.ex_from_buffer_kernel.end
 
         import numpy as np
+
         x = np.arange(10).astype(np.float32)
         r = np.ndarray((), dtype=np.float32)
 
@@ -81,5 +86,5 @@ class TestFFI(CUDATestCase):
         np.testing.assert_allclose(expected, actual)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/doc_examples/test_laplace.py

@@ -1,14 +1,18 @@
 import unittest
 
-from numba.cuda.testing import (CUDATestCase, skip_if_cudadevrt_missing,
-                                skip_on_cudasim, skip_unless_cc_60,
-                                skip_if_mvc_enabled)
+from numba.cuda.testing import (
+    CUDATestCase,
+    skip_if_cudadevrt_missing,
+    skip_on_cudasim,
+    skip_unless_cc_60,
+    skip_if_mvc_enabled,
+)
 from numba.tests.support import captured_stdout
 
 
 @skip_if_cudadevrt_missing
 @skip_unless_cc_60
-@skip_if_mvc_enabled('CG not supported with MVC')
+@skip_if_mvc_enabled("CG not supported with MVC")
 @skip_on_cudasim("cudasim doesn't support cuda import at non-top-level")
 class TestLaplace(CUDATestCase):
     """
@@ -27,7 +31,6 @@ class TestLaplace(CUDATestCase):
         super().tearDown()
 
     def test_ex_laplace(self):
-
         # set True to regenerate the figures that
         # accompany this example
         plot = False
@@ -55,24 +58,25 @@ class TestLaplace(CUDATestCase):
 
         if plot:
             import matplotlib.pyplot as plt
+
             fig, ax = plt.subplots(figsize=(16 * 0.66, 9 * 0.66))
             plt.plot(
                 np.arange(len(buf_0)),
                 buf_0.copy_to_host(),
                 lw=3,
                 marker="*",
-                color='black'
+                color="black",
             )
 
-            plt.title('Initial State', fontsize=24)
-            plt.xlabel('Position', fontsize=24)
-            plt.ylabel('Temperature', fontsize=24)
+            plt.title("Initial State", fontsize=24)
+            plt.xlabel("Position", fontsize=24)
+            plt.ylabel("Temperature", fontsize=24)
 
             ax.set_xticks(ax.get_xticks(), fontsize=16)
             ax.set_yticks(ax.get_yticks(), fontsize=16)
             plt.xlim(0, len(data))
             plt.ylim(0, 10001)
-            plt.savefig('laplace_initial.svg')
+            plt.savefig("laplace_initial.svg")
 
         # ex_laplace.kernel.begin
         @cuda.jit
@@ -116,12 +120,11 @@ class TestLaplace(CUDATestCase):
 
                 # Wait for every thread to write before moving on
                 grid.sync()
+
         # ex_laplace.kernel.end
 
         # ex_laplace.launch.begin
-        solve_heat_equation.forall(len(data))(
-            buf_0, buf_1, niter, 0.25
-        )
+        solve_heat_equation.forall(len(data))(buf_0, buf_1, niter, 0.25)
         # ex_laplace.launch.end
 
         results = buf_1.copy_to_host()
@@ -129,20 +132,21 @@ class TestLaplace(CUDATestCase):
             fig, ax = plt.subplots(figsize=(16 * 0.66, 9 * 0.66))
             plt.plot(
                 np.arange(len(results)),
-                results, lw=3,
+                results,
+                lw=3,
                 marker="*",
-                color='black'
+                color="black",
             )
             plt.title(f"T = {niter}", fontsize=24)
-            plt.xlabel('Position', fontsize=24)
-            plt.ylabel('Temperature', fontsize=24)
+            plt.xlabel("Position", fontsize=24)
+            plt.ylabel("Temperature", fontsize=24)
 
             ax.set_xticks(ax.get_xticks(), fontsize=16)
             ax.set_yticks(ax.get_yticks(), fontsize=16)
 
             plt.ylim(0, max(results))
             plt.xlim(0, len(results))
-            plt.savefig('laplace_final.svg')
+            plt.savefig("laplace_final.svg")
 
         # Integral over the domain should be equal to its initial value.
         # Note that this should match the initial value of data[500] above, but

numba_cuda/numba/cuda/tests/doc_examples/test_matmul.py

@@ -6,6 +6,7 @@ Reference: https://stackoverflow.com/a/64198479/13697228 by @RobertCrovella
 Contents in this file are referenced from the sphinx-generated docs.
 "magictoken" is used for markers as beginning and ending of example text.
 """
+
 import unittest
 from numba.cuda.testing import CUDATestCase, skip_on_cudasim
 from numba.tests.support import captured_stdout
@@ -43,10 +44,11 @@ class TestMatMul(CUDATestCase):
             """Perform square matrix multiplication of C = A * B."""
             i, j = cuda.grid(2)
             if i < C.shape[0] and j < C.shape[1]:
-                tmp = 0.
+                tmp = 0.0
                 for k in range(A.shape[1]):
                     tmp += A[i, k] * B[k, j]
                 C[i, j] = tmp
+
         # magictoken.ex_matmul.end
 
         # magictoken.ex_run_matmul.begin
@@ -91,11 +93,11 @@ class TestMatMul(CUDATestCase):
 
             tx = cuda.threadIdx.x
             ty = cuda.threadIdx.y
-            bpg = cuda.gridDim.x    # blocks per grid
+            bpg = cuda.gridDim.x  # blocks per grid
 
             # Each thread computes one element in the result matrix.
             # The dot product is chunked into dot products of TPB-long vectors.
-            tmp = float32(0.)
+            tmp = float32(0.0)
             for i in range(bpg):
                 # Preload data into shared memory
                 sA[ty, tx] = 0
@@ -116,6 +118,7 @@ class TestMatMul(CUDATestCase):
                 cuda.syncthreads()
             if y < C.shape[0] and x < C.shape[1]:
                 C[y, x] = tmp
+
         # magictoken.ex_fast_matmul.end
 
         # magictoken.ex_run_fast_matmul.begin
@@ -169,5 +172,5 @@ class TestMatMul(CUDATestCase):
         self.assertTrue(np.all(z_h == x_h @ y_h), msg=msg)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/doc_examples/test_montecarlo.py

@@ -59,6 +59,7 @@ class TestMonteCarlo(CUDATestCase):
                 # value of the sample
                 y = func(samp)
                 out[gid] = y
+
         # ex_montecarlo.kernel.end
 
         # ex_montecarlo.callfunc.begin
@@ -84,6 +85,7 @@ class TestMonteCarlo(CUDATestCase):
             factor = (upper_lim - lower_lim) / (nsamps - 1)
 
             return sum_reduce(out) * factor
+
         # ex_montecarlo.callfunc.end
 
         # ex_montecarlo.launch.begin

numba_cuda/numba/cuda/tests/doc_examples/test_random.py

@@ -10,8 +10,10 @@ class TestRandom(CUDATestCase):
     def test_ex_3d_grid(self):
         # magictoken.ex_3d_grid.begin
         from numba import cuda
-        from numba.cuda.random import (create_xoroshiro128p_states,
-                                       xoroshiro128p_uniform_float32)
+        from numba.cuda.random import (
+            create_xoroshiro128p_states,
+            xoroshiro128p_uniform_float32,
+        )
         import numpy as np
 
         @cuda.jit
@@ -27,7 +29,9 @@ class TestRandom(CUDATestCase):
             for i in range(startz, arr.shape[0], stridez):
                 for j in range(starty, arr.shape[1], stridey):
                     for k in range(startx, arr.shape[2], stridex):
-                        arr[i, j, k] = xoroshiro128p_uniform_float32(rng_states, tid)
+                        arr[i, j, k] = xoroshiro128p_uniform_float32(
+                            rng_states, tid
+                        )
 
         # Array dimensions
         X, Y, Z = 701, 900, 719
@@ -55,5 +59,5 @@ class TestRandom(CUDATestCase):
         self.assertTrue(np.all(host_arr >= 0.0))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/doc_examples/test_reduction.py

@@ -61,11 +61,12 @@ class TestReduction(CUDATestCase):
                 # After the loop, the zeroth  element contains the sum
                 if tid == 0:
                     data[tid] = shr[tid]
+
         # ex_reduction.kernel.end
 
         # ex_reduction.launch.begin
         array_sum[1, nelem](a)
-        print(a[0])                  # 523776
+        print(a[0])  # 523776
         print(sum(np.arange(1024)))  # 523776
         # ex_reduction.launch.end