test/java/lang/invoke/LFCaching/LFGarbageCollectedTest.java

*** 25,52 ****
   * @test LFGarbageCollectedTest
   * @bug 8046703
   * @summary Test verifies that lambda forms are garbage collected
   * @author kshefov
   * @library /lib/testlibrary/jsr292 /lib/testlibrary
-  * @ignore 8057020
   * @build TestMethods
   * @build LambdaFormTestCase
   * @build LFGarbageCollectedTest
!  * @run main/othervm LFGarbageCollectedTest
   */
  
  import java.lang.invoke.MethodHandle;
  import java.lang.ref.PhantomReference;
  import java.lang.ref.ReferenceQueue;
  import java.lang.reflect.InvocationTargetException;
  import java.util.EnumSet;
  import java.util.Map;
  
  /**
   * Lambda forms garbage collection test class.
   */
  public final class LFGarbageCollectedTest extends LambdaFormTestCase {
  
      /**
       * Constructor for a lambda forms garbage collection test case.
       *
       * @param testMethod A method from {@code j.l.i.MethodHandles} class that
--- 25,54 ----
   * @test LFGarbageCollectedTest
   * @bug 8046703
   * @summary Test verifies that lambda forms are garbage collected
   * @author kshefov
   * @library /lib/testlibrary/jsr292 /lib/testlibrary
   * @build TestMethods
   * @build LambdaFormTestCase
   * @build LFGarbageCollectedTest
!  * @run main/othervm -Xmx64m -XX:SoftRefLRUPolicyMSPerMB=0 -XX:+HeapDumpOnOutOfMemoryError -DHEAP_DUMP=false LFGarbageCollectedTest
   */
  
  import java.lang.invoke.MethodHandle;
+ import java.lang.invoke.MethodType;
  import java.lang.ref.PhantomReference;
+ import java.lang.ref.Reference;
  import java.lang.ref.ReferenceQueue;
  import java.lang.reflect.InvocationTargetException;
  import java.util.EnumSet;
  import java.util.Map;
  
  /**
   * Lambda forms garbage collection test class.
   */
  public final class LFGarbageCollectedTest extends LambdaFormTestCase {
+     private static boolean HEAP_DUMP = Boolean.getBoolean("HEAP_DUMP");
  
      /**
       * Constructor for a lambda forms garbage collection test case.
       *
       * @param testMethod A method from {@code j.l.i.MethodHandles} class that
*** 54,94 ****
       */
      public LFGarbageCollectedTest(TestMethods testMethod) {
          super(testMethod);
      }
  
      @Override
      public void doTest() {
          try {
!             Map<String, Object> data = getTestMethod().getTestCaseData();
              MethodHandle adapter;
              try {
!                 adapter = getTestMethod().getTestCaseMH(data, TestMethods.Kind.ONE);
              } catch (NoSuchMethodException ex) {
                  throw new Error("Unexpected exception: ", ex);
              }
!             Object lambdaForm = LambdaFormTestCase.INTERNAL_FORM.invoke(adapter);
              if (lambdaForm == null) {
                  throw new Error("Unexpected error: Lambda form of the method handle is null");
              }
!             ReferenceQueue rq = new ReferenceQueue();
!             PhantomReference ph = new PhantomReference(lambdaForm, rq);
              lambdaForm = null;
-             data = null;
              adapter = null;
!             for (int i = 0; i < 1000 && !ph.isEnqueued(); i++) {
!                 System.gc();
!             }
!             if (!ph.isEnqueued()) {
!                 throw new AssertionError("Error: Lambda form is not garbage collected");
!             }
          } catch (IllegalAccessException | IllegalArgumentException |
                  InvocationTargetException ex) {
              throw new Error("Unexpected exception: ", ex);
          }
      }
  
      /**
       * Main routine for lambda forms garbage collection test.
       *
       * @param args Accepts no arguments.
       */
--- 56,144 ----
       */
      public LFGarbageCollectedTest(TestMethods testMethod) {
          super(testMethod);
      }
  
+      PhantomReference ph;
+      ReferenceQueue rq = new ReferenceQueue();
+      MethodType mtype;
+      Map<String, Object> data;
+ 
      @Override
      public void doTest() {
          try {
!             TestMethods testCase = getTestMethod();
!             data = testCase.getTestCaseData();
              MethodHandle adapter;
              try {
!                 adapter = testCase.getTestCaseMH(data, TestMethods.Kind.ONE);
              } catch (NoSuchMethodException ex) {
                  throw new Error("Unexpected exception: ", ex);
              }
!             mtype = adapter.type();
!             Object lambdaForm = INTERNAL_FORM.invoke(adapter);
              if (lambdaForm == null) {
                  throw new Error("Unexpected error: Lambda form of the method handle is null");
              }
!             
!             String debugName = (String)DEBUG_NAME.get(lambdaForm);
!             if (debugName != null && debugName.startsWith("identity_")) {
!                 // Ignore identity_* LambdaForms.
!                 return;
!             }
! 
!             ph = new PhantomReference(lambdaForm, rq);
              lambdaForm = null;
              adapter = null;
! 
!             collectLambdaForm();
          } catch (IllegalAccessException | IllegalArgumentException |
                  InvocationTargetException ex) {
              throw new Error("Unexpected exception: ", ex);
          }
      }
      
+     private void collectLambdaForm() throws IllegalAccessException {
+        // Usually, 2 System.GCs are necessary to enqueue a SoftReference.
+         System.gc();
+         System.gc();
+ 
+         Reference ref = null;
+         for (int i = 0; i < 10; i++) {
+             try {
+                 ref = rq.remove(1000);
+             } catch (InterruptedException e) {
+                 /* ignore */
+             }
+             if (ref != null) {
+                 break;
+             }
+             System.gc(); // If the reference hasn't been queued yet, trigger one more GC.
+         }
+ 
+         if (ref == null) {
+             dumpTestData();
+             System.err.println("Method type: " + mtype);
+             System.err.println("LambdaForm:  " + REF_FIELD.get(ph));
+ 
+             if (HEAP_DUMP) {
+                 // Trigger OOM to force heap dump for post-mortem analysis.
+                 val = new long[1_000_000_000];
+             }
+             throw new AssertionError("Error: LambdaForm is not garbage collected");
+         };
+     }
+ 
+    private void dumpTestData() {
+         System.err.println("Test case: " + getTestMethod());
+         for (String s : data.keySet()) {
+             System.err.printf("\t%20s => %s\n", s, data.get(s));
+         }
+     }
+ 
+     private static long[] val;
+ 
      /**
       * Main routine for lambda forms garbage collection test.
       *
       * @param args Accepts no arguments.
       */
*** 100,108 ****
          // so no memory leak happens.
          EnumSet<TestMethods> testMethods = EnumSet.complementOf(EnumSet.of(
                  TestMethods.IDENTITY,
                  TestMethods.CONSTANT,
                  TestMethods.ARRAY_ELEMENT_GETTER,
!                 TestMethods.ARRAY_ELEMENT_SETTER));
          LambdaFormTestCase.runTests(LFGarbageCollectedTest::new, testMethods);
      }
  }
--- 150,160 ----
          // so no memory leak happens.
          EnumSet<TestMethods> testMethods = EnumSet.complementOf(EnumSet.of(
                  TestMethods.IDENTITY,
                  TestMethods.CONSTANT,
                  TestMethods.ARRAY_ELEMENT_GETTER,
!                 TestMethods.ARRAY_ELEMENT_SETTER,
!                 TestMethods.EXACT_INVOKER,
!                 TestMethods.INVOKER));
          LambdaFormTestCase.runTests(LFGarbageCollectedTest::new, testMethods);
      }
  }