@@ -1,3 +1,23 @@
+Version 0.53.1 (25 March, 2021)
+-------------------------------
+
+This is a bugfix release for 0.53.0. It contains the following four
+pull-requests which fix two critical regressions and two build failures
+reported by the openSuSe team:
+
+* PR #6851 set non-reported llvm timing values to 0.0
+* PR #6837 Ignore warnings from packaging module when testing import behaviour.
+* PR #6828 Fix regression in CUDA: Set stream in mapped and managed array
+  device_setup
+* PR #6826 Fix regression on gufunc serialization
+
+Authors:
+
+* Ben Greiner
+* Graham Markall
+* Siu Kwan Lam
+* Stuart Archibald
+
 Version 0.53.0 (11 March, 2021)
 -------------------------------
 
 
@@ -678,6 +678,7 @@ class MappedNDArray(DeviceNDArrayBase, np.ndarray):
 
     def device_setup(self, gpu_data, stream=0):
         self.gpu_data = gpu_data
+        self.stream = stream
 
 
 class ManagedNDArray(DeviceNDArrayBase, np.ndarray):
@@ -687,6 +688,7 @@ class ManagedNDArray(DeviceNDArrayBase, np.ndarray):
 
     def device_setup(self, gpu_data, stream=0):
         self.gpu_data = gpu_data
+        self.stream = stream
 
 
 def from_array_like(ary, stream=0, gpu_data=None):
 
@@ -4,7 +4,7 @@
 from numba import cuda
 from numba.cuda.testing import unittest, ContextResettingTestCase, ForeignArray
 from numba.cuda.testing import skip_on_cudasim, skip_if_external_memmgr
-from numba.tests.support import override_config
+from numba.tests.support import linux_only, override_config
 from unittest.mock import call, patch
 
 
@@ -261,12 +261,32 @@ def test_produce_no_stream(self):
         c_arr = cuda.device_array(10)
         self.assertIsNone(c_arr.__cuda_array_interface__['stream'])
 
+        mapped_arr = cuda.mapped_array(10)
+        self.assertIsNone(mapped_arr.__cuda_array_interface__['stream'])
+
+    @linux_only
+    def test_produce_managed_no_stream(self):
+        managed_arr = cuda.managed_array(10)
+        self.assertIsNone(managed_arr.__cuda_array_interface__['stream'])
+
     def test_produce_stream(self):
         s = cuda.stream()
         c_arr = cuda.device_array(10, stream=s)
         cai_stream = c_arr.__cuda_array_interface__['stream']
         self.assertEqual(s.handle.value, cai_stream)
 
+        s = cuda.stream()
+        mapped_arr = cuda.mapped_array(10, stream=s)
+        cai_stream = mapped_arr.__cuda_array_interface__['stream']
+        self.assertEqual(s.handle.value, cai_stream)
+
+    @linux_only
+    def test_produce_managed_stream(self):
+        s = cuda.stream()
+        managed_arr = cuda.managed_array(10, stream=s)
+        cai_stream = managed_arr.__cuda_array_interface__['stream']
+        self.assertEqual(s.handle.value, cai_stream)
+
     def test_consume_no_stream(self):
         # Create a foreign array with no stream
         f_arr = ForeignArray(cuda.device_array(10))
 
@@ -239,12 +239,14 @@ def parse(raw_data):
                     missing[k] = 0.0
             # parse timings
             n = r"\s*((?:[0-9]+\.)?[0-9]+)"
-            pat = f"\\s+{n}\\s*\\({n}%\\)" * (len(headers) - 1) + r"\s*(.*)"
+            pat = f"\\s+(?:{n}\\s*\\({n}%\\)|-+)" * (len(headers) - 1)
+            pat += r"\s*(.*)"
             for ln in line_iter:
                 m = re.match(pat, ln)
                 if m is not None:
                     raw_data = list(m.groups())
