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

numba_cuda/numba/cuda/tests/cudadrv/test_module_callbacks.py

@@ -0,0 +1,294 @@
+import unittest
+import threading
+
+import numpy as np
+
+from numba import cuda, config
+from numba.cuda.cudadrv.linkable_code import CUSource
+from numba.cuda.testing import CUDATestCase, ContextResettingTestCase
+
+from cuda.bindings.driver import cuModuleGetGlobal, cuMemcpyHtoD
+
+if config.CUDA_USE_NVIDIA_BINDING:
+    from cuda.cuda import CUmodule as cu_module_type
+else:
+    from numba.cuda.cudadrv.drvapi import cu_module as cu_module_type
+
+
+def wipe_all_modules_in_context():
+    """Cleans all modules reference held by current context.
+    This simulates the behavior on interpreter shutdown.
+
+    TODO: This is a temp solution until
+    https://github.com/NVIDIA/numba-cuda/issues/171 is implemented.
+    """
+    ctx = cuda.current_context()
+    ctx.reset()
+
+
+def get_hashable_handle_value(handle):
+    if not config.CUDA_USE_NVIDIA_BINDING:
+        handle = handle.value
+    return handle
+
+
+class TestModuleCallbacksBasic(ContextResettingTestCase):
+    def test_basic(self):
+        counter = 0
+
+        def setup(handle):
+            self.assertTrue(isinstance(handle, cu_module_type))
+            nonlocal counter
+            counter += 1
+
+        def teardown(handle):
+            self.assertTrue(isinstance(handle, cu_module_type))
+            nonlocal counter
+            counter -= 1
+
+        lib = CUSource("", setup_callback=setup, teardown_callback=teardown)
+
+        @cuda.jit(link=[lib])
+        def kernel():
+            pass
+
+        self.assertEqual(counter, 0)
+        kernel[1, 1]()
+        self.assertEqual(counter, 1)
+        kernel[1, 1]()  # cached
+        self.assertEqual(counter, 1)
+
+        wipe_all_modules_in_context()
+        del kernel
+        self.assertEqual(counter, 0)
+
+    def test_different_argtypes(self):
+        counter = 0
+        setup_seen = set()
+        teardown_seen = set()
+
+        def setup(handle):
+            nonlocal counter, setup_seen
+            counter += 1
+            setup_seen.add(get_hashable_handle_value(handle))
+
+        def teardown(handle):
+            nonlocal counter
+            counter -= 1
+            teardown_seen.add(get_hashable_handle_value(handle))
+
+        lib = CUSource("", setup_callback=setup, teardown_callback=teardown)
+
+        @cuda.jit(link=[lib])
+        def kernel(arg):
+            pass
+
+        self.assertEqual(counter, 0)
+        kernel[1, 1](42)  # (int64)->() : module 1
+        self.assertEqual(counter, 1)
+        kernel[1, 1](100)  # (int64)->() : module 1, cached
+        self.assertEqual(counter, 1)
+        kernel[1, 1](3.14)  # (float64)->() : module 2
+        self.assertEqual(counter, 2)
+
+        wipe_all_modules_in_context()
+        del kernel
+        self.assertEqual(counter, 0)
+
+        self.assertEqual(len(setup_seen), 2)
+        self.assertEqual(len(teardown_seen), 2)
+
+    def test_two_kernels(self):
+        counter = 0
+        setup_seen = set()
+        teardown_seen = set()
+
+        def setup(handle):
+            nonlocal counter, setup_seen
+            counter += 1
+            setup_seen.add(get_hashable_handle_value(handle))
+
+        def teardown(handle):
+            nonlocal counter, teardown_seen
+            counter -= 1
+            teardown_seen.add(get_hashable_handle_value(handle))
+
+        lib = CUSource("", setup_callback=setup, teardown_callback=teardown)
+
+        @cuda.jit(link=[lib])
+        def kernel():
+            pass
+
+        @cuda.jit(link=[lib])
+        def kernel2():
+            pass
+
+        kernel[1, 1]()
+        self.assertEqual(counter, 1)
+        kernel2[1, 1]()
+        self.assertEqual(counter, 2)
+
+        wipe_all_modules_in_context()
+        del kernel
+        self.assertEqual(counter, 0)
+
+        self.assertEqual(len(setup_seen), 2)
+        self.assertEqual(len(teardown_seen), 2)
+
+
+class TestModuleCallbacksAPICompleteness(CUDATestCase):
+    def test_api(self):
+        def setup(handle):
+            pass
+
+        def teardown(handle):
+            pass
+
+        api_combo = [
+            (setup, teardown),
+            (setup, None),
+            (None, teardown),
+            (None, None),
+        ]
+
+        for setup, teardown in api_combo:
+            with self.subTest(setup=setup, teardown=teardown):
+                lib = CUSource(
+                    "", setup_callback=setup, teardown_callback=teardown
+                )
+
+                @cuda.jit(link=[lib])
+                def kernel():
+                    pass
+
+                kernel[1, 1]()
+
+
+class TestModuleCallbacks(CUDATestCase):
+    def setUp(self):
+        super().setUp()
+
+        module = """
+__device__ int num = 0;
+extern "C"
+__device__ int get_num(int &retval) {
+    retval = num;
+    return 0;
+}
+"""
+
+        def set_forty_two(handle):
+            # Initialize 42 to global variable `num`
+            res, dptr, size = cuModuleGetGlobal(
+                get_hashable_handle_value(handle), "num".encode()
+            )
+
+            arr = np.array([42], np.int32)
+            cuMemcpyHtoD(dptr, arr.ctypes.data, size)
+
+        self.lib = CUSource(
+            module, setup_callback=set_forty_two, teardown_callback=None
+        )
+
+    def test_decldevice_arg(self):
+        get_num = cuda.declare_device("get_num", "int32()", link=[self.lib])
+
+        @cuda.jit
+        def kernel(arr):
+            arr[0] = get_num()
+
+        arr = np.zeros(1, np.int32)
+        kernel[1, 1](arr)
+        self.assertEqual(arr[0], 42)
+
+    def test_jitarg(self):
+        get_num = cuda.declare_device("get_num", "int32()")
+
+        @cuda.jit(link=[self.lib])
+        def kernel(arr):
+            arr[0] = get_num()
+
+        arr = np.zeros(1, np.int32)
+        kernel[1, 1](arr)
+        self.assertEqual(arr[0], 42)
+
+
+class TestMultithreadedCallbacks(CUDATestCase):
+    def test_concurrent_initialization(self):
+        seen_mods = set()
+        max_seen_mods = 0
+
+        def setup(mod):
+            nonlocal seen_mods, max_seen_mods
+            seen_mods.add(get_hashable_handle_value(mod))
+            max_seen_mods = max(max_seen_mods, len(seen_mods))
+
+        def teardown(mod):
+            nonlocal seen_mods
+            # Raises an error if the module is not found in the seen_mods
+            seen_mods.remove(get_hashable_handle_value(mod))
+
+        lib = CUSource("", setup_callback=setup, teardown_callback=teardown)
+
+        @cuda.jit(link=[lib])
+        def kernel():
+            pass
+
+        def concurrent_compilation_launch(kernel):
+            kernel[1, 1]()
+
+        threads = [
+            threading.Thread(
+                target=concurrent_compilation_launch, args=(kernel,)
+            )
+            for _ in range(4)
+        ]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        wipe_all_modules_in_context()
+        self.assertEqual(len(seen_mods), 0)
+        self.assertEqual(max_seen_mods, 1)  # one moduled shared across threads
+
+    def test_concurrent_initialization_different_args(self):
+        seen_mods = set()
+        max_seen_mods = 0
+
+        def setup(mod):
+            nonlocal seen_mods, max_seen_mods
+            seen_mods.add(get_hashable_handle_value(mod))
+            max_seen_mods = max(max_seen_mods, len(seen_mods))
+
+        def teardown(mod):
+            nonlocal seen_mods
+            seen_mods.remove(get_hashable_handle_value(mod))
+
+        lib = CUSource("", setup_callback=setup, teardown_callback=teardown)
+
+        @cuda.jit(link=[lib])
+        def kernel(a):
+            pass
+
+        def concurrent_compilation_launch():
+            kernel[1, 1](42)  # (int64)->() : module 1
+            kernel[1, 1](9)  # (int64)->() : module 1 from cache
+            kernel[1, 1](3.14)  # (float64)->() : module 2
+
+        threads = [
+            threading.Thread(target=concurrent_compilation_launch)
+            for _ in range(4)
+        ]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join()
+
+        wipe_all_modules_in_context()
+        assert len(seen_mods) == 0
+        self.assertEqual(max_seen_mods, 2)  # two modules shared across threads
+
+
+if __name__ == "__main__":
+    unittest.main()

