1 /*
  2  * Copyright (c) 2005, 2015, 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  * @bug 5089849
 27  * @summary Add support for backtracking reference graph.
 28  * @author jjh
 29  *
 30  * @run build TestScaffold VMConnection TargetListener TargetAdapter
 31  * @run compile -g ReferrersTest.java
 32  * @run driver ReferrersTest
 33  */
 34 
 35 /*
 36  *  To run this test do this:
 37  *     runregress -no ReferrersTest <cmd line options>
 38  *
 39  *  where <cmd line options> are the options to be used to
 40  *  launch the debuggee, with the classname prefixed with @@.
 41  *  For example, this would run java2d demo as the debuggee:
 42  *     runregress -no ReferrersTest -classpath
 43  *                                    $jdkDir/demo/jfc/Java2D/Java2Demo.jar \
 44  *                                    -client @@java2d.Java2Demo
 45  *
 46  * In this mode, the specified debuggee is launched in debug mode,
 47  * and the debugger waits for a keystroke before connecting to the debuggee.
 48  *
 49  * If <cmd line options> is not specified, then the ReferrersTarg class below
 50  * is run as the debuggee.
 51  */
 52 import com.sun.jdi.*;
 53 import com.sun.jdi.event.*;
 54 import com.sun.jdi.request.*;
 55 
 56 import java.util.*;
 57 
 58 class ReferrersFiller {
 59     // This many instances of this are created.
 60     static int FILLER_COUNT = 20000;
 61     static ReferrersFiller[] lotsAndLots = new ReferrersFiller[
 62                                                ReferrersFiller.FILLER_COUNT];
 63     int xx;
 64     ReferrersFiller(int p1) {
 65         xx = p1;
 66     }
 67 }
 68 
 69 class ReferrersTarg {
 70     // This many instances + 1 of this class are created.
 71     static int TARG_COUNT = 10;
 72     static ReferrersTarg theReferrersTarg;
 73     static ReferrersTarg[] allReferrersTargs;
 74 
 75     // Each instance will point to the theReferrersTarg
 76     ReferrersTarg oneReferrersTarg;
 77 
 78     public static void bkpt() {
 79     }
 80 
 81     public static void main(String[] args) {
 82         System.out.println("Howdy!");
 83         for (int ii = 0; ii < ReferrersFiller.lotsAndLots.length; ii++) {
 84             ReferrersFiller.lotsAndLots[ii] = new ReferrersFiller(ii);
 85         }
 86 
 87         theReferrersTarg = new ReferrersTarg();
 88         allReferrersTargs = new ReferrersTarg[ReferrersTarg.TARG_COUNT];
 89         for (int ii = 0; ii < ReferrersTarg.TARG_COUNT; ii++) {
 90             allReferrersTargs[ii] = new ReferrersTarg();
 91             allReferrersTargs[ii].oneReferrersTarg = theReferrersTarg;
 92         }
 93         bkpt();
 94 
 95         System.out.println("Goodbye from ReferrersTarg!");
 96     }
 97 }
 98 
 99 /********** test program **********/
