Merge "metricsd: Remove dead code." (695da489) · Commits · e / os / android_system_core

metricsd/metrics_daemon.cc

+0 −66

Original line number	Diff line number	Diff line
		@@ -74,11 +74,6 @@ const int kMetricMeminfoInterval = 30; // seconds
		const char kMeminfoFileName[] = "/proc/meminfo";
		const char kVmStatFileName[] = "/proc/vmstat";

		// Thermal CPU throttling.

		const char kMetricScaledCpuFrequencyName[] =
		"Platform.CpuFrequencyThermalScaling";

		} // namespace

		// Zram sysfs entries.
		@@ -169,8 +164,6 @@ void MetricsDaemon::Init(bool testing,
		bool dbus_enabled,
		MetricsLibraryInterface* metrics_lib,
		const string& diskstats_path,
		const string& scaling_max_freq_path,
		const string& cpuinfo_max_freq_path,
		const base::TimeDelta& upload_interval,
		const string& server,
		const base::FilePath& metrics_directory) {
		@@ -221,8 +214,6 @@ void MetricsDaemon::Init(bool testing,
		weekly_cycle_.reset(new PersistentInteger("weekly.cycle"));
		version_cycle_.reset(new PersistentInteger("version.cycle"));

		scaling_max_freq_path_ = scaling_max_freq_path;
		cpuinfo_max_freq_path_ = cpuinfo_max_freq_path;
		disk_usage_collector_.reset(new DiskUsageCollector(metrics_lib_));
		averaged_stats_collector_.reset(
		new AveragedStatisticsCollector(metrics_lib_, diskstats_path,
		@@ -461,63 +452,6 @@ void MetricsDaemon::StatsReporterInit() {
		averaged_stats_collector_->ScheduleWait();
		}


		bool MetricsDaemon::ReadFreqToInt(const string& sysfs_file_name, int* value) {
		const FilePath sysfs_path(sysfs_file_name);
		string value_string;
		if (!base::ReadFileToString(sysfs_path, &value_string)) {
		LOG(WARNING) << "cannot read " << sysfs_path.value().c_str();
		return false;
		}
		if (!base::RemoveChars(value_string, "\n", &value_string)) {
		LOG(WARNING) << "no newline in " << value_string;
		// Continue even though the lack of newline is suspicious.
		}
		if (!base::StringToInt(value_string, value)) {
		LOG(WARNING) << "cannot convert " << value_string << " to int";
		return false;
		}
		return true;
		}

		void MetricsDaemon::SendCpuThrottleMetrics() {
		// \|max_freq\| is 0 only the first time through.
		static int max_freq = 0;
		if (max_freq == -1)
		// Give up, as sysfs did not report max_freq correctly.
		return;
		if (max_freq == 0 \|\| testing_) {
		// One-time initialization of max_freq. (Every time when testing.)
		if (!ReadFreqToInt(cpuinfo_max_freq_path_, &max_freq)) {
		max_freq = -1;
		return;
		}
		if (max_freq == 0) {
		LOG(WARNING) << "sysfs reports 0 max CPU frequency\n";
		max_freq = -1;
		return;
		}
		if (max_freq % 10000 == 1000) {
		// Special case: system has turbo mode, and max non-turbo frequency is
		// max_freq - 1000. This relies on "normal" (non-turbo) frequencies
		// being multiples of (at least) 10 MHz. Although there is no guarantee
		// of this, it seems a fairly reasonable assumption. Otherwise we should
		// read scaling_available_frequencies, sort the frequencies, compare the
		// two highest ones, and check if they differ by 1000 (kHz) (and that's a
		// hack too, no telling when it will change).
		max_freq -= 1000;
		}
		}
		int scaled_freq = 0;
		if (!ReadFreqToInt(scaling_max_freq_path_, &scaled_freq))
		return;
		// Frequencies are in kHz. If scaled_freq > max_freq, turbo is on, but
		// scaled_freq is not the actual turbo frequency. We indicate this situation
		// with a 101% value.
		int percent = scaled_freq > max_freq ? 101 : scaled_freq / (max_freq / 100);
		SendLinearSample(kMetricScaledCpuFrequencyName, percent, 101, 102);
		}

		void MetricsDaemon::ScheduleMeminfoCallback(int wait) {
		if (testing_) {
		return;

metricsd/metrics_daemon.h

+0 −13

Original line number	Diff line number	Diff line
		@@ -51,8 +51,6 @@ class MetricsDaemon : public brillo::DBusDaemon {
		bool dbus_enabled,
		MetricsLibraryInterface* metrics_lib,
		const std::string& diskstats_path,
		const std::string& cpuinfo_max_freq_path,
		const std::string& scaling_max_freq_path,
		const base::TimeDelta& upload_interval,
		const std::string& server,
		const base::FilePath& metrics_directory);
		@@ -92,12 +90,10 @@ class MetricsDaemon : public brillo::DBusDaemon {
		FRIEND_TEST(MetricsDaemonTest, ProcessUncleanShutdown);
		FRIEND_TEST(MetricsDaemonTest, ProcessUserCrash);
		FRIEND_TEST(MetricsDaemonTest, ReportCrashesDailyFrequency);
		FRIEND_TEST(MetricsDaemonTest, ReadFreqToInt);
		FRIEND_TEST(MetricsDaemonTest, ReportKernelCrashInterval);
		FRIEND_TEST(MetricsDaemonTest, ReportUncleanShutdownInterval);
		FRIEND_TEST(MetricsDaemonTest, ReportUserCrashInterval);
		FRIEND_TEST(MetricsDaemonTest, SendSample);
		FRIEND_TEST(MetricsDaemonTest, SendCpuThrottleMetrics);
		FRIEND_TEST(MetricsDaemonTest, SendZramMetrics);

		// Type of scale to use for meminfo histograms. For most of them we use
		@@ -215,12 +211,6 @@ class MetricsDaemon : public brillo::DBusDaemon {
		// Parses meminfo data and sends it to UMA.
		bool ProcessMemuse(const std::string& meminfo_raw);

		// Sends stats for thermal CPU throttling.
		void SendCpuThrottleMetrics();

		// Reads an integer CPU frequency value from sysfs.
		bool ReadFreqToInt(const std::string& sysfs_file_name, int* value);

		// Reads the current OS version from /etc/lsb-release and hashes it
		// to a unsigned 32-bit int.
		uint32_t GetOsVersionHash();
		@@ -301,9 +291,6 @@ class MetricsDaemon : public brillo::DBusDaemon {
		scoped_ptr<DiskUsageCollector> disk_usage_collector_;
		scoped_ptr<AveragedStatisticsCollector> averaged_stats_collector_;

		std::string scaling_max_freq_path_;
		std::string cpuinfo_max_freq_path_;

		base::TimeDelta upload_interval_;
		std::string server_;

metricsd/metrics_daemon_main.cc

+0 −6

Original line number	Diff line number	Diff line
		@@ -25,10 +25,6 @@
		#include "constants.h"
		#include "metrics_daemon.h"

		const char kScalingMaxFreqPath[] =
		"/sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq";
		const char kCpuinfoMaxFreqPath[] =
		"/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq";

		// Returns the path to the disk stats in the sysfs. Returns the null string if
		// it cannot find the disk stats file.
		@@ -112,8 +108,6 @@ int main(int argc, char** argv) {
		FLAGS_withdbus,
		&metrics_lib,
		MetricsMainDiskStatsPath(),
		kScalingMaxFreqPath,
		kCpuinfoMaxFreqPath,
		base::TimeDelta::FromSeconds(FLAGS_upload_interval_secs),
		FLAGS_server,
		base::FilePath(FLAGS_metrics_directory));

metricsd/metrics_daemon_test.cc

+0 −38

Original line number	Diff line number	Diff line
		@@ -45,11 +45,6 @@ class MetricsDaemonTest : public testing::Test {
		virtual void SetUp() {
		brillo::FlagHelper::Init(0, nullptr, "");
		EXPECT_TRUE(temp_dir_.CreateUniqueTempDir());
		scaling_max_freq_path_ = temp_dir_.path().Append("scaling_max");
		cpu_max_freq_path_ = temp_dir_.path().Append("cpu_freq_max");

		CreateUint64ValueFile(cpu_max_freq_path_, 10000000);
		CreateUint64ValueFile(scaling_max_freq_path_, 10000000);

		chromeos_metrics::PersistentInteger::SetMetricsDirectory(
		temp_dir_.path().value());
		@@ -58,8 +53,6 @@ class MetricsDaemonTest : public testing::Test {
		true,
		&metrics_lib_,
		"",
		scaling_max_freq_path_.value(),
		cpu_max_freq_path_.value(),
		base::TimeDelta::FromMinutes(30),
		metrics::kMetricsServer,
		temp_dir_.path());
		@@ -120,10 +113,6 @@ class MetricsDaemonTest : public testing::Test {
		// Temporary directory used for tests.
		base::ScopedTempDir temp_dir_;

		// Path for the fake files.
		base::FilePath scaling_max_freq_path_;
		base::FilePath cpu_max_freq_path_;

		// Mocks. They are strict mock so that all unexpected
		// calls are marked as failures.
		StrictMock<MetricsLibraryMock> metrics_lib_;
		@@ -209,33 +198,6 @@ TEST_F(MetricsDaemonTest, ProcessMeminfo2) {
		EXPECT_FALSE(daemon_.ProcessMeminfo(meminfo));
		}

		TEST_F(MetricsDaemonTest, ReadFreqToInt) {
		const int fake_scaled_freq = 1666999;
		const int fake_max_freq = 2000000;
		int scaled_freq = 0;
		int max_freq = 0;
		CreateUint64ValueFile(scaling_max_freq_path_, fake_scaled_freq);
		CreateUint64ValueFile(cpu_max_freq_path_, fake_max_freq);
		EXPECT_TRUE(daemon_.testing_);
		EXPECT_TRUE(daemon_.ReadFreqToInt(scaling_max_freq_path_.value(),
		&scaled_freq));
		EXPECT_TRUE(daemon_.ReadFreqToInt(cpu_max_freq_path_.value(), &max_freq));
		EXPECT_EQ(fake_scaled_freq, scaled_freq);
		EXPECT_EQ(fake_max_freq, max_freq);
		}

		TEST_F(MetricsDaemonTest, SendCpuThrottleMetrics) {
		CreateUint64ValueFile(cpu_max_freq_path_, 2001000);
		// Test the 101% and 100% cases.
		CreateUint64ValueFile(scaling_max_freq_path_, 2001000);
		EXPECT_TRUE(daemon_.testing_);
		EXPECT_CALL(metrics_lib_, SendEnumToUMA(_, 101, 101));
		daemon_.SendCpuThrottleMetrics();
		CreateUint64ValueFile(scaling_max_freq_path_, 2000000);
		EXPECT_CALL(metrics_lib_, SendEnumToUMA(_, 100, 101));
		daemon_.SendCpuThrottleMetrics();
		}

		TEST_F(MetricsDaemonTest, SendZramMetrics) {
		EXPECT_TRUE(daemon_.testing_);