Merge "Add class to read per-thread CPU usage from proc filesystem" (0c6b2afb) · Commits · e / os / android_frameworks_base

apct-tests/perftests/core/src/android/os/KernelCpuThreadReaderPerfTest.java

0 → 100644

+52 −0

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

		import static org.junit.Assert.assertNotNull;

		import android.perftests.utils.BenchmarkState;
		import android.perftests.utils.PerfStatusReporter;
		import android.support.test.filters.LargeTest;
		import android.support.test.runner.AndroidJUnit4;

		import com.android.internal.os.KernelCpuThreadReader;

		import org.junit.Rule;
		import org.junit.Test;
		import org.junit.runner.RunWith;


		/**
		* Performance tests collecting per-thread CPU data.
		*/
		@RunWith(AndroidJUnit4.class)
		@LargeTest
		public class KernelCpuThreadReaderPerfTest {
		@Rule
		public final PerfStatusReporter mPerfStatusReporter = new PerfStatusReporter();

		private final KernelCpuThreadReader mKernelCpuThreadReader = KernelCpuThreadReader.create();

		@Test
		public void timeReadCurrentProcessCpuUsage() {
		final BenchmarkState state = mPerfStatusReporter.getBenchmarkState();
		assertNotNull(mKernelCpuThreadReader);
		while (state.keepRunning()) {
		this.mKernelCpuThreadReader.getCurrentProcessCpuUsage();
		}
		}
		}

core/java/android/os/Process.java

+4 −1

