mirror of
https://github.com/openjdk/jdk.git
synced 2026-05-07 12:14:55 +00:00
769 lines
29 KiB
Java
769 lines
29 KiB
Java
/*
|
|
* Copyright (c) 2004, 2013, 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. Oracle designates this
|
|
* particular file as subject to the "Classpath" exception as provided
|
|
* by Oracle in the LICENSE file that accompanied this code.
|
|
*
|
|
* 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.tools.jconsole;
|
|
|
|
import java.awt.*;
|
|
import java.awt.event.*;
|
|
import java.io.*;
|
|
import java.lang.management.*;
|
|
import java.lang.reflect.*;
|
|
import java.util.*;
|
|
import java.util.concurrent.*;
|
|
|
|
import javax.accessibility.*;
|
|
import javax.management.*;
|
|
import javax.management.openmbean.CompositeData;
|
|
import javax.swing.*;
|
|
import javax.swing.border.*;
|
|
|
|
|
|
import static sun.tools.jconsole.Formatter.*;
|
|
import static sun.tools.jconsole.Utilities.*;
|
|
|
|
@SuppressWarnings("serial")
|
|
class MemoryTab extends Tab implements ActionListener, ItemListener {
|
|
JComboBox<Plotter> plotterChoice;
|
|
TimeComboBox timeComboBox;
|
|
JButton gcButton;
|
|
|
|
PlotterPanel plotterPanel;
|
|
JPanel bottomPanel;
|
|
HTMLPane details;
|
|
PoolChart poolChart;
|
|
|
|
ArrayList<Plotter> plotterList;
|
|
Plotter heapPlotter, nonHeapPlotter;
|
|
|
|
private MemoryOverviewPanel overviewPanel;
|
|
|
|
private static final String usedKey = "used";
|
|
private static final String committedKey = "committed";
|
|
private static final String maxKey = "max";
|
|
private static final String thresholdKey = "threshold";
|
|
private static final Color usedColor = Plotter.defaultColor;
|
|
private static final Color committedColor = null;
|
|
private static final Color maxColor = null;
|
|
private static final Color thresholdColor = Color.red;
|
|
|
|
/*
|
|
Hierarchy of panels and layouts for this tab:
|
|
|
|
MemoryTab (BorderLayout)
|
|
|
|
North: topPanel (BorderLayout)
|
|
|
|
Center: controlPanel (FlowLayout)
|
|
plotterChoice, timeComboBox
|
|
|
|
East: topRightPanel (FlowLayout)
|
|
gcButton
|
|
|
|
Center: plotterPanel
|
|
|
|
Center: plotter
|
|
|
|
South: bottomPanel (BorderLayout)
|
|
|
|
Center: details
|
|
East: poolChart
|
|
*/
|
|
|
|
|
|
public static String getTabName() {
|
|
return Messages.MEMORY;
|
|
}
|
|
|
|
public MemoryTab(VMPanel vmPanel) {
|
|
super(vmPanel, getTabName());
|
|
|
|
setLayout(new BorderLayout(0, 0));
|
|
setBorder(new EmptyBorder(4, 4, 3, 4));
|
|
|
|
JPanel topPanel = new JPanel(new BorderLayout());
|
|
plotterPanel = new PlotterPanel(null);
|
|
bottomPanel = new JPanel(new BorderLayout());
|
|
|
|
add(topPanel, BorderLayout.NORTH);
|
|
add(plotterPanel, BorderLayout.CENTER);
|
|
|
|
JPanel controlPanel = new JPanel(new FlowLayout(FlowLayout.LEADING, 20, 5));
|
|
topPanel.add(controlPanel, BorderLayout.CENTER);
|
|
|
|
// Plotter choice
|
|
plotterChoice = new JComboBox<Plotter>();
|
|
plotterChoice.addItemListener(this);
|
|
controlPanel.add(new LabeledComponent(Messages.CHART_COLON,
|
|
Resources.getMnemonicInt(Messages.CHART_COLON),
|
|
plotterChoice));
|
|
|
|
// Range control
|
|
timeComboBox = new TimeComboBox();
|
|
controlPanel.add(new LabeledComponent(Messages.TIME_RANGE_COLON,
|
|
Resources.getMnemonicInt(Messages.TIME_RANGE_COLON),
|
|
timeComboBox));
|
|
|
|
gcButton = new JButton(Messages.PERFORM_GC);
|
|
gcButton.setMnemonic(Resources.getMnemonicInt(Messages.PERFORM_GC));
|
|
gcButton.addActionListener(this);
|
|
gcButton.setToolTipText(Messages.PERFORM_GC_TOOLTIP);
|
|
JPanel topRightPanel = new JPanel();
|
|
topRightPanel.setBorder(new EmptyBorder(0, 65-8, 0, 70));
|
|
topRightPanel.add(gcButton);
|
|
topPanel.add(topRightPanel, BorderLayout.AFTER_LINE_ENDS);
|
|
|
|
bottomPanel.setBorder(new CompoundBorder(new TitledBorder(Messages.DETAILS),
|
|
new EmptyBorder(10, 10, 10, 10)));
|
|
|
|
details = new HTMLPane();
|
|
setAccessibleName(details, Messages.DETAILS);
|
|
bottomPanel.add(new JScrollPane(details), BorderLayout.CENTER);
|
|
|
|
poolChart = new PoolChart();
|
|
bottomPanel.add(poolChart, BorderLayout.AFTER_LINE_ENDS);
|
|
}
|
|
|
|
|
|
private void createPlotters() throws IOException {
|
|
plotterList = new ArrayList<Plotter>();
|
|
|
|
ProxyClient proxyClient = vmPanel.getProxyClient();
|
|
|
|
heapPlotter = new Plotter(Plotter.Unit.BYTES) {
|
|
public String toString() {
|
|
return Messages.HEAP_MEMORY_USAGE;
|
|
}
|
|
};
|
|
proxyClient.addWeakPropertyChangeListener(heapPlotter);
|
|
|
|
nonHeapPlotter = new Plotter(Plotter.Unit.BYTES) {
|
|
public String toString() {
|
|
return Messages.NON_HEAP_MEMORY_USAGE;
|
|
}
|
|
};
|
|
|
|
setAccessibleName(heapPlotter,
|
|
Messages.MEMORY_TAB_HEAP_PLOTTER_ACCESSIBLE_NAME);
|
|
setAccessibleName(nonHeapPlotter,
|
|
Messages.MEMORY_TAB_NON_HEAP_PLOTTER_ACCESSIBLE_NAME);
|
|
|
|
proxyClient.addWeakPropertyChangeListener(nonHeapPlotter);
|
|
|
|
heapPlotter.createSequence(usedKey, Messages.USED, usedColor, true);
|
|
heapPlotter.createSequence(committedKey, Messages.COMMITTED, committedColor, false);
|
|
heapPlotter.createSequence(maxKey, Messages.MAX, maxColor, false);
|
|
|
|
nonHeapPlotter.createSequence(usedKey, Messages.USED, usedColor, true);
|
|
nonHeapPlotter.createSequence(committedKey, Messages.COMMITTED, committedColor, false);
|
|
nonHeapPlotter.createSequence(maxKey, Messages.MAX, maxColor, false);
|
|
|
|
plotterList.add(heapPlotter);
|
|
plotterList.add(nonHeapPlotter);
|
|
|
|
// Now add memory pools
|
|
Map<ObjectName, MBeanInfo> mBeanMap = proxyClient.getMBeans("java.lang");
|
|
Set<ObjectName> keys = mBeanMap.keySet();
|
|
ObjectName[] objectNames = keys.toArray(new ObjectName[keys.size()]);
|
|
ArrayList<PoolPlotter> nonHeapPlotters = new ArrayList<PoolPlotter>(2);
|
|
for (ObjectName objectName : objectNames) {
|
|
String type = objectName.getKeyProperty("type");
|
|
if (type.equals("MemoryPool")) {
|
|
String name = Resources.format(Messages.MEMORY_POOL_LABEL,
|
|
objectName.getKeyProperty("name"));
|
|
// Heap or non-heap?
|
|
boolean isHeap = false;
|
|
AttributeList al =
|
|
proxyClient.getAttributes(objectName,
|
|
new String[] { "Type" });
|
|
if (al.size() > 0) {
|
|
isHeap = MemoryType.HEAP.name().equals(((Attribute)al.get(0)).getValue());
|
|
}
|
|
PoolPlotter poolPlotter = new PoolPlotter(objectName, name, isHeap);
|
|
proxyClient.addWeakPropertyChangeListener(poolPlotter);
|
|
|
|
poolPlotter.createSequence(usedKey, Messages.USED, usedColor, true);
|
|
poolPlotter.createSequence(committedKey, Messages.COMMITTED, committedColor, false);
|
|
poolPlotter.createSequence(maxKey, Messages.MAX, maxColor, false);
|
|
poolPlotter.createSequence(thresholdKey, Messages.THRESHOLD, thresholdColor, false);
|
|
poolPlotter.setUseDashedTransitions(thresholdKey, true);
|
|
|
|
if (isHeap) {
|
|
plotterList.add(poolPlotter);
|
|
} else {
|
|
// Will be added to plotterList below
|
|
nonHeapPlotters.add(poolPlotter);
|
|
}
|
|
}
|
|
}
|
|
// Add non-heap plotters last
|
|
for (PoolPlotter poolPlotter : nonHeapPlotters) {
|
|
plotterList.add(poolPlotter);
|
|
}
|
|
}
|
|
|
|
|
|
public void itemStateChanged(ItemEvent ev) {
|
|
if (ev.getStateChange() == ItemEvent.SELECTED) {
|
|
Plotter plotter = (Plotter)plotterChoice.getSelectedItem();
|
|
plotterPanel.setPlotter(plotter);
|
|
plotterPanel.repaint();
|
|
}
|
|
}
|
|
|
|
public void gc() {
|
|
new Thread("MemoryPanel.gc") {
|
|
public void run() {
|
|
ProxyClient proxyClient = vmPanel.getProxyClient();
|
|
try {
|
|
proxyClient.getMemoryMXBean().gc();
|
|
} catch (UndeclaredThrowableException e) {
|
|
proxyClient.markAsDead();
|
|
} catch (IOException e) {
|
|
// Ignore
|
|
}
|
|
}
|
|
}.start();
|
|
}
|
|
|
|
public SwingWorker<?, ?> newSwingWorker() {
|
|
return new SwingWorker<Boolean, Object>() {
|
|
private long[] used, committed, max, threshold;
|
|
private long timeStamp;
|
|
private String detailsStr;
|
|
private boolean initialRun = false;
|
|
|
|
public Boolean doInBackground() {
|
|
ProxyClient proxyClient = vmPanel.getProxyClient();
|
|
|
|
if (plotterList == null) {
|
|
try {
|
|
createPlotters();
|
|
} catch (UndeclaredThrowableException e) {
|
|
proxyClient.markAsDead();
|
|
return false;
|
|
} catch (final IOException ex) {
|
|
return false;
|
|
}
|
|
initialRun = true;
|
|
}
|
|
|
|
int n = plotterList.size();
|
|
used = new long[n];
|
|
committed = new long[n];
|
|
max = new long[n];
|
|
threshold = new long[n];
|
|
timeStamp = System.currentTimeMillis();
|
|
|
|
for (int i = 0; i < n; i++) {
|
|
Plotter plotter = plotterList.get(i);
|
|
MemoryUsage mu = null;
|
|
used[i] = -1L;
|
|
threshold[i] = -1L;
|
|
|
|
try {
|
|
if (plotter instanceof PoolPlotter) {
|
|
PoolPlotter poolPlotter = (PoolPlotter)plotter;
|
|
ObjectName objectName = poolPlotter.objectName;
|
|
AttributeList al =
|
|
proxyClient.getAttributes(objectName,
|
|
new String[] { "Usage", "UsageThreshold" });
|
|
if (al.size() > 0) {
|
|
CompositeData cd = (CompositeData)((Attribute)al.get(0)).getValue();
|
|
mu = MemoryUsage.from(cd);
|
|
|
|
if (al.size() > 1) {
|
|
threshold[i] = (Long)((Attribute)al.get(1)).getValue();
|
|
}
|
|
}
|
|
} else if (plotter == heapPlotter) {
|
|
mu = proxyClient.getMemoryMXBean().getHeapMemoryUsage();
|
|
} else if (plotter == nonHeapPlotter) {
|
|
mu = proxyClient.getMemoryMXBean().getNonHeapMemoryUsage();
|
|
}
|
|
} catch (UndeclaredThrowableException e) {
|
|
proxyClient.markAsDead();
|
|
return false;
|
|
} catch (IOException ex) {
|
|
// Skip this plotter
|
|
}
|
|
|
|
if (mu != null) {
|
|
used[i] = mu.getUsed();
|
|
committed[i] = mu.getCommitted();
|
|
max[i] = mu.getMax();
|
|
}
|
|
}
|
|
detailsStr = formatDetails();
|
|
|
|
return true;
|
|
}
|
|
|
|
protected void done() {
|
|
try {
|
|
if (!get()) {
|
|
return;
|
|
}
|
|
} catch (InterruptedException ex) {
|
|
return;
|
|
} catch (ExecutionException ex) {
|
|
if (JConsole.isDebug()) {
|
|
ex.printStackTrace();
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (initialRun) {
|
|
// Add Memory Pools
|
|
for (Plotter p : plotterList) {
|
|
plotterChoice.addItem(p);
|
|
timeComboBox.addPlotter(p);
|
|
}
|
|
add(bottomPanel, BorderLayout.SOUTH);
|
|
}
|
|
|
|
|
|
int n = plotterList.size();
|
|
int poolCount = 0;
|
|
|
|
for (int i = 0; i < n; i++) {
|
|
Plotter plotter = plotterList.get(i);
|
|
if (used[i] >= 0L) {
|
|
if (plotter instanceof PoolPlotter) {
|
|
plotter.addValues(timeStamp, used[i], committed[i], max[i], threshold[i]);
|
|
if (threshold[i] > 0L) {
|
|
plotter.setIsPlotted(thresholdKey, true);
|
|
}
|
|
poolChart.setValue(poolCount++, (PoolPlotter)plotter,
|
|
used[i], threshold[i], max[i]);
|
|
} else {
|
|
plotter.addValues(timeStamp, used[i], committed[i], max[i]);
|
|
}
|
|
|
|
if (plotter == heapPlotter && overviewPanel != null) {
|
|
overviewPanel.getPlotter().addValues(timeStamp, used[i]);
|
|
overviewPanel.updateMemoryInfo(used[i], committed[i], max[i]);
|
|
}
|
|
}
|
|
}
|
|
details.setText(detailsStr);
|
|
}
|
|
};
|
|
}
|
|
|
|
private String formatDetails() {
|
|
ProxyClient proxyClient = vmPanel.getProxyClient();
|
|
if (proxyClient.isDead()) {
|
|
return "";
|
|
}
|
|
|
|
String text = "<table cellspacing=0 cellpadding=0>";
|
|
|
|
Plotter plotter = (Plotter)plotterChoice.getSelectedItem();
|
|
if (plotter == null) {
|
|
return "";
|
|
}
|
|
|
|
//long time = plotter.getLastTimeStamp();
|
|
long time = System.currentTimeMillis();
|
|
String timeStamp = formatDateTime(time);
|
|
text += newRow(Messages.TIME, timeStamp);
|
|
|
|
long used = plotter.getLastValue(usedKey);
|
|
long committed = plotter.getLastValue(committedKey);
|
|
long max = plotter.getLastValue(maxKey);
|
|
long threshold = plotter.getLastValue(thresholdKey);
|
|
|
|
text += newRow(Messages.USED, formatKBytes(used));
|
|
if (committed > 0L) {
|
|
text += newRow(Messages.COMMITTED, formatKBytes(committed));
|
|
}
|
|
if (max > 0L) {
|
|
text += newRow(Messages.MAX, formatKBytes(max));
|
|
}
|
|
if (threshold > 0L) {
|
|
text += newRow(Messages.USAGE_THRESHOLD, formatKBytes(threshold));
|
|
}
|
|
|
|
try {
|
|
Collection<GarbageCollectorMXBean> garbageCollectors =
|
|
proxyClient.getGarbageCollectorMXBeans();
|
|
|
|
boolean descPrinted = false;
|
|
for (GarbageCollectorMXBean garbageCollectorMBean : garbageCollectors) {
|
|
String gcName = garbageCollectorMBean.getName();
|
|
long gcCount = garbageCollectorMBean.getCollectionCount();
|
|
long gcTime = garbageCollectorMBean.getCollectionTime();
|
|
String str = Resources.format(Messages.GC_TIME_DETAILS, justify(formatTime(gcTime), 14),
|
|
gcName,
|
|
String.format("%,d",gcCount));
|
|
if (!descPrinted) {
|
|
text += newRow(Messages.GC_TIME, str);
|
|
descPrinted = true;
|
|
} else {
|
|
text += newRow(null, str);
|
|
}
|
|
}
|
|
} catch (IOException e) {
|
|
}
|
|
|
|
return text;
|
|
}
|
|
|
|
public void actionPerformed(ActionEvent ev) {
|
|
Object src = ev.getSource();
|
|
if (src == gcButton) {
|
|
gc();
|
|
}
|
|
}
|
|
|
|
private class PoolPlotter extends Plotter {
|
|
ObjectName objectName;
|
|
String name;
|
|
boolean isHeap;
|
|
long value, threshold, max;
|
|
int barX;
|
|
|
|
public PoolPlotter(ObjectName objectName, String name, boolean isHeap) {
|
|
super(Plotter.Unit.BYTES);
|
|
|
|
this.objectName = objectName;
|
|
this.name = name;
|
|
this.isHeap = isHeap;
|
|
|
|
setAccessibleName(this,
|
|
Resources.format(Messages.MEMORY_TAB_POOL_PLOTTER_ACCESSIBLE_NAME,
|
|
name));
|
|
}
|
|
|
|
|
|
public String toString() {
|
|
return name;
|
|
}
|
|
}
|
|
|
|
private class PoolChart extends BorderedComponent
|
|
implements Accessible, MouseListener {
|
|
final int height = 150;
|
|
final int leftMargin = 50;
|
|
final int rightMargin = 23;
|
|
final int bottomMargin = 35;
|
|
final int barWidth = 22;
|
|
final int barGap = 3;
|
|
final int groupGap = 8;
|
|
final int barHeight = height * 2 / 3;
|
|
|
|
final Color greenBar = new Color(100, 255, 100);
|
|
final Color greenBarBackground = new Color(210, 255, 210);
|
|
final Color redBarBackground = new Color(255, 210, 210);
|
|
|
|
Font smallFont = null;
|
|
|
|
ArrayList<PoolPlotter> poolPlotters = new ArrayList<PoolPlotter>(5);
|
|
|
|
int nHeapPools = 0;
|
|
int nNonHeapPools = 0;
|
|
Rectangle heapRect = new Rectangle(leftMargin, height - bottomMargin + 6, barWidth, 20);
|
|
Rectangle nonHeapRect = new Rectangle(leftMargin + groupGap, height - bottomMargin + 6, barWidth, 20);
|
|
|
|
public PoolChart() {
|
|
super(null, null);
|
|
|
|
setFocusable(true);
|
|
addMouseListener(this);
|
|
ToolTipManager.sharedInstance().registerComponent(this);
|
|
}
|
|
|
|
public void setValue(int poolIndex, PoolPlotter poolPlotter,
|
|
long value, long threshold, long max) {
|
|
poolPlotter.value = value;
|
|
poolPlotter.threshold = threshold;
|
|
poolPlotter.max = max;
|
|
|
|
if (poolIndex == poolPlotters.size()) {
|
|
poolPlotters.add(poolPlotter);
|
|
if (poolPlotter.isHeap) {
|
|
poolPlotter.barX = nHeapPools * (barWidth + barGap);
|
|
nHeapPools++;
|
|
heapRect.width = nHeapPools * barWidth + (nHeapPools - 1) * barGap;
|
|
nonHeapRect.x = leftMargin + heapRect.width + groupGap;
|
|
} else {
|
|
poolPlotter.barX = nonHeapRect.x - leftMargin + nNonHeapPools * (barWidth + barGap);
|
|
nNonHeapPools++;
|
|
nonHeapRect.width = nNonHeapPools * barWidth + (nNonHeapPools - 1) * barGap;
|
|
}
|
|
} else {
|
|
poolPlotters.set(poolIndex, poolPlotter);
|
|
}
|
|
repaint();
|
|
}
|
|
|
|
private void paintPoolBar(Graphics g, PoolPlotter poolPlotter) {
|
|
Rectangle barRect = getBarRect(poolPlotter);
|
|
g.setColor(Color.gray);
|
|
g.drawRect(barRect.x, barRect.y, barRect.width, barRect.height);
|
|
|
|
long value = poolPlotter.value;
|
|
long max = poolPlotter.max;
|
|
if (max > 0L) {
|
|
g.translate(barRect.x, barRect.y);
|
|
|
|
// Paint green background
|
|
g.setColor(greenBarBackground);
|
|
g.fillRect(1, 1, barRect.width - 1, barRect.height - 1);
|
|
|
|
int greenHeight = (int)(value * barRect.height / max);
|
|
long threshold = poolPlotter.threshold;
|
|
if (threshold > 0L) {
|
|
int redHeight = (int)(threshold * barRect.height / max);
|
|
|
|
// Paint red background
|
|
g.setColor(redBarBackground);
|
|
g.fillRect(1, 1, barRect.width - 1, barRect.height - redHeight);
|
|
|
|
if (value > threshold) {
|
|
// Over threshold, paint red bar
|
|
g.setColor(thresholdColor);
|
|
g.fillRect(1, barRect.height - greenHeight,
|
|
barRect.width - 1, greenHeight - redHeight);
|
|
greenHeight = redHeight;
|
|
}
|
|
}
|
|
|
|
// Paint green bar
|
|
g.setColor(greenBar);
|
|
g.fillRect(1, barRect.height - greenHeight,
|
|
barRect.width - 1, greenHeight);
|
|
|
|
g.translate(-barRect.x, -barRect.y);
|
|
}
|
|
}
|
|
|
|
public void paintComponent(Graphics g) {
|
|
super.paintComponent(g);
|
|
|
|
if (poolPlotters.size() == 0) {
|
|
return;
|
|
}
|
|
|
|
if (smallFont == null) {
|
|
smallFont = g.getFont().deriveFont(9.0F);
|
|
}
|
|
|
|
// Paint background for chart area
|
|
g.setColor(getBackground());
|
|
Rectangle r = g.getClipBounds();
|
|
g.fillRect(r.x, r.y, r.width, r.height);
|
|
|
|
g.setFont(smallFont);
|
|
FontMetrics fm = g.getFontMetrics();
|
|
int fontDescent = fm.getDescent();
|
|
|
|
// Paint percentage axis
|
|
g.setColor(getForeground());
|
|
for (int pc : new int[] { 0, 25, 50, 75, 100 }) {
|
|
String str = pc + "% --";
|
|
g.drawString(str,
|
|
leftMargin - fm.stringWidth(str) - 4,
|
|
height - bottomMargin - (pc * barHeight / 100) + fontDescent + 1);
|
|
}
|
|
|
|
for (PoolPlotter poolPlotter : poolPlotters) {
|
|
paintPoolBar(g, poolPlotter);
|
|
}
|
|
|
|
g.setColor(Color.gray);
|
|
g.drawRect(heapRect.x, heapRect.y, heapRect.width, heapRect.height);
|
|
g.drawRect(nonHeapRect.x, nonHeapRect.y, nonHeapRect.width, nonHeapRect.height);
|
|
|
|
Color heapColor = greenBar;
|
|
Color nonHeapColor = greenBar;
|
|
|
|
|
|
for (PoolPlotter poolPlotter : poolPlotters) {
|
|
if (poolPlotter.threshold > 0L && poolPlotter.value > poolPlotter.threshold) {
|
|
if (poolPlotter.isHeap) {
|
|
heapColor = thresholdColor;
|
|
} else {
|
|
nonHeapColor = thresholdColor;
|
|
}
|
|
}
|
|
}
|
|
g.setColor(heapColor);
|
|
g.fillRect(heapRect.x + 1, heapRect.y + 1, heapRect.width - 1, heapRect.height - 1);
|
|
g.setColor(nonHeapColor);
|
|
g.fillRect(nonHeapRect.x + 1, nonHeapRect.y + 1, nonHeapRect.width - 1, nonHeapRect.height - 1);
|
|
|
|
String str = Messages.HEAP;
|
|
int stringWidth = fm.stringWidth(str);
|
|
int x = heapRect.x + (heapRect.width - stringWidth) / 2;
|
|
int y = heapRect.y + heapRect.height - 6;
|
|
g.setColor(Color.white);
|
|
g.drawString(str, x-1, y-1);
|
|
g.drawString(str, x+1, y-1);
|
|
g.drawString(str, x-1, y+1);
|
|
g.drawString(str, x+1, y+1);
|
|
g.setColor(Color.black);
|
|
g.drawString(str, x, y);
|
|
|
|
str = Messages.NON_HEAP;
|
|
stringWidth = fm.stringWidth(str);
|
|
x = nonHeapRect.x + (nonHeapRect.width - stringWidth) / 2;
|
|
y = nonHeapRect.y + nonHeapRect.height - 6;
|
|
g.setColor(Color.white);
|
|
g.drawString(str, x-1, y-1);
|
|
g.drawString(str, x+1, y-1);
|
|
g.drawString(str, x-1, y+1);
|
|
g.drawString(str, x+1, y+1);
|
|
g.setColor(Color.black);
|
|
g.drawString(str, x, y);
|
|
|
|
// Highlight current plotter
|
|
g.setColor(Color.blue);
|
|
r = null;
|
|
Plotter plotter = (Plotter)plotterChoice.getSelectedItem();
|
|
if (plotter == heapPlotter) {
|
|
r = heapRect;
|
|
} else if (plotter == nonHeapPlotter) {
|
|
r = nonHeapRect;
|
|
} else if (plotter instanceof PoolPlotter) {
|
|
r = getBarRect((PoolPlotter)plotter);
|
|
}
|
|
if (r != null) {
|
|
g.drawRect(r.x - 1, r.y - 1, r.width + 2, r.height + 2);
|
|
}
|
|
}
|
|
|
|
private Rectangle getBarRect(PoolPlotter poolPlotter) {
|
|
return new Rectangle(leftMargin + poolPlotter.barX,
|
|
height - bottomMargin - barHeight,
|
|
barWidth, barHeight);
|
|
}
|
|
|
|
public Dimension getPreferredSize() {
|
|
return new Dimension(nonHeapRect.x + nonHeapRect.width + rightMargin,
|
|
height);
|
|
}
|
|
|
|
public void mouseClicked(MouseEvent e) {
|
|
requestFocusInWindow();
|
|
Plotter plotter = getPlotter(e);
|
|
|
|
if (plotter != null && plotter != plotterChoice.getSelectedItem()) {
|
|
plotterChoice.setSelectedItem(plotter);
|
|
repaint();
|
|
}
|
|
}
|
|
|
|
public String getToolTipText(MouseEvent e) {
|
|
Plotter plotter = getPlotter(e);
|
|
|
|
return (plotter != null) ? plotter.toString() : null;
|
|
}
|
|
|
|
private Plotter getPlotter(MouseEvent e) {
|
|
Point p = e.getPoint();
|
|
Plotter plotter = null;
|
|
|
|
if (heapRect.contains(p)) {
|
|
plotter = heapPlotter;
|
|
} else if (nonHeapRect.contains(p)) {
|
|
plotter = nonHeapPlotter;
|
|
} else {
|
|
for (PoolPlotter poolPlotter : poolPlotters) {
|
|
if (getBarRect(poolPlotter).contains(p)) {
|
|
plotter = poolPlotter;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return plotter;
|
|
}
|
|
|
|
public void mousePressed(MouseEvent e) {}
|
|
public void mouseReleased(MouseEvent e) {}
|
|
public void mouseEntered(MouseEvent e) {}
|
|
public void mouseExited(MouseEvent e) {}
|
|
|
|
|
|
public AccessibleContext getAccessibleContext() {
|
|
if (accessibleContext == null) {
|
|
accessibleContext = new AccessiblePoolChart();
|
|
}
|
|
return accessibleContext;
|
|
}
|
|
|
|
protected class AccessiblePoolChart extends AccessibleJPanel {
|
|
public String getAccessibleName() {
|
|
String name = Messages.MEMORY_TAB_POOL_CHART_ACCESSIBLE_NAME;
|
|
|
|
String keyValueList = "";
|
|
for (PoolPlotter poolPlotter : poolPlotters) {
|
|
String value = (poolPlotter.value * 100 / poolPlotter.max) + "%";
|
|
// Assume format string ends with newline
|
|
keyValueList +=
|
|
Resources.format(Messages.PLOTTER_ACCESSIBLE_NAME_KEY_AND_VALUE,
|
|
poolPlotter.toString(), value);
|
|
if (poolPlotter.threshold > 0L) {
|
|
String threshold =
|
|
(poolPlotter.threshold * 100 / poolPlotter.max) + "%";
|
|
if (poolPlotter.value > poolPlotter.threshold) {
|
|
keyValueList +=
|
|
Resources.format(Messages.MEMORY_TAB_POOL_CHART_ABOVE_THRESHOLD,
|
|
threshold);
|
|
} else {
|
|
keyValueList +=
|
|
Resources.format(Messages.MEMORY_TAB_POOL_CHART_BELOW_THRESHOLD,
|
|
threshold);
|
|
}
|
|
}
|
|
}
|
|
|
|
return name + "\n" + keyValueList + ".";
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
OverviewPanel[] getOverviewPanels() {
|
|
if (overviewPanel == null) {
|
|
overviewPanel = new MemoryOverviewPanel();
|
|
}
|
|
return new OverviewPanel[] { overviewPanel };
|
|
}
|
|
|
|
private static class MemoryOverviewPanel extends OverviewPanel {
|
|
MemoryOverviewPanel() {
|
|
super(Messages.HEAP_MEMORY_USAGE, usedKey, Messages.USED, Plotter.Unit.BYTES);
|
|
}
|
|
|
|
private void updateMemoryInfo(long used, long committed, long max) {
|
|
getInfoLabel().setText(Resources.format(Messages.MEMORY_TAB_INFO_LABEL_FORMAT,
|
|
formatBytes(used, true),
|
|
formatBytes(committed, true),
|
|
formatBytes(max, true)));
|
|
}
|
|
}
|
|
}
|