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

numba_cuda/numba/cuda/tests/nocuda/test_library_lookup.py

@@ -21,12 +21,12 @@ from numba.cuda.cuda_paths import (
 
 
 has_cuda = nvvm.is_available()
-has_mp_get_context = hasattr(mp, 'get_context')
+has_mp_get_context = hasattr(mp, "get_context")
 
 
 class LibraryLookupBase(SerialMixin, unittest.TestCase):
     def setUp(self):
-        ctx = mp.get_context('spawn')
+        ctx = mp.get_context("spawn")
 
         qrecv = ctx.Queue()
         qsend = ctx.Queue()
@@ -84,108 +84,108 @@ def check_lib_lookup(qout, qin):
                 status = False
 
 
-@skip_on_cudasim('Library detection unsupported in the simulator')
-@unittest.skipUnless(has_mp_get_context, 'mp.get_context not available')
-@skip_unless_conda_cudatoolkit('test assumes conda installed cudatoolkit')
+@skip_on_cudasim("Library detection unsupported in the simulator")
+@unittest.skipUnless(has_mp_get_context, "mp.get_context not available")
+@skip_unless_conda_cudatoolkit("test assumes conda installed cudatoolkit")
 class TestLibDeviceLookUp(LibraryLookupBase):
     def test_libdevice_path_decision(self):
         # Check that the default is using conda environment
         by, info, warns = self.remote_do(self.do_clear_envs)
         if has_cuda:
-            self.assertEqual(by, 'Conda environment')
+            self.assertEqual(by, "Conda environment")
         else:
             self.assertEqual(by, "<unknown>")
             self.assertIsNone(info)
         self.assertFalse(warns)
         # Check that CUDA_HOME works by removing conda-env
         by, info, warns = self.remote_do(self.do_set_cuda_home)
-        self.assertEqual(by, 'CUDA_HOME')
-        self.assertEqual(info, os.path.join('mycudahome', 'nvvm', 'libdevice'))
+        self.assertEqual(by, "CUDA_HOME")
+        self.assertEqual(info, os.path.join("mycudahome", "nvvm", "libdevice"))
         self.assertFalse(warns)
 
         if get_system_ctk() is None:
             # Fake remove conda environment so no cudatoolkit is available
             by, info, warns = self.remote_do(self.do_clear_envs)
-            self.assertEqual(by, '<unknown>')
+            self.assertEqual(by, "<unknown>")
             self.assertIsNone(info)
             self.assertFalse(warns)
         else:
             # Use system available cudatoolkit
             by, info, warns = self.remote_do(self.do_clear_envs)
-            self.assertEqual(by, 'System')
+            self.assertEqual(by, "System")
             self.assertFalse(warns)
 
     @staticmethod
     def do_clear_envs():
-        remove_env('CUDA_HOME')
-        remove_env('CUDA_PATH')
+        remove_env("CUDA_HOME")
+        remove_env("CUDA_PATH")
         return True, _get_libdevice_path_decision()
 
     @staticmethod
     def do_set_cuda_home():
-        os.environ['CUDA_HOME'] = os.path.join('mycudahome')
+        os.environ["CUDA_HOME"] = os.path.join("mycudahome")
         _fake_non_conda_env()
         return True, _get_libdevice_path_decision()
 
 
-@skip_on_cudasim('Library detection unsupported in the simulator')
-@unittest.skipUnless(has_mp_get_context, 'mp.get_context not available')
-@skip_unless_conda_cudatoolkit('test assumes conda installed cudatoolkit')
+@skip_on_cudasim("Library detection unsupported in the simulator")
+@unittest.skipUnless(has_mp_get_context, "mp.get_context not available")
+@skip_unless_conda_cudatoolkit("test assumes conda installed cudatoolkit")
 class TestNvvmLookUp(LibraryLookupBase):
     def test_nvvm_path_decision(self):
         # Check that the default is using conda environment
         by, info, warns = self.remote_do(self.do_clear_envs)
         if has_cuda:
-            self.assertEqual(by, 'Conda environment')
+            self.assertEqual(by, "Conda environment")
         else:
             self.assertEqual(by, "<unknown>")
             self.assertIsNone(info)
         self.assertFalse(warns)
         # Check that CUDA_HOME works by removing conda-env
         by, info, warns = self.remote_do(self.do_set_cuda_home)
-        self.assertEqual(by, 'CUDA_HOME')
+        self.assertEqual(by, "CUDA_HOME")
         self.assertFalse(warns)
         if IS_WIN32:
-            self.assertEqual(info, os.path.join('mycudahome', 'nvvm', 'bin'))
+            self.assertEqual(info, os.path.join("mycudahome", "nvvm", "bin"))
         elif IS_OSX:
-            self.assertEqual(info, os.path.join('mycudahome', 'nvvm', 'lib'))
+            self.assertEqual(info, os.path.join("mycudahome", "nvvm", "lib"))
         else:
-            self.assertEqual(info, os.path.join('mycudahome', 'nvvm', 'lib64'))
+            self.assertEqual(info, os.path.join("mycudahome", "nvvm", "lib64"))
 
         if get_system_ctk() is None:
             # Fake remove conda environment so no cudatoolkit is available
             by, info, warns = self.remote_do(self.do_clear_envs)
-            self.assertEqual(by, '<unknown>')
+            self.assertEqual(by, "<unknown>")
             self.assertIsNone(info)
             self.assertFalse(warns)
         else:
             # Use system available cudatoolkit
             by, info, warns = self.remote_do(self.do_clear_envs)
-            self.assertEqual(by, 'System')
+            self.assertEqual(by, "System")
             self.assertFalse(warns)
 
     @staticmethod
     def do_clear_envs():
-        remove_env('CUDA_HOME')
-        remove_env('CUDA_PATH')
+        remove_env("CUDA_HOME")
+        remove_env("CUDA_PATH")
         return True, _get_nvvm_path_decision()
 
     @staticmethod
     def do_set_cuda_home():
-        os.environ['CUDA_HOME'] = os.path.join('mycudahome')
+        os.environ["CUDA_HOME"] = os.path.join("mycudahome")
         _fake_non_conda_env()
         return True, _get_nvvm_path_decision()
 
 
-@skip_on_cudasim('Library detection unsupported in the simulator')
-@unittest.skipUnless(has_mp_get_context, 'mp.get_context not available')
-@skip_unless_conda_cudatoolkit('test assumes conda installed cudatoolkit')
+@skip_on_cudasim("Library detection unsupported in the simulator")
+@unittest.skipUnless(has_mp_get_context, "mp.get_context not available")
+@skip_unless_conda_cudatoolkit("test assumes conda installed cudatoolkit")
 class TestCudaLibLookUp(LibraryLookupBase):
     def test_cudalib_path_decision(self):
         # Check that the default is using conda environment
         by, info, warns = self.remote_do(self.do_clear_envs)
         if has_cuda:
-            self.assertEqual(by, 'Conda environment')
+            self.assertEqual(by, "Conda environment")
         else:
             self.assertEqual(by, "<unknown>")
             self.assertIsNone(info)
@@ -194,14 +194,14 @@ class TestCudaLibLookUp(LibraryLookupBase):
         # Check that CUDA_HOME works by removing conda-env
         self.remote_do(self.do_clear_envs)
         by, info, warns = self.remote_do(self.do_set_cuda_home)
-        self.assertEqual(by, 'CUDA_HOME')
+        self.assertEqual(by, "CUDA_HOME")
         self.assertFalse(warns)
         if IS_WIN32:
-            self.assertEqual(info, os.path.join('mycudahome', 'bin'))
+            self.assertEqual(info, os.path.join("mycudahome", "bin"))
         elif IS_OSX:
-            self.assertEqual(info, os.path.join('mycudahome', 'lib'))
+            self.assertEqual(info, os.path.join("mycudahome", "lib"))
         else:
-            self.assertEqual(info, os.path.join('mycudahome', 'lib64'))
+            self.assertEqual(info, os.path.join("mycudahome", "lib64"))
         if get_system_ctk() is None:
             # Fake remove conda environment so no cudatoolkit is available
             by, info, warns = self.remote_do(self.do_clear_envs)
@@ -211,18 +211,18 @@ class TestCudaLibLookUp(LibraryLookupBase):
         else:
             # Use system available cudatoolkit
             by, info, warns = self.remote_do(self.do_clear_envs)
-            self.assertEqual(by, 'System')
+            self.assertEqual(by, "System")
             self.assertFalse(warns)
 
     @staticmethod
     def do_clear_envs():
-        remove_env('CUDA_HOME')
-        remove_env('CUDA_PATH')
+        remove_env("CUDA_HOME")
+        remove_env("CUDA_PATH")
         return True, _get_cudalib_dir_path_decision()
 
     @staticmethod
     def do_set_cuda_home():
-        os.environ['CUDA_HOME'] = os.path.join('mycudahome')
+        os.environ["CUDA_HOME"] = os.path.join("mycudahome")
         _fake_non_conda_env()
         return True, _get_cudalib_dir_path_decision()
 
@@ -231,8 +231,8 @@ def _fake_non_conda_env():
     """
     Monkeypatch sys.prefix to hide the fact we are in a conda-env
     """
-    sys.prefix = ''
+    sys.prefix = ""
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/nocuda/test_nvvm.py

@@ -8,14 +8,17 @@ from llvmlite import binding as llvm
 import unittest
 
 
-original = "call void @llvm.memset.p0i8.i64(" \
-           "i8* align 4 %arg.x.41, i8 0, i64 %0, i1 false)"
+original = (
+    "call void @llvm.memset.p0i8.i64("
+    "i8* align 4 %arg.x.41, i8 0, i64 %0, i1 false)"
+)
 
-missing_align = "call void @llvm.memset.p0i8.i64(" \
-                "i8* %arg.x.41, i8 0, i64 %0, i1 false)"
+missing_align = (
+    "call void @llvm.memset.p0i8.i64(i8* %arg.x.41, i8 0, i64 %0, i1 false)"
+)
 
 
-@skip_on_cudasim('libNVVM not supported in simulator')
+@skip_on_cudasim("libNVVM not supported in simulator")
 @unittest.skipIf(utils.MACHINE_BITS == 32, "CUDA not support for 32-bit")
 @unittest.skipIf(not nvvm.is_available(), "No libNVVM")
 class TestNvvmWithoutCuda(unittest.TestCase):
@@ -30,10 +33,9 @@ class TestNvvmWithoutCuda(unittest.TestCase):
         # NVVM that it cannot parse correctly
 
         # Create a module with a constant containing all 8-bit characters
-        c = ir.Constant(ir.ArrayType(ir.IntType(8), 256),
-                        bytearray(range(256)))
+        c = ir.Constant(ir.ArrayType(ir.IntType(8), 256), bytearray(range(256)))
         m = ir.Module()
-        m.triple = 'nvptx64-nvidia-cuda'
+        m.triple = "nvptx64-nvidia-cuda"
         nvvm.add_ir_version(m)
         gv = ir.GlobalVariable(m, c.type, "myconstant")
         gv.global_constant = True
@@ -46,9 +48,9 @@ class TestNvvmWithoutCuda(unittest.TestCase):
 
         # Ensure all characters appear in the generated constant array.
         elements = ", ".join([str(i) for i in range(256)])
-        myconstant = f"myconstant[256] = {{{elements}}}".encode('utf-8')
+        myconstant = f"myconstant[256] = {{{elements}}}".encode("utf-8")
         self.assertIn(myconstant, ptx)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/nrt/test_nrt.py

@@ -26,7 +26,7 @@ class TestNrtBasic(CUDATestCase):
             x = np.empty(10, np.int64)
             f(x)
 
-        g[1,1]()
+        g[1, 1]()
         cuda.synchronize()
 
     def test_nrt_ptx_contains_refcount(self):
@@ -39,7 +39,7 @@ class TestNrtBasic(CUDATestCase):
             x = np.empty(10, np.int64)
             f(x)
 
-        g[1,1]()
+        g[1, 1]()
 
         ptx = next(iter(g.inspect_asm().values()))
 
@@ -72,13 +72,12 @@ class TestNrtBasic(CUDATestCase):
 
         out_ary = np.zeros(1, dtype=np.int64)
 
-        g[1,1](out_ary)
+        g[1, 1](out_ary)
 
         self.assertEqual(out_ary[0], 1)
 
 
 class TestNrtStatistics(CUDATestCase):
-
     def setUp(self):
         self._stream = cuda.default_stream()
         # Store the current stats state
@@ -126,12 +125,11 @@ class TestNrtStatistics(CUDATestCase):
 
         # Check env var explicitly being set works
         env = os.environ.copy()
-        env['NUMBA_CUDA_NRT_STATS'] = "1"
-        env['NUMBA_CUDA_ENABLE_NRT'] = "1"
+        env["NUMBA_CUDA_NRT_STATS"] = "1"
+        env["NUMBA_CUDA_ENABLE_NRT"] = "1"
         run_in_subprocess(src, env=env)
 
     def check_env_var_off(self, env):
-
         src = """if 1:
         from numba import cuda
         import numpy as np
@@ -152,27 +150,26 @@ class TestNrtStatistics(CUDATestCase):
     def test_stats_env_var_explicit_off(self):
         # Checks that explicitly turning the stats off via the env var works.
         env = os.environ.copy()
-        env['NUMBA_CUDA_NRT_STATS'] = "0"
+        env["NUMBA_CUDA_NRT_STATS"] = "0"
         self.check_env_var_off(env)
 
     def test_stats_env_var_default_off(self):
         # Checks that the env var not being set is the same as "off", i.e.
         # default for Numba is off.
         env = os.environ.copy()
-        env.pop('NUMBA_CUDA_NRT_STATS', None)
+        env.pop("NUMBA_CUDA_NRT_STATS", None)
         self.check_env_var_off(env)
 
     def test_stats_status_toggle(self):
-
         @cuda.jit
         def foo():
             tmp = np.ones(3)
-            arr = np.arange(5 * tmp[0]) # noqa: F841
+            arr = np.arange(5 * tmp[0])  # noqa: F841
             return None
 
         with (
-            override_config('CUDA_ENABLE_NRT', True),
-            override_config('CUDA_NRT_STATS', True)
+            override_config("CUDA_ENABLE_NRT", True),
+            override_config("CUDA_NRT_STATS", True),
         ):
             # Switch on stats
             rtsys.memsys_enable_stats()
@@ -218,9 +215,9 @@ class TestNrtStatistics(CUDATestCase):
     def test_nrt_explicit_stats_query_raises_exception_when_disabled(self):
         # Checks the various memsys_get_stats functions raise if queried when
         # the stats counters are disabled.
-        method_variations = ('alloc', 'free', 'mi_alloc', 'mi_free')
+        method_variations = ("alloc", "free", "mi_alloc", "mi_free")
         for meth in method_variations:
-            stats_func = getattr(rtsys, f'memsys_get_stats_{meth}')
+            stats_func = getattr(rtsys, f"memsys_get_stats_{meth}")
             with self.subTest(stats_func=stats_func):
                 # Turn stats off
                 rtsys.memsys_disable_stats()
@@ -233,14 +230,13 @@ class TestNrtStatistics(CUDATestCase):
         @cuda.jit
         def foo():
             tmp = np.ones(3)
-            arr = np.arange(5 * tmp[0]) # noqa: F841
+            arr = np.arange(5 * tmp[0])  # noqa: F841
             return None
 
         with (
-            override_config('CUDA_ENABLE_NRT', True),
-            override_config('CUDA_NRT_STATS', True)
+            override_config("CUDA_ENABLE_NRT", True),
+            override_config("CUDA_NRT_STATS", True),
         ):
-
             # Switch on stats
             rtsys.memsys_enable_stats()
 
@@ -262,5 +258,5 @@ class TestNrtStatistics(CUDATestCase):
             self.assertEqual(stats.mi_free, stats_mi_free)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/nrt/test_nrt_refct.py

@@ -9,7 +9,6 @@ from numba import cuda
 
 
 class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
-
     def setUp(self):
         super(TestNrtRefCt, self).setUp()
 
@@ -19,7 +18,7 @@ class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
     def run(self, result=None):
         with (
             override_config("CUDA_ENABLE_NRT", True),
-            override_config('CUDA_NRT_STATS', True)
+            override_config("CUDA_NRT_STATS", True),
         ):
             super(TestNrtRefCt, self).run(result)
 
@@ -33,7 +32,7 @@ class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
         @cuda.jit
         def kernel():
             for i in range(n):
-                temp = np.empty(2) # noqa: F841
+                temp = np.empty(2)  # noqa: F841
             return None
 
         init_stats = rtsys.get_allocation_stats()
@@ -49,14 +48,13 @@ class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
 
         @cuda.jit
         def g(n):
-
             x = np.empty((n, 2))
 
             for i in range(n):
                 y = x[i]
 
             for i in range(n):
-                y = x[i] # noqa: F841
+                y = x[i]  # noqa: F841
 
             return None
 
@@ -70,6 +68,7 @@ class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
         """
         Test issue #1573
         """
+
         @cuda.jit
         def if_with_allocation_and_initialization(arr1, test1):
             tmp_arr = np.empty_like(arr1)
@@ -85,13 +84,15 @@ class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
         init_stats = rtsys.get_allocation_stats()
         if_with_allocation_and_initialization[1, 1](arr, False)
         cur_stats = rtsys.get_allocation_stats()
-        self.assertEqual(cur_stats.alloc - init_stats.alloc,
-                         cur_stats.free - init_stats.free)
+        self.assertEqual(
+            cur_stats.alloc - init_stats.alloc, cur_stats.free - init_stats.free
+        )
 
     def test_del_at_beginning_of_loop(self):
         """
         Test issue #1734
         """
+
         @cuda.jit
         def f(arr):
             res = 0
@@ -108,9 +109,10 @@ class TestNrtRefCt(EnableNRTStatsMixin, CUDATestCase):
         init_stats = rtsys.get_allocation_stats()
         f[1, 1](arr)
         cur_stats = rtsys.get_allocation_stats()
-        self.assertEqual(cur_stats.alloc - init_stats.alloc,
-                         cur_stats.free - init_stats.free)
+        self.assertEqual(
+            cur_stats.alloc - init_stats.alloc, cur_stats.free - init_stats.free
+        )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/test_binary_generation/generate_raw_ltoir.py

@@ -58,7 +58,7 @@ def determine_include_flags():
         return None
 
     # NVCC writes to stdout on Windows and stderr on Linux
-    if platform.system() == 'Windows':
+    if platform.system() == "Windows":
         stream = cp.stdout
     else:
         stream = cp.stderr
@@ -157,7 +157,7 @@ if __name__ == "__main__":
     parser.add_argument(
         "-a",
         "--arch",
-        help="compute arch to target (e.g. sm_87). " "Defaults to sm_50.",
+        help="compute arch to target (e.g. sm_87). Defaults to sm_50.",
         default="sm_50",
     )
 

numba_cuda/numba/cuda/types.py

@@ -5,16 +5,18 @@ class Dim3(types.Type):
     """
     A 3-tuple (x, y, z) representing the position of a block or thread.
     """
+
     def __init__(self):
-        super().__init__(name='Dim3')
+        super().__init__(name="Dim3")
 
 
 class GridGroup(types.Type):
     """
     The grid of all threads in a cooperative kernel launch.
     """
+
     def __init__(self):
-        super().__init__(name='GridGroup')
+        super().__init__(name="GridGroup")
 
 
 dim3 = Dim3()
@@ -23,6 +25,7 @@ grid_group = GridGroup()
 
 class CUDADispatcher(types.Dispatcher):
     """The type of CUDA dispatchers"""
+
     # This type exists (instead of using types.Dispatcher as the type of CUDA
     # dispatchers) so that we can have an alternative lowering for them to the
     # lowering of CPU dispatchers - the CPU target lowers all dispatchers as a