dropped WaitForFullGCComplete, as GC.Collect is blocking

lostmsu · lostmsu · commit 8d89411e356f · 2020-12-10T16:19:39.000-08:00
diff --git a/src/embed_tests/TestFinalizer.cs b/src/embed_tests/TestFinalizer.cs
@@ -28,25 +28,16 @@ public void TearDown()
             PythonEngine.Shutdown();
         }
 
-        private static bool FullGCCollect()
+        private static void FullGCCollect()
         {
-            GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
-            try
-            {
-                return GC.WaitForFullGCComplete() == GCNotificationStatus.Succeeded;
-            }
-            catch (NotImplementedException)
-            {
-                // Some clr runtime didn't implement GC.WaitForFullGCComplete yet.
-                return false;
-            }
-            finally
-            {
-                GC.WaitForPendingFinalizers();
-            }
+            Thread.MemoryBarrier();
+            GC.Collect();
+            GC.WaitForPendingFinalizers();
+            Thread.MemoryBarrier();
         }
 
         [Test]
+        [Obsolete("GC tests are not guaranteed")]
         public void CollectBasicObject()
         {
             Assert.IsTrue(Finalizer.Instance.Enable);
@@ -103,17 +94,13 @@ public void CollectBasicObject()
         }
 
         [Test]
+        [Obsolete("GC tests are not guaranteed")]
         public void CollectOnShutdown()
         {
             IntPtr op = MakeAGarbage(out var shortWeak, out var longWeak);
-            int hash = shortWeak.Target.GetHashCode();
-            List<WeakReference> garbage;
-            if (!FullGCCollect())
-            {
-                Assert.IsTrue(WaitForCollected(op, hash, 10000));
-            }
+            FullGCCollect();
             Assert.IsFalse(shortWeak.IsAlive);
-            garbage = Finalizer.Instance.GetCollectedObjects();
+            List<WeakReference> garbage = Finalizer.Instance.GetCollectedObjects();
             Assert.IsNotEmpty(garbage, "The garbage object should be collected");
             Assert.IsTrue(garbage.Any(r => ReferenceEquals(r.Target, longWeak.Target)),
                 "Garbage should contains the collected object");
@@ -123,13 +110,29 @@ public void CollectOnShutdown()
             Assert.IsEmpty(garbage);
         }
 
-        [MethodImpl(MethodImplOptions.NoInlining)] // ensure lack of references to obj
+        [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)] // ensure lack of references to obj
+        [Obsolete("GC tests are not guaranteed")]
         private static IntPtr MakeAGarbage(out WeakReference shortWeak, out WeakReference longWeak)
         {
-            PyLong obj = new PyLong(1024);
-            shortWeak = new WeakReference(obj);
-            longWeak = new WeakReference(obj, true);
-            return obj.Handle;
+            IntPtr handle = IntPtr.Zero;
+            WeakReference @short = null, @long = null;
+            // must create Python object in the thread where we have GIL
+            IntPtr val = PyLong.FromLong(1024);
+            // must create temp object in a different thread to ensure it is not present
+            // when conservatively scanning stack for GC roots.
+            // see https://xamarin.github.io/bugzilla-archives/17/17593/bug.html
+            var garbageGen = new Thread(() =>
+            {
+                var obj = new PyObject(val, skipCollect: true);
+                @short = new WeakReference(obj);
+                @long = new WeakReference(obj, true);
+                handle = obj.Handle;
+            });
+            garbageGen.Start();
+            Assert.IsTrue(garbageGen.Join(TimeSpan.FromSeconds(5)), "Garbage creation timed out");
+            shortWeak = @short;
+            longWeak = @long;
+            return handle;
         }
 
         private static long CompareWithFinalizerOn(PyObject pyCollect, bool enbale)
@@ -210,6 +213,7 @@ internal static void CreateMyPyObject(IntPtr op)
         }
 
         [Test]
+        [Obsolete("GC tests are not guaranteed")]
         public void ErrorHandling()
         {
             bool called = false;
@@ -227,7 +231,7 @@ public void ErrorHandling()
                 WeakReference longWeak;
                 {
                     MakeAGarbage(out shortWeak, out longWeak);
-                    var obj = (PyLong)longWeak.Target;
+                    var obj = (PyObject)longWeak.Target;
                     IntPtr handle = obj.Handle;
                     shortWeak = null;
                     longWeak = null;
@@ -278,36 +282,13 @@ public void ValidateRefCount()
             }
         }
 
+        [MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)] // ensure lack of references to s1 and s2
         private static IntPtr CreateStringGarbage()
         {
             PyString s1 = new PyString("test_string");
             // s2 steal a reference from s1
             PyString s2 = new PyString(s1.Handle);
             return s1.Handle;
         }
-
-        private static bool WaitForCollected(IntPtr op, int hash, int milliseconds)
-        {
-            var stopwatch = Stopwatch.StartNew();
-            do
-            {
-                var garbage = Finalizer.Instance.GetCollectedObjects();
-                foreach (var item in garbage)
-                {
-                    // The validation is not 100% precise,
-                    // but it's rare that two conditions satisfied but they're still not the same object.
-                    if (item.Target.GetHashCode() != hash)
-                    {
-                        continue;
-                    }
-                    var obj = (IPyDisposable)item.Target;
-                    if (obj.GetTrackedHandles().Contains(op))
-                    {
-                        return true;
-                    }
-                }
-            } while (stopwatch.ElapsedMilliseconds < milliseconds);
-            return false;
-        }
     }
 }
diff --git a/src/runtime/pylong.cs b/src/runtime/pylong.cs
@@ -74,7 +74,7 @@ public PyLong(uint value) : base(FromInt((int)value))
         }
 
 
-        private static IntPtr FromLong(long value)
+        internal static IntPtr FromLong(long value)
         {
             IntPtr val = Runtime.PyLong_FromLongLong(value);
             PythonException.ThrowIfIsNull(val);
diff --git a/src/runtime/pyobject.cs b/src/runtime/pyobject.cs
@@ -54,6 +54,19 @@ public PyObject(IntPtr ptr)
 #endif
         }
 
+        [Obsolete("this is for testing purposes only")]
+        internal PyObject(IntPtr ptr, bool skipCollect)
+        {
+            if (ptr == IntPtr.Zero) throw new ArgumentNullException(nameof(ptr));
+
+            obj = ptr;
+            if (!skipCollect)
+                Finalizer.Instance.ThrottledCollect();
+#if TRACE_ALLOC
+            Traceback = new StackTrace(1);
+#endif
+        }
+
         /// <summary>
         /// Creates new <see cref="PyObject"/> pointing to the same object as
         /// the <paramref name="reference"/>. Increments refcount, allowing <see cref="PyObject"/>

Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ public PyLong(uint value) : base(FromInt((int)value))`
`74`	`74`	`}`
`75`	`75`
`76`	`76`
`77`		`- private static IntPtr FromLong(long value)`
	`77`	`+ internal static IntPtr FromLong(long value)`
`78`	`78`	`{`
`79`	`79`	`IntPtr val = Runtime.PyLong_FromLongLong(value);`
`80`	`80`	`PythonException.ThrowIfIsNull(val);`