Java example source code file (ReferrersTest.java)

This example Java source code file (ReferrersTest.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

arraylist, classtype, cut_off, exception, expected, field, jdi, limit, list, objectreference, referencetype, referrersfiller, referrerstarg, referrerstest, tosort, util

The ReferrersTest.java Java example source code

/*
 * Copyright (c) 2005, 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 main 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 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.misc.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++);
        }
    }
}