mv libcpustats from frameworks/base to /native
OK to lose history Change-Id: I563fec271e0bc240e4a09a8b9647c7439badd85b
This commit is contained in:
Glenn Kasten
parent
94ff71fd6a
commit
0b94dcd03d
|
|
@ -0,0 +1,75 @@
|
|||
/*
|
||||
* Copyright (C) 2011 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.
|
||||
*/
|
||||
|
||||
#ifndef _CENTRAL_TENDENCY_STATISTICS_H
|
||||
#define _CENTRAL_TENDENCY_STATISTICS_H
|
||||
|
||||
#include <math.h>
|
||||
|
||||
// Not multithread safe
|
||||
class CentralTendencyStatistics {
|
||||
|
||||
public:
|
||||
|
||||
CentralTendencyStatistics() :
|
||||
mMean(NAN), mMedian(NAN), mMinimum(INFINITY), mMaximum(-INFINITY), mN(0), mM2(0),
|
||||
mVariance(NAN), mVarianceKnownForN(0), mStddev(NAN), mStddevKnownForN(0) { }
|
||||
|
||||
~CentralTendencyStatistics() { }
|
||||
|
||||
// add x to the set of samples
|
||||
void sample(double x);
|
||||
|
||||
// return the arithmetic mean of all samples so far
|
||||
double mean() const { return mMean; }
|
||||
|
||||
// return the minimum of all samples so far
|
||||
double minimum() const { return mMinimum; }
|
||||
|
||||
// return the maximum of all samples so far
|
||||
double maximum() const { return mMaximum; }
|
||||
|
||||
// return the variance of all samples so far
|
||||
double variance() const;
|
||||
|
||||
// return the standard deviation of all samples so far
|
||||
double stddev() const;
|
||||
|
||||
// return the number of samples added so far
|
||||
unsigned n() const { return mN; }
|
||||
|
||||
// reset the set of samples to be empty
|
||||
void reset();
|
||||
|
||||
private:
|
||||
double mMean;
|
||||
double mMedian;
|
||||
double mMinimum;
|
||||
double mMaximum;
|
||||
unsigned mN; // number of samples so far
|
||||
double mM2;
|
||||
|
||||
// cached variance, and n at time of caching
|
||||
mutable double mVariance;
|
||||
mutable unsigned mVarianceKnownForN;
|
||||
|
||||
// cached standard deviation, and n at time of caching
|
||||
mutable double mStddev;
|
||||
mutable unsigned mStddevKnownForN;
|
||||
|
||||
};
|
||||
|
||||
#endif // _CENTRAL_TENDENCY_STATISTICS_H
|
||||
|
|
@ -0,0 +1,6 @@
|
|||
This is a static library of CPU usage statistics, originally written
|
||||
for audio but most are not actually specific to audio.
|
||||
|
||||
Requirements to be here:
|
||||
* should be related to CPU usage statistics
|
||||
* should be portable to host; avoid Android OS dependencies without a conditional
|
||||
|
|
@ -0,0 +1,139 @@
|
|||
/*
|
||||
* Copyright (C) 2011 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.
|
||||
*/
|
||||
|
||||
#ifndef _THREAD_CPU_USAGE_H
|
||||
#define _THREAD_CPU_USAGE_H
|
||||
|
||||
#include <fcntl.h>
|
||||
#include <pthread.h>
|
||||
|
||||
namespace android {
|
||||
|
||||
// Track CPU usage for the current thread.
|
||||
// Units are in per-thread CPU ns, as reported by
|
||||
// clock_gettime(CLOCK_THREAD_CPUTIME_ID). Simple usage: for cyclic
|
||||
// threads where you want to measure the execution time of the whole
|
||||
// cycle, just call sampleAndEnable() at the start of each cycle.
|
||||
// For acyclic threads, or for cyclic threads where you want to measure/track
|
||||
// only part of each cycle, call enable(), disable(), and/or setEnabled()
|
||||
// to demarcate the region(s) of interest, and then call sample() periodically.
|
||||
// This class is not thread-safe for concurrent calls from multiple threads;
|
||||
// the methods of this class may only be called by the current thread
|
||||
// which constructed the object.
|
||||
|
||||
class ThreadCpuUsage
|
||||
{
|
||||
|
||||
public:
|
||||
ThreadCpuUsage() :
|
||||
mIsEnabled(false),
|
||||
mWasEverEnabled(false),
|
||||
mAccumulator(0),
|
||||
// mPreviousTs
|
||||
// mMonotonicTs
|
||||
mMonotonicKnown(false)
|
||||
{
|
||||
(void) pthread_once(&sOnceControl, &init);
|
||||
for (int i = 0; i < sKernelMax; ++i) {
|
||||
mCurrentkHz[i] = (uint32_t) ~0; // unknown
|
||||
}
|
||||
}
|
||||
|
||||
~ThreadCpuUsage() { }
|
||||
|
||||
// Return whether currently tracking CPU usage by current thread
|
||||
bool isEnabled() const { return mIsEnabled; }
|
||||
|
||||
// Enable tracking of CPU usage by current thread;
|
||||
// any CPU used from this point forward will be tracked.
|
||||
// Returns the previous enabled status.
|
||||
bool enable() { return setEnabled(true); }
|
||||
|
||||
// Disable tracking of CPU usage by current thread;
|
||||
// any CPU used from this point forward will be ignored.
|
||||
// Returns the previous enabled status.
|
||||
bool disable() { return setEnabled(false); }
|
||||
|
||||
// Set the enabled status and return the previous enabled status.
|
||||
// This method is intended to be used for safe nested enable/disabling.
|
||||
bool setEnabled(bool isEnabled);
|
||||
|
||||
// Add a sample point, and also enable tracking if needed.
|
||||
// If tracking has never been enabled, then this call enables tracking but
|
||||
// does _not_ add a sample -- it is not possible to add a sample the
|
||||
// first time because there is no previous point to subtract from.
|
||||
// Otherwise, if tracking is enabled,
|
||||
// then adds a sample for tracked CPU ns since the previous
|
||||
// sample, or since the first call to sampleAndEnable(), enable(), or
|
||||
// setEnabled(true). If there was a previous sample but tracking is
|
||||
// now disabled, then adds a sample for the tracked CPU ns accumulated
|
||||
// up until the most recent disable(), resets this accumulator, and then
|
||||
// enables tracking. Calling this method rather than enable() followed
|
||||
// by sample() avoids a race condition for the first sample.
|
||||
// Returns true if the sample 'ns' is valid, or false if invalid.
|
||||
// Note that 'ns' is an output parameter passed by reference.
|
||||
// The caller does not need to initialize this variable.
|
||||
// The units are CPU nanoseconds consumed by current thread.
|
||||
bool sampleAndEnable(double& ns);
|
||||
|
||||
// Add a sample point, but do not
|
||||
// change the tracking enabled status. If tracking has either never been
|
||||
// enabled, or has never been enabled since the last sample, then log a warning
|
||||
// and don't add sample. Otherwise, adds a sample for tracked CPU ns since
|
||||
// the previous sample or since the first call to sampleAndEnable(),
|
||||
// enable(), or setEnabled(true) if no previous sample.
|
||||
// Returns true if the sample is valid, or false if invalid.
|
||||
// Note that 'ns' is an output parameter passed by reference.
|
||||
// The caller does not need to initialize this variable.
|
||||
// The units are CPU nanoseconds consumed by current thread.
|
||||
bool sample(double& ns);
|
||||
|
||||
// Return the elapsed delta wall clock ns since initial enable or reset,
|
||||
// as reported by clock_gettime(CLOCK_MONOTONIC).
|
||||
long long elapsed() const;
|
||||
|
||||
// Reset elapsed wall clock. Has no effect on tracking or accumulator.
|
||||
void resetElapsed();
|
||||
|
||||
// Return current clock frequency for specified CPU, in kHz.
|
||||
// You can get your CPU number using sched_getcpu(2). Note that, unless CPU affinity
|
||||
// has been configured appropriately, the CPU number can change.
|
||||
// Also note that, unless the CPU governor has been configured appropriately,
|
||||
// the CPU frequency can change. And even if the CPU frequency is locked down
|
||||
// to a particular value, that the frequency might still be adjusted
|
||||
// to prevent thermal overload. Therefore you should poll for your thread's
|
||||
// current CPU number and clock frequency periodically.
|
||||
uint32_t getCpukHz(int cpuNum);
|
||||
|
||||
private:
|
||||
bool mIsEnabled; // whether tracking is currently enabled
|
||||
bool mWasEverEnabled; // whether tracking was ever enabled
|
||||
long long mAccumulator; // accumulated thread CPU time since last sample, in ns
|
||||
struct timespec mPreviousTs; // most recent thread CPU time, valid only if mIsEnabled is true
|
||||
struct timespec mMonotonicTs; // most recent monotonic time
|
||||
bool mMonotonicKnown; // whether mMonotonicTs has been set
|
||||
|
||||
static const int MAX_CPU = 8;
|
||||
static int sScalingFds[MAX_CPU];// file descriptor per CPU for reading scaling_cur_freq
|
||||
uint32_t mCurrentkHz[MAX_CPU]; // current CPU frequency in kHz, not static to avoid a race
|
||||
static pthread_once_t sOnceControl;
|
||||
static int sKernelMax; // like MAX_CPU, but determined at runtime == cpu/kernel_max + 1
|
||||
static void init();
|
||||
};
|
||||
|
||||
} // namespace android
|
||||
|
||||
#endif // _THREAD_CPU_USAGE_H
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
LOCAL_PATH:= $(call my-dir)
|
||||
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_SRC_FILES := \
|
||||
CentralTendencyStatistics.cpp \
|
||||
ThreadCpuUsage.cpp
|
||||
|
||||
LOCAL_MODULE := libcpustats
|
||||
|
||||
include $(BUILD_STATIC_LIBRARY)
|
||||
|
|
@ -0,0 +1,81 @@
|
|||
/*
|
||||
* Copyright (C) 2011 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.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <cpustats/CentralTendencyStatistics.h>
|
||||
|
||||
void CentralTendencyStatistics::sample(double x)
|
||||
{
|
||||
// update min and max
|
||||
if (x < mMinimum)
|
||||
mMinimum = x;
|
||||
if (x > mMaximum)
|
||||
mMaximum = x;
|
||||
// Knuth
|
||||
if (mN == 0) {
|
||||
mMean = 0;
|
||||
}
|
||||
++mN;
|
||||
double delta = x - mMean;
|
||||
mMean += delta / mN;
|
||||
mM2 += delta * (x - mMean);
|
||||
}
|
||||
|
||||
void CentralTendencyStatistics::reset()
|
||||
{
|
||||
mMean = NAN;
|
||||
mMedian = NAN;
|
||||
mMinimum = INFINITY;
|
||||
mMaximum = -INFINITY;
|
||||
mN = 0;
|
||||
mM2 = 0;
|
||||
mVariance = NAN;
|
||||
mVarianceKnownForN = 0;
|
||||
mStddev = NAN;
|
||||
mStddevKnownForN = 0;
|
||||
}
|
||||
|
||||
double CentralTendencyStatistics::variance() const
|
||||
{
|
||||
double variance;
|
||||
if (mVarianceKnownForN != mN) {
|
||||
if (mN > 1) {
|
||||
// double variance_n = M2/n;
|
||||
variance = mM2 / (mN - 1);
|
||||
} else {
|
||||
variance = NAN;
|
||||
}
|
||||
mVariance = variance;
|
||||
mVarianceKnownForN = mN;
|
||||
} else {
|
||||
variance = mVariance;
|
||||
}
|
||||
return variance;
|
||||
}
|
||||
|
||||
double CentralTendencyStatistics::stddev() const
|
||||
{
|
||||
double stddev;
|
||||
if (mStddevKnownForN != mN) {
|
||||
stddev = sqrt(variance());
|
||||
mStddev = stddev;
|
||||
mStddevKnownForN = mN;
|
||||
} else {
|
||||
stddev = mStddev;
|
||||
}
|
||||
return stddev;
|
||||
}
|
||||
|
|
@ -0,0 +1,252 @@
|
|||
/*
|
||||
* Copyright (C) 2011 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.
|
||||
*/
|
||||
|
||||
#define LOG_TAG "ThreadCpuUsage"
|
||||
//#define LOG_NDEBUG 0
|
||||
|
||||
#include <errno.h>
|
||||
#include <stdlib.h>
|
||||
#include <time.h>
|
||||
|
||||
#include <utils/Debug.h>
|
||||
#include <utils/Log.h>
|
||||
|
||||
#include <cpustats/ThreadCpuUsage.h>
|
||||
|
||||
namespace android {
|
||||
|
||||
bool ThreadCpuUsage::setEnabled(bool isEnabled)
|
||||
{
|
||||
bool wasEnabled = mIsEnabled;
|
||||
// only do something if there is a change
|
||||
if (isEnabled != wasEnabled) {
|
||||
ALOGV("setEnabled(%d)", isEnabled);
|
||||
int rc;
|
||||
// enabling
|
||||
if (isEnabled) {
|
||||
rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &mPreviousTs);
|
||||
if (rc) {
|
||||
ALOGE("clock_gettime(CLOCK_THREAD_CPUTIME_ID) errno=%d", errno);
|
||||
isEnabled = false;
|
||||
} else {
|
||||
mWasEverEnabled = true;
|
||||
// record wall clock time at first enable
|
||||
if (!mMonotonicKnown) {
|
||||
rc = clock_gettime(CLOCK_MONOTONIC, &mMonotonicTs);
|
||||
if (rc) {
|
||||
ALOGE("clock_gettime(CLOCK_MONOTONIC) errno=%d", errno);
|
||||
} else {
|
||||
mMonotonicKnown = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
// disabling
|
||||
} else {
|
||||
struct timespec ts;
|
||||
rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
|
||||
if (rc) {
|
||||
ALOGE("clock_gettime(CLOCK_THREAD_CPUTIME_ID) errno=%d", errno);
|
||||
} else {
|
||||
long long delta = (ts.tv_sec - mPreviousTs.tv_sec) * 1000000000LL +
|
||||
(ts.tv_nsec - mPreviousTs.tv_nsec);
|
||||
mAccumulator += delta;
|
||||
#if 0
|
||||
mPreviousTs = ts;
|
||||
#endif
|
||||
}
|
||||
}
|
||||
mIsEnabled = isEnabled;
|
||||
}
|
||||
return wasEnabled;
|
||||
}
|
||||
|
||||
bool ThreadCpuUsage::sampleAndEnable(double& ns)
|
||||
{
|
||||
bool ret;
|
||||
bool wasEverEnabled = mWasEverEnabled;
|
||||
if (enable()) {
|
||||
// already enabled, so add a new sample relative to previous
|
||||
return sample(ns);
|
||||
} else if (wasEverEnabled) {
|
||||
// was disabled, but add sample for accumulated time while enabled
|
||||
ns = (double) mAccumulator;
|
||||
mAccumulator = 0;
|
||||
ALOGV("sampleAndEnable %.0f", ns);
|
||||
return true;
|
||||
} else {
|
||||
// first time called
|
||||
ns = 0.0;
|
||||
ALOGV("sampleAndEnable false");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
bool ThreadCpuUsage::sample(double &ns)
|
||||
{
|
||||
if (mWasEverEnabled) {
|
||||
if (mIsEnabled) {
|
||||
struct timespec ts;
|
||||
int rc;
|
||||
rc = clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
|
||||
if (rc) {
|
||||
ALOGE("clock_gettime(CLOCK_THREAD_CPUTIME_ID) errno=%d", errno);
|
||||
ns = 0.0;
|
||||
return false;
|
||||
} else {
|
||||
long long delta = (ts.tv_sec - mPreviousTs.tv_sec) * 1000000000LL +
|
||||
(ts.tv_nsec - mPreviousTs.tv_nsec);
|
||||
mAccumulator += delta;
|
||||
mPreviousTs = ts;
|
||||
}
|
||||
} else {
|
||||
mWasEverEnabled = false;
|
||||
}
|
||||
ns = (double) mAccumulator;
|
||||
ALOGV("sample %.0f", ns);
|
||||
mAccumulator = 0;
|
||||
return true;
|
||||
} else {
|
||||
ALOGW("Can't add sample because measurements have never been enabled");
|
||||
ns = 0.0;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
long long ThreadCpuUsage::elapsed() const
|
||||
{
|
||||
long long elapsed;
|
||||
if (mMonotonicKnown) {
|
||||
struct timespec ts;
|
||||
int rc;
|
||||
rc = clock_gettime(CLOCK_MONOTONIC, &ts);
|
||||
if (rc) {
|
||||
ALOGE("clock_gettime(CLOCK_MONOTONIC) errno=%d", errno);
|
||||
elapsed = 0;
|
||||
} else {
|
||||
// mMonotonicTs is updated only at first enable and resetStatistics
|
||||
elapsed = (ts.tv_sec - mMonotonicTs.tv_sec) * 1000000000LL +
|
||||
(ts.tv_nsec - mMonotonicTs.tv_nsec);
|
||||
}
|
||||
} else {
|
||||
ALOGW("Can't compute elapsed time because measurements have never been enabled");
|
||||
elapsed = 0;
|
||||
}
|
||||
ALOGV("elapsed %lld", elapsed);
|
||||
return elapsed;
|
||||
}
|
||||
|
||||
void ThreadCpuUsage::resetElapsed()
|
||||
{
|
||||
ALOGV("resetElapsed");
|
||||
if (mMonotonicKnown) {
|
||||
int rc;
|
||||
rc = clock_gettime(CLOCK_MONOTONIC, &mMonotonicTs);
|
||||
if (rc) {
|
||||
ALOGE("clock_gettime(CLOCK_MONOTONIC) errno=%d", errno);
|
||||
mMonotonicKnown = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*static*/
|
||||
int ThreadCpuUsage::sScalingFds[ThreadCpuUsage::MAX_CPU];
|
||||
pthread_once_t ThreadCpuUsage::sOnceControl = PTHREAD_ONCE_INIT;
|
||||
int ThreadCpuUsage::sKernelMax;
|
||||
|
||||
/*static*/
|
||||
void ThreadCpuUsage::init()
|
||||
{
|
||||
// read the number of CPUs
|
||||
sKernelMax = 1;
|
||||
int fd = open("/sys/devices/system/cpu/kernel_max", O_RDONLY);
|
||||
if (fd >= 0) {
|
||||
#define KERNEL_MAX_SIZE 12
|
||||
char kernelMax[KERNEL_MAX_SIZE];
|
||||
ssize_t actual = read(fd, kernelMax, sizeof(kernelMax));
|
||||
if (actual >= 2 && kernelMax[actual-1] == '\n') {
|
||||
sKernelMax = atoi(kernelMax);
|
||||
if (sKernelMax >= MAX_CPU - 1) {
|
||||
ALOGW("kernel_max %d but MAX_CPU %d", sKernelMax, MAX_CPU);
|
||||
sKernelMax = MAX_CPU;
|
||||
} else if (sKernelMax < 0) {
|
||||
ALOGW("kernel_max invalid %d", sKernelMax);
|
||||
sKernelMax = 1;
|
||||
} else {
|
||||
++sKernelMax;
|
||||
ALOGV("number of CPUs %d", sKernelMax);
|
||||
}
|
||||
} else {
|
||||
ALOGW("Can't read number of CPUs");
|
||||
}
|
||||
(void) close(fd);
|
||||
} else {
|
||||
ALOGW("Can't open number of CPUs");
|
||||
}
|
||||
|
||||
// open fd to each frequency per CPU
|
||||
#define FREQ_SIZE 64
|
||||
char freq_path[FREQ_SIZE];
|
||||
#define FREQ_DIGIT 27
|
||||
COMPILE_TIME_ASSERT_FUNCTION_SCOPE(MAX_CPU <= 10);
|
||||
strlcpy(freq_path, "/sys/devices/system/cpu/cpu?/cpufreq/scaling_cur_freq", sizeof(freq_path));
|
||||
int i;
|
||||
for (i = 0; i < MAX_CPU; ++i) {
|
||||
sScalingFds[i] = -1;
|
||||
}
|
||||
for (i = 0; i < sKernelMax; ++i) {
|
||||
freq_path[FREQ_DIGIT] = i + '0';
|
||||
fd = open(freq_path, O_RDONLY);
|
||||
if (fd >= 0) {
|
||||
// keep this fd until process exit
|
||||
sScalingFds[i] = fd;
|
||||
} else {
|
||||
ALOGW("Can't open CPU %d", i);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t ThreadCpuUsage::getCpukHz(int cpuNum)
|
||||
{
|
||||
if (cpuNum < 0 || cpuNum >= MAX_CPU) {
|
||||
ALOGW("getCpukHz called with invalid CPU %d", cpuNum);
|
||||
return 0;
|
||||
}
|
||||
int fd = sScalingFds[cpuNum];
|
||||
if (fd < 0) {
|
||||
ALOGW("getCpukHz called for unopened CPU %d", cpuNum);
|
||||
return 0;
|
||||
}
|
||||
#define KHZ_SIZE 12
|
||||
char kHz[KHZ_SIZE]; // kHz base 10
|
||||
ssize_t actual = pread(fd, kHz, sizeof(kHz), (off_t) 0);
|
||||
uint32_t ret;
|
||||
if (actual >= 2 && kHz[actual-1] == '\n') {
|
||||
ret = atoi(kHz);
|
||||
} else {
|
||||
ret = 0;
|
||||
}
|
||||
if (ret != mCurrentkHz[cpuNum]) {
|
||||
if (ret > 0) {
|
||||
ALOGV("CPU %d frequency %u kHz", cpuNum, ret);
|
||||
} else {
|
||||
ALOGW("Can't read CPU %d frequency", cpuNum);
|
||||
}
|
||||
mCurrentkHz[cpuNum] = ret;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
} // namespace android
|
||||
Loading…
Reference in New Issue