AtomicReference will participate in PEA while WeakReference won't

Author: mur47x111

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/core/test/ea/PartialEscapeAnalysisIterationTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2017, 2025, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -30,6 +30,7 @@
 import org.junit.Assert;
 import org.junit.Test;
 
+import jdk.graal.compiler.nodes.EndNode;
 import jdk.graal.compiler.nodes.extended.BoxNode;
 import jdk.graal.compiler.nodes.extended.UnboxNode;
 import jdk.graal.compiler.nodes.java.StoreFieldNode;
@@ -59,13 +60,16 @@ private static final class AllocatedObject {
         }
     }
 
+    public static int cnt;
     public static volatile Object obj1;
     public static volatile Double object1 = (double) 123;
     public static volatile AllocatedObject object2 = new AllocatedObject(123);
 
     public static String moveIntoBranchBox(int id) {
         Double box = object1 + 1;
         if (id == 0) {
+            // Prevent if simplification
+            cnt++;
             obj1 = new AtomicReference<>(box);
         }
         return "value";
@@ -82,7 +86,7 @@ public static String moveIntoBranch(int id) {
     @Test
     public void testJMHBlackholePattern() {
         /*
-         * The overall number of allocations in this methods does not change during PEA, but the
+         * The overall number of allocations in these methods does not change during PEA, but the
          * effects still need to be applied since they move the allocation between blocks.
          */
 
@@ -91,7 +95,7 @@ public void testJMHBlackholePattern() {
         Assert.assertEquals(1, graph.getNodes().filter(UnboxNode.class).count());
         Assert.assertEquals(1, graph.getNodes().filter(BoxNode.class).count());
         // the boxing needs to be moved into the branch
-        Assert.assertTrue(graph.getNodes().filter(BoxNode.class).first().next() instanceof StoreFieldNode);
+        Assert.assertTrue(graph.getNodes().filter(BoxNode.class).first().next() instanceof CommitAllocationNode);
 
         // test with a normal object
         prepareGraph("moveIntoBranch", false);
@@ -133,23 +137,24 @@ public static String noLoopIterationEmpty(int id) {
     @Test
     public void testNoLoopIteration() {
         /*
-         * PEA should not apply any effects on this method, since it cannot move the allocation into
-         * the branch anyway (it needs to stay outside the loop).
+         * After PEA, the BoxNode stays outside the loop.
          */
 
         // test with a boxing object
         prepareGraph("noLoopIterationBox", true);
+        List<BoxNode> boxNodes = graph.getNodes().filter(BoxNode.class).snapshot();
         Assert.assertEquals(1, boxNodes.size());
-        Assert.assertTrue(boxNodes.get(0).isAlive());
+        Assert.assertTrue(boxNodes.getFirst().next() instanceof EndNode);
 
         // test with a normal object (needs one iteration to replace NewInstance with
         // CommitAllocation)
         for (String name : new String[]{"noLoopIterationEmpty", "noLoopIteration"}) {
             prepareGraph(name, false);
             List<CommitAllocationNode> allocations = graph.getNodes().filter(CommitAllocationNode.class).snapshot();
             new PartialEscapePhase(true, false, createCanonicalizerPhase(), null, graph.getOptions()).apply(graph, context);
-            Assert.assertEquals(1, allocations.size());
+            Assert.assertEquals(2, allocations.size());
             Assert.assertTrue(allocations.get(0).isAlive());
+            Assert.assertTrue(allocations.get(1).isAlive());
         }
     }