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

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

@@ -7,12 +7,13 @@ from numba import cuda
 from numba.cuda.testing import skip_on_cudasim, CUDATestCase
 import unittest
 
-has_mp_get_context = hasattr(mp, 'get_context')
-is_unix = os.name == 'posix'
+has_mp_get_context = hasattr(mp, "get_context")
+is_unix = os.name == "posix"
 
 
 def fork_test(q):
     from numba.cuda.cudadrv.error import CudaDriverError
+
     try:
         cuda.to_device(np.arange(1))
     except CudaDriverError as e:
@@ -21,17 +22,17 @@ def fork_test(q):
         q.put(None)
 
 
-@skip_on_cudasim('disabled for cudasim')
+@skip_on_cudasim("disabled for cudasim")
 class TestMultiprocessing(CUDATestCase):
-    @unittest.skipUnless(has_mp_get_context, 'requires mp.get_context')
-    @unittest.skipUnless(is_unix, 'requires Unix')
+    @unittest.skipUnless(has_mp_get_context, "requires mp.get_context")
+    @unittest.skipUnless(is_unix, "requires Unix")
     def test_fork(self):
         """
         Test fork detection.
         """
         cuda.current_context()  # force cuda initialize
         # fork in process that also uses CUDA
-        ctx = mp.get_context('fork')
+        ctx = mp.get_context("fork")
         q = ctx.Queue()
         proc = ctx.Process(target=fork_test, args=[q])
         proc.start()
@@ -39,8 +40,8 @@ class TestMultiprocessing(CUDATestCase):
         proc.join()
         # there should be an exception raised in the child process
         self.assertIsNotNone(exc)
-        self.assertIn('CUDA initialized before forking', str(exc))
+        self.assertIn("CUDA initialized before forking", str(exc))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -3,8 +3,11 @@ import threading
 import multiprocessing
 import numpy as np
 from numba import cuda
-from numba.cuda.testing import (skip_on_cudasim, skip_under_cuda_memcheck,
-                                CUDATestCase)
+from numba.cuda.testing import (
+    skip_on_cudasim,
+    skip_under_cuda_memcheck,
+    CUDATestCase,
+)
 import unittest
 
 try:
@@ -15,7 +18,7 @@ else:
     has_concurrent_futures = True
 
 
-has_mp_get_context = hasattr(multiprocessing, 'get_context')
+has_mp_get_context = hasattr(multiprocessing, "get_context")
 
 
 def check_concurrent_compiling():
@@ -41,15 +44,14 @@ def spawn_process_entry(q):
     # Catch anything that goes wrong in the threads
     except:  # noqa: E722
         msg = traceback.format_exc()
-        q.put('\n'.join(['', '=' * 80, msg]))
+        q.put("\n".join(["", "=" * 80, msg]))
     else:
         q.put(None)
 
 
-@skip_under_cuda_memcheck('Hangs cuda-memcheck')
-@skip_on_cudasim('disabled for cudasim')
+@skip_under_cuda_memcheck("Hangs cuda-memcheck")
+@skip_on_cudasim("disabled for cudasim")
 class TestMultiThreadCompiling(CUDATestCase):
-
     @unittest.skipIf(not has_concurrent_futures, "no concurrent.futures")
     def test_concurrent_compiling(self):
         check_concurrent_compiling()
@@ -59,7 +61,7 @@ class TestMultiThreadCompiling(CUDATestCase):
         # force CUDA context init
         cuda.get_current_device()
         # use "spawn" to avoid inheriting the CUDA context
-        ctx = multiprocessing.get_context('spawn')
+        ctx = multiprocessing.get_context("spawn")
 
         q = ctx.Queue()
         p = ctx.Process(target=spawn_process_entry, args=(q,))
@@ -70,7 +72,7 @@ class TestMultiThreadCompiling(CUDATestCase):
             p.join()
         if err is not None:
             raise AssertionError(err)
-        self.assertEqual(p.exitcode, 0, 'test failed in child process')
+        self.assertEqual(p.exitcode, 0, "test failed in child process")
 
     def test_invalid_context_error_with_d2h(self):
         def d2h(arr, out):
