add atoms for cpu power calculation (9da105bb) · Commits · e / os / android_frameworks_base

cmds/statsd/src/atoms.proto

+48 −0

Original line number	Diff line number	Diff line
		@@ -103,6 +103,10 @@ message Atom {
		WifiActivityEnergyInfo wifi_activity_energy_info = 10011;
		ModemActivityInfo modem_activity_info = 10012;
		MemoryStat memory_stat = 10013;
		CpuSuspendTime cpu_suspend_time = 10014;
		CpuIdleTime cpu_idle_time = 10015;
		CpuActiveTime cpu_active_time = 10016;
		CpuClusterTime cpu_cluster_time = 10017;
		}
		}

		@@ -1223,3 +1227,47 @@ message LmkEventOccurred {
		}
		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	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	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	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	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