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

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

@@ -14,14 +14,17 @@ class TestConstStringCodegen(unittest.TestCase):
 
         targetctx = cuda_target.target_context
         mod = targetctx.create_module("")
-        textstring = 'A Little Brown Fox'
+        textstring = "A Little Brown Fox"
         gv0 = targetctx.insert_const_string(mod, textstring)
         # Insert the same const string a second time - the first should be
         # reused.
         targetctx.insert_const_string(mod, textstring)
 
-        res = re.findall(r"@\"__conststring__.*internal.*constant.*\["
-                         r"19\s+x\s+i8\]", str(mod))
+        res = re.findall(
+            r"@\"__conststring__.*internal.*constant.*\["
+            r"19\s+x\s+i8\]",
+            str(mod),
+        )
         # Ensure that the const string was only inserted once
         self.assertEqual(len(res), 1)
 
@@ -30,12 +33,16 @@ class TestConstStringCodegen(unittest.TestCase):
         # Using insert_const_string
         fn = ir.Function(mod, fnty, "test_insert_const_string")
         builder = ir.IRBuilder(fn.append_basic_block())
-        res = builder.addrspacecast(gv0, ir.PointerType(ir.IntType(8)),
-                                    'generic')
+        res = builder.addrspacecast(
+            gv0, ir.PointerType(ir.IntType(8)), "generic"
+        )
         builder.ret(res)
 
-        matches = re.findall(r"@\"__conststring__.*internal.*constant.*\["
-                             r"19\s+x\s+i8\]", str(mod))
+        matches = re.findall(
+            r"@\"__conststring__.*internal.*constant.*\["
+            r"19\s+x\s+i8\]",
+            str(mod),
+        )
         self.assertEqual(len(matches), 1)
 
         # Using insert_string_const_addrspace
@@ -44,11 +51,14 @@ class TestConstStringCodegen(unittest.TestCase):
         res = targetctx.insert_string_const_addrspace(builder, textstring)
         builder.ret(res)
 
-        matches = re.findall(r"@\"__conststring__.*internal.*constant.*\["
-                             r"19\s+x\s+i8\]", str(mod))
+        matches = re.findall(
+            r"@\"__conststring__.*internal.*constant.*\["
+            r"19\s+x\s+i8\]",
+            str(mod),
+        )
         self.assertEqual(len(matches), 1)
 
-        ptx = compile_ir(str(mod)).decode('ascii')
+        ptx = compile_ir(str(mod)).decode("ascii")
         matches = list(re.findall(r"\.const.*__conststring__", ptx))
 
         self.assertEqual(len(matches), 1)
@@ -70,8 +80,8 @@ class TestConstString(CUDATestCase):
         # Expected result, e.g.:
         #     ['XYZ' 'XYZ' 'XYZ' 'XYZ' 'XYZ' 'XYZ' 'XYZ' 'XYZ' '']
         expected = np.zeros_like(arr)
-        expected[:-1] = 'XYZ'
-        expected[-1] = ''
+        expected[:-1] = "XYZ"
+        expected[-1] = ""
         np.testing.assert_equal(arr, expected)
 
     def test_assign_const_byte_string(self):
@@ -88,42 +98,42 @@ class TestConstString(CUDATestCase):
         # Expected result, e.g.:
         #     [b'XYZ' b'XYZ' b'XYZ' b'XYZ' b'XYZ' b'XYZ' b'XYZ' b'XYZ' b'']
         expected = np.zeros_like(arr)
-        expected[:-1] = b'XYZ'
-        expected[-1] = b''
+        expected[:-1] = b"XYZ"
+        expected[-1] = b""
         np.testing.assert_equal(arr, expected)
 
     def test_assign_const_string_in_record(self):
         @cuda.jit
         def f(a):
-            a[0]['x'] = 1
-            a[0]['y'] = 'ABC'
-            a[1]['x'] = 2
-            a[1]['y'] = 'XYZ'
+            a[0]["x"] = 1
+            a[0]["y"] = "ABC"
+            a[1]["x"] = 2
+            a[1]["y"] = "XYZ"
 
-        dt = np.dtype([('x', np.int32), ('y', np.dtype('<U12'))])
+        dt = np.dtype([("x", np.int32), ("y", np.dtype("<U12"))])
         a = np.zeros(2, dt)
 
         f[1, 1](a)
 