@@ -97,5 +99,5 @@ class TestMultiThreadCompiling(CUDATestCase):
         np.testing.assert_equal(darr.copy_to_host(), arr)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -45,5 +45,5 @@ class TestCudaNonDet(CUDATestCase):
         np.testing.assert_array_almost_equal(dF.copy_to_host(), E)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -1,6 +1,10 @@
 import numpy as np
-from numba.cuda.testing import (unittest, CUDATestCase, skip_unless_cc_53,
-                                skip_on_cudasim)
+from numba.cuda.testing import (
+    unittest,
+    CUDATestCase,
+    skip_unless_cc_53,
+    skip_on_cudasim,
+)
 from numba import cuda
 from numba.core.types import f2, b1
 from numba.cuda import compile_ptx
@@ -73,12 +77,12 @@ def simple_fp16_ne(ary, a, b):
     ary[0] = a != b
 
 
-@cuda.jit('b1(f2, f2)', device=True)
+@cuda.jit("b1(f2, f2)", device=True)
 def hlt_func_1(x, y):
     return x < y
 
 
-@cuda.jit('b1(f2, f2)', device=True)
+@cuda.jit("b1(f2, f2)", device=True)
 def hlt_func_2(x, y):
     return x < y
 
@@ -116,6 +120,7 @@ class TestOperatorModule(CUDATestCase):
     """
     Test if operator module is supported by the CUDA target.
     """
+
     def operator_template(self, op):
         @cuda.jit
         def foo(a, b):
@@ -146,8 +151,12 @@ class TestOperatorModule(CUDATestCase):
 
     @skip_unless_cc_53
     def test_fp16_binary(self):
-        functions = (simple_fp16add, simple_fp16sub, simple_fp16mul,
-                     simple_fp16_div_scalar)
+        functions = (
+            simple_fp16add,
+            simple_fp16sub,
+            simple_fp16mul,
+            simple_fp16_div_scalar,
+        )
         ops = (operator.add, operator.sub, operator.mul, operator.truediv)
 
         for fn, op in zip(functions, ops):
@@ -162,10 +171,10 @@ class TestOperatorModule(CUDATestCase):
                 expected = op(arg1, arg2)
                 np.testing.assert_allclose(got, expected)
 
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_fp16_binary_ptx(self):
         functions = (simple_fp16add, simple_fp16sub, simple_fp16mul)
-        instrs = ('add.f16', 'sub.f16', 'mul.f16')
+        instrs = ("add.f16", "sub.f16", "mul.f16")
         args = (f2[:], f2, f2)
         for fn, instr in zip(functions, instrs):
             with self.subTest(instr=instr):
@@ -174,11 +183,14 @@ class TestOperatorModule(CUDATestCase):
 
     @skip_unless_cc_53
     def test_mixed_fp16_binary_arithmetic(self):
-        functions = (simple_fp16add, simple_fp16sub, simple_fp16mul,
-                     simple_fp16_div_scalar)
+        functions = (
+            simple_fp16add,
+            simple_fp16sub,
+            simple_fp16mul,
+            simple_fp16_div_scalar,
+        )
         ops = (operator.add, operator.sub, operator.mul, operator.truediv)
-        types = (np.int8, np.int16, np.int32, np.int64,
-                 np.float32, np.float64)
+        types = (np.int8, np.int16, np.int32, np.int64, np.float32, np.float64)
         for (fn, op), ty in itertools.product(zip(functions, ops), types):
             with self.subTest(op=op, ty=ty):
                 kernel = cuda.jit(fn)
@@ -192,10 +204,10 @@ class TestOperatorModule(CUDATestCase):
                 expected = op(arg1, arg2)
                 np.testing.assert_allclose(got, expected)
 
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_fp16_inplace_binary_ptx(self):
         functions = (simple_fp16_iadd, simple_fp16_isub, simple_fp16_imul)
-        instrs = ('add.f16', 'sub.f16', 'mul.f16')
+        instrs = ("add.f16", "sub.f16", "mul.f16")
         args = (f2[:], f2)
 
         for fn, instr in zip(functions, instrs):
@@ -205,8 +217,12 @@ class TestOperatorModule(CUDATestCase):
 
     @skip_unless_cc_53
     def test_fp16_inplace_binary(self):
