ddms/libs/ddmuilib/src/com/android/ddmuilib/HeapPanel.java

   1 /*
   2  * Copyright (C) 2007 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.ddmuilib;
  18
  19 import com.android.ddmlib.Client;
  20 import com.android.ddmlib.ClientData;
  21 import com.android.ddmlib.Log;
  22 import com.android.ddmlib.AndroidDebugBridge.IClientChangeListener;
  23 import com.android.ddmlib.HeapSegment.HeapSegmentElement;
  24
  25 import org.eclipse.jface.preference.IPreferenceStore;
  26 import org.eclipse.swt.SWT;
  27 import org.eclipse.swt.SWTException;
  28 import org.eclipse.swt.custom.StackLayout;
  29 import org.eclipse.swt.events.SelectionAdapter;
  30 import org.eclipse.swt.events.SelectionEvent;
  31 import org.eclipse.swt.graphics.Color;
  32 import org.eclipse.swt.graphics.Font;
  33 import org.eclipse.swt.graphics.FontData;
  34 import org.eclipse.swt.graphics.GC;
  35 import org.eclipse.swt.graphics.Image;
  36 import org.eclipse.swt.graphics.ImageData;
  37 import org.eclipse.swt.graphics.PaletteData;
  38 import org.eclipse.swt.graphics.Point;
  39 import org.eclipse.swt.graphics.RGB;
  40 import org.eclipse.swt.layout.GridData;
  41 import org.eclipse.swt.layout.GridLayout;
  42 import org.eclipse.swt.widgets.Button;
  43 import org.eclipse.swt.widgets.Combo;
  44 import org.eclipse.swt.widgets.Composite;
  45 import org.eclipse.swt.widgets.Control;
  46 import org.eclipse.swt.widgets.Display;
  47 import org.eclipse.swt.widgets.Group;
  48 import org.eclipse.swt.widgets.Label;
  49 import org.eclipse.swt.widgets.Table;
  50 import org.eclipse.swt.widgets.TableColumn;
  51 import org.eclipse.swt.widgets.TableItem;
  52 import org.jfree.chart.ChartFactory;
  53 import org.jfree.chart.JFreeChart;
  54 import org.jfree.chart.axis.CategoryAxis;
  55 import org.jfree.chart.axis.CategoryLabelPositions;
  56 import org.jfree.chart.labels.CategoryToolTipGenerator;
  57 import org.jfree.chart.plot.CategoryPlot;
  58 import org.jfree.chart.plot.Plot;
  59 import org.jfree.chart.plot.PlotOrientation;
  60 import org.jfree.chart.renderer.category.CategoryItemRenderer;
  61 import org.jfree.chart.title.TextTitle;
  62 import org.jfree.data.category.CategoryDataset;
  63 import org.jfree.data.category.DefaultCategoryDataset;
  64 import org.jfree.experimental.chart.swt.ChartComposite;
  65 import org.jfree.experimental.swt.SWTUtils;
  66
  67 import java.io.ByteArrayInputStream;
  68 import java.io.IOException;
  69 import java.io.InputStream;
  70 import java.text.NumberFormat;
  71 import java.util.ArrayList;
  72 import java.util.Iterator;
  73 import java.util.Map;
  74 import java.util.Set;
  75
  76
  77 /**
  78  * Base class for our information panels.
  79  */
  80 public final class HeapPanel extends BaseHeapPanel {
  81     private static final String PREFS_STATS_COL_TYPE = "heapPanel.col0"; //$NON-NLS-1$
  82     private static final String PREFS_STATS_COL_COUNT = "heapPanel.col1"; //$NON-NLS-1$
  83     private static final String PREFS_STATS_COL_SIZE = "heapPanel.col2"; //$NON-NLS-1$
  84     private static final String PREFS_STATS_COL_SMALLEST = "heapPanel.col3"; //$NON-NLS-1$
  85     private static final String PREFS_STATS_COL_LARGEST = "heapPanel.col4"; //$NON-NLS-1$
  86     private static final String PREFS_STATS_COL_MEDIAN = "heapPanel.col5"; //$NON-NLS-1$
  87     private static final String PREFS_STATS_COL_AVERAGE = "heapPanel.col6"; //$NON-NLS-1$
  88
  89     /* args to setUpdateStatus() */
  90     private static final int NOT_SELECTED   = 0;
  91     private static final int NOT_ENABLED    = 1;
  92     private static final int ENABLED        = 2;
  93
  94     /** color palette and map legend. NATIVE is the last enum is a 0 based enum list, so we need
  95      * Native+1 at least. We also need 2 more entries for free area and expansion area.  */
  96     private static final int NUM_PALETTE_ENTRIES = HeapSegmentElement.KIND_NATIVE+2 +1;
  97     private static final String[] mMapLegend = new String[NUM_PALETTE_ENTRIES];
  98     private static final PaletteData mMapPalette = createPalette();
  99
 100     private static final boolean DISPLAY_HEAP_BITMAP = false;
 101     private static final boolean DISPLAY_HILBERT_BITMAP = false;
 102
 103     private static final int PLACEHOLDER_HILBERT_SIZE = 200;
 104     private static final int PLACEHOLDER_LINEAR_V_SIZE = 100;
 105     private static final int PLACEHOLDER_LINEAR_H_SIZE = 300;
 106
 107     private static final int[] ZOOMS = {100, 50, 25};
 108
 109     private static final NumberFormat sByteFormatter = NumberFormat.getInstance();
 110     private static final NumberFormat sLargeByteFormatter = NumberFormat.getInstance();
 111     private static final NumberFormat sCountFormatter = NumberFormat.getInstance();
 112
 113     static {
 114         sByteFormatter.setMinimumFractionDigits(0);
 115         sByteFormatter.setMaximumFractionDigits(1);
 116         sLargeByteFormatter.setMinimumFractionDigits(3);
 117         sLargeByteFormatter.setMaximumFractionDigits(3);
 118
 119         sCountFormatter.setGroupingUsed(true);
 120     }
 121
 122     private Display mDisplay;
 123
 124     private Composite mTop; // real top
 125     private Label mUpdateStatus;
 126     private Table mHeapSummary;
 127     private Combo mDisplayMode;
 128
 129     //private ScrolledComposite mScrolledComposite;
 130
 131     private Composite mDisplayBase; // base of the displays.
 132     private StackLayout mDisplayStack;
 133
 134     private Composite mStatisticsBase;
 135     private Table mStatisticsTable;
 136     private JFreeChart mChart;
 137     private ChartComposite mChartComposite;
 138     private Button mGcButton;
 139     private DefaultCategoryDataset mAllocCountDataSet;
 140
 141     private Composite mLinearBase;
 142     private Label mLinearHeapImage;
 143
 144     private Composite mHilbertBase;
 145     private Label mHilbertHeapImage;
 146     private Group mLegend;
 147     private Combo mZoom;
 148
 149     /** Image used for the hilbert display. Since we recreate a new image every time, we
 150      * keep this one around to dispose it. */
 151     private Image mHilbertImage;
 152     private Image mLinearImage;
 153     private Composite[] mLayout;
 154
 155     /*
 156      * Create color palette for map.  Set up titles for legend.
 157      */
 158     private static PaletteData createPalette() {
 159         RGB colors[] = new RGB[NUM_PALETTE_ENTRIES];
 160         colors[0]
 161                 = new RGB(192, 192, 192); // non-heap pixels are gray
 162         mMapLegend[0]
 163                 = "(heap expansion area)";
 164
 165         colors[1]
 166                 = new RGB(0, 0, 0);       // free chunks are black
 167         mMapLegend[1]
 168                 = "free";
 169
 170         colors[HeapSegmentElement.KIND_OBJECT + 2]
 171                 = new RGB(0, 0, 255);     // objects are blue
 172         mMapLegend[HeapSegmentElement.KIND_OBJECT + 2]
 173                 = "data object";
 174
 175         colors[HeapSegmentElement.KIND_CLASS_OBJECT + 2]
 176                 = new RGB(0, 255, 0);     // class objects are green
 177         mMapLegend[HeapSegmentElement.KIND_CLASS_OBJECT + 2]
 178                 = "class object";
 179
 180         colors[HeapSegmentElement.KIND_ARRAY_1 + 2]
 181                 = new RGB(255, 0, 0);     // byte/bool arrays are red
 182         mMapLegend[HeapSegmentElement.KIND_ARRAY_1 + 2]
 183                 = "1-byte array (byte[], boolean[])";
 184
 185         colors[HeapSegmentElement.KIND_ARRAY_2 + 2]
 186                 = new RGB(255, 128, 0);   // short/char arrays are orange
 187         mMapLegend[HeapSegmentElement.KIND_ARRAY_2 + 2]
 188                 = "2-byte array (short[], char[])";
 189
 190         colors[HeapSegmentElement.KIND_ARRAY_4 + 2]
 191                 = new RGB(255, 255, 0);   // obj/int/float arrays are yellow
 192         mMapLegend[HeapSegmentElement.KIND_ARRAY_4 + 2]
 193                 = "4-byte array (object[], int[], float[])";
 194
 195         colors[HeapSegmentElement.KIND_ARRAY_8 + 2]
 196                 = new RGB(255, 128, 128); // long/double arrays are pink
 197         mMapLegend[HeapSegmentElement.KIND_ARRAY_8 + 2]
 198                 = "8-byte array (long[], double[])";
 199
 200         colors[HeapSegmentElement.KIND_UNKNOWN + 2]
 201                 = new RGB(255, 0, 255);   // unknown objects are cyan
 202         mMapLegend[HeapSegmentElement.KIND_UNKNOWN + 2]
 203                 = "unknown object";
 204
 205         colors[HeapSegmentElement.KIND_NATIVE + 2]
 206                 = new RGB(64, 64, 64);    // native objects are dark gray
 207         mMapLegend[HeapSegmentElement.KIND_NATIVE + 2]
 208                 = "non-Java object";
 209
 210         return new PaletteData(colors);
 211     }
 212
 213     /**
 214      * Sent when an existing client information changed.
 215      * <p/>
 216      * This is sent from a non UI thread.
 217      * @param client the updated client.
 218      * @param changeMask the bit mask describing the changed properties. It can contain
 219      * any of the following values: {@link Client#CHANGE_INFO}, {@link Client#CHANGE_NAME}
 220      * {@link Client#CHANGE_DEBUGGER_STATUS}, {@link Client#CHANGE_THREAD_MODE},
 221      * {@link Client#CHANGE_THREAD_DATA}, {@link Client#CHANGE_HEAP_MODE},
 222      * {@link Client#CHANGE_HEAP_DATA}, {@link Client#CHANGE_NATIVE_HEAP_DATA}
 223      *
 224      * @see IClientChangeListener#clientChanged(Client, int)
 225      */
 226     public void clientChanged(final Client client, int changeMask) {
 227         if (client == getCurrentClient()) {
 228             if ((changeMask & Client.CHANGE_HEAP_MODE) == Client.CHANGE_HEAP_MODE ||
 229                     (changeMask & Client.CHANGE_HEAP_DATA) == Client.CHANGE_HEAP_DATA) {
 230                 try {
 231                     mTop.getDisplay().asyncExec(new Runnable() {
 232                         public void run() {
 233                             clientSelected();
 234                         }
 235                     });
 236                 } catch (SWTException e) {
 237                     // display is disposed (app is quitting most likely), we do nothing.
 238                 }
 239             }
 240         }
 241     }
 242
 243     /**
 244      * Sent when a new device is selected. The new device can be accessed
 245      * with {@link #getCurrentDevice()}
 246      */
 247     @Override
 248     public void deviceSelected() {
 249         // pass
 250     }
 251
 252     /**
 253      * Sent when a new client is selected. The new client can be accessed
 254      * with {@link #getCurrentClient()}.
 255      */
 256     @Override
 257     public void clientSelected() {
 258         if (mTop.isDisposed())
 259             return;
 260
 261         Client client = getCurrentClient();
 262
 263         Log.d("ddms", "HeapPanel: changed " + client);
 264
 265         if (client != null) {
 266             ClientData cd = client.getClientData();
 267
 268             if (client.isHeapUpdateEnabled()) {
 269                 mGcButton.setEnabled(true);
 270                 mDisplayMode.setEnabled(true);
 271                 setUpdateStatus(ENABLED);
 272             } else {
 273                 setUpdateStatus(NOT_ENABLED);
 274                 mGcButton.setEnabled(false);
 275                 mDisplayMode.setEnabled(false);
 276             }
 277
 278             fillSummaryTable(cd);
 279
 280             int mode = mDisplayMode.getSelectionIndex();
 281             if (mode == 0) {
 282                 fillDetailedTable(client, false /* forceRedraw */);
 283             } else {
 284                 if (DISPLAY_HEAP_BITMAP) {
 285                     renderHeapData(cd, mode - 1, false /* forceRedraw */);
 286                 }
 287             }
 288         } else {
 289             mGcButton.setEnabled(false);
 290             mDisplayMode.setEnabled(false);
 291             fillSummaryTable(null);
 292             fillDetailedTable(null, true);
 293             setUpdateStatus(NOT_SELECTED);
 294         }
 295
 296         // sizes of things change frequently, so redo layout
 297         //mScrolledComposite.setMinSize(mDisplayStack.topControl.computeSize(SWT.DEFAULT,
 298         //        SWT.DEFAULT));
 299         mDisplayBase.layout();
 300         //mScrolledComposite.redraw();
 301     }
 302
 303     /**
 304      * Create our control(s).
 305      */
 306     @Override
 307     protected Control createControl(Composite parent) {
 308         mDisplay = parent.getDisplay();
 309
 310         GridLayout gl;
 311
 312         mTop = new Composite(parent, SWT.NONE);
 313         mTop.setLayout(new GridLayout(1, false));
 314         mTop.setLayoutData(new GridData(GridData.FILL_BOTH));
 315
 316         mUpdateStatus = new Label(mTop, SWT.NONE);
 317         setUpdateStatus(NOT_SELECTED);
 318
 319         Composite summarySection = new Composite(mTop, SWT.NONE);
 320         summarySection.setLayout(gl = new GridLayout(2, false));
 321         gl.marginHeight = gl.marginWidth = 0;
 322
 323         mHeapSummary = createSummaryTable(summarySection);
 324         mGcButton = new Button(summarySection, SWT.PUSH);
 325         mGcButton.setText("Cause GC");
 326         mGcButton.setEnabled(false);
 327         mGcButton.addSelectionListener(new SelectionAdapter() {
 328             @Override
 329             public void widgetSelected(SelectionEvent e) {
 330                 Client client = getCurrentClient();
 331                 if (client != null) {
 332                     client.executeGarbageCollector();
 333                 }
 334             }
 335         });
 336
 337         Composite comboSection = new Composite(mTop, SWT.NONE);
 338         gl = new GridLayout(2, false);
 339         gl.marginHeight = gl.marginWidth = 0;
 340         comboSection.setLayout(gl);
 341
 342         Label displayLabel = new Label(comboSection, SWT.NONE);
 343         displayLabel.setText("Display: ");
 344
 345         mDisplayMode = new Combo(comboSection, SWT.READ_ONLY);
 346         mDisplayMode.setEnabled(false);
 347         mDisplayMode.add("Stats");
 348         if (DISPLAY_HEAP_BITMAP) {
 349             mDisplayMode.add("Linear");
 350             if (DISPLAY_HILBERT_BITMAP) {
 351                 mDisplayMode.add("Hilbert");
 352             }
 353         }
 354
 355         // the base of the displays.
 356         mDisplayBase = new Composite(mTop, SWT.NONE);
 357         mDisplayBase.setLayoutData(new GridData(GridData.FILL_BOTH));
 358         mDisplayStack = new StackLayout();
 359         mDisplayBase.setLayout(mDisplayStack);
 360
 361         // create the statistics display
 362         mStatisticsBase = new Composite(mDisplayBase, SWT.NONE);
 363         //mStatisticsBase.setLayoutData(new GridData(GridData.FILL_BOTH));
 364         mStatisticsBase.setLayout(gl = new GridLayout(1, false));
 365         gl.marginHeight = gl.marginWidth = 0;
 366         mDisplayStack.topControl = mStatisticsBase;
 367
 368         mStatisticsTable = createDetailedTable(mStatisticsBase);
 369         mStatisticsTable.setLayoutData(new GridData(GridData.FILL_BOTH));
 370
 371         createChart();
 372
 373         //create the linear composite
 374         mLinearBase = new Composite(mDisplayBase, SWT.NONE);
 375         //mLinearBase.setLayoutData(new GridData());
 376         gl = new GridLayout(1, false);
 377         gl.marginHeight = gl.marginWidth = 0;
 378         mLinearBase.setLayout(gl);
 379
 380         {
 381             mLinearHeapImage = new Label(mLinearBase, SWT.NONE);
 382             mLinearHeapImage.setLayoutData(new GridData());
 383             mLinearHeapImage.setImage(ImageLoader.createPlaceHolderArt(mDisplay,
 384                     PLACEHOLDER_LINEAR_H_SIZE, PLACEHOLDER_LINEAR_V_SIZE,
 385                     mDisplay.getSystemColor(SWT.COLOR_BLUE)));
 386
 387             // create a composite to contain the bottom part (legend)
 388             Composite bottomSection = new Composite(mLinearBase, SWT.NONE);
 389             gl = new GridLayout(1, false);
 390             gl.marginHeight = gl.marginWidth = 0;
 391             bottomSection.setLayout(gl);
 392
 393             createLegend(bottomSection);
 394         }
 395
 396 /*
 397         mScrolledComposite = new ScrolledComposite(mTop, SWT.H_SCROLL | SWT.V_SCROLL);
 398         mScrolledComposite.setLayoutData(new GridData(GridData.FILL_BOTH));
 399         mScrolledComposite.setExpandHorizontal(true);
 400         mScrolledComposite.setExpandVertical(true);
 401         mScrolledComposite.setContent(mDisplayBase);
 402 */
 403
 404
 405         // create the hilbert display.
 406         mHilbertBase = new Composite(mDisplayBase, SWT.NONE);
 407         //mHilbertBase.setLayoutData(new GridData());
 408         gl = new GridLayout(2, false);
 409         gl.marginHeight = gl.marginWidth = 0;
 410         mHilbertBase.setLayout(gl);
 411
 412         if (DISPLAY_HILBERT_BITMAP) {
 413             mHilbertHeapImage = new Label(mHilbertBase, SWT.NONE);
 414             mHilbertHeapImage.setLayoutData(new GridData());
 415             mHilbertHeapImage.setImage(ImageLoader.createPlaceHolderArt(mDisplay,
 416                     PLACEHOLDER_HILBERT_SIZE, PLACEHOLDER_HILBERT_SIZE,
 417                     mDisplay.getSystemColor(SWT.COLOR_BLUE)));
 418
 419             // create a composite to contain the right part (legend + zoom)
 420             Composite rightSection = new Composite(mHilbertBase, SWT.NONE);
 421             gl = new GridLayout(1, false);
 422             gl.marginHeight = gl.marginWidth = 0;
 423             rightSection.setLayout(gl);
 424
 425             Composite zoomComposite = new Composite(rightSection, SWT.NONE);
 426             gl = new GridLayout(2, false);
 427             zoomComposite.setLayout(gl);
 428
 429             Label l = new Label(zoomComposite, SWT.NONE);
 430             l.setText("Zoom:");
 431             mZoom = new Combo(zoomComposite, SWT.READ_ONLY);
 432             for (int z : ZOOMS) {
 433                 mZoom.add(String.format("%1$d%%", z)); //$NON-NLS-1$
 434             }
 435
 436             mZoom.select(0);
 437             mZoom.addSelectionListener(new SelectionAdapter() {
 438                 @Override
 439                 public void widgetSelected(SelectionEvent e) {
 440                     setLegendText(mZoom.getSelectionIndex());
 441                     Client client = getCurrentClient();
 442                     if (client != null) {
 443                         renderHeapData(client.getClientData(), 1, true);
 444                         mTop.pack();
 445                     }
 446                 }
 447             });
 448
 449             createLegend(rightSection);
 450         }
 451         mHilbertBase.pack();
 452
 453         mLayout = new Composite[] { mStatisticsBase, mLinearBase, mHilbertBase };
 454         mDisplayMode.select(0);
 455         mDisplayMode.addSelectionListener(new SelectionAdapter() {
 456             @Override
 457             public void widgetSelected(SelectionEvent e) {
 458                 int index = mDisplayMode.getSelectionIndex();
 459                 Client client = getCurrentClient();
 460
 461                 if (client != null) {
 462                     if (index == 0) {
 463                         fillDetailedTable(client, true /* forceRedraw */);
 464                     } else {
 465                         renderHeapData(client.getClientData(), index-1, true /* forceRedraw */);
 466                     }
 467                 }
 468
 469                 mDisplayStack.topControl = mLayout[index];
 470                 //mScrolledComposite.setMinSize(mDisplayStack.topControl.computeSize(SWT.DEFAULT,
 471                 //        SWT.DEFAULT));
 472                 mDisplayBase.layout();
 473                 //mScrolledComposite.redraw();
 474             }
 475         });
 476
 477         //mScrolledComposite.setMinSize(mDisplayStack.topControl.computeSize(SWT.DEFAULT,
 478         //        SWT.DEFAULT));
 479         mDisplayBase.layout();
 480         //mScrolledComposite.redraw();
 481
 482         return mTop;
 483     }
 484
 485     /**
 486      * Sets the focus to the proper control inside the panel.
 487      */
 488     @Override
 489     public void setFocus() {
 490         mHeapSummary.setFocus();
 491     }
 492
 493
 494     private Table createSummaryTable(Composite base) {
 495         Table tab = new Table(base, SWT.SINGLE | SWT.FULL_SELECTION);
 496         tab.setHeaderVisible(true);
 497         tab.setLinesVisible(true);
 498
 499         TableColumn col;
 500
 501         col = new TableColumn(tab, SWT.RIGHT);
 502         col.setText("ID");
 503         col.pack();
 504
 505         col = new TableColumn(tab, SWT.RIGHT);
 506         col.setText("000.000WW"); //$NON-NLS-1$
 507         col.pack();
 508         col.setText("Heap Size");
 509
 510         col = new TableColumn(tab, SWT.RIGHT);
 511         col.setText("000.000WW"); //$NON-NLS-1$
 512         col.pack();
 513         col.setText("Allocated");
 514
 515         col = new TableColumn(tab, SWT.RIGHT);
 516         col.setText("000.000WW"); //$NON-NLS-1$
 517         col.pack();
 518         col.setText("Free");
 519
 520         col = new TableColumn(tab, SWT.RIGHT);
 521         col.setText("000.00%"); //$NON-NLS-1$
 522         col.pack();
 523         col.setText("% Used");
 524
 525         col = new TableColumn(tab, SWT.RIGHT);
 526         col.setText("000,000,000"); //$NON-NLS-1$
 527         col.pack();
 528         col.setText("# Objects");
 529
 530         return tab;
 531     }
 532
 533     private Table createDetailedTable(Composite base) {
 534         IPreferenceStore store = DdmUiPreferences.getStore();
 535
 536         Table tab = new Table(base, SWT.SINGLE | SWT.FULL_SELECTION);
 537         tab.setHeaderVisible(true);
 538         tab.setLinesVisible(true);
 539
 540         TableHelper.createTableColumn(tab, "Type", SWT.LEFT,
 541                 "4-byte array (object[], int[], float[])", //$NON-NLS-1$
 542                 PREFS_STATS_COL_TYPE, store);
 543
 544         TableHelper.createTableColumn(tab, "Count", SWT.RIGHT,
 545                 "00,000", //$NON-NLS-1$
 546                 PREFS_STATS_COL_COUNT, store);
 547
 548         TableHelper.createTableColumn(tab, "Total Size", SWT.RIGHT,
 549                 "000.000 WW", //$NON-NLS-1$
 550                 PREFS_STATS_COL_SIZE, store);
 551
 552         TableHelper.createTableColumn(tab, "Smallest", SWT.RIGHT,
 553                 "000.000 WW", //$NON-NLS-1$
 554                 PREFS_STATS_COL_SMALLEST, store);
 555
 556         TableHelper.createTableColumn(tab, "Largest", SWT.RIGHT,
 557                 "000.000 WW", //$NON-NLS-1$
 558                 PREFS_STATS_COL_LARGEST, store);
 559
 560         TableHelper.createTableColumn(tab, "Median", SWT.RIGHT,
 561                 "000.000 WW", //$NON-NLS-1$
 562                 PREFS_STATS_COL_MEDIAN, store);
 563
 564         TableHelper.createTableColumn(tab, "Average", SWT.RIGHT,
 565                 "000.000 WW", //$NON-NLS-1$
 566                 PREFS_STATS_COL_AVERAGE, store);
 567
 568         tab.addSelectionListener(new SelectionAdapter() {
 569             @Override
 570             public void widgetSelected(SelectionEvent e) {
 571
 572                 Client client = getCurrentClient();
 573                 if (client != null) {
 574                     int index = mStatisticsTable.getSelectionIndex();
 575                     TableItem item = mStatisticsTable.getItem(index);
 576
 577                     if (item != null) {
 578                         Map<Integer, ArrayList<HeapSegmentElement>> heapMap =
 579                             client.getClientData().getVmHeapData().getProcessedHeapMap();
 580
 581                         ArrayList<HeapSegmentElement> list = heapMap.get(item.getData());
 582                         if (list != null) {
 583                             showChart(list);
 584                         }
 585                     }
 586                 }
 587
 588             }
 589         });
 590
 591         return tab;
 592     }
 593
 594     /**
 595      * Creates the chart below the statistics table
 596      */
 597     private void createChart() {
 598         mAllocCountDataSet = new DefaultCategoryDataset();
 599         mChart = ChartFactory.createBarChart(null, "Size", "Count", mAllocCountDataSet,
 600                 PlotOrientation.VERTICAL, false, true, false);
 601
 602         // get the font to make a proper title. We need to convert the swt font,
 603         // into an awt font.
 604         Font f = mStatisticsBase.getFont();
 605         FontData[] fData = f.getFontData();
 606
 607         // event though on Mac OS there could be more than one fontData, we'll only use
 608         // the first one.
 609         FontData firstFontData = fData[0];
 610
 611         java.awt.Font awtFont = SWTUtils.toAwtFont(mStatisticsBase.getDisplay(),
 612                 firstFontData, true /* ensureSameSize */);
 613
 614         mChart.setTitle(new TextTitle("Allocation count per size", awtFont));
 615
 616         Plot plot = mChart.getPlot();
 617         if (plot instanceof CategoryPlot) {
 618             // get the plot
 619             CategoryPlot categoryPlot = (CategoryPlot)plot;
 620
 621             // set the domain axis to draw labels that are displayed even with many values.
 622             CategoryAxis domainAxis = categoryPlot.getDomainAxis();
 623             domainAxis.setCategoryLabelPositions(CategoryLabelPositions.DOWN_90);
 624
 625             CategoryItemRenderer renderer = categoryPlot.getRenderer();
 626             renderer.setBaseToolTipGenerator(new CategoryToolTipGenerator() {
 627                 public String generateToolTip(CategoryDataset dataset, int row, int column) {
 628                     // get the key for the size of the allocation
 629                     ByteLong columnKey = (ByteLong)dataset.getColumnKey(column);
 630                     String rowKey = (String)dataset.getRowKey(row);
 631                     Number value = dataset.getValue(rowKey, columnKey);
 632
 633                     return String.format("%1$d %2$s of %3$d bytes", value.intValue(), rowKey,
 634                             columnKey.getValue());
 635                 }
 636             });
 637         }
 638         mChartComposite = new ChartComposite(mStatisticsBase, SWT.BORDER, mChart,
 639                 ChartComposite.DEFAULT_WIDTH,
 640                 ChartComposite.DEFAULT_HEIGHT,
 641                 ChartComposite.DEFAULT_MINIMUM_DRAW_WIDTH,
 642                 ChartComposite.DEFAULT_MINIMUM_DRAW_HEIGHT,
 643                 3000, // max draw width. We don't want it to zoom, so we put a big number
 644                 3000, // max draw height. We don't want it to zoom, so we put a big number
 645                 true,  // off-screen buffer
 646                 true,  // properties
 647                 true,  // save
 648                 true,  // print
 649                 false,  // zoom
 650                 true);   // tooltips
 651
 652         mChartComposite.setLayoutData(new GridData(GridData.FILL_BOTH));
 653     }
 654
 655     private static String prettyByteCount(long bytes) {
 656         double fracBytes = bytes;
 657         String units = " B";
 658         if (fracBytes < 1024) {
 659             return sByteFormatter.format(fracBytes) + units;
 660         } else {
 661             fracBytes /= 1024;
 662             units = " KB";
 663         }
 664         if (fracBytes >= 1024) {
 665             fracBytes /= 1024;
 666             units = " MB";
 667         }
 668         if (fracBytes >= 1024) {
 669             fracBytes /= 1024;
 670             units = " GB";
 671         }
 672
 673         return sLargeByteFormatter.format(fracBytes) + units;
 674     }
 675
 676     private static String approximateByteCount(long bytes) {
 677         double fracBytes = bytes;
 678         String units = "";
 679         if (fracBytes >= 1024) {
 680             fracBytes /= 1024;
 681             units = "K";
 682         }
 683         if (fracBytes >= 1024) {
 684             fracBytes /= 1024;
 685             units = "M";
 686         }
 687         if (fracBytes >= 1024) {
 688             fracBytes /= 1024;
 689             units = "G";
 690         }
 691
 692         return sByteFormatter.format(fracBytes) + units;
 693     }
 694
 695     private static String addCommasToNumber(long num) {
 696         return sCountFormatter.format(num);
 697     }
 698
 699     private static String fractionalPercent(long num, long denom) {
 700         double val = (double)num / (double)denom;
 701         val *= 100;
 702
 703         NumberFormat nf = NumberFormat.getInstance();
 704         nf.setMinimumFractionDigits(2);
 705         nf.setMaximumFractionDigits(2);
 706         return nf.format(val) + "%";
 707     }
 708
 709     private void fillSummaryTable(ClientData cd) {
 710         if (mHeapSummary.isDisposed()) {
 711             return;
 712         }
 713
 714         mHeapSummary.setRedraw(false);
 715         mHeapSummary.removeAll();
 716
 717         if (cd != null) {
 718             synchronized (cd) {
 719                 Iterator<Integer> iter = cd.getVmHeapIds();
 720
 721                 while (iter.hasNext()) {
 722                     Integer id = iter.next();
 723                     Map<String, Long> heapInfo = cd.getVmHeapInfo(id);
 724                     if (heapInfo == null) {
 725                         continue;
 726                     }
 727                     long sizeInBytes = heapInfo.get(ClientData.HEAP_SIZE_BYTES);
 728                     long bytesAllocated = heapInfo.get(ClientData.HEAP_BYTES_ALLOCATED);
 729                     long objectsAllocated = heapInfo.get(ClientData.HEAP_OBJECTS_ALLOCATED);
 730
 731                     TableItem item = new TableItem(mHeapSummary, SWT.NONE);
 732                     item.setText(0, id.toString());
 733
 734                     item.setText(1, prettyByteCount(sizeInBytes));
 735                     item.setText(2, prettyByteCount(bytesAllocated));
 736                     item.setText(3, prettyByteCount(sizeInBytes - bytesAllocated));
 737                     item.setText(4, fractionalPercent(bytesAllocated, sizeInBytes));
 738                     item.setText(5, addCommasToNumber(objectsAllocated));
 739                 }
 740             }
 741         }
 742
 743         mHeapSummary.pack();
 744         mHeapSummary.setRedraw(true);
 745     }
 746
 747     private void fillDetailedTable(Client client, boolean forceRedraw) {
 748         // first check if the client is invalid or heap updates are not enabled.
 749         if (client == null || client.isHeapUpdateEnabled() == false) {
 750             mStatisticsTable.removeAll();
 751             showChart(null);
 752             return;
 753         }
 754
 755         ClientData cd = client.getClientData();
 756
 757         Map<Integer, ArrayList<HeapSegmentElement>> heapMap;
 758
 759         // Atomically get and clear the heap data.
 760         synchronized (cd) {
 761             if (serializeHeapData(cd.getVmHeapData()) == false && forceRedraw == false) {
 762                 // no change, we return.
 763                 return;
 764             }
 765
 766             heapMap = cd.getVmHeapData().getProcessedHeapMap();
 767         }
 768
 769         // we have new data, lets display it.
 770
 771         // First, get the current selection, and its key.
 772         int index = mStatisticsTable.getSelectionIndex();
 773         Integer selectedKey = null;
 774         if (index != -1) {
 775             selectedKey = (Integer)mStatisticsTable.getItem(index).getData();
 776         }
 777
 778         // disable redraws and remove all from the table.
 779         mStatisticsTable.setRedraw(false);
 780         mStatisticsTable.removeAll();
 781
 782         if (heapMap != null) {
 783             int selectedIndex = -1;
 784             ArrayList<HeapSegmentElement> selectedList = null;
 785
 786             // get the keys
 787             Set<Integer> keys = heapMap.keySet();
 788             int iter = 0; // use a manual iter int because Set<?> doesn't have an index
 789             // based accessor.
 790             for (Integer key : keys) {
 791                 ArrayList<HeapSegmentElement> list = heapMap.get(key);
 792
 793                 // check if this is the key that is supposed to be selected
 794                 if (key.equals(selectedKey)) {
 795                     selectedIndex = iter;
 796                     selectedList = list;
 797                 }
 798                 iter++;
 799
 800                 TableItem item = new TableItem(mStatisticsTable, SWT.NONE);
 801                 item.setData(key);
 802
 803                 // get the type
 804                 item.setText(0, mMapLegend[key]);
 805
 806                 // set the count, smallest, largest
 807                 int count = list.size();
 808                 item.setText(1, addCommasToNumber(count));
 809
 810                 if (count > 0) {
 811                     item.setText(3, prettyByteCount(list.get(0).getLength()));
 812                     item.setText(4, prettyByteCount(list.get(count-1).getLength()));
 813
 814                     int median = count / 2;
 815                     HeapSegmentElement element = list.get(median);
 816                     long size = element.getLength();
 817                     item.setText(5, prettyByteCount(size));
 818
 819                     long totalSize = 0;
 820                     for (int i = 0 ; i < count; i++) {
 821                         element = list.get(i);
 822
 823                         size = element.getLength();
 824                         totalSize += size;
 825                     }
 826
 827                     // set the average and total
 828                     item.setText(2, prettyByteCount(totalSize));
 829                     item.setText(6, prettyByteCount(totalSize / count));
 830                 }
 831             }
 832
 833             mStatisticsTable.setRedraw(true);
 834
 835             if (selectedIndex != -1) {
 836                 mStatisticsTable.setSelection(selectedIndex);
 837                 showChart(selectedList);
 838             } else {
 839                 showChart(null);
 840             }
 841         } else {
 842             mStatisticsTable.setRedraw(true);
 843         }
 844     }
 845
 846     private static class ByteLong implements Comparable<ByteLong> {
 847         private long mValue;
 848
 849         private ByteLong(long value) {
 850             mValue = value;
 851         }
 852
 853         public long getValue() {
 854             return mValue;
 855         }
 856
 857         @Override
 858         public String toString() {
 859             return approximateByteCount(mValue);
 860         }
 861
 862         public int compareTo(ByteLong other) {
 863             if (mValue != other.mValue) {
 864                 return mValue < other.mValue ? -1 : 1;
 865             }
 866             return 0;
 867         }
 868
 869     }
 870
 871     /**
 872      * Fills the chart with the content of the list of {@link HeapSegmentElement}.
 873      */
 874     private void showChart(ArrayList<HeapSegmentElement> list) {
 875         mAllocCountDataSet.clear();
 876
 877         if (list != null) {
 878             String rowKey = "Alloc Count";
 879
 880             long currentSize = -1;
 881             int currentCount = 0;
 882             for (HeapSegmentElement element : list) {
 883                 if (element.getLength() != currentSize) {
 884                     if (currentSize != -1) {
 885                         ByteLong columnKey = new ByteLong(currentSize);
 886                         mAllocCountDataSet.addValue(currentCount, rowKey, columnKey);
 887                     }
 888
 889                     currentSize = element.getLength();
 890                     currentCount = 1;
 891                 } else {
 892                     currentCount++;
 893                 }
 894             }
 895
 896             // add the last item
 897             if (currentSize != -1) {
 898                 ByteLong columnKey = new ByteLong(currentSize);
 899                 mAllocCountDataSet.addValue(currentCount, rowKey, columnKey);
 900             }
 901         }
 902     }
 903
 904     /*
 905      * Add a color legend to the specified table.
 906      */
 907     private void createLegend(Composite parent) {
 908         mLegend = new Group(parent, SWT.NONE);
 909         mLegend.setText(getLegendText(0));
 910
 911         mLegend.setLayout(new GridLayout(2, false));
 912
 913         RGB[] colors = mMapPalette.colors;
 914
 915         for (int i = 0; i < NUM_PALETTE_ENTRIES; i++) {
 916             Image tmpImage = createColorRect(parent.getDisplay(), colors[i]);
 917
 918             Label l = new Label(mLegend, SWT.NONE);
 919             l.setImage(tmpImage);
 920
 921             l = new Label(mLegend, SWT.NONE);
 922             l.setText(mMapLegend[i]);
 923         }
 924     }
 925
 926     private String getLegendText(int level) {
 927         int bytes = 8 * (100 / ZOOMS[level]);
 928
 929         return String.format("Key (1 pixel = %1$d bytes)", bytes);
 930     }
 931
 932     private void setLegendText(int level) {
 933         mLegend.setText(getLegendText(level));
 934
 935     }
 936
 937     /*
 938      * Create a nice rectangle in the specified color.
 939      */
 940     private Image createColorRect(Display display, RGB color) {
 941         int width = 32;
 942         int height = 16;
 943
 944         Image img = new Image(display, width, height);
 945         GC gc = new GC(img);
 946         gc.setBackground(new Color(display, color));
 947         gc.fillRectangle(0, 0, width, height);
 948         gc.dispose();
 949         return img;
 950     }
 951
 952
 953     /*
 954      * Are updates enabled?
 955      */
 956     private void setUpdateStatus(int status) {
 957         switch (status) {
 958             case NOT_SELECTED:
 959                 mUpdateStatus.setText("Select a client to see heap updates");
 960                 break;
 961             case NOT_ENABLED:
 962                 mUpdateStatus.setText("Heap updates are " +
 963                                       "NOT ENABLED for this client");
 964                 break;
 965             case ENABLED:
 966                 mUpdateStatus.setText("Heap updates will happen after " +
 967                                       "every GC for this client");
 968                 break;
 969             default:
 970                 throw new RuntimeException();
 971         }
 972
 973         mUpdateStatus.pack();
 974     }
 975
 976
 977     /**
 978      * Return the closest power of two greater than or equal to value.
 979      *
 980      * @param value the return value will be >= value
 981      * @return a power of two >= value.  If value > 2^31, 2^31 is returned.
 982      */
 983 //xxx use Integer.highestOneBit() or numberOfLeadingZeros().
 984     private int nextPow2(int value) {
 985         for (int i = 31; i >= 0; --i) {
 986             if ((value & (1<<i)) != 0) {
 987                 if (i < 31) {
 988                     return 1<<(i + 1);
 989                 } else {
 990                     return 1<<31;
 991                 }
 992             }
 993         }
 994         return 0;
 995     }
 996
 997     private int zOrderData(ImageData id, byte pixData[]) {
 998         int maxX = 0;
 999         for (int i = 0; i < pixData.length; i++) {
1000             /* Tread the pixData index as a z-order curve index and
1001              * decompose into Cartesian coordinates.
1002              */
1003             int x = (i & 1) |
1004                     ((i >>> 2) & 1) << 1 |
1005                     ((i >>> 4) & 1) << 2 |
1006                     ((i >>> 6) & 1) << 3 |
1007                     ((i >>> 8) & 1) << 4 |
1008                     ((i >>> 10) & 1) << 5 |
1009                     ((i >>> 12) & 1) << 6 |
1010                     ((i >>> 14) & 1) << 7 |
1011                     ((i >>> 16) & 1) << 8 |
1012                     ((i >>> 18) & 1) << 9 |
1013                     ((i >>> 20) & 1) << 10 |
1014                     ((i >>> 22) & 1) << 11 |
1015                     ((i >>> 24) & 1) << 12 |
1016                     ((i >>> 26) & 1) << 13 |
1017                     ((i >>> 28) & 1) << 14 |
1018                     ((i >>> 30) & 1) << 15;
1019             int y = ((i >>> 1) & 1) << 0 |
1020                     ((i >>> 3) & 1) << 1 |
1021                     ((i >>> 5) & 1) << 2 |
1022                     ((i >>> 7) & 1) << 3 |
1023                     ((i >>> 9) & 1) << 4 |
1024                     ((i >>> 11) & 1) << 5 |
1025                     ((i >>> 13) & 1) << 6 |
1026                     ((i >>> 15) & 1) << 7 |
1027                     ((i >>> 17) & 1) << 8 |
1028                     ((i >>> 19) & 1) << 9 |
1029                     ((i >>> 21) & 1) << 10 |
1030                     ((i >>> 23) & 1) << 11 |
1031                     ((i >>> 25) & 1) << 12 |
1032                     ((i >>> 27) & 1) << 13 |
1033                     ((i >>> 29) & 1) << 14 |
1034                     ((i >>> 31) & 1) << 15;
1035             try {
1036                 id.setPixel(x, y, pixData[i]);
1037                 if (x > maxX) {
1038                     maxX = x;
1039                 }
1040             } catch (IllegalArgumentException ex) {
1041                 System.out.println("bad pixels: i " + i +
1042                         ", w " + id.width +
1043                         ", h " + id.height +
1044                         ", x " + x +
1045                         ", y " + y);
1046                 throw ex;
1047             }
1048         }
1049         return maxX;
1050     }
1051
1052     private final static int HILBERT_DIR_N = 0;
1053     private final static int HILBERT_DIR_S = 1;
1054     private final static int HILBERT_DIR_E = 2;
1055     private final static int HILBERT_DIR_W = 3;
1056
1057     private void hilbertWalk(ImageData id, InputStream pixData,
1058                              int order, int x, int y, int dir)
1059                              throws IOException {
1060         if (x >= id.width || y >= id.height) {
1061             return;
1062         } else if (order == 0) {
1063             try {
1064                 int p = pixData.read();
1065                 if (p >= 0) {
1066                     // flip along x=y axis;  assume width == height
1067                     id.setPixel(y, x, p);
1068
1069                     /* Skanky; use an otherwise-unused ImageData field
1070                      * to keep track of the max x,y used. Note that x and y are inverted.
1071                      */
1072                     if (y > id.x) {
1073                         id.x = y;
1074                     }
1075                     if (x > id.y) {
1076                         id.y = x;
1077                     }
1078                 }
1079 //xxx just give up; don't bother walking the rest of the image
1080             } catch (IllegalArgumentException ex) {
1081                 System.out.println("bad pixels: order " + order +
1082                         ", dir " + dir +
1083                         ", w " + id.width +
1084                         ", h " + id.height +
1085                         ", x " + x +
1086                         ", y " + y);
1087                 throw ex;
1088             }
1089         } else {
1090             order--;
1091             int delta = 1 << order;
1092             int nextX = x + delta;
1093             int nextY = y + delta;
1094
1095             switch (dir) {
1096             case HILBERT_DIR_E:
1097                 hilbertWalk(id, pixData, order,     x,     y, HILBERT_DIR_N);
1098                 hilbertWalk(id, pixData, order,     x, nextY, HILBERT_DIR_E);
1099                 hilbertWalk(id, pixData, order, nextX, nextY, HILBERT_DIR_E);
1100                 hilbertWalk(id, pixData, order, nextX,     y, HILBERT_DIR_S);
1101                 break;
1102             case HILBERT_DIR_N:
1103                 hilbertWalk(id, pixData, order,     x,     y, HILBERT_DIR_E);
1104                 hilbertWalk(id, pixData, order, nextX,     y, HILBERT_DIR_N);
1105                 hilbertWalk(id, pixData, order, nextX, nextY, HILBERT_DIR_N);
1106                 hilbertWalk(id, pixData, order,     x, nextY, HILBERT_DIR_W);
1107                 break;
1108             case HILBERT_DIR_S:
1109                 hilbertWalk(id, pixData, order, nextX, nextY, HILBERT_DIR_W);
1110                 hilbertWalk(id, pixData, order,     x, nextY, HILBERT_DIR_S);
1111                 hilbertWalk(id, pixData, order,     x,     y, HILBERT_DIR_S);
1112                 hilbertWalk(id, pixData, order, nextX,     y, HILBERT_DIR_E);
1113                 break;
1114             case HILBERT_DIR_W:
1115                 hilbertWalk(id, pixData, order, nextX, nextY, HILBERT_DIR_S);
1116                 hilbertWalk(id, pixData, order, nextX,     y, HILBERT_DIR_W);
1117                 hilbertWalk(id, pixData, order,     x,     y, HILBERT_DIR_W);
1118                 hilbertWalk(id, pixData, order,     x, nextY, HILBERT_DIR_N);
1119                 break;
1120             default:
1121                 throw new RuntimeException("Unexpected Hilbert direction " +
1122                                            dir);
1123             }
1124         }
1125     }
1126
1127     private Point hilbertOrderData(ImageData id, byte pixData[]) {
1128
1129         int order = 0;
1130         for (int n = 1; n < id.width; n *= 2) {
1131             order++;
1132         }
1133         /* Skanky; use an otherwise-unused ImageData field
1134          * to keep track of maxX.
1135          */
1136         Point p = new Point(0,0);
1137         int oldIdX = id.x;
1138         int oldIdY = id.y;
1139         id.x = id.y = 0;
1140         try {
1141             hilbertWalk(id, new ByteArrayInputStream(pixData),
1142                         order, 0, 0, HILBERT_DIR_E);
1143             p.x = id.x;
1144             p.y = id.y;
1145         } catch (IOException ex) {
1146             System.err.println("Exception during hilbertWalk()");
1147             p.x = id.height;
1148             p.y = id.width;
1149         }
1150         id.x = oldIdX;
1151         id.y = oldIdY;
1152         return p;
1153     }
1154
1155     private ImageData createHilbertHeapImage(byte pixData[]) {
1156         int w, h;
1157
1158         // Pick an image size that the largest of heaps will fit into.
1159         w = (int)Math.sqrt((double)((16 * 1024 * 1024)/8));
1160
1161         // Space-filling curves require a power-of-2 width.
1162         w = nextPow2(w);
1163         h = w;
1164
1165         // Create the heap image.
1166         ImageData id = new ImageData(w, h, 8, mMapPalette);
1167
1168         // Copy the data into the image
1169         //int maxX = zOrderData(id, pixData);
1170         Point maxP = hilbertOrderData(id, pixData);
1171
1172         // update the max size to make it a round number once the zoom is applied
1173         int factor = 100 / ZOOMS[mZoom.getSelectionIndex()];
1174         if (factor != 1) {
1175             int tmp = maxP.x % factor;
1176             if (tmp != 0) {
1177                 maxP.x += factor - tmp;
1178             }
1179
1180             tmp = maxP.y % factor;
1181             if (tmp != 0) {
1182                 maxP.y += factor - tmp;
1183             }
1184         }
1185
1186         if (maxP.y < id.height) {
1187             // Crop the image down to the interesting part.
1188             id = new ImageData(id.width, maxP.y, id.depth, id.palette,
1189                                id.scanlinePad, id.data);
1190         }
1191
1192         if (maxP.x < id.width) {
1193             // crop the image again. A bit trickier this time.
1194            ImageData croppedId = new ImageData(maxP.x, id.height, id.depth, id.palette);
1195
1196            int[] buffer = new int[maxP.x];
1197            for (int l = 0 ; l < id.height; l++) {
1198                id.getPixels(0, l, maxP.x, buffer, 0);
1199                croppedId.setPixels(0, l, maxP.x, buffer, 0);
1200            }
1201
1202            id = croppedId;
1203         }
1204
1205         // apply the zoom
1206         if (factor != 1) {
1207             id = id.scaledTo(id.width / factor, id.height / factor);
1208         }
1209
1210         return id;
1211     }
1212
1213     /**
1214      * Convert the raw heap data to an image.  We know we're running in
1215      * the UI thread, so we can issue graphics commands directly.
1216      *
1217      * http://help.eclipse.org/help31/nftopic/org.eclipse.platform.doc.isv/reference/api/org/eclipse/swt/graphics/GC.html
1218      *
1219      * @param cd The client data
1220      * @param mode The display mode. 0 = linear, 1 = hilbert.
1221      * @param forceRedraw
1222      */
1223     private void renderHeapData(ClientData cd, int mode, boolean forceRedraw) {
1224         Image image;
1225
1226         byte[] pixData;
1227
1228         // Atomically get and clear the heap data.
1229         synchronized (cd) {
1230             if (serializeHeapData(cd.getVmHeapData()) == false && forceRedraw == false) {
1231                 // no change, we return.
1232                 return;
1233             }
1234
1235             pixData = getSerializedData();
1236         }
1237
1238         if (pixData != null) {
1239             ImageData id;
1240             if (mode == 1) {
1241                 id = createHilbertHeapImage(pixData);
1242             } else {
1243                 id = createLinearHeapImage(pixData, 200, mMapPalette);
1244             }
1245
1246             image = new Image(mDisplay, id);
1247         } else {
1248             // Render a placeholder image.
1249             int width, height;
1250             if (mode == 1) {
1251                 width = height = PLACEHOLDER_HILBERT_SIZE;
1252             } else {
1253                 width = PLACEHOLDER_LINEAR_H_SIZE;
1254                 height = PLACEHOLDER_LINEAR_V_SIZE;
1255             }
1256             image = new Image(mDisplay, width, height);
1257             GC gc = new GC(image);
1258             gc.setForeground(mDisplay.getSystemColor(SWT.COLOR_RED));
1259             gc.drawLine(0, 0, width-1, height-1);
1260             gc.dispose();
1261             gc = null;
1262         }
1263
1264         // set the new image
1265
1266         if (mode == 1) {
1267             if (mHilbertImage != null) {
1268                 mHilbertImage.dispose();
1269             }
1270
1271             mHilbertImage = image;
1272             mHilbertHeapImage.setImage(mHilbertImage);
1273             mHilbertHeapImage.pack(true);
1274             mHilbertBase.layout();
1275             mHilbertBase.pack(true);
1276         } else {
1277             if (mLinearImage != null) {
1278                 mLinearImage.dispose();
1279             }
1280
1281             mLinearImage = image;
1282             mLinearHeapImage.setImage(mLinearImage);
1283             mLinearHeapImage.pack(true);
1284             mLinearBase.layout();
1285             mLinearBase.pack(true);
1286         }
1287     }
1288
1289     @Override
1290     protected void setTableFocusListener() {
1291         addTableToFocusListener(mHeapSummary);
1292     }
1293 }
1294