-        reference = np.asarray([(1, 'ABC'), (2, 'XYZ')], dtype=dt)
+        reference = np.asarray([(1, "ABC"), (2, "XYZ")], dtype=dt)
         np.testing.assert_array_equal(reference, a)
 
     def test_assign_const_bytes_in_record(self):
         @cuda.jit
         def f(a):
-            a[0]['x'] = 1
-            a[0]['y'] = b'ABC'
-            a[1]['x'] = 2
-            a[1]['y'] = b'XYZ'
+            a[0]["x"] = 1
+            a[0]["y"] = b"ABC"
+            a[1]["x"] = 2
+            a[1]["y"] = b"XYZ"
 
-        dt = np.dtype([('x', np.float32), ('y', np.dtype('S12'))])
+        dt = np.dtype([("x", np.float32), ("y", np.dtype("S12"))])
         a = np.zeros(2, dt)
 
         f[1, 1](a)
 
-        reference = np.asarray([(1, b'ABC'), (2, b'XYZ')], dtype=dt)
+        reference = np.asarray([(1, b"ABC"), (2, b"XYZ")], dtype=dt)
         np.testing.assert_array_equal(reference, a)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -5,30 +5,26 @@ from numba.cuda.testing import unittest, CUDATestCase
 from numba.core.config import ENABLE_CUDASIM
 
 CONST_EMPTY = np.array([])
-CONST1D = np.arange(10, dtype=np.float64) / 2.
-CONST2D = np.asfortranarray(
-    np.arange(100, dtype=np.int32).reshape(10, 10))
-CONST3D = ((np.arange(5 * 5 * 5, dtype=np.complex64).reshape(5, 5, 5) + 1j) /
-           2j)
+CONST1D = np.arange(10, dtype=np.float64) / 2.0
+CONST2D = np.asfortranarray(np.arange(100, dtype=np.int32).reshape(10, 10))
+CONST3D = (np.arange(5 * 5 * 5, dtype=np.complex64).reshape(5, 5, 5) + 1j) / 2j
 CONST3BYTES = np.arange(3, dtype=np.uint8)
 
-CONST_RECORD_EMPTY = np.array(
-    [],
-    dtype=[('x', float), ('y', int)])
-CONST_RECORD = np.array(
-    [(1.0, 2), (3.0, 4)],
-    dtype=[('x', float), ('y', int)])
+CONST_RECORD_EMPTY = np.array([], dtype=[("x", float), ("y", int)])
+CONST_RECORD = np.array([(1.0, 2), (3.0, 4)], dtype=[("x", float), ("y", int)])
 CONST_RECORD_ALIGN = np.array(
     [(1, 2, 3, 0xDEADBEEF, 8), (4, 5, 6, 0xBEEFDEAD, 10)],
     dtype=np.dtype(
         dtype=[
-            ('a', np.uint8),
-            ('b', np.uint8),
-            ('x', np.uint8),
-            ('y', np.uint32),
-            ('z', np.uint8),
+            ("a", np.uint8),
+            ("b", np.uint8),
+            ("x", np.uint8),
+            ("y", np.uint32),
+            ("z", np.uint8),
         ],
-        align=True))
+        align=True,
+    ),
+)
 
 
 def cuconstEmpty(A):
@@ -68,18 +64,18 @@ def cuconstRecEmpty(A):
 def cuconstRec(A, B):
     C = cuda.const.array_like(CONST_RECORD)
     i = cuda.grid(1)
-    A[i] = C[i]['x']
-    B[i] = C[i]['y']
+    A[i] = C[i]["x"]
+    B[i] = C[i]["y"]
 
 
 def cuconstRecAlign(A, B, C, D, E):
     Z = cuda.const.array_like(CONST_RECORD_ALIGN)
     i = cuda.grid(1)
-    A[i] = Z[i]['a']
-    B[i] = Z[i]['b']
-    C[i] = Z[i]['x']
-    D[i] = Z[i]['y']
-    E[i] = Z[i]['z']
+    A[i] = Z[i]["a"]
+    B[i] = Z[i]["b"]
+    C[i] = Z[i]["x"]
+    D[i] = Z[i]["y"]
+    E[i] = Z[i]["z"]
 
 
 def cuconstAlign(z):
