Script 'mail_helper' called by obssrc Hello community, here is the log from the commit of package python-numba for openSUSE:Factory checked in at 2023-08-14 22:35:49 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/python-numba (Old) and /work/SRC/openSUSE:Factory/.python-numba.new.11712 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "python-numba" Mon Aug 14 22:35:49 2023 rev:39 rq:1103793 version:0.57.1 Changes: -------- --- /work/SRC/openSUSE:Factory/python-numba/python-numba.changes 2023-05-26 20:16:04.364476979 +0200 +++ /work/SRC/openSUSE:Factory/.python-numba.new.11712/python-numba.changes 2023-08-14 22:36:00.652511949 +0200 @@ -1,0 +2,7 @@ +Mon Aug 14 06:47:15 UTC 2023 - Dirk Müller <[email protected]> + +- update to 0.57.1: + * fix regressions with 0.57.0 +- remove upper bound on numpy - upstream does not have it either + +------------------------------------------------------------------- Old: ---- numba-0.57.0.tar.gz New: ---- numba-0.57.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ python-numba.spec ++++++ --- /var/tmp/diff_new_pack.En7rbl/_old 2023-08-14 22:36:01.684518511 +0200 +++ /var/tmp/diff_new_pack.En7rbl/_new 2023-08-14 22:36:01.692518562 +0200 @@ -18,9 +18,7 @@ %define skip_python2 1 %define plainpython python -# upper bound is exclusive: min-numpy_ver <= numpy < max_numpy_ver %define min_numpy_ver 1.21 -%define max_numpy_ver 1.25 %global flavor @BUILD_FLAVOR@%{nil} %if "%{flavor}" == "" @@ -47,7 +45,7 @@ %endif Name: python-numba%{?psuffix} -Version: 0.57.0 +Version: 0.57.1 Release: 0 Summary: NumPy-aware optimizing compiler for Python using LLVM License: BSD-2-Clause @@ -57,7 +55,7 @@ # PATCH-FIX-OPENSUSE skip tests failing due to OBS specifics Patch3: skip-failing-tests.patch BuildRequires: %{python_module devel >= 3.8} -BuildRequires: %{python_module numpy-devel >= %{min_numpy_ver} with %python-numpy-devel < %{max_numpy_ver}} +BuildRequires: %{python_module numpy-devel >= %{min_numpy_ver}} BuildRequires: %{python_module pip} BuildRequires: %{python_module setuptools} BuildRequires: %{python_module wheel} @@ -65,8 +63,8 @@ BuildRequires: gcc-c++ BuildRequires: python-rpm-macros BuildRequires: (tbb-devel >= 2021) +Requires: python-numpy >= %{min_numpy_ver} Requires: (python-llvmlite >= 0.40 with python-llvmlite < 0.41) -Requires: (python-numpy >= %{min_numpy_ver} with python-numpy < %{max_numpy_ver}) Requires(post): update-alternatives Requires(postun):update-alternatives Recommends: python-Jinja2 @@ -114,8 +112,8 @@ Summary: Development files for numba applications Requires: %{name} = %{version} Requires: python-devel +Requires: python-numpy-devel >= %{min_numpy_ver} Requires: %{plainpython}(abi) = %{python_version} -Requires: (python-numpy-devel >= %{min_numpy_ver} with python-numpy-devel < %{max_numpy_ver}) %description devel This package contains files for developing applications using numba. ++++++ numba-0.57.0.tar.gz -> numba-0.57.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/CHANGE_LOG new/numba-0.57.1/CHANGE_LOG --- old/numba-0.57.0/CHANGE_LOG 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/CHANGE_LOG 2023-06-21 10:39:47.000000000 +0200 @@ -1,3 +1,30 @@ +Version 0.57.1 (21 June, 2023) +------------------------------ + +Pull-Requests: + +* PR `#8964 <https://github.com/numba/numba/pull/8964>`_: fix missing nopython keyword in cuda random module (`esc <https://github.com/esc>`_) +* PR `#8965 <https://github.com/numba/numba/pull/8965>`_: fix return dtype for np.angle (`guilhermeleobas <https://github.com/guilhermeleobas>`_ `esc <https://github.com/esc>`_) +* PR `#8982 <https://github.com/numba/numba/pull/8982>`_: Don't do the parfor diagnostics pass for the parfor gufunc. (`DrTodd13 <https://github.com/DrTodd13>`_) +* PR `#8996 <https://github.com/numba/numba/pull/8996>`_: adding a test for 8940 (`esc <https://github.com/esc>`_) +* PR `#8958 <https://github.com/numba/numba/pull/8958>`_: resurrect the import, this time in the registry initialization (`esc <https://github.com/esc>`_) +* PR `#8947 <https://github.com/numba/numba/pull/8947>`_: Introduce internal _isinstance_no_warn (`guilhermeleobas <https://github.com/guilhermeleobas>`_ `esc <https://github.com/esc>`_) +* PR `#8998 <https://github.com/numba/numba/pull/8998>`_: Fix 8939 (second attempt) (`esc <https://github.com/esc>`_) +* PR `#8978 <https://github.com/numba/numba/pull/8978>`_: Import MVC packages when using MVCLinker. (`bdice <https://github.com/bdice>`_) +* PR `#8895 <https://github.com/numba/numba/pull/8895>`_: CUDA: Enable caching functions that use CG (`gmarkall <https://github.com/gmarkall>`_) +* PR `#8976 <https://github.com/numba/numba/pull/8976>`_: Fix index URL for ptxcompiler/cubinlinker packages. (`bdice <https://github.com/bdice>`_) +* PR `#9004 <https://github.com/numba/numba/pull/9004>`_: Skip MVC test when libraries unavailable (`gmarkall <https://github.com/gmarkall>`_ `esc <https://github.com/esc>`_) +* PR `#9006 <https://github.com/numba/numba/pull/9006>`_: link to version support table instead of using explicit versions (`esc <https://github.com/esc>`_) +* PR `#9005 <https://github.com/numba/numba/pull/9005>`_: Fix: Issue #8923 - avoid spurious device-to-host transfers in CUDA ufuncs (`gmarkall <https://github.com/gmarkall>`_) + + +Authors: + +* `bdice <https://github.com/bdice>`_ +* `DrTodd13 <https://github.com/DrTodd13>`_ +* `esc <https://github.com/esc>`_ +* `gmarkall <https://github.com/gmarkall>`_ + Version 0.57.0 (1 May, 2023) ---------------------------- diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/PKG-INFO new/numba-0.57.1/PKG-INFO --- old/numba-0.57.0/PKG-INFO 2023-05-02 17:53:19.207916700 +0200 +++ new/numba-0.57.1/PKG-INFO 2023-06-21 10:39:57.145105000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: numba -Version: 0.57.0 +Version: 0.57.1 Summary: compiling Python code using LLVM Home-page: https://numba.pydata.org License: BSD diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/docs/source/cuda/minor_version_compatibility.rst new/numba-0.57.1/docs/source/cuda/minor_version_compatibility.rst --- old/numba-0.57.0/docs/source/cuda/minor_version_compatibility.rst 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/docs/source/cuda/minor_version_compatibility.rst 2023-06-21 10:39:46.000000000 +0200 @@ -37,7 +37,7 @@ .. code:: bash - pip install ptxcompiler-cu11 cubinlinker-cu11 --extra-index-url=https://pypi.ngc.nvidia.com + pip install ptxcompiler-cu11 cubinlinker-cu11 --extra-index-url=https://pypi.nvidia.com MVC support is enabled by setting the environment variable: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/docs/source/user/installing.rst new/numba-0.57.1/docs/source/user/installing.rst --- old/numba-0.57.0/docs/source/user/installing.rst 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/docs/source/user/installing.rst 2023-06-21 10:39:47.000000000 +0200 @@ -5,7 +5,8 @@ Compatibility ------------- -Numba is compatible with Python 3.8--3.10, and NumPy versions 1.21--1.24. +For software compatability, please see the section on :ref:`version support +information<numba_support_info>` for details. Our supported platforms are: @@ -261,6 +262,8 @@ +----------++--------------+---------------------------+----------------------------+------------------------------+-------------------+-----------------------------+ | Numba | Release date | Python | NumPy | llvmlite | LLVM | TBB | +===========+==============+===========================+============================+==============================+===================+=============================+ +| 0.57.1 | 2023-06-21 | 3.8.x <= version < 3.12 | 1.21 <= version < 1.25 | 0.40.x | 14.x | 2021.6 <= version | ++-----------+--------------+---------------------------+----------------------------+------------------------------+-------------------+-----------------------------+ | 0.57.0 | 2023-05-01 | 3.8.x <= version < 3.12 | 1.21 <= version < 1.25 | 0.40.x | 14.x | 2021.6 <= version | +-----------+--------------+---------------------------+----------------------------+------------------------------+-------------------+-----------------------------+ | 0.56.4 | 2022-11-03 | 3.7.x <= version < 3.11 | 1.18 <= version < 1.24 | 0.39.x | 11.x | 2021.x | diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/_version.py new/numba-0.57.1/numba/_version.py --- old/numba-0.57.0/numba/_version.py 2023-05-02 17:53:19.207916700 +0200 +++ new/numba-0.57.1/numba/_version.py 2023-06-21 10:39:57.145105000 +0200 @@ -8,11 +8,11 @@ version_json = ''' { - "date": "2023-05-01T10:59:47-0500", + "date": "2023-06-19T16:25:22+0200", "dirty": false, "error": null, - "full-revisionid": "4fd4e39c672d119b54a2276d170f270764d2bce7", - "version": "0.57.0" + "full-revisionid": "04e81073b2c1e3ff4afa1da8513738e5e136775b", + "version": "0.57.1" } ''' # END VERSION_JSON diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/core/compiler.py new/numba-0.57.1/numba/core/compiler.py --- old/numba-0.57.0/numba/core/compiler.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/core/compiler.py 2023-06-21 10:39:46.000000000 +0200 @@ -602,6 +602,26 @@ return pm @staticmethod + def define_parfor_gufunc_nopython_lowering_pipeline( + state, name='parfor_gufunc_nopython_lowering'): + pm = PassManager(name) + # legalise + pm.add_pass(NoPythonSupportedFeatureValidation, + "ensure features that are in use are in a valid form") + pm.add_pass(IRLegalization, + "ensure IR is legal prior to lowering") + # Annotate only once legalized + pm.add_pass(AnnotateTypes, "annotate types") + # lower + if state.flags.auto_parallel.enabled: + pm.add_pass(NativeParforLowering, "native parfor lowering") + else: + pm.add_pass(NativeLowering, "native lowering") + pm.add_pass(NoPythonBackend, "nopython mode backend") + pm.finalize() + return pm + + @staticmethod def define_typed_pipeline(state, name="typed"): """Returns the typed part of the nopython pipeline""" pm = PassManager(name) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/core/cpu.py new/numba-0.57.1/numba/core/cpu.py --- old/numba-0.57.0/numba/core/cpu.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/core/cpu.py 2023-06-21 10:39:46.000000000 +0200 @@ -98,6 +98,9 @@ # load 3rd party extensions numba.core.entrypoints.init_all() + # fix for #8940 + from numba.np.unsafe import ndarray # noqa F401 + @property def target_data(self): return self._internal_codegen.target_data diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/core/untyped_passes.py new/numba-0.57.1/numba/core/untyped_passes.py --- old/numba-0.57.0/numba/core/untyped_passes.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/core/untyped_passes.py 2023-06-21 10:39:46.000000000 +0200 @@ -906,8 +906,16 @@ new_var_dict = {} for name, var in var_table.items(): scope = switch_ir.blocks[lbl].scope - new_var_dict[name] = scope.define( - f"v{branch_ty}_{name}", var.loc).name + try: + scope.get_exact(name) + except errors.NotDefinedError: + # In case the scope doesn't have the variable, we need to + # define it prior creating new copies of it! This is + # because the scope of the function and the scope of the + # loop are different and the variable needs to be redefined + # within the scope of the loop. + scope.define(name, var.loc) + new_var_dict[name] = scope.redefine(name, var.loc).name replace_var_names(loop_blocks, new_var_dict) # clobber the sentinel body and then stuff in the rest @@ -1480,7 +1488,7 @@ typemap = state.typemap flags = state.flags - accepted_functions = ('isinstance', 'hasattr') + accepted_functions = ('isinstance', '_isinstance_no_warn', 'hasattr') if not hasattr(func_ir, '_definitions') \ and not flags.enable_ssa: @@ -1531,8 +1539,13 @@ fn = guard(get_definition, func_ir, value.func.name) if fn is None: continue - if not (isinstance(fn, ir.Global) and fn.name in - accepted_functions): # noqa: E501 + + is_isinstance_no_warn = isinstance(fn, ir.FreeVar) and \ + fn.name == '_isinstance_no_warn' + + if not (is_isinstance_no_warn or + (isinstance(fn, ir.Global) and fn.name in + accepted_functions)): continue for arg in value.args: @@ -1580,13 +1593,16 @@ def run_pass(self, state): # Determine whether to even attempt this pass... if there's no # `isinstance` as a global or as a freevar then just skip. + from numba.cpython.builtins import _isinstance_no_warn + found = False func_ir = state.func_ir for blk in func_ir.blocks.values(): for asgn in blk.find_insts(ir.Assign): if isinstance(asgn.value, (ir.Global, ir.FreeVar)): value = asgn.value.value - if value is isinstance or value is hasattr: + if value is isinstance or value is hasattr or \ + value is _isinstance_no_warn: found = True break if found: diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/cpython/builtins.py new/numba-0.57.1/numba/cpython/builtins.py --- old/numba-0.57.0/numba/cpython/builtins.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/cpython/builtins.py 2023-06-21 10:39:46.000000000 +0200 @@ -745,8 +745,21 @@ return impl +def _isinstance_no_warn(var, typs): + pass + + @overload(isinstance) def ol_isinstance(var, typs): + # Warn about the experimental nature of this feature. + msg = "Use of isinstance() detected. This is an experimental feature." + warnings.warn(msg, category=NumbaExperimentalFeatureWarning) + + return ol_isinstance_no_warn(var, typs) + + +@overload(_isinstance_no_warn) +def ol_isinstance_no_warn(var, typs): def true_impl(var, typs): return True @@ -775,10 +788,6 @@ msg = f'isinstance() does not support variables of type "{var_ty}".' raise NumbaTypeError(msg) - # Warn about the experimental nature of this feature. - msg = "Use of isinstance() detected. This is an experimental feature." - warnings.warn(msg, category=NumbaExperimentalFeatureWarning) - t_typs = typs # Check the types that the var can be an instance of, it'll be a scalar, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/cuda/codegen.py new/numba-0.57.1/numba/cuda/codegen.py --- old/numba-0.57.0/numba/cuda/codegen.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/cuda/codegen.py 2023-06-21 10:39:46.000000000 +0200 @@ -3,6 +3,7 @@ from numba.core import config, serialize from numba.core.codegen import Codegen, CodeLibrary from .cudadrv import devices, driver, nvvm, runtime +from numba.cuda.cudadrv.libs import get_cudalib import os import subprocess @@ -74,6 +75,8 @@ # Files to link with the generated PTX. These are linked using the # Driver API at link time. self._linking_files = set() + # Should we link libcudadevrt? + self.needs_cudadevrt = False # Cache the LLVM IR string self._llvm_strs = None @@ -156,6 +159,8 @@ linker.add_ptx(ptx.encode()) for path in self._linking_files: linker.add_file_guess_ext(path) + if self.needs_cudadevrt: + linker.add_file_guess_ext(get_cudalib('cudadevrt', static=True)) cubin = linker.complete() self._cubin_cache[cc] = cubin @@ -283,12 +288,14 @@ cubin_cache=self._cubin_cache, linkerinfo_cache=self._linkerinfo_cache, max_registers=self._max_registers, - nvvm_options=self._nvvm_options + nvvm_options=self._nvvm_options, + needs_cudadevrt=self.needs_cudadevrt ) @classmethod def _rebuild(cls, codegen, name, entry_name, llvm_strs, ptx_cache, - cubin_cache, linkerinfo_cache, max_registers, nvvm_options): + cubin_cache, linkerinfo_cache, max_registers, nvvm_options, + needs_cudadevrt): """ Rebuild an instance. """ @@ -301,6 +308,7 @@ instance._max_registers = max_registers instance._nvvm_options = nvvm_options + instance.needs_cudadevrt = needs_cudadevrt instance._finalized = True diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/cuda/cudadrv/driver.py new/numba-0.57.1/numba/cuda/cudadrv/driver.py --- old/numba-0.57.0/numba/cuda/cudadrv/driver.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/cuda/cudadrv/driver.py 2023-06-21 10:39:46.000000000 +0200 @@ -37,15 +37,6 @@ from .drvapi import cu_occupancy_b2d_size, cu_stream_callback_pyobj, cu_uuid from numba.cuda.cudadrv import enums, drvapi, _extras -if config.CUDA_ENABLE_MINOR_VERSION_COMPATIBILITY: - try: - from ptxcompiler import compile_ptx - from cubinlinker import CubinLinker, CubinLinkerError - except ImportError as ie: - msg = ("Minor version compatibility requires ptxcompiler and " - "cubinlinker packages to be available") - raise ImportError(msg) from ie - USE_NV_BINDING = config.CUDA_USE_NVIDIA_BINDING if USE_NV_BINDING: @@ -2670,12 +2661,23 @@ """ +_MVC_ERROR_MESSAGE = ( + "Minor version compatibility requires ptxcompiler and cubinlinker packages " + "to be available" +) + + class MVCLinker(Linker): """ Linker supporting Minor Version Compatibility, backed by the cubinlinker package. """ def __init__(self, max_registers=None, lineinfo=False, cc=None): + try: + from cubinlinker import CubinLinker + except ImportError as err: + raise ImportError(_MVC_ERROR_MESSAGE) from err + if cc is None: raise RuntimeError("MVCLinker requires Compute Capability to be " "specified, but cc is None") @@ -2700,6 +2702,11 @@ return self._linker.error_log def add_ptx(self, ptx, name='<cudapy-ptx>'): + try: + from ptxcompiler import compile_ptx + from cubinlinker import CubinLinkerError + except ImportError as err: + raise ImportError(_MVC_ERROR_MESSAGE) from err compile_result = compile_ptx(ptx.decode(), self.ptx_compile_options) try: self._linker.add_cubin(compile_result.compiled_program, name) @@ -2708,6 +2715,11 @@ def add_file(self, path, kind): try: + from cubinlinker import CubinLinkerError + except ImportError as err: + raise ImportError(_MVC_ERROR_MESSAGE) from err + + try: with open(path, 'rb') as f: data = f.read() except FileNotFoundError: @@ -2744,6 +2756,11 @@ def complete(self): try: + from cubinlinker import CubinLinkerError + except ImportError as err: + raise ImportError(_MVC_ERROR_MESSAGE) from err + + try: return self._linker.complete() except CubinLinkerError as e: raise LinkerError from e diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/cuda/dispatcher.py new/numba-0.57.1/numba/cuda/dispatcher.py --- old/numba-0.57.0/numba/cuda/dispatcher.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/cuda/dispatcher.py 2023-06-21 10:39:46.000000000 +0200 @@ -16,7 +16,6 @@ from numba.cuda.compiler import compile_cuda, CUDACompiler from numba.cuda.cudadrv import driver from numba.cuda.cudadrv.devices import get_context -from numba.cuda.cudadrv.libs import get_cudalib from numba.cuda.descriptor import cuda_target from numba.cuda.errors import (missing_launch_config_msg, normalize_kernel_dimensions) @@ -104,7 +103,7 @@ self.cooperative = 'cudaCGGetIntrinsicHandle' in lib.get_asm_str() # We need to link against cudadevrt if grid sync is being used. if self.cooperative: - link.append(get_cudalib('cudadevrt', static=True)) + lib.needs_cudadevrt = True res = [fn for fn in cuda_fp16_math_funcs if (f'__numba_wrapper_{fn}' in lib.get_asm_str())] diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/cuda/random.py new/numba-0.57.1/numba/cuda/random.py --- old/numba-0.57.0/numba/cuda/random.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/cuda/random.py 2023-06-21 10:39:46.000000000 +0200 @@ -34,15 +34,16 @@ xoroshiro128p_type = from_dtype(xoroshiro128p_dtype) # When cudasim is enabled, Fake CUDA arrays are passed to some of the -# @jit-decorated functions. This causes a fallback to object mode and the -# emission of a warning at present - this is visible in the test suite with -# cudasim, but also fallback-by-default will not be permitted in future. In -# order to avoid the warning / future error, we explicitly specify that +# @jit-decorated functions. This required fallback to object mode. With +# Numba 0.59.0 object mode must be explicitly enabled. +# https://numba.readthedocs.io/en/stable/reference/deprecation.html#deprecation-of-object-mode-fall-back-behaviour-when-using-jit +# In order to avoid the warning / future error, we explicitly specify that # object mode with loop lifting is acceptable when using the simulator. _forceobj = _looplift = config.ENABLE_CUDASIM +_nopython = not config.ENABLE_CUDASIM -@jit(forceobj=_forceobj, looplift=_looplift) +@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython) def init_xoroshiro128p_state(states, index, seed): '''Use SplitMix64 to generate an xoroshiro128p state from 64-bit seed. @@ -68,7 +69,7 @@ states[index]['s1'] = z -@jit(forceobj=_forceobj, looplift=_looplift) +@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython) def rotl(x, k): '''Left rotate x by k bits.''' x = uint64(x) @@ -76,7 +77,7 @@ return (x << k) | (x >> uint32(64 - k)) -@jit(forceobj=_forceobj, looplift=_looplift) +@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython) def xoroshiro128p_next(states, index): '''Return the next random uint64 and advance the RNG in states[index]. @@ -98,7 +99,7 @@ return result -@jit(forceobj=_forceobj, looplift=_looplift) +@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython) def xoroshiro128p_jump(states, index): '''Advance the RNG in ``states[index]`` by 2**64 steps. @@ -125,21 +126,21 @@ states[index]['s1'] = s1 -@jit(forceobj=_forceobj, looplift=_looplift) +@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython) def uint64_to_unit_float64(x): '''Convert uint64 to float64 value in the range [0.0, 1.0)''' x = uint64(x) return (x >> uint32(11)) * (float64(1) / (uint64(1) << uint32(53))) -@jit(forceobj=_forceobj, looplift=_looplift) +@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython) def uint64_to_unit_float32(x): '''Convert uint64 to float32 value in the range [0.0, 1.0)''' x = uint64(x) return float32(uint64_to_unit_float64(x)) -@jit(forceobj=_forceobj, looplift=_looplift) +@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython) def xoroshiro128p_uniform_float32(states, index): '''Return a float32 in range [0.0, 1.0) and advance ``states[index]``. @@ -153,7 +154,7 @@ return uint64_to_unit_float32(xoroshiro128p_next(states, index)) -@jit(forceobj=_forceobj, looplift=_looplift) +@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython) def xoroshiro128p_uniform_float64(states, index): '''Return a float64 in range [0.0, 1.0) and advance ``states[index]``. @@ -171,7 +172,7 @@ TWO_PI_FLOAT64 = np.float64(2 * math.pi) -@jit(forceobj=_forceobj, looplift=_looplift) +@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython) def xoroshiro128p_normal_float32(states, index): '''Return a normally distributed float32 and advance ``states[index]``. @@ -196,7 +197,7 @@ return z0 -@jit(forceobj=_forceobj, looplift=_looplift) +@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython) def xoroshiro128p_normal_float64(states, index): '''Return a normally distributed float32 and advance ``states[index]``. @@ -221,7 +222,7 @@ return z0 -@jit(forceobj=_forceobj, looplift=_looplift) +@jit(forceobj=_forceobj, looplift=_looplift, nopython=_nopython) def init_xoroshiro128p_states_cpu(states, seed, subsequence_start): n = states.shape[0] seed = uint64(seed) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/cuda/target.py new/numba-0.57.1/numba/cuda/target.py --- old/numba-0.57.0/numba/cuda/target.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/cuda/target.py 2023-06-21 10:39:46.000000000 +0200 @@ -111,6 +111,8 @@ from . import ( cudaimpl, printimpl, libdeviceimpl, mathimpl, vector_types ) + # fix for #8940 + from numba.np.unsafe import ndarray # noqa F401 self.install_registry(cudaimpl.registry) self.install_registry(cffiimpl.registry) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/cuda/testing.py new/numba-0.57.1/numba/cuda/testing.py --- old/numba-0.57.0/numba/cuda/testing.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/cuda/testing.py 2023-06-21 10:39:46.000000000 +0200 @@ -119,6 +119,19 @@ reason) +def skip_if_mvc_libraries_unavailable(fn): + libs_available = False + try: + import cubinlinker # noqa: F401 + import ptxcompiler # noqa: F401 + libs_available = True + except ImportError: + pass + + return unittest.skipUnless(libs_available, + "Requires cubinlinker and ptxcompiler")(fn) + + def cc_X_or_above(major, minor): if not config.ENABLE_CUDASIM: cc = devices.get_context().device.compute_capability diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/cuda/tests/cudadrv/test_mvc.py new/numba-0.57.1/numba/cuda/tests/cudadrv/test_mvc.py --- old/numba-0.57.0/numba/cuda/tests/cudadrv/test_mvc.py 1970-01-01 01:00:00.000000000 +0100 +++ new/numba-0.57.1/numba/cuda/tests/cudadrv/test_mvc.py 2023-06-21 10:39:46.000000000 +0200 @@ -0,0 +1,54 @@ +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.tests.support import linux_only + + +def child_test(): + from numba import config, cuda + + # Change the MVC config after importing numba.cuda + config.CUDA_ENABLE_MINOR_VERSION_COMPATIBILITY = 1 + + @cuda.jit + def f(): + pass + + f[1, 1]() + + +def child_test_wrapper(result_queue): + try: + output = child_test() + success = True + # Catch anything raised so it can be propagated + except: # noqa: E722 + output = traceback.format_exc() + success = False + + result_queue.put((success, output)) + + +@linux_only +@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') + result_queue = ctx.Queue() + proc = ctx.Process(target=child_test_wrapper, args=(result_queue,)) + proc.start() + proc.join() + success, output = result_queue.get() + + # Ensure the child process ran to completion before checking its output + if not success: + self.fail(output) + + +if __name__ == '__main__': + unittest.main() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/cuda/tests/cudapy/cache_usecases.py new/numba-0.57.1/numba/cuda/tests/cudapy/cache_usecases.py --- old/numba-0.57.0/numba/cuda/tests/cudapy/cache_usecases.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/cuda/tests/cudapy/cache_usecases.py 2023-06-21 10:39:46.000000000 +0200 @@ -198,6 +198,17 @@ simple_usecase_caller = CUDAUseCase(simple_usecase_kernel) +# Usecase with cooperative groups + [email protected](cache=True) +def cg_usecase_kernel(r, x): + grid = cuda.cg.this_grid() + grid.sync() + + +cg_usecase = CUDAUseCase(cg_usecase_kernel) + + class _TestModule(CUDATestCase): """ Tests for functionality of this module's functions. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/cuda/tests/cudapy/test_caching.py new/numba-0.57.1/numba/cuda/tests/cudapy/test_caching.py --- old/numba-0.57.0/numba/cuda/tests/cudapy/test_caching.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/cuda/tests/cudapy/test_caching.py 2023-06-21 10:39:46.000000000 +0200 @@ -6,8 +6,9 @@ from numba import cuda from numba.core.errors import NumbaWarning -from numba.cuda.codegen import CUDACodeLibrary -from numba.cuda.testing import CUDATestCase, skip_on_cudasim, test_data_dir +from numba.cuda.testing import (CUDATestCase, skip_on_cudasim, + skip_unless_cc_60, skip_if_cudadevrt_missing, + skip_if_mvc_enabled, test_data_dir) from numba.tests.support import SerialMixin from numba.tests.test_caching import (DispatcherCacheUsecasesTest, skip_bad_access) @@ -153,6 +154,22 @@ f = mod.renamed_function2 self.assertPreciseEqual(f(2), 8) + @skip_unless_cc_60 + @skip_if_cudadevrt_missing + @skip_if_mvc_enabled('CG not supported with MVC') + def test_cache_cg(self): + # Functions using cooperative groups should be cacheable. See Issue + # #8888: https://github.com/numba/numba/issues/8888 + self.check_pycache(0) + mod = self.import_module() + self.check_pycache(0) + + mod.cg_usecase(0) + self.check_pycache(2) # 1 index, 1 data + + # Check the code runs ok from another process + self.run_in_separate_process() + def _test_pycache_fallback(self): """ With a disabled __pycache__, test there is a working fallback @@ -482,6 +499,10 @@ # explicitly check def test_cannot_serialize_unfinalized(self): + # The CUDA codegen failes to import under the simulator, so we cannot + # import it at the top level + from numba.cuda.codegen import CUDACodeLibrary + # Usually a CodeLibrary requires a real CodeGen, but since we don't # interact with it, anything will do codegen = object() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/cuda/tests/cudapy/test_vectorize.py new/numba-0.57.1/numba/cuda/tests/cudapy/test_vectorize.py --- old/numba-0.57.0/numba/cuda/tests/cudapy/test_vectorize.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/cuda/tests/cudapy/test_vectorize.py 2023-06-21 10:39:46.000000000 +0200 @@ -4,6 +4,7 @@ from itertools import product from numba import vectorize from numba import cuda, int32, float32, float64 +from numba.cuda.cudadrv.driver import CudaAPIError, driver from numba.cuda.testing import skip_on_cudasim from numba.cuda.testing import CUDATestCase import unittest @@ -227,6 +228,56 @@ self.assertEqual(bar.__name__, 'bar') + def test_no_transfer_for_device_data(self): + # Initialize test data on the device prior to banning host <-> device + # transfer + + noise = np.random.randn(1, 3, 64, 64).astype(np.float32) + noise = cuda.to_device(noise) + + # A mock of a CUDA function that always raises a CudaAPIError + + def raising_transfer(*args, **kwargs): + 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) + + setattr(driver, 'cuMemcpyHtoD', raising_transfer) + setattr(driver, 'cuMemcpyDtoH', raising_transfer) + + # Ensure that the mock functions are working as expected + + with self.assertRaisesRegex(CudaAPIError, "Transfer not allowed"): + noise.copy_to_host() + + with self.assertRaisesRegex(CudaAPIError, "Transfer not allowed"): + cuda.to_device([1]) + + try: + # Check that defining and calling a ufunc with data on the device + # induces no transfers + + @vectorize(['float32(float32)'], target='cuda') + def func(noise): + return noise + 1.0 + + func(noise) + finally: + # Replace our mocks with the original implementations. If there was + # no original implementation, simply remove ours. + + if old_HtoD is not None: + setattr(driver, 'cuMemcpyHtoD', old_HtoD) + else: + del driver.cuMemcpyHtoD + if old_DtoH is not None: + setattr(driver, 'cuMemcpyDtoH', old_DtoH) + else: + del driver.cuMemcpyDtoH + if __name__ == '__main__': unittest.main() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/misc/numba_sysinfo.py new/numba-0.57.1/numba/misc/numba_sysinfo.py --- old/numba-0.57.0/numba/misc/numba_sysinfo.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/misc/numba_sysinfo.py 2023-06-21 10:39:46.000000000 +0200 @@ -392,8 +392,8 @@ sys_info[_cu_mvc_available] = False sys_info[_cu_mvc_needed] = cu_rt_ver > cu_drv_ver - mvc_used = hasattr(cudadrv.driver, 'CubinLinker') - sys_info[_cu_mvc_in_use] = mvc_used + sys_info[_cu_mvc_in_use] = bool( + config.CUDA_ENABLE_MINOR_VERSION_COMPATIBILITY) except Exception as e: _warning_log.append( "Warning (cuda): Probing CUDA failed " diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/np/arraymath.py new/numba-0.57.1/numba/np/arraymath.py --- old/numba-0.57.0/numba/np/arraymath.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/np/arraymath.py 2023-06-21 10:39:47.000000000 +0200 @@ -3212,7 +3212,14 @@ return np.arctan2(z.imag, z.real) return impl elif isinstance(z, types.Array): - ret_dtype = z.dtype + dtype = z.dtype + + if isinstance(dtype, types.Complex): + ret_dtype = dtype.underlying_float + elif isinstance(dtype, types.Float): + ret_dtype = dtype + else: + return def impl(z, deg=False): out = np.zeros_like(z, dtype=ret_dtype) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/np/arrayobj.py new/numba-0.57.1/numba/np/arrayobj.py --- old/numba-0.57.0/numba/np/arrayobj.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/np/arrayobj.py 2023-06-21 10:39:46.000000000 +0200 @@ -1543,14 +1543,16 @@ else: tup_init = (1,) * m + from numba.cpython.builtins import _isinstance_no_warn + def impl(*args): # propagate args r = [1] * m tup = tup_init for arg in literal_unroll(args): - if isinstance(arg, tuple) and len(arg) > 0: + if _isinstance_no_warn(arg, tuple) and len(arg) > 0: numpy_broadcast_shapes_list(r, m, arg) - elif isinstance(arg, int): + elif _isinstance_no_warn(arg, int): numpy_broadcast_shapes_list(r, m, (arg,)) for idx, elem in enumerate(r): tup = tuple_setitem(tup, idx, elem) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/np/ufunc/deviceufunc.py new/numba-0.57.1/numba/np/ufunc/deviceufunc.py --- old/numba-0.57.0/numba/np/ufunc/deviceufunc.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/np/ufunc/deviceufunc.py 2023-06-21 10:39:46.000000000 +0200 @@ -105,7 +105,10 @@ """ for i, ary in enumerate(self.arrays): if ary is not None: - self.argtypes[i] = np.asarray(ary).dtype + dtype = getattr(ary, 'dtype') + if dtype is None: + dtype = np.asarray(ary).dtype + self.argtypes[i] = dtype def _resolve_signature(self): """Resolve signature. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/parfors/parfor_lowering.py new/numba-0.57.1/numba/parfors/parfor_lowering.py --- old/numba-0.57.0/numba/parfors/parfor_lowering.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/parfors/parfor_lowering.py 2023-06-21 10:39:46.000000000 +0200 @@ -1539,7 +1539,7 @@ pm = PassManager("full_parfor_gufunc") parfor_gufunc_passes = dpb.define_parfor_gufunc_pipeline(self.state) pm.passes.extend(parfor_gufunc_passes.passes) - lowering_passes = dpb.define_nopython_lowering_pipeline(self.state) + lowering_passes = dpb.define_parfor_gufunc_nopython_lowering_pipeline(self.state) pm.passes.extend(lowering_passes.passes) pm.finalize() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/tests/test_array_methods.py new/numba-0.57.1/numba/tests/test_array_methods.py --- old/numba-0.57.0/numba/tests/test_array_methods.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/tests/test_array_methods.py 2023-06-21 10:39:47.000000000 +0200 @@ -8,7 +8,8 @@ from numba import jit, typeof from numba.core import types from numba.core.compiler import compile_isolated -from numba.core.errors import TypingError, LoweringError, NumbaValueError +from numba.core.errors import (TypingError, LoweringError, NumbaValueError, + NumbaExperimentalFeatureWarning) from numba.np.numpy_support import as_dtype, numpy_version from numba.tests.support import (TestCase, CompilationCache, MemoryLeak, MemoryLeakMixin, tag, needs_blas) @@ -784,6 +785,23 @@ def test_np_where_1(self): self.check_nonzero(np_where_1) + def test_np_where_no_isinstance_warn(self): + # TODO: remove this test before Numba 0.58 release + # When _isinstance_no_warn has been removed. + msg = 'Use of isinstance() detected. This is an experimental feature.' + category = NumbaExperimentalFeatureWarning + a = np.arange(10) + cfunc = jit(nopython=True)(np_where_3) + + with warnings.catch_warnings(record=True) as catch: + cfunc(a < 5, a, 10 * a) + + found = False + for w in catch: + if msg in str(w.message) and w.category == category: + found = True + self.assertFalse(found) + def test_np_where_3(self): pyfunc = np_where_3 def fac(N): diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/tests/test_mixed_tuple_unroller.py new/numba-0.57.1/numba/tests/test_mixed_tuple_unroller.py --- old/numba-0.57.0/numba/tests/test_mixed_tuple_unroller.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/tests/test_mixed_tuple_unroller.py 2023-06-21 10:39:47.000000000 +0200 @@ -1830,6 +1830,35 @@ while x == 1: x = 0 + def test_literal_unroll_legalize_var_names01(self): + # See issue #8939 + test = np.array([(1, 2), (2, 3)], dtype=[("a1", "f8"), ("a2", "f8")]) + fields = tuple(test.dtype.fields.keys()) + + @njit + def foo(arr): + res = 0 + for k in literal_unroll(fields): + res = res + np.abs(arr[k]).sum() + return res + + self.assertEqual(foo(test), 8.0) + + def test_literal_unroll_legalize_var_names02(self): + # See issue #8939 + test = np.array([(1, 2), (2, 3)], + dtype=[("a1[0]", "f8"), ("a2[1]", "f8")]) + fields = tuple(test.dtype.fields.keys()) + + @njit + def foo(arr): + res = 0 + for k in literal_unroll(fields): + res = res + np.abs(arr[k]).sum() + return res + + self.assertEqual(foo(test), 8.0) + def capture(real_pass): """ Returns a compiler pass that captures the mutation state reported diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/tests/test_np_functions.py new/numba-0.57.1/numba/tests/test_np_functions.py --- old/numba-0.57.0/numba/tests/test_np_functions.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/tests/test_np_functions.py 2023-06-21 10:39:47.000000000 +0200 @@ -6,6 +6,7 @@ from functools import partial from itertools import product import warnings +from textwrap import dedent import numpy as np @@ -19,7 +20,7 @@ from numba.core.utils import pysignature from numba.np.extensions import cross2d from numba.tests.support import (TestCase, CompilationCache, MemoryLeakMixin, - needs_blas) + needs_blas, run_in_subprocess) import unittest @@ -644,6 +645,22 @@ x_types = [types.complex64, types.complex128] check(x_types, x_values) + def test_angle_return_type(self): + # see issue #8949 + def numba_angle(x): + r = np.angle(x) + return r.dtype + + pyfunc = numba_angle + x_values = [1., -1., 1. + 0j, -5 - 5j] + x_types = ['f4', 'f8', 'c8', 'c16'] + for val, typ in zip(x_values, x_types): + x = np.array([val], dtype=typ) + cfunc = jit(nopython=True)(pyfunc) + expected = pyfunc(x) + got = cfunc(x) + self.assertEquals(expected, got) + def test_angle_exceptions(self): pyfunc = angle1 cfunc = jit(nopython=True)(pyfunc) @@ -5367,5 +5384,25 @@ self.assertIn('`np.MachAr` is deprecated', str(w[0])) +class TestRegistryImports(TestCase): + + def test_unsafe_import_in_registry(self): + # See 8940 + # This should not fail + code = dedent(""" + import numba + import numpy as np + @numba.njit + def foo(): + np.array([1 for _ in range(1)]) + foo() + print("OK") + """) + result, error = run_in_subprocess(code) + # Assert that the bytestring "OK" was printed to stdout + self.assertEquals(b"OK", result.strip()) + self.assertEquals(b"", error.strip()) + + if __name__ == '__main__': unittest.main() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba/tests/test_parfors.py new/numba-0.57.1/numba/tests/test_parfors.py --- old/numba-0.57.0/numba/tests/test_parfors.py 2023-05-02 17:53:11.000000000 +0200 +++ new/numba-0.57.1/numba/tests/test_parfors.py 2023-06-21 10:39:47.000000000 +0200 @@ -4697,5 +4697,24 @@ self.assertPreciseEqual(expect, got) +@skip_parfors_unsupported +class TestDiagnosticEnvVar(TestCase): + @TestCase.run_test_in_subprocess() + def test_diagnostics_env_var1(self): + os.environ['NUMBA_PARALLEL_DIAGNOSTICS']='4' + with captured_stdout() as stdout: + @njit(parallel=True) + def impl(): + n = 100 + b = np.zeros((n), dtype=np.float64) + for i in prange(n): + b[i] = 1 + return b + + impl() + the_output = stdout.getvalue() + self.assertIn("Parallel Accelerator Optimizing", the_output) + + if __name__ == "__main__": unittest.main() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba.egg-info/PKG-INFO new/numba-0.57.1/numba.egg-info/PKG-INFO --- old/numba-0.57.0/numba.egg-info/PKG-INFO 2023-05-02 17:53:18.000000000 +0200 +++ new/numba-0.57.1/numba.egg-info/PKG-INFO 2023-06-21 10:39:56.000000000 +0200 @@ -1,6 +1,6 @@ Metadata-Version: 2.1 Name: numba -Version: 0.57.0 +Version: 0.57.1 Summary: compiling Python code using LLVM Home-page: https://numba.pydata.org License: BSD diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/numba-0.57.0/numba.egg-info/SOURCES.txt new/numba-0.57.1/numba.egg-info/SOURCES.txt --- old/numba-0.57.0/numba.egg-info/SOURCES.txt 2023-05-02 17:53:18.000000000 +0200 +++ new/numba-0.57.1/numba.egg-info/SOURCES.txt 2023-06-21 10:39:56.000000000 +0200 @@ -407,6 +407,7 @@ numba/cuda/tests/cudadrv/test_is_fp16.py numba/cuda/tests/cudadrv/test_linker.py numba/cuda/tests/cudadrv/test_managed_alloc.py +numba/cuda/tests/cudadrv/test_mvc.py numba/cuda/tests/cudadrv/test_nvvm_driver.py numba/cuda/tests/cudadrv/test_pinned.py numba/cuda/tests/cudadrv/test_profiler.py
