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