-        functions = (simple_fp16_iadd, simple_fp16_isub, simple_fp16_imul,
-                     simple_fp16_idiv)
+        functions = (
+            simple_fp16_iadd,
+            simple_fp16_isub,
+            simple_fp16_imul,
+            simple_fp16_idiv,
+        )
         ops = (operator.iadd, operator.isub, operator.imul, operator.itruediv)
 
         for fn, op in zip(functions, ops):
@@ -236,26 +252,37 @@ class TestOperatorModule(CUDATestCase):
                 expected = op(arg1)
                 np.testing.assert_allclose(got, expected)
 
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_fp16_neg_ptx(self):
         args = (f2[:], f2)
         ptx, _ = compile_ptx(simple_fp16neg, args, cc=(5, 3))
-        self.assertIn('neg.f16', ptx)
+        self.assertIn("neg.f16", ptx)
 
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_fp16_abs_ptx(self):
         args = (f2[:], f2)
         ptx, _ = compile_ptx(simple_fp16abs, args, cc=(5, 3))
 
-        self.assertIn('abs.f16', ptx)
+        self.assertIn("abs.f16", ptx)
 
     @skip_unless_cc_53
     def test_fp16_comparison(self):
-        functions = (simple_fp16_gt, simple_fp16_ge,
-                     simple_fp16_lt, simple_fp16_le,
-                     simple_fp16_eq, simple_fp16_ne)
-        ops = (operator.gt, operator.ge, operator.lt, operator.le,
-               operator.eq, operator.ne)
+        functions = (
+            simple_fp16_gt,
+            simple_fp16_ge,
+            simple_fp16_lt,
+            simple_fp16_le,
+            simple_fp16_eq,
+            simple_fp16_ne,
+        )
+        ops = (
+            operator.gt,
+            operator.ge,
+            operator.lt,
+            operator.le,
+            operator.eq,
+            operator.ne,
+        )
 
         for fn, op in zip(functions, ops):
             with self.subTest(op=op):
@@ -271,16 +298,25 @@ class TestOperatorModule(CUDATestCase):
 
     @skip_unless_cc_53
     def test_mixed_fp16_comparison(self):
-        functions = (simple_fp16_gt, simple_fp16_ge,
-                     simple_fp16_lt, simple_fp16_le,
-                     simple_fp16_eq, simple_fp16_ne)
-        ops = (operator.gt, operator.ge, operator.lt, operator.le,
-               operator.eq, operator.ne)
-        types = (np.int8, np.int16, np.int32, np.int64,
-                 np.float32, np.float64)
-
-        for (fn, op), ty in itertools.product(zip(functions, ops),
-                                              types):
+        functions = (
+            simple_fp16_gt,
+            simple_fp16_ge,
+            simple_fp16_lt,
+            simple_fp16_le,
+            simple_fp16_eq,
+            simple_fp16_ne,
+        )
+        ops = (
+            operator.gt,
+            operator.ge,
+            operator.lt,
+            operator.le,
+            operator.eq,
+            operator.ne,
+        )
+        types = (np.int8, np.int16, np.int32, np.int64, np.float32, np.float64)
+
+        for (fn, op), ty in itertools.product(zip(functions, ops), types):
             with self.subTest(op=op, ty=ty):
                 kernel = cuda.jit(fn)
 
@@ -294,48 +330,68 @@ class TestOperatorModule(CUDATestCase):
 
     @skip_unless_cc_53
     def test_multiple_float16_comparisons(self):
-        functions = (test_multiple_hcmp_1,
-                     test_multiple_hcmp_2,
-                     test_multiple_hcmp_3,
-                     test_multiple_hcmp_4,
-                     test_multiple_hcmp_5)
+        functions = (
+            test_multiple_hcmp_1,
+            test_multiple_hcmp_2,
+            test_multiple_hcmp_3,
+            test_multiple_hcmp_4,
+            test_multiple_hcmp_5,
+        )
         for fn in functions:
             with self.subTest(fn=fn):
                 compiled = cuda.jit("void(b1[:], f2, f2, f2)")(fn)
                 ary = np.zeros(1, dtype=np.bool_)
