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

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

@@ -13,9 +13,11 @@ import unittest
 # Signatures to test with - these are all homogeneous in dtype, so the output
 # dtype should match the input dtype - the output should not have been cast
 # upwards, as reported in #8400: https://github.com/numba/numba/issues/8400
-signatures = [int32(int32, int32),
-              float32(float32, float32),
-              float64(float64, float64)]
+signatures = [
+    int32(int32, int32),
+    float32(float32, float32),
+    float64(float64, float64),
+]
 
 # The order here is chosen such that each subsequent dtype might have been
 # casted to a previously-used dtype. This is unlikely to be an issue for CUDA,
@@ -25,16 +27,16 @@ signatures = [int32(int32, int32),
 dtypes = (np.float64, np.float32, np.int32)
 
 # NumPy ndarray orders
-orders = ('C', 'F')
+orders = ("C", "F")
 
 # Input sizes corresponding to operations:
 # - Less than one warp,
 # - Less than one block,
 # - Greater than one block (i.e. many blocks)
-input_sizes = (8, 100, 2 ** 10 + 1)
+input_sizes = (8, 100, 2**10 + 1)
 
 
-@skip_on_cudasim('ufunc API unsupported in the simulator')
+@skip_on_cudasim("ufunc API unsupported in the simulator")
 class TestCUDAVectorize(CUDATestCase):
     # Presumably chosen as an odd number unlikely to coincide with the total
     # thread count, and large enough to ensure a significant number of blocks
@@ -42,8 +44,7 @@ class TestCUDAVectorize(CUDATestCase):
     N = 1000001
 
     def test_scalar(self):
-
-        @vectorize(signatures, target='cuda')
+        @vectorize(signatures, target="cuda")
         def vector_add(a, b):
             return a + b
 
@@ -53,8 +54,7 @@ class TestCUDAVectorize(CUDATestCase):
         self.assertEqual(c, a + b)
 
     def test_1d(self):
-
-        @vectorize(signatures, target='cuda')
+        @vectorize(signatures, target="cuda")
         def vector_add(a, b):
             return a + b
 
@@ -66,8 +66,7 @@ class TestCUDAVectorize(CUDATestCase):
             self.assertEqual(actual.dtype, ty)
 
     def test_1d_async(self):
-
-        @vectorize(signatures, target='cuda')
+        @vectorize(signatures, target="cuda")
         def vector_add(a, b):
             return a + b
 
@@ -86,8 +85,7 @@ class TestCUDAVectorize(CUDATestCase):
             self.assertEqual(actual.dtype, ty)
 
     def test_nd(self):
-
-        @vectorize(signatures, target='cuda')
+        @vectorize(signatures, target="cuda")
         def vector_add(a, b):
             return a + b
 
@@ -102,7 +100,7 @@ class TestCUDAVectorize(CUDATestCase):
             self.assertEqual(actual.dtype, dtype)
 
     def test_output_arg(self):
-        @vectorize(signatures, target='cuda')
+        @vectorize(signatures, target="cuda")
         def vector_add(a, b):
             return a + b
 
@@ -117,7 +115,7 @@ class TestCUDAVectorize(CUDATestCase):
         self.assertEqual(expected.dtype, actual.dtype)
 
     def test_reduce(self):
-        @vectorize(signatures, target='cuda')
+        @vectorize(signatures, target="cuda")
         def vector_add(a, b):
             return a + b
 
@@ -135,8 +133,7 @@ class TestCUDAVectorize(CUDATestCase):
             self.assertEqual(dtype, actual.dtype)
 
     def test_reduce_async(self):
-
-        @vectorize(signatures, target='cuda')
+        @vectorize(signatures, target="cuda")
         def vector_add(a, b):
             return a + b
 
@@ -153,7 +150,7 @@ class TestCUDAVectorize(CUDATestCase):
             self.assertEqual(dtype, actual.dtype)
 
     def test_manual_transfer(self):
-        @vectorize(signatures, target='cuda')
+        @vectorize(signatures, target="cuda")
         def vector_add(a, b):
             return a + b
 
@@ -166,7 +163,7 @@ class TestCUDAVectorize(CUDATestCase):
         self.assertEqual(expected.dtype, actual.dtype)
 
     def test_ufunc_output_2d(self):
-        @vectorize(signatures, target='cuda')
+        @vectorize(signatures, target="cuda")
         def vector_add(a, b):
             return a + b
 
@@ -181,7 +178,7 @@ class TestCUDAVectorize(CUDATestCase):
         self.assertEqual(expected.dtype, actual.dtype)
 
     def check_tuple_arg(self, a, b):
-        @vectorize(signatures, target='cuda')
+        @vectorize(signatures, target="cuda")
         def vector_add(a, b):
             return a + b
 
@@ -194,7 +191,7 @@ class TestCUDAVectorize(CUDATestCase):
         self.check_tuple_arg(a, b)
 
     def test_namedtuple_arg(self):
-        Point = namedtuple('Point', ('x', 'y', 'z'))
+        Point = namedtuple("Point", ("x", "y", "z"))
         a = Point(x=1.0, y=2.0, z=3.0)
         b = Point(x=4.0, y=5.0, z=6.0)
         self.check_tuple_arg(a, b)
@@ -206,7 +203,7 @@ class TestCUDAVectorize(CUDATestCase):
         self.check_tuple_arg(a, b)
 
     def test_tuple_of_namedtuple_arg(self):
-        Point = namedtuple('Point', ('x', 'y', 'z'))
+        Point = namedtuple("Point", ("x", "y", "z"))
         a = (Point(x=1.0, y=2.0, z=3.0), Point(x=1.5, y=2.5, z=3.5))
         b = (Point(x=4.0, y=5.0, z=6.0), Point(x=4.5, y=5.5, z=6.5))
         self.check_tuple_arg(a, b)
@@ -216,17 +213,17 @@ class TestCUDAVectorize(CUDATestCase):
         ys1 = xs1 + 2
         xs2 = np.arange(10, dtype=np.int32) * 2
         ys2 = xs2 + 1
-        Points = namedtuple('Points', ('xs', 'ys'))
+        Points = namedtuple("Points", ("xs", "ys"))
         a = Points(xs=xs1, ys=ys1)
         b = Points(xs=xs2, ys=ys2)
         self.check_tuple_arg(a, b)
 
     def test_name_attribute(self):
-        @vectorize('f8(f8)', target='cuda')
+        @vectorize("f8(f8)", target="cuda")
         def bar(x):
-            return x ** 2
+            return x**2
 
-        self.assertEqual(bar.__name__, 'bar')
+        self.assertEqual(bar.__name__, "bar")
 
     def test_no_transfer_for_device_data(self):
         # Initialize test data on the device prior to banning host <-> device
@@ -238,15 +235,15 @@ class TestCUDAVectorize(CUDATestCase):
         # A mock of a CUDA function that always raises a CudaAPIError
 
         def raising_transfer(*args, **kwargs):
-            raise CudaAPIError(999, 'Transfer not allowed')
+            raise CudaAPIError(999, "Transfer not allowed")
 
         # Use the mock for transfers between the host and device
 
-        old_HtoD = getattr(driver, 'cuMemcpyHtoD', None)
-        old_DtoH = getattr(driver, 'cuMemcpyDtoH', None)
+        old_HtoD = getattr(driver, "cuMemcpyHtoD", None)
+        old_DtoH = getattr(driver, "cuMemcpyDtoH", None)
 
-        setattr(driver, 'cuMemcpyHtoD', raising_transfer)
-        setattr(driver, 'cuMemcpyDtoH', raising_transfer)
+        setattr(driver, "cuMemcpyHtoD", raising_transfer)
+        setattr(driver, "cuMemcpyDtoH", raising_transfer)
 
         # Ensure that the mock functions are working as expected
 
@@ -260,7 +257,7 @@ class TestCUDAVectorize(CUDATestCase):
             # Check that defining and calling a ufunc with data on the device
             # induces no transfers
 
-            @vectorize(['float32(float32)'], target='cuda')
+            @vectorize(["float32(float32)"], target="cuda")
             def func(noise):
                 return noise + 1.0
 
@@ -270,14 +267,14 @@ class TestCUDAVectorize(CUDATestCase):
             # no original implementation, simply remove ours.
 
             if old_HtoD is not None:
-                setattr(driver, 'cuMemcpyHtoD', old_HtoD)
+                setattr(driver, "cuMemcpyHtoD", old_HtoD)
             else:
                 del driver.cuMemcpyHtoD
             if old_DtoH is not None:
-                setattr(driver, 'cuMemcpyDtoH', old_DtoH)
+                setattr(driver, "cuMemcpyDtoH", old_DtoH)
             else:
                 del driver.cuMemcpyDtoH
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -4,17 +4,17 @@ from numba.cuda.testing import skip_on_cudasim, CUDATestCase
 import unittest
 
 
-@skip_on_cudasim('ufunc API unsupported in the simulator')
+@skip_on_cudasim("ufunc API unsupported in the simulator")
 class TestVectorizeComplex(CUDATestCase):
     def test_vectorize_complex(self):
-        @vectorize(['complex128(complex128)'], target='cuda')
+        @vectorize(["complex128(complex128)"], target="cuda")
         def vcomp(a):
-            return a * a + 1.
+            return a * a + 1.0
 
         A = np.arange(5, dtype=np.complex128)
         B = vcomp(A)
-        self.assertTrue(np.allclose(A * A + 1., B))
+        self.assertTrue(np.allclose(A * A + 1.0, B))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -1,21 +1,25 @@
 import numpy as np
 
 from numba import vectorize, cuda
-from numba.tests.npyufunc.test_vectorize_decor import BaseVectorizeDecor, \
-    BaseVectorizeNopythonArg, BaseVectorizeUnrecognizedArg
+from numba.tests.npyufunc.test_vectorize_decor import (
+    BaseVectorizeDecor,
+    BaseVectorizeNopythonArg,
+    BaseVectorizeUnrecognizedArg,
+)
 from numba.cuda.testing import skip_on_cudasim, CUDATestCase
 import unittest
 
 
-@skip_on_cudasim('ufunc API unsupported in the simulator')
+@skip_on_cudasim("ufunc API unsupported in the simulator")
 class TestVectorizeDecor(CUDATestCase, BaseVectorizeDecor):
     """
     Runs the tests from BaseVectorizeDecor with the CUDA target.
     """
-    target = 'cuda'
 
+    target = "cuda"
 
-@skip_on_cudasim('ufunc API unsupported in the simulator')
+
+@skip_on_cudasim("ufunc API unsupported in the simulator")
 class TestGPUVectorizeBroadcast(CUDATestCase):
     def test_broadcast(self):
         a = np.random.randn(100, 3, 1)
@@ -24,7 +28,7 @@ class TestGPUVectorizeBroadcast(CUDATestCase):
         def fn(a, b):
             return a - b
 
-        @vectorize(['float64(float64,float64)'], target='cuda')
+        @vectorize(["float64(float64,float64)"], target="cuda")
         def fngpu(a, b):
             return a - b
 
@@ -43,7 +47,7 @@ class TestGPUVectorizeBroadcast(CUDATestCase):
         def fn(a, b):
             return a - b
 
-        @vectorize(['float64(float64,float64)'], target='cuda')
+        @vectorize(["float64(float64,float64)"], target="cuda")
         def fngpu(a, b):
             return a - b
 
@@ -52,18 +56,18 @@ class TestGPUVectorizeBroadcast(CUDATestCase):
         np.testing.assert_almost_equal(expect, got.copy_to_host())
 
 
-@skip_on_cudasim('ufunc API unsupported in the simulator')
+@skip_on_cudasim("ufunc API unsupported in the simulator")
 class TestVectorizeNopythonArg(BaseVectorizeNopythonArg, CUDATestCase):
     def test_target_cuda_nopython(self):
         warnings = ["nopython kwarg for cuda target is redundant"]
-        self._test_target_nopython('cuda', warnings)
+        self._test_target_nopython("cuda", warnings)
 
 
-@skip_on_cudasim('ufunc API unsupported in the simulator')
+@skip_on_cudasim("ufunc API unsupported in the simulator")
 class TestVectorizeUnrecognizedArg(BaseVectorizeUnrecognizedArg, CUDATestCase):
     def test_target_cuda_unrecognized_arg(self):
-        self._test_target_unrecognized_arg('cuda')
+        self._test_target_unrecognized_arg("cuda")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -5,19 +5,19 @@ from numba.cuda.testing import skip_on_cudasim, CUDATestCase
 import unittest
 
 
-@skip_on_cudasim('ufunc API unsupported in the simulator')
+@skip_on_cudasim("ufunc API unsupported in the simulator")
 class TestCudaVectorizeDeviceCall(CUDATestCase):
     def test_cuda_vectorize_device_call(self):
-
         @cuda.jit(float32(float32, float32, float32), device=True)
         def cu_device_fn(x, y, z):
-            return x ** y / z
+            return x**y / z
 
         def cu_ufunc(x, y, z):
             return cu_device_fn(x, y, z)
 
-        ufunc = vectorize([float32(float32, float32, float32)], target='cuda')(
-            cu_ufunc)
+        ufunc = vectorize([float32(float32, float32, float32)], target="cuda")(
+            cu_ufunc
+        )
 
         N = 100
 
@@ -27,10 +27,10 @@ class TestCudaVectorizeDeviceCall(CUDATestCase):
 
         out = ufunc(X, Y, Z)
 
-        gold = (X ** Y) / Z
+        gold = (X**Y) / Z
 
         self.assertTrue(np.allclose(out, gold))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -7,11 +7,10 @@ import unittest
 sig = [float64(float64, float64)]
 
 
-@skip_on_cudasim('ufunc API unsupported in the simulator')
+@skip_on_cudasim("ufunc API unsupported in the simulator")
 class TestCUDAVectorizeScalarArg(CUDATestCase):
-
     def test_vectorize_scalar_arg(self):
-        @vectorize(sig, target='cuda')
+        @vectorize(sig, target="cuda")
         def vector_add(a, b):
             return a + b
 
@@ -20,11 +19,11 @@ class TestCUDAVectorizeScalarArg(CUDATestCase):
         v = vector_add(1.0, dA)
 
         np.testing.assert_array_almost_equal(
-            v.copy_to_host(),
-            np.arange(1, 11, dtype=np.float64))
+            v.copy_to_host(), np.arange(1, 11, dtype=np.float64)
+        )
 
     def test_vectorize_all_scalars(self):