Original line number	Diff line number	Diff line
		@@ -990,6 +990,8 @@ public class Process {
		/** @hide */
		public static final int PROC_TAB_TERM = (int)'\t';
		/** @hide */
		public static final int PROC_NEWLINE_TERM = (int) '\n';
		/** @hide */
		public static final int PROC_COMBINE = 0x100;
		/** @hide */
		public static final int PROC_PARENS = 0x200;
		@@ -1009,7 +1011,8 @@ public class Process {
		*
		* <p>The format is a list of integers, where every integer describes a variable in the file. It
		* specifies how the variable is syntactically terminated (e.g. {@link Process#PROC_SPACE_TERM},
		* {@link Process#PROC_TAB_TERM}, {@link Process#PROC_ZERO_TERM}).
		* {@link Process#PROC_TAB_TERM}, {@link Process#PROC_ZERO_TERM}, {@link
		* Process#PROC_NEWLINE_TERM}).
		*
		* <p>If the variable should be parsed and returned to the caller, the termination type should
		* be binary OR'd with the type of output (e.g. {@link Process#PROC_OUT_STRING}, {@link

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

0 → 100644

+306 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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 android.annotation.Nullable;
		import android.os.Process;
		import android.util.Slog;

		import com.android.internal.annotations.VisibleForTesting;

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

		/**
		* Given a process, will iterate over the child threads of the process, and return the CPU usage
		* statistics for each child thread. The CPU usage statistics contain the amount of time spent in a
		* frequency band.
		*/
		public class KernelCpuThreadReader {

		private static final String TAG = "KernelCpuThreadReader";

		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";

		/**
		* The name of the file to read process command line invocation from, must be found in
		* {@code /proc/$PID/}
		*/
		private static final String PROCESS_NAME_FILENAME = "cmdline";

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

		/**
		* Default process name when the name can't be read
		*/
		private static final String DEFAULT_PROCESS_NAME = "unknown_process";

		/**
		* Default thread name when the name can't be read
		*/
		private static final String DEFAULT_THREAD_NAME = "unknown_thread";

		/**
		* 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 DEFAULT_INITIAL_TIME_IN_STATE_PATH =
		DEFAULT_PROC_PATH.resolve("self/time_in_state");

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

		/**
		* Frequencies read from the {@code time_in_state} file. Read from {@link
		* #mProcTimeInStateReader#getCpuFrequenciesKhz()} and cast to {@code int[]}
		*/
		private final int[] mFrequenciesKhz;

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

		private KernelCpuThreadReader() throws IOException {
		this(DEFAULT_PROC_PATH, DEFAULT_INITIAL_TIME_IN_STATE_PATH);
		}

		/**
		* Create with a path where `proc` is mounted. Used primarily for testing
		*
		* @param procPath where `proc` is mounted (to find, see {@code mount \| grep ^proc})
		* @param initialTimeInStatePath where the initial {@code time_in_state} file exists to define
		* format
		*/
		@VisibleForTesting
		public KernelCpuThreadReader(Path procPath, Path initialTimeInStatePath) throws IOException {
		mProcPath = procPath;
		mProcTimeInStateReader = new ProcTimeInStateReader(initialTimeInStatePath);

		// Copy mProcTimeInState's frequencies, casting the longs to ints
		long[] frequenciesKhz = mProcTimeInStateReader.getFrequenciesKhz();
		mFrequenciesKhz = new int[frequenciesKhz.length];
		for (int i = 0; i < frequenciesKhz.length; i++) {
		mFrequenciesKhz[i] = (int) frequenciesKhz[i];
		}
		}

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

		/**
		* Read all of the CPU usage statistics for each child thread of the current process
		*
		* @return process CPU usage containing usage of all child threads
		*/
		@Nullable
		public ProcessCpuUsage getCurrentProcessCpuUsage() {
		return getProcessCpuUsage(
		mProcPath.resolve("self"),
		Process.myPid(),
		Process.myUid());
		}

		/**
		* Read all of the CPU usage statistics for each child thread of a process
		*
		* @param processPath the {@code /proc} path of the thread
		* @param processId the ID of the process
		* @param uid the ID of the user who owns the process
		* @return process CPU usage containing usage of all child threads
		*/
		@Nullable
		private ProcessCpuUsage getProcessCpuUsage(Path processPath, int processId, int uid) {
		if (DEBUG) {
		Slog.d(TAG, "Reading CPU thread usages with directory " + processPath
		+ " process ID " + processId
		+ " and user ID " + uid);
		}

		final Path allThreadsPath = processPath.resolve("task");
		final ArrayList<ThreadCpuUsage> threadCpuUsages = new ArrayList<>();
		try (DirectoryStream<Path> threadPaths = Files.newDirectoryStream(allThreadsPath)) {
		for (Path threadDirectory : threadPaths) {
		ThreadCpuUsage threadCpuUsage = getThreadCpuUsage(threadDirectory);
		if (threadCpuUsage != null) {
		threadCpuUsages.add(threadCpuUsage);
		}
		}
		} catch (IOException e) {
		Slog.w(TAG, "Failed to iterate over thread paths", e);
		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(
		processId,
		getProcessName(processPath),
		uid,
		threadCpuUsages);
		}

		/**
		* Get the CPU frequencies that correspond to the times reported in
		* {@link ThreadCpuUsage#usageTimesMillis}
		*/
		@Nullable
		public int[] getCpuFrequenciesKhz() {
		return mFrequenciesKhz;
		}

		/**
		* Get a thread's CPU usage
		*
		* @param threadDirectory the {@code /proc} directory of the thread
		* @return null in the case that the directory read failed
		*/
		@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 thread name from the thread directory
		final String threadName = getThreadName(threadDirectory);

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

		// Convert long[] to int[]
		final int[] cpuUsages = new int[cpuUsagesLong.length];
		for (int i = 0; i < cpuUsagesLong.length; i++) {
		cpuUsages[i] = (int) cpuUsagesLong[i];
		}

		return new ThreadCpuUsage(threadId, threadName, cpuUsages);
		}

		/**
		* Get the command used to start a process
		*/
		private String getProcessName(Path processPath) {
		final Path processNamePath = processPath.resolve(PROCESS_NAME_FILENAME);

		final String processName =
		ProcStatsUtil.readSingleLineProcFile(processNamePath.toString());
		if (processName != null) {
		return processName;
		}
		return DEFAULT_PROCESS_NAME;
		}

		/**
		* Get the name of a thread, given the {@code /proc} path of the thread
		*/
		private String getThreadName(Path threadPath) {
		final Path threadNamePath = threadPath.resolve(THREAD_NAME_FILENAME);
		final String threadName =
		ProcStatsUtil.readNullSeparatedFile(threadNamePath.toString());
		if (threadName == null) {
		return DEFAULT_THREAD_NAME;
		}
		return threadName;
		}

		/**
		* CPU usage of a process
		*/
		public static class ProcessCpuUsage {
		public final int processId;
		public final String processName;
		public final int uid;
		public final ArrayList<ThreadCpuUsage> threadCpuUsages;

		ProcessCpuUsage(
		int processId,
		String processName,
		int uid,
		ArrayList<ThreadCpuUsage> threadCpuUsages) {
		this.processId = processId;
		this.processName = processName;
		this.uid = uid;
		this.threadCpuUsages = threadCpuUsages;
		}
		}

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

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

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

0 → 100644

+145 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2018 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 android.annotation.Nullable;
		import android.os.StrictMode;
		import android.util.Slog;

		import java.io.ByteArrayOutputStream;
		import java.io.FileInputStream;
		import java.io.IOException;

		/**
		* Utility functions for reading {@code proc} files
		*/
		final class ProcStatsUtil {

		private static final String TAG = "ProcStatsUtil";

		/**
		* How much to read into a buffer when reading a proc file
		*/
		private static final int READ_SIZE = 1024;

		/**
		* Class only contains static utility functions, and should not be instantiated
		*/
		private ProcStatsUtil() {
		}

		/**
		* Read a {@code proc} file where the contents are separated by null bytes. Replaces the null
		* bytes with spaces, and removes any trailing null bytes
		*
		* @param path path of the file to read
		*/
		@Nullable
		static String readNullSeparatedFile(String path) {
		String contents = readSingleLineProcFile(path);
		if (contents == null) {
		return null;
		}

		// Content is either double-null terminated, or terminates at end of line. Remove anything
		// after the double-null
		final int endIndex = contents.indexOf("\0\0");
		if (endIndex != -1) {
		contents = contents.substring(0, endIndex);
		}

		// Change the null-separated contents into space-seperated
		return contents.replace("\0", " ");
		}

		/**
		* Read a {@code proc} file that contains a single line (e.g. {@code /proc/$PID/cmdline}, {@code
		* /proc/$PID/comm})
		*
		* @param path path of the file to read
		*/
		@Nullable
		static String readSingleLineProcFile(String path) {
		return readTerminatedProcFile(path, (byte) '\n');
		}

		/**
		* Read a {@code proc} file that terminates with a specific byte
		*
		* @param path path of the file to read
		* @param terminator byte that terminates the file. We stop reading once this character is
		* seen, or at the end of the file
		*/
		@Nullable
		public static String readTerminatedProcFile(String path, byte terminator) {
		// Permit disk reads here, as /proc isn't really "on disk" and should be fast.
		// TODO: make BlockGuard ignore /proc/ and /sys/ files perhaps?
		final StrictMode.ThreadPolicy savedPolicy = StrictMode.allowThreadDiskReads();
		try (FileInputStream is = new FileInputStream(path)) {
		ByteArrayOutputStream byteStream = null;
		final byte[] buffer = new byte[READ_SIZE];
		while (true) {
		// Read file into buffer
		final int len = is.read(buffer);
		if (len <= 0) {
		// If we've read nothing, we're done
		break;
		}

		// Find the terminating character
		int terminatingIndex = -1;
		for (int i = 0; i < len; i++) {
		if (buffer[i] == terminator) {
		terminatingIndex = i;
		break;
		}
		}
		final boolean foundTerminator = terminatingIndex != -1;

		// If we have found it and the byte stream isn't initialized, we don't need to
		// initialize it and can return the string here
		if (foundTerminator && byteStream == null) {
		return new String(buffer, 0, terminatingIndex);
		}

		// Initialize the byte stream
		if (byteStream == null) {
		byteStream = new ByteArrayOutputStream(READ_SIZE);
		}

		// Write the whole buffer if terminator not found, or up to the terminator if found
		byteStream.write(buffer, 0, foundTerminator ? terminatingIndex : len);

		// If we've found the terminator, we can finish
		if (foundTerminator) {
		break;
		}
		}

		// If the byte stream is null at the end, this means that we have read an empty file
		if (byteStream == null) {
		return "";
		}
		return byteStream.toString();
		} catch (IOException e) {
		Slog.w(TAG, "Failed to open proc file", e);
		return null;
		} finally {
		StrictMode.setThreadPolicy(savedPolicy);
		}
		}
		}

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

0 → 100644

+186 −0

File added.

Preview size limit exceeded, changes collapsed.