Merge "Reduce pss collection amount, improve logging." (6fa646ab) · Commits · e / os / android_frameworks_base

core/java/android/os/Debug.java

+42 −18

Original line number	Diff line number	Diff line
		@@ -116,6 +116,8 @@ public final class Debug
		/** The proportional set size that is swappable for dalvik heap. */
		/** @hide We may want to expose this, eventually. */
		public int dalvikSwappablePss;
		/** @hide The resident set size for dalvik heap. (Without other Dalvik overhead.) */
		public int dalvikRss;
		/** The private dirty pages used by dalvik heap. */
		public int dalvikPrivateDirty;
		/** The shared dirty pages used by dalvik heap. */
		@@ -138,6 +140,8 @@ public final class Debug
		/** The proportional set size that is swappable for the native heap. */
		/** @hide We may want to expose this, eventually. */
		public int nativeSwappablePss;
		/** @hide The resident set size for the native heap. */
		public int nativeRss;
		/** The private dirty pages used by the native heap. */
		public int nativePrivateDirty;
		/** The shared dirty pages used by the native heap. */
		@@ -160,6 +164,8 @@ public final class Debug
		/** The proportional set size that is swappable for everything else. */
		/** @hide We may want to expose this, eventually. */
		public int otherSwappablePss;
		/** @hide The resident set size for everything else. */
		public int otherRss;
		/** The private dirty pages used by everything else. */
		public int otherPrivateDirty;
		/** The shared dirty pages used by everything else. */
		@@ -288,24 +294,26 @@ public final class Debug
		public static final int NUM_DVK_STATS = 14;

		/** @hide */
		public static final int NUM_CATEGORIES = 8;
		public static final int NUM_CATEGORIES = 9;

		/** @hide */
		public static final int offsetPss = 0;
		public static final int OFFSET_PSS = 0;
		/** @hide */
		public static final int offsetSwappablePss = 1;
		public static final int OFFSET_SWAPPABLE_PSS = 1;
		/** @hide */
		public static final int offsetPrivateDirty = 2;
		public static final int OFFSET_RSS = 2;
		/** @hide */
		public static final int offsetSharedDirty = 3;
		public static final int OFFSET_PRIVATE_DIRTY = 3;
		/** @hide */
		public static final int offsetPrivateClean = 4;
		public static final int OFFSET_SHARED_DIRTY = 4;
		/** @hide */
		public static final int offsetSharedClean = 5;
		public static final int OFFSET_PRIVATE_CLEAN = 5;
		/** @hide */
		public static final int offsetSwappedOut = 6;
		public static final int OFFSET_SHARED_CLEAN = 6;
		/** @hide */
		public static final int offsetSwappedOutPss = 7;
		public static final int OFFSET_SWAPPED_OUT = 7;
		/** @hide */
		public static final int OFFSET_SWAPPED_OUT_PSS = 8;

		private int[] otherStats = new int[(NUM_OTHER_STATS+NUM_DVK_STATS)*NUM_CATEGORIES];

		@@ -336,6 +344,13 @@ public final class Debug
		return dalvikSwappablePss + nativeSwappablePss + otherSwappablePss;
		}

		/**
		* @hide Return total RSS memory usage in kB.
		*/
		public int getTotalRss() {
		return dalvikRss + nativeRss + otherRss;
		}

		/**
		* Return total private dirty memory usage in kB.
		*/
		@@ -382,29 +397,32 @@ public final class Debug

		/** @hide */
		public int getOtherPss(int which) {
		return otherStats[which*NUM_CATEGORIES + offsetPss];
		return otherStats[which * NUM_CATEGORIES + OFFSET_PSS];
		}


		/** @hide */
		public int getOtherSwappablePss(int which) {
		return otherStats[which*NUM_CATEGORIES + offsetSwappablePss];
		return otherStats[which * NUM_CATEGORIES + OFFSET_SWAPPABLE_PSS];
		}

		/** @hide */
		public int getOtherRss(int which) {
		return otherStats[which * NUM_CATEGORIES + OFFSET_RSS];
		}

		/** @hide */
		public int getOtherPrivateDirty(int which) {
		return otherStats[which*NUM_CATEGORIES + offsetPrivateDirty];
		return otherStats[which * NUM_CATEGORIES + OFFSET_PRIVATE_DIRTY];
		}

		/** @hide */
		public int getOtherSharedDirty(int which) {
		return otherStats[which*NUM_CATEGORIES + offsetSharedDirty];
		return otherStats[which * NUM_CATEGORIES + OFFSET_SHARED_DIRTY];
		}

		/** @hide */
		public int getOtherPrivateClean(int which) {
		return otherStats[which*NUM_CATEGORIES + offsetPrivateClean];
		return otherStats[which * NUM_CATEGORIES + OFFSET_PRIVATE_CLEAN];
		}

		/** @hide */
		@@ -414,17 +432,17 @@ public final class Debug

		/** @hide */
		public int getOtherSharedClean(int which) {
		return otherStats[which*NUM_CATEGORIES + offsetSharedClean];
		return otherStats[which * NUM_CATEGORIES + OFFSET_SHARED_CLEAN];
		}

		/** @hide */
		public int getOtherSwappedOut(int which) {
		return otherStats[which*NUM_CATEGORIES + offsetSwappedOut];
		return otherStats[which * NUM_CATEGORIES + OFFSET_SWAPPED_OUT];
		}

		/** @hide */
		public int getOtherSwappedOutPss(int which) {
		return otherStats[which*NUM_CATEGORIES + offsetSwappedOutPss];
		return otherStats[which * NUM_CATEGORIES + OFFSET_SWAPPED_OUT_PSS];
		}

		/** @hide */
		@@ -741,6 +759,7 @@ public final class Debug
		public void writeToParcel(Parcel dest, int flags) {
		dest.writeInt(dalvikPss);
		dest.writeInt(dalvikSwappablePss);
		dest.writeInt(dalvikRss);
		dest.writeInt(dalvikPrivateDirty);
		dest.writeInt(dalvikSharedDirty);
		dest.writeInt(dalvikPrivateClean);
		@@ -749,6 +768,7 @@ public final class Debug
		dest.writeInt(dalvikSwappedOutPss);
		dest.writeInt(nativePss);
		dest.writeInt(nativeSwappablePss);
		dest.writeInt(nativeRss);
		dest.writeInt(nativePrivateDirty);
		dest.writeInt(nativeSharedDirty);
		dest.writeInt(nativePrivateClean);
		@@ -757,6 +777,7 @@ public final class Debug
		dest.writeInt(nativeSwappedOutPss);
		dest.writeInt(otherPss);
		dest.writeInt(otherSwappablePss);
		dest.writeInt(otherRss);
		dest.writeInt(otherPrivateDirty);
		dest.writeInt(otherSharedDirty);
		dest.writeInt(otherPrivateClean);
		@@ -770,6 +791,7 @@ public final class Debug
		public void readFromParcel(Parcel source) {
		dalvikPss = source.readInt();
		dalvikSwappablePss = source.readInt();
		dalvikRss = source.readInt();
		dalvikPrivateDirty = source.readInt();
		dalvikSharedDirty = source.readInt();
		dalvikPrivateClean = source.readInt();
		@@ -778,6 +800,7 @@ public final class Debug
		dalvikSwappedOutPss = source.readInt();
		nativePss = source.readInt();
		nativeSwappablePss = source.readInt();
		nativeRss = source.readInt();
		nativePrivateDirty = source.readInt();
		nativeSharedDirty = source.readInt();
		nativePrivateClean = source.readInt();
		@@ -786,6 +809,7 @@ public final class Debug
		nativeSwappedOutPss = source.readInt();
		otherPss = source.readInt();
		otherSwappablePss = source.readInt();
		otherRss = source.readInt();
		otherPrivateDirty = source.readInt();
		otherSharedDirty = source.readInt();
		otherPrivateClean = source.readInt();

core/java/android/util/AtomicFile.java

+28 −0

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		package android.util;

		import android.os.FileUtils;
		import android.os.SystemClock;

		import libcore.io.IoUtils;

		@@ -47,14 +48,25 @@ import java.util.function.Consumer;
		public class AtomicFile {
		private final File mBaseName;
		private final File mBackupName;
		private final String mCommitTag;
		private long mStartTime;

		/**
		* Create a new AtomicFile for a file located at the given File path.
		* The secondary backup file will be the same file path with ".bak" appended.
		*/
		public AtomicFile(File baseName) {
		this(baseName, null);
		}

		/**
		* @hide Internal constructor that also allows you to have the class
		* automatically log commit events.
		*/
		public AtomicFile(File baseName, String commitTag) {
		mBaseName = baseName;
		mBackupName = new File(baseName.getPath() + ".bak");
		mCommitTag = commitTag;
		}

		/**
		@@ -88,6 +100,18 @@ public class AtomicFile {
		* access to AtomicFile.
		*/
		public FileOutputStream startWrite() throws IOException {
		return startWrite(mCommitTag != null ? SystemClock.uptimeMillis() : 0);
		}

		/**
		* @hide Internal version of {@link #startWrite()} that allows you to specify an earlier
		* start time of the operation to adjust how the commit is logged.
		* @param startTime The effective start time of the operation, in the time
		* base of {@link SystemClock#uptimeMillis()}.
		*/
		public FileOutputStream startWrite(long startTime) throws IOException {
		mStartTime = startTime;

		// Rename the current file so it may be used as a backup during the next read
		if (mBaseName.exists()) {
		if (!mBackupName.exists()) {
		@@ -135,6 +159,10 @@ public class AtomicFile {
		} catch (IOException e) {
		Log.w("AtomicFile", "finishWrite: Got exception:", e);
		}
		if (mCommitTag != null) {
		com.android.internal.logging.EventLogTags.writeCommitSysConfigFile(
		mCommitTag, SystemClock.uptimeMillis() - mStartTime);
		}
		}
		}

core/java/com/android/internal/app/procstats/ProcessState.java

+64 −24

Original line number	Diff line number	Diff line
		@@ -17,25 +17,18 @@
		package com.android.internal.app.procstats;

		import android.os.Parcel;
		import android.os.Parcelable;
		import android.os.SystemClock;
		import android.os.SystemProperties;
		import android.os.UserHandle;
		import android.service.pm.PackageProto;
		import android.service.procstats.ProcessStatsProto;
		import android.text.format.DateFormat;
		import android.util.ArrayMap;
		import android.util.ArraySet;
		import android.util.DebugUtils;
		import android.util.Log;
		import android.util.LongSparseArray;
		import android.util.Slog;
		import android.util.SparseArray;
		import android.util.TimeUtils;
		import android.util.proto.ProtoOutputStream;
		import android.util.proto.ProtoUtils;

		import com.android.internal.app.procstats.ProcessStats;
		import com.android.internal.app.procstats.ProcessStats.PackageState;
		import com.android.internal.app.procstats.ProcessStats.ProcessStateHolder;
		import com.android.internal.app.procstats.ProcessStats.TotalMemoryUseCollection;
		@@ -43,6 +36,9 @@ import static com.android.internal.app.procstats.ProcessStats.PSS_SAMPLE_COUNT;
		import static com.android.internal.app.procstats.ProcessStats.PSS_MINIMUM;
		import static com.android.internal.app.procstats.ProcessStats.PSS_AVERAGE;
		import static com.android.internal.app.procstats.ProcessStats.PSS_MAXIMUM;
		import static com.android.internal.app.procstats.ProcessStats.PSS_RSS_MINIMUM;
		import static com.android.internal.app.procstats.ProcessStats.PSS_RSS_AVERAGE;
		import static com.android.internal.app.procstats.ProcessStats.PSS_RSS_MAXIMUM;
		import static com.android.internal.app.procstats.ProcessStats.PSS_USS_MINIMUM;
		import static com.android.internal.app.procstats.ProcessStats.PSS_USS_AVERAGE;
		import static com.android.internal.app.procstats.ProcessStats.PSS_USS_MAXIMUM;
		@@ -64,20 +60,10 @@ import static com.android.internal.app.procstats.ProcessStats.STATE_CACHED_ACTIV
		import static com.android.internal.app.procstats.ProcessStats.STATE_CACHED_EMPTY;
		import static com.android.internal.app.procstats.ProcessStats.STATE_COUNT;

		import dalvik.system.VMRuntime;
		import libcore.util.EmptyArray;

		import java.io.IOException;
		import java.io.InputStream;
		import java.io.PrintWriter;
		import java.util.ArrayList;
		import java.util.Arrays;
		import java.util.Collections;
		import java.util.Comparator;
		import java.util.HashMap;
		import java.util.List;
		import java.util.Map;
		import java.util.Objects;

		public final class ProcessState {
		private static final String TAG = "ProcessStats";
		@@ -469,13 +455,21 @@ public final class ProcessState {
		}
		}

		public void addPss(long pss, long uss, boolean always, int type, long duration,
		public void addPss(long pss, long uss, long rss, boolean always, int type, long duration,
		ArrayMap<String, ProcessStateHolder> pkgList) {
		ensureNotDead();
		switch (type) {
		case ProcessStats.ADD_PSS_INTERNAL:
		mStats.mInternalPssCount++;
		mStats.mInternalPssTime += duration;
		case ProcessStats.ADD_PSS_INTERNAL_SINGLE:
		mStats.mInternalSinglePssCount++;
		mStats.mInternalSinglePssTime += duration;
		break;
		case ProcessStats.ADD_PSS_INTERNAL_ALL_MEM:
		mStats.mInternalAllMemPssCount++;
		mStats.mInternalAllMemPssTime += duration;
		break;
		case ProcessStats.ADD_PSS_INTERNAL_ALL_POLL:
		mStats.mInternalAllPollPssCount++;
		mStats.mInternalAllPollPssTime += duration;
		break;
		case ProcessStats.ADD_PSS_EXTERNAL:
		mStats.mExternalPssCount++;
		@@ -496,7 +490,8 @@ public final class ProcessState {
		mLastPssTime = SystemClock.uptimeMillis();
		if (mCurState != STATE_NOTHING) {
		// First update the common process.
		mCommonProcess.mPssTable.mergeStats(mCurState, 1, pss, pss, pss, uss, uss, uss);
		mCommonProcess.mPssTable.mergeStats(mCurState, 1, pss, pss, pss, uss, uss, uss,
		rss, rss, rss);

		// If the common process is not multi-package, there is nothing else to do.
		if (!mCommonProcess.mMultiPackage) {
		@@ -506,7 +501,7 @@ public final class ProcessState {
		if (pkgList != null) {
		for (int ip=pkgList.size()-1; ip>=0; ip--) {
		pullFixedProc(pkgList, ip).mPssTable.mergeStats(mCurState, 1,
		pss, pss, pss, uss, uss, uss);
		pss, pss, pss, uss, uss, uss, rss, rss, rss);
		}
		}
		}
		@@ -658,6 +653,18 @@ public final class ProcessState {
		return mPssTable.getValueForId((byte)state, PSS_USS_MAXIMUM);
		}

		public long getPssRssMinimum(int state) {
		return mPssTable.getValueForId((byte)state, PSS_RSS_MINIMUM);
		}

		public long getPssRssAverage(int state) {
		return mPssTable.getValueForId((byte)state, PSS_RSS_AVERAGE);
		}

		public long getPssRssMaximum(int state) {
		return mPssTable.getValueForId((byte)state, PSS_RSS_MAXIMUM);
		}

		/**
		* Sums up the PSS data and adds it to 'data'.
		*
		@@ -793,6 +800,8 @@ public final class ProcessState {
		new int[] {STATE_SERVICE_RESTARTING}, now, totalTime, true);
		dumpProcessSummaryDetails(pw, prefix, " Receiver: ", screenStates, memStates,
		new int[] {STATE_RECEIVER}, now, totalTime, true);
		dumpProcessSummaryDetails(pw, prefix, " Heavy: ", screenStates, memStates,
		new int[] {STATE_HOME}, now, totalTime, true);
		dumpProcessSummaryDetails(pw, prefix, " (Home): ", screenStates, memStates,
		new int[] {STATE_HOME}, now, totalTime, true);
		dumpProcessSummaryDetails(pw, prefix, " (Last Act): ", screenStates, memStates,
		@@ -897,6 +906,12 @@ public final class ProcessState {
		DebugUtils.printSizeValue(pw, getPssUssAverage(bucket) * 1024);
		pw.print(" ");
		DebugUtils.printSizeValue(pw, getPssUssMaximum(bucket) * 1024);
		pw.print(" / ");
		DebugUtils.printSizeValue(pw, getPssRssMinimum(bucket) * 1024);
		pw.print(" ");
		DebugUtils.printSizeValue(pw, getPssRssAverage(bucket) * 1024);
		pw.print(" ");
		DebugUtils.printSizeValue(pw, getPssRssMaximum(bucket) * 1024);
		pw.println();
		}
		}
		@@ -969,7 +984,8 @@ public final class ProcessState {
		public void computeProcessData(ProcessStats.ProcessDataCollection data, long now) {
		data.totalTime = 0;
		data.numPss = data.minPss = data.avgPss = data.maxPss =
		data.minUss = data.avgUss = data.maxUss = 0;
		data.minUss = data.avgUss = data.maxUss =
		data.minRss = data.avgRss = data.maxRss = 0;
		for (int is=0; is<data.screenStates.length; is++) {
		for (int im=0; im<data.memStates.length; im++) {
		for (int ip=0; ip<data.procStates.length; ip++) {
		@@ -984,6 +1000,9 @@ public final class ProcessState {
		long minUss = getPssUssMinimum(bucket);
		long avgUss = getPssUssAverage(bucket);
		long maxUss = getPssUssMaximum(bucket);
		long minRss = getPssRssMinimum(bucket);
		long avgRss = getPssRssAverage(bucket);
		long maxRss = getPssRssMaximum(bucket);
		if (data.numPss == 0) {
		data.minPss = minPss;
		data.avgPss = avgPss;
		@@ -991,6 +1010,9 @@ public final class ProcessState {
		data.minUss = minUss;
		data.avgUss = avgUss;
		data.maxUss = maxUss;
		data.minRss = minRss;
		data.avgRss = avgRss;
		data.maxRss = maxRss;
		} else {
		if (minPss < data.minPss) {
		data.minPss = minPss;
		@@ -1008,6 +1030,14 @@ public final class ProcessState {
		if (maxUss > data.maxUss) {
		data.maxUss = maxUss;
		}
		if (minRss < data.minRss) {
		data.minRss = minRss;
		}
		data.avgRss = (long)( ((data.avgRss*(double)data.numPss)
		+ (avgRss*(double)samples)) / (data.numPss+samples) );
		if (maxRss > data.maxRss) {
		data.maxRss = maxRss;
		}
		}
		data.numPss += samples;
		}
		@@ -1176,6 +1206,12 @@ public final class ProcessState {
		pw.print(mPssTable.getValue(key, PSS_USS_AVERAGE));
		pw.print(':');
		pw.print(mPssTable.getValue(key, PSS_USS_MAXIMUM));
		pw.print(':');
		pw.print(mPssTable.getValue(key, PSS_RSS_MINIMUM));
		pw.print(':');
		pw.print(mPssTable.getValue(key, PSS_RSS_AVERAGE));
		pw.print(':');
		pw.print(mPssTable.getValue(key, PSS_RSS_MAXIMUM));
		}
		}

		@@ -1249,6 +1285,10 @@ public final class ProcessState {
		mPssTable.getValue(key, PSS_USS_MINIMUM),
		mPssTable.getValue(key, PSS_USS_AVERAGE),
		mPssTable.getValue(key, PSS_USS_MAXIMUM));
		ProtoUtils.toAggStatsProto(proto, ProcessStatsProto.State.RSS,
		mPssTable.getValue(key, PSS_RSS_MINIMUM),
		mPssTable.getValue(key, PSS_RSS_AVERAGE),
		mPssTable.getValue(key, PSS_RSS_MAXIMUM));

		proto.end(stateToken);
		}

core/java/com/android/internal/app/procstats/ProcessStats.java

+67 −29

File changed.

Preview size limit exceeded, changes collapsed.

core/java/com/android/internal/app/procstats/PssTable.java

+25 −2

Original line number	Diff line number	Diff line
		@@ -16,6 +16,9 @@

		package com.android.internal.app.procstats;

		import static com.android.internal.app.procstats.ProcessStats.PSS_RSS_AVERAGE;
		import static com.android.internal.app.procstats.ProcessStats.PSS_RSS_MAXIMUM;
		import static com.android.internal.app.procstats.ProcessStats.PSS_RSS_MINIMUM;
		import static com.android.internal.app.procstats.ProcessStats.PSS_SAMPLE_COUNT;
		import static com.android.internal.app.procstats.ProcessStats.PSS_MINIMUM;
		import static com.android.internal.app.procstats.ProcessStats.PSS_AVERAGE;
		@@ -51,7 +54,10 @@ public class PssTable extends SparseMappingTable.Table {
		that.getValue(key, PSS_MAXIMUM),
		that.getValue(key, PSS_USS_MINIMUM),
		that.getValue(key, PSS_USS_AVERAGE),
		that.getValue(key, PSS_USS_MAXIMUM));
		that.getValue(key, PSS_USS_MAXIMUM),
		that.getValue(key, PSS_RSS_MINIMUM),
		that.getValue(key, PSS_RSS_AVERAGE),
		that.getValue(key, PSS_RSS_MAXIMUM));
		}
		}

		@@ -60,7 +66,7 @@ public class PssTable extends SparseMappingTable.Table {
		* one and the new one, the average will now incorporate the new average, etc.
		*/
		public void mergeStats(int state, int inCount, long minPss, long avgPss, long maxPss,
		long minUss, long avgUss, long maxUss) {
		long minUss, long avgUss, long maxUss, long minRss, long avgRss, long maxRss) {
		final int key = getOrAddKey((byte)state, PSS_COUNT);
		final long count = getValue(key, PSS_SAMPLE_COUNT);
		if (count == 0) {
		@@ -71,6 +77,9 @@ public class PssTable extends SparseMappingTable.Table {
		setValue(key, PSS_USS_MINIMUM, minUss);
		setValue(key, PSS_USS_AVERAGE, avgUss);
		setValue(key, PSS_USS_MAXIMUM, maxUss);
		setValue(key, PSS_RSS_MINIMUM, minRss);
		setValue(key, PSS_RSS_AVERAGE, avgRss);
		setValue(key, PSS_RSS_MAXIMUM, maxRss);
		} else {
		setValue(key, PSS_SAMPLE_COUNT, count + inCount);

		@@ -103,6 +112,20 @@ public class PssTable extends SparseMappingTable.Table {
		if (val < maxUss) {
		setValue(key, PSS_USS_MAXIMUM, maxUss);
		}

		val = getValue(key, PSS_RSS_MINIMUM);
		if (val > minUss) {
		setValue(key, PSS_RSS_MINIMUM, minUss);
		}

		val = getValue(key, PSS_RSS_AVERAGE);
		setValue(key, PSS_RSS_AVERAGE,
		(long)(((val(double)count)+(avgUss(double)inCount)) / (count+inCount)));

		val = getValue(key, PSS_RSS_MAXIMUM);
		if (val < maxUss) {
		setValue(key, PSS_RSS_MAXIMUM, maxUss);
		}
		}
		}
		}