-                arg1 = np.float16(2.)
-                arg2 = np.float16(3.)
-                arg3 = np.float16(4.)
+                arg1 = np.float16(2.0)
+                arg2 = np.float16(3.0)
+                arg3 = np.float16(4.0)
                 compiled[1, 1](ary, arg1, arg2, arg3)
                 self.assertTrue(ary[0])
 
     @skip_unless_cc_53
     def test_multiple_float16_comparisons_false(self):
-        functions = (test_multiple_hcmp_1,
-                     test_multiple_hcmp_2,
-                     test_multiple_hcmp_3,
-                     test_multiple_hcmp_4,
-                     test_multiple_hcmp_5)
+        functions = (
+            test_multiple_hcmp_1,
+            test_multiple_hcmp_2,
+            test_multiple_hcmp_3,
+            test_multiple_hcmp_4,
+            test_multiple_hcmp_5,
+        )
         for fn in functions:
             with self.subTest(fn=fn):
                 compiled = cuda.jit("void(b1[:], f2, f2, f2)")(fn)
                 ary = np.zeros(1, dtype=np.bool_)
-                arg1 = np.float16(2.)
-                arg2 = np.float16(3.)
-                arg3 = np.float16(1.)
+                arg1 = np.float16(2.0)
+                arg2 = np.float16(3.0)
+                arg3 = np.float16(1.0)
                 compiled[1, 1](ary, arg1, arg2, arg3)
                 self.assertFalse(ary[0])
 
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_fp16_comparison_ptx(self):
-        functions = (simple_fp16_gt, simple_fp16_ge,
-                     simple_fp16_lt, simple_fp16_le,
-                     simple_fp16_eq, simple_fp16_ne)
-        ops = (operator.gt, operator.ge, operator.lt, operator.le,
-               operator.eq, operator.ne)
-        opstring = ('setp.gt.f16', 'setp.ge.f16',
-                    'setp.lt.f16', 'setp.le.f16',
-                    'setp.eq.f16', 'setp.ne.f16')
+        functions = (
+            simple_fp16_gt,
+            simple_fp16_ge,
+            simple_fp16_lt,
+            simple_fp16_le,
+            simple_fp16_eq,
+            simple_fp16_ne,
+        )
+        ops = (
+            operator.gt,
+            operator.ge,
+            operator.lt,
+            operator.le,
+            operator.eq,
+            operator.ne,
+        )
+        opstring = (
+            "setp.gt.f16",
+            "setp.ge.f16",
+            "setp.lt.f16",
+            "setp.le.f16",
+            "setp.eq.f16",
+            "setp.ne.f16",
+        )
         args = (b1[:], f2, f2)
 
         for fn, op, s in zip(functions, ops, opstring):
@@ -343,51 +399,79 @@ class TestOperatorModule(CUDATestCase):
                 ptx, _ = compile_ptx(fn, args, cc=(5, 3))
                 self.assertIn(s, ptx)
 
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_fp16_int8_comparison_ptx(self):
         # Test that int8 can be safely converted to fp16
         # in a comparison
-        functions = (simple_fp16_gt, simple_fp16_ge,
-                     simple_fp16_lt, simple_fp16_le,
-                     simple_fp16_eq, simple_fp16_ne)
-        ops = (operator.gt, operator.ge, operator.lt, operator.le,
-               operator.eq, operator.ne)
-
-        opstring = {operator.gt:'setp.gt.f16',
-                    operator.ge:'setp.ge.f16',
-                    operator.lt:'setp.lt.f16',
-                    operator.le:'setp.le.f16',
-                    operator.eq:'setp.eq.f16',
-                    operator.ne:'setp.ne.f16'}
+        functions = (
+            simple_fp16_gt,
+            simple_fp16_ge,
+            simple_fp16_lt,
+            simple_fp16_le,
+            simple_fp16_eq,
+            simple_fp16_ne,
+        )
+        ops = (
+            operator.gt,
+            operator.ge,
+            operator.lt,
+            operator.le,
+            operator.eq,
+            operator.ne,
+        )
+
+        opstring = {
+            operator.gt: "setp.gt.f16",
+            operator.ge: "setp.ge.f16",
+            operator.lt: "setp.lt.f16",
+            operator.le: "setp.le.f16",
+            operator.eq: "setp.eq.f16",
+            operator.ne: "setp.ne.f16",
+        }
         for fn, op in zip(functions, ops):
             with self.subTest(op=op):
                 args = (b1[:], f2, from_dtype(np.int8))
                 ptx, _ = compile_ptx(fn, args, cc=(5, 3))
                 self.assertIn(opstring[op], ptx)
 
