473 lines
17 KiB
Java
473 lines
17 KiB
Java
/*
|
|
* Copyright (c) 2005, 2023, 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;
|
|
}
|
|
if (name.equals("java.lang.reflect.Method")) {
|
|
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++);
|
|
}
|
|
}
|
|
}
|