-        @vectorize(sig, target='cuda')
+        @vectorize(sig, target="cuda")
         def vector_add(a, b):
             return a + b
 
@@ -33,5 +32,5 @@ class TestCUDAVectorizeScalarArg(CUDATestCase):
         np.testing.assert_almost_equal(2.0, v)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

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

@@ -7,27 +7,27 @@ from numba.core import config
 import warnings
 
 
-@skip_on_cudasim('cudasim does not raise performance warnings')
+@skip_on_cudasim("cudasim does not raise performance warnings")
 class TestWarnings(CUDATestCase):
     def test_inefficient_launch_configuration(self):
         @cuda.jit
         def kernel():
             pass
 
-        with override_config('CUDA_LOW_OCCUPANCY_WARNINGS', 1):
+        with override_config("CUDA_LOW_OCCUPANCY_WARNINGS", 1):
             with warnings.catch_warnings(record=True) as w:
                 kernel[1, 1]()
 
         self.assertEqual(w[0].category, NumbaPerformanceWarning)
-        self.assertIn('Grid size', str(w[0].message))
-        self.assertIn('low occupancy', str(w[0].message))
+        self.assertIn("Grid size", str(w[0].message))
+        self.assertIn("low occupancy", str(w[0].message))
 
     def test_efficient_launch_configuration(self):
         @cuda.jit
         def kernel():
             pass
 