-                    data = {k: float(v) for k, v in zip(attrs, raw_data)}
+                    data = {k: float(v) if v is not None else 0.0
+                            for k, v in zip(attrs, raw_data)}
                     data.update(missing)
                     pass_name = raw_data[-1]
                     rec = PassTimingRecord(
 
@@ -3,9 +3,10 @@
 from numba.np.ufunc.ufuncbuilder import GUFuncBuilder
 from numba.np.ufunc.sigparse import parse_signature
 from numba.np.numpy_support import ufunc_find_matching_loop
+from numba.core import serialize
 
 
-class GUFunc(object):
+class GUFunc(serialize.ReduceMixin):
     """
     Dynamic generalized universal function (GUFunc)
     intended to act like a normal Numpy gufunc, but capable
@@ -18,13 +19,40 @@ def __init__(self, py_func, signature, identity=None, cache=None,
         self.ufunc = None
         self._frozen = False
         self._is_dynamic = is_dynamic
+        self._identity = identity
 
         # GUFunc cannot inherit from GUFuncBuilder because "identity"
         # is a property of GUFunc. Thus, we hold a reference to a GUFuncBuilder
         # object here
         self.gufunc_builder = GUFuncBuilder(
             py_func, signature, identity, cache, targetoptions)
 
+    def _reduce_states(self):
+        gb = self.gufunc_builder
+        dct = dict(
+            py_func=gb.py_func,
+            signature=gb.signature,
+            identity=self._identity,
+            cache=gb.cache,
+            is_dynamic=self._is_dynamic,
+            targetoptions=gb.targetoptions,
+            typesigs=gb._sigs,
+            frozen=self._frozen,
+        )
+        return dct
+
+    @classmethod
+    def _rebuild(cls, py_func, signature, identity, cache, is_dynamic,
+                 targetoptions, typesigs, frozen):
+        self = cls(py_func=py_func, signature=signature, identity=identity,
+                   cache=cache, is_dynamic=is_dynamic,
+                   targetoptions=targetoptions)
+        for sig in typesigs:
+            self.add(sig)
+        self.build_ufunc()
+        self._frozen = frozen
+        return self
+
     def __repr__(self):
         return f"<numba._GUFunc '{self.__name__}'>"
 
 
@@ -1,10 +1,12 @@
+import unittest
+import pickle
+
 import numpy as np
 import numpy.core.umath_tests as ut
 
 from numba import void, float32, jit, guvectorize
 from numba.np.ufunc import GUVectorize
 from numba.tests.support import tag, TestCase
-import unittest
 
 
 def matmulcore(A, B, C):
@@ -281,5 +283,119 @@ class TestGUVectorizeScalarParallel(TestGUVectorizeScalar):
     target = 'parallel'
 
 
+class TestGUVectorizePickling(TestCase):
+    def test_pickle_gufunc_non_dyanmic(self):
+        """Non-dynamic gufunc.
+        """
+        @guvectorize(["f8,f8[:]"], "()->()")
+        def double(x, out):
+            out[:] = x * 2
+
+        # pickle
+        ser = pickle.dumps(double)
+        cloned = pickle.loads(ser)
+
+        # attributes carried over
+        self.assertEqual(cloned._frozen, double._frozen)
+        self.assertEqual(cloned.identity, double.identity)
+        self.assertEqual(cloned.is_dynamic, double.is_dynamic)
+        self.assertEqual(cloned.gufunc_builder._sigs,
+                         double.gufunc_builder._sigs)
+        # expected value of attributes
+        self.assertTrue(cloned._frozen)
+
+        cloned.disable_compile()
+        self.assertTrue(cloned._frozen)
+
+        # scalar version
+        self.assertPreciseEqual(double(0.5), cloned(0.5))
+        # array version
+        arr = np.arange(10)
+        self.assertPreciseEqual(double(arr), cloned(arr))
+
+    def test_pickle_gufunc_dyanmic_null_init(self):
+        """Dynamic gufunc w/o prepopulating before pickling.
+        """
+        @guvectorize("()->()", identity=1)
+        def double(x, out):
+            out[:] = x * 2
+
+        # pickle
+        ser = pickle.dumps(double)
+        cloned = pickle.loads(ser)
+
+        # attributes carried over
+        self.assertEqual(cloned._frozen, double._frozen)
+        self.assertEqual(cloned.identity, double.identity)
+        self.assertEqual(cloned.is_dynamic, double.is_dynamic)
+        self.assertEqual(cloned.gufunc_builder._sigs,
+                         double.gufunc_builder._sigs)
+        # expected value of attributes
+        self.assertFalse(cloned._frozen)
+
+        # scalar version
+        expect = np.zeros(1)
+        got = np.zeros(1)
+        double(0.5, out=expect)
+        cloned(0.5, out=got)
+        self.assertPreciseEqual(expect, got)
+        # array version
+        arr = np.arange(10)
+        expect = np.zeros_like(arr)
+        got = np.zeros_like(arr)
+        double(arr, out=expect)
+        cloned(arr, out=got)
+        self.assertPreciseEqual(expect, got)
+
+    def test_pickle_gufunc_dyanmic_initialized(self):
+        """Dynamic gufunc prepopulated before pickling.
+
+        Once unpickled, we disable compilation to verify that the gufunc
+        compilation state is carried over.
+        """
+        @guvectorize("()->()", identity=1)
+        def double(x, out):
+            out[:] = x * 2
+
+        # prepopulate scalar
+        expect = np.zeros(1)
+        got = np.zeros(1)
+        double(0.5, out=expect)
+        # prepopulate array
+        arr = np.arange(10)
+        expect = np.zeros_like(arr)
+        got = np.zeros_like(arr)
+        double(arr, out=expect)
+
+        # pickle
+        ser = pickle.dumps(double)
+        cloned = pickle.loads(ser)
+
+        # attributes carried over
+        self.assertEqual(cloned._frozen, double._frozen)
+        self.assertEqual(cloned.identity, double.identity)
+        self.assertEqual(cloned.is_dynamic, double.is_dynamic)
+        self.assertEqual(cloned.gufunc_builder._sigs,
+                         double.gufunc_builder._sigs)
+        # expected value of attributes
+        self.assertFalse(cloned._frozen)
+
+        # disable compilation
+        cloned.disable_compile()
+        self.assertTrue(cloned._frozen)
+        # scalar version
+        expect = np.zeros(1)
+        got = np.zeros(1)
+        double(0.5, out=expect)
+        cloned(0.5, out=got)
+        self.assertPreciseEqual(expect, got)
+        # array version
+        expect = np.zeros_like(arr)
+        got = np.zeros_like(arr)
+        double(arr, out=expect)
+        cloned(arr, out=got)
+        self.assertPreciseEqual(expect, got)
+
+
 if __name__ == '__main__':
     unittest.main()
@@ -58,7 +58,9 @@ def test_no_accidental_warnings(self):
         # checks that importing Numba isn't accidentally triggering warnings due
         # to e.g. deprecated use of import locations from Python's stdlib
         code = "import numba"
-        flags = ["-Werror",]
+        # See: https://github.com/numba/numba/issues/6831
+        # bug in setuptools/packaging causing a deprecation warning
+        flags = ["-Werror", "-Wignore::DeprecationWarning:packaging.version:"]
         self.run_in_subproc(code, flags)
 
     def test_import_star(self):
 
@@ -5,6 +5,33 @@
 from numba.misc import llvm_pass_timings as lpt
 
 
+timings_raw1 = """
+===-------------------------------------------------------------------------===
+                      ... Pass execution timing report ...
+===-------------------------------------------------------------------------===
+  Total Execution Time: 0.0001 seconds (0.0001 wall clock)
+
+   ---User Time---   --System Time--   --User+System--   ---Wall Time---  --- Name ---
+   0.0001 ( 90.1%)   0.0001 ( 90.1%)   0.0001 ( 90.1%)   0.0001 ( 90.1%)  A1
+   0.0000 (  9.9%)   0.0000 (  9.9%)   0.0000 (  9.9%)   0.0000 (  9.9%)  A2
+   0.0001 (100.0%)   0.0001 (100.0%)   0.0001 (100.0%)   0.0001 (100.0%)  Total
+
+"""    # noqa: E501
+
+timings_raw2 = """
+===-------------------------------------------------------------------------===
+                      ... Pass execution timing report ...
+===-------------------------------------------------------------------------===
+  Total Execution Time: 0.0001 seconds (0.0001 wall clock)
+
+   ---User Time---   --System Time--   --User+System--   ---Wall Time---  --- Name ---
+   0.0001 ( 90.1%)        -----        0.0001 ( 90.1%)   0.0001 ( 90.1%)  A1
+   0.0000 (  9.9%)        -----        0.0000 (  9.9%)   0.0000 (  9.9%)  A2
+   0.0001 (100.0%)        -----        0.0001 (100.0%)   0.0001 (100.0%)  Total
+
+"""    # noqa: E501
+
+
 class TestLLVMPassTimings(TestCase):
 
     def test_usage(self):
@@ -61,6 +88,15 @@ def foo(n):
             self.assertGreaterEqual(last, cur)
             cur = last
 
+    def test_parse_raw(self):
+        timings1 = lpt.ProcessedPassTimings(timings_raw1)
+        self.assertAlmostEqual(timings1.get_total_time(), 0.0001)
+        self.assertIsInstance(timings1.summary(), str)
+
+        timings2 = lpt.ProcessedPassTimings(timings_raw2)
+        self.assertAlmostEqual(timings2.get_total_time(), 0.0001)
+        self.assertIsInstance(timings2.summary(), str)
+
 
 class TestLLVMPassTimingsDisabled(TestCase):
     def test_disabled_behavior(self):