Optimize getting time_in_state for threads of system server (2237efed) · Commits · e / os / android_frameworks_base

core/java/android/os/BatteryStats.java

+8 −4

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@ import static android.os.BatteryStatsManager.NUM_WIFI_STATES;
		import static android.os.BatteryStatsManager.NUM_WIFI_SUPPL_STATES;

		import android.annotation.IntDef;
		import android.annotation.Nullable;
		import android.app.ActivityManager;
		import android.app.job.JobParameters;
		import android.compat.annotation.UnsupportedAppUsage;
		@@ -2889,14 +2890,17 @@ public abstract class BatteryStats implements Parcelable {

		/**
		* Returns the approximate CPU time (in microseconds) spent by the system server handling
		* incoming service calls from apps.
		* incoming service calls from apps. The result is returned as an array of longs,
		* organized as a sequence like this:
		* <pre>
		* cluster1-speeed1, cluster1-speed2, ..., cluster2-speed1, cluster2-speed2, ...
		* </pre>
		*
		* @param cluster the index of the CPU cluster.
		* @param step the index of the CPU speed. This is not the actual speed of the CPU.
		* @see com.android.internal.os.PowerProfile#getNumCpuClusters()
		* @see com.android.internal.os.PowerProfile#getNumSpeedStepsInCpuCluster(int)
		*/
		public abstract long getSystemServiceTimeAtCpuSpeed(int cluster, int step);
		@Nullable
		public abstract long[] getSystemServiceTimeAtCpuSpeeds();

		/**
		* Returns the total, last, or current battery uptime in microseconds.

core/java/com/android/internal/os/BatteryStatsImpl.java

+99 −84

Original line number	Diff line number	Diff line
		@@ -145,7 +145,7 @@ public class BatteryStatsImpl extends BatteryStats {
		private static final boolean DEBUG = false;
		public static final boolean DEBUG_ENERGY = false;
		private static final boolean DEBUG_ENERGY_CPU = DEBUG_ENERGY;
		private static final boolean DEBUG_BINDER_STATS = true;
		private static final boolean DEBUG_BINDER_STATS = false;
		private static final boolean DEBUG_MEMORY = false;
		private static final boolean DEBUG_HISTORY = false;
		private static final boolean USE_OLD_HISTORY = false; // for debugging.
		@@ -156,7 +156,7 @@ public class BatteryStatsImpl extends BatteryStats {
		private static final int MAGIC = 0xBA757475; // 'BATSTATS'

		// Current on-disk Parcel version
		static final int VERSION = 188 + (USE_OLD_HISTORY ? 1000 : 0);
		static final int VERSION = 189 + (USE_OLD_HISTORY ? 1000 : 0);

		// The maximum number of names wakelocks we will keep track of
		// per uid; once the limit is reached, we batch the remaining wakelocks
		@@ -221,7 +221,8 @@ public class BatteryStatsImpl extends BatteryStats {
		@VisibleForTesting
		protected KernelSingleUidTimeReader mKernelSingleUidTimeReader;
		@VisibleForTesting
		protected SystemServerCpuThreadReader mSystemServerCpuThreadReader;
		protected SystemServerCpuThreadReader mSystemServerCpuThreadReader =
		SystemServerCpuThreadReader.create();

		private final KernelMemoryBandwidthStats mKernelMemoryBandwidthStats
		= new KernelMemoryBandwidthStats();
		@@ -1013,15 +1014,22 @@ public class BatteryStatsImpl extends BatteryStats {

		private long[] mCpuFreqs;

		/**
		* Times spent by the system server process grouped by cluster and CPU speed.
		*/
		private LongSamplingCounterArray mSystemServerCpuTimesUs;

		private long[] mTmpSystemServerCpuTimesUs;

		/**
		* Times spent by the system server threads grouped by cluster and CPU speed.
		*/
		private LongSamplingCounter[][] mSystemServerThreadCpuTimesUs;
		private LongSamplingCounterArray mSystemServerThreadCpuTimesUs;

		/**
		* Times spent by the system server threads handling incoming binder requests.
		*/
		private LongSamplingCounter[][] mBinderThreadCpuTimesUs;
		private LongSamplingCounterArray mBinderThreadCpuTimesUs;

		@VisibleForTesting
		protected PowerProfile mPowerProfile;
		@@ -10610,8 +10618,6 @@ public class BatteryStatsImpl extends BatteryStats {
		firstCpuOfCluster += mPowerProfile.getNumCoresInCpuCluster(i);
		}

		mSystemServerCpuThreadReader = SystemServerCpuThreadReader.create();

		if (mEstimatedBatteryCapacity == -1) {
		// Initialize the estimated battery capacity to a known preset one.
		mEstimatedBatteryCapacity = (int) mPowerProfile.getBatteryCapacity();
		@@ -11291,6 +11297,7 @@ public class BatteryStatsImpl extends BatteryStats {

		mTmpRailStats.reset();

		resetIfNotNull(mSystemServerCpuTimesUs, false, elapsedRealtimeUs);
		resetIfNotNull(mSystemServerThreadCpuTimesUs, false, elapsedRealtimeUs);
		resetIfNotNull(mBinderThreadCpuTimesUs, false, elapsedRealtimeUs);

		@@ -12421,38 +12428,58 @@ public class BatteryStatsImpl extends BatteryStats {

		SystemServerCpuThreadReader.SystemServiceCpuThreadTimes systemServiceCpuThreadTimes =
		mSystemServerCpuThreadReader.readDelta();
		if (systemServiceCpuThreadTimes == null) {
		return;
		}

		int index = 0;
		int numCpuClusters = mPowerProfile.getNumCpuClusters();
		if (mSystemServerThreadCpuTimesUs == null) {
		mSystemServerThreadCpuTimesUs = new LongSamplingCounter[numCpuClusters][];
		mBinderThreadCpuTimesUs = new LongSamplingCounter[numCpuClusters][];
		}
		for (int cluster = 0; cluster < numCpuClusters; cluster++) {
		int numSpeeds = mPowerProfile.getNumSpeedStepsInCpuCluster(cluster);
		if (mSystemServerThreadCpuTimesUs[cluster] == null) {
		mSystemServerThreadCpuTimesUs[cluster] = new LongSamplingCounter[numSpeeds];
		mBinderThreadCpuTimesUs[cluster] = new LongSamplingCounter[numSpeeds];
		for (int speed = 0; speed < numSpeeds; speed++) {
		mSystemServerThreadCpuTimesUs[cluster][speed] =
		new LongSamplingCounter(mOnBatteryTimeBase);
		mBinderThreadCpuTimesUs[cluster][speed] =
		new LongSamplingCounter(mOnBatteryTimeBase);
		if (mSystemServerCpuTimesUs == null) {
		mSystemServerCpuTimesUs = new LongSamplingCounterArray(mOnBatteryTimeBase);
		mSystemServerThreadCpuTimesUs = new LongSamplingCounterArray(mOnBatteryTimeBase);
		mBinderThreadCpuTimesUs = new LongSamplingCounterArray(mOnBatteryTimeBase);
		}
		mSystemServerThreadCpuTimesUs.addCountLocked(systemServiceCpuThreadTimes.threadCpuTimesUs);
		mBinderThreadCpuTimesUs.addCountLocked(systemServiceCpuThreadTimes.binderThreadCpuTimesUs);

		long totalCpuTimeAllThreads = 0;
		for (int index = systemServiceCpuThreadTimes.threadCpuTimesUs.length - 1; index >= 0;
		index--) {
		totalCpuTimeAllThreads += systemServiceCpuThreadTimes.threadCpuTimesUs[index];
		}
		for (int speed = 0; speed < numSpeeds; speed++) {
		mSystemServerThreadCpuTimesUs[cluster][speed].addCountLocked(
		systemServiceCpuThreadTimes.threadCpuTimesUs[index]);
		mBinderThreadCpuTimesUs[cluster][speed].addCountLocked(
		systemServiceCpuThreadTimes.binderThreadCpuTimesUs[index]);
		index++;

		// Estimate per cluster per frequency CPU time for the entire process
		// by distributing the total process CPU time proportionately to how much
		// CPU time its threads took on those clusters/frequencies. This algorithm
		// works more accurately when when we have equally distributed concurrency.
		// TODO(b/169279846): obtain actual process CPU times from the kernel
		long processCpuTime = systemServiceCpuThreadTimes.processCpuTimeUs;
		if (mTmpSystemServerCpuTimesUs == null) {
		mTmpSystemServerCpuTimesUs =
		new long[systemServiceCpuThreadTimes.threadCpuTimesUs.length];
		}
		for (int index = systemServiceCpuThreadTimes.threadCpuTimesUs.length - 1; index >= 0;
		index--) {
		mTmpSystemServerCpuTimesUs[index] =
		processCpuTime * systemServiceCpuThreadTimes.threadCpuTimesUs[index]
		/ totalCpuTimeAllThreads;

		}

		mSystemServerCpuTimesUs.addCountLocked(mTmpSystemServerCpuTimesUs);

		if (DEBUG_BINDER_STATS) {
		Slog.d(TAG, "System server threads per CPU cluster (binder threads/total threads/%)");
		long binderThreadTimeMs = 0;
		long totalCpuTimeMs = 0;
		long totalThreadTimeMs = 0;
		long binderThreadTimeMs = 0;
		int cpuIndex = 0;
		final long[] systemServerCpuTimesUs =
		mSystemServerCpuTimesUs.getCountsLocked(0);
		final long[] systemServerThreadCpuTimesUs =
		mSystemServerThreadCpuTimesUs.getCountsLocked(0);
		final long[] binderThreadCpuTimesUs =
		mBinderThreadCpuTimesUs.getCountsLocked(0);
		int index = 0;
		for (int cluster = 0; cluster < numCpuClusters; cluster++) {
		StringBuilder sb = new StringBuilder();
		sb.append("cpu").append(cpuIndex).append(": [");
		@@ -12461,15 +12488,14 @@ public class BatteryStatsImpl extends BatteryStats {
		if (speed != 0) {
		sb.append(", ");
		}
		long totalCountMs =
		mSystemServerThreadCpuTimesUs[cluster][speed].getCountLocked(0) / 1000;
		long binderCountMs = mBinderThreadCpuTimesUs[cluster][speed].getCountLocked(0)
		/ 1000;
		long totalCountMs = systemServerThreadCpuTimesUs[index] / 1000;
		long binderCountMs = binderThreadCpuTimesUs[index] / 1000;
		sb.append(String.format("%d/%d(%.1f%%)",
		binderCountMs,
		totalCountMs,
		totalCountMs != 0 ? (double) binderCountMs * 100 / totalCountMs : 0));

		totalCpuTimeMs += systemServerCpuTimesUs[index] / 1000;
		totalThreadTimeMs += totalCountMs;
		binderThreadTimeMs += binderCountMs;
		index++;
		@@ -12477,6 +12503,8 @@ public class BatteryStatsImpl extends BatteryStats {
		cpuIndex += mPowerProfile.getNumCoresInCpuCluster(cluster);
		Slog.d(TAG, sb.toString());
		}

		Slog.d(TAG, "Total system server CPU time (ms): " + totalCpuTimeMs);
		Slog.d(TAG, "Total system server thread time (ms): " + totalThreadTimeMs);
		Slog.d(TAG, String.format("Total Binder thread time (ms): %d (%.1f%%)",
		binderThreadTimeMs,
		@@ -13715,7 +13743,7 @@ public class BatteryStatsImpl extends BatteryStats {


		@Override
		public long getSystemServiceTimeAtCpuSpeed(int cluster, int step) {
		public long[] getSystemServiceTimeAtCpuSpeeds() {
		// Estimates the time spent by the system server handling incoming binder requests.
		//
		// The data that we can get from the kernel is this:
		@@ -13731,7 +13759,7 @@ public class BatteryStatsImpl extends BatteryStats {
		// - These 10 threads spent 1000 ms of CPU time in aggregate
		// - Of the 10 threads 4 were execute exclusively incoming binder calls.
		// - These 4 "binder" threads consumed 600 ms of CPU time in aggregate
		// - The real time spent by the system server UID doing all of this is, say, 200 ms.
		// - The real time spent by the system server process doing all of this is, say, 200 ms.
		//
		// We will assume that power consumption is proportional to the time spent by the CPU
		// across all threads. This is a crude assumption, but we don't have more detailed data.
		@@ -13745,41 +13773,29 @@ public class BatteryStatsImpl extends BatteryStats {
		// of the total power consumed by incoming binder calls for the given cluster/speed
		// combination.

		if (mSystemServerThreadCpuTimesUs == null) {
		return 0;
		}

		if (cluster < 0 \|\| cluster >= mSystemServerThreadCpuTimesUs.length) {
		return 0;
		}

		final LongSamplingCounter[] threadTimesForCluster = mSystemServerThreadCpuTimesUs[cluster];

		if (step < 0 \|\| step >= threadTimesForCluster.length) {
		return 0;
		}

		Uid systemUid = mUidStats.get(Process.SYSTEM_UID);
		if (systemUid == null) {
		return 0;
		if (mSystemServerCpuTimesUs == null) {
		return null;
		}

		final long uidTimeAtCpuSpeedUs = systemUid.getTimeAtCpuSpeed(cluster, step,
		final long[] systemServerCpuTimesUs = mSystemServerCpuTimesUs.getCountsLocked(
		BatteryStats.STATS_SINCE_CHARGED);
		final long [] systemServerThreadCpuTimesUs = mSystemServerThreadCpuTimesUs.getCountsLocked(
		BatteryStats.STATS_SINCE_CHARGED);
		final long[] binderThreadCpuTimesUs = mBinderThreadCpuTimesUs.getCountsLocked(
		BatteryStats.STATS_SINCE_CHARGED);
		if (uidTimeAtCpuSpeedUs == 0) {
		return 0;
		}

		final long uidThreadTimeUs =
		threadTimesForCluster[step].getCountLocked(BatteryStats.STATS_SINCE_CHARGED);
		final int size = systemServerCpuTimesUs.length;
		final long[] results = new long[size];

		if (uidThreadTimeUs == 0) {
		return 0;
		for (int i = 0; i < size; i++) {
		if (systemServerThreadCpuTimesUs[i] == 0) {
		continue;
		}

		final long binderThreadTimeUs = mBinderThreadCpuTimesUs[cluster][step].getCountLocked(
		BatteryStats.STATS_SINCE_CHARGED);
		return uidTimeAtCpuSpeedUs * binderThreadTimeUs / uidThreadTimeUs;
		results[i] = systemServerCpuTimesUs[i] * binderThreadCpuTimesUs[i]
		/ systemServerThreadCpuTimesUs[i];
		}
		return results;
		}

		/**
		@@ -14181,18 +14197,14 @@ public class BatteryStatsImpl extends BatteryStats {
		updateSystemServiceCallStats();
		if (mSystemServerThreadCpuTimesUs != null) {
		pw.println("Per UID System server binder time in ms:");
		long[] systemServiceTimeAtCpuSpeeds = getSystemServiceTimeAtCpuSpeeds();
		for (int i = 0; i < size; i++) {
		int u = mUidStats.keyAt(i);
		Uid uid = mUidStats.get(u);
		double proportionalSystemServiceUsage = uid.getProportionalSystemServiceUsage();

		long timeUs = 0;
		for (int cluster = 0; cluster < mSystemServerThreadCpuTimesUs.length; cluster++) {
		int numSpeeds = mSystemServerThreadCpuTimesUs[cluster].length;
		for (int speed = 0; speed < numSpeeds; speed++) {
		timeUs += getSystemServiceTimeAtCpuSpeed(cluster, speed)
		* proportionalSystemServiceUsage;
		}
		for (int j = systemServiceTimeAtCpuSpeeds.length - 1; j >= 0; j--) {
		timeUs += systemServiceTimeAtCpuSpeeds[j] * proportionalSystemServiceUsage;
		}

		pw.print(" ");
		@@ -15728,8 +15740,10 @@ public class BatteryStatsImpl extends BatteryStats {
		mUidStats.append(uid, u);
		}

		mSystemServerThreadCpuTimesUs = readCpuSpeedCountersFromParcel(in);
		mBinderThreadCpuTimesUs = readCpuSpeedCountersFromParcel(in);
		mSystemServerCpuTimesUs = LongSamplingCounterArray.readFromParcel(in, mOnBatteryTimeBase);
		mSystemServerThreadCpuTimesUs = LongSamplingCounterArray.readFromParcel(in,
		mOnBatteryTimeBase);
		mBinderThreadCpuTimesUs = LongSamplingCounterArray.readFromParcel(in, mOnBatteryTimeBase);
		}

		public void writeToParcel(Parcel out, int flags) {
		@@ -15930,8 +15944,9 @@ public class BatteryStatsImpl extends BatteryStats {
		} else {
		out.writeInt(0);
		}
		writeCpuSpeedCountersToParcel(out, mSystemServerThreadCpuTimesUs);
		writeCpuSpeedCountersToParcel(out, mBinderThreadCpuTimesUs);
		LongSamplingCounterArray.writeToParcel(out, mSystemServerCpuTimesUs);
		LongSamplingCounterArray.writeToParcel(out, mSystemServerThreadCpuTimesUs);
		LongSamplingCounterArray.writeToParcel(out, mBinderThreadCpuTimesUs);
		}

		private void writeCpuSpeedCountersToParcel(Parcel out, LongSamplingCounter[][] counters) {

core/java/com/android/internal/os/KernelSingleProcessCpuThreadReader.java

0 → 100644

+259 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2020 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.internal.os;

		import static android.os.Process.PROC_OUT_LONG;
		import static android.os.Process.PROC_SPACE_TERM;

		import android.annotation.Nullable;
		import android.os.Process;
		import android.system.Os;
		import android.system.OsConstants;
		import android.util.Slog;

		import com.android.internal.annotations.VisibleForTesting;

		import java.io.IOException;
		import java.nio.file.DirectoryIteratorException;
		import java.nio.file.DirectoryStream;
		import java.nio.file.Files;
		import java.nio.file.Path;
		import java.nio.file.Paths;
		import java.util.ArrayList;
		import java.util.List;

		/**
		* Iterates over all threads owned by a given process, and return the CPU usage for
		* each thread. The CPU usage statistics contain the amount of time spent in a frequency band. CPU
		* usage is collected using {@link ProcTimeInStateReader}.
		*/
		public class KernelSingleProcessCpuThreadReader {

		private static final String TAG = "KernelSingleProcCpuThreadRdr";

		private static final boolean DEBUG = false;

		/**
		* The name of the file to read CPU statistics from, must be found in {@code
		* /proc/$PID/task/$TID}
		*/
		private static final String CPU_STATISTICS_FILENAME = "time_in_state";

		private static final String PROC_STAT_FILENAME = "stat";

		/** Directory under /proc/$PID containing CPU stats files for threads */
		public static final String THREAD_CPU_STATS_DIRECTORY = "task";

		/** Default mount location of the {@code proc} filesystem */
		private static final Path DEFAULT_PROC_PATH = Paths.get("/proc");

		/** The initial {@code time_in_state} file for {@link ProcTimeInStateReader} */
		private static final Path INITIAL_TIME_IN_STATE_PATH = Paths.get("self/time_in_state");

		/** See https://man7.org/linux/man-pages/man5/proc.5.html */
		private static final int[] PROCESS_FULL_STATS_FORMAT = new int[]{
		PROC_SPACE_TERM,
		PROC_SPACE_TERM,
		PROC_SPACE_TERM,
		PROC_SPACE_TERM,
		PROC_SPACE_TERM,
		PROC_SPACE_TERM,
		PROC_SPACE_TERM,
		PROC_SPACE_TERM,
		PROC_SPACE_TERM,
		PROC_SPACE_TERM,
		PROC_SPACE_TERM,
		PROC_SPACE_TERM,
		PROC_SPACE_TERM,
		PROC_SPACE_TERM \| PROC_OUT_LONG, // 14: utime
		PROC_SPACE_TERM \| PROC_OUT_LONG, // 15: stime
		// Ignore remaining fields
		};

		private final long[] mProcessFullStatsData = new long[2];

		private static final int PROCESS_FULL_STAT_UTIME = 0;
		private static final int PROCESS_FULL_STAT_STIME = 1;

		/** Used to read and parse {@code time_in_state} files */
		private final ProcTimeInStateReader mProcTimeInStateReader;

		private final int mPid;

		/** Where the proc filesystem is mounted */
		private final Path mProcPath;

		// How long a CPU jiffy is in milliseconds.
		private final long mJiffyMillis;

		// Path: /proc/<pid>/stat
		private final String mProcessStatFilePath;

		// Path: /proc/<pid>/task
		private final Path mThreadsDirectoryPath;

		/**
		* Count of frequencies read from the {@code time_in_state} file. Read from {@link
		* #mProcTimeInStateReader#getCpuFrequenciesKhz()}.
		*/
		private int mFrequencyCount;

		/**
		* Create with a path where `proc` is mounted. Used primarily for testing
		*
		* @param pid PID of the process whose threads are to be read.
		* @param procPath where `proc` is mounted (to find, see {@code mount \| grep ^proc})
		*/
		@VisibleForTesting
		public KernelSingleProcessCpuThreadReader(
		int pid,
		Path procPath) throws IOException {
		mPid = pid;
		mProcPath = procPath;
		mProcTimeInStateReader = new ProcTimeInStateReader(
		mProcPath.resolve(INITIAL_TIME_IN_STATE_PATH));
		long jiffyHz = Os.sysconf(OsConstants._SC_CLK_TCK);
		mJiffyMillis = 1000 / jiffyHz;
		mProcessStatFilePath =
		mProcPath.resolve(String.valueOf(mPid)).resolve(PROC_STAT_FILENAME).toString();
		mThreadsDirectoryPath =
		mProcPath.resolve(String.valueOf(mPid)).resolve(THREAD_CPU_STATS_DIRECTORY);
		}

		/**
		* Create the reader and handle exceptions during creation
		*
		* @return the reader, null if an exception was thrown during creation
		*/
		@Nullable
		public static KernelSingleProcessCpuThreadReader create(int pid) {
		try {
		return new KernelSingleProcessCpuThreadReader(pid, DEFAULT_PROC_PATH);
		} catch (IOException e) {
		Slog.e(TAG, "Failed to initialize KernelSingleProcessCpuThreadReader", e);
		return null;
		}
		}

		/**
		* Get the CPU frequencies that correspond to the times reported in {@link
		* ThreadCpuUsage#usageTimesMillis}
		*/
		public int getCpuFrequencyCount() {
		if (mFrequencyCount == 0) {
		mFrequencyCount = mProcTimeInStateReader.getFrequenciesKhz().length;
		}
		return mFrequencyCount;
		}

		/**
		* Get the total and per-thread CPU usage of the process with the PID specified in the
		* constructor.
		*/
		@Nullable
		public ProcessCpuUsage getProcessCpuUsage() {
		if (DEBUG) {
		Slog.d(TAG, "Reading CPU thread usages with directory " + mProcPath + " process ID "
		+ mPid);
		}

		if (!Process.readProcFile(mProcessStatFilePath, PROCESS_FULL_STATS_FORMAT, null,
		mProcessFullStatsData, null)) {
		Slog.e(TAG, "Failed to read process stat file " + mProcessStatFilePath);
		return null;
		}

		long utime = mProcessFullStatsData[PROCESS_FULL_STAT_UTIME];
		long stime = mProcessFullStatsData[PROCESS_FULL_STAT_STIME];

		long processCpuTimeMillis = (utime + stime) * mJiffyMillis;

		final ArrayList<ThreadCpuUsage> threadCpuUsages = new ArrayList<>();
		try (DirectoryStream<Path> threadPaths = Files.newDirectoryStream(mThreadsDirectoryPath)) {
		for (Path threadDirectory : threadPaths) {
		ThreadCpuUsage threadCpuUsage = getThreadCpuUsage(threadDirectory);
		if (threadCpuUsage == null) {
		continue;
		}
		threadCpuUsages.add(threadCpuUsage);
		}
		} catch (IOException \| DirectoryIteratorException e) {
		// Expected when a process finishes
		return null;
		}

		// If we found no threads, then the process has exited while we were reading from it
		if (threadCpuUsages.isEmpty()) {
		return null;
		}
		if (DEBUG) {
		Slog.d(TAG, "Read CPU usage of " + threadCpuUsages.size() + " threads");
		}
		return new ProcessCpuUsage(processCpuTimeMillis, threadCpuUsages);
		}

		/**
		* Get a thread's CPU usage
		*
		* @param threadDirectory the {@code /proc} directory of the thread
		* @return thread CPU usage. Null if the thread exited and its {@code proc} directory was
		* removed while collecting information
		*/
		@Nullable
		private ThreadCpuUsage getThreadCpuUsage(Path threadDirectory) {
		// Get the thread ID from the directory name
		final int threadId;
		try {
		final String directoryName = threadDirectory.getFileName().toString();
		threadId = Integer.parseInt(directoryName);
		} catch (NumberFormatException e) {
		Slog.w(TAG, "Failed to parse thread ID when iterating over /proc/*/task", e);
		return null;
		}

		// Get the CPU statistics from the directory
		final Path threadCpuStatPath = threadDirectory.resolve(CPU_STATISTICS_FILENAME);
		final long[] cpuUsages = mProcTimeInStateReader.getUsageTimesMillis(threadCpuStatPath);
		if (cpuUsages == null) {
		return null;
		}

		return new ThreadCpuUsage(threadId, cpuUsages);
		}

		/** CPU usage of a process and all of its threads */
		public static class ProcessCpuUsage {
		public final long cpuTimeMillis;
		public final List<ThreadCpuUsage> threadCpuUsages;

		ProcessCpuUsage(long cpuTimeMillis, List<ThreadCpuUsage> threadCpuUsages) {
		this.cpuTimeMillis = cpuTimeMillis;
		this.threadCpuUsages = threadCpuUsages;
		}
		}

		/** CPU usage of a thread */
		public static class ThreadCpuUsage {
		public final int threadId;
		public final long[] usageTimesMillis;

		ThreadCpuUsage(int threadId, long[] usageTimesMillis) {
		this.threadId = threadId;
		this.usageTimesMillis = usageTimesMillis;
		}
		}
		}

core/java/com/android/internal/os/SystemServerCpuThreadReader.java

+45 −47

File changed.

Preview size limit exceeded, changes collapsed.

core/java/com/android/internal/os/SystemServicePowerCalculator.java

+24 −18

File changed.

Preview size limit exceeded, changes collapsed.