Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2017 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | package com.android.internal.os; |
| 18 | |
Sudheer Shanka | b8ad594 | 2017-08-08 12:16:09 -0700 | [diff] [blame] | 19 | import static com.android.internal.util.Preconditions.checkNotNull; |
| 20 | |
| 21 | import android.annotation.NonNull; |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 22 | import android.annotation.Nullable; |
Sudheer Shanka | 0085752 | 2017-07-06 18:28:14 -0700 | [diff] [blame] | 23 | import android.os.SystemClock; |
Sudheer Shanka | b8ad594 | 2017-08-08 12:16:09 -0700 | [diff] [blame] | 24 | import android.util.IntArray; |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 25 | import android.util.Slog; |
| 26 | import android.util.SparseArray; |
Sudheer Shanka | 0085752 | 2017-07-06 18:28:14 -0700 | [diff] [blame] | 27 | import android.util.TimeUtils; |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 28 | |
| 29 | import com.android.internal.annotations.VisibleForTesting; |
| 30 | |
| 31 | import java.io.BufferedReader; |
| 32 | import java.io.FileReader; |
| 33 | import java.io.IOException; |
| 34 | |
| 35 | /** |
| 36 | * Reads /proc/uid_time_in_state which has the format: |
| 37 | * |
| 38 | * uid: [freq1] [freq2] [freq3] ... |
| 39 | * [uid1]: [time in freq1] [time in freq2] [time in freq3] ... |
| 40 | * [uid2]: [time in freq1] [time in freq2] [time in freq3] ... |
| 41 | * ... |
| 42 | * |
| 43 | * This provides the times a UID's processes spent executing at each different cpu frequency. |
| 44 | * The file contains a monotonically increasing count of time for a single boot. This class |
| 45 | * maintains the previous results of a call to {@link #readDelta} in order to provide a proper |
| 46 | * delta. |
| 47 | */ |
| 48 | public class KernelUidCpuFreqTimeReader { |
| 49 | private static final String TAG = "KernelUidCpuFreqTimeReader"; |
| 50 | private static final String UID_TIMES_PROC_FILE = "/proc/uid_time_in_state"; |
| 51 | |
| 52 | public interface Callback { |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 53 | void onUidCpuFreqTime(int uid, long[] cpuFreqTimeMs); |
| 54 | } |
| 55 | |
| 56 | private long[] mCpuFreqs; |
| 57 | private int mCpuFreqsCount; |
Sudheer Shanka | 0085752 | 2017-07-06 18:28:14 -0700 | [diff] [blame] | 58 | private long mLastTimeReadMs; |
| 59 | private long mNowTimeMs; |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 60 | |
| 61 | private SparseArray<long[]> mLastUidCpuFreqTimeMs = new SparseArray<>(); |
| 62 | |
Sudheer Shanka | acd7f2c | 2017-06-01 17:39:40 -0700 | [diff] [blame] | 63 | // We check the existence of proc file a few times (just in case it is not ready yet when we |
| 64 | // start reading) and if it is not available, we simply ignore further read requests. |
| 65 | private static final int TOTAL_READ_ERROR_COUNT = 5; |
| 66 | private int mReadErrorCounter; |
| 67 | private boolean mProcFileAvailable; |
Sudheer Shanka | b8ad594 | 2017-08-08 12:16:09 -0700 | [diff] [blame] | 68 | private boolean mPerClusterTimesAvailable; |
| 69 | |
| 70 | public boolean perClusterTimesAvailable() { |
| 71 | return mPerClusterTimesAvailable; |
| 72 | } |
| 73 | |
| 74 | public long[] readFreqs(@NonNull PowerProfile powerProfile) { |
| 75 | checkNotNull(powerProfile); |
| 76 | |
| 77 | if (mCpuFreqs != null) { |
| 78 | // No need to read cpu freqs more than once. |
| 79 | return mCpuFreqs; |
| 80 | } |
| 81 | if (!mProcFileAvailable && mReadErrorCounter >= TOTAL_READ_ERROR_COUNT) { |
| 82 | return null; |
| 83 | } |
| 84 | try (BufferedReader reader = new BufferedReader(new FileReader(UID_TIMES_PROC_FILE))) { |
| 85 | mProcFileAvailable = true; |
| 86 | return readFreqs(reader, powerProfile); |
| 87 | } catch (IOException e) { |
| 88 | mReadErrorCounter++; |
| 89 | Slog.e(TAG, "Failed to read " + UID_TIMES_PROC_FILE + ": " + e); |
| 90 | return null; |
| 91 | } |
| 92 | } |
| 93 | |
| 94 | @VisibleForTesting |
| 95 | public long[] readFreqs(BufferedReader reader, PowerProfile powerProfile) |
| 96 | throws IOException { |
| 97 | final String line = reader.readLine(); |
| 98 | if (line == null) { |
| 99 | return null; |
| 100 | } |
| 101 | return readCpuFreqs(line, powerProfile); |
| 102 | } |
Sudheer Shanka | acd7f2c | 2017-06-01 17:39:40 -0700 | [diff] [blame] | 103 | |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 104 | public void readDelta(@Nullable Callback callback) { |
Sudheer Shanka | b8ad594 | 2017-08-08 12:16:09 -0700 | [diff] [blame] | 105 | if (!mProcFileAvailable) { |
Sudheer Shanka | acd7f2c | 2017-06-01 17:39:40 -0700 | [diff] [blame] | 106 | return; |
| 107 | } |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 108 | try (BufferedReader reader = new BufferedReader(new FileReader(UID_TIMES_PROC_FILE))) { |
Sudheer Shanka | 0085752 | 2017-07-06 18:28:14 -0700 | [diff] [blame] | 109 | mNowTimeMs = SystemClock.elapsedRealtime(); |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 110 | readDelta(reader, callback); |
Sudheer Shanka | 0085752 | 2017-07-06 18:28:14 -0700 | [diff] [blame] | 111 | mLastTimeReadMs = mNowTimeMs; |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 112 | } catch (IOException e) { |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 113 | Slog.e(TAG, "Failed to read " + UID_TIMES_PROC_FILE + ": " + e); |
| 114 | } |
| 115 | } |
| 116 | |
Sudheer Shanka | 6d8dcec | 2017-06-01 12:09:03 -0700 | [diff] [blame] | 117 | public void removeUid(int uid) { |
| 118 | mLastUidCpuFreqTimeMs.delete(uid); |
| 119 | } |
| 120 | |
Suprabh Shukla | e6e723d | 2017-06-14 16:14:43 -0700 | [diff] [blame] | 121 | public void removeUidsInRange(int startUid, int endUid) { |
| 122 | if (endUid < startUid) { |
| 123 | return; |
| 124 | } |
| 125 | mLastUidCpuFreqTimeMs.put(startUid, null); |
| 126 | mLastUidCpuFreqTimeMs.put(endUid, null); |
| 127 | final int firstIndex = mLastUidCpuFreqTimeMs.indexOfKey(startUid); |
| 128 | final int lastIndex = mLastUidCpuFreqTimeMs.indexOfKey(endUid); |
| 129 | mLastUidCpuFreqTimeMs.removeAtRange(firstIndex, lastIndex - firstIndex + 1); |
| 130 | } |
| 131 | |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 132 | @VisibleForTesting |
| 133 | public void readDelta(BufferedReader reader, @Nullable Callback callback) throws IOException { |
| 134 | String line = reader.readLine(); |
| 135 | if (line == null) { |
| 136 | return; |
| 137 | } |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 138 | while ((line = reader.readLine()) != null) { |
| 139 | final int index = line.indexOf(' '); |
| 140 | final int uid = Integer.parseInt(line.substring(0, index - 1), 10); |
| 141 | readTimesForUid(uid, line.substring(index + 1, line.length()), callback); |
| 142 | } |
| 143 | } |
| 144 | |
| 145 | private void readTimesForUid(int uid, String line, Callback callback) { |
| 146 | long[] uidTimeMs = mLastUidCpuFreqTimeMs.get(uid); |
| 147 | if (uidTimeMs == null) { |
| 148 | uidTimeMs = new long[mCpuFreqsCount]; |
| 149 | mLastUidCpuFreqTimeMs.put(uid, uidTimeMs); |
| 150 | } |
| 151 | final String[] timesStr = line.split(" "); |
| 152 | final int size = timesStr.length; |
| 153 | if (size != uidTimeMs.length) { |
| 154 | Slog.e(TAG, "No. of readings don't match cpu freqs, readings: " + size |
| 155 | + " cpuFreqsCount: " + uidTimeMs.length); |
| 156 | return; |
| 157 | } |
| 158 | final long[] deltaUidTimeMs = new long[size]; |
Sudheer Shanka | 0085752 | 2017-07-06 18:28:14 -0700 | [diff] [blame] | 159 | final long[] curUidTimeMs = new long[size]; |
Sudheer Shanka | 97d15bf | 2017-06-19 19:19:08 -0700 | [diff] [blame] | 160 | boolean notify = false; |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 161 | for (int i = 0; i < size; ++i) { |
| 162 | // Times read will be in units of 10ms |
| 163 | final long totalTimeMs = Long.parseLong(timesStr[i], 10) * 10; |
| 164 | deltaUidTimeMs[i] = totalTimeMs - uidTimeMs[i]; |
Sudheer Shanka | 0085752 | 2017-07-06 18:28:14 -0700 | [diff] [blame] | 165 | // If there is malformed data for any uid, then we just log about it and ignore |
| 166 | // the data for that uid. |
| 167 | if (deltaUidTimeMs[i] < 0 || totalTimeMs < 0) { |
| 168 | final StringBuilder sb = new StringBuilder("Malformed cpu freq data for UID=") |
| 169 | .append(uid).append("\n"); |
| 170 | sb.append("data=").append("(").append(uidTimeMs[i]).append(",") |
| 171 | .append(totalTimeMs).append(")").append("\n"); |
Sudheer Shanka | 40c43f1 | 2017-08-08 15:44:09 -0700 | [diff] [blame] | 172 | sb.append("times=").append("("); |
| 173 | TimeUtils.formatDuration(mLastTimeReadMs, sb); sb.append(","); |
| 174 | TimeUtils.formatDuration(mNowTimeMs, sb); sb.append(")"); |
Sudheer Shanka | 8cde930 | 2017-08-23 11:29:23 -0700 | [diff] [blame] | 175 | Slog.e(TAG, sb.toString()); |
Sudheer Shanka | 0085752 | 2017-07-06 18:28:14 -0700 | [diff] [blame] | 176 | return; |
| 177 | } |
| 178 | curUidTimeMs[i] = totalTimeMs; |
Sudheer Shanka | 97d15bf | 2017-06-19 19:19:08 -0700 | [diff] [blame] | 179 | notify = notify || (deltaUidTimeMs[i] > 0); |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 180 | } |
Sudheer Shanka | 0085752 | 2017-07-06 18:28:14 -0700 | [diff] [blame] | 181 | if (notify) { |
| 182 | System.arraycopy(curUidTimeMs, 0, uidTimeMs, 0, size); |
| 183 | if (callback != null) { |
| 184 | callback.onUidCpuFreqTime(uid, deltaUidTimeMs); |
| 185 | } |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 186 | } |
| 187 | } |
| 188 | |
Sudheer Shanka | b8ad594 | 2017-08-08 12:16:09 -0700 | [diff] [blame] | 189 | private long[] readCpuFreqs(String line, PowerProfile powerProfile) { |
| 190 | final String[] freqStr = line.split(" "); |
| 191 | // First item would be "uid: " which needs to be ignored. |
| 192 | mCpuFreqsCount = freqStr.length - 1; |
| 193 | mCpuFreqs = new long[mCpuFreqsCount]; |
| 194 | for (int i = 0; i < mCpuFreqsCount; ++i) { |
| 195 | mCpuFreqs[i] = Long.parseLong(freqStr[i + 1], 10); |
| 196 | } |
| 197 | |
| 198 | // Check if the freqs in the proc file correspond to per-cluster freqs. |
| 199 | final IntArray numClusterFreqs = extractClusterInfoFromProcFileFreqs(); |
| 200 | final int numClusters = powerProfile.getNumCpuClusters(); |
| 201 | if (numClusterFreqs.size() == numClusters) { |
| 202 | mPerClusterTimesAvailable = true; |
| 203 | for (int i = 0; i < numClusters; ++i) { |
| 204 | if (numClusterFreqs.get(i) != powerProfile.getNumSpeedStepsInCpuCluster(i)) { |
| 205 | mPerClusterTimesAvailable = false; |
| 206 | break; |
| 207 | } |
| 208 | } |
| 209 | } else { |
| 210 | mPerClusterTimesAvailable = false; |
| 211 | } |
| 212 | Slog.i(TAG, "mPerClusterTimesAvailable=" + mPerClusterTimesAvailable); |
| 213 | |
| 214 | return mCpuFreqs; |
| 215 | } |
| 216 | |
| 217 | /** |
| 218 | * Extracts no. of cpu clusters and no. of freqs in each of these clusters from the freqs |
| 219 | * read from the proc file. |
| 220 | * |
| 221 | * We need to assume that freqs in each cluster are strictly increasing. |
| 222 | * For e.g. if the freqs read from proc file are: 12, 34, 15, 45, 12, 15, 52. Then it means |
| 223 | * there are 3 clusters: (12, 34), (15, 45), (12, 15, 52) |
| 224 | * |
| 225 | * @return an IntArray filled with no. of freqs in each cluster. |
| 226 | */ |
| 227 | private IntArray extractClusterInfoFromProcFileFreqs() { |
| 228 | final IntArray numClusterFreqs = new IntArray(); |
| 229 | int freqsFound = 0; |
| 230 | for (int i = 0; i < mCpuFreqsCount; ++i) { |
| 231 | freqsFound++; |
| 232 | if (i + 1 == mCpuFreqsCount || mCpuFreqs[i + 1] <= mCpuFreqs[i]) { |
| 233 | numClusterFreqs.add(freqsFound); |
| 234 | freqsFound = 0; |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 235 | } |
| 236 | } |
Sudheer Shanka | b8ad594 | 2017-08-08 12:16:09 -0700 | [diff] [blame] | 237 | return numClusterFreqs; |
Sudheer Shanka | 9b735c5 | 2017-05-09 18:26:18 -0700 | [diff] [blame] | 238 | } |
| 239 | } |