Mercurial > hg > graal-compiler
view test/compiler/7047069/Test7047069.java @ 4181:319860ae697a
Simplify FrameMap: make offsets of spill slots and outgoing parameters independent so that they can be allocated at the same time, eliminating the separate phases. This makes the separate StackBlock unnecesary. Change CiStackSlot to use byte offsets instead of spill slot index. This makes CiTarget.spillSlotSize unnecessary.
author | Christian Wimmer <Christian.Wimmer@Oracle.com> |
---|---|
date | Mon, 02 Jan 2012 14:16:08 -0800 |
parents | ea0da5474c23 |
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()) {} } } }