-        with override_config('CUDA_LOW_OCCUPANCY_WARNINGS', 1):
+        with override_config("CUDA_LOW_OCCUPANCY_WARNINGS", 1):
             with warnings.catch_warnings(record=True) as w:
                 kernel[256, 256]()
 
@@ -40,14 +40,15 @@ class TestWarnings(CUDATestCase):
 
         N = 10
         arr_f32 = np.zeros(N, dtype=np.float32)
-        with override_config('CUDA_WARN_ON_IMPLICIT_COPY', 1):
+        with override_config("CUDA_WARN_ON_IMPLICIT_COPY", 1):
             with warnings.catch_warnings(record=True) as w:
                 foo[1, N](arr_f32, N)
 
         self.assertEqual(w[0].category, NumbaPerformanceWarning)
-        self.assertIn('Host array used in CUDA kernel will incur',
-                      str(w[0].message))
-        self.assertIn('copy overhead', str(w[0].message))
+        self.assertIn(
+            "Host array used in CUDA kernel will incur", str(w[0].message)
+        )
+        self.assertIn("copy overhead", str(w[0].message))
 
     def test_pinned_warn_on_host_array(self):
         @cuda.jit
@@ -57,14 +58,15 @@ class TestWarnings(CUDATestCase):
         N = 10
         ary = cuda.pinned_array(N, dtype=np.float32)
 
