Mercurial > hg > truffle
view test/compiler/7047069/Test7047069.java @ 10246:194f52aa2f23
7176479: G1: JVM crashes on T5-8 system with 1.5 TB heap
Summary: Refactor G1's hot card cache and card counts table into their own files. Simplify the card counts table, including removing the encoding of the card index in each entry. The card counts table now has a 1:1 correspondence with the cards spanned by heap. Space for the card counts table is reserved from virtual memory (rather than C heap) during JVM startup and is committed/expanded when the heap is expanded. Changes were also reviewed-by Vitaly Davidovich.
Reviewed-by: tschatzl, jmasa
author | johnc |
---|---|
date | Thu, 09 May 2013 11:16:39 -0700 |
parents | b2cb497dec28 |
children |
line wrap: on
line source
/* * Copyright (c) 2011, 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 7047069 * @summary Array can dynamically change size when assigned to an object field * * @run main/othervm -Xbatch Test7047069 */ import java.util.*; import java.awt.geom.*; public class Test7047069 { static boolean verbose; static final int GROW_SIZE = 24; // Multiple of cubic & quad curve size float squareflat; // Square of the flatness parameter // for testing against squared lengths int limit; // Maximum number of recursion levels float hold[] = new float[14]; // The cache of interpolated coords // Note that this must be long enough // to store a full cubic segment and // a relative cubic segment to avoid // aliasing when copying the coords // of a curve to the end of the array. // This is also serendipitously equal // to the size of a full quad segment // and 2 relative quad segments. int holdEnd; // The index of the last curve segment // being held for interpolation int holdIndex; // The index of the curve segment // that was last interpolated. This // is the curve segment ready to be // returned in the next call to // currentSegment(). int levels[]; // The recursion level at which // each curve being held in storage // was generated. int levelIndex; // The index of the entry in the // levels array of the curve segment // at the holdIndex public static void subdivide(float src[], int srcoff, float left[], int leftoff, float right[], int rightoff) { float x1 = src[srcoff + 0]; float y1 = src[srcoff + 1]; float ctrlx = src[srcoff + 2]; float ctrly = src[srcoff + 3]; float x2 = src[srcoff + 4]; float y2 = src[srcoff + 5]; if (left != null) { left[leftoff + 0] = x1; left[leftoff + 1] = y1; } if (right != null) { right[rightoff + 4] = x2; right[rightoff + 5] = y2; } x1 = (x1 + ctrlx) / 2f; y1 = (y1 + ctrly) / 2f; x2 = (x2 + ctrlx) / 2f; y2 = (y2 + ctrly) / 2f; ctrlx = (x1 + x2) / 2f; ctrly = (y1 + y2) / 2f; if (left != null) { left[leftoff + 2] = x1; left[leftoff + 3] = y1; left[leftoff + 4] = ctrlx; left[leftoff + 5] = ctrly; } if (right != null) { right[rightoff + 0] = ctrlx; right[rightoff + 1] = ctrly; right[rightoff + 2] = x2; right[rightoff + 3] = y2; } } public static double getFlatnessSq(float coords[], int offset) { return Line2D.ptSegDistSq(coords[offset + 0], coords[offset + 1], coords[offset + 4], coords[offset + 5], coords[offset + 2], coords[offset + 3]); } public Test7047069() { this.squareflat = .0001f * .0001f; holdIndex = hold.length - 6; holdEnd = hold.length - 2; hold[holdIndex + 0] = (float) (Math.random() * 100); hold[holdIndex + 1] = (float) (Math.random() * 100); hold[holdIndex + 2] = (float) (Math.random() * 100); hold[holdIndex + 3] = (float) (Math.random() * 100); hold[holdIndex + 4] = (float) (Math.random() * 100); hold[holdIndex + 5] = (float) (Math.random() * 100); levelIndex = 0; this.limit = 10; this.levels = new int[limit + 1]; } /* * Ensures that the hold array can hold up to (want) more values. * It is currently holding (hold.length - holdIndex) values. */ void ensureHoldCapacity(int want) { if (holdIndex - want < 0) { int have = hold.length - holdIndex; int newsize = hold.length + GROW_SIZE; float newhold[] = new float[newsize]; System.arraycopy(hold, holdIndex, newhold, holdIndex + GROW_SIZE, have); if (verbose) System.err.println("old hold = "+hold+"["+hold.length+"]"); if (verbose) System.err.println("replacement hold = "+newhold+"["+newhold.length+"]"); hold = newhold; if (verbose) System.err.println("new hold = "+hold+"["+hold.length+"]"); if (verbose) System.err.println("replacement hold still = "+newhold+"["+newhold.length+"]"); holdIndex += GROW_SIZE; holdEnd += GROW_SIZE; } } private boolean next() { if (holdIndex >= holdEnd) { return false; } int level = levels[levelIndex]; while (level < limit) { if (getFlatnessSq(hold, holdIndex) < squareflat) { break; } ensureHoldCapacity(4); subdivide(hold, holdIndex, hold, holdIndex - 4, hold, holdIndex); holdIndex -= 4; // Now that we have subdivided, we have constructed // two curves of one depth lower than the original // curve. One of those curves is in the place of // the former curve and one of them is in the next // set of held coordinate slots. We now set both // curves level values to the next higher level. level++; levels[levelIndex] = level; levelIndex++; levels[levelIndex] = level; } // This curve segment is flat enough, or it is too deep // in recursion levels to try to flatten any more. The // two coordinates at holdIndex+4 and holdIndex+5 now // contain the endpoint of the curve which can be the // endpoint of an approximating line segment. holdIndex += 4; levelIndex--; return true; } public static void main(String argv[]) { verbose = (argv.length > 0); for (int i = 0; i < 100000; i++) { Test7047069 st = new Test7047069(); while (st.next()) {} } } }