| /* |
| * Copyright (c) 2005, 2015, 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 |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| /** |
| * @test |
| * @bug 5089849 |
| * @summary Add support for backtracking reference graph. |
| * @author jjh |
| * |
| * @run build TestScaffold VMConnection TargetListener TargetAdapter |
| * @run compile -g ReferrersTest.java |
| * @run driver ReferrersTest |
| */ |
| |
| /* |
| * To run this test do this: |
| * runregress -no ReferrersTest <cmd line options> |
| * |
| * where <cmd line options> are the options to be used to |
| * launch the debuggee, with the classname prefixed with @@. |
| * For example, this would run java2d demo as the debuggee: |
| * runregress -no ReferrersTest -classpath |
| * $jdkDir/demo/jfc/Java2D/Java2Demo.jar \ |
| * -client @@java2d.Java2Demo |
| * |
| * In this mode, the specified debuggee is launched in debug mode, |
| * and the debugger waits for a keystroke before connecting to the debuggee. |
| * |
| * If <cmd line options> is not specified, then the ReferrersTarg class below |
| * is run as the debuggee. |
| */ |
| import com.sun.jdi.*; |
| import com.sun.jdi.event.*; |
| import com.sun.jdi.request.*; |
| |
| import java.util.*; |
| |
| class ReferrersFiller { |
| // This many instances of this are created. |
| static int FILLER_COUNT = 20000; |
| static ReferrersFiller[] lotsAndLots = new ReferrersFiller[ |
| ReferrersFiller.FILLER_COUNT]; |
| int xx; |
| ReferrersFiller(int p1) { |
| xx = p1; |
| } |
| } |
| |
| class ReferrersTarg { |
| // This many instances + 1 of this class are created. |
| static int TARG_COUNT = 10; |
| static ReferrersTarg theReferrersTarg; |
| static ReferrersTarg[] allReferrersTargs; |
| |
| // Each instance will point to the theReferrersTarg |
| ReferrersTarg oneReferrersTarg; |
| |
| public static void bkpt() { |
| } |
| |
| public static void main(String[] args) { |
| System.out.println("Howdy!"); |
| for (int ii = 0; ii < ReferrersFiller.lotsAndLots.length; ii++) { |
| ReferrersFiller.lotsAndLots[ii] = new ReferrersFiller(ii); |
| } |
| |
| theReferrersTarg = new ReferrersTarg(); |
| allReferrersTargs = new ReferrersTarg[ReferrersTarg.TARG_COUNT]; |
| for (int ii = 0; ii < ReferrersTarg.TARG_COUNT; ii++) { |
| allReferrersTargs[ii] = new ReferrersTarg(); |
| allReferrersTargs[ii].oneReferrersTarg = theReferrersTarg; |
| } |
| bkpt(); |
| |
| System.out.println("Goodbye from ReferrersTarg!"); |
| } |
| } |
| |
| /********** test program **********/ |
| |
| public class ReferrersTest extends TestScaffold { |
| static String targetName = "ReferrersTarg"; |
| ReferenceType targetClass; |
| ThreadReference mainThread; |
| |
| ReferrersTest(String args[]) { |
| super(args); |
| } |
| |
| public static void main(String[] args) throws Exception { |
| /* |
| * If args contains @@xxxx, then that is the |
| * name of the class we are to run. |
| */ |
| for (int ii = 0; ii < args.length; ii ++) { |
| if (args[ii].startsWith("@@")) { |
| targetName = args[ii] = args[ii].substring(2); |
| break; |
| } |
| } |
| new ReferrersTest(args).startTests(); |
| } |
| |
| /* |
| * Used to sort a list of ReferenceTypes by |
| * instance count. |
| */ |
| class ToSort implements Comparable<ToSort> { |
| long count; |
| ReferenceType rt; |
| |
| public ToSort(long count, ReferenceType rt) { |
| this.count = count; |
| this.rt = rt; |
| } |
| |
| public int compareTo(ToSort obj) { |
| if (count < obj.count) return -1; |
| if (count == obj.count) return 0; |
| return 1; |
| } |
| } |
| |
| protected void runTests() throws Exception { |
| /* |
| * Get to the top of main() |
| * to determine targetClass and mainThread |
| */ |
| int CUT_OFF = 1000; |
| BreakpointEvent bpe; |
| bpe = startToMain(targetName); |
| targetClass = bpe.location().declaringType(); |
| mainThread = bpe.thread(); |
| |
| if (targetName.equals("ReferrersTarg")) { |
| resumeTo("ReferrersTarg", "bkpt", "()V"); |
| } else { |
| // Let debuggee run for awhile to get classes loaded |
| vm().resume(); |
| try { |
| System.err.println("Press <enter> to continue"); |
| System.in.read(); |
| System.err.println("running..."); |
| |
| } catch(Exception e) { |
| } |
| vm().suspend(); |
| } |
| |
| // Get all classes. |
| long start = System.currentTimeMillis(); |
| List<ReferenceType> allClasses = vm().allClasses(); |
| long end = System.currentTimeMillis(); |
| System.out.println( allClasses.size() + |
| " classes from vm.allClasses() took " + |
| (end - start) + " ms"); |
| |
| long[] counts; |
| |
| // Test for NPE |
| { |
| boolean pass = false; |
| try { |
| counts = vm().instanceCounts(null); |
| } catch (NullPointerException ee) { |
| pass = true; |
| } |
| if (!pass) { |
| failure("failure: NullPointerException not thrown on instanceCounts(null)"); |
| } |
| } |
| |
| // Test for 0 length array |
| { |
| List<ReferenceType>someClasses = new ArrayList(2); |
| counts = vm().instanceCounts(someClasses); |
| if (counts.length != 0) { |
| failure("failure: instanceCounts with a zero length array fails: " + |
| counts.length); |
| } |
| } |
| |
| // Test various values of maxInstances |
| if (targetClass.name().equals("ReferrersTarg")) { |
| List<ObjectReference> noInstances = targetClass.instances(0); |
| if (noInstances.size() != ReferrersTarg.TARG_COUNT + 1) { |
| failure("failure: instances(0): " + noInstances.size() + ", for " + targetClass); |
| } |
| noInstances = targetClass.instances(1); |
| if (noInstances.size() != 1) { |
| failure("failure: instances(1): " + noInstances.size() + ", for " + targetClass); |
| } |
| boolean pass = false; |
| try { |
| noInstances = targetClass.instances(-1); |
| } catch (IllegalArgumentException ee) { |
| pass = true; |
| } |
| if (!pass) { |
| failure("failure: instances(-1) did not get an exception"); |
| } |
| } |
| |
| // Instance counts for all classes |
| start = System.currentTimeMillis(); |
| counts = vm().instanceCounts(allClasses); |
| end = System.currentTimeMillis(); |
| |
| if (counts.length == 0) { |
| System.out.println("failure: No instances found"); |
| throw new Exception("ReferrersTest: failed"); |
| } |
| |
| // Create a list of ReferenceTypes sorted by instance count |
| int size = 0; |
| List<ToSort> sorted = new ArrayList(allClasses.size()); |
| for (int ii = 0; ii < allClasses.size(); ii++) { |
| size += counts[ii]; |
| ToSort tos = new ToSort(counts[ii], allClasses.get(ii)); |
| sorted.add(tos); |
| } |
| |
| System.out.println("instance counts for " + counts.length + |
| " classes got " + size + " instances and took " + |
| (end - start) + " ms"); |
| |
| |
| boolean gotReferrersFiller = false; |
| boolean gotReferrersTarg = false; |
| |
| Collections.sort(sorted); |
| for (int ii = sorted.size() - 1; ii >= 0 ; ii--) { |
| ToSort xxx = sorted.get(ii); |
| |
| if (xxx.rt.name().equals("ReferrersFiller") && |
| xxx.count == ReferrersFiller.FILLER_COUNT) { |
| gotReferrersFiller = true; |
| } |
| if (xxx.rt.name().equals("ReferrersTarg") && |
| xxx.count == ReferrersTarg.TARG_COUNT + 1) { |
| gotReferrersTarg = true; |
| } |
| } |
| if (!gotReferrersFiller) { |
| failure("failure: Expected " + ReferrersFiller.FILLER_COUNT + |
| " instances of ReferrersFiller"); |
| } |
| if (!gotReferrersTarg) { |
| failure("failure: Expected " + (ReferrersTarg.TARG_COUNT + 1) + |
| " instances of ReferrersTarg"); |
| } |
| |
| List<List<ObjectReference>> allInstances = new ArrayList(10); |
| |
| // Instances, one class at a time, in sorted order, printing each line |
| if (true) { |
| System.out.println("\nGetting instances for one class " + |
| "at a time (limited) in sorted order"); |
| List<ReferenceType> rtList = new ArrayList(1); |
| rtList.add(null); |
| long start1 = System.currentTimeMillis(); |
| size = 0; |
| long count = 0; |
| for (int ii = sorted.size() - 1; ii >= 0 ; ii--) { |
| ToSort xxx = sorted.get(ii); |
| if (xxx.count <= CUT_OFF) { |
| break; |
| } |
| rtList.set(0, xxx.rt); |
| start = System.currentTimeMillis(); |
| List<ObjectReference> oneInstances = xxx.rt.instances(19999999); |
| end = System.currentTimeMillis(); |
| size += oneInstances.size(); |
| count++; |
| System.out.println("Expected " + xxx.count + " instances, got " + |
| oneInstances.size() + |
| " instances for " + sorted.get(ii).rt + |
| " in " + (end - start) + " ms"); |
| |
| if (xxx.rt.name().equals("ReferrersFiller") && |
| oneInstances.size() != ReferrersFiller.FILLER_COUNT) { |
| failure("failure: Expected " + ReferrersFiller.FILLER_COUNT + |
| " instances of ReferrersFiller"); |
| } |
| if (xxx.rt.name().equals("ReferrersTarg") && |
| oneInstances.size() != ReferrersTarg.TARG_COUNT + 1) { |
| failure("failure: Expected " + (ReferrersTarg.TARG_COUNT + 1) + |
| " instances of ReferrersTarg"); |
| } |
| allInstances.add(oneInstances); |
| } |
| |
| end = System.currentTimeMillis(); |
| |
| System.out.println(size + " instances via making one vm.instances" + |
| " call for each of " + count + |
| " classes took " + (end - start1) + " ms"); |
| System.out.println("Per class = " + |
| (end - start) / allClasses.size() + " ms"); |
| } |
| |
| |
| // referrers |
| |
| // Test various values of maxReferrers |
| if (targetClass.name().equals("ReferrersTarg")) { |
| Field field1 = targetClass.fieldByName("theReferrersTarg"); |
| ObjectReference anInstance = (ObjectReference)targetClass.getValue(field1); |
| List<ObjectReference> noReferrers = anInstance.referringObjects(0); |
| if (noReferrers.size() != ReferrersTarg.TARG_COUNT + 1 ) { |
| failure("failure: referringObjects(0) got " + noReferrers.size() + |
| ", for " + anInstance); |
| } |
| noReferrers = anInstance.referringObjects(1); |
| if (noReferrers.size() != 1 ) { |
| failure("failure: referringObjects(1) got " + noReferrers.size() + |
| ", for " + anInstance); |
| } |
| boolean pass = false; |
| try { |
| noReferrers = anInstance.referringObjects(-1); |
| } catch (IllegalArgumentException ee) { |
| pass = true; |
| } |
| if (!pass) { |
| failure("failure: referringObjects(-1) did not get an exception"); |
| } |
| } |
| |
| List<ObjectReference> allReferrers = null; |
| List<ObjectReference> someInstances = new ArrayList(); |
| if (targetName.equals("ReferrersTarg")) { |
| Field field1 = targetClass.fieldByName("theReferrersTarg"); |
| ObjectReference val = (ObjectReference)targetClass.getValue(field1); |
| someInstances.add(val); |
| allReferrers = val.referringObjects(99999); //LIMIT |
| if (allReferrers.size() != ReferrersTarg.TARG_COUNT + 1) { |
| failure("failure: expected " + (ReferrersTarg.TARG_COUNT + 1) + |
| "referrers, but got " + allReferrers.size() + |
| " referrers for " + val); |
| } |
| } else { |
| // referrers |
| // Create someInstances to find the referrers of. |
| for (int ii = 0; ii < allClasses.size(); ii++) { |
| List<ObjectReference> objRefList = allInstances.get(ii); |
| if (objRefList != null) { |
| int asize = objRefList.size(); |
| if (false) { |
| System.out.println(asize + ", " + allClasses.get(ii)); |
| } |
| // Remember one instance per class to get referrers |
| if (asize > 0) { |
| someInstances.add(objRefList.get(0)); |
| } |
| } |
| } |
| } |
| |
| for (ObjectReference objRef: someInstances) { |
| //System.out.println( "Getting referrers for " + objRef); |
| start = System.currentTimeMillis(); |
| if ( true) { |
| showReferrers(objRef, 0, 0, 0); |
| } else { |
| allReferrers = objRef.referringObjects(99999); //LIMIT |
| end = System.currentTimeMillis(); |
| if (true || allReferrers.size() > 1) { |
| System.out.println( allReferrers.size() + " referrers for " + objRef + " took " + (end - start) + " ms"); |
| } |
| } |
| } |
| |
| /* |
| * deal with results of test |
| * if anything has called failure("foo") testFailed will be true |
| */ |
| if (!testFailed) { |
| println("ReferrersTest: passed"); |
| } else { |
| throw new Exception("ReferrersTest: failed"); |
| } |
| } |
| void indent(int level) { |
| for (int ii = 0; ii < level; ii++) { |
| System.out.print(" "); |
| } |
| } |
| |
| |
| Map<ObjectReference, Object> visited = new HashMap(100); |
| void showReferrers(ObjectReference objRef, int level, int total, int which) { |
| |
| if (level == 0) { |
| visited.clear(); |
| } else { |
| if (visited.containsKey(objRef)) { |
| indent(level); |
| System.out.println("(" + which + ")" + ":<pruned> " + objRef); |
| return; |
| } |
| visited.put(objRef, null); |
| indent(level); |
| //System.out.println(which + "/" + total + ": " + objRef + " took " + time + " ms"); |
| } |
| |
| List<ObjectReference> allReferrers = null; |
| |
| //System.out.println( "Getting referrers for " + objRef); |
| long start, end; |
| start = System.currentTimeMillis(); |
| allReferrers = objRef.referringObjects(99999); //LIMIT |
| end = System.currentTimeMillis(); |
| |
| if (which == 0) { |
| System.out.println(allReferrers.size() + " referrers for " + objRef + " took " + (end - start) + " ms"); |
| } else { |
| System.out.println("(" + which + ") " + objRef); |
| indent(level); |
| System.out.println(" " + allReferrers.size() + " referrers for " + objRef + " took " + (end - start) + " ms"); |
| } |
| |
| // We have to stop going up a referrer chain in some cases |
| Type rt = objRef.type(); |
| if (rt instanceof ClassType) { |
| ClassType ct = (ClassType)rt; |
| String name = ct.name(); |
| if (name.equals("sun.awt.SoftCache$ValueCell")) { |
| return; |
| } |
| if (name.equals("java.lang.ref.Finalizer")) { |
| return; |
| } |
| if (name.equals("java.lang.ref.SoftReference")) { |
| return; |
| } |
| // oh oh, should really check for a subclass of ClassLoader :-) |
| if (name.indexOf("ClassLoader") >= 0) { |
| return; |
| } |
| // No doubt there are other reasons to stop ... |
| } |
| int itemNumber = 1; |
| int allSize = allReferrers.size(); |
| for (ObjectReference objx: allReferrers) { |
| showReferrers(objx, level + 1, allSize, itemNumber++); |
| } |
| } |
| } |