-        with override_config('CUDA_WARN_ON_IMPLICIT_COPY', 1):
+        with override_config("CUDA_WARN_ON_IMPLICIT_COPY", 1):
             with warnings.catch_warnings(record=True) as w:
                 foo[1, N](ary, N)
 
         self.assertEqual(w[0].category, NumbaPerformanceWarning)
-        self.assertIn('Host array used in CUDA kernel will incur',
-                      str(w[0].message))
-        self.assertIn('copy overhead', str(w[0].message))
+        self.assertIn(
+            "Host array used in CUDA kernel will incur", str(w[0].message)
+        )
+        self.assertIn("copy overhead", str(w[0].message))
 
     def test_nowarn_on_mapped_array(self):
         @cuda.jit
@@ -74,7 +76,7 @@ class TestWarnings(CUDATestCase):
         N = 10
         ary = cuda.mapped_array(N, dtype=np.float32)
 
-        with override_config('CUDA_WARN_ON_IMPLICIT_COPY', 1):
+        with override_config("CUDA_WARN_ON_IMPLICIT_COPY", 1):
             with warnings.catch_warnings(record=True) as w:
                 foo[1, N](ary, N)
 
@@ -89,7 +91,7 @@ class TestWarnings(CUDATestCase):
         N = 10
         ary = cuda.managed_array(N, dtype=np.float32)
 
