Name: tb29552 Date: 02/23/2001


/*
JVMPI CPU profiler bug

The testcase is GCBench.java, I attached it to the tail of the bug report.

This bug is easily reproducible on a Sparc box in-house here. It is reproducible
in both -hotspot mode and -Xint mode. It is reproduced with JDK1.3, HotSpot 2.0
Server VM.^X^S

  To reproduce:
1, javac GCBench.java
2, java -hotspot -Xrunhprof:cpu=times GCBench or
        java -Xint -Xrunhprof:cpu=times GCBench

$ java -hotspot -Xrunhprof:cpu=times GCBench
Garbage Collector Test
 Stretching memory with a binary tree of depth 18
 Total memory available=3604480 bytes Free memory=1230504 bytes
HPROF ERROR : stack underflow in method exit
HPROF ERROR : stack underflow in method exit
HPROF ERROR : stack underflow in method exit
HPROF ERROR : stack underflow in method exit
HPROF ERROR : stack underflow in method exit
 Creating a long-lived binary tree of depth 16
 Creating a long-lived array of 500000 doubles
^C

$ java -version
java version "1.3.0"
Java HotSpot(TM) Server VM (mixed mode)


GCBench.java
*/

class Node {
    Node left, right;
    int i, j;
    Node (Node l, Node r) {
        left = l;
        right = r;
    }
    Node () {
    }
}

public class GCBench {

    public static final int kStretchTreeDepth = 18; // about 16Mb
    public static final int kLongLivedTreeDepth = 16; // about 4Mb
    public static final int kArraySize = 500000; // about 4Mb
    public static final int kMinTreeDepth = 4;
    public static final int kMaxTreeDepth = 16;

    // Nodes used by a tree of a given size
    static int TreeSize(int i) {
        return ((1 << (i + 1)) - 1);
    }

    // Number of iterations to use for a given tree depth
    static int NumIters(int i) {
        return 2 * TreeSize(kStretchTreeDepth) / TreeSize(i);
    }

    // Build tree top down, assigning to older objects.
    static void Populate(int iDepth, Node thisNode) {
        if (iDepth <= 0) {
            return;
        } else {
            iDepth--;
            thisNode.left = new Node ();
            thisNode.right = new Node ();
            Populate(iDepth, thisNode.left);
            Populate(iDepth, thisNode.right);
        }
    }

    // Build tree bottom-up
    static Node MakeTree(int iDepth) {
        if (iDepth <= 0) {
            return new Node ();
        } else {
            return new Node (MakeTree(iDepth - 1),
                             MakeTree(iDepth - 1));
        }
    }

    static void PrintDiagnostics() {
        long lFreeMemory = Runtime.getRuntime().freeMemory();
        long lTotalMemory = Runtime.getRuntime().totalMemory();

        System.out.print(" Total memory available="
                         + lTotalMemory + " bytes");
        System.out.println(" Free memory=" + lFreeMemory + " bytes");
    }

    static void TimeConstruction(int depth) {
        Node root;
        long tStart, tFinish;
        int iNumIters = NumIters(depth);
        Node tempTree;

        System.out.println("Creating " + iNumIters +
                           " trees of depth " + depth);
        tStart = System.currentTimeMillis();
        for (int i = 0; i < iNumIters; ++i) {
            tempTree = new Node ();
            Populate(depth, tempTree);
            tempTree = null;
        }
        tFinish = System.currentTimeMillis();
        System.out.println("\tTop down construction took "
                           + (tFinish - tStart) + "msecs");
        tStart = System.currentTimeMillis();
        for (int i = 0; i < iNumIters; ++i) {
            tempTree = MakeTree(depth);
            tempTree = null;
        }
        tFinish = System.currentTimeMillis();
        System.out.println("\tBottom up construction took "
                           + (tFinish - tStart) + "msecs");

    }

    public static void main(String args[]) {
        Node root;
        Node longLivedTree;
        Node tempTree;
        long tStart, tFinish;
        long tElapsed;


        System.out.println("Garbage Collector Test");
        System.out.println(
                           " Stretching memory with a binary tree of depth "
                           + kStretchTreeDepth);
        PrintDiagnostics();
        tStart = System.currentTimeMillis();

        // Stretch the memory space quickly
        tempTree = MakeTree(kStretchTreeDepth);
        tempTree = null;

        // Create a long lived object
        System.out.println(
                           " Creating a long-lived binary tree of depth " +
                           kLongLivedTreeDepth);
        longLivedTree = new Node ();
        Populate(kLongLivedTreeDepth, longLivedTree);

        // Create long-lived array, filling half of it
        System.out.println(
                           " Creating a long-lived array of "
                           + kArraySize + " doubles");
        double array[] = new double[kArraySize];
        for (int i = 0; i < kArraySize / 2; ++i) {
            array[i] = 1.0 / i;
        }
        PrintDiagnostics();

        for (int d = kMinTreeDepth; d <= kMaxTreeDepth; d += 2) {
            TimeConstruction(d);
        }

        if (longLivedTree == null || array[1000] != 1.0 / 1000)
            System.out.println("Failed");
        // fake reference to LongLivedTree
        // and array
        // to keep them from being optimized away

        tFinish = System.currentTimeMillis();
        tElapsed = tFinish - tStart;
        PrintDiagnostics();
        System.out.println("Completed in " + tElapsed + "ms.");
    }
} // class JavaGC

(Review ID: 111053)
======================================================================