Using heap dump analyser on Windows.

Author: tzezula

truffle/src/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/GCUtils.java

@@ -43,6 +43,7 @@
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.IOException;
+import java.io.PrintStream;
 import java.lang.management.ManagementFactory;
 import java.lang.ref.Reference;
 import java.lang.ref.WeakReference;
@@ -97,7 +98,7 @@ public final class GCUtils {
      */
     private static final String SAVE_HEAP_DUMP_TO = System.getProperty(GCUtils.class.getSimpleName() + ".saveHeapDumpTo");
 
-    private static final ReachabilityAnalyser<?> analyser = selectAnalyser();
+    private static final ReachabilityAnalyser<?> analyser = new HeapDumpAnalyser();
 
     private GCUtils() {
         throw new IllegalStateException("No instance allowed.");
@@ -115,6 +116,10 @@ private GCUtils() {
      * @param objectFactory producer of collectible object per an iteration
      */
     public static void assertObjectsCollectible(Function<Integer, Object> objectFactory) {
+        if (!isSupported()) {
+            emitHeapDumpNotSupportedWarning("assertObjectsCollectible");
+            return;
+        }
         List<Reference<Object>> collectibleObjects = new ArrayList<>();
         for (int i = 0; i < GC_TEST_ITERATIONS; i++) {
             collectibleObjects.add(new WeakReference<>(objectFactory.apply(i)));
@@ -138,6 +143,10 @@ public static void assertObjectsCollectible(Function<Integer, Object> objectFact
      * @see #assertGc(Collection)
      */
     public static void assertGc(String message, Reference<?> ref) {
+        if (!isSupported()) {
+            emitHeapDumpNotSupportedWarning("assertGc");
+            return;
+        }
         Result result = analyser.allCollected(Collections.singleton(ref), true, true, PRESERVE_HEAP_DUMP_ON_FAILURE);
         if (!result.isCollected()) {
             Assert.fail(formatShortestGCRootPath(message, result));
@@ -154,6 +163,10 @@ public static void assertGc(String message, Reference<?> ref) {
      * @param refs references their referents are to be released
      */
     public static void assertGc(String message, Collection<? extends Reference<?>> refs) {
+        if (!isSupported()) {
+            emitHeapDumpNotSupportedWarning("assertGc");
+            return;
+        }
         Result result = analyser.allCollected(refs, true, true, PRESERVE_HEAP_DUMP_ON_FAILURE);
         if (!result.isCollected()) {
             Assert.fail(formatShortestGCRootPath(message, result));
@@ -170,6 +183,10 @@ public static void assertGc(String message, Collection<? extends Reference<?>> r
      *            {@link AssertionError} thrown when the referent is not freed by the GC
      */
     public static void assertGc(Collection<? extends Pair<String, Reference<?>>> refsWithMessages) {
+        if (!isSupported()) {
+            emitHeapDumpNotSupportedWarning("assertGc");
+            return;
+        }
         Map<Reference<?>, String> refsMap = new IdentityHashMap<>();
         for (Pair<String, Reference<?>> pair : refsWithMessages) {
             refsMap.putIfAbsent(pair.getRight(), pair.getLeft());
@@ -188,6 +205,10 @@ public static void assertGc(Collection<? extends Pair<String, Reference<?>>> ref
      * @param ref the reference
      */
     public static void assertNotGc(final String message, final Reference<?> ref) {
+        if (!isSupported()) {
+            emitHeapDumpNotSupportedWarning("assertNotGc");
+            return;
+        }
         if (analyser.allCollected(Collections.singleton(ref), false, false, false).isCollected()) {
             Assert.fail(message);
         }
@@ -243,14 +264,14 @@ public static void generateGcPressure(double heapLoadFactor) {
         }
     }
 
-    private static ReachabilityAnalyser<?> selectAnalyser() {
-        if (OSUtils.isWindows()) {
-            // On Windows there are problems with the Heap release, which prevents the headump file
-            // from being deleted.
-            return new GCAnalyser();
-        } else {
-            return new HeapDumpAnalyser();
-        }
+    public static boolean isSupported() {
+        return !ImageInfo.inImageRuntimeCode() || !OSUtils.isWindows();
+    }
+
+    private static void emitHeapDumpNotSupportedWarning(String method) {
+        PrintStream err = System.err;
+        err.printf("[GCUtils] Ignoring GCUtils.%s: heap dump not supported in native-image on %s.%n",
+                        method, OSUtils.getCurrent());
     }
 
     private static String formatShortestGCRootPath(String message, Result result) {
@@ -344,17 +365,6 @@ private Result() {
             this.heapDumpFile = null;
         }
 
-        Result(Reference<?> reference) {
-            this.collected = false;
-            this.reference = reference;
-            this.gcRootKind = null;
-            this.instanceId = -1;
-            this.shortestGCRootPath = null;
-            this.gcRootThreadId = -1;
-            this.gcRootStackTrace = null;
-            this.heapDumpFile = null;
-        }
-
         Result(Reference<?> reference, long instanceId, String gcRootKind, Iterable<? extends InstanceReference> shortestGCRootPath,
                         long gcRootThreadId, Iterable<? extends StackTraceElement> gcRootStackTrace, Path heapDumpFile) {
             this.collected = false;
@@ -674,60 +684,18 @@ private static HotSpotDiagnosticMXBean getHotSpotDiagnosticMBean() throws IOExce
         }
 
         private static void delete(Path file) throws IOException {
-            if (Files.isDirectory(file, LinkOption.NOFOLLOW_LINKS)) {
-                try (DirectoryStream<Path> content = Files.newDirectoryStream(file)) {
-                    for (Path child : content) {
-                        delete(child);
-                    }
-                }
-            }
-            Files.delete(file);
-        }
-    }
-
-    private static final class GCAnalyser extends ReachabilityAnalyser<Void> {
-
-        @Override
-        Result analyse(Collection<? extends Reference<?>> references, boolean performAllocations, boolean collectGCRootPath,
-                        boolean preserveHeapDumpIfNonCollectable, Function<Void, Result> testCollected) {
-            int blockSize = 100_000;
-            final List<byte[]> blocks = new ArrayList<>();
-            Result result = null;
-            for (int i = 0; i < 50; i++) {
-                result = testCollected.apply(null);
-                if (result.isCollected()) {
-                    return result;
-                }
-                try {
-                    System.gc();
-                } catch (OutOfMemoryError oom) {
-                }
-                try {
-                    System.runFinalization();
-                } catch (OutOfMemoryError oom) {
-                }
-                if (performAllocations) {
-                    try {
-                        blocks.add(new byte[blockSize]);
-                        blockSize = (int) (blockSize * 1.3);
-                    } catch (OutOfMemoryError oom) {
-                        blockSize >>>= 1;
-                    }
-                }
-                if (i % 10 == 0) {
-                    try {
-                        Thread.sleep(500);
-                    } catch (InterruptedException ie) {
-                        break;
+            // On Windows there are problems with the Heap release, which prevents the headump file
+            // from being deleted.
+            if (OSUtils.getCurrent() != OSUtils.OS.Windows) {
+                if (Files.isDirectory(file, LinkOption.NOFOLLOW_LINKS)) {
+                    try (DirectoryStream<Path> content = Files.newDirectoryStream(file)) {
+                        for (Path child : content) {
+                            delete(child);
+                        }
                     }
                 }
+                Files.delete(file);
             }
-            return result;
-        }
-
-        @Override
-        Result isCollected(Reference<?> reference, Void context) {
-            return reference.get() == null ? Result.COLLECTED : new Result(reference);
         }
     }
 }

truffle/src/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/polyglot/LoggingTest.java

@@ -1389,6 +1389,7 @@ public void testInterpreterOnlyWarning() {
 
     @Test
     public void testGR49739() {
+        Assume.assumeTrue(GCUtils.isSupported());
         AtomicReference<TruffleLogger> loggerHolder = new AtomicReference<>();
         AbstractLoggingLanguage.action = (ctx, defaultLoggers) -> {
             loggerHolder.set(ctx.env.getLogger("after.close"));

truffle/src/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/polyglot/PolyglotGCTest.java

@@ -56,6 +56,7 @@
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.RootNode;
 import com.oracle.truffle.api.test.GCUtils;
+import com.oracle.truffle.api.test.OSUtils;
 import com.oracle.truffle.api.test.ReflectionUtils;
 import com.oracle.truffle.api.test.SubprocessTestUtils;
 import com.oracle.truffle.api.test.common.AbstractExecutableTestLanguage;
@@ -77,6 +78,7 @@
 import org.graalvm.polyglot.management.ExecutionListener;
 import org.junit.AfterClass;
 import org.junit.Assert;
+import org.junit.Assume;
 import org.junit.Before;
 import org.junit.BeforeClass;
 import org.junit.Test;
@@ -156,6 +158,7 @@ public static void tearDownClass() {
 
     @Before
     public void setUp() {
+        Assume.assumeTrue(GCUtils.isSupported());
         testLogHandler = new TestLogHandler();
         languageInnerContextDisposed.set(false);
     }
@@ -680,6 +683,7 @@ protected Object execute(RootNode node, Env env, Object[] contextArguments, Obje
 
     @Test
     public void testInnerContextSPI() throws Exception {
+        Assume.assumeTrue(TruffleTestAssumptions.isWeakEncapsulation() || !OSUtils.isWindows());
         runInSubprocess(() -> {
             Context context = newContextBuilder().build();
             AbstractExecutableTestLanguage.execute(context, UnreachableInnerContextGcLanguage2.class);

truffle/src/com.oracle.truffle.api.test/src/com/oracle/truffle/api/test/source/SourceCacheTest.java

@@ -66,6 +66,7 @@
 import org.graalvm.polyglot.Source;
 import org.graalvm.polyglot.io.ByteSequence;
 import org.junit.Assert;
+import org.junit.Assume;
 import org.junit.Test;
 
 import com.oracle.truffle.api.CallTarget;
@@ -154,6 +155,7 @@ public void testTraceSourceCacheFailure() throws Throwable {
     @Test
     public void testTraceSourceCacheEviction() throws IOException, InterruptedException {
         TruffleTestAssumptions.assumeWeakEncapsulation(); // Can't control GC in the isolate.
+        Assume.assumeTrue(GCUtils.isSupported());
         Runnable runnable = () -> {
             try (ByteArrayOutputStream out = new ByteArrayOutputStream(); Context context = Context.newBuilder().option("engine.TraceSourceCache", "true").out(out).err(out).build()) {
                 Source auxiliarySource = Source.newBuilder(SourceCacheTestLanguage.ID, "x", "AuxiliarySource").build();
@@ -321,6 +323,7 @@ protected CallTarget parse(ParsingRequest request) throws Exception {
     @Test
     public void testSourceCachesCleared() throws IOException, InterruptedException {
         TruffleTestAssumptions.assumeWeakEncapsulation(); // Can't control GC in the isolate.
+        Assume.assumeTrue(GCUtils.isSupported());
         Runnable runnable = () -> {
             List<String> logs = new ArrayList<>();
             String[] expectedSequence = new String[]{"miss1", "miss2", "evict2", "miss1", "evict1", "evict1"};