-    @skip_on_cudasim('Compilation unsupported in the simulator')
+    @skip_on_cudasim("Compilation unsupported in the simulator")
     def test_mixed_fp16_comparison_promotion_ptx(self):
-        functions = (simple_fp16_gt, simple_fp16_ge,
-                     simple_fp16_lt, simple_fp16_le,
-                     simple_fp16_eq, simple_fp16_ne)
-        ops = (operator.gt, operator.ge, operator.lt, operator.le,
-               operator.eq, operator.ne)
-
-        types_promote = (np.int16, np.int32, np.int64,
-                         np.float32, np.float64)
-        opstring = {operator.gt:'setp.gt.',
-                    operator.ge:'setp.ge.',
-                    operator.lt:'setp.lt.',
-                    operator.le:'setp.le.',
-                    operator.eq:'setp.eq.',
-                    operator.ne:'setp.neu.'}
-        opsuffix = {np.dtype('int32'): 'f64',
-                    np.dtype('int64'): 'f64',
-                    np.dtype('float32'): 'f32',
-                    np.dtype('float64'): 'f64'}
-
-        for (fn, op), ty in itertools.product(zip(functions, ops),
-                                              types_promote):
+        functions = (
+            simple_fp16_gt,
+            simple_fp16_ge,
+            simple_fp16_lt,
+            simple_fp16_le,
+            simple_fp16_eq,
+            simple_fp16_ne,
+        )
+        ops = (
+            operator.gt,
+            operator.ge,
+            operator.lt,
+            operator.le,
+            operator.eq,
+            operator.ne,
+        )
+
+        types_promote = (np.int16, np.int32, np.int64, np.float32, np.float64)
+        opstring = {
+            operator.gt: "setp.gt.",
+            operator.ge: "setp.ge.",
+            operator.lt: "setp.lt.",
+            operator.le: "setp.le.",
+            operator.eq: "setp.eq.",
+            operator.ne: "setp.neu.",
+        }
+        opsuffix = {
+            np.dtype("int32"): "f64",
+            np.dtype("int64"): "f64",
+            np.dtype("float32"): "f32",
+            np.dtype("float64"): "f64",
+        }
+
+        for (fn, op), ty in itertools.product(
+            zip(functions, ops), types_promote
+        ):
             with self.subTest(op=op, ty=ty):
                 arg2_ty = np.result_type(np.float16, ty)
                 args = (b1[:], f2, from_dtype(arg2_ty))
@@ -397,5 +481,5 @@ class TestOperatorModule(CUDATestCase):
                 self.assertIn(ops, ptx)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -18,10 +18,10 @@ def device_func(x, y, z):
 # the test function were more complex it may be possible to isolate additional
 # fragments of PTX we could check for the absence / presence of, but removal of
 # the use of local memory is a good indicator that optimization was applied.
-removed_by_opt = ( '__local_depot0',)
+removed_by_opt = ("__local_depot0",)
 
 
-@skip_on_cudasim('Simulator does not optimize code')
+@skip_on_cudasim("Simulator does not optimize code")
 class TestOptimization(CUDATestCase):
     def test_eager_opt(self):
         # Optimization should occur by default
@@ -74,7 +74,7 @@ class TestOptimization(CUDATestCase):
         sig = (float64, float64, float64)
         device = cuda.jit(sig, device=True)(device_func)
         ptx = device.inspect_asm(sig)
-        self.assertIn('fma.rn.f64', ptx)
+        self.assertIn("fma.rn.f64", ptx)
 
     def test_device_noopt(self):
         # Optimization disabled
@@ -82,8 +82,8 @@ class TestOptimization(CUDATestCase):
         device = cuda.jit(sig, device=True, opt=False)(device_func)
         ptx = device.inspect_asm(sig)
         # Fused-multiply adds should be disabled when not optimizing
-        self.assertNotIn('fma.rn.f64', ptx)
+        self.assertNotIn("fma.rn.f64", ptx)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()