@@ -99,50 +95,52 @@ class TestCudaConstantMemory(CUDATestCase):
 
         if not ENABLE_CUDASIM:
             self.assertIn(
-                'ld.const.f64',
+                "ld.const.f64",
                 jcuconst.inspect_asm(sig),
-                "as we're adding to it, load as a double")
+                "as we're adding to it, load as a double",
+            )
 
     def test_const_empty(self):
-        jcuconstEmpty = cuda.jit('void(int64[:])')(cuconstEmpty)
+        jcuconstEmpty = cuda.jit("void(int64[:])")(cuconstEmpty)
         A = np.full(1, fill_value=-1, dtype=np.int64)
         jcuconstEmpty[1, 1](A)
         self.assertTrue(np.all(A == 0))
 
     def test_const_align(self):
-        jcuconstAlign = cuda.jit('void(float64[:])')(cuconstAlign)
+        jcuconstAlign = cuda.jit("void(float64[:])")(cuconstAlign)
         A = np.full(3, fill_value=np.nan, dtype=float)
         jcuconstAlign[1, 3](A)
         self.assertTrue(np.all(A == (CONST3BYTES + CONST1D[:3])))
 
     def test_const_array_2d(self):
-        sig = (int32[:,:],)
+        sig = (int32[:, :],)
         jcuconst2d = cuda.jit(sig)(cuconst2d)
-        A = np.zeros_like(CONST2D, order='C')
+        A = np.zeros_like(CONST2D, order="C")
         jcuconst2d[(2, 2), (5, 5)](A)
         self.assertTrue(np.all(A == CONST2D))
 
         if not ENABLE_CUDASIM:
             self.assertIn(
-                'ld.const.u32',
+                "ld.const.u32",
                 jcuconst2d.inspect_asm(sig),
-                "load the ints as ints")
+                "load the ints as ints",
+            )
 
     def test_const_array_3d(self):
-        sig = (complex64[:,:,:],)
+        sig = (complex64[:, :, :],)
         jcuconst3d = cuda.jit(sig)(cuconst3d)
-        A = np.zeros_like(CONST3D, order='F')
+        A = np.zeros_like(CONST3D, order="F")
         jcuconst3d[1, (5, 5, 5)](A)
         self.assertTrue(np.all(A == CONST3D))
 
         if not ENABLE_CUDASIM:
             asm = jcuconst3d.inspect_asm(sig)
-            complex_load = 'ld.const.v2.f32'
-            description = 'Load the complex as a vector of 2x f32'
+            complex_load = "ld.const.v2.f32"
+            description = "Load the complex as a vector of 2x f32"
             self.assertIn(complex_load, asm, description)
 
     def test_const_record_empty(self):
-        jcuconstRecEmpty = cuda.jit('void(int64[:])')(cuconstRecEmpty)
+        jcuconstRecEmpty = cuda.jit("void(int64[:])")(cuconstRecEmpty)
         A = np.full(1, fill_value=-1, dtype=np.int64)
         jcuconstRecEmpty[1, 1](A)
         self.assertTrue(np.all(A == 0))
@@ -153,8 +151,8 @@ class TestCudaConstantMemory(CUDATestCase):
         jcuconst = cuda.jit(cuconstRec).specialize(A, B)
 
         jcuconst[2, 1](A, B)
-        np.testing.assert_allclose(A, CONST_RECORD['x'])
-        np.testing.assert_allclose(B, CONST_RECORD['y'])
+        np.testing.assert_allclose(A, CONST_RECORD["x"])
+        np.testing.assert_allclose(B, CONST_RECORD["y"])
 
     def test_const_record_align(self):
         A = np.zeros(2, dtype=np.float64)
@@ -165,12 +163,12 @@ class TestCudaConstantMemory(CUDATestCase):
         jcuconst = cuda.jit(cuconstRecAlign).specialize(A, B, C, D, E)
 
         jcuconst[2, 1](A, B, C, D, E)
-        np.testing.assert_allclose(A, CONST_RECORD_ALIGN['a'])
-        np.testing.assert_allclose(B, CONST_RECORD_ALIGN['b'])
-        np.testing.assert_allclose(C, CONST_RECORD_ALIGN['x'])
-        np.testing.assert_allclose(D, CONST_RECORD_ALIGN['y'])
-        np.testing.assert_allclose(E, CONST_RECORD_ALIGN['z'])
+        np.testing.assert_allclose(A, CONST_RECORD_ALIGN["a"])
+        np.testing.assert_allclose(B, CONST_RECORD_ALIGN["b"])
+        np.testing.assert_allclose(C, CONST_RECORD_ALIGN["x"])
+        np.testing.assert_allclose(D, CONST_RECORD_ALIGN["y"])
+        np.testing.assert_allclose(E, CONST_RECORD_ALIGN["z"])
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -3,9 +3,14 @@ from __future__ import print_function
 import numpy as np
 
 from numba import config, cuda, int32
