| /* |
| * 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.NativeAllocationInfo; |
| import com.android.ddmlib.NativeLibraryMapInfo; |
| import com.android.ddmlib.NativeStackCallInfo; |
| import com.android.ddmlib.AndroidDebugBridge.IClientChangeListener; |
| import com.android.ddmlib.HeapSegment.HeapSegmentElement; |
| import com.android.ddmuilib.annotation.WorkerThread; |
| |
| 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.Image; |
| import org.eclipse.swt.graphics.ImageData; |
| import org.eclipse.swt.graphics.PaletteData; |
| import org.eclipse.swt.graphics.RGB; |
| import org.eclipse.swt.graphics.Rectangle; |
| import org.eclipse.swt.layout.FormAttachment; |
| import org.eclipse.swt.layout.FormData; |
| import org.eclipse.swt.layout.FormLayout; |
| 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.Event; |
| import org.eclipse.swt.widgets.FileDialog; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Listener; |
| import org.eclipse.swt.widgets.Sash; |
| import org.eclipse.swt.widgets.Table; |
| import org.eclipse.swt.widgets.TableItem; |
| |
| import java.io.BufferedWriter; |
| import java.io.FileWriter; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.text.DecimalFormat; |
| import java.text.NumberFormat; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| |
| /** |
| * Panel with native heap information. |
| */ |
| public final class NativeHeapPanel extends BaseHeapPanel { |
| |
| /** 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 int ALLOC_DISPLAY_ALL = 0; |
| private static final int ALLOC_DISPLAY_PRE_ZYGOTE = 1; |
| private static final int ALLOC_DISPLAY_POST_ZYGOTE = 2; |
| |
| private Display mDisplay; |
| |
| private Composite mBase; |
| |
| private Label mUpdateStatus; |
| |
| /** combo giving choice of what to display: all, pre-zygote, post-zygote */ |
| private Combo mAllocDisplayCombo; |
| |
| private Button mFullUpdateButton; |
| |
| // see CreateControl() |
| //private Button mDiffUpdateButton; |
| |
| private Combo mDisplayModeCombo; |
| |
| /** stack composite for mode (1-2) & 3 */ |
| private Composite mTopStackComposite; |
| |
| private StackLayout mTopStackLayout; |
| |
| /** stack composite for mode 1 & 2 */ |
| private Composite mAllocationStackComposite; |
| |
| private StackLayout mAllocationStackLayout; |
| |
| /** top level container for mode 1 & 2 */ |
| private Composite mTableModeControl; |
| |
| /** top level object for the allocation mode */ |
| private Control mAllocationModeTop; |
| |
| /** top level for the library mode */ |
| private Control mLibraryModeTopControl; |
| |
| /** composite for page UI and total memory display */ |
| private Composite mPageUIComposite; |
| |
| private Label mTotalMemoryLabel; |
| |
| private Label mPageLabel; |
| |
| private Button mPageNextButton; |
| |
| private Button mPagePreviousButton; |
| |
| private Table mAllocationTable; |
| |
| private Table mLibraryTable; |
| |
| private Table mLibraryAllocationTable; |
| |
| private Table mDetailTable; |
| |
| private Label mImage; |
| |
| private int mAllocDisplayMode = ALLOC_DISPLAY_ALL; |
| |
| /** |
| * pointer to current stackcall thread computation in order to quit it if |
| * required (new update requested) |
| */ |
| private StackCallThread mStackCallThread; |
| |
| /** Current Library Allocation table fill thread. killed if selection changes */ |
| private FillTableThread mFillTableThread; |
| |
| /** |
| * current client data. Used to access the malloc info when switching pages |
| * or selecting allocation to show stack call |
| */ |
| private ClientData mClientData; |
| |
| /** |
| * client data from a previous display. used when asking for an "update & diff" |
| */ |
| private ClientData mBackUpClientData; |
| |
| /** list of NativeAllocationInfo objects filled with the list from ClientData */ |
| private final ArrayList<NativeAllocationInfo> mAllocations = |
| new ArrayList<NativeAllocationInfo>(); |
| |
| /** list of the {@link NativeAllocationInfo} being displayed based on the selection |
| * of {@link #mAllocDisplayCombo}. |
| */ |
| private final ArrayList<NativeAllocationInfo> mDisplayedAllocations = |
| new ArrayList<NativeAllocationInfo>(); |
| |
| /** list of NativeAllocationInfo object kept as backup when doing an "update & diff" */ |
| private final ArrayList<NativeAllocationInfo> mBackUpAllocations = |
| new ArrayList<NativeAllocationInfo>(); |
| |
| /** back up of the total memory, used when doing an "update & diff" */ |
| private int mBackUpTotalMemory; |
| |
| private int mCurrentPage = 0; |
| |
| private int mPageCount = 0; |
| |
| /** |
| * list of allocation per Library. This is created from the list of |
| * NativeAllocationInfo objects that is stored in the ClientData object. Since we |
| * don't keep this list around, it is recomputed everytime the client |
| * changes. |
| */ |
| private final ArrayList<LibraryAllocations> mLibraryAllocations = |
| new ArrayList<LibraryAllocations>(); |
| |
| /* args to setUpdateStatus() */ |
| private static final int NOT_SELECTED = 0; |
| |
| private static final int NOT_ENABLED = 1; |
| |
| private static final int ENABLED = 2; |
| |
| private static final int DISPLAY_PER_PAGE = 20; |
| |
| private static final String PREFS_ALLOCATION_SASH = "NHallocSash"; //$NON-NLS-1$ |
| private static final String PREFS_LIBRARY_SASH = "NHlibrarySash"; //$NON-NLS-1$ |
| private static final String PREFS_DETAIL_ADDRESS = "NHdetailAddress"; //$NON-NLS-1$ |
| private static final String PREFS_DETAIL_LIBRARY = "NHdetailLibrary"; //$NON-NLS-1$ |
| private static final String PREFS_DETAIL_METHOD = "NHdetailMethod"; //$NON-NLS-1$ |
| private static final String PREFS_DETAIL_FILE = "NHdetailFile"; //$NON-NLS-1$ |
| private static final String PREFS_DETAIL_LINE = "NHdetailLine"; //$NON-NLS-1$ |
| private static final String PREFS_ALLOC_TOTAL = "NHallocTotal"; //$NON-NLS-1$ |
| private static final String PREFS_ALLOC_COUNT = "NHallocCount"; //$NON-NLS-1$ |
| private static final String PREFS_ALLOC_SIZE = "NHallocSize"; //$NON-NLS-1$ |
| private static final String PREFS_ALLOC_LIBRARY = "NHallocLib"; //$NON-NLS-1$ |
| private static final String PREFS_ALLOC_METHOD = "NHallocMethod"; //$NON-NLS-1$ |
| private static final String PREFS_ALLOC_FILE = "NHallocFile"; //$NON-NLS-1$ |
| private static final String PREFS_LIB_LIBRARY = "NHlibLibrary"; //$NON-NLS-1$ |
| private static final String PREFS_LIB_SIZE = "NHlibSize"; //$NON-NLS-1$ |
| private static final String PREFS_LIB_COUNT = "NHlibCount"; //$NON-NLS-1$ |
| private static final String PREFS_LIBALLOC_TOTAL = "NHlibAllocTotal"; //$NON-NLS-1$ |
| private static final String PREFS_LIBALLOC_COUNT = "NHlibAllocCount"; //$NON-NLS-1$ |
| private static final String PREFS_LIBALLOC_SIZE = "NHlibAllocSize"; //$NON-NLS-1$ |
| private static final String PREFS_LIBALLOC_METHOD = "NHlibAllocMethod"; //$NON-NLS-1$ |
| |
| /** static formatter object to format all numbers as #,### */ |
| private static DecimalFormat sFormatter; |
| static { |
| sFormatter = (DecimalFormat)NumberFormat.getInstance(); |
| if (sFormatter != null) |
| sFormatter = new DecimalFormat("#,###"); |
| else |
| sFormatter.applyPattern("#,###"); |
| } |
| |
| |
| /** |
| * caching mechanism to avoid recomputing the backtrace for a particular |
| * address several times. |
| */ |
| private HashMap<Long, NativeStackCallInfo> mSourceCache = |
| new HashMap<Long,NativeStackCallInfo>(); |
| private long mTotalSize; |
| private Button mSaveButton; |
| private Button mSymbolsButton; |
| |
| /** |
| * thread class to convert the address call into method, file and line |
| * number in the background. |
| */ |
| private class StackCallThread extends BackgroundThread { |
| private ClientData mClientData; |
| |
| public StackCallThread(ClientData cd) { |
| mClientData = cd; |
| } |
| |
| public ClientData getClientData() { |
| return mClientData; |
| } |
| |
| @Override |
| public void run() { |
| // loop through all the NativeAllocationInfo and init them |
| Iterator<NativeAllocationInfo> iter = mAllocations.iterator(); |
| int total = mAllocations.size(); |
| int count = 0; |
| while (iter.hasNext()) { |
| |
| if (isQuitting()) |
| return; |
| |
| NativeAllocationInfo info = iter.next(); |
| if (info.isStackCallResolved() == false) { |
| final Long[] list = info.getStackCallAddresses(); |
| final int size = list.length; |
| |
| ArrayList<NativeStackCallInfo> resolvedStackCall = |
| new ArrayList<NativeStackCallInfo>(); |
| |
| for (int i = 0; i < size; i++) { |
| long addr = list[i]; |
| |
| // first check if the addr has already been converted. |
| NativeStackCallInfo source = mSourceCache.get(addr); |
| |
| // if not we convert it |
| if (source == null) { |
| source = sourceForAddr(addr); |
| mSourceCache.put(addr, source); |
| } |
| |
| resolvedStackCall.add(source); |
| } |
| |
| info.setResolvedStackCall(resolvedStackCall); |
| } |
| // after every DISPLAY_PER_PAGE we ask for a ui refresh, unless |
| // we reach total, since we also do it after the loop |
| // (only an issue in case we have a perfect number of page) |
| count++; |
| if ((count % DISPLAY_PER_PAGE) == 0 && count != total) { |
| if (updateNHAllocationStackCalls(mClientData, count) == false) { |
| // looks like the app is quitting, so we just |
| // stopped the thread |
| return; |
| } |
| } |
| } |
| |
| updateNHAllocationStackCalls(mClientData, count); |
| } |
| |
| private NativeStackCallInfo sourceForAddr(long addr) { |
| NativeLibraryMapInfo library = getLibraryFor(addr); |
| |
| if (library != null) { |
| |
| Addr2Line process = Addr2Line.getProcess(library.getLibraryName()); |
| if (process != null) { |
| // remove the base of the library address |
| long value = addr - library.getStartAddress(); |
| NativeStackCallInfo info = process.getAddress(value); |
| if (info != null) { |
| return info; |
| } |
| } |
| } |
| |
| return new NativeStackCallInfo(library != null ? library.getLibraryName() : null, |
| Long.toHexString(addr), ""); |
| } |
| |
| private NativeLibraryMapInfo getLibraryFor(long addr) { |
| Iterator<NativeLibraryMapInfo> it = mClientData.getNativeLibraryMapInfo(); |
| |
| while (it.hasNext()) { |
| NativeLibraryMapInfo info = it.next(); |
| |
| if (info.isWithinLibrary(addr)) { |
| return info; |
| } |
| } |
| |
| Log.d("ddm-nativeheap", "Failed finding Library for " + Long.toHexString(addr)); |
| return null; |
| } |
| |
| /** |
| * update the Native Heap panel with the amount of allocation for which the |
| * stack call has been computed. This is called from a non UI thread, but |
| * will be executed in the UI thread. |
| * |
| * @param count the amount of allocation |
| * @return false if the display was disposed and the update couldn't happen |
| */ |
| private boolean updateNHAllocationStackCalls(final ClientData clientData, final int count) { |
| if (mDisplay.isDisposed() == false) { |
| mDisplay.asyncExec(new Runnable() { |
| public void run() { |
| updateAllocationStackCalls(clientData, count); |
| } |
| }); |
| return true; |
| } |
| return false; |
| } |
| } |
| |
| private class FillTableThread extends BackgroundThread { |
| private LibraryAllocations mLibAlloc; |
| |
| private int mMax; |
| |
| public FillTableThread(LibraryAllocations liballoc, int m) { |
| mLibAlloc = liballoc; |
| mMax = m; |
| } |
| |
| @Override |
| public void run() { |
| for (int i = mMax; i > 0 && isQuitting() == false; i -= 10) { |
| updateNHLibraryAllocationTable(mLibAlloc, mMax - i, mMax - i + 10); |
| } |
| } |
| |
| /** |
| * updates the library allocation table in the Native Heap panel. This is |
| * called from a non UI thread, but will be executed in the UI thread. |
| * |
| * @param liballoc the current library allocation object being displayed |
| * @param start start index of items that need to be displayed |
| * @param end end index of the items that need to be displayed |
| */ |
| private void updateNHLibraryAllocationTable(final LibraryAllocations libAlloc, |
| final int start, final int end) { |
| if (mDisplay.isDisposed() == false) { |
| mDisplay.asyncExec(new Runnable() { |
| public void run() { |
| updateLibraryAllocationTable(libAlloc, start, end); |
| } |
| }); |
| } |
| |
| } |
| } |
| |
| /** class to aggregate allocations per library */ |
| public static class LibraryAllocations { |
| private String mLibrary; |
| |
| private final ArrayList<NativeAllocationInfo> mLibAllocations = |
| new ArrayList<NativeAllocationInfo>(); |
| |
| private int mSize; |
| |
| private int mCount; |
| |
| /** construct the aggregate object for a library */ |
| public LibraryAllocations(final String lib) { |
| mLibrary = lib; |
| } |
| |
| /** get the library name */ |
| public String getLibrary() { |
| return mLibrary; |
| } |
| |
| /** add a NativeAllocationInfo object to this aggregate object */ |
| public void addAllocation(NativeAllocationInfo info) { |
| mLibAllocations.add(info); |
| } |
| |
| /** get an iterator on the NativeAllocationInfo objects */ |
| public Iterator<NativeAllocationInfo> getAllocations() { |
| return mLibAllocations.iterator(); |
| } |
| |
| /** get a NativeAllocationInfo object by index */ |
| public NativeAllocationInfo getAllocation(int index) { |
| return mLibAllocations.get(index); |
| } |
| |
| /** returns the NativeAllocationInfo object count */ |
| public int getAllocationSize() { |
| return mLibAllocations.size(); |
| } |
| |
| /** returns the total allocation size */ |
| public int getSize() { |
| return mSize; |
| } |
| |
| /** returns the number of allocations */ |
| public int getCount() { |
| return mCount; |
| } |
| |
| /** |
| * compute the allocation count and size for allocation objects added |
| * through <code>addAllocation()</code>, and sort the objects by |
| * total allocation size. |
| */ |
| public void computeAllocationSizeAndCount() { |
| mSize = 0; |
| mCount = 0; |
| for (NativeAllocationInfo info : mLibAllocations) { |
| mCount += info.getAllocationCount(); |
| mSize += info.getAllocationCount() * info.getSize(); |
| } |
| Collections.sort(mLibAllocations, new Comparator<NativeAllocationInfo>() { |
| public int compare(NativeAllocationInfo o1, NativeAllocationInfo o2) { |
| return o2.getAllocationCount() * o2.getSize() - |
| o1.getAllocationCount() * o1.getSize(); |
| } |
| }); |
| } |
| } |
| |
| /** |
| * Create our control(s). |
| */ |
| @Override |
| protected Control createControl(Composite parent) { |
| |
| mDisplay = parent.getDisplay(); |
| |
| mBase = new Composite(parent, SWT.NONE); |
| GridLayout gl = new GridLayout(1, false); |
| gl.horizontalSpacing = 0; |
| gl.verticalSpacing = 0; |
| mBase.setLayout(gl); |
| mBase.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| // composite for <update btn> <status> |
| Composite tmp = new Composite(mBase, SWT.NONE); |
| tmp.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| tmp.setLayout(gl = new GridLayout(2, false)); |
| gl.marginWidth = gl.marginHeight = 0; |
| |
| mFullUpdateButton = new Button(tmp, SWT.NONE); |
| mFullUpdateButton.setText("Full Update"); |
| mFullUpdateButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| mBackUpClientData = null; |
| mDisplayModeCombo.setEnabled(false); |
| mSaveButton.setEnabled(false); |
| emptyTables(); |
| // if we already have a stack call computation for this |
| // client |
| // we stop it |
| if (mStackCallThread != null && |
| mStackCallThread.getClientData() == mClientData) { |
| mStackCallThread.quit(); |
| mStackCallThread = null; |
| } |
| mLibraryAllocations.clear(); |
| Client client = getCurrentClient(); |
| if (client != null) { |
| client.requestNativeHeapInformation(); |
| } |
| } |
| }); |
| |
| mUpdateStatus = new Label(tmp, SWT.NONE); |
| mUpdateStatus.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| |
| // top layout for the combos and oter controls on the right. |
| Composite top_layout = new Composite(mBase, SWT.NONE); |
| top_layout.setLayout(gl = new GridLayout(4, false)); |
| gl.marginWidth = gl.marginHeight = 0; |
| |
| new Label(top_layout, SWT.NONE).setText("Show:"); |
| |
| mAllocDisplayCombo = new Combo(top_layout, SWT.DROP_DOWN | SWT.READ_ONLY); |
| mAllocDisplayCombo.setLayoutData(new GridData( |
| GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL)); |
| mAllocDisplayCombo.add("All Allocations"); |
| mAllocDisplayCombo.add("Pre-Zygote Allocations"); |
| mAllocDisplayCombo.add("Zygote Child Allocations (Z)"); |
| mAllocDisplayCombo.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| onAllocDisplayChange(); |
| } |
| }); |
| mAllocDisplayCombo.select(0); |
| |
| // separator |
| Label separator = new Label(top_layout, SWT.SEPARATOR | SWT.VERTICAL); |
| GridData gd; |
| separator.setLayoutData(gd = new GridData( |
| GridData.VERTICAL_ALIGN_FILL | GridData.GRAB_VERTICAL)); |
| gd.heightHint = 0; |
| gd.verticalSpan = 2; |
| |
| mSaveButton = new Button(top_layout, SWT.PUSH); |
| mSaveButton.setText("Save..."); |
| mSaveButton.setEnabled(false); |
| mSaveButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| FileDialog fileDialog = new FileDialog(mBase.getShell(), SWT.SAVE); |
| |
| fileDialog.setText("Save Allocations"); |
| fileDialog.setFileName("allocations.txt"); |
| |
| String fileName = fileDialog.open(); |
| if (fileName != null) { |
| saveAllocations(fileName); |
| } |
| } |
| }); |
| |
| /* |
| * TODO: either fix the diff mechanism or remove it altogether. |
| mDiffUpdateButton = new Button(top_layout, SWT.NONE); |
| mDiffUpdateButton.setText("Update && Diff"); |
| mDiffUpdateButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| // since this is an update and diff, we need to store the |
| // current list |
| // of mallocs |
| mBackUpAllocations.clear(); |
| mBackUpAllocations.addAll(mAllocations); |
| mBackUpClientData = mClientData; |
| mBackUpTotalMemory = mClientData.getTotalNativeMemory(); |
| |
| mDisplayModeCombo.setEnabled(false); |
| emptyTables(); |
| // if we already have a stack call computation for this |
| // client |
| // we stop it |
| if (mStackCallThread != null && |
| mStackCallThread.getClientData() == mClientData) { |
| mStackCallThread.quit(); |
| mStackCallThread = null; |
| } |
| mLibraryAllocations.clear(); |
| Client client = getCurrentClient(); |
| if (client != null) { |
| client.requestNativeHeapInformation(); |
| } |
| } |
| }); |
| */ |
| |
| Label l = new Label(top_layout, SWT.NONE); |
| l.setText("Display:"); |
| |
| mDisplayModeCombo = new Combo(top_layout, SWT.DROP_DOWN | SWT.READ_ONLY); |
| mDisplayModeCombo.setLayoutData(new GridData( |
| GridData.HORIZONTAL_ALIGN_FILL | GridData.GRAB_HORIZONTAL)); |
| mDisplayModeCombo.setItems(new String[] { "Allocation List", "By Libraries" }); |
| mDisplayModeCombo.select(0); |
| mDisplayModeCombo.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| switchDisplayMode(); |
| } |
| }); |
| mDisplayModeCombo.setEnabled(false); |
| |
| mSymbolsButton = new Button(top_layout, SWT.PUSH); |
| mSymbolsButton.setText("Load Symbols"); |
| mSymbolsButton.setEnabled(false); |
| |
| |
| // create a composite that will contains the actual content composites, |
| // in stack mode layout. |
| // This top level composite contains 2 other composites. |
| // * one for both Allocations and Libraries mode |
| // * one for flat mode (which is gone for now) |
| |
| mTopStackComposite = new Composite(mBase, SWT.NONE); |
| mTopStackComposite.setLayout(mTopStackLayout = new StackLayout()); |
| mTopStackComposite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| // create 1st and 2nd modes |
| createTableDisplay(mTopStackComposite); |
| |
| mTopStackLayout.topControl = mTableModeControl; |
| mTopStackComposite.layout(); |
| |
| setUpdateStatus(NOT_SELECTED); |
| |
| // Work in progress |
| // TODO add image display of native heap. |
| //mImage = new Label(mBase, SWT.NONE); |
| |
| mBase.pack(); |
| |
| return mBase; |
| } |
| |
| /** |
| * Sets the focus to the proper control inside the panel. |
| */ |
| @Override |
| public void setFocus() { |
| // TODO |
| } |
| |
| |
| /** |
| * 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_NATIVE_HEAP_DATA) == Client.CHANGE_NATIVE_HEAP_DATA) { |
| if (mBase.isDisposed()) |
| return; |
| |
| mBase.getDisplay().asyncExec(new Runnable() { |
| public void run() { |
| clientSelected(); |
| } |
| }); |
| } |
| } |
| } |
| |
| /** |
| * 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 (mBase.isDisposed()) |
| return; |
| |
| Client client = getCurrentClient(); |
| |
| mDisplayModeCombo.setEnabled(false); |
| emptyTables(); |
| |
| Log.d("ddms", "NativeHeapPanel: changed " + client); |
| |
| if (client != null) { |
| ClientData cd = client.getClientData(); |
| mClientData = cd; |
| |
| // if (cd.getShowHeapUpdates()) |
| setUpdateStatus(ENABLED); |
| // else |
| // setUpdateStatus(NOT_ENABLED); |
| |
| initAllocationDisplay(); |
| |
| //renderBitmap(cd); |
| } else { |
| mClientData = null; |
| setUpdateStatus(NOT_SELECTED); |
| } |
| |
| mBase.pack(); |
| } |
| |
| /** |
| * Update the UI with the newly compute stack calls, unless the UI switched |
| * to a different client. |
| * |
| * @param cd the ClientData for which the stack call are being computed. |
| * @param count the current count of allocations for which the stack calls |
| * have been computed. |
| */ |
| @WorkerThread |
| public void updateAllocationStackCalls(ClientData cd, int count) { |
| // we have to check that the panel still shows the same clientdata than |
| // the thread is computing for. |
| if (cd == mClientData) { |
| |
| int total = mAllocations.size(); |
| |
| if (count == total) { |
| // we're done: do something |
| mDisplayModeCombo.setEnabled(true); |
| mSaveButton.setEnabled(true); |
| |
| mStackCallThread = null; |
| } else { |
| // work in progress, update the progress bar. |
| // mUiThread.setStatusLine("Computing stack call: " + count |
| // + "/" + total); |
| } |
| |
| // FIXME: attempt to only update when needed. |
| // Because the number of pages is not related to mAllocations.size() anymore |
| // due to pre-zygote/post-zygote display, update all the time. |
| // At some point we should remove the pages anyway, since it's getting computed |
| // really fast now. |
| // if ((mCurrentPage + 1) * DISPLAY_PER_PAGE == count |
| // || (count == total && mCurrentPage == mPageCount - 1)) { |
| try { |
| // get the current selection of the allocation |
| int index = mAllocationTable.getSelectionIndex(); |
| NativeAllocationInfo info = null; |
| |
| if (index != -1) { |
| info = (NativeAllocationInfo)mAllocationTable.getItem(index).getData(); |
| } |
| |
| // empty the table |
| emptyTables(); |
| |
| // fill it again |
| fillAllocationTable(); |
| |
| // reselect |
| mAllocationTable.setSelection(index); |
| |
| // display detail table if needed |
| if (info != null) { |
| fillDetailTable(info); |
| } |
| } catch (SWTException e) { |
| if (mAllocationTable.isDisposed()) { |
| // looks like the table is disposed. Let's ignore it. |
| } else { |
| throw e; |
| } |
| } |
| |
| } else { |
| // old client still running. doesn't really matter. |
| } |
| } |
| |
| @Override |
| protected void setTableFocusListener() { |
| addTableToFocusListener(mAllocationTable); |
| addTableToFocusListener(mLibraryTable); |
| addTableToFocusListener(mLibraryAllocationTable); |
| addTableToFocusListener(mDetailTable); |
| } |
| |
| protected void onAllocDisplayChange() { |
| mAllocDisplayMode = mAllocDisplayCombo.getSelectionIndex(); |
| |
| // create the new list |
| updateAllocDisplayList(); |
| |
| updateTotalMemoryDisplay(); |
| |
| // reset the ui. |
| mCurrentPage = 0; |
| updatePageUI(); |
| switchDisplayMode(); |
| } |
| |
| private void updateAllocDisplayList() { |
| mTotalSize = 0; |
| mDisplayedAllocations.clear(); |
| for (NativeAllocationInfo info : mAllocations) { |
| if (mAllocDisplayMode == ALLOC_DISPLAY_ALL || |
| (mAllocDisplayMode == ALLOC_DISPLAY_PRE_ZYGOTE ^ info.isZygoteChild())) { |
| mDisplayedAllocations.add(info); |
| mTotalSize += info.getSize() * info.getAllocationCount(); |
| } else { |
| // skip this item |
| continue; |
| } |
| } |
| |
| int count = mDisplayedAllocations.size(); |
| |
| mPageCount = count / DISPLAY_PER_PAGE; |
| |
| // need to add a page for the rest of the div |
| if ((count % DISPLAY_PER_PAGE) > 0) { |
| mPageCount++; |
| } |
| } |
| |
| private void updateTotalMemoryDisplay() { |
| switch (mAllocDisplayMode) { |
| case ALLOC_DISPLAY_ALL: |
| mTotalMemoryLabel.setText(String.format("Total Memory: %1$s Bytes", |
| sFormatter.format(mTotalSize))); |
| break; |
| case ALLOC_DISPLAY_PRE_ZYGOTE: |
| mTotalMemoryLabel.setText(String.format("Zygote Memory: %1$s Bytes", |
| sFormatter.format(mTotalSize))); |
| break; |
| case ALLOC_DISPLAY_POST_ZYGOTE: |
| mTotalMemoryLabel.setText(String.format("Post-zygote Memory: %1$s Bytes", |
| sFormatter.format(mTotalSize))); |
| break; |
| } |
| } |
| |
| |
| private void switchDisplayMode() { |
| switch (mDisplayModeCombo.getSelectionIndex()) { |
| case 0: {// allocations |
| mTopStackLayout.topControl = mTableModeControl; |
| mAllocationStackLayout.topControl = mAllocationModeTop; |
| mAllocationStackComposite.layout(); |
| mTopStackComposite.layout(); |
| emptyTables(); |
| fillAllocationTable(); |
| } |
| break; |
| case 1: {// libraries |
| mTopStackLayout.topControl = mTableModeControl; |
| mAllocationStackLayout.topControl = mLibraryModeTopControl; |
| mAllocationStackComposite.layout(); |
| mTopStackComposite.layout(); |
| emptyTables(); |
| fillLibraryTable(); |
| } |
| break; |
| } |
| } |
| |
| private void initAllocationDisplay() { |
| mAllocations.clear(); |
| mAllocations.addAll(mClientData.getNativeAllocationList()); |
| |
| updateAllocDisplayList(); |
| |
| // if we have a previous clientdata and it matches the current one. we |
| // do a diff between the new list and the old one. |
| if (mBackUpClientData != null && mBackUpClientData == mClientData) { |
| |
| ArrayList<NativeAllocationInfo> add = new ArrayList<NativeAllocationInfo>(); |
| |
| // we go through the list of NativeAllocationInfo in the new list and check if |
| // there's one with the same exact data (size, allocation, count and |
| // stackcall addresses) in the old list. |
| // if we don't find any, we add it to the "add" list |
| for (NativeAllocationInfo mi : mAllocations) { |
| boolean found = false; |
| for (NativeAllocationInfo old_mi : mBackUpAllocations) { |
| if (mi.equals(old_mi)) { |
| found = true; |
| break; |
| } |
| } |
| if (found == false) { |
| add.add(mi); |
| } |
| } |
| |
| // put the result in mAllocations |
| mAllocations.clear(); |
| mAllocations.addAll(add); |
| |
| // display the difference in memory usage. This is computed |
| // calculating the memory usage of the objects in mAllocations. |
| int count = 0; |
| for (NativeAllocationInfo allocInfo : mAllocations) { |
| count += allocInfo.getSize() * allocInfo.getAllocationCount(); |
| } |
| |
| mTotalMemoryLabel.setText(String.format("Memory Difference: %1$s Bytes", |
| sFormatter.format(count))); |
| } |
| else { |
| // display the full memory usage |
| updateTotalMemoryDisplay(); |
| //mDiffUpdateButton.setEnabled(mClientData.getTotalNativeMemory() > 0); |
| } |
| mTotalMemoryLabel.pack(); |
| |
| // update the page ui |
| mDisplayModeCombo.select(0); |
| |
| mLibraryAllocations.clear(); |
| |
| // reset to first page |
| mCurrentPage = 0; |
| |
| // update the label |
| updatePageUI(); |
| |
| // now fill the allocation Table with the current page |
| switchDisplayMode(); |
| |
| // start the thread to compute the stack calls |
| if (mAllocations.size() > 0) { |
| mStackCallThread = new StackCallThread(mClientData); |
| mStackCallThread.start(); |
| } |
| } |
| |
| private void updatePageUI() { |
| |
| // set the label and pack to update the layout, otherwise |
| // the label will be cut off if the new size is bigger |
| if (mPageCount == 0) { |
| mPageLabel.setText("0 of 0 allocations."); |
| } else { |
| StringBuffer buffer = new StringBuffer(); |
| // get our starting index |
| int start = (mCurrentPage * DISPLAY_PER_PAGE) + 1; |
| // end index, taking into account the last page can be half full |
| int count = mDisplayedAllocations.size(); |
| int end = Math.min(start + DISPLAY_PER_PAGE - 1, count); |
| buffer.append(sFormatter.format(start)); |
| buffer.append(" - "); |
| buffer.append(sFormatter.format(end)); |
| buffer.append(" of "); |
| buffer.append(sFormatter.format(count)); |
| buffer.append(" allocations."); |
| mPageLabel.setText(buffer.toString()); |
| } |
| |
| // handle the button enabled state. |
| mPagePreviousButton.setEnabled(mCurrentPage > 0); |
| // reminder: mCurrentPage starts at 0. |
| mPageNextButton.setEnabled(mCurrentPage < mPageCount - 1); |
| |
| mPageLabel.pack(); |
| mPageUIComposite.pack(); |
| |
| } |
| |
| private void fillAllocationTable() { |
| // get the count |
| int count = mDisplayedAllocations.size(); |
| |
| // get our starting index |
| int start = mCurrentPage * DISPLAY_PER_PAGE; |
| |
| // loop for DISPLAY_PER_PAGE or till we reach count |
| int end = start + DISPLAY_PER_PAGE; |
| |
| for (int i = start; i < end && i < count; i++) { |
| NativeAllocationInfo info = mDisplayedAllocations.get(i); |
| |
| TableItem item = null; |
| |
| if (mAllocDisplayMode == ALLOC_DISPLAY_ALL) { |
| item = new TableItem(mAllocationTable, SWT.NONE); |
| item.setText(0, (info.isZygoteChild() ? "Z " : "") + |
| sFormatter.format(info.getSize() * info.getAllocationCount())); |
| item.setText(1, sFormatter.format(info.getAllocationCount())); |
| item.setText(2, sFormatter.format(info.getSize())); |
| } else if (mAllocDisplayMode == ALLOC_DISPLAY_PRE_ZYGOTE ^ info.isZygoteChild()) { |
| item = new TableItem(mAllocationTable, SWT.NONE); |
| item.setText(0, sFormatter.format(info.getSize() * info.getAllocationCount())); |
| item.setText(1, sFormatter.format(info.getAllocationCount())); |
| item.setText(2, sFormatter.format(info.getSize())); |
| } else { |
| // skip this item |
| continue; |
| } |
| |
| item.setData(info); |
| |
| NativeStackCallInfo bti = info.getRelevantStackCallInfo(); |
| if (bti != null) { |
| String lib = bti.getLibraryName(); |
| String method = bti.getMethodName(); |
| String source = bti.getSourceFile(); |
| if (lib != null) |
| item.setText(3, lib); |
| if (method != null) |
| item.setText(4, method); |
| if (source != null) |
| item.setText(5, source); |
| } |
| } |
| } |
| |
| private void fillLibraryTable() { |
| // fill the library table |
| sortAllocationsPerLibrary(); |
| |
| for (LibraryAllocations liballoc : mLibraryAllocations) { |
| if (liballoc != null) { |
| TableItem item = new TableItem(mLibraryTable, SWT.NONE); |
| String lib = liballoc.getLibrary(); |
| item.setText(0, lib != null ? lib : ""); |
| item.setText(1, sFormatter.format(liballoc.getSize())); |
| item.setText(2, sFormatter.format(liballoc.getCount())); |
| } |
| } |
| } |
| |
| private void fillLibraryAllocationTable() { |
| mLibraryAllocationTable.removeAll(); |
| mDetailTable.removeAll(); |
| int index = mLibraryTable.getSelectionIndex(); |
| if (index != -1) { |
| LibraryAllocations liballoc = mLibraryAllocations.get(index); |
| // start a thread that will fill table 10 at a time to keep the ui |
| // responsive, but first we kill the previous one if there was one |
| if (mFillTableThread != null) { |
| mFillTableThread.quit(); |
| } |
| mFillTableThread = new FillTableThread(liballoc, |
| liballoc.getAllocationSize()); |
| mFillTableThread.start(); |
| } |
| } |
| |
| public void updateLibraryAllocationTable(LibraryAllocations liballoc, |
| int start, int end) { |
| try { |
| if (mLibraryTable.isDisposed() == false) { |
| int index = mLibraryTable.getSelectionIndex(); |
| if (index != -1) { |
| LibraryAllocations newliballoc = mLibraryAllocations.get( |
| index); |
| if (newliballoc == liballoc) { |
| int count = liballoc.getAllocationSize(); |
| for (int i = start; i < end && i < count; i++) { |
| NativeAllocationInfo info = liballoc.getAllocation(i); |
| |
| TableItem item = new TableItem( |
| mLibraryAllocationTable, SWT.NONE); |
| item.setText(0, sFormatter.format( |
| info.getSize() * info.getAllocationCount())); |
| item.setText(1, sFormatter.format(info.getAllocationCount())); |
| item.setText(2, sFormatter.format(info.getSize())); |
| |
| NativeStackCallInfo stackCallInfo = info.getRelevantStackCallInfo(); |
| if (stackCallInfo != null) { |
| item.setText(3, stackCallInfo.getMethodName()); |
| } |
| } |
| } else { |
| // we should quit the thread |
| if (mFillTableThread != null) { |
| mFillTableThread.quit(); |
| mFillTableThread = null; |
| } |
| } |
| } |
| } |
| } catch (SWTException e) { |
| Log.e("ddms", "error when updating the library allocation table"); |
| } |
| } |
| |
| private void fillDetailTable(final NativeAllocationInfo mi) { |
| mDetailTable.removeAll(); |
| mDetailTable.setRedraw(false); |
| |
| try { |
| // populate the detail Table with the back trace |
| Long[] addresses = mi.getStackCallAddresses(); |
| NativeStackCallInfo[] resolvedStackCall = mi.getResolvedStackCall(); |
| |
| if (resolvedStackCall == null) { |
| return; |
| } |
| |
| for (int i = 0 ; i < resolvedStackCall.length ; i++) { |
| if (addresses[i] == null || addresses[i].longValue() == 0) { |
| continue; |
| } |
| |
| long addr = addresses[i].longValue(); |
| NativeStackCallInfo source = resolvedStackCall[i]; |
| |
| TableItem item = new TableItem(mDetailTable, SWT.NONE); |
| item.setText(0, String.format("%08x", addr)); //$NON-NLS-1$ |
| |
| String libraryName = source.getLibraryName(); |
| String methodName = source.getMethodName(); |
| String sourceFile = source.getSourceFile(); |
| int lineNumber = source.getLineNumber(); |
| |
| if (libraryName != null) |
| item.setText(1, libraryName); |
| if (methodName != null) |
| item.setText(2, methodName); |
| if (sourceFile != null) |
| item.setText(3, sourceFile); |
| if (lineNumber != -1) |
| item.setText(4, Integer.toString(lineNumber)); |
| } |
| } finally { |
| mDetailTable.setRedraw(true); |
| } |
| } |
| |
| /* |
| * Are updates enabled? |
| */ |
| private void setUpdateStatus(int status) { |
| switch (status) { |
| case NOT_SELECTED: |
| mUpdateStatus.setText("Select a client to see heap info"); |
| mAllocDisplayCombo.setEnabled(false); |
| mFullUpdateButton.setEnabled(false); |
| //mDiffUpdateButton.setEnabled(false); |
| break; |
| case NOT_ENABLED: |
| mUpdateStatus.setText("Heap updates are " + "NOT ENABLED for this client"); |
| mAllocDisplayCombo.setEnabled(false); |
| mFullUpdateButton.setEnabled(false); |
| //mDiffUpdateButton.setEnabled(false); |
| break; |
| case ENABLED: |
| mUpdateStatus.setText("Press 'Full Update' to retrieve " + "latest data"); |
| mAllocDisplayCombo.setEnabled(true); |
| mFullUpdateButton.setEnabled(true); |
| //mDiffUpdateButton.setEnabled(true); |
| break; |
| default: |
| throw new RuntimeException(); |
| } |
| |
| mUpdateStatus.pack(); |
| } |
| |
| /** |
| * Create the Table display. This includes a "detail" Table in the bottom |
| * half and 2 modes in the top half: allocation Table and |
| * library+allocations Tables. |
| * |
| * @param base the top parent to create the display into |
| */ |
| private void createTableDisplay(Composite base) { |
| final int minPanelWidth = 60; |
| |
| final IPreferenceStore prefs = DdmUiPreferences.getStore(); |
| |
| // top level composite for mode 1 & 2 |
| mTableModeControl = new Composite(base, SWT.NONE); |
| GridLayout gl = new GridLayout(1, false); |
| gl.marginLeft = gl.marginRight = gl.marginTop = gl.marginBottom = 0; |
| mTableModeControl.setLayout(gl); |
| mTableModeControl.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| mTotalMemoryLabel = new Label(mTableModeControl, SWT.NONE); |
| mTotalMemoryLabel.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| mTotalMemoryLabel.setText("Total Memory: 0 Bytes"); |
| |
| // the top half of these modes is dynamic |
| |
| final Composite sash_composite = new Composite(mTableModeControl, |
| SWT.NONE); |
| sash_composite.setLayout(new FormLayout()); |
| sash_composite.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| // create the stacked composite |
| mAllocationStackComposite = new Composite(sash_composite, SWT.NONE); |
| mAllocationStackLayout = new StackLayout(); |
| mAllocationStackComposite.setLayout(mAllocationStackLayout); |
| mAllocationStackComposite.setLayoutData(new GridData( |
| GridData.FILL_BOTH)); |
| |
| // create the top half for mode 1 |
| createAllocationTopHalf(mAllocationStackComposite); |
| |
| // create the top half for mode 2 |
| createLibraryTopHalf(mAllocationStackComposite); |
| |
| final Sash sash = new Sash(sash_composite, SWT.HORIZONTAL); |
| |
| // bottom half of these modes is the same: detail table |
| createDetailTable(sash_composite); |
| |
| // init value for stack |
| mAllocationStackLayout.topControl = mAllocationModeTop; |
| |
| // form layout data |
| FormData data = new FormData(); |
| data.top = new FormAttachment(mTotalMemoryLabel, 0); |
| data.bottom = new FormAttachment(sash, 0); |
| data.left = new FormAttachment(0, 0); |
| data.right = new FormAttachment(100, 0); |
| mAllocationStackComposite.setLayoutData(data); |
| |
| final FormData sashData = new FormData(); |
| if (prefs != null && prefs.contains(PREFS_ALLOCATION_SASH)) { |
| sashData.top = new FormAttachment(0, |
| prefs.getInt(PREFS_ALLOCATION_SASH)); |
| } else { |
| sashData.top = new FormAttachment(50, 0); // 50% across |
| } |
| sashData.left = new FormAttachment(0, 0); |
| sashData.right = new FormAttachment(100, 0); |
| sash.setLayoutData(sashData); |
| |
| data = new FormData(); |
| data.top = new FormAttachment(sash, 0); |
| data.bottom = new FormAttachment(100, 0); |
| data.left = new FormAttachment(0, 0); |
| data.right = new FormAttachment(100, 0); |
| mDetailTable.setLayoutData(data); |
| |
| // allow resizes, but cap at minPanelWidth |
| sash.addListener(SWT.Selection, new Listener() { |
| public void handleEvent(Event e) { |
| Rectangle sashRect = sash.getBounds(); |
| Rectangle panelRect = sash_composite.getClientArea(); |
| int bottom = panelRect.height - sashRect.height - minPanelWidth; |
| e.y = Math.max(Math.min(e.y, bottom), minPanelWidth); |
| if (e.y != sashRect.y) { |
| sashData.top = new FormAttachment(0, e.y); |
| prefs.setValue(PREFS_ALLOCATION_SASH, e.y); |
| sash_composite.layout(); |
| } |
| } |
| }); |
| } |
| |
| private void createDetailTable(Composite base) { |
| |
| final IPreferenceStore prefs = DdmUiPreferences.getStore(); |
| |
| mDetailTable = new Table(base, SWT.MULTI | SWT.FULL_SELECTION); |
| mDetailTable.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| mDetailTable.setHeaderVisible(true); |
| mDetailTable.setLinesVisible(true); |
| |
| TableHelper.createTableColumn(mDetailTable, "Address", SWT.RIGHT, |
| "00000000", PREFS_DETAIL_ADDRESS, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mDetailTable, "Library", SWT.LEFT, |
| "abcdefghijklmnopqrst", PREFS_DETAIL_LIBRARY, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mDetailTable, "Method", SWT.LEFT, |
| "abcdefghijklmnopqrst", PREFS_DETAIL_METHOD, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mDetailTable, "File", SWT.LEFT, |
| "abcdefghijklmnopqrstuvwxyz", PREFS_DETAIL_FILE, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mDetailTable, "Line", SWT.RIGHT, |
| "9,999", PREFS_DETAIL_LINE, prefs); //$NON-NLS-1$ |
| } |
| |
| private void createAllocationTopHalf(Composite b) { |
| final IPreferenceStore prefs = DdmUiPreferences.getStore(); |
| |
| Composite base = new Composite(b, SWT.NONE); |
| mAllocationModeTop = base; |
| GridLayout gl = new GridLayout(1, false); |
| gl.marginLeft = gl.marginRight = gl.marginTop = gl.marginBottom = 0; |
| gl.verticalSpacing = 0; |
| base.setLayout(gl); |
| base.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| // horizontal layout for memory total and pages UI |
| mPageUIComposite = new Composite(base, SWT.NONE); |
| mPageUIComposite.setLayoutData(new GridData( |
| GridData.HORIZONTAL_ALIGN_BEGINNING)); |
| gl = new GridLayout(3, false); |
| gl.marginLeft = gl.marginRight = gl.marginTop = gl.marginBottom = 0; |
| gl.horizontalSpacing = 0; |
| mPageUIComposite.setLayout(gl); |
| |
| // Page UI |
| mPagePreviousButton = new Button(mPageUIComposite, SWT.NONE); |
| mPagePreviousButton.setText("<"); |
| mPagePreviousButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| mCurrentPage--; |
| updatePageUI(); |
| emptyTables(); |
| fillAllocationTable(); |
| } |
| }); |
| |
| mPageNextButton = new Button(mPageUIComposite, SWT.NONE); |
| mPageNextButton.setText(">"); |
| mPageNextButton.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| mCurrentPage++; |
| updatePageUI(); |
| emptyTables(); |
| fillAllocationTable(); |
| } |
| }); |
| |
| mPageLabel = new Label(mPageUIComposite, SWT.NONE); |
| mPageLabel.setLayoutData(new GridData(GridData.FILL_HORIZONTAL)); |
| |
| updatePageUI(); |
| |
| mAllocationTable = new Table(base, SWT.MULTI | SWT.FULL_SELECTION); |
| mAllocationTable.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| mAllocationTable.setHeaderVisible(true); |
| mAllocationTable.setLinesVisible(true); |
| |
| TableHelper.createTableColumn(mAllocationTable, "Total", SWT.RIGHT, |
| "9,999,999", PREFS_ALLOC_TOTAL, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mAllocationTable, "Count", SWT.RIGHT, |
| "9,999", PREFS_ALLOC_COUNT, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mAllocationTable, "Size", SWT.RIGHT, |
| "999,999", PREFS_ALLOC_SIZE, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mAllocationTable, "Library", SWT.LEFT, |
| "abcdefghijklmnopqrst", PREFS_ALLOC_LIBRARY, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mAllocationTable, "Method", SWT.LEFT, |
| "abcdefghijklmnopqrst", PREFS_ALLOC_METHOD, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mAllocationTable, "File", SWT.LEFT, |
| "abcdefghijklmnopqrstuvwxyz", PREFS_ALLOC_FILE, prefs); //$NON-NLS-1$ |
| |
| mAllocationTable.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| // get the selection index |
| int index = mAllocationTable.getSelectionIndex(); |
| TableItem item = mAllocationTable.getItem(index); |
| if (item != null && item.getData() instanceof NativeAllocationInfo) { |
| fillDetailTable((NativeAllocationInfo)item.getData()); |
| } |
| } |
| }); |
| } |
| |
| private void createLibraryTopHalf(Composite base) { |
| final int minPanelWidth = 60; |
| |
| final IPreferenceStore prefs = DdmUiPreferences.getStore(); |
| |
| // create a composite that'll contain 2 tables horizontally |
| final Composite top = new Composite(base, SWT.NONE); |
| mLibraryModeTopControl = top; |
| top.setLayout(new FormLayout()); |
| top.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| |
| // first table: library |
| mLibraryTable = new Table(top, SWT.MULTI | SWT.FULL_SELECTION); |
| mLibraryTable.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| mLibraryTable.setHeaderVisible(true); |
| mLibraryTable.setLinesVisible(true); |
| |
| TableHelper.createTableColumn(mLibraryTable, "Library", SWT.LEFT, |
| "abcdefghijklmnopqrstuvwxyz", PREFS_LIB_LIBRARY, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mLibraryTable, "Size", SWT.RIGHT, |
| "9,999,999", PREFS_LIB_SIZE, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mLibraryTable, "Count", SWT.RIGHT, |
| "9,999", PREFS_LIB_COUNT, prefs); //$NON-NLS-1$ |
| |
| mLibraryTable.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| fillLibraryAllocationTable(); |
| } |
| }); |
| |
| final Sash sash = new Sash(top, SWT.VERTICAL); |
| |
| // 2nd table: allocation per library |
| mLibraryAllocationTable = new Table(top, SWT.MULTI | SWT.FULL_SELECTION); |
| mLibraryAllocationTable.setLayoutData(new GridData(GridData.FILL_BOTH)); |
| mLibraryAllocationTable.setHeaderVisible(true); |
| mLibraryAllocationTable.setLinesVisible(true); |
| |
| TableHelper.createTableColumn(mLibraryAllocationTable, "Total", |
| SWT.RIGHT, "9,999,999", PREFS_LIBALLOC_TOTAL, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mLibraryAllocationTable, "Count", |
| SWT.RIGHT, "9,999", PREFS_LIBALLOC_COUNT, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mLibraryAllocationTable, "Size", |
| SWT.RIGHT, "999,999", PREFS_LIBALLOC_SIZE, prefs); //$NON-NLS-1$ |
| TableHelper.createTableColumn(mLibraryAllocationTable, "Method", |
| SWT.LEFT, "abcdefghijklmnopqrst", PREFS_LIBALLOC_METHOD, prefs); //$NON-NLS-1$ |
| |
| mLibraryAllocationTable.addSelectionListener(new SelectionAdapter() { |
| @Override |
| public void widgetSelected(SelectionEvent e) { |
| // get the index of the selection in the library table |
| int index1 = mLibraryTable.getSelectionIndex(); |
| // get the index in the library allocation table |
| int index2 = mLibraryAllocationTable.getSelectionIndex(); |
| // get the MallocInfo object |
| LibraryAllocations liballoc = mLibraryAllocations.get(index1); |
| NativeAllocationInfo info = liballoc.getAllocation(index2); |
| fillDetailTable(info); |
| } |
| }); |
| |
| // form layout data |
| FormData data = new FormData(); |
| data.top = new FormAttachment(0, 0); |
| data.bottom = new FormAttachment(100, 0); |
| data.left = new FormAttachment(0, 0); |
| data.right = new FormAttachment(sash, 0); |
| mLibraryTable.setLayoutData(data); |
| |
| final FormData sashData = new FormData(); |
| if (prefs != null && prefs.contains(PREFS_LIBRARY_SASH)) { |
| sashData.left = new FormAttachment(0, |
| prefs.getInt(PREFS_LIBRARY_SASH)); |
| } else { |
| sashData.left = new FormAttachment(50, 0); |
| } |
| sashData.bottom = new FormAttachment(100, 0); |
| sashData.top = new FormAttachment(0, 0); // 50% across |
| sash.setLayoutData(sashData); |
| |
| data = new FormData(); |
| data.top = new FormAttachment(0, 0); |
| data.bottom = new FormAttachment(100, 0); |
| data.left = new FormAttachment(sash, 0); |
| data.right = new FormAttachment(100, 0); |
| mLibraryAllocationTable.setLayoutData(data); |
| |
| // allow resizes, but cap at minPanelWidth |
| sash.addListener(SWT.Selection, new Listener() { |
| public void handleEvent(Event e) { |
| Rectangle sashRect = sash.getBounds(); |
| Rectangle panelRect = top.getClientArea(); |
| int right = panelRect.width - sashRect.width - minPanelWidth; |
| e.x = Math.max(Math.min(e.x, right), minPanelWidth); |
| if (e.x != sashRect.x) { |
| sashData.left = new FormAttachment(0, e.x); |
| prefs.setValue(PREFS_LIBRARY_SASH, e.y); |
| top.layout(); |
| } |
| } |
| }); |
| } |
| |
| private void emptyTables() { |
| mAllocationTable.removeAll(); |
| mLibraryTable.removeAll(); |
| mLibraryAllocationTable.removeAll(); |
| mDetailTable.removeAll(); |
| } |
| |
| private void sortAllocationsPerLibrary() { |
| if (mClientData != null) { |
| mLibraryAllocations.clear(); |
| |
| // create a hash map of LibraryAllocations to access aggregate |
| // objects already created |
| HashMap<String, LibraryAllocations> libcache = |
| new HashMap<String, LibraryAllocations>(); |
| |
| // get the allocation count |
| int count = mDisplayedAllocations.size(); |
| for (int i = 0; i < count; i++) { |
| NativeAllocationInfo allocInfo = mDisplayedAllocations.get(i); |
| |
| NativeStackCallInfo stackCallInfo = allocInfo.getRelevantStackCallInfo(); |
| if (stackCallInfo != null) { |
| String libraryName = stackCallInfo.getLibraryName(); |
| LibraryAllocations liballoc = libcache.get(libraryName); |
| if (liballoc == null) { |
| // didn't find a library allocation object already |
| // created so we create one |
| liballoc = new LibraryAllocations(libraryName); |
| // add it to the cache |
| libcache.put(libraryName, liballoc); |
| // add it to the list |
| mLibraryAllocations.add(liballoc); |
| } |
| // add the MallocInfo object to it. |
| liballoc.addAllocation(allocInfo); |
| } |
| } |
| // now that the list is created, we need to compute the size and |
| // sort it by size. This will also sort the MallocInfo objects |
| // inside each LibraryAllocation objects. |
| for (LibraryAllocations liballoc : mLibraryAllocations) { |
| liballoc.computeAllocationSizeAndCount(); |
| } |
| |
| // now we sort it |
| Collections.sort(mLibraryAllocations, |
| new Comparator<LibraryAllocations>() { |
| public int compare(LibraryAllocations o1, |
| LibraryAllocations o2) { |
| return o2.getSize() - o1.getSize(); |
| } |
| }); |
| } |
| } |
| |
| private void renderBitmap(ClientData cd) { |
| byte[] pixData; |
| |
| // Atomically get and clear the heap data. |
| synchronized (cd) { |
| if (serializeHeapData(cd.getVmHeapData()) == false) { |
| // no change, we return. |
| return; |
| } |
| |
| pixData = getSerializedData(); |
| |
| ImageData id = createLinearHeapImage(pixData, 200, mMapPalette); |
| Image image = new Image(mBase.getDisplay(), id); |
| mImage.setImage(image); |
| mImage.pack(true); |
| } |
| } |
| |
| /* |
| * 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); |
| } |
| |
| private void saveAllocations(String fileName) { |
| try { |
| PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName))); |
| |
| for (NativeAllocationInfo alloc : mAllocations) { |
| out.println(alloc.toString()); |
| } |
| out.close(); |
| } catch (IOException e) { |
| Log.e("Native", e); |
| } |
| } |
| } |