numba_cuda/numba/cuda/tests/cudadrv/test_mvc.py

@@ -1,8 +1,11 @@
 import multiprocessing as mp
 import traceback
 from numba.cuda.testing import unittest, CUDATestCase
-from numba.cuda.testing import (skip_on_cudasim, skip_under_cuda_memcheck,
-                                skip_if_mvc_libraries_unavailable)
+from numba.cuda.testing import (
+    skip_on_cudasim,
+    skip_under_cuda_memcheck,
+    skip_if_mvc_libraries_unavailable,
+)
 from numba.tests.support import linux_only
 
 
@@ -24,7 +27,7 @@ def child_test_wrapper(result_queue):
         output = child_test()
         success = True
     # Catch anything raised so it can be propagated
-    except: # noqa: E722
+    except:  # noqa: E722
         output = traceback.format_exc()
         success = False
 
@@ -32,13 +35,13 @@ def child_test_wrapper(result_queue):
 
 
 @linux_only
-@skip_under_cuda_memcheck('May hang CUDA memcheck')
-@skip_on_cudasim('Simulator does not require or implement MVC')
+@skip_under_cuda_memcheck("May hang CUDA memcheck")
+@skip_on_cudasim("Simulator does not require or implement MVC")
 @skip_if_mvc_libraries_unavailable
 class TestMinorVersionCompatibility(CUDATestCase):
     def test_mvc(self):
         # Run test with Minor Version Compatibility enabled in a child process
