1 /* 2 * Copyright (C) 2011 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 #define LOG_TAG "ThreadCpuUsage" 18 //#define LOG_NDEBUG 0 19 20 #include <errno.h> 21 #include <stdlib.h> 22 #include <time.h> 23 24 #include <utils/Debug.h> 25 #include <utils/Log.h> 26 27 #include <cpustats/ThreadCpuUsage.h> 28 29 namespace android { 30 31 bool ThreadCpuUsage::setEnabled(bool isEnabled) 32 { 33 bool wasEnabled = mIsEnabled; 34 // only do something if there is a change 35 if (isEnabled != wasEnabled) { 36 ALOGV("setEnabled(%d)", isEnabled); 37 int rc; 38 // enabling 39 if (isEnabled) { 40 rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &mPreviousTs); 41 if (rc) { 42 ALOGE("clock_gettime(CLOCK_THREAD_CPUTIME_ID) errno=%d", errno); 43 isEnabled = false; 44 } else { 45 mWasEverEnabled = true; 46 // record wall clock time at first enable 47 if (!mMonotonicKnown) { 48 rc = clock_gettime(CLOCK_MONOTONIC, &mMonotonicTs); 49 if (rc) { 50 ALOGE("clock_gettime(CLOCK_MONOTONIC) errno=%d", errno); 51 } else { 52 mMonotonicKnown = true; 53 } 54 } 55 } 56 // disabling 57 } else { 58 struct timespec ts; 59 rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts); 60 if (rc) { 61 ALOGE("clock_gettime(CLOCK_THREAD_CPUTIME_ID) errno=%d", errno); 62 } else { 63 long long delta = (ts.tv_sec - mPreviousTs.tv_sec) * 1000000000LL + 64 (ts.tv_nsec - mPreviousTs.tv_nsec); 65 mAccumulator += delta; 66 #if 0 67 mPreviousTs = ts; 68 #endif 69 } 70 } 71 mIsEnabled = isEnabled; 72 } 73 return wasEnabled; 74 } 75 76 bool ThreadCpuUsage::sampleAndEnable(double& ns) 77 { 78 bool ret; 79 bool wasEverEnabled = mWasEverEnabled; 80 if (enable()) { 81 // already enabled, so add a new sample relative to previous 82 return sample(ns); 83 } else if (wasEverEnabled) { 84 // was disabled, but add sample for accumulated time while enabled 85 ns = (double) mAccumulator; 86 mAccumulator = 0; 87 ALOGV("sampleAndEnable %.0f", ns); 88 return true; 89 } else { 90 // first time called 91 ns = 0.0; 92 ALOGV("sampleAndEnable false"); 93 return false; 94 } 95 } 96 97 bool ThreadCpuUsage::sample(double &ns) 98 { 99 if (mWasEverEnabled) { 100 if (mIsEnabled) { 101 struct timespec ts; 102 int rc; 103 rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts); 104 if (rc) { 105 ALOGE("clock_gettime(CLOCK_THREAD_CPUTIME_ID) errno=%d", errno); 106 ns = 0.0; 107 return false; 108 } else { 109 long long delta = (ts.tv_sec - mPreviousTs.tv_sec) * 1000000000LL + 110 (ts.tv_nsec - mPreviousTs.tv_nsec); 111 mAccumulator += delta; 112 mPreviousTs = ts; 113 } 114 } else { 115 mWasEverEnabled = false; 116 } 117 ns = (double) mAccumulator; 118 ALOGV("sample %.0f", ns); 119 mAccumulator = 0; 120 return true; 121 } else { 122 ALOGW("Can't add sample because measurements have never been enabled"); 123 ns = 0.0; 124 return false; 125 } 126 } 127 128 long long ThreadCpuUsage::elapsed() const 129 { 130 long long elapsed; 131 if (mMonotonicKnown) { 132 struct timespec ts; 133 int rc; 134 rc = clock_gettime(CLOCK_MONOTONIC, &ts); 135 if (rc) { 136 ALOGE("clock_gettime(CLOCK_MONOTONIC) errno=%d", errno); 137 elapsed = 0; 138 } else { 139 // mMonotonicTs is updated only at first enable and resetStatistics 140 elapsed = (ts.tv_sec - mMonotonicTs.tv_sec) * 1000000000LL + 141 (ts.tv_nsec - mMonotonicTs.tv_nsec); 142 } 143 } else { 144 ALOGW("Can't compute elapsed time because measurements have never been enabled"); 145 elapsed = 0; 146 } 147 ALOGV("elapsed %lld", elapsed); 148 return elapsed; 149 } 150 151 void ThreadCpuUsage::resetElapsed() 152 { 153 ALOGV("resetElapsed"); 154 if (mMonotonicKnown) { 155 int rc; 156 rc = clock_gettime(CLOCK_MONOTONIC, &mMonotonicTs); 157 if (rc) { 158 ALOGE("clock_gettime(CLOCK_MONOTONIC) errno=%d", errno); 159 mMonotonicKnown = false; 160 } 161 } 162 } 163 164 /*static*/ 165 int ThreadCpuUsage::sScalingFds[ThreadCpuUsage::MAX_CPU]; 166 pthread_once_t ThreadCpuUsage::sOnceControl = PTHREAD_ONCE_INIT; 167 int ThreadCpuUsage::sKernelMax; 168 pthread_mutex_t ThreadCpuUsage::sMutex = PTHREAD_MUTEX_INITIALIZER; 169 170 /*static*/ 171 void ThreadCpuUsage::init() 172 { 173 // read the number of CPUs 174 sKernelMax = 1; 175 int fd = open("/sys/devices/system/cpu/kernel_max", O_RDONLY); 176 if (fd >= 0) { 177 #define KERNEL_MAX_SIZE 12 178 char kernelMax[KERNEL_MAX_SIZE]; 179 ssize_t actual = read(fd, kernelMax, sizeof(kernelMax)); 180 if (actual >= 2 && kernelMax[actual-1] == '\n') { 181 sKernelMax = atoi(kernelMax); 182 if (sKernelMax >= MAX_CPU - 1) { 183 ALOGW("kernel_max %d but MAX_CPU %d", sKernelMax, MAX_CPU); 184 sKernelMax = MAX_CPU; 185 } else if (sKernelMax < 0) { 186 ALOGW("kernel_max invalid %d", sKernelMax); 187 sKernelMax = 1; 188 } else { 189 ++sKernelMax; 190 ALOGV("number of CPUs %d", sKernelMax); 191 } 192 } else { 193 ALOGW("Can't read number of CPUs"); 194 } 195 (void) close(fd); 196 } else { 197 ALOGW("Can't open number of CPUs"); 198 } 199 int i; 200 for (i = 0; i < MAX_CPU; ++i) { 201 sScalingFds[i] = -1; 202 } 203 } 204 205 uint32_t ThreadCpuUsage::getCpukHz(int cpuNum) 206 { 207 if (cpuNum < 0 || cpuNum >= MAX_CPU) { 208 ALOGW("getCpukHz called with invalid CPU %d", cpuNum); 209 return 0; 210 } 211 // double-checked locking idiom is not broken for atomic values such as fd 212 int fd = sScalingFds[cpuNum]; 213 if (fd < 0) { 214 // some kernels can't open a scaling file until hot plug complete 215 pthread_mutex_lock(&sMutex); 216 fd = sScalingFds[cpuNum]; 217 if (fd < 0) { 218 #define FREQ_SIZE 64 219 char freq_path[FREQ_SIZE]; 220 #define FREQ_DIGIT 27 221 COMPILE_TIME_ASSERT_FUNCTION_SCOPE(MAX_CPU <= 10); 222 #define FREQ_PATH "/sys/devices/system/cpu/cpu?/cpufreq/scaling_cur_freq" 223 strlcpy(freq_path, FREQ_PATH, sizeof(freq_path)); 224 freq_path[FREQ_DIGIT] = cpuNum + '0'; 225 fd = open(freq_path, O_RDONLY | O_CLOEXEC); 226 // keep this fd until process exit or exec 227 sScalingFds[cpuNum] = fd; 228 } 229 pthread_mutex_unlock(&sMutex); 230 if (fd < 0) { 231 ALOGW("getCpukHz can't open CPU %d", cpuNum); 232 return 0; 233 } 234 } 235 #define KHZ_SIZE 12 236 char kHz[KHZ_SIZE]; // kHz base 10 237 ssize_t actual = pread(fd, kHz, sizeof(kHz), (off_t) 0); 238 uint32_t ret; 239 if (actual >= 2 && kHz[actual-1] == '\n') { 240 ret = atoi(kHz); 241 } else { 242 ret = 0; 243 } 244 if (ret != mCurrentkHz[cpuNum]) { 245 if (ret > 0) { 246 ALOGV("CPU %d frequency %u kHz", cpuNum, ret); 247 } else { 248 ALOGW("Can't read CPU %d frequency", cpuNum); 249 } 250 mCurrentkHz[cpuNum] = ret; 251 } 252 return ret; 253 } 254 255 } // namespace android 256
