tools/ddms/libs/ddmlib/src/com/android/ddmlib/NativeAllocationInfo.java - platform/development - Git at Google

 /*
  * 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.ddmlib;

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;

 /**
  * Stores native allocation information.
  * <p/>Contains number of allocations, their size and the stack trace.
  * <p/>Note: the ddmlib does not resolve the stack trace automatically. While this class provides
  * storage for resolved stack trace, this is merely for convenience.
  */
 public final class NativeAllocationInfo {
     /* constants for flag bits */
     private static final int FLAG_ZYGOTE_CHILD  = (1<<31);
     private static final int FLAG_MASK          = (FLAG_ZYGOTE_CHILD);

     /**
      * list of alloc functions that are filtered out when attempting to display
      * a relevant method responsible for an allocation
      */
     private static ArrayList<String> sAllocFunctionFilter;
     static {
         sAllocFunctionFilter = new ArrayList<String>();
         sAllocFunctionFilter.add("malloc"); //$NON-NLS-1$
         sAllocFunctionFilter.add("calloc"); //$NON-NLS-1$
         sAllocFunctionFilter.add("realloc"); //$NON-NLS-1$
         sAllocFunctionFilter.add("get_backtrace"); //$NON-NLS-1$
         sAllocFunctionFilter.add("get_hash"); //$NON-NLS-1$
         sAllocFunctionFilter.add("??"); //$NON-NLS-1$
         sAllocFunctionFilter.add("internal_free"); //$NON-NLS-1$
         sAllocFunctionFilter.add("operator new"); //$NON-NLS-1$
         sAllocFunctionFilter.add("leak_free"); //$NON-NLS-1$
         sAllocFunctionFilter.add("chk_free"); //$NON-NLS-1$
         sAllocFunctionFilter.add("chk_memalign"); //$NON-NLS-1$
         sAllocFunctionFilter.add("Malloc"); //$NON-NLS-1$
     }

     private final int mSize;

     private final boolean mIsZygoteChild;

     private final int mAllocations;

     private final ArrayList<Long> mStackCallAddresses = new ArrayList<Long>();

     private ArrayList<NativeStackCallInfo> mResolvedStackCall = null;

     private boolean mIsStackCallResolved = false;

     /**
      * Constructs a new {@link NativeAllocationInfo}.
      * @param size The size of the allocations.
      * @param allocations the allocation count
      */
     NativeAllocationInfo(int size, int allocations) {
         this.mSize = size & ~FLAG_MASK;
         this.mIsZygoteChild = ((size & FLAG_ZYGOTE_CHILD) != 0);
         this.mAllocations = allocations;
     }

     /**
      * Adds a stack call address for this allocation.
      * @param address The address to add.
      */
     void addStackCallAddress(long address) {
         mStackCallAddresses.add(address);
     }

     /**
      * Returns the total size of this allocation.
      */
     public int getSize() {
         return mSize;
     }

     /**
      * Returns whether the allocation happened in a child of the zygote
      * process.
      */
     public boolean isZygoteChild() {
         return mIsZygoteChild;
     }

     /**
      * Returns the allocation count.
      */
     public int getAllocationCount() {
         return mAllocations;
     }

     /**
      * Returns whether the stack call addresses have been resolved into
      * {@link NativeStackCallInfo} objects.
      */
     public boolean isStackCallResolved() {
         return mIsStackCallResolved;
     }

     /**
      * Returns the stack call of this allocation as raw addresses.
      * @return the list of addresses where the allocation happened.
      */
     public Long[] getStackCallAddresses() {
         return mStackCallAddresses.toArray(new Long[mStackCallAddresses.size()]);
     }

     /**
      * Sets the resolved stack call for this allocation.
      * <p/>
      * If <code>resolvedStackCall</code> is non <code>null</code> then
      * {@link #isStackCallResolved()} will return <code>true</code> after this call.
      * @param resolvedStackCall The list of {@link NativeStackCallInfo}.
      */
     public synchronized void setResolvedStackCall(List<NativeStackCallInfo> resolvedStackCall) {
         if (mResolvedStackCall == null) {
             mResolvedStackCall = new ArrayList<NativeStackCallInfo>();
         } else {
             mResolvedStackCall.clear();
         }
         mResolvedStackCall.addAll(resolvedStackCall);
         mIsStackCallResolved = mResolvedStackCall.size() != 0;
     }

     /**
      * Returns the resolved stack call.
      * @return An array of {@link NativeStackCallInfo} or <code>null</code> if the stack call
      * was not resolved.
      * @see #setResolvedStackCall(ArrayList)
      * @see #isStackCallResolved()
      */
     public synchronized NativeStackCallInfo[] getResolvedStackCall() {
         if (mIsStackCallResolved) {
             return mResolvedStackCall.toArray(new NativeStackCallInfo[mResolvedStackCall.size()]);
         }

         return null;
     }

     /**
      * Indicates whether some other object is "equal to" this one.
      * @param obj the reference object with which to compare.
      * @return <code>true</code> if this object is equal to the obj argument;
      * <code>false</code> otherwise.
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
     public boolean equals(Object obj) {
         if (obj == this)
             return true;
         if (obj instanceof NativeAllocationInfo) {
             NativeAllocationInfo mi = (NativeAllocationInfo)obj;
             // quick compare of size, alloc, and stackcall size
             if (mSize != mi.mSize || mAllocations != mi.mAllocations ||
                     mStackCallAddresses.size() != mi.mStackCallAddresses.size()) {
                 return false;
             }
             // compare the stack addresses
             int count = mStackCallAddresses.size();
             for (int i = 0 ; i < count ; i++) {
                 long a = mStackCallAddresses.get(i);
                 long b = mi.mStackCallAddresses.get(i);
                 if (a != b) {
                     return false;
                 }
             }

             return true;
         }
         return false;
     }

     /**
      * Returns a string representation of the object.
      * @see java.lang.Object#toString()
      */
     @Override
     public String toString() {
         StringBuffer buffer = new StringBuffer();
         buffer.append("Allocations: ");
         buffer.append(mAllocations);
         buffer.append("\n"); //$NON-NLS-1$

         buffer.append("Size: ");
         buffer.append(mSize);
         buffer.append("\n"); //$NON-NLS-1$

         buffer.append("Total Size: ");
         buffer.append(mSize * mAllocations);
         buffer.append("\n"); //$NON-NLS-1$

         Iterator<Long> addrIterator = mStackCallAddresses.iterator();
         Iterator<NativeStackCallInfo> sourceIterator = mResolvedStackCall.iterator();

         while (sourceIterator.hasNext()) {
             long addr = addrIterator.next();
             NativeStackCallInfo source = sourceIterator.next();
             if (addr == 0)
                 continue;

             if (source.getLineNumber() != -1) {
                 buffer.append(String.format("\t%1$08x\t%2$s --- %3$s --- %4$s:%5$d\n", addr,
                         source.getLibraryName(), source.getMethodName(),
                         source.getSourceFile(), source.getLineNumber()));
             } else {
                 buffer.append(String.format("\t%1$08x\t%2$s --- %3$s --- %4$s\n", addr,
                         source.getLibraryName(), source.getMethodName(), source.getSourceFile()));
             }
         }

         return buffer.toString();
     }

     /**
      * Returns the first {@link NativeStackCallInfo} that is relevant.
      * <p/>
      * A relevant <code>NativeStackCallInfo</code> is a stack call that is not deep in the
      * lower level of the libc, but the actual method that performed the allocation.
      * @return a <code>NativeStackCallInfo</code> or <code>null</code> if the stack call has not
      * been processed from the raw addresses.
      * @see #setResolvedStackCall(ArrayList)
      * @see #isStackCallResolved()
      */
     public synchronized NativeStackCallInfo getRelevantStackCallInfo() {
         if (mIsStackCallResolved && mResolvedStackCall != null) {
             Iterator<NativeStackCallInfo> sourceIterator = mResolvedStackCall.iterator();
             Iterator<Long> addrIterator = mStackCallAddresses.iterator();

             while (sourceIterator.hasNext() && addrIterator.hasNext()) {
                 long addr = addrIterator.next();
                 NativeStackCallInfo info = sourceIterator.next();
                 if (addr != 0 && info != null) {
                     if (isRelevant(info.getMethodName())) {
                         return info;
                     }
                 }
             }

             // couldnt find a relevant one, so we'll return the first one if it
             // exists.
             if (mResolvedStackCall.size() > 0)
                 return mResolvedStackCall.get(0);
         }

         return null;
     }

     /**
      * Returns true if the method name is relevant.
      * @param methodName the method name to test.
      */
     private boolean isRelevant(String methodName) {
         for (String filter : sAllocFunctionFilter) {
             if (methodName.contains(filter)) {
                 return false;
             }
         }

         return true;
     }
 }
	/*
	* 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.ddmlib;

	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;

	/**
	* Stores native allocation information.
	* <p/>Contains number of allocations, their size and the stack trace.
	* <p/>Note: the ddmlib does not resolve the stack trace automatically. While this class provides
	* storage for resolved stack trace, this is merely for convenience.
	*/
	public final class NativeAllocationInfo {
	/* constants for flag bits */
	private static final int FLAG_ZYGOTE_CHILD = (1<<31);
	private static final int FLAG_MASK = (FLAG_ZYGOTE_CHILD);

	/**
	* list of alloc functions that are filtered out when attempting to display
	* a relevant method responsible for an allocation
	*/
	private static ArrayList<String> sAllocFunctionFilter;
	static {
	sAllocFunctionFilter = new ArrayList<String>();
	sAllocFunctionFilter.add("malloc"); //$NON-NLS-1$
	sAllocFunctionFilter.add("calloc"); //$NON-NLS-1$
	sAllocFunctionFilter.add("realloc"); //$NON-NLS-1$
	sAllocFunctionFilter.add("get_backtrace"); //$NON-NLS-1$
	sAllocFunctionFilter.add("get_hash"); //$NON-NLS-1$
	sAllocFunctionFilter.add("??"); //$NON-NLS-1$
	sAllocFunctionFilter.add("internal_free"); //$NON-NLS-1$
	sAllocFunctionFilter.add("operator new"); //$NON-NLS-1$
	sAllocFunctionFilter.add("leak_free"); //$NON-NLS-1$
	sAllocFunctionFilter.add("chk_free"); //$NON-NLS-1$
	sAllocFunctionFilter.add("chk_memalign"); //$NON-NLS-1$
	sAllocFunctionFilter.add("Malloc"); //$NON-NLS-1$
	}

	private final int mSize;

	private final boolean mIsZygoteChild;

	private final int mAllocations;

	private final ArrayList<Long> mStackCallAddresses = new ArrayList<Long>();

	private ArrayList<NativeStackCallInfo> mResolvedStackCall = null;

	private boolean mIsStackCallResolved = false;

	/**
	* Constructs a new {@link NativeAllocationInfo}.
	* @param size The size of the allocations.
	* @param allocations the allocation count
	*/
	NativeAllocationInfo(int size, int allocations) {
	this.mSize = size & ~FLAG_MASK;
	this.mIsZygoteChild = ((size & FLAG_ZYGOTE_CHILD) != 0);
	this.mAllocations = allocations;
	}

	/**
	* Adds a stack call address for this allocation.
	* @param address The address to add.
	*/
	void addStackCallAddress(long address) {
	mStackCallAddresses.add(address);
	}

	/**
	* Returns the total size of this allocation.
	*/
	public int getSize() {
	return mSize;
	}

	/**
	* Returns whether the allocation happened in a child of the zygote
	* process.
	*/
	public boolean isZygoteChild() {
	return mIsZygoteChild;
	}

	/**
	* Returns the allocation count.
	*/
	public int getAllocationCount() {
	return mAllocations;
	}

	/**
	* Returns whether the stack call addresses have been resolved into
	* {@link NativeStackCallInfo} objects.
	*/
	public boolean isStackCallResolved() {
	return mIsStackCallResolved;
	}

	/**
	* Returns the stack call of this allocation as raw addresses.
	* @return the list of addresses where the allocation happened.
	*/
	public Long[] getStackCallAddresses() {
	return mStackCallAddresses.toArray(new Long[mStackCallAddresses.size()]);
	}

	/**
	* Sets the resolved stack call for this allocation.
	* <p/>
	* If <code>resolvedStackCall</code> is non <code>null</code> then
	* {@link #isStackCallResolved()} will return <code>true</code> after this call.
	* @param resolvedStackCall The list of {@link NativeStackCallInfo}.
	*/
	public synchronized void setResolvedStackCall(List<NativeStackCallInfo> resolvedStackCall) {
	if (mResolvedStackCall == null) {
	mResolvedStackCall = new ArrayList<NativeStackCallInfo>();
	} else {
	mResolvedStackCall.clear();
	}
	mResolvedStackCall.addAll(resolvedStackCall);
	mIsStackCallResolved = mResolvedStackCall.size() != 0;
	}

	/**
	* Returns the resolved stack call.
	* @return An array of {@link NativeStackCallInfo} or <code>null</code> if the stack call
	* was not resolved.
	* @see #setResolvedStackCall(ArrayList)
	* @see #isStackCallResolved()
	*/
	public synchronized NativeStackCallInfo[] getResolvedStackCall() {
	if (mIsStackCallResolved) {
	return mResolvedStackCall.toArray(new NativeStackCallInfo[mResolvedStackCall.size()]);
	}

	return null;
	}

	/**
	* Indicates whether some other object is "equal to" this one.
	* @param obj the reference object with which to compare.
	* @return <code>true</code> if this object is equal to the obj argument;
	* <code>false</code> otherwise.
	* @see java.lang.Object#equals(java.lang.Object)
	*/
	@Override
	public boolean equals(Object obj) {
	if (obj == this)
	return true;
	if (obj instanceof NativeAllocationInfo) {
	NativeAllocationInfo mi = (NativeAllocationInfo)obj;
	// quick compare of size, alloc, and stackcall size
	if (mSize != mi.mSize \|\| mAllocations != mi.mAllocations \|\|
	mStackCallAddresses.size() != mi.mStackCallAddresses.size()) {
	return false;
	}
	// compare the stack addresses
	int count = mStackCallAddresses.size();
	for (int i = 0 ; i < count ; i++) {
	long a = mStackCallAddresses.get(i);
	long b = mi.mStackCallAddresses.get(i);
	if (a != b) {
	return false;
	}
	}

	return true;
	}
	return false;
	}

	/**
	* Returns a string representation of the object.
	* @see java.lang.Object#toString()
	*/
	@Override
	public String toString() {
	StringBuffer buffer = new StringBuffer();
	buffer.append("Allocations: ");
	buffer.append(mAllocations);
	buffer.append("\n"); //$NON-NLS-1$

	buffer.append("Size: ");
	buffer.append(mSize);
	buffer.append("\n"); //$NON-NLS-1$

	buffer.append("Total Size: ");
	buffer.append(mSize * mAllocations);
	buffer.append("\n"); //$NON-NLS-1$

	Iterator<Long> addrIterator = mStackCallAddresses.iterator();
	Iterator<NativeStackCallInfo> sourceIterator = mResolvedStackCall.iterator();

	while (sourceIterator.hasNext()) {
	long addr = addrIterator.next();
	NativeStackCallInfo source = sourceIterator.next();
	if (addr == 0)
	continue;

	if (source.getLineNumber() != -1) {
	buffer.append(String.format("\t%1$08x\t%2$s --- %3$s --- %4$s:%5$d\n", addr,
	source.getLibraryName(), source.getMethodName(),
	source.getSourceFile(), source.getLineNumber()));
	} else {
	buffer.append(String.format("\t%1$08x\t%2$s --- %3$s --- %4$s\n", addr,
	source.getLibraryName(), source.getMethodName(), source.getSourceFile()));
	}
	}

	return buffer.toString();
	}

	/**
	* Returns the first {@link NativeStackCallInfo} that is relevant.
	* <p/>
	* A relevant <code>NativeStackCallInfo</code> is a stack call that is not deep in the
	* lower level of the libc, but the actual method that performed the allocation.
	* @return a <code>NativeStackCallInfo</code> or <code>null</code> if the stack call has not
	* been processed from the raw addresses.
	* @see #setResolvedStackCall(ArrayList)
	* @see #isStackCallResolved()
	*/
	public synchronized NativeStackCallInfo getRelevantStackCallInfo() {
	if (mIsStackCallResolved && mResolvedStackCall != null) {
	Iterator<NativeStackCallInfo> sourceIterator = mResolvedStackCall.iterator();
	Iterator<Long> addrIterator = mStackCallAddresses.iterator();

	while (sourceIterator.hasNext() && addrIterator.hasNext()) {
	long addr = addrIterator.next();
	NativeStackCallInfo info = sourceIterator.next();
	if (addr != 0 && info != null) {
	if (isRelevant(info.getMethodName())) {
	return info;
	}
	}
	}

	// couldnt find a relevant one, so we'll return the first one if it
	// exists.
	if (mResolvedStackCall.size() > 0)
	return mResolvedStackCall.get(0);
	}

	return null;
	}

	/**
	* Returns true if the method name is relevant.
	* @param methodName the method name to test.
	*/
	private boolean isRelevant(String methodName) {
	for (String filter : sAllocFunctionFilter) {
	if (methodName.contains(filter)) {
	return false;
	}
	}

	return true;
	}
	}