100 
101 public class ReferrersTest extends TestScaffold {
102     static String targetName = "ReferrersTarg";
103     ReferenceType targetClass;
104     ThreadReference mainThread;
105 
106     ReferrersTest(String args[]) {
107         super(args);
108     }
109 
110     public static void main(String[] args) throws Exception {
111         /*
112          * If args contains @@xxxx, then that is the
113          * name of the class we are to run.
114          */
115         for (int ii = 0; ii < args.length; ii ++) {
116             if (args[ii].startsWith("@@")) {
117                 targetName = args[ii] = args[ii].substring(2);
118                 break;
119             }
120         }
121         new ReferrersTest(args).startTests();
122     }
123 
124     /*
125      * Used to sort a list of ReferenceTypes by
126      * instance count.
127      */
128     class ToSort implements Comparable<ToSort> {
129         long count;
130         ReferenceType rt;
131 
132         public ToSort(long count, ReferenceType rt) {
133             this.count = count;
134             this.rt = rt;
135         }
136 
137         public int compareTo(ToSort obj) {
138             if (count < obj.count) return -1;
139             if (count == obj.count) return 0;
140             return 1;
141         }
142     }
143 
144     protected void runTests() throws Exception {
145         /*
146          * Get to the top of main()
147          * to determine targetClass and mainThread
148          */
149         int CUT_OFF = 1000;
150         BreakpointEvent bpe;
151         bpe = startToMain(targetName);
152         targetClass = bpe.location().declaringType();
153         mainThread = bpe.thread();
154 
155         if (targetName.equals("ReferrersTarg")) {
156             resumeTo("ReferrersTarg", "bkpt", "()V");
157         } else {
158             // Let debuggee run for awhile to get classes loaded
159             vm().resume();
160             try {
161                 System.err.println("Press <enter> to continue");
162                 System.in.read();
163                 System.err.println("running...");
164 
165             } catch(Exception e) {
166             }
167             vm().suspend();
168         }
169 
170         // Get all classes.
171         long start = System.currentTimeMillis();
172         List<ReferenceType> allClasses = vm().allClasses();
173         long end = System.currentTimeMillis();
174         System.out.println( allClasses.size() +
175                             " classes from vm.allClasses() took " +
176                             (end - start) + " ms");
177 
178         long[] counts;
179 
180         // Test for NPE
181         {
182             boolean pass = false;
183             try {
184                 counts = vm().instanceCounts(null);
185             } catch (NullPointerException ee) {
186                 pass = true;
187             }
188             if (!pass) {
189                 failure("failure: NullPointerException not thrown on instanceCounts(null)");
190             }
191         }
192 
193         // Test for 0 length array
194         {
195             List<ReferenceType>someClasses = new ArrayList(2);
196             counts = vm().instanceCounts(someClasses);
197             if (counts.length != 0) {
198                 failure("failure: instanceCounts with a zero length array fails: " +
199                         counts.length);
200             }
201         }
202 
203         // Test various values of maxInstances
204         if (targetClass.name().equals("ReferrersTarg")) {
205             List<ObjectReference> noInstances = targetClass.instances(0);
206             if (noInstances.size() != ReferrersTarg.TARG_COUNT + 1) {
207                 failure("failure: instances(0): " + noInstances.size() + ", for " + targetClass);
208             }
209             noInstances = targetClass.instances(1);
210             if (noInstances.size() != 1) {
211                 failure("failure: instances(1): " + noInstances.size() + ", for " + targetClass);
212             }
213             boolean pass = false;
214             try {
215                 noInstances = targetClass.instances(-1);
216             } catch (IllegalArgumentException ee) {
217                 pass = true;
218             }
219             if (!pass) {
220                 failure("failure: instances(-1) did not get an exception");
221             }
222         }
223 
224         // Instance counts for all classes
225         start = System.currentTimeMillis();
226         counts = vm().instanceCounts(allClasses);
227         end = System.currentTimeMillis();
228 
229         if (counts.length == 0) {
230             System.out.println("failure: No instances found");
231             throw new Exception("ReferrersTest: failed");
232         }
233 
234         // Create a list of ReferenceTypes sorted by instance count
235         int size = 0;
236         List<ToSort> sorted = new ArrayList(allClasses.size());
237         for (int ii = 0; ii < allClasses.size(); ii++) {
238             size += counts[ii];
239             ToSort tos = new ToSort(counts[ii], allClasses.get(ii));
240             sorted.add(tos);
241         }
242 
243         System.out.println("instance counts for " + counts.length +
244                            " classes got " + size + " instances and took " +
245                             (end - start) + " ms");
246 
247 
248         boolean gotReferrersFiller = false;
249         boolean gotReferrersTarg = false;
250 
251         Collections.sort(sorted);
252         for (int ii = sorted.size() - 1; ii >= 0 ; ii--) {
253             ToSort xxx = sorted.get(ii);
254 
255             if (xxx.rt.name().equals("ReferrersFiller") &&
256                 xxx.count == ReferrersFiller.FILLER_COUNT) {
257                 gotReferrersFiller = true;
258             }
259             if (xxx.rt.name().equals("ReferrersTarg") &&
260                 xxx.count == ReferrersTarg.TARG_COUNT + 1) {
261                 gotReferrersTarg = true;
262             }
263         }
264         if (!gotReferrersFiller) {
265             failure("failure: Expected " + ReferrersFiller.FILLER_COUNT +
266                         " instances of ReferrersFiller");
267         }
268         if (!gotReferrersTarg) {
269             failure("failure: Expected " + (ReferrersTarg.TARG_COUNT + 1) +
270                     " instances of ReferrersTarg");
271         }
272 
273         List<List<ObjectReference>> allInstances = new ArrayList(10);
274 
275         // Instances, one class at a time, in sorted order, printing each line
276         if (true) {
277             System.out.println("\nGetting instances for one class " +
278                                "at a time (limited) in sorted order");
279             List<ReferenceType> rtList = new ArrayList(1);
280             rtList.add(null);
281             long start1 = System.currentTimeMillis();
282             size = 0;
283             long count = 0;
284             for (int ii = sorted.size() - 1; ii >= 0 ; ii--) {
285                 ToSort xxx = sorted.get(ii);
286                 if (xxx.count <= CUT_OFF) {
287                     break;
288                 }
289                 rtList.set(0, xxx.rt);
290                 start = System.currentTimeMillis();
291                 List<ObjectReference> oneInstances = xxx.rt.instances(19999999);
292                 end = System.currentTimeMillis();
293                 size += oneInstances.size();
294                 count++;
295                 System.out.println("Expected " + xxx.count + " instances, got " +
296                                    oneInstances.size() +
297                                    " instances for " + sorted.get(ii).rt +
298                                    " in " + (end - start) + " ms");
299 
300                 if (xxx.rt.name().equals("ReferrersFiller") &&
301                     oneInstances.size() != ReferrersFiller.FILLER_COUNT) {
302                     failure("failure: Expected " + ReferrersFiller.FILLER_COUNT +
303                             " instances of ReferrersFiller");
304                 }
305                 if (xxx.rt.name().equals("ReferrersTarg") &&
306                     oneInstances.size() != ReferrersTarg.TARG_COUNT + 1) {
307                     failure("failure: Expected " + (ReferrersTarg.TARG_COUNT + 1) +
308                             " instances of ReferrersTarg");
309                 }
310                 allInstances.add(oneInstances);
311             }
312 
313             end = System.currentTimeMillis();
314 
315             System.out.println(size + " instances via making one vm.instances" +
316                                " call for each of " + count +
317                                " classes took " + (end - start1) + " ms");
318             System.out.println("Per class = " +
319                                (end - start) / allClasses.size() + " ms");
320         }
321 
322 
323         // referrers
324 
325         // Test various values of maxReferrers
326         if (targetClass.name().equals("ReferrersTarg")) {
327             Field field1 = targetClass.fieldByName("theReferrersTarg");
328             ObjectReference anInstance = (ObjectReference)targetClass.getValue(field1);
329             List<ObjectReference> noReferrers = anInstance.referringObjects(0);
330             if (noReferrers.size() != ReferrersTarg.TARG_COUNT + 1 ) {
331                 failure("failure: referringObjects(0) got " + noReferrers.size() +
332                         ", for " + anInstance);
333             }
334             noReferrers = anInstance.referringObjects(1);
335             if (noReferrers.size() != 1 ) {
336                 failure("failure: referringObjects(1) got " + noReferrers.size() +
337                         ", for " + anInstance);
338             }
339             boolean pass = false;
340             try {
341                 noReferrers = anInstance.referringObjects(-1);
342             } catch (IllegalArgumentException ee) {
343                 pass = true;
344             }
345             if (!pass) {
346                 failure("failure: referringObjects(-1) did not get an exception");
347             }
348         }
349 
350         List<ObjectReference> allReferrers = null;
351         List<ObjectReference> someInstances = new ArrayList();
352         if (targetName.equals("ReferrersTarg")) {
353             Field field1 = targetClass.fieldByName("theReferrersTarg");
354             ObjectReference val = (ObjectReference)targetClass.getValue(field1);
355             someInstances.add(val);
356             allReferrers = val.referringObjects(99999);  //LIMIT
357             if (allReferrers.size() != ReferrersTarg.TARG_COUNT + 1) {
358                 failure("failure: expected " + (ReferrersTarg.TARG_COUNT + 1) +
359                         "referrers, but got " + allReferrers.size() +
360                         " referrers for " + val);
361             }
362         } else {
363             // referrers
364             // Create someInstances to find the referrers of.
365             for (int ii = 0; ii < allClasses.size(); ii++) {
366                 List<ObjectReference> objRefList = allInstances.get(ii);
367                 if (objRefList != null) {
368                     int asize = objRefList.size();
369                     if (false) {
370                         System.out.println(asize + ", " + allClasses.get(ii));
371                     }
372                     // Remember one instance per class to get referrers
373                     if (asize > 0) {
374                         someInstances.add(objRefList.get(0));
375                     }
376                 }
377             }
378         }
379 
380         for (ObjectReference objRef: someInstances) {
381             //System.out.println( "Getting referrers for " + objRef);
382             start = System.currentTimeMillis();
383             if ( true) {
384                 showReferrers(objRef, 0, 0, 0);
385             } else {
386                 allReferrers = objRef.referringObjects(99999);  //LIMIT
387                 end = System.currentTimeMillis();
388                 if (true || allReferrers.size() > 1) {
389                     System.out.println( allReferrers.size() + " referrers for " + objRef + " took " + (end - start) + " ms");
390                 }
391             }
392         }
393 
394         /*
395          * deal with results of test
396          * if anything has called failure("foo") testFailed will be true
397          */
398         if (!testFailed) {
399             println("ReferrersTest: passed");
400         } else {
401             throw new Exception("ReferrersTest: failed");
402         }
403     }
404     void indent(int level) {
405         for (int ii = 0; ii < level; ii++) {
406             System.out.print("    ");
407         }
408     }
409 
410 
411     Map<ObjectReference, Object> visited = new HashMap(100);
412     void showReferrers(ObjectReference objRef, int level, int total, int which) {
413 
414         if (level == 0) {
415             visited.clear();
416         } else {
417             if (visited.containsKey(objRef)) {
418                 indent(level);
419                 System.out.println("(" + which + ")" + ":<pruned> " + objRef);
420                 return;
421             }
422             visited.put(objRef, null);
423             indent(level);
424             //System.out.println(which + "/" + total + ": " + objRef + " took " + time + " ms");
425         }
426 
427         List<ObjectReference> allReferrers = null;
428 
429         //System.out.println( "Getting referrers for " + objRef);
430         long start, end;
431         start = System.currentTimeMillis();
432         allReferrers = objRef.referringObjects(99999);  //LIMIT
433         end = System.currentTimeMillis();
434 
435         if (which == 0) {
436             System.out.println(allReferrers.size() + " referrers for " + objRef + " took " + (end - start) + " ms");
437         } else {
438             System.out.println("(" + which + ") "  + objRef);
439             indent(level);
440             System.out.println("    " + allReferrers.size() + " referrers for " + objRef + " took " + (end - start) + " ms");
441         }
442 
443         // We have to stop going up a referrer chain in some cases
444         Type rt = objRef.type();
445         if (rt instanceof ClassType) {
446             ClassType ct = (ClassType)rt;
447             String name = ct.name();
448             if (name.equals("sun.awt.SoftCache$ValueCell")) {
449                 return;
450             }
451             if (name.equals("java.lang.ref.Finalizer")) {
452                 return;
453             }
454             if (name.equals("java.lang.ref.SoftReference")) {
455                 return;
456             }
457             // oh oh, should really check for a subclass of ClassLoader :-)
458             if (name.indexOf("ClassLoader") >= 0) {
459                 return;
460             }
461             // No doubt there are other reasons to stop ...
462         }
463         int itemNumber = 1;
464         int allSize = allReferrers.size();
465         for (ObjectReference objx: allReferrers) {
466             showReferrers(objx, level + 1, allSize, itemNumber++);
467         }
468     }
469 }