/*
* Copyright (c) 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 TestGCOld
* @key gc
* @key stress
* @requires vm.gc=="null"
* @summary Stress the GC by trying to make old objects more likely to be garbage than young objects.
* @run main/othervm -Xmx384M -XX:+UseSerialGC TestGCOld 50 1 20 10 10000
* @run main/othervm -Xmx384M -XX:+UseParallelGC TestGCOld 50 1 20 10 10000
* @run main/othervm -Xmx384M -XX:+UseParallelGC -XX:-UseParallelOldGC TestGCOld 50 1 20 10 10000
* @run main/othervm -Xmx384M -XX:+UseConcMarkSweepGC TestGCOld 50 1 20 10 10000
* @run main/othervm -Xmx384M -XX:+UseG1GC TestGCOld 50 1 20 10 10000
*/
import java.text.*;
import java.util.Random;
class TreeNode {
public TreeNode left, right;
public int val; // will always be the height of the tree
}
/* Args:
live-data-size: in megabytes (approximate, will be rounded down).
work: units of mutator non-allocation work per byte allocated,
(in unspecified units. This will affect the promotion rate
printed at the end of the run: more mutator work per step implies
fewer steps per second implies fewer bytes promoted per second.)
short/long ratio: ratio of short-lived bytes allocated to long-lived
bytes allocated.
pointer mutation rate: number of pointer mutations per step.
steps: number of steps to do.
*/
public class TestGCOld {
// Command-line parameters.
private static int size, workUnits, promoteRate, ptrMutRate, steps;
// Constants.
private static final int MEG = 1000000;
private static final int INSIGNIFICANT = 999; // this many bytes don't matter
private static final int BYTES_PER_WORD = 4;
private static final int BYTES_PER_NODE = 20; // bytes per TreeNode
private static final int WORDS_DEAD = 100; // size of young garbage object
private final static int treeHeight = 14;
private final static long treeSize = heightToBytes(treeHeight);
private static final String msg1
= "Usage: java TestGCOld <size> <work> <ratio> <mutation> <steps>";
private static final String msg2
= " where <size> is the live storage in megabytes";
private static final String msg3
= " <work> is the mutator work per step (arbitrary units)";
private static final String msg4
= " <ratio> is the ratio of short-lived to long-lived allocation";
private static final String msg5
= " <mutation> is the mutations per step";
private static final String msg6
= " <steps> is the number of steps";
// Counters (and global variables that discourage optimization)
private static long youngBytes = 0; // total young bytes allocated
private static long nodes = 0; // total tree nodes allocated
private static long actuallyMut = 0; // pointer mutations in old trees
private static long mutatorSum = 0; // checksum to discourage optimization
public static int[] aexport; // exported array to discourage opt
// Global variables.
private static TreeNode[] trees;
private static int where = 0; // roving index into trees
private static Random rnd = new Random();
// Returns the height of the given tree.
private static int height (TreeNode t) {
if (t == null) {
return 0;
}
else {
return 1 + Math.max (height (t.left), height (t.right));
}
}
// Returns the length of the shortest path in the given tree.
private static int shortestPath (TreeNode t) {
if (t == null) {
return 0;
}
else {
return 1 + Math.min (shortestPath (t.left), shortestPath (t.right));
}
}
// Returns the number of nodes in a balanced tree of the given height.
private static long heightToNodes (int h) {
if (h == 0) {
return 0;
}
else {
long n = 1;
while (h > 1) {
n = n + n;
h = h - 1;
}
return n + n - 1;
}
}
// Returns the number of bytes in a balanced tree of the given height.
private static long heightToBytes (int h) {
return BYTES_PER_NODE * heightToNodes (h);
}
// Returns the height of the largest balanced tree
// that has no more than the given number of nodes.
private static int nodesToHeight (long nodes) {
int h = 1;
long n = 1;
while (n + n - 1 <= nodes) {
n = n + n;
h = h + 1;
}
return h - 1;
}
// Returns the height of the largest balanced tree
// that occupies no more than the given number of bytes.
private static int bytesToHeight (long bytes) {
return nodesToHeight (bytes / BYTES_PER_NODE);
}
// Returns a newly allocated balanced binary tree of height h.
private static TreeNode makeTree(int h) {
if (h == 0) return null;
else {
TreeNode res = new TreeNode();
nodes++;
res.left = makeTree(h-1);
res.right = makeTree(h-1);
res.val = h;
return res;
}
}
// Allocates approximately size megabytes of trees and stores
// them into a global array.
private static void init() {
int ntrees = (int) ((size * MEG) / treeSize);
trees = new TreeNode[ntrees];
System.err.println("Allocating " + ntrees + " trees.");
System.err.println(" (" + (ntrees * treeSize) + " bytes)");
for (int i = 0; i < ntrees; i++) {
trees[i] = makeTree(treeHeight);
// doYoungGenAlloc(promoteRate*ntrees*treeSize, WORDS_DEAD);
}
System.err.println(" (" + nodes + " nodes)");
/* Allow any in-progress GC to catch up... */
// try { Thread.sleep(20000); } catch (InterruptedException x) {}
}
// Confirms that all trees are balanced and have the correct height.
private static void checkTrees() {
int ntrees = trees.length;
for (int i = 0; i < ntrees; i++) {
TreeNode t = trees[i];
int h1 = height(t);
int h2 = shortestPath(t);
if ((h1 != treeHeight) || (h2 != treeHeight)) {
System.err.println("*****BUG: " + h1 + " " + h2);
}
}
}
// Called only by replaceTree (below) and by itself.
private static void replaceTreeWork(TreeNode full, TreeNode partial, boolean dir) {
boolean canGoLeft = full.left != null && full.left.val > partial.val;
boolean canGoRight = full.right != null && full.right.val > partial.val;
if (canGoLeft && canGoRight) {
if (dir)
replaceTreeWork(full.left, partial, !dir);
else
replaceTreeWork(full.right, partial, !dir);
} else if (!canGoLeft && !canGoRight) {
if (dir)
full.left = partial;
else
full.right = partial;
} else if (!canGoLeft) {
full.left = partial;
} else {
full.right = partial;
}
}
// Given a balanced tree full and a smaller balanced tree partial,
// replaces an appropriate subtree of full by partial, taking care
// to preserve the shape of the full tree.
private static void replaceTree(TreeNode full, TreeNode partial) {
boolean dir = (partial.val % 2) == 0;
actuallyMut++;
replaceTreeWork(full, partial, dir);
}
// Allocates approximately n bytes of long-lived storage,
// replacing oldest existing long-lived storage.
private static void oldGenAlloc(long n) {
int full = (int) (n / treeSize);
long partial = n % treeSize;
// System.out.println("In oldGenAlloc, doing " + full + " full trees "
// + "and one partial tree of size " + partial);
for (int i = 0; i < full; i++) {
trees[where++] = makeTree(treeHeight);
if (where == trees.length) where = 0;
}
while (partial > INSIGNIFICANT) {
int h = bytesToHeight(partial);
TreeNode newTree = makeTree(h);
replaceTree(trees[where++], newTree);
if (where == trees.length) where = 0;
partial = partial - heightToBytes(h);
}
}
// Interchanges two randomly selected subtrees (of same size and depth).
private static void oldGenSwapSubtrees() {
// Randomly pick:
// * two tree indices
// * A depth
// * A path to that depth.
int index1 = rnd.nextInt(trees.length);
int index2 = rnd.nextInt(trees.length);
int depth = rnd.nextInt(treeHeight);
int path = rnd.nextInt();
TreeNode tn1 = trees[index1];
TreeNode tn2 = trees[index2];
for (int i = 0; i < depth; i++) {
if ((path & 1) == 0) {
tn1 = tn1.left;
tn2 = tn2.left;
} else {
tn1 = tn1.right;
tn2 = tn2.right;
}
path >>= 1;
}
TreeNode tmp;
if ((path & 1) == 0) {
tmp = tn1.left;
tn1.left = tn2.left;
tn2.left = tmp;
} else {
tmp = tn1.right;
tn1.right = tn2.right;
tn2.right = tmp;
}
actuallyMut += 2;
}
// Update "n" old-generation pointers.
private static void oldGenMut(long n) {
for (int i = 0; i < n/2; i++) {
oldGenSwapSubtrees();
}
}
// Does the amount of mutator work appropriate for n bytes of young-gen
// garbage allocation.
private static void doMutWork(long n) {
int sum = 0;
long limit = workUnits*n/10;
for (long k = 0; k < limit; k++) sum++;
// We don't want dead code elimination to eliminate the loop above.
mutatorSum = mutatorSum + sum;
}
// Allocate n bytes of young-gen garbage, in units of "nwords"
// words.
private static void doYoungGenAlloc(long n, int nwords) {
final int nbytes = nwords*BYTES_PER_WORD;
int allocated = 0;
while (allocated < n) {
aexport = new int[nwords];
/* System.err.println("Step"); */
allocated += nbytes;
}
youngBytes = youngBytes + allocated;
}
// Allocate "n" bytes of young-gen data; and do the
// corresponding amount of old-gen allocation and pointer
// mutation.
// oldGenAlloc may perform some mutations, so this code
// takes those mutations into account.
private static void doStep(long n) {
long mutations = actuallyMut;
doYoungGenAlloc(n, WORDS_DEAD);
doMutWork(n);
oldGenAlloc(n / promoteRate);
oldGenMut(Math.max(0L, (mutations + ptrMutRate) - actuallyMut));
}
public static void main(String[] args) {
if (args.length != 5) {
System.err.println(msg1);
System.err.println(msg2);
System.err.println(msg3);
System.err.println(msg4);
System.err.println(msg5);
System.err.println(msg6);
return;
}
size = Integer.parseInt(args[0]);
workUnits = Integer.parseInt(args[1]);
promoteRate = Integer.parseInt(args[2]);
ptrMutRate = Integer.parseInt(args[3]);
steps = Integer.parseInt(args[4]);
System.out.println(size + " megabytes of live storage");
System.out.println(workUnits + " work units per step");
System.out.println("promotion ratio is 1:" + promoteRate);
System.out.println("pointer mutation rate is " + ptrMutRate);
System.out.println(steps + " steps");
init();
// checkTrees();
youngBytes = 0;
nodes = 0;
System.err.println("Initialization complete...");
long start = System.currentTimeMillis();
for (int step = 0; step < steps; step++) {
doStep(MEG);
}
long end = System.currentTimeMillis();
float secs = ((float)(end-start))/1000.0F;
// checkTrees();
NumberFormat nf = NumberFormat.getInstance();
nf.setMaximumFractionDigits(1);
System.out.println("\nTook " + nf.format(secs) + " sec in steady state.");
nf.setMaximumFractionDigits(2);
System.out.println("Allocated " + steps + " Mb of young gen garbage"
+ " (= " + nf.format(((float)steps)/secs) +
" Mb/sec)");
System.out.println(" (actually allocated " +
nf.format(((float) youngBytes)/MEG) + " megabytes)");
float promoted = ((float)steps) / (float)promoteRate;
System.out.println("Promoted " + promoted +
" Mb (= " + nf.format(promoted/secs) + " Mb/sec)");
System.out.println(" (actually promoted " +
nf.format(((float) (nodes * BYTES_PER_NODE))/MEG) +
" megabytes)");
if (ptrMutRate != 0) {
System.out.println("Mutated " + actuallyMut +
" pointers (= " +
nf.format(actuallyMut/secs) + " ptrs/sec)");
}
// This output serves mainly to discourage optimization.
System.out.println("Checksum = " + (mutatorSum + aexport.length));
}
}