Loading cmds/statsd/src/atoms.proto +48 −0 Original line number Original line Diff line number Diff line Loading @@ -103,6 +103,10 @@ message Atom { WifiActivityEnergyInfo wifi_activity_energy_info = 10011; WifiActivityEnergyInfo wifi_activity_energy_info = 10011; ModemActivityInfo modem_activity_info = 10012; ModemActivityInfo modem_activity_info = 10012; MemoryStat memory_stat = 10013; MemoryStat memory_stat = 10013; CpuSuspendTime cpu_suspend_time = 10014; CpuIdleTime cpu_idle_time = 10015; CpuActiveTime cpu_active_time = 10016; CpuClusterTime cpu_cluster_time = 10017; } } } } Loading Loading @@ -1223,3 +1227,47 @@ message LmkEventOccurred { } } optional State state = 4; optional State state = 4; } } /* * Cpu syspend time for cpu power calculation. */ message CpuSuspendTime { optional uint64 time = 1; } /* * Cpu idle time for cpu power calculation. */ message CpuIdleTime { optional uint64 time = 1; } /* * Reads from /proc/uid_concurrent_active_time which has the format: * active: X (X is # cores) * [uid0]: [time-0] [time-1] [time-2] ... (# entries = # cores) * [uid1]: [time-0] [time-1] [time-2] ... ... * ... * Time-N means the CPU time a UID spent running concurrently with N other processes. * The file contains a monotonically increasing count of time for a single boot. */ message CpuActiveTime { optional uint64 uid = 1; optional uint64 idx = 2; optional uint64 time_ms = 3; } /** * Reads from /proc/uid_concurrent_policy_time which has the format: * policy0: X policy4: Y (there are X cores on policy0, Y cores on policy4) * [uid0]: [time-0-0] [time-0-1] ... [time-1-0] [time-1-1] ... * [uid1]: [time-0-0] [time-0-1] ... [time-1-0] [time-1-1] ... * ... * Time-X-Y means the time a UID spent on clusterX running concurrently with Y other processes. * The file contains a monotonically increasing count of time for a single boot. */ message CpuClusterTime { optional uint64 uid = 1; optional uint64 idx = 2; optional uint64 time_ms = 3; } No newline at end of file cmds/statsd/src/external/KernelUidCpuActiveTimeReader.cpp 0 → 100644 +89 −0 Original line number Original line 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. */ #define DEBUG true // STOPSHIP if true #include "Log.h" #include <fstream> #include "KernelUidCpuActiveTimeReader.h" #include "guardrail/StatsdStats.h" #include "logd/LogEvent.h" #include "statslog.h" using std::make_shared; using std::shared_ptr; using std::ifstream; namespace android { namespace os { namespace statsd { static const string sProcFile = "/proc/uid_concurrent_active_time"; static const int kLineBufferSize = 1024; /** * Reads /proc/uid_concurrent_active_time which has the format: * active: X (X is # cores) * [uid0]: [time-0] [time-1] [time-2] ... (# entries = # cores) * [uid1]: [time-0] [time-1] [time-2] ... ... * ... * Time-N means the CPU time a UID spent running concurrently with N other processes. * The file contains a monotonically increasing count of time for a single boot. */ KernelUidCpuActiveTimeReader::KernelUidCpuActiveTimeReader() : StatsPuller(android::util::CPU_ACTIVE_TIME) { } bool KernelUidCpuActiveTimeReader::PullInternal(vector<shared_ptr<LogEvent>>* data) { data->clear(); ifstream fin; fin.open(sProcFile); if (!fin.good()) { VLOG("Failed to read pseudo file %s", sProcFile.c_str()); return false; } uint64_t timestamp = time(nullptr) * NS_PER_SEC; char buf[kLineBufferSize]; char* pch; while (!fin.eof()) { fin.getline(buf, kLineBufferSize); pch = strtok(buf, " :"); if (pch == NULL) break; uint64_t uid = std::stoull(pch); pch = strtok(NULL, " "); uint64_t timeMs; int idx = 0; do { timeMs = std::stoull(pch); auto ptr = make_shared<LogEvent>(mTagId, timestamp); ptr->write(uid); ptr->write(idx); ptr->write(timeMs); ptr->init(); data->push_back(ptr); VLOG("uid %lld, freq idx %d, active time %lld", (long long)uid, idx, (long long)timeMs); idx++; pch = strtok(NULL, " "); } while (pch != NULL); } return true; } } // namespace statsd } // namespace os } // namespace android cmds/statsd/src/external/KernelUidCpuActiveTimeReader.h 0 → 100644 +34 −0 Original line number Original line 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. */ #pragma once #include <utils/String16.h> #include "StatsPuller.h" namespace android { namespace os { namespace statsd { class KernelUidCpuActiveTimeReader : public StatsPuller { public: KernelUidCpuActiveTimeReader(); bool PullInternal(vector<std::shared_ptr<LogEvent>>* data) override; }; } // namespace statsd } // namespace os } // namespace android cmds/statsd/src/external/KernelUidCpuClusterTimeReader.cpp 0 → 100644 +88 −0 Original line number Original line 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. */ #define DEBUG true // STOPSHIP if true #include "Log.h" #include <fstream> #include "KernelUidCpuClusterTimeReader.h" #include "guardrail/StatsdStats.h" #include "logd/LogEvent.h" #include "statslog.h" using std::make_shared; using std::shared_ptr; using std::ifstream; namespace android { namespace os { namespace statsd { static const string sProcFile = "/proc/uid_concurrent_policy_time"; static const int kLineBufferSize = 1024; /** * Reads /proc/uid_concurrent_policy_time which has the format: * policy0: X policy4: Y (there are X cores on policy0, Y cores on policy4) * [uid0]: [time-0-0] [time-0-1] ... [time-1-0] [time-1-1] ... * [uid1]: [time-0-0] [time-0-1] ... [time-1-0] [time-1-1] ... * ... * Time-X-Y means the time a UID spent on clusterX running concurrently with Y other processes. * The file contains a monotonically increasing count of time for a single boot. */ KernelUidCpuClusterTimeReader::KernelUidCpuClusterTimeReader() : StatsPuller(android::util::CPU_CLUSTER_TIME) { } bool KernelUidCpuClusterTimeReader::PullInternal(vector<shared_ptr<LogEvent>>* data) { data->clear(); ifstream fin; fin.open(sProcFile); if (!fin.good()) { VLOG("Failed to read pseudo file %s", sProcFile.c_str()); return false; } uint64_t timestamp = time(nullptr) * NS_PER_SEC; char buf[kLineBufferSize]; char* pch; while (!fin.eof()) { fin.getline(buf, kLineBufferSize); pch = strtok(buf, " :"); if (pch == NULL) break; uint64_t uid = std::stoull(pch); pch = strtok(NULL, " "); uint64_t timeMs; int idx = 0; do { timeMs = std::stoull(pch); auto ptr = make_shared<LogEvent>(mTagId, timestamp); ptr->write(uid); ptr->write(idx); ptr->write(timeMs); ptr->init(); data->push_back(ptr); VLOG("uid %lld, freq idx %d, cluster time %lld", (long long)uid, idx, (long long)timeMs); idx++; pch = strtok(NULL, " "); } while (pch != NULL); } return true; } } // namespace statsd } // namespace os } // namespace android cmds/statsd/src/external/KernelUidCpuClusterTimeReader.h 0 → 100644 +42 −0 Original line number Original line 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. */ #pragma once #include <utils/String16.h> #include "StatsPuller.h" namespace android { namespace os { namespace statsd { /** * Reads /proc/uid_cputime/show_uid_stat which has the line format: * * uid: user_time_micro_seconds system_time_micro_seconds * * This provides the time a UID's processes spent executing in user-space and kernel-space. * The file contains a monotonically increasing count of time for a single boot. */ class KernelUidCpuClusterTimeReader : public StatsPuller { public: KernelUidCpuClusterTimeReader(); bool PullInternal(vector<std::shared_ptr<LogEvent>>* data) override; }; } // namespace statsd } // namespace os } // namespace android Loading
cmds/statsd/src/atoms.proto +48 −0 Original line number Original line Diff line number Diff line Loading @@ -103,6 +103,10 @@ message Atom { WifiActivityEnergyInfo wifi_activity_energy_info = 10011; WifiActivityEnergyInfo wifi_activity_energy_info = 10011; ModemActivityInfo modem_activity_info = 10012; ModemActivityInfo modem_activity_info = 10012; MemoryStat memory_stat = 10013; MemoryStat memory_stat = 10013; CpuSuspendTime cpu_suspend_time = 10014; CpuIdleTime cpu_idle_time = 10015; CpuActiveTime cpu_active_time = 10016; CpuClusterTime cpu_cluster_time = 10017; } } } } Loading Loading @@ -1223,3 +1227,47 @@ message LmkEventOccurred { } } optional State state = 4; optional State state = 4; } } /* * Cpu syspend time for cpu power calculation. */ message CpuSuspendTime { optional uint64 time = 1; } /* * Cpu idle time for cpu power calculation. */ message CpuIdleTime { optional uint64 time = 1; } /* * Reads from /proc/uid_concurrent_active_time which has the format: * active: X (X is # cores) * [uid0]: [time-0] [time-1] [time-2] ... (# entries = # cores) * [uid1]: [time-0] [time-1] [time-2] ... ... * ... * Time-N means the CPU time a UID spent running concurrently with N other processes. * The file contains a monotonically increasing count of time for a single boot. */ message CpuActiveTime { optional uint64 uid = 1; optional uint64 idx = 2; optional uint64 time_ms = 3; } /** * Reads from /proc/uid_concurrent_policy_time which has the format: * policy0: X policy4: Y (there are X cores on policy0, Y cores on policy4) * [uid0]: [time-0-0] [time-0-1] ... [time-1-0] [time-1-1] ... * [uid1]: [time-0-0] [time-0-1] ... [time-1-0] [time-1-1] ... * ... * Time-X-Y means the time a UID spent on clusterX running concurrently with Y other processes. * The file contains a monotonically increasing count of time for a single boot. */ message CpuClusterTime { optional uint64 uid = 1; optional uint64 idx = 2; optional uint64 time_ms = 3; } No newline at end of file
cmds/statsd/src/external/KernelUidCpuActiveTimeReader.cpp 0 → 100644 +89 −0 Original line number Original line 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. */ #define DEBUG true // STOPSHIP if true #include "Log.h" #include <fstream> #include "KernelUidCpuActiveTimeReader.h" #include "guardrail/StatsdStats.h" #include "logd/LogEvent.h" #include "statslog.h" using std::make_shared; using std::shared_ptr; using std::ifstream; namespace android { namespace os { namespace statsd { static const string sProcFile = "/proc/uid_concurrent_active_time"; static const int kLineBufferSize = 1024; /** * Reads /proc/uid_concurrent_active_time which has the format: * active: X (X is # cores) * [uid0]: [time-0] [time-1] [time-2] ... (# entries = # cores) * [uid1]: [time-0] [time-1] [time-2] ... ... * ... * Time-N means the CPU time a UID spent running concurrently with N other processes. * The file contains a monotonically increasing count of time for a single boot. */ KernelUidCpuActiveTimeReader::KernelUidCpuActiveTimeReader() : StatsPuller(android::util::CPU_ACTIVE_TIME) { } bool KernelUidCpuActiveTimeReader::PullInternal(vector<shared_ptr<LogEvent>>* data) { data->clear(); ifstream fin; fin.open(sProcFile); if (!fin.good()) { VLOG("Failed to read pseudo file %s", sProcFile.c_str()); return false; } uint64_t timestamp = time(nullptr) * NS_PER_SEC; char buf[kLineBufferSize]; char* pch; while (!fin.eof()) { fin.getline(buf, kLineBufferSize); pch = strtok(buf, " :"); if (pch == NULL) break; uint64_t uid = std::stoull(pch); pch = strtok(NULL, " "); uint64_t timeMs; int idx = 0; do { timeMs = std::stoull(pch); auto ptr = make_shared<LogEvent>(mTagId, timestamp); ptr->write(uid); ptr->write(idx); ptr->write(timeMs); ptr->init(); data->push_back(ptr); VLOG("uid %lld, freq idx %d, active time %lld", (long long)uid, idx, (long long)timeMs); idx++; pch = strtok(NULL, " "); } while (pch != NULL); } return true; } } // namespace statsd } // namespace os } // namespace android
cmds/statsd/src/external/KernelUidCpuActiveTimeReader.h 0 → 100644 +34 −0 Original line number Original line 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. */ #pragma once #include <utils/String16.h> #include "StatsPuller.h" namespace android { namespace os { namespace statsd { class KernelUidCpuActiveTimeReader : public StatsPuller { public: KernelUidCpuActiveTimeReader(); bool PullInternal(vector<std::shared_ptr<LogEvent>>* data) override; }; } // namespace statsd } // namespace os } // namespace android
cmds/statsd/src/external/KernelUidCpuClusterTimeReader.cpp 0 → 100644 +88 −0 Original line number Original line 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. */ #define DEBUG true // STOPSHIP if true #include "Log.h" #include <fstream> #include "KernelUidCpuClusterTimeReader.h" #include "guardrail/StatsdStats.h" #include "logd/LogEvent.h" #include "statslog.h" using std::make_shared; using std::shared_ptr; using std::ifstream; namespace android { namespace os { namespace statsd { static const string sProcFile = "/proc/uid_concurrent_policy_time"; static const int kLineBufferSize = 1024; /** * Reads /proc/uid_concurrent_policy_time which has the format: * policy0: X policy4: Y (there are X cores on policy0, Y cores on policy4) * [uid0]: [time-0-0] [time-0-1] ... [time-1-0] [time-1-1] ... * [uid1]: [time-0-0] [time-0-1] ... [time-1-0] [time-1-1] ... * ... * Time-X-Y means the time a UID spent on clusterX running concurrently with Y other processes. * The file contains a monotonically increasing count of time for a single boot. */ KernelUidCpuClusterTimeReader::KernelUidCpuClusterTimeReader() : StatsPuller(android::util::CPU_CLUSTER_TIME) { } bool KernelUidCpuClusterTimeReader::PullInternal(vector<shared_ptr<LogEvent>>* data) { data->clear(); ifstream fin; fin.open(sProcFile); if (!fin.good()) { VLOG("Failed to read pseudo file %s", sProcFile.c_str()); return false; } uint64_t timestamp = time(nullptr) * NS_PER_SEC; char buf[kLineBufferSize]; char* pch; while (!fin.eof()) { fin.getline(buf, kLineBufferSize); pch = strtok(buf, " :"); if (pch == NULL) break; uint64_t uid = std::stoull(pch); pch = strtok(NULL, " "); uint64_t timeMs; int idx = 0; do { timeMs = std::stoull(pch); auto ptr = make_shared<LogEvent>(mTagId, timestamp); ptr->write(uid); ptr->write(idx); ptr->write(timeMs); ptr->init(); data->push_back(ptr); VLOG("uid %lld, freq idx %d, cluster time %lld", (long long)uid, idx, (long long)timeMs); idx++; pch = strtok(NULL, " "); } while (pch != NULL); } return true; } } // namespace statsd } // namespace os } // namespace android
cmds/statsd/src/external/KernelUidCpuClusterTimeReader.h 0 → 100644 +42 −0 Original line number Original line 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. */ #pragma once #include <utils/String16.h> #include "StatsPuller.h" namespace android { namespace os { namespace statsd { /** * Reads /proc/uid_cputime/show_uid_stat which has the line format: * * uid: user_time_micro_seconds system_time_micro_seconds * * This provides the time a UID's processes spent executing in user-space and kernel-space. * The file contains a monotonically increasing count of time for a single boot. */ class KernelUidCpuClusterTimeReader : public StatsPuller { public: KernelUidCpuClusterTimeReader(); bool PullInternal(vector<std::shared_ptr<LogEvent>>* data) override; }; } // namespace statsd } // namespace os } // namespace android
