ddmlib/src/main/java/com/android/ddmlib/HeapSegment.java - platform/tools/base.git - 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.nio.BufferUnderflowException;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.text.ParseException;

 /**
  * Describes the types and locations of objects in a segment of a heap.
  */
 public final class HeapSegment implements Comparable<HeapSegment> {

     /**
      * Describes an object/region encoded in the HPSG data.
      */
     public static class HeapSegmentElement implements Comparable<HeapSegmentElement> {

         /*
          * Solidity values, which must match the values in
          * the HPSG data.
          */

         /** The element describes a free block. */
         public static final int SOLIDITY_FREE = 0;

         /** The element is strongly-reachable. */
         public static final int SOLIDITY_HARD = 1;

         /** The element is softly-reachable. */
         public static final int SOLIDITY_SOFT = 2;

         /** The element is weakly-reachable. */
         public static final int SOLIDITY_WEAK = 3;

         /** The element is phantom-reachable. */
         public static final int SOLIDITY_PHANTOM = 4;

         /** The element is pending finalization. */
         public static final int SOLIDITY_FINALIZABLE = 5;

         /** The element is not reachable, and is about to be swept/freed. */
         public static final int SOLIDITY_SWEEP = 6;

         /** The reachability of the object is unknown. */
         public static final int SOLIDITY_INVALID = -1;


         /*
          * Kind values, which must match the values in
          * the HPSG data.
          */

         /** The element describes a data object. */
         public static final int KIND_OBJECT = 0;

         /** The element describes a class object. */
         public static final int KIND_CLASS_OBJECT = 1;

         /** The element describes an array of 1-byte elements. */
         public static final int KIND_ARRAY_1 = 2;

         /** The element describes an array of 2-byte elements. */
         public static final int KIND_ARRAY_2 = 3;

         /** The element describes an array of 4-byte elements. */
         public static final int KIND_ARRAY_4 = 4;

         /** The element describes an array of 8-byte elements. */
         public static final int KIND_ARRAY_8 = 5;

         /** The element describes an unknown type of object. */
         public static final int KIND_UNKNOWN = 6;

         /** The element describes a native object. */
         public static final int KIND_NATIVE = 7;

         /** The object kind is unknown or unspecified. */
         public static final int KIND_INVALID = -1;


         /**
          * A bit in the HPSG data that indicates that an element should
          * be combined with the element that follows, typically because
          * an element is too large to be described by a single element.
          */
         private static final int PARTIAL_MASK = 1 << 7;


         /**
          * Describes the reachability/solidity of the element.  Must
          * be set to one of the SOLIDITY_* values.
          */
         private int mSolidity;

         /**
          * Describes the type/kind of the element.  Must be set to one
          * of the KIND_* values.
          */
         private int mKind;

         /**
          * Describes the length of the element, in bytes.
          */
         private int mLength;


         /**
          * Creates an uninitialized element.
          */
         public HeapSegmentElement() {
             setSolidity(SOLIDITY_INVALID);
             setKind(KIND_INVALID);
             setLength(-1);
         }

         /**
          * Create an element describing the entry at the current
          * position of hpsgData.
          *
          * @param hs The heap segment to pull the entry from.
          * @throws BufferUnderflowException if there is not a whole entry
          *                                  following the current position
          *                                  of hpsgData.
          * @throws ParseException           if the provided data is malformed.
          */
         public HeapSegmentElement(HeapSegment hs)
                 throws BufferUnderflowException, ParseException {
             set(hs);
         }

         /**
          * Replace the element with the entry at the current position of
          * hpsgData.
          *
          * @param hs The heap segment to pull the entry from.
          * @return this object.
          * @throws BufferUnderflowException if there is not a whole entry
          *                                  following the current position of
          *                                  hpsgData.
          * @throws ParseException           if the provided data is malformed.
          */
         public HeapSegmentElement set(HeapSegment hs)
                 throws BufferUnderflowException, ParseException {

             /* TODO: Maybe keep track of the virtual address of each element
              *       so that they can be examined independently.
              */
             ByteBuffer data = hs.mUsageData;
             int eState = data.get() & 0x000000ff;
             int eLen = (data.get() & 0x000000ff) + 1;

             while ((eState & PARTIAL_MASK) != 0) {

                 /* If the partial bit was set, the next byte should describe
                  * the same object as the current one.
                  */
                 int nextState = data.get() & 0x000000ff;
                 if ((nextState & ~PARTIAL_MASK) != (eState & ~PARTIAL_MASK)) {
                     throw new ParseException("State mismatch", data.position());
                 }
                 eState = nextState;
                 eLen += (data.get() & 0x000000ff) + 1;
             }

             setSolidity(eState & 0x7);
             setKind((eState >> 3) & 0x7);
             setLength(eLen * hs.mAllocationUnitSize);

             return this;
         }

         public int getSolidity() {
             return mSolidity;
         }

         public void setSolidity(int solidity) {
             this.mSolidity = solidity;
         }

         public int getKind() {
             return mKind;
         }

         public void setKind(int kind) {
             this.mKind = kind;
         }

         public int getLength() {
             return mLength;
         }

         public void setLength(int length) {
             this.mLength = length;
         }

         @Override
         public int compareTo(HeapSegmentElement other) {
             if (mLength != other.mLength) {
                 return mLength < other.mLength ? -1 : 1;
             }
             return 0;
         }
     }

     //* The ID of the heap that this segment belongs to.
     protected int mHeapId;

     //* The size of an allocation unit, in bytes. (e.g., 8 bytes)
     protected int mAllocationUnitSize;

     //* The virtual address of the start of this segment.
     protected long mStartAddress;

     //* The offset of this pices from mStartAddress, in bytes.
     protected int mOffset;

     //* The number of allocation units described in this segment.
     protected int mAllocationUnitCount;

     //* The raw data that describes the contents of this segment.
     protected ByteBuffer mUsageData;

     //* mStartAddress is set to this value when the segment becomes invalid.
     private static final long INVALID_START_ADDRESS = -1;

     /**
      * Create a new HeapSegment based on the raw contents
      * of an HPSG chunk.
      *
      * @param hpsgData The raw data from an HPSG chunk.
      * @throws BufferUnderflowException if hpsgData is too small
      *                                  to hold the HPSG chunk header data.
      */
     public HeapSegment(ByteBuffer hpsgData) throws BufferUnderflowException {
         /* Read the HPSG chunk header.
          * These get*() calls may throw a BufferUnderflowException
          * if the underlying data isn't big enough.
          */
         hpsgData.order(ByteOrder.BIG_ENDIAN);
         mHeapId = hpsgData.getInt();
         mAllocationUnitSize = hpsgData.get();
         mStartAddress = hpsgData.getInt() & 0x00000000ffffffffL;
         mOffset = hpsgData.getInt();
         mAllocationUnitCount = hpsgData.getInt();

         // Hold onto the remainder of the data.
         mUsageData = hpsgData.slice();
         mUsageData.order(ByteOrder.BIG_ENDIAN);   // doesn't actually matter

         // Validate the data.
 //xxx do it
 //xxx make sure the number of elements matches mAllocationUnitCount.
 //xxx make sure the last element doesn't have P set
     }

     /**
      * See if this segment still contains data, and has not been
      * appended to another segment.
      *
      * @return true if this segment has not been appended to
      *         another segment.
      */
     public boolean isValid() {
         return mStartAddress != INVALID_START_ADDRESS;
     }

     /**
      * See if <code>other</code> comes immediately after this segment.
      *
      * @param other The HeapSegment to check.
      * @return true if <code>other</code> comes immediately after this
      *         segment.
      */
     public boolean canAppend(HeapSegment other) {
         return isValid() && other.isValid() && mHeapId == other.mHeapId &&
                 mAllocationUnitSize == other.mAllocationUnitSize &&
                 getEndAddress() == other.getStartAddress();
     }

     /**
      * Append the contents of <code>other</code> to this segment
      * if it describes the segment immediately after this one.
      *
      * @param other The segment to append to this segment, if possible.
      *              If appended, <code>other</code> will be invalid
      *              when this method returns.
      * @return true if <code>other</code> was successfully appended to
      *         this segment.
      */
     public boolean append(HeapSegment other) {
         if (canAppend(other)) {
             /* Preserve the position.  The mark is not preserved,
              * but we don't use it anyway.
              */
             int pos = mUsageData.position();

             // Guarantee that we have enough room for the new data.
             if (mUsageData.capacity() - mUsageData.limit() <
                     other.mUsageData.limit()) {
                 /* Grow more than necessary in case another append()
                  * is about to happen.
                  */
                 int newSize = mUsageData.limit() + other.mUsageData.limit();
                 ByteBuffer newData = ByteBuffer.allocate(newSize * 2);

                 mUsageData.rewind();
                 newData.put(mUsageData);
                 mUsageData = newData;
             }

             // Copy the data from the other segment and restore the position.
             other.mUsageData.rewind();
             mUsageData.put(other.mUsageData);
             mUsageData.position(pos);

             // Fix this segment's header to cover the new data.
             mAllocationUnitCount += other.mAllocationUnitCount;

             // Mark the other segment as invalid.
             other.mStartAddress = INVALID_START_ADDRESS;
             other.mUsageData = null;

             return true;
         } else {
             return false;
         }
     }

     public long getStartAddress() {
         return mStartAddress + mOffset;
     }

     public int getLength() {
         return mAllocationUnitSize * mAllocationUnitCount;
     }

     public long getEndAddress() {
         return getStartAddress() + getLength();
     }

     public void rewindElements() {
         if (mUsageData != null) {
             mUsageData.rewind();
         }
     }

     public HeapSegmentElement getNextElement(HeapSegmentElement reuse) {
         try {
             if (reuse != null) {
                 return reuse.set(this);
             } else {
                 return new HeapSegmentElement(this);
             }
         } catch (BufferUnderflowException ex) {
             /* Normal "end of buffer" situation.
              */
         } catch (ParseException ex) {
             /* Malformed data.
              */
 //TODO: we should catch this in the constructor
         }
         return null;
     }

     /*
      * Method overrides for Comparable
      */
     @Override
     public boolean equals(Object o) {
         if (o instanceof HeapSegment) {
             return compareTo((HeapSegment) o) == 0;
         }
         return false;
     }

     @Override
     public int hashCode() {
         return mHeapId * 31 +
                 mAllocationUnitSize * 31 +
                 (int) mStartAddress * 31 +
                 mOffset * 31 +
                 mAllocationUnitCount * 31 +
                 mUsageData.hashCode();
     }

     @Override
     public String toString() {
         StringBuilder str = new StringBuilder();

         str.append("HeapSegment { heap ").append(mHeapId)
                 .append(", start 0x")
                 .append(Integer.toHexString((int) getStartAddress()))
                 .append(", length ").append(getLength())
                 .append(" }");

         return str.toString();
     }

     @Override
     public int compareTo(HeapSegment other) {
         if (mHeapId != other.mHeapId) {
             return mHeapId < other.mHeapId ? -1 : 1;
         }
         if (getStartAddress() != other.getStartAddress()) {
             return getStartAddress() < other.getStartAddress() ? -1 : 1;
         }

         /* If two segments have the same start address, the rest of
          * the fields should be equal.  Go through the motions, though.
          * Note that we re-check the components of getStartAddress()
          * (mStartAddress and mOffset) to make sure that all fields in
          * an equal segment are equal.
          */

         if (mAllocationUnitSize != other.mAllocationUnitSize) {
             return mAllocationUnitSize < other.mAllocationUnitSize ? -1 : 1;
         }
         if (mStartAddress != other.mStartAddress) {
             return mStartAddress < other.mStartAddress ? -1 : 1;
         }
         if (mOffset != other.mOffset) {
             return mOffset < other.mOffset ? -1 : 1;
         }
         if (mAllocationUnitCount != other.mAllocationUnitCount) {
             return mAllocationUnitCount < other.mAllocationUnitCount ? -1 : 1;
         }
         if (mUsageData != other.mUsageData) {
             return mUsageData.compareTo(other.mUsageData);
         }
         return 0;
     }
 }
	/*
	* 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.nio.BufferUnderflowException;
	import java.nio.ByteBuffer;
	import java.nio.ByteOrder;
	import java.text.ParseException;

	/**
	* Describes the types and locations of objects in a segment of a heap.
	*/
	public final class HeapSegment implements Comparable<HeapSegment> {

	/**
	* Describes an object/region encoded in the HPSG data.
	*/
	public static class HeapSegmentElement implements Comparable<HeapSegmentElement> {

	/*
	* Solidity values, which must match the values in
	* the HPSG data.
	*/

	/** The element describes a free block. */
	public static final int SOLIDITY_FREE = 0;

	/** The element is strongly-reachable. */
	public static final int SOLIDITY_HARD = 1;

	/** The element is softly-reachable. */
	public static final int SOLIDITY_SOFT = 2;

	/** The element is weakly-reachable. */
	public static final int SOLIDITY_WEAK = 3;

	/** The element is phantom-reachable. */
	public static final int SOLIDITY_PHANTOM = 4;

	/** The element is pending finalization. */
	public static final int SOLIDITY_FINALIZABLE = 5;

	/** The element is not reachable, and is about to be swept/freed. */
	public static final int SOLIDITY_SWEEP = 6;

	/** The reachability of the object is unknown. */
	public static final int SOLIDITY_INVALID = -1;


	/*
	* Kind values, which must match the values in
	* the HPSG data.
	*/

	/** The element describes a data object. */
	public static final int KIND_OBJECT = 0;

	/** The element describes a class object. */
	public static final int KIND_CLASS_OBJECT = 1;

	/** The element describes an array of 1-byte elements. */
	public static final int KIND_ARRAY_1 = 2;

	/** The element describes an array of 2-byte elements. */
	public static final int KIND_ARRAY_2 = 3;

	/** The element describes an array of 4-byte elements. */
	public static final int KIND_ARRAY_4 = 4;

	/** The element describes an array of 8-byte elements. */
	public static final int KIND_ARRAY_8 = 5;

	/** The element describes an unknown type of object. */
	public static final int KIND_UNKNOWN = 6;

	/** The element describes a native object. */
	public static final int KIND_NATIVE = 7;

	/** The object kind is unknown or unspecified. */
	public static final int KIND_INVALID = -1;


	/**
	* A bit in the HPSG data that indicates that an element should
	* be combined with the element that follows, typically because
	* an element is too large to be described by a single element.
	*/
	private static final int PARTIAL_MASK = 1 << 7;


	/**
	* Describes the reachability/solidity of the element. Must
	* be set to one of the SOLIDITY_* values.
	*/
	private int mSolidity;

	/**
	* Describes the type/kind of the element. Must be set to one
	* of the KIND_* values.
	*/
	private int mKind;

	/**
	* Describes the length of the element, in bytes.
	*/
	private int mLength;


	/**
	* Creates an uninitialized element.
	*/
	public HeapSegmentElement() {
	setSolidity(SOLIDITY_INVALID);
	setKind(KIND_INVALID);
	setLength(-1);
	}

	/**
	* Create an element describing the entry at the current
	* position of hpsgData.
	*
	* @param hs The heap segment to pull the entry from.
	* @throws BufferUnderflowException if there is not a whole entry
	* following the current position
	* of hpsgData.
	* @throws ParseException if the provided data is malformed.
	*/
	public HeapSegmentElement(HeapSegment hs)
	throws BufferUnderflowException, ParseException {
	set(hs);
	}

	/**
	* Replace the element with the entry at the current position of
	* hpsgData.
	*
	* @param hs The heap segment to pull the entry from.
	* @return this object.
	* @throws BufferUnderflowException if there is not a whole entry
	* following the current position of
	* hpsgData.
	* @throws ParseException if the provided data is malformed.
	*/
	public HeapSegmentElement set(HeapSegment hs)
	throws BufferUnderflowException, ParseException {

	/* TODO: Maybe keep track of the virtual address of each element
	* so that they can be examined independently.
	*/
	ByteBuffer data = hs.mUsageData;
	int eState = data.get() & 0x000000ff;
	int eLen = (data.get() & 0x000000ff) + 1;

	while ((eState & PARTIAL_MASK) != 0) {

	/* If the partial bit was set, the next byte should describe
	* the same object as the current one.
	*/
	int nextState = data.get() & 0x000000ff;
	if ((nextState & ~PARTIAL_MASK) != (eState & ~PARTIAL_MASK)) {
	throw new ParseException("State mismatch", data.position());
	}
	eState = nextState;
	eLen += (data.get() & 0x000000ff) + 1;
	}

	setSolidity(eState & 0x7);
	setKind((eState >> 3) & 0x7);
	setLength(eLen * hs.mAllocationUnitSize);

	return this;
	}

	public int getSolidity() {
	return mSolidity;
	}

	public void setSolidity(int solidity) {
	this.mSolidity = solidity;
	}

	public int getKind() {
	return mKind;
	}

	public void setKind(int kind) {
	this.mKind = kind;
	}

	public int getLength() {
	return mLength;
	}

	public void setLength(int length) {
	this.mLength = length;
	}

	@Override
	public int compareTo(HeapSegmentElement other) {
	if (mLength != other.mLength) {
	return mLength < other.mLength ? -1 : 1;
	}
	return 0;
	}
	}

	//* The ID of the heap that this segment belongs to.
	protected int mHeapId;

	//* The size of an allocation unit, in bytes. (e.g., 8 bytes)
	protected int mAllocationUnitSize;

	//* The virtual address of the start of this segment.
	protected long mStartAddress;

	//* The offset of this pices from mStartAddress, in bytes.
	protected int mOffset;

	//* The number of allocation units described in this segment.
	protected int mAllocationUnitCount;

	//* The raw data that describes the contents of this segment.
	protected ByteBuffer mUsageData;

	//* mStartAddress is set to this value when the segment becomes invalid.
	private static final long INVALID_START_ADDRESS = -1;

	/**
	* Create a new HeapSegment based on the raw contents
	* of an HPSG chunk.
	*
	* @param hpsgData The raw data from an HPSG chunk.
	* @throws BufferUnderflowException if hpsgData is too small
	* to hold the HPSG chunk header data.
	*/
	public HeapSegment(ByteBuffer hpsgData) throws BufferUnderflowException {
	/* Read the HPSG chunk header.
	* These get*() calls may throw a BufferUnderflowException
	* if the underlying data isn't big enough.
	*/
	hpsgData.order(ByteOrder.BIG_ENDIAN);
	mHeapId = hpsgData.getInt();
	mAllocationUnitSize = hpsgData.get();
	mStartAddress = hpsgData.getInt() & 0x00000000ffffffffL;
	mOffset = hpsgData.getInt();
	mAllocationUnitCount = hpsgData.getInt();

	// Hold onto the remainder of the data.
	mUsageData = hpsgData.slice();
	mUsageData.order(ByteOrder.BIG_ENDIAN); // doesn't actually matter

	// Validate the data.
	//xxx do it
	//xxx make sure the number of elements matches mAllocationUnitCount.
	//xxx make sure the last element doesn't have P set
	}

	/**
	* See if this segment still contains data, and has not been
	* appended to another segment.
	*
	* @return true if this segment has not been appended to
	* another segment.
	*/
	public boolean isValid() {
	return mStartAddress != INVALID_START_ADDRESS;
	}

	/**
	* See if <code>other</code> comes immediately after this segment.
	*
	* @param other The HeapSegment to check.
	* @return true if <code>other</code> comes immediately after this
	* segment.
	*/
	public boolean canAppend(HeapSegment other) {
	return isValid() && other.isValid() && mHeapId == other.mHeapId &&
	mAllocationUnitSize == other.mAllocationUnitSize &&
	getEndAddress() == other.getStartAddress();
	}

	/**
	* Append the contents of <code>other</code> to this segment
	* if it describes the segment immediately after this one.
	*
	* @param other The segment to append to this segment, if possible.
	* If appended, <code>other</code> will be invalid
	* when this method returns.
	* @return true if <code>other</code> was successfully appended to
	* this segment.
	*/
	public boolean append(HeapSegment other) {
	if (canAppend(other)) {
	/* Preserve the position. The mark is not preserved,
	* but we don't use it anyway.
	*/
	int pos = mUsageData.position();

	// Guarantee that we have enough room for the new data.
	if (mUsageData.capacity() - mUsageData.limit() <
	other.mUsageData.limit()) {
	/* Grow more than necessary in case another append()
	* is about to happen.
	*/
	int newSize = mUsageData.limit() + other.mUsageData.limit();
	ByteBuffer newData = ByteBuffer.allocate(newSize * 2);

	mUsageData.rewind();
	newData.put(mUsageData);
	mUsageData = newData;
	}

	// Copy the data from the other segment and restore the position.
	other.mUsageData.rewind();
	mUsageData.put(other.mUsageData);
	mUsageData.position(pos);

	// Fix this segment's header to cover the new data.
	mAllocationUnitCount += other.mAllocationUnitCount;

	// Mark the other segment as invalid.
	other.mStartAddress = INVALID_START_ADDRESS;
	other.mUsageData = null;

	return true;
	} else {
	return false;
	}
	}

	public long getStartAddress() {
	return mStartAddress + mOffset;
	}

	public int getLength() {
	return mAllocationUnitSize * mAllocationUnitCount;
	}

	public long getEndAddress() {
	return getStartAddress() + getLength();
	}

	public void rewindElements() {
	if (mUsageData != null) {
	mUsageData.rewind();
	}
	}

	public HeapSegmentElement getNextElement(HeapSegmentElement reuse) {
	try {
	if (reuse != null) {
	return reuse.set(this);
	} else {
	return new HeapSegmentElement(this);
	}
	} catch (BufferUnderflowException ex) {
	/* Normal "end of buffer" situation.
	*/
	} catch (ParseException ex) {
	/* Malformed data.
	*/
	//TODO: we should catch this in the constructor
	}
	return null;
	}

	/*
	* Method overrides for Comparable
	*/
	@Override
	public boolean equals(Object o) {
	if (o instanceof HeapSegment) {
	return compareTo((HeapSegment) o) == 0;
	}
	return false;
	}

	@Override
	public int hashCode() {
	return mHeapId * 31 +
	mAllocationUnitSize * 31 +
	(int) mStartAddress * 31 +
	mOffset * 31 +
	mAllocationUnitCount * 31 +
	mUsageData.hashCode();
	}

	@Override
	public String toString() {
	StringBuilder str = new StringBuilder();

	str.append("HeapSegment { heap ").append(mHeapId)
	.append(", start 0x")
	.append(Integer.toHexString((int) getStartAddress()))
	.append(", length ").append(getLength())
	.append(" }");

	return str.toString();
	}

	@Override
	public int compareTo(HeapSegment other) {
	if (mHeapId != other.mHeapId) {
	return mHeapId < other.mHeapId ? -1 : 1;
	}
	if (getStartAddress() != other.getStartAddress()) {
	return getStartAddress() < other.getStartAddress() ? -1 : 1;
	}

	/* If two segments have the same start address, the rest of
	* the fields should be equal. Go through the motions, though.
	* Note that we re-check the components of getStartAddress()
	* (mStartAddress and mOffset) to make sure that all fields in
	* an equal segment are equal.
	*/

	if (mAllocationUnitSize != other.mAllocationUnitSize) {
	return mAllocationUnitSize < other.mAllocationUnitSize ? -1 : 1;
	}
	if (mStartAddress != other.mStartAddress) {
	return mStartAddress < other.mStartAddress ? -1 : 1;
	}
	if (mOffset != other.mOffset) {
	return mOffset < other.mOffset ? -1 : 1;
	}
	if (mAllocationUnitCount != other.mAllocationUnitCount) {
	return mAllocationUnitCount < other.mAllocationUnitCount ? -1 : 1;
	}
	if (mUsageData != other.mUsageData) {
	return mUsageData.compareTo(other.mUsageData);
	}
	return 0;
	}
	}