Mercurial > hg > truffle
view agent/src/share/classes/sun/jvm/hotspot/ui/HighPrecisionJScrollBar.java @ 8790:7f0cb32dd233
8004241: NPG: Metaspace occupies more memory than specified by -XX:MaxMetaspaceSize option
Summary: Enforce MaxMetaspaceSize for both metaspace parts, check MaxMetaspaceSize against "reserved", not "capacity"
Reviewed-by: jmasa, johnc
author | mgerdin |
---|---|
date | Thu, 21 Mar 2013 09:07:43 +0100 |
parents | c18cbe5936b8 |
children |
line wrap: on
line source
/* * Copyright (c) 2000, 2008, 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. * */ package sun.jvm.hotspot.ui; import java.awt.event.*; import javax.swing.*; import javax.swing.event.*; import java.math.*; import java.util.*; /** A JScrollBar which uses BigIntegers as the representation for the minimum, maximum, unit increment, etc. Interaction with the buttons and track is accurate to unit and block increments; however, if the scale of the scrollbar (defined by getMaximumHP().subtract(getMinimumHP())) is very large, each interaction with the thumb will necessarily cause extremely large motion of the value. */ public class HighPrecisionJScrollBar extends JScrollBar { private BigInteger valueHP; private BigInteger visibleHP; private BigInteger minimumHP; private BigInteger maximumHP; private BigInteger unitIncrementHP; private BigInteger blockIncrementHP; private BigDecimal scaleFactor; private BigInteger rangeHP; // The underlying scrollbar runs a range from 0..BIG_RANGE-1 private static final int BIG_RANGE = 10000; // Do we need to scale HP values up/down to fit in 0..BIG_RANGE-1? private boolean down; private java.util.List changeListeners = new ArrayList(); // Number of digits after decimal point to use when scaling between // high and low precision private static final int SCALE = 20; // This is a hack to allow us to differentiate between clicks on the // arrow and track since we can't get useful information from // JScrollBars' AdjustmentListener (bug in design of BasicUI // classes; FIXME: file RFE.) private static final int UNIT_INCREMENT = 1; private static final int BLOCK_INCREMENT = 2; private static final int MINIMUM = 0; private static final int MAXIMUM = 65536; private boolean updating = false; private int lastValueSeen = -1; public HighPrecisionJScrollBar() { super(); initialize(); installListener(); } public HighPrecisionJScrollBar(int orientation) { super(orientation); initialize(); installListener(); } /** value, minimum and maximum should be positive */ public HighPrecisionJScrollBar(int orientation, BigInteger value, BigInteger minimum, BigInteger maximum) { super(orientation); initialize(value, minimum, maximum); installListener(); } public BigInteger getValueHP() { return valueHP; } /** NOTE: the real value will always be set to be (value mod unitIncrement) == 0, subtracting off the mod of the passed value if necessary. */ public void setValueHP(BigInteger value) { if (value.compareTo(getMaximumHP()) > 0) { value = getMaximumHP(); } else if (value.compareTo(getMinimumHP()) < 0) { value = getMinimumHP(); } valueHP = value.subtract(value.mod(unitIncrementHP)); int lpValue = toUnderlyingRange(this.valueHP); if (getValueHP().add(getVisibleAmountHP()).compareTo(getMaximumHP()) >= 0 ) { lpValue = BIG_RANGE - getVisibleAmount(); } lastValueSeen = lpValue; setValue(lpValue); fireStateChanged(); } public BigInteger getMinimumHP() { return minimumHP; } public void setMinimumHP(BigInteger minimum) { setRange(minimum, maximumHP); updateScrollBarValues(); } public BigInteger getMaximumHP() { return maximumHP; } public void setMaximumHP(BigInteger maximum) { setRange(minimumHP, maximum); updateScrollBarValues(); } public BigInteger getVisibleAmountHP() { return visibleHP; } public void setVisibleAmountHP(BigInteger visibleAmount) { this.visibleHP = visibleAmount; // int lpVisAmt = toUnderlyingRange(visibleAmount); // Make certain that visibleAmount value that are full range come out looking like full range int lpVisAmt; if (visibleAmount.compareTo(rangeHP) < 0) { lpVisAmt = scaleToUnderlying(visibleAmount); if (lpVisAmt == 0) { lpVisAmt = 1; } setVisible(true); } else { lpVisAmt = BIG_RANGE; setVisible(false); } setVisibleAmount(lpVisAmt); } public BigInteger getBlockIncrementHP() { return blockIncrementHP; } public void setBlockIncrementHP(BigInteger blockIncrement) { this.blockIncrementHP = blockIncrement; // NOTE we do not forward this to the underlying scrollBar because of // the earlier mentioned hack. } public BigInteger getUnitIncrementHP() { return unitIncrementHP; } public void setUnitIncrementHP(BigInteger unitIncrement) { this.unitIncrementHP = unitIncrement; // NOTE we do not forward this to the underlying scrollBar because of // the earlier mentioned hack. } public void addChangeListener(ChangeListener l) { changeListeners.add(l); } public void removeChangeListener(ChangeListener l) { changeListeners.remove(l); } //---------------------------------------------------------------------- // Programmatic access to scrollbar functionality // (Causes change events to be sent) public void scrollUpOrLeft() { if (updating) return; beginUpdate(); setValueHP(getValueHP().subtract(getUnitIncrementHP())); endUpdate(); } public void scrollDownOrRight() { if (updating) return; beginUpdate(); setValueHP(getValueHP().add(getUnitIncrementHP())); endUpdate(); } public void pageUpOrLeft() { if (updating) return; beginUpdate(); setValueHP(getValueHP().subtract(getBlockIncrementHP())); endUpdate(); } public void pageDownOrRight() { if (updating) return; beginUpdate(); setValueHP(getValueHP().add(getBlockIncrementHP())); endUpdate(); } //---------------------------------------------------------------------- // Internals only below this point // private void beginUpdate() { updating = true; } private void endUpdate() { updating = false; } private void initialize(BigInteger value, BigInteger minimum, BigInteger maximum) { // Initialize the underlying scrollbar to the standard range values // The increments are important and are how we differentiate arrow from track events setMinimum(0); setMaximum(BIG_RANGE - 1); setValue(0); setVisibleAmount(1); setUnitIncrement(UNIT_INCREMENT); setBlockIncrement(BLOCK_INCREMENT); setUnitIncrementHP(new BigInteger(Integer.toString(getUnitIncrement()))); setBlockIncrementHP(new BigInteger(Integer.toString(getBlockIncrement()))); // Must set range and value first (it sets min/max) setRange(minimum, maximum); setVisibleAmountHP(new BigInteger(Integer.toString(getVisibleAmount()))); setValueHP(value); } private void initialize() { BigInteger min = new BigInteger(Integer.toString(getMinimum())); BigInteger max = new BigInteger(Integer.toString(getMaximum())); initialize(min, min, max); } private void setRange(BigInteger minimum, BigInteger maximum) { if (minimum.compareTo(maximum) > 0 ) { throw new RuntimeException("Bad scrollbar range " + minimum + " > " + maximum); } minimumHP = minimum; maximumHP = maximum; rangeHP = maximum.subtract(minimum).add(BigInteger.ONE); BigInteger range2 = new BigInteger(Integer.toString(BIG_RANGE)); if (rangeHP.compareTo(range2) >= 0 ) { down = true; scaleFactor = new BigDecimal(rangeHP, SCALE).divide(new BigDecimal(range2, SCALE), BigDecimal.ROUND_DOWN).max(new BigDecimal(BigInteger.ONE)); } else { down = false; scaleFactor = new BigDecimal(range2, SCALE).divide(new BigDecimal(rangeHP, SCALE), BigDecimal.ROUND_DOWN).max(new BigDecimal(BigInteger.ONE)); } // FIXME: should put in original scaling algorithm (shifting by // number of bits) as alternative when scale between low and high // precision is very large } // A range update is complete. Rescale our computed values and // inform the underlying scrollBar as needed. private void updateScrollBarValues() { setValueHP(getValueHP()); setVisibleAmountHP(getVisibleAmountHP()); setBlockIncrementHP(getBlockIncrementHP()); setUnitIncrementHP(getUnitIncrementHP()); } private BigDecimal getScaleFactor() { return scaleFactor; } // Value scaling routines private BigInteger scaleToHP(int i) { BigDecimal ib = new BigDecimal(Integer.toString(i)); if (down) return ib.multiply(getScaleFactor()).toBigInteger(); else return ib.divide(getScaleFactor(), BigDecimal.ROUND_DOWN).toBigInteger(); } private int scaleToUnderlying(BigInteger i) { BigDecimal d = new BigDecimal(i); if (down) return d.divide(getScaleFactor(), BigDecimal.ROUND_DOWN).intValue(); else return d.multiply(getScaleFactor()).intValue(); } // Range scaling routines private BigInteger toHPRange(int i) { return scaleToHP(i).add(minimumHP); // return ib.shiftLeft(Math.max(2, maximumHP.bitLength() - 33)); } private int toUnderlyingRange(BigInteger i) { return scaleToUnderlying(i.subtract(minimumHP)); // return i.shiftRight(Math.max(2, maximumHP.bitLength() - 33)).intValue(); } private void installListener() { super.addAdjustmentListener(new AdjustmentListener() { public void adjustmentValueChanged(AdjustmentEvent e) { if (updating) { return; } beginUpdate(); switch (e.getAdjustmentType()) { case AdjustmentEvent.TRACK: int val = e.getValue(); int diff = val - lastValueSeen; int absDiff = Math.abs(diff); // System.err.println("diff: " + diff + " absDiff: " + absDiff); if (absDiff == UNIT_INCREMENT) { if (diff > 0) { // System.err.println("case 1"); setValueHP(getValueHP().add(getUnitIncrementHP())); } else { // System.err.println("case 2"); setValueHP(getValueHP().subtract(getUnitIncrementHP())); } } else if (absDiff == BLOCK_INCREMENT) { if (diff > 0) { // System.err.println("case 3"); setValueHP(getValueHP().add(getBlockIncrementHP())); } else { // System.err.println("case 4"); setValueHP(getValueHP().subtract(getBlockIncrementHP())); } } else { // System.err.println("case 5"); // FIXME: seem to be getting spurious update events, // with diff = 0, upon mouse down/up on the track if (absDiff != 0) { // Convert low-precision value to high precision // (note we lose the low bits) BigInteger i = null; if (e.getValue() == getMinimum()) { i = getMinimumHP(); } else if (e.getValue() >= getMaximum() - 1) { i = getMaximumHP(); } else { i = toHPRange(e.getValue()); } setValueHP(i); } } break; default: // Should not reach here, but leaving it a no-op in case // we later get the other events (should revisit code in // that case) break; } endUpdate(); } }); } private void fireStateChanged() { ChangeEvent e = null; for (Iterator iter = changeListeners.iterator(); iter.hasNext(); ) { ChangeListener l = (ChangeListener) iter.next(); if (e == null) { e = new ChangeEvent(this); } l.stateChanged(e); } } public static void main(String[] args) { JFrame frame = new JFrame(); frame.setSize(300, 300); // 32-bit version /* HighPrecisionJScrollBar hpsb = new HighPrecisionJScrollBar( JScrollBar.VERTICAL, new BigInteger(1, new byte[] { (byte) 0x80, (byte) 0x00, (byte) 0x00, (byte) 0x00}), new BigInteger(1, new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00}), new BigInteger(1, new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF})); hpsb.setUnitIncrementHP(new BigInteger(1, new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x01})); hpsb.setBlockIncrementHP(new BigInteger(1, new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x10})); */ // 64-bit version HighPrecisionJScrollBar hpsb = new HighPrecisionJScrollBar( JScrollBar.VERTICAL, new BigInteger(1, new byte[] { (byte) 0x80, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00}), new BigInteger(1, new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00}), new BigInteger(1, new byte[] { (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF})); hpsb.setUnitIncrementHP(new BigInteger(1, new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x01})); hpsb.setBlockIncrementHP(new BigInteger(1, new byte[] { (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x10})); hpsb.addChangeListener(new ChangeListener() { public void stateChanged(ChangeEvent e) { HighPrecisionJScrollBar h = (HighPrecisionJScrollBar) e.getSource(); System.out.println("New value = 0x" + h.getValueHP().toString(16)); } }); frame.getContentPane().add(hpsb); frame.setVisible(true); } }