-        with override_config('CUDA_WARN_ON_IMPLICIT_COPY', 1):
+        with override_config("CUDA_WARN_ON_IMPLICIT_COPY", 1):
             with warnings.catch_warnings(record=True) as w:
                 foo[1, N](ary, N)
 
@@ -103,7 +105,7 @@ class TestWarnings(CUDATestCase):
         N = 10
         ary = cuda.device_array(N, dtype=np.float32)
 
-        with override_config('CUDA_WARN_ON_IMPLICIT_COPY', 1):
+        with override_config("CUDA_WARN_ON_IMPLICIT_COPY", 1):
             with warnings.catch_warnings(record=True) as w:
                 foo[1, N](ary, N)
 
@@ -114,14 +116,14 @@ class TestWarnings(CUDATestCase):
             cuda.jit(debug=True, opt=True)
 
         self.assertEqual(len(w), 1)
-        self.assertIn('not supported by CUDA', str(w[0].message))
+        self.assertIn("not supported by CUDA", str(w[0].message))
 
     def test_warn_on_debug_and_opt_default(self):
         with warnings.catch_warnings(record=True) as w:
             cuda.jit(debug=True)
 
         self.assertEqual(len(w), 1)
-        self.assertIn('not supported by CUDA', str(w[0].message))
+        self.assertIn("not supported by CUDA", str(w[0].message))
 
     def test_no_warn_on_debug_and_no_opt(self):
         with warnings.catch_warnings(record=True) as w:
@@ -136,8 +138,8 @@ class TestWarnings(CUDATestCase):
         self.assertEqual(len(w), 0)
 
     def test_no_warn_on_debug_and_opt_with_config(self):
-        with override_config('CUDA_DEBUGINFO_DEFAULT', 1):
-            with override_config('OPT', config._OptLevel(0)):
+        with override_config("CUDA_DEBUGINFO_DEFAULT", 1):
+            with override_config("OPT", config._OptLevel(0)):
                 with warnings.catch_warnings(record=True) as w:
                     cuda.jit()
 
@@ -148,30 +150,30 @@ class TestWarnings(CUDATestCase):
 
             self.assertEqual(len(w), 0)
 
-        with override_config('OPT', config._OptLevel(0)):
+        with override_config("OPT", config._OptLevel(0)):
             with warnings.catch_warnings(record=True) as w:
                 cuda.jit(debug=True)
 
             self.assertEqual(len(w), 0)
 
     def test_warn_on_debug_and_opt_with_config(self):
-        with override_config('CUDA_DEBUGINFO_DEFAULT', 1):
-            for opt in (1, 2, 3, 'max'):
-                with override_config('OPT', config._OptLevel(opt)):
+        with override_config("CUDA_DEBUGINFO_DEFAULT", 1):
+            for opt in (1, 2, 3, "max"):
+                with override_config("OPT", config._OptLevel(opt)):
                     with warnings.catch_warnings(record=True) as w:
                         cuda.jit()
 
                 self.assertEqual(len(w), 1)
-                self.assertIn('not supported by CUDA', str(w[0].message))
+                self.assertIn("not supported by CUDA", str(w[0].message))
 
-        for opt in (1, 2, 3, 'max'):
-            with override_config('OPT', config._OptLevel(opt)):
+        for opt in (1, 2, 3, "max"):
+            with override_config("OPT", config._OptLevel(opt)):
                 with warnings.catch_warnings(record=True) as w:
                     cuda.jit(debug=True)
 
                 self.assertEqual(len(w), 1)
-                self.assertIn('not supported by CUDA', str(w[0].message))
+                self.assertIn("not supported by CUDA", str(w[0].message))
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()