1 /* 2 * Copyright (c) 2007, 2018, 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 /* 25 * @test 26 * @key stress gc 27 * 28 * @summary converted from VM Testbase gc/gctests/WeakReference/weak006. 29 * VM Testbase keywords: [gc, stress, stressopt, nonconcurrent] 30 * 31 * @library /vmTestbase 32 * /test/lib 33 * @run driver jdk.test.lib.FileInstaller . . 34 * @run main/othervm -XX:-UseGCOverheadLimit gc.gctests.WeakReference.weak006.weak006 -t 1 35 */ 36 37 package gc.gctests.WeakReference.weak006; 38 39 import nsk.share.test.*; 40 import nsk.share.gc.*; 41 import nsk.share.TestFailure; 42 import java.lang.ref.WeakReference; 43 import java.lang.ref.SoftReference; 44 import java.lang.ref.PhantomReference; 45 import java.lang.ref.Reference; 46 47 /** 48 * Test that GC correctly clears references. 49 * 50 * This test randomly creates a number of weak, soft, 51 * phantom and strong references, each of which points 52 * to the next, then provokes GC with Algorithms.eatMemory(). 53 * The test succedes if last reference has been cleared. 54 */ 55 public class weak006 extends ThreadedGCTest { 56 57 class Worker implements Runnable { 58 59 private int length; 60 private int objectSize = 100; 61 private Object[] references; 62 private Reference lastReference; 63 64 private Object makeReference(int n, Object o) { 65 switch (n) { 66 case 0: 67 return new WeakReference(o); 68 case 1: 69 return new SoftReference(o); 70 case 2: 71 return new PhantomReference(o, null); 72 case 4: { 73 // Array of strong references 74 int len = Memory.getArrayLength(objectSize, Memory.getReferenceSize()); 75 Object[] arr = new Object[len]; 76 for (int i = 0; i < len; ++i) { 77 arr[i] = o; 78 } 79 return arr; 80 } 81 case 5: { 82 // reference to array of strong references and strong reference to reference 83 int len = Memory.getArrayLength(objectSize, Memory.getReferenceSize()); 84 Object[] arr = new Object[len]; 85 for (int i = 1; i < len; ++i) { 86 arr[i] = o; 87 } 88 Reference ref = (Reference) makeReference(LocalRandom.nextInt(3), arr); 89 if (len > 0) { 90 arr[0] = ref; 91 } 92 return ref; 93 } 94 case 3: 95 default: 96 // Strong reference 97 return o; 98 } 99 } 100 101 private void clear() { 102 lastReference = null; 103 references[length - 1] = null; 104 } 105 106 private void makeReferences(int n) { 107 clear(); 108 MemoryObject obj = new MemoryObject(objectSize); 109 references[0] = new WeakReference(obj); 110 for (int i = 1; i < length; ++i) { 111 if (i != length - 1) { 112 references[i] = makeReference(LocalRandom.nextInt(2), references[i - 1]); 113 } else { 114 lastReference = (Reference) makeReference(n, references[i - 1]); 115 references[i] = lastReference; 116 } 117 } 118 for (int i = 0; i < length; ++i) { 119 references[i] = null; 120 } 121 } 122 123 public void run() { 124 makeReferences(0); 125 ExecutionController stresser = getExecutionController(); 126 Algorithms.eatMemory(stresser); 127 if (!stresser.continueExecution()) { 128 return; 129 } 130 if (lastReference.get() != null) { 131 references = null; 132 throw new TestFailure("Last weak reference has not been cleared"); 133 } 134 makeReferences(1); 135 Algorithms.eatMemory(stresser); 136 if (!stresser.continueExecution()) { 137 return; 138 } 139 if (lastReference.get() != null) { 140 references = null; 141 throw new TestFailure("Last soft reference has not been cleared"); 142 } 143 } 144 145 public Worker() { 146 length = Memory.getArrayLength(runParams.getTestMemory() - objectSize, Memory.getReferenceSize() + objectSize); 147 System.out.println("Array size: " + length); 148 references = new Object[length]; 149 } 150 } 151 152 @Override 153 protected Runnable createRunnable(int i) { 154 return new Worker(); 155 } 156 157 public static void main(String[] args) { 158 GC.runTest(new weak006(), args); 159 } 160 }