-from numba.cuda.testing import (unittest, CUDATestCase, skip_on_cudasim,
-                                skip_unless_cc_60, skip_if_cudadevrt_missing,
-                                skip_if_mvc_enabled)
+from numba.cuda.testing import (
+    unittest,
+    CUDATestCase,
+    skip_on_cudasim,
+    skip_unless_cc_60,
+    skip_if_cudadevrt_missing,
+    skip_if_mvc_enabled,
+)
 
 
 @cuda.jit
@@ -47,7 +52,7 @@ def sequential_rows(M):
 
 
 @skip_if_cudadevrt_missing
-@skip_if_mvc_enabled('CG not supported with MVC')
+@skip_if_mvc_enabled("CG not supported with MVC")
 class TestCudaCooperativeGroups(CUDATestCase):
     @skip_unless_cc_60
     def test_this_grid(self):
@@ -55,11 +60,12 @@ class TestCudaCooperativeGroups(CUDATestCase):
         this_grid[1, 1](A)
 
         # Ensure the kernel executed beyond the call to cuda.this_grid()
-        self.assertFalse(np.isnan(A[0]), 'Value was not set')
+        self.assertFalse(np.isnan(A[0]), "Value was not set")
 
     @skip_unless_cc_60
-    @skip_on_cudasim("Simulator doesn't differentiate between normal and "
-                     "cooperative kernels")
+    @skip_on_cudasim(
+        "Simulator doesn't differentiate between normal and cooperative kernels"
+    )
     def test_this_grid_is_cooperative(self):
         A = np.full(1, fill_value=np.nan)
         this_grid[1, 1](A)
@@ -74,11 +80,12 @@ class TestCudaCooperativeGroups(CUDATestCase):
         sync_group[1, 1](A)
 
         # Ensure the kernel executed beyond the call to cuda.sync_group()
-        self.assertFalse(np.isnan(A[0]), 'Value was not set')
+        self.assertFalse(np.isnan(A[0]), "Value was not set")
 
     @skip_unless_cc_60
-    @skip_on_cudasim("Simulator doesn't differentiate between normal and "
-                     "cooperative kernels")
+    @skip_on_cudasim(
+        "Simulator doesn't differentiate between normal and cooperative kernels"
+    )
     def test_sync_group_is_cooperative(self):
         A = np.full(1, fill_value=np.nan)
         sync_group[1, 1](A)
@@ -99,7 +106,7 @@ class TestCudaCooperativeGroups(CUDATestCase):
         for key, overload in no_sync.overloads.items():
             self.assertFalse(overload.cooperative)
             for link in overload._codelibrary._linking_files:
-                self.assertNotIn('cudadevrt', link)
+                self.assertNotIn("cudadevrt", link)
 
     @skip_unless_cc_60
     def test_sync_at_matrix_row(self):
@@ -113,7 +120,7 @@ class TestCudaCooperativeGroups(CUDATestCase):
         blockdim = 32
         griddim = A.shape[1] // blockdim
 
-        sig = (int32[:,::1],)
+        sig = (int32[:, ::1],)
         c_sequential_rows = cuda.jit(sig)(sequential_rows)
 
         overload = c_sequential_rows.overloads[sig]
@@ -133,7 +140,7 @@ class TestCudaCooperativeGroups(CUDATestCase):
         # doesn't error, and that varying the number of dimensions of the block
         # whilst keeping the total number of threads constant doesn't change
         # the maximum to validate some of the logic.
-        sig = (int32[:,::1],)
+        sig = (int32[:, ::1],)
         c_sequential_rows = cuda.jit(sig)(sequential_rows)
         overload = c_sequential_rows.overloads[sig]
         blocks1d = overload.max_cooperative_grid_blocks(256)
@@ -143,5 +150,5 @@ class TestCudaCooperativeGroups(CUDATestCase):
         self.assertEqual(blocks1d, blocks3d)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()