1 /*
  2  * Copyright (c) 2020, 2023, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 13  * accompanied this code).
 14  *
 15  * You should have received a copy of the GNU General Public License version
 16  * 2 along with this work; if not, write to the Free Software Foundation,
 17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 18  *
 19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 20  * or visit www.oracle.com if you need additional information or have any
 21  * questions.
 22  */
 23 
 24 package gc.shenandoah;
 25 
 26 /* @test id=satb
 27  * @requires vm.gc.Shenandoah
 28  * @library /test/lib
 29  * @build jdk.test.whitebox.WhiteBox
 30  * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
 31  * @run main/othervm
 32  *      -Xbootclasspath/a:.
 33  *      -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
 34  *      -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC -XX:ShenandoahGCMode=satb
 35  *      gc.shenandoah.TestReferenceRefersToShenandoah
 36  */
 37 
 38 /* @test id=satb-100
 39  * @requires vm.gc.Shenandoah
 40  * @library /test/lib
 41  * @build jdk.test.whitebox.WhiteBox
 42  * @modules java.base
 43  * @run main jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
 44  * @run main/othervm
 45  *      -Xbootclasspath/a:.
 46  *      -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
 47  *      -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC -XX:ShenandoahGCMode=satb -XX:ShenandoahGarbageThreshold=100 -Xmx100m
 48  *      gc.shenandoah.TestReferenceRefersToShenandoah
 49  */
 50 
 51 /* @test id=generational
 52  * @requires vm.gc.Shenandoah
 53  * @library /test/lib
 54  * @build jdk.test.whitebox.WhiteBox
 55  * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
 56  * @run main/othervm
 57  *      -Xbootclasspath/a:.
 58  *      -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
 59  *      -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC -XX:ShenandoahGCMode=generational
 60  *      gc.shenandoah.TestReferenceRefersToShenandoah
 61  */
 62 
 63 /* @test id=generational-100
 64  * @requires vm.gc.Shenandoah
 65  * @library /test/lib
 66  * @build jdk.test.whitebox.WhiteBox
 67  * @modules java.base
 68  * @run main jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
 69  * @run main/othervm
 70  *      -Xbootclasspath/a:.
 71  *      -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
 72  *      -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC -XX:ShenandoahGCMode=generational -XX:ShenandoahGarbageThreshold=100 -Xmx100m
 73  *      gc.shenandoah.TestReferenceRefersToShenandoah
 74  */
 75 
 76 /* @test id=iu
 77  * @requires vm.gc.Shenandoah
 78  * @library /test/lib
 79  * @build jdk.test.whitebox.WhiteBox
 80  * @run driver jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
 81  * @run main/othervm
 82  *      -Xbootclasspath/a:.
 83  *      -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
 84  *      -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC -XX:ShenandoahGCMode=iu
 85  *      gc.shenandoah.TestReferenceRefersToShenandoah
 86  */
 87 
 88 /* @test id=iu-100
 89  * @requires vm.gc.Shenandoah
 90  * @library /test/lib
 91  * @build jdk.test.whitebox.WhiteBox
 92  * @modules java.base
 93  * @run main jdk.test.lib.helpers.ClassFileInstaller jdk.test.whitebox.WhiteBox
 94  * @run main/othervm
 95  *      -Xbootclasspath/a:.
 96  *      -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI
 97  *      -XX:+UnlockExperimentalVMOptions -XX:+UseShenandoahGC -XX:ShenandoahGCMode=iu -XX:ShenandoahGarbageThreshold=100 -Xmx100m
 98  *      gc.shenandoah.TestReferenceRefersToShenandoah
 99  */
100 
101 import java.lang.ref.PhantomReference;
102 import java.lang.ref.Reference;
103 import java.lang.ref.ReferenceQueue;
104 import java.lang.ref.WeakReference;
105 import jdk.test.whitebox.WhiteBox;
106 
107 public class TestReferenceRefersToShenandoah {
108     private static final WhiteBox WB = WhiteBox.getWhiteBox();
109 
110     private static final class TestObject {
111         public final int value;
112 
113         public TestObject(int value) {
114             this.value = value;
115         }
116     }
117 
118     private static volatile TestObject testObjectNone = null;
119     private static volatile TestObject testObject1 = null;
120     private static volatile TestObject testObject2 = null;
121     private static volatile TestObject testObject3 = null;
122     private static volatile TestObject testObject4 = null;
123 
124     private static ReferenceQueue<TestObject> queue = null;
125 
126     private static PhantomReference<TestObject> testPhantom1 = null;
127 
128     private static WeakReference<TestObject> testWeak2 = null;
129     private static WeakReference<TestObject> testWeak3 = null;
130     private static WeakReference<TestObject> testWeak4 = null;
131 
132     private static void setup() {
133         testObjectNone = new TestObject(0);
134         testObject1 = new TestObject(1);
135         testObject2 = new TestObject(2);
136         testObject3 = new TestObject(3);
137         testObject4 = new TestObject(4);
138 
139         queue = new ReferenceQueue<TestObject>();
140 
141         testPhantom1 = new PhantomReference<TestObject>(testObject1, queue);
142 
143         testWeak2 = new WeakReference<TestObject>(testObject2, queue);
144         testWeak3 = new WeakReference<TestObject>(testObject3, queue);
145         testWeak4 = new WeakReference<TestObject>(testObject4, queue);
146     }
147 
148     private static void gcUntilOld(Object o) throws Exception {
149         if (!WB.isObjectInOldGen(o)) {
150             WB.fullGC();
151             if (!WB.isObjectInOldGen(o)) {
152                 // This is just a warning, because failing would
153                 // be overspecifying for generational shenandoah,
154                 // which need not necessarily promote objects upon
155                 // a full GC.
156                 warn("object not promoted by full gc");
157             }
158         }
159     }
160 
161     private static void gcUntilOld() throws Exception {
162         gcUntilOld(testObjectNone);
163         gcUntilOld(testObject1);
164         gcUntilOld(testObject2);
165         gcUntilOld(testObject3);
166         gcUntilOld(testObject4);
167 
168         gcUntilOld(testPhantom1);
169 
170         gcUntilOld(testWeak2);
171         gcUntilOld(testWeak3);
172         gcUntilOld(testWeak4);
173     }
174 
175     private static void progress(String msg) {
176         System.out.println(msg);
177     }
178 
179     private static void fail(String msg) throws Exception {
180         throw new RuntimeException(msg);
181     }
182 
183     private static void warn(String msg) {
184         System.out.println("Warning: " + msg);
185     }
186 
187     private static void expectCleared(Reference<TestObject> ref,
188                                       String which) throws Exception {
189         expectNotValue(ref, testObjectNone, which);
190         if (!ref.refersTo(null)) {
191             fail("expected " + which + " to be cleared");
192         }
193     }
194 
195     private static void expectNotCleared(Reference<TestObject> ref,
196                                          String which) throws Exception {
197         expectNotValue(ref, testObjectNone, which);
198         if (ref.refersTo(null)) {
199             fail("expected " + which + " to not be cleared");
200         }
201     }
202 
203     private static void expectValue(Reference<TestObject> ref,
204                                     TestObject value,
205                                     String which) throws Exception {
206         expectNotValue(ref, testObjectNone, which);
207         expectNotCleared(ref, which);
208         if (!ref.refersTo(value)) {
209             fail(which + " doesn't refer to expected value");
210         }
211     }
212 
213     private static void expectNotValue(Reference<TestObject> ref,
214                                        TestObject value,
215                                        String which) throws Exception {
216         if (ref.refersTo(value)) {
217             fail(which + " refers to unexpected value");
218         }
219     }
220 
221     private static void checkInitialStates() throws Exception {
222         expectValue(testPhantom1, testObject1, "testPhantom1");
223         expectValue(testWeak2, testObject2, "testWeak2");
224         expectValue(testWeak3, testObject3, "testWeak3");
225         expectValue(testWeak4, testObject4, "testWeak4");
226     }
227 
228     private static void discardStrongReferences() {
229         // testObjectNone not dropped
230         testObject1 = null;
231         testObject2 = null;
232         // testObject3 not dropped
233         testObject4 = null;
234     }
235 
236     private static boolean isShenandoahIUMode() {
237         return "iu".equals(WB.getStringVMFlag("ShenandoahGCMode"));
238     }
239 
240     private static void testConcurrentCollection() throws Exception {
241         progress("setup concurrent collection test");
242         setup();
243         progress("gcUntilOld");
244         gcUntilOld();
245 
246         progress("acquire control of concurrent cycles");
247         WB.concurrentGCAcquireControl();
248         try {
249             progress("check initial states");
250             checkInitialStates();
251 
252             progress("discard strong references");
253             discardStrongReferences();
254 
255             progress("run GC to before marking completed");
256             WB.concurrentGCRunTo(WB.BEFORE_MARKING_COMPLETED);
257 
258             progress("fetch test objects, possibly keeping some alive");
259             expectNotCleared(testPhantom1, "testPhantom1");
260             expectNotCleared(testWeak2, "testWeak2");
261             expectValue(testWeak3, testObject3, "testWeak3");
262 
263             // For some collectors, calling get() will keep testObject4 alive.
264             if (testWeak4.get() == null) {
265                 fail("testWeak4 unexpectedly == null");
266             }
267 
268             progress("finish collection");
269             WB.concurrentGCRunToIdle();
270 
271             progress("verify expected clears");
272             expectCleared(testPhantom1, "testPhantom1");
273             expectCleared(testWeak2, "testWeak2");
274             expectValue(testWeak3, testObject3, "testWeak3");
275             // This is true for all currently supported concurrent collectors,
276             // except Shenandoah+IU, which allows clearing refs even when
277             // accessed during concurrent marking.
278             if (isShenandoahIUMode()) {
279               expectCleared(testWeak4, "testWeak4");
280             } else {
281               expectNotCleared(testWeak4, "testWeak4");
282             }
283 
284             progress("verify get returns expected values");
285             if (testWeak2.get() != null) {
286                 fail("testWeak2.get() != null");
287             }
288 
289             TestObject obj3 = testWeak3.get();
290             if (obj3 == null) {
291                 fail("testWeak3.get() returned null");
292             } else if (obj3.value != 3) {
293                 fail("testWeak3.get().value is " + obj3.value);
294             }
295 
296             TestObject obj4 = testWeak4.get();
297             if (!isShenandoahIUMode()) {
298                 if (obj4 == null) {
299                     fail("testWeak4.get() returned null");
300                 } else if (obj4.value != 4) {
301                     fail("testWeak4.get().value is " + obj4.value);
302                 }
303             }
304 
305             progress("verify queue entries");
306             long timeout = 60000; // 1 minute of milliseconds.
307             while (true) {
308                 Reference<? extends TestObject> ref = queue.remove(timeout);
309                 if (ref == null) {
310                     break;
311                 } else if (ref == testPhantom1) {
312                     testPhantom1 = null;
313                 } else if (ref == testWeak2) {
314                     testWeak2 = null;
315                 } else if (ref == testWeak3) {
316                     testWeak3 = null;
317                 } else if (ref == testWeak4) {
318                     testWeak4 = null;
319                 } else {
320                     fail("unexpected reference in queue");
321                 }
322             }
323             if (testPhantom1 != null) {
324                 fail("testPhantom1 not notified");
325             } else if (testWeak2 != null) {
326                 fail("testWeak2 not notified");
327             } else if (testWeak3 == null) {
328                 fail("testWeak3 notified");
329             } else if (testWeak4 == null) {
330                 if (obj4 != null) {
331                     fail("testWeak4 notified");
332                 }
333             }
334 
335         } finally {
336             progress("release control of concurrent cycles");
337             WB.concurrentGCReleaseControl();
338         }
339         progress("finished concurrent collection test");
340     }
341 
342     private static void testSimpleCollection() throws Exception {
343         progress("setup simple collection test");
344         setup();
345         progress("gcUntilOld");
346         gcUntilOld();
347 
348         progress("check initial states");
349         checkInitialStates();
350 
351         progress("discard strong references");
352         TestObject tw4 = testWeak4.get(); // Keep testObject4 alive.
353         discardStrongReferences();
354 
355         progress("collect garbage");
356         WB.fullGC();
357 
358         progress("verify expected clears");
359         expectCleared(testPhantom1, "testPhantom1");
360         expectCleared(testWeak2, "testWeak2");
361         expectValue(testWeak3, testObject3, "testWeak3");
362         expectNotCleared(testWeak4, "testWeak4");
363 
364         progress("verify get returns expected values");
365         if (testWeak2.get() != null) {
366             fail("testWeak2.get() != null");
367         } else if (testWeak3.get() != testObject3) {
368             fail("testWeak3.get() is not expected value");
369         } else if (testWeak4.get() != tw4) {
370             fail("testWeak4.get() is not expected value");
371         }
372 
373         progress("finished simple collection test");
374     }
375 
376     public static void main(String[] args) throws Exception {
377         if (WB.supportsConcurrentGCBreakpoints()) {
378             testConcurrentCollection();
379         }
380         testSimpleCollection();
381     }
382 }
--- EOF ---