-        ctx = mp.get_context('spawn')
+        ctx = mp.get_context("spawn")
         result_queue = ctx.Queue()
         proc = ctx.Process(target=child_test_wrapper, args=(result_queue,))
         proc.start()
@@ -50,5 +53,5 @@ class TestMinorVersionCompatibility(CUDATestCase):
             self.fail(output)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudadrv/test_nvjitlink.py

@@ -10,6 +10,7 @@ from numba.tests.support import run_in_subprocess, override_config
 
 try:
     import pynvjitlink  # noqa: F401
+
     PYNVJITLINK_INSTALLED = True
 except ImportError:
     PYNVJITLINK_INSTALLED = False
@@ -52,7 +53,7 @@ if TEST_BIN_DIR:
 
 @unittest.skipIf(
     not config.CUDA_ENABLE_PYNVJITLINK or not TEST_BIN_DIR,
-    "pynvjitlink not enabled"
+    "pynvjitlink not enabled",
 )
 @skip_on_cudasim("Linking unsupported in the simulator")
 class TestLinker(CUDATestCase):
@@ -85,7 +86,6 @@ class TestLinker(CUDATestCase):
             PyNvJitLinker(cc=0)
 
     def test_nvjitlink_ptx_compile_options(self):
-
         max_registers = (None, 32)
         lineinfo = (False, True)
         lto = (False, True)
@@ -190,7 +190,7 @@ class TestLinker(CUDATestCase):
         files = [
             test_device_functions_cu,
             test_device_functions_ltoir,
-            test_device_functions_fatbin_multi
+            test_device_functions_fatbin_multi,
         ]
 
         config.DUMP_ASSEMBLY = True
@@ -228,7 +228,7 @@ class TestLinker(CUDATestCase):
         for file in files:
             with self.subTest(file=file):
                 with warnings.catch_warnings(record=True) as w:
-                    with contextlib.redirect_stdout(None): # suppress other PTX
+                    with contextlib.redirect_stdout(None):  # suppress other PTX
                         sig = "uint32(uint32, uint32)"
                         add_from_numba = cuda.declare_device(
                             "add_from_numba", sig
@@ -243,8 +243,11 @@ class TestLinker(CUDATestCase):
                         assert result[0] == 3
 
                 assert len(w) == 1
-                self.assertIn("it is not optimizable at link time, and "
-                              "`ignore_nonlto == True`", str(w[0].message))
+                self.assertIn(
+                    "it is not optimizable at link time, and "
+                    "`ignore_nonlto == True`",
+                    str(w[0].message),
+                )
 
         config.DUMP_ASSEMBLY = False
 
@@ -262,7 +265,7 @@ class TestLinker(CUDATestCase):
 
 @unittest.skipIf(
     not PYNVJITLINK_INSTALLED or not TEST_BIN_DIR,
-    reason="pynvjitlink not enabled"
+    reason="pynvjitlink not enabled",
 )
 class TestLinkerUsage(CUDATestCase):
     """Test that whether pynvjitlink can be enabled by both environment variable
@@ -295,12 +298,12 @@ class TestLinkerUsage(CUDATestCase):
 
     def test_linker_enabled_envvar(self):
         env = os.environ.copy()
-        env['NUMBA_CUDA_ENABLE_PYNVJITLINK'] = "1"
+        env["NUMBA_CUDA_ENABLE_PYNVJITLINK"] = "1"
         run_in_subprocess(self.src.format(config=""), env=env)
 
     def test_linker_disabled_envvar(self):
         env = os.environ.copy()
-        env.pop('NUMBA_CUDA_ENABLE_PYNVJITLINK', None)
+        env.pop("NUMBA_CUDA_ENABLE_PYNVJITLINK", None)
         with self.assertRaisesRegex(
             AssertionError, "LTO and additional flags require PyNvJitLinker"
         ):
@@ -310,19 +313,25 @@ class TestLinkerUsage(CUDATestCase):
 
     def test_linker_enabled_config(self):
         env = os.environ.copy()
-        env.pop('NUMBA_CUDA_ENABLE_PYNVJITLINK', None)
-        run_in_subprocess(self.src.format(
-            config="config.CUDA_ENABLE_PYNVJITLINK = True"), env=env)
+        env.pop("NUMBA_CUDA_ENABLE_PYNVJITLINK", None)
+        run_in_subprocess(
+            self.src.format(config="config.CUDA_ENABLE_PYNVJITLINK = True"),
+            env=env,
+        )
 
     def test_linker_disabled_config(self):
         env = os.environ.copy()
-        env.pop('NUMBA_CUDA_ENABLE_PYNVJITLINK', None)
+        env.pop("NUMBA_CUDA_ENABLE_PYNVJITLINK", None)
         with override_config("CUDA_ENABLE_PYNVJITLINK", False):
             with self.assertRaisesRegex(
                 AssertionError, "LTO and additional flags require PyNvJitLinker"
             ):
-                run_in_subprocess(self.src.format(
-                    config="config.CUDA_ENABLE_PYNVJITLINK = False"), env=env)
+                run_in_subprocess(
+                    self.src.format(
+                        config="config.CUDA_ENABLE_PYNVJITLINK = False"
+                    ),
+                    env=env,
+                )
 
 
 if __name__ == "__main__":

numba_cuda/numba/cuda/tests/cudadrv/test_nvvm_driver.py

@@ -7,7 +7,7 @@ from numba.cuda.cudadrv.nvvm import LibDevice, NvvmError, NVVM
 from numba.cuda.testing import skip_on_cudasim
 
 
-@skip_on_cudasim('NVVM Driver unsupported in the simulator')
+@skip_on_cudasim("NVVM Driver unsupported in the simulator")
 class TestNvvmDriver(unittest.TestCase):
     def get_nvvmir(self):
         versions = NVVM().get_ir_version()
@@ -16,9 +16,9 @@ class TestNvvmDriver(unittest.TestCase):
 
     def test_nvvm_compile_simple(self):
         nvvmir = self.get_nvvmir()
-        ptx = nvvm.compile_ir(nvvmir).decode('utf8')
-        self.assertTrue('simple' in ptx)
-        self.assertTrue('ave' in ptx)
+        ptx = nvvm.compile_ir(nvvmir).decode("utf8")
+        self.assertTrue("simple" in ptx)
+        self.assertTrue("ave" in ptx)
 
     def test_nvvm_compile_nullary_option(self):
         # Tests compilation with an option that doesn't take an argument
@@ -34,7 +34,7 @@ class TestNvvmDriver(unittest.TestCase):
 
         # Verify we correctly passed the option by checking if we got LTOIR
         # from NVVM (by looking for the expected magic number for LTOIR)
-        self.assertEqual(ltoir[:4], b'\xed\x43\x4e\x7f')
+        self.assertEqual(ltoir[:4], b"\xed\x43\x4e\x7f")
 
     def test_nvvm_bad_option(self):
         # Ensure that unsupported / non-existent options are reported as such
@@ -45,36 +45,37 @@ class TestNvvmDriver(unittest.TestCase):
 
     def test_nvvm_from_llvm(self):
         m = ir.Module("test_nvvm_from_llvm")
-        m.triple = 'nvptx64-nvidia-cuda'
+        m.triple = "nvptx64-nvidia-cuda"
         nvvm.add_ir_version(m)
         fty = ir.FunctionType(ir.VoidType(), [ir.IntType(32)])
-        kernel = ir.Function(m, fty, name='mycudakernel')
-        bldr = ir.IRBuilder(kernel.append_basic_block('entry'))
+        kernel = ir.Function(m, fty, name="mycudakernel")
+        bldr = ir.IRBuilder(kernel.append_basic_block("entry"))
         bldr.ret_void()
         nvvm.set_cuda_kernel(kernel)
 
         m.data_layout = NVVM().data_layout
-        ptx = nvvm.compile_ir(str(m)).decode('utf8')
-        self.assertTrue('mycudakernel' in ptx)
-        self.assertTrue('.address_size 64' in ptx)
+        ptx = nvvm.compile_ir(str(m)).decode("utf8")
+        self.assertTrue("mycudakernel" in ptx)
+        self.assertTrue(".address_size 64" in ptx)
 
     def test_used_list(self):
         # Construct a module
         m = ir.Module("test_used_list")
-        m.triple = 'nvptx64-nvidia-cuda'
+        m.triple = "nvptx64-nvidia-cuda"
         m.data_layout = NVVM().data_layout
         nvvm.add_ir_version(m)
 
         # Add a function and mark it as a kernel
         fty = ir.FunctionType(ir.VoidType(), [ir.IntType(32)])
-        kernel = ir.Function(m, fty, name='mycudakernel')
-        bldr = ir.IRBuilder(kernel.append_basic_block('entry'))
+        kernel = ir.Function(m, fty, name="mycudakernel")
+        bldr = ir.IRBuilder(kernel.append_basic_block("entry"))
         bldr.ret_void()
         nvvm.set_cuda_kernel(kernel)
 
         # Verify that the used list was correctly constructed
-        used_lines = [line for line in str(m).splitlines()
-                      if 'llvm.used' in line]
+        used_lines = [
+            line for line in str(m).splitlines() if "llvm.used" in line
+        ]
         msg = 'Expected exactly one @"llvm.used" array'
         self.assertEqual(len(used_lines), 1, msg)
 
@@ -93,70 +94,71 @@ class TestNvvmDriver(unittest.TestCase):
         m.triple = "unknown-unknown-unknown"
         m.data_layout = NVVM().data_layout
         nvvm.add_ir_version(m)
-        with self.assertRaisesRegex(NvvmError, 'Invalid target triple'):
+        with self.assertRaisesRegex(NvvmError, "Invalid target triple"):
             nvvm.compile_ir(str(m))
 
     def _test_nvvm_support(self, arch):
-        compute_xx = 'compute_{0}{1}'.format(*arch)
+        compute_xx = "compute_{0}{1}".format(*arch)
         nvvmir = self.get_nvvmir()
-        ptx = nvvm.compile_ir(nvvmir, arch=compute_xx, ftz=1, prec_sqrt=0,
-                              prec_div=0).decode('utf8')
+        ptx = nvvm.compile_ir(
+            nvvmir, arch=compute_xx, ftz=1, prec_sqrt=0, prec_div=0
+        ).decode("utf8")
         self.assertIn(".target sm_{0}{1}".format(*arch), ptx)
-        self.assertIn('simple', ptx)
-        self.assertIn('ave', ptx)
+        self.assertIn("simple", ptx)
+        self.assertIn("ave", ptx)
 
     def test_nvvm_support(self):
-        """Test supported CC by NVVM
-        """
+        """Test supported CC by NVVM"""
         for arch in nvvm.get_supported_ccs():
             self._test_nvvm_support(arch=arch)
 
     def test_nvvm_warning(self):
         m = ir.Module("test_nvvm_warning")
-        m.triple = 'nvptx64-nvidia-cuda'
+        m.triple = "nvptx64-nvidia-cuda"
         m.data_layout = NVVM().data_layout
         nvvm.add_ir_version(m)
 
         fty = ir.FunctionType(ir.VoidType(), [])
-        kernel = ir.Function(m, fty, name='inlinekernel')
-        builder = ir.IRBuilder(kernel.append_basic_block('entry'))
+        kernel = ir.Function(m, fty, name="inlinekernel")
+        builder = ir.IRBuilder(kernel.append_basic_block("entry"))
         builder.ret_void()
         nvvm.set_cuda_kernel(kernel)
 
         # Add the noinline attribute to trigger NVVM to generate a warning
-        kernel.attributes.add('noinline')
+        kernel.attributes.add("noinline")
 
         with warnings.catch_warnings(record=True) as w:
             nvvm.compile_ir(str(m))
 
         self.assertEqual(len(w), 1)
-        self.assertIn('overriding noinline attribute', str(w[0]))
+        self.assertIn("overriding noinline attribute", str(w[0]))
 
 
-@skip_on_cudasim('NVVM Driver unsupported in the simulator')
+@skip_on_cudasim("NVVM Driver unsupported in the simulator")
 class TestArchOption(unittest.TestCase):
     def test_get_arch_option(self):
         # Test returning the nearest lowest arch.
-        self.assertEqual(nvvm.get_arch_option(5, 3), 'compute_53')
-        self.assertEqual(nvvm.get_arch_option(7, 5), 'compute_75')
-        self.assertEqual(nvvm.get_arch_option(7, 7), 'compute_75')
+        self.assertEqual(nvvm.get_arch_option(5, 3), "compute_53")
+        self.assertEqual(nvvm.get_arch_option(7, 5), "compute_75")
+        self.assertEqual(nvvm.get_arch_option(7, 7), "compute_75")
         # Test known arch.
         supported_cc = nvvm.get_supported_ccs()
         for arch in supported_cc:
-            self.assertEqual(nvvm.get_arch_option(*arch), 'compute_%d%d' % arch)
-        self.assertEqual(nvvm.get_arch_option(1000, 0),
-                         'compute_%d%d' % supported_cc[-1])
+            self.assertEqual(nvvm.get_arch_option(*arch), "compute_%d%d" % arch)
+        self.assertEqual(
+            nvvm.get_arch_option(1000, 0), "compute_%d%d" % supported_cc[-1]
+        )
 
 
-@skip_on_cudasim('NVVM Driver unsupported in the simulator')
+@skip_on_cudasim("NVVM Driver unsupported in the simulator")
 class TestLibDevice(unittest.TestCase):
     def test_libdevice_load(self):
         # Test that constructing LibDevice gives a bitcode file
         libdevice = LibDevice()
-        self.assertEqual(libdevice.bc[:4], b'BC\xc0\xde')
+        self.assertEqual(libdevice.bc[:4], b"BC\xc0\xde")
 
 
-nvvmir_generic = '''\
+nvvmir_generic = """\
 target triple="nvptx64-nvidia-cuda"
 target datalayout = "{data_layout}"
 
@@ -194,8 +196,8 @@ declare i32 @llvm.nvvm.read.ptx.sreg.tid.x() nounwind readnone
 !2 = !{{void (i32*)* @simple, !"kernel", i32 1}}
 
 @"llvm.used" = appending global [1 x i8*] [i8* bitcast (void (i32*)* @simple to i8*)], section "llvm.metadata"
-'''  # noqa: E501
+"""  # noqa: E501
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudadrv/test_pinned.py

@@ -6,7 +6,6 @@ from numba.cuda.testing import unittest, ContextResettingTestCase
 
 
 class TestPinned(ContextResettingTestCase):
-
     def _run_copies(self, A):
         A0 = np.copy(A)
 
@@ -20,8 +19,8 @@ class TestPinned(ContextResettingTestCase):
 
     def test_pinned(self):
         machine = platform.machine()
-        if machine.startswith('arm') or machine.startswith('aarch64'):
-            count = 262144   # 2MB
+        if machine.startswith("arm") or machine.startswith("aarch64"):
+            count = 262144  # 2MB
         else:
             count = 2097152  # 16MB
         A = np.arange(count)
@@ -29,9 +28,9 @@ class TestPinned(ContextResettingTestCase):
             self._run_copies(A)
 
     def test_unpinned(self):
-        A = np.arange(2 * 1024 * 1024) # 16 MB
+        A = np.arange(2 * 1024 * 1024)  # 16 MB
         self._run_copies(A)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

numba_cuda/numba/cuda/tests/cudadrv/test_profiler.py

@@ -4,7 +4,7 @@ from numba import cuda
 from numba.cuda.testing import skip_on_cudasim
 
 
-@skip_on_cudasim('CUDA Profiler unsupported in the simulator')
+@skip_on_cudasim("CUDA Profiler unsupported in the simulator")
 class TestProfiler(ContextResettingTestCase):
     def test_profiling(self):
         with cuda.profiling():
@@ -16,5 +16,5 @@ class TestProfiler(ContextResettingTestCase):
             del a
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()