| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.ddmuilib; |
| |
| import com.android.ddmlib.Client; |
| import com.android.ddmlib.ClientData; |
| import com.android.ddmlib.Log; |
| import com.android.ddmlib.AndroidDebugBridge.IClientChangeListener; |
| import com.android.ddmlib.HeapSegment.HeapSegmentElement; |
| |
| import org.eclipse.jface.preference.IPreferenceStore; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.SWTException; |
| import org.eclipse.swt.custom.StackLayout; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.graphics.Color; |
| import org.eclipse.swt.graphics.Font; |
| import org.eclipse.swt.graphics.FontData; |
| import org.eclipse.swt.graphics.GC; |
| import org.eclipse.swt.graphics.Image; |
| import org.eclipse.swt.graphics.ImageData; |
| import org.eclipse.swt.graphics.PaletteData; |
| import org.eclipse.swt.graphics.Point; |
| import org.eclipse.swt.graphics.RGB; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Combo; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Control; |
| import org.eclipse.swt.widgets.Display; |
| import org.eclipse.swt.widgets.Group; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Table; |
| import org.eclipse.swt.widgets.TableColumn; |
| import org.eclipse.swt.widgets.TableItem; |
| import org.jfree.chart.ChartFactory; |
| import org.jfree.chart.JFreeChart; |
| import org.jfree.chart.axis.CategoryAxis; |
| import org.jfree.chart.axis.CategoryLabelPositions; |
| import org.jfree.chart.labels.CategoryToolTipGenerator; |
| import org.jfree.chart.plot.CategoryPlot; |
| import org.jfree.chart.plot.Plot; |
| import org.jfree.chart.plot.PlotOrientation; |
| import org.jfree.chart.renderer.category.CategoryItemRenderer; |
| import org.jfree.chart.title.TextTitle; |
| import org.jfree.data.category.CategoryDataset; |
| import org.jfree.data.category.DefaultCategoryDataset; |
| import org.jfree.experimental.chart.swt.ChartComposite; |
| import org.jfree.experimental.swt.SWTUtils; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.text.NumberFormat; |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.Set; |
| |
| |
| /** |
| * Base class for our information panels. |
| */ |
| public final class HeapPanel extends BaseHeapPanel { |
| private static final String PREFS_STATS_COL_TYPE = "heapPanel.col0"; //$NON-NLS-1$ |
| private static final String PREFS_STATS_COL_COUNT = "heapPanel.col1"; //$NON-NLS-1$ |
| private static final String PREFS_STATS_COL_SIZE = "heapPanel.col2"; //$NON-NLS-1$ |
| private static final String PREFS_STATS_COL_SMALLEST = "heapPanel.col3"; //$NON-NLS-1$ |
| private static final String PREFS_STATS_COL_LARGEST = "heapPanel.col4"; //$NON-NLS-1$ |
| private static final String PREFS_STATS_COL_MEDIAN = "heapPanel.col5"; //$NON-NLS-1$ |
| private static final String PREFS_STATS_COL_AVERAGE = "heapPanel.col6"; //$NON-NLS-1$ |
| |
| /* args to setUpdateStatus() */ |
| private static final int NOT_SELECTED = 0; |
| private static final int NOT_ENABLED = 1; |
| private static final int ENABLED = 2; |
| |
| /** color palette and map legend. NATIVE is the last enum is a 0 based enum list, so we need |
| * Native+1 at least. We also need 2 more entries for free area and expansion area. */ |
| private static final int NUM_PALETTE_ENTRIES = HeapSegmentElement.KIND_NATIVE+2 +1; |
| private static final String[] mMapLegend = new String[NUM_PALETTE_ENTRIES]; |
| private static final PaletteData mMapPalette = createPalette(); |
| |
| private static final boolean DISPLAY_HEAP_BITMAP = false; |
| private static final boolean DISPLAY_HILBERT_BITMAP = false; |
| |
| private static final int PLACEHOLDER_HILBERT_SIZE = 200; |
| private static final int PLACEHOLDER_LINEAR_V_SIZE = 100; |
| private static final int PLACEHOLDER_LINEAR_H_SIZE = 300; |
| |
| private static final int[] ZOOMS = {100, 50, 25}; |
| |
| private static final NumberFormat sByteFormatter = NumberFormat.getInstance(); |
| private static final NumberFormat sLargeByteFormatter = NumberFormat.getInstance(); |
| private static final NumberFormat sCountFormatter = NumberFormat.getInstance(); |
| |
| static { |
| sByteFormatter.setMinimumFractionDigits(0); |
| sByteFormatter.setMaximumFractionDigits(1); |
| sLargeByteFormatter.setMinimumFractionDigits(3); |
| sLargeByteFormatter.setMaximumFractionDigits(3); |
| |
| sCountFormatter.setGroupingUsed(true); |
| } |
| |
| private Display mDisplay; |
| |
| private Composite mTop; // real top |
| private Label mUpdateStatus; |
| private Table mHeapSummary; |
| private Combo mDisplayMode; |
| |
| //private ScrolledComposite mScrolledComposite; |
| |
| private Composite mDisplayBase; // base of the displays. |
| private StackLayout mDisplayStack; |
| |
| private Composite mStatisticsBase; |
| private Table mStatisticsTable; |
| private JFreeChart mChart; |
| private ChartComposite mChartComposite; |
| private Button mGcButton; |
| private DefaultCategoryDataset mAllocCountDataSet; |
| |
| private Composite mLinearBase; |
| private Label mLinearHeapImage; |
| |
| private Composite mHilbertBase; |
| private Label mHilbertHeapImage; |
| private Group mLegend; |
| private Combo mZoom; |
| |
| /** Image used for the hilbert display. Since we recreate a new image every time, we |
| * keep this one around to dispose it. */ |
| private Image mHilbertImage; |
| private Image mLinearImage; |
| private Composite[] mLayout; |
| |
| /* |
| * Create color palette for map. Set up titles for legend. |
| */ |
| private static PaletteData createPalette() { |
| RGB colors[] = new RGB[NUM_PALETTE_ENTRIES]; |
| colors[0] |
| = new RGB(192, 192, 192); // non-heap pixels are gray |
| mMapLegend[0] |
| = "(heap expansion area)"; |
| |
| colors[1] |
| = new RGB(0, 0, 0); // free chunks are black |
| mMapLegend[1] |
| = "free"; |
| |
| colors[HeapSegmentElement.KIND_OBJECT + 2] |
| = new RGB(0, 0, 255); // objects are blue |
| mMapLegend[HeapSegmentElement.KIND_OBJECT + 2] |
| = "data object"; |
| |
| colors[HeapSegmentElement.KIND_CLASS_OBJECT + 2] |
| = new RGB(0, 255, 0); // class objects are green |
| mMapLegend[HeapSegmentElement.KIND_CLASS_OBJECT + 2] |
| = "class object"; |
| |
| colors[HeapSegmentElement.KIND_ARRAY_1 + 2] |
| = new RGB(255, 0, 0); // byte/bool arrays are red |
| mMapLegend[HeapSegmentElement.KIND_ARRAY_1 + 2] |
| = "1-byte array (byte[], boolean[])"; |
| |
| colors[HeapSegmentElement.KIND_ARRAY_2 + 2] |
| = new RGB(255, 128, 0); // short/char arrays are orange |
| mMapLegend[HeapSegmentElement.KIND_ARRAY_2 + 2] |
| = "2-byte array (short[], char[])"; |
| |
| colors[HeapSegmentElement.KIND_ARRAY_4 + 2] |
| = new RGB(255, 255, 0); // obj/int/float arrays are yellow |
| mMapLegend[HeapSegmentElement.KIND_ARRAY_4 + 2] |
| = "4-byte array (object[], int[], float[])"; |
| |
| colors[HeapSegmentElement.KIND_ARRAY_8 + 2] |
| = new RGB(255, 128, 128); // long/double arrays are pink |
| mMapLegend[HeapSegmentElement.KIND_ARRAY_8 + 2] |
| = "8-byte array (long[], double[])"; |
| |
| colors[HeapSegmentElement.KIND_UNKNOWN + 2] |
| = new RGB(255, 0, 255); // unknown objects are cyan |
| mMapLegend[HeapSegmentElement.KIND_UNKNOWN + 2] |
| = "unknown object"; |
| |
| colors[HeapSegmentElement.KIND_NATIVE + 2] |
| = new RGB(64, 64, 64); // native objects are dark gray |
| mMapLegend[HeapSegmentElement.KIND_NATIVE + 2] |
| = "non-Java object"; |
| |
| return new PaletteData(colors); |
| } |
| |
| /** |
| * Sent when an existing client information changed. |
| * <p/> |
| * This is sent from a non UI thread. |
| * @param client the updated client. |
| * @param changeMask the bit mask describing the changed properties. It can contain |
| * any of the following values: {@link Client#CHANGE_INFO}, {@link Client#CHANGE_NAME} |
| * {@link Client#CHANGE_DEBUGGER_INTEREST}, {@link Client#CHANGE_THREAD_MODE}, |
| * {@link Client#CHANGE_THREAD_DATA}, {@link Client#CHANGE_HEAP_MODE}, |
| * {@link Client#CHANGE_HEAP_DATA}, {@link Client#CHANGE_NATIVE_HEAP_DATA} |
| * |
| * @see IClientChangeListener#clientChanged(Client, int) |
| */ |
| public void clientChanged(final Client client, int changeMask) { |
| if (client == getCurrentClient()) { |
| if ((changeMask & Client.CHANGE_HEAP_MODE) == Client.CHANGE_HEAP_MODE || |
| (changeMask & Client.CHANGE_HEAP_DATA) == Client.CHANGE_HEAP_DATA) { |
| try { |
| mTop.getDisplay().asyncExec(new Runnable() { |
| public void run() { |
| clientSelected(); |
| } |
| }); |
| } catch (SWTException e) { |
| // display is disposed (app is quitting most likely), we do nothing. |
| } |
| } |
| } |
| } |
| |
| /** |
| * Sent when a new device is selected. The new device can be accessed |
| * with {@link #getCurrentDevice()} |
| */ |
| @Override |
| public void deviceSelected() { |
| // pass |
| } |
| |
| /** |
| * Sent when a new client is selected. The new client can be accessed |
| * with {@link #getCurrentClient()}. |
| */ |
| @Override |
| public void clientSelected() { |
| if (mTop.isDisposed()) |
| return; |
| |
| Client client = getCurrentClient(); |
| |
| Log.d("ddms", "HeapPanel: changed " + client); |
| |
| if (client != null) { |
| ClientData cd = client.getClientData(); |
| |
| if (client.isHeapUpdateEnabled()) { |
| mGcButton.setEnabled(true); |
| mDisplayMode.setEnabled(true); |
| setUpdateStatus(ENABLED); |
| } else { |
| setUpdateStatus(NOT_ENABLED); |
| mGcButton.setEnabled(false); |
| mDisplayMode.setEnabled(false); |
| } |
| |
| fillSummaryTable(cd); |
| |
| int mode = mDisplayMode.getSelectionIndex(); |
| if (mode == 0) { |
| fillDetailedTable(client, false /* forceRedraw */); |
| } else { |
| if (DISPLAY_HEAP_BITMAP) { |
| renderHeapData(cd, mode - 1, false /* forceRedraw */); |
| } |
| } |
| } else { |
| mGcButton.setEnabled(false); |
| mDisplayMode.setEnabled(false); |
| fillSummaryTable(null); |
| fillDetailedTable(null, true); |
| setUpdateStatus(NOT_SELECTED); |
| } |
| |
| // sizes of things change frequently, so redo layout |
| //mScrolledComposite.setMinSize(mDisplayStack.topControl.computeSize(SWT.DEFAULT, |
| // SWT.DEFAULT)); |
| mDisplayBase.layout(); |
| //mScrolledComposite.redraw(); |
| } |
| |
| /** |
| * Create our control(s). |
| */ |
| @Override |
| protected Control createControl(Composite parent) { |
| mDisplay = parent.getDisplay(); |
| |
| GridLayout gl; |
| |
| mTop = new Composite(parent, SWT.NONE); |
| mTop.setLayout(new GridLayout(1, false)); |
| mTop.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| mUpdateStatus = new Label(mTop, SWT.NONE); |
| setUpdateStatus(NOT_SELECTED); |
| |
| Composite summarySection = new Composite(mTop, SWT.NONE); |
| summarySection.setLayout(gl = new GridLayout(2, false)); |
| gl.marginHeight = gl.marginWidth = 0; |
| |
| mHeapSummary = createSummaryTable(summarySection); |
| mGcButton = new Button(summarySection, SWT.PUSH); |
| mGcButton.setText("Cause GC"); |
| mGcButton.setEnabled(false); |
| mGcButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| Client client = getCurrentClient(); |
| if (client != null) { |
| client.executeGarbageCollector(); |
| } |
| } |
| }); |
| |
| Composite comboSection = new Composite(mTop, SWT.NONE); |
| gl = new GridLayout(2, false); |
| gl.marginHeight = gl.marginWidth = 0; |
| comboSection.setLayout(gl); |
| |
| Label displayLabel = new Label(comboSection, SWT.NONE); |
| displayLabel.setText("Display: "); |
| |
| mDisplayMode = new Combo(comboSection, SWT.READ_ONLY); |
| mDisplayMode.setEnabled(false); |
| mDisplayMode.add("Stats"); |
| if (DISPLAY_HEAP_BITMAP) { |
| mDisplayMode.add("Linear"); |
| if (DISPLAY_HILBERT_BITMAP) { |
| mDisplayMode.add("Hilbert"); |
| } |
| } |
| |
| // the base of the displays. |
| mDisplayBase = new Composite(mTop, SWT.NONE); |
| mDisplayBase.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| mDisplayStack = new StackLayout(); |
| mDisplayBase.setLayout(mDisplayStack); |
| |
| // create the statistics display |
| mStatisticsBase = new Composite(mDisplayBase, SWT.NONE); |
| //mStatisticsBase.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| mStatisticsBase.setLayout(gl = new GridLayout(1, false)); |
| gl.marginHeight = gl.marginWidth = 0; |
| mDisplayStack.topControl = mStatisticsBase; |
| |
| mStatisticsTable = createDetailedTable(mStatisticsBase); |
| mStatisticsTable.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| createChart(); |
| |
| //create the linear composite |
| mLinearBase = new Composite(mDisplayBase, SWT.NONE); |
| //mLinearBase.setLayoutData(new GridData()); |
| gl = new GridLayout(1, false); |
| gl.marginHeight = gl.marginWidth = 0; |
| mLinearBase.setLayout(gl); |
| |
| { |
| mLinearHeapImage = new Label(mLinearBase, SWT.NONE); |
| mLinearHeapImage.setLayoutData(new GridData()); |
| mLinearHeapImage.setImage(ImageHelper.createPlaceHolderArt(mDisplay, |
| PLACEHOLDER_LINEAR_H_SIZE, PLACEHOLDER_LINEAR_V_SIZE, |
| mDisplay.getSystemColor(SWT.COLOR_BLUE))); |
| |
| // create a composite to contain the bottom part (legend) |
| Composite bottomSection = new Composite(mLinearBase, SWT.NONE); |
| gl = new GridLayout(1, false); |
| gl.marginHeight = gl.marginWidth = 0; |
| bottomSection.setLayout(gl); |
| |
| createLegend(bottomSection); |
| } |
| |
| /* |
| mScrolledComposite = new ScrolledComposite(mTop, SWT.H_SCROLL | SWT.V_SCROLL); |
| mScrolledComposite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| mScrolledComposite.setExpandHorizontal(true); |
| mScrolledComposite.setExpandVertical(true); |
| mScrolledComposite.setContent(mDisplayBase); |
| */ |
| |
| |
| // create the hilbert display. |
| mHilbertBase = new Composite(mDisplayBase, SWT.NONE); |
| //mHilbertBase.setLayoutData(new GridData()); |
| gl = new GridLayout(2, false); |
| gl.marginHeight = gl.marginWidth = 0; |
| mHilbertBase.setLayout(gl); |
| |
| if (DISPLAY_HILBERT_BITMAP) { |
| mHilbertHeapImage = new Label(mHilbertBase, SWT.NONE); |
| mHilbertHeapImage.setLayoutData(new GridData()); |
| mHilbertHeapImage.setImage(ImageHelper.createPlaceHolderArt(mDisplay, |
| PLACEHOLDER_HILBERT_SIZE, PLACEHOLDER_HILBERT_SIZE, |
| mDisplay.getSystemColor(SWT.COLOR_BLUE))); |
| |
| // create a composite to contain the right part (legend + zoom) |
| Composite rightSection = new Composite(mHilbertBase, SWT.NONE); |
| gl = new GridLayout(1, false); |
| gl.marginHeight = gl.marginWidth = 0; |
| rightSection.setLayout(gl); |
| |
| Composite zoomComposite = new Composite(rightSection, SWT.NONE); |
| gl = new GridLayout(2, false); |
| zoomComposite.setLayout(gl); |
| |
| Label l = new Label(zoomComposite, SWT.NONE); |
| l.setText("Zoom:"); |
| mZoom = new Combo(zoomComposite, SWT.READ_ONLY); |
| for (int z : ZOOMS) { |
| mZoom.add(String.format("%1$d%%", z)); // $NON-NLS-1$ |
| } |
| |
| mZoom.select(0); |
| mZoom.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| setLegendText(mZoom.getSelectionIndex()); |
| Client client = getCurrentClient(); |
| if (client != null) { |
| renderHeapData(client.getClientData(), 1, true); |
| mTop.pack(); |
| } |
| } |
| }); |
| |
| createLegend(rightSection); |
| } |
| mHilbertBase.pack(); |
| |
| mLayout = new Composite[] { mStatisticsBase, mLinearBase, mHilbertBase }; |
| mDisplayMode.select(0); |
| mDisplayMode.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| int index = mDisplayMode.getSelectionIndex(); |
| Client client = getCurrentClient(); |
| |
| if (client != null) { |
| if (index == 0) { |
| fillDetailedTable(client, true /* forceRedraw */); |
| } else { |
| renderHeapData(client.getClientData(), index-1, true /* forceRedraw */); |
| } |
| } |
| |
| mDisplayStack.topControl = mLayout[index]; |
| //mScrolledComposite.setMinSize(mDisplayStack.topControl.computeSize(SWT.DEFAULT, |
| // SWT.DEFAULT)); |
| mDisplayBase.layout(); |
| //mScrolledComposite.redraw(); |
| } |
| }); |
| |
| //mScrolledComposite.setMinSize(mDisplayStack.topControl.computeSize(SWT.DEFAULT, |
| // SWT.DEFAULT)); |
| mDisplayBase.layout(); |
| //mScrolledComposite.redraw(); |
| |
| return mTop; |
| } |
| |
| /** |
| * Sets the focus to the proper control inside the panel. |
| */ |
| @Override |
| public void setFocus() { |
| mHeapSummary.setFocus(); |
| } |
| |
| |
| private Table createSummaryTable(Composite base) { |
| Table tab = new Table(base, SWT.SINGLE | SWT.FULL_SELECTION); |
| tab.setHeaderVisible(true); |
| tab.setLinesVisible(true); |
| |
| TableColumn col; |
| |
| col = new TableColumn(tab, SWT.RIGHT); |
| col.setText("ID"); |
| col.pack(); |
| |
| col = new TableColumn(tab, SWT.RIGHT); |
| col.setText("000.000WW"); // $NON-NLS-1$ |
| col.pack(); |
| col.setText("Heap Size"); |
| |
| col = new TableColumn(tab, SWT.RIGHT); |
| col.setText("000.000WW"); // $NON-NLS-1$ |
| col.pack(); |
| col.setText("Allocated"); |
| |
| col = new TableColumn(tab, SWT.RIGHT); |
| col.setText("000.000WW"); // $NON-NLS-1$ |
| col.pack(); |
| col.setText("Free"); |
| |
| col = new TableColumn(tab, SWT.RIGHT); |
| col.setText("000.00%"); // $NON-NLS-1$ |
| col.pack(); |
| col.setText("% Used"); |
| |
| col = new TableColumn(tab, SWT.RIGHT); |
| col.setText("000,000,000"); // $NON-NLS-1$ |
| col.pack(); |
| col.setText("# Objects"); |
| |
| return tab; |
| } |
| |
| private Table createDetailedTable(Composite base) { |
| IPreferenceStore store = DdmUiPreferences.getStore(); |
| |
| Table tab = new Table(base, SWT.SINGLE | SWT.FULL_SELECTION); |
| tab.setHeaderVisible(true); |
| tab.setLinesVisible(true); |
| |
| TableHelper.createTableColumn(tab, "Type", SWT.LEFT, |
| "4-byte array (object[], int[], float[])", //$NON-NLS-1$ |
| PREFS_STATS_COL_TYPE, store); |
| |
| TableHelper.createTableColumn(tab, "Count", SWT.RIGHT, |
| "00,000", //$NON-NLS-1$ |
| PREFS_STATS_COL_COUNT, store); |
| |
| TableHelper.createTableColumn(tab, "Total Size", SWT.RIGHT, |
| "000.000 WW", //$NON-NLS-1$ |
| PREFS_STATS_COL_SIZE, store); |
| |
| TableHelper.createTableColumn(tab, "Smallest", SWT.RIGHT, |
| "000.000 WW", //$NON-NLS-1$ |
| PREFS_STATS_COL_SMALLEST, store); |
| |
| TableHelper.createTableColumn(tab, "Largest", SWT.RIGHT, |
| "000.000 WW", //$NON-NLS-1$ |
| PREFS_STATS_COL_LARGEST, store); |
| |
| TableHelper.createTableColumn(tab, "Median", SWT.RIGHT, |
| "000.000 WW", //$NON-NLS-1$ |
| PREFS_STATS_COL_MEDIAN, store); |
| |
| TableHelper.createTableColumn(tab, "Average", SWT.RIGHT, |
| "000.000 WW", //$NON-NLS-1$ |
| PREFS_STATS_COL_AVERAGE, store); |
| |
| tab.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| |
| Client client = getCurrentClient(); |
| if (client != null) { |
| int index = mStatisticsTable.getSelectionIndex(); |
| TableItem item = mStatisticsTable.getItem(index); |
| |
| if (item != null) { |
| Map<Integer, ArrayList<HeapSegmentElement>> heapMap = |
| client.getClientData().getVmHeapData().getProcessedHeapMap(); |
| |
| ArrayList<HeapSegmentElement> list = heapMap.get(item.getData()); |
| if (list != null) { |
| showChart(list); |
| } |
| } |
| } |
| |
| } |
| }); |
| |
| return tab; |
| } |
| |
| /** |
| * Creates the chart below the statistics table |
| */ |
| private void createChart() { |
| mAllocCountDataSet = new DefaultCategoryDataset(); |
| mChart = ChartFactory.createBarChart(null, "Size", "Count", mAllocCountDataSet, |
| PlotOrientation.VERTICAL, false, true, false); |
| |
| // get the font to make a proper title. We need to convert the swt font, |
| // into an awt font. |
| Font f = mStatisticsBase.getFont(); |
| FontData[] fData = f.getFontData(); |
| |
| // event though on Mac OS there could be more than one fontData, we'll only use |
| // the first one. |
| FontData firstFontData = fData[0]; |
| |
| java.awt.Font awtFont = SWTUtils.toAwtFont(mStatisticsBase.getDisplay(), |
| firstFontData, true /* ensureSameSize */); |
| |
| mChart.setTitle(new TextTitle("Allocation count per size", awtFont)); |
| |
| Plot plot = mChart.getPlot(); |
| if (plot instanceof CategoryPlot) { |
| // get the plot |
| CategoryPlot categoryPlot = (CategoryPlot)plot; |
| |
| // set the domain axis to draw labels that are displayed even with many values. |
| CategoryAxis domainAxis = categoryPlot.getDomainAxis(); |
| domainAxis.setCategoryLabelPositions(CategoryLabelPositions.DOWN_90); |
| |
| CategoryItemRenderer renderer = categoryPlot.getRenderer(); |
| renderer.setBaseToolTipGenerator(new CategoryToolTipGenerator() { |
| public String generateToolTip(CategoryDataset dataset, int row, int column) { |
| // get the key for the size of the allocation |
| ByteLong columnKey = (ByteLong)dataset.getColumnKey(column); |
| String rowKey = (String)dataset.getRowKey(row); |
| Number value = dataset.getValue(rowKey, columnKey); |
| |
| return String.format("%1$d %2$s of %3$d bytes", value.intValue(), rowKey, |
| columnKey.getValue()); |
| } |
| }); |
| } |
| mChartComposite = new ChartComposite(mStatisticsBase, SWT.BORDER, mChart, |
| ChartComposite.DEFAULT_WIDTH, |
| ChartComposite.DEFAULT_HEIGHT, |
| ChartComposite.DEFAULT_MINIMUM_DRAW_WIDTH, |
| ChartComposite.DEFAULT_MINIMUM_DRAW_HEIGHT, |
| 3000, // max draw width. We don't want it to zoom, so we put a big number |
| 3000, // max draw height. We don't want it to zoom, so we put a big number |
| true, // off-screen buffer |
| true, // properties |
| true, // save |
| true, // print |
| false, // zoom |
| true); // tooltips |
| |
| mChartComposite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| } |
| |
| private static String prettyByteCount(long bytes) { |
| double fracBytes = bytes; |
| String units = " B"; |
| if (fracBytes < 1024) { |
| return sByteFormatter.format(fracBytes) + units; |
| } else { |
| fracBytes /= 1024; |
| units = " KB"; |
| } |
| if (fracBytes >= 1024) { |
| fracBytes /= 1024; |
| units = " MB"; |
| } |
| if (fracBytes >= 1024) { |
| fracBytes /= 1024; |
| units = " GB"; |
| } |
| |
| return sLargeByteFormatter.format(fracBytes) + units; |
| } |
| |
| private static String approximateByteCount(long bytes) { |
| double fracBytes = bytes; |
| String units = ""; |
| if (fracBytes >= 1024) { |
| fracBytes /= 1024; |
| units = "K"; |
| } |
| if (fracBytes >= 1024) { |
| fracBytes /= 1024; |
| units = "M"; |
| } |
| if (fracBytes >= 1024) { |
| fracBytes /= 1024; |
| units = "G"; |
| } |
| |
| return sByteFormatter.format(fracBytes) + units; |
| } |
| |
| private static String addCommasToNumber(long num) { |
| return sCountFormatter.format(num); |
| } |
| |
| private static String fractionalPercent(long num, long denom) { |
| double val = (double)num / (double)denom; |
| val *= 100; |
| |
| NumberFormat nf = NumberFormat.getInstance(); |
| nf.setMinimumFractionDigits(2); |
| nf.setMaximumFractionDigits(2); |
| return nf.format(val) + "%"; |
| } |
| |
| private void fillSummaryTable(ClientData cd) { |
| if (mHeapSummary.isDisposed()) { |
| return; |
| } |
| |
| mHeapSummary.setRedraw(false); |
| mHeapSummary.removeAll(); |
| |
| if (cd != null) { |
| synchronized (cd) { |
| Iterator<Integer> iter = cd.getVmHeapIds(); |
| |
| while (iter.hasNext()) { |
| Integer id = iter.next(); |
| Map<String, Long> heapInfo = cd.getVmHeapInfo(id); |
| if (heapInfo == null) { |
| continue; |
| } |
| long sizeInBytes = heapInfo.get(ClientData.HEAP_SIZE_BYTES); |
| long bytesAllocated = heapInfo.get(ClientData.HEAP_BYTES_ALLOCATED); |
| long objectsAllocated = heapInfo.get(ClientData.HEAP_OBJECTS_ALLOCATED); |
| |
| TableItem item = new TableItem(mHeapSummary, SWT.NONE); |
| item.setText(0, id.toString()); |
| |
| item.setText(1, prettyByteCount(sizeInBytes)); |
| item.setText(2, prettyByteCount(bytesAllocated)); |
| item.setText(3, prettyByteCount(sizeInBytes - bytesAllocated)); |
| item.setText(4, fractionalPercent(bytesAllocated, sizeInBytes)); |
| item.setText(5, addCommasToNumber(objectsAllocated)); |
| } |
| } |
| } |
| |
| mHeapSummary.pack(); |
| mHeapSummary.setRedraw(true); |
| } |
| |
| private void fillDetailedTable(Client client, boolean forceRedraw) { |
| // first check if the client is invalid or heap updates are not enabled. |
| if (client == null || client.isHeapUpdateEnabled() == false) { |
| mStatisticsTable.removeAll(); |
| showChart(null); |
| return; |
| } |
| |
| ClientData cd = client.getClientData(); |
| |
| Map<Integer, ArrayList<HeapSegmentElement>> heapMap; |
| |
| // Atomically get and clear the heap data. |
| synchronized (cd) { |
| if (serializeHeapData(cd.getVmHeapData()) == false && forceRedraw == false) { |
| // no change, we return. |
| return; |
| } |
| |
| heapMap = cd.getVmHeapData().getProcessedHeapMap(); |
| } |
| |
| // we have new data, lets display it. |
| |
| // First, get the current selection, and its key. |
| int index = mStatisticsTable.getSelectionIndex(); |
| Integer selectedKey = null; |
| if (index != -1) { |
| selectedKey = (Integer)mStatisticsTable.getItem(index).getData(); |
| } |
| |
| // disable redraws and remove all from the table. |
| mStatisticsTable.setRedraw(false); |
| mStatisticsTable.removeAll(); |
| |
| if (heapMap != null) { |
| int selectedIndex = -1; |
| ArrayList<HeapSegmentElement> selectedList = null; |
| |
| // get the keys |
| Set<Integer> keys = heapMap.keySet(); |
| int iter = 0; // use a manual iter int because Set<?> doesn't have an index |
| // based accessor. |
| for (Integer key : keys) { |
| ArrayList<HeapSegmentElement> list = heapMap.get(key); |
| |
| // check if this is the key that is supposed to be selected |
| if (key.equals(selectedKey)) { |
| selectedIndex = iter; |
| selectedList = list; |
| } |
| iter++; |
| |
| TableItem item = new TableItem(mStatisticsTable, SWT.NONE); |
| item.setData(key); |
| |
| // get the type |
| item.setText(0, mMapLegend[key]); |
| |
| // set the count, smallest, largest |
| int count = list.size(); |
| item.setText(1, addCommasToNumber(count)); |
| |
| if (count > 0) { |
| item.setText(3, prettyByteCount(list.get(0).getLength())); |
| item.setText(4, prettyByteCount(list.get(count-1).getLength())); |
| |
| int median = count / 2; |
| HeapSegmentElement element = list.get(median); |
| long size = element.getLength(); |
| item.setText(5, prettyByteCount(size)); |
| |
| long totalSize = 0; |
| for (int i = 0 ; i < count; i++) { |
| element = list.get(i); |
| |
| size = element.getLength(); |
| totalSize += size; |
| } |
| |
| // set the average and total |
| item.setText(2, prettyByteCount(totalSize)); |
| item.setText(6, prettyByteCount(totalSize / count)); |
| } |
| } |
| |
| mStatisticsTable.setRedraw(true); |
| |
| if (selectedIndex != -1) { |
| mStatisticsTable.setSelection(selectedIndex); |
| showChart(selectedList); |
| } else { |
| showChart(null); |
| } |
| } else { |
| mStatisticsTable.setRedraw(true); |
| } |
| } |
| |
| private static class ByteLong implements Comparable<ByteLong> { |
| private long mValue; |
| |
| private ByteLong(long value) { |
| mValue = value; |
| } |
| |
| public long getValue() { |
| return mValue; |
| } |
| |
| @Override |
| public String toString() { |
| return approximateByteCount(mValue); |
| } |
| |
| public int compareTo(ByteLong other) { |
| if (mValue != other.mValue) { |
| return mValue < other.mValue ? -1 : 1; |
| } |
| return 0; |
| } |
| |
| } |
| |
| /** |
| * Fills the chart with the content of the list of {@link HeapSegmentElement}. |
| */ |
| private void showChart(ArrayList<HeapSegmentElement> list) { |
| mAllocCountDataSet.clear(); |
| |
| if (list != null) { |
| String rowKey = "Alloc Count"; |
| |
| long currentSize = -1; |
| int currentCount = 0; |
| for (HeapSegmentElement element : list) { |
| if (element.getLength() != currentSize) { |
| if (currentSize != -1) { |
| ByteLong columnKey = new ByteLong(currentSize); |
| mAllocCountDataSet.addValue(currentCount, rowKey, columnKey); |
| } |
| |
| currentSize = element.getLength(); |
| currentCount = 1; |
| } else { |
| currentCount++; |
| } |
| } |
| |
| // add the last item |
| if (currentSize != -1) { |
| ByteLong columnKey = new ByteLong(currentSize); |
| mAllocCountDataSet.addValue(currentCount, rowKey, columnKey); |
| } |
| } |
| } |
| |
| /* |
| * Add a color legend to the specified table. |
| */ |
| private void createLegend(Composite parent) { |
| mLegend = new Group(parent, SWT.NONE); |
| mLegend.setText(getLegendText(0)); |
| |
| mLegend.setLayout(new GridLayout(2, false)); |
| |
| RGB[] colors = mMapPalette.colors; |
| |
| for (int i = 0; i < NUM_PALETTE_ENTRIES; i++) { |
| Image tmpImage = createColorRect(parent.getDisplay(), colors[i]); |
| |
| Label l = new Label(mLegend, SWT.NONE); |
| l.setImage(tmpImage); |
| |
| l = new Label(mLegend, SWT.NONE); |
| l.setText(mMapLegend[i]); |
| } |
| } |
| |
| private String getLegendText(int level) { |
| int bytes = 8 * (100 / ZOOMS[level]); |
| |
| return String.format("Key (1 pixel = %1$d bytes)", bytes); |
| } |
| |
| private void setLegendText(int level) { |
| mLegend.setText(getLegendText(level)); |
| |
| } |
| |
| /* |
| * Create a nice rectangle in the specified color. |
| */ |
| private Image createColorRect(Display display, RGB color) { |
| int width = 32; |
| int height = 16; |
| |
| Image img = new Image(display, width, height); |
| GC gc = new GC(img); |
| gc.setBackground(new Color(display, color)); |
| gc.fillRectangle(0, 0, width, height); |
| gc.dispose(); |
| return img; |
| } |
| |
| |
| /* |
| * Are updates enabled? |
| */ |
| private void setUpdateStatus(int status) { |
| switch (status) { |
| case NOT_SELECTED: |
| mUpdateStatus.setText("Select a client to see heap updates"); |
| break; |
| case NOT_ENABLED: |
| mUpdateStatus.setText("Heap updates are " + |
| "NOT ENABLED for this client"); |
| break; |
| case ENABLED: |
| mUpdateStatus.setText("Heap updates will happen after " + |
| "every GC for this client"); |
| break; |
| default: |
| throw new RuntimeException(); |
| } |
| |
| mUpdateStatus.pack(); |
| } |
| |
| |
| /** |
| * Return the closest power of two greater than or equal to value. |
| * |
| * @param value the return value will be >= value |
| * @return a power of two >= value. If value > 2^31, 2^31 is returned. |
| */ |
| //xxx use Integer.highestOneBit() or numberOfLeadingZeros(). |
| private int nextPow2(int value) { |
| for (int i = 31; i >= 0; --i) { |
| if ((value & (1<<i)) != 0) { |
| if (i < 31) { |
| return 1<<(i + 1); |
| } else { |
| return 1<<31; |
| } |
| } |
| } |
| return 0; |
| } |
| |
| private int zOrderData(ImageData id, byte pixData[]) { |
| int maxX = 0; |
| for (int i = 0; i < pixData.length; i++) { |
| /* Tread the pixData index as a z-order curve index and |
| * decompose into Cartesian coordinates. |
| */ |
| int x = (i & 1) | |
| ((i >>> 2) & 1) << 1 | |
| ((i >>> 4) & 1) << 2 | |
| ((i >>> 6) & 1) << 3 | |
| ((i >>> 8) & 1) << 4 | |
| ((i >>> 10) & 1) << 5 | |
| ((i >>> 12) & 1) << 6 | |
| ((i >>> 14) & 1) << 7 | |
| ((i >>> 16) & 1) << 8 | |
| ((i >>> 18) & 1) << 9 | |
| ((i >>> 20) & 1) << 10 | |
| ((i >>> 22) & 1) << 11 | |
| ((i >>> 24) & 1) << 12 | |
| ((i >>> 26) & 1) << 13 | |
| ((i >>> 28) & 1) << 14 | |
| ((i >>> 30) & 1) << 15; |
| int y = ((i >>> 1) & 1) << 0 | |
| ((i >>> 3) & 1) << 1 | |
| ((i >>> 5) & 1) << 2 | |
| ((i >>> 7) & 1) << 3 | |
| ((i >>> 9) & 1) << 4 | |
| ((i >>> 11) & 1) << 5 | |
| ((i >>> 13) & 1) << 6 | |
| ((i >>> 15) & 1) << 7 | |
| ((i >>> 17) & 1) << 8 | |
| ((i >>> 19) & 1) << 9 | |
| ((i >>> 21) & 1) << 10 | |
| ((i >>> 23) & 1) << 11 | |
| ((i >>> 25) & 1) << 12 | |
| ((i >>> 27) & 1) << 13 | |
| ((i >>> 29) & 1) << 14 | |
| ((i >>> 31) & 1) << 15; |
| try { |
| id.setPixel(x, y, pixData[i]); |
| if (x > maxX) { |
| maxX = x; |
| } |
| } catch (IllegalArgumentException ex) { |
| System.out.println("bad pixels: i " + i + |
| ", w " + id.width + |
| ", h " + id.height + |
| ", x " + x + |
| ", y " + y); |
| throw ex; |
| } |
| } |
| return maxX; |
| } |
| |
| private final static int HILBERT_DIR_N = 0; |
| private final static int HILBERT_DIR_S = 1; |
| private final static int HILBERT_DIR_E = 2; |
| private final static int HILBERT_DIR_W = 3; |
| |
| private void hilbertWalk(ImageData id, InputStream pixData, |
| int order, int x, int y, int dir) |
| throws IOException { |
| if (x >= id.width || y >= id.height) { |
| return; |
| } else if (order == 0) { |
| try { |
| int p = pixData.read(); |
| if (p >= 0) { |
| // flip along x=y axis; assume width == height |
| id.setPixel(y, x, p); |
| |
| /* Skanky; use an otherwise-unused ImageData field |
| * to keep track of the max x,y used. Note that x and y are inverted. |
| */ |
| if (y > id.x) { |
| id.x = y; |
| } |
| if (x > id.y) { |
| id.y = x; |
| } |
| } |
| //xxx just give up; don't bother walking the rest of the image |
| } catch (IllegalArgumentException ex) { |
| System.out.println("bad pixels: order " + order + |
| ", dir " + dir + |
| ", w " + id.width + |
| ", h " + id.height + |
| ", x " + x + |
| ", y " + y); |
| throw ex; |
| } |
| } else { |
| order--; |
| int delta = 1 << order; |
| int nextX = x + delta; |
| int nextY = y + delta; |
| |
| switch (dir) { |
| case HILBERT_DIR_E: |
| hilbertWalk(id, pixData, order, x, y, HILBERT_DIR_N); |
| hilbertWalk(id, pixData, order, x, nextY, HILBERT_DIR_E); |
| hilbertWalk(id, pixData, order, nextX, nextY, HILBERT_DIR_E); |
| hilbertWalk(id, pixData, order, nextX, y, HILBERT_DIR_S); |
| break; |
| case HILBERT_DIR_N: |
| hilbertWalk(id, pixData, order, x, y, HILBERT_DIR_E); |
| hilbertWalk(id, pixData, order, nextX, y, HILBERT_DIR_N); |
| hilbertWalk(id, pixData, order, nextX, nextY, HILBERT_DIR_N); |
| hilbertWalk(id, pixData, order, x, nextY, HILBERT_DIR_W); |
| break; |
| case HILBERT_DIR_S: |
| hilbertWalk(id, pixData, order, nextX, nextY, HILBERT_DIR_W); |
| hilbertWalk(id, pixData, order, x, nextY, HILBERT_DIR_S); |
| hilbertWalk(id, pixData, order, x, y, HILBERT_DIR_S); |
| hilbertWalk(id, pixData, order, nextX, y, HILBERT_DIR_E); |
| break; |
| case HILBERT_DIR_W: |
| hilbertWalk(id, pixData, order, nextX, nextY, HILBERT_DIR_S); |
| hilbertWalk(id, pixData, order, nextX, y, HILBERT_DIR_W); |
| hilbertWalk(id, pixData, order, x, y, HILBERT_DIR_W); |
| hilbertWalk(id, pixData, order, x, nextY, HILBERT_DIR_N); |
| break; |
| default: |
| throw new RuntimeException("Unexpected Hilbert direction " + |
| dir); |
| } |
| } |
| } |
| |
| private Point hilbertOrderData(ImageData id, byte pixData[]) { |
| |
| int order = 0; |
| for (int n = 1; n < id.width; n *= 2) { |
| order++; |
| } |
| /* Skanky; use an otherwise-unused ImageData field |
| * to keep track of maxX. |
| */ |
| Point p = new Point(0,0); |
| int oldIdX = id.x; |
| int oldIdY = id.y; |
| id.x = id.y = 0; |
| try { |
| hilbertWalk(id, new ByteArrayInputStream(pixData), |
| order, 0, 0, HILBERT_DIR_E); |
| p.x = id.x; |
| p.y = id.y; |
| } catch (IOException ex) { |
| System.err.println("Exception during hilbertWalk()"); |
| p.x = id.height; |
| p.y = id.width; |
| } |
| id.x = oldIdX; |
| id.y = oldIdY; |
| return p; |
| } |
| |
| private ImageData createHilbertHeapImage(byte pixData[]) { |
| int w, h; |
| |
| // Pick an image size that the largest of heaps will fit into. |
| w = (int)Math.sqrt((double)((16 * 1024 * 1024)/8)); |
| |
| // Space-filling curves require a power-of-2 width. |
| w = nextPow2(w); |
| h = w; |
| |
| // Create the heap image. |
| ImageData id = new ImageData(w, h, 8, mMapPalette); |
| |
| // Copy the data into the image |
| //int maxX = zOrderData(id, pixData); |
| Point maxP = hilbertOrderData(id, pixData); |
| |
| // update the max size to make it a round number once the zoom is applied |
| int factor = 100 / ZOOMS[mZoom.getSelectionIndex()]; |
| if (factor != 1) { |
| int tmp = maxP.x % factor; |
| if (tmp != 0) { |
| maxP.x += factor - tmp; |
| } |
| |
| tmp = maxP.y % factor; |
| if (tmp != 0) { |
| maxP.y += factor - tmp; |
| } |
| } |
| |
| if (maxP.y < id.height) { |
| // Crop the image down to the interesting part. |
| id = new ImageData(id.width, maxP.y, id.depth, id.palette, |
| id.scanlinePad, id.data); |
| } |
| |
| if (maxP.x < id.width) { |
| // crop the image again. A bit trickier this time. |
| ImageData croppedId = new ImageData(maxP.x, id.height, id.depth, id.palette); |
| |
| int[] buffer = new int[maxP.x]; |
| for (int l = 0 ; l < id.height; l++) { |
| id.getPixels(0, l, maxP.x, buffer, 0); |
| croppedId.setPixels(0, l, maxP.x, buffer, 0); |
| } |
| |
| id = croppedId; |
| } |
| |
| // apply the zoom |
| if (factor != 1) { |
| id = id.scaledTo(id.width / factor, id.height / factor); |
| } |
| |
| return id; |
| } |
| |
| /** |
| * Convert the raw heap data to an image. We know we're running in |
| * the UI thread, so we can issue graphics commands directly. |
| * |
| * http://help.eclipse.org/help31/nftopic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/swt/graphics/GC.html |
| * |
| * @param cd The client data |
| * @param mode The display mode. 0 = linear, 1 = hilbert. |
| * @param forceRedraw |
| */ |
| private void renderHeapData(ClientData cd, int mode, boolean forceRedraw) { |
| Image image; |
| |
| byte[] pixData; |
| |
| // Atomically get and clear the heap data. |
| synchronized (cd) { |
| if (serializeHeapData(cd.getVmHeapData()) == false && forceRedraw == false) { |
| // no change, we return. |
| return; |
| } |
| |
| pixData = getSerializedData(); |
| } |
| |
| if (pixData != null) { |
| ImageData id; |
| if (mode == 1) { |
| id = createHilbertHeapImage(pixData); |
| } else { |
| id = createLinearHeapImage(pixData, 200, mMapPalette); |
| } |
| |
| image = new Image(mDisplay, id); |
| } else { |
| // Render a placeholder image. |
| int width, height; |
| if (mode == 1) { |
| width = height = PLACEHOLDER_HILBERT_SIZE; |
| } else { |
| width = PLACEHOLDER_LINEAR_H_SIZE; |
| height = PLACEHOLDER_LINEAR_V_SIZE; |
| } |
| image = new Image(mDisplay, width, height); |
| GC gc = new GC(image); |
| gc.setForeground(mDisplay.getSystemColor(SWT.COLOR_RED)); |
| gc.drawLine(0, 0, width-1, height-1); |
| gc.dispose(); |
| gc = null; |
| } |
| |
| // set the new image |
| |
| if (mode == 1) { |
| if (mHilbertImage != null) { |
| mHilbertImage.dispose(); |
| } |
| |
| mHilbertImage = image; |
| mHilbertHeapImage.setImage(mHilbertImage); |
| mHilbertHeapImage.pack(true); |
| mHilbertBase.layout(); |
| mHilbertBase.pack(true); |
| } else { |
| if (mLinearImage != null) { |
| mLinearImage.dispose(); |
| } |
| |
| mLinearImage = image; |
| mLinearHeapImage.setImage(mLinearImage); |
| mLinearHeapImage.pack(true); |
| mLinearBase.layout(); |
| mLinearBase.pack(true); |
| } |
| } |
| |
| @Override |
| protected void setTableFocusListener() { |
| addTableToFocusListener(mHeapSummary); |
| } |
| } |
| |
