Merge "Make the platform proto naming consistent, Part 1 Change proto names in incident_helper" (fc749759) · Commits · e / os / android_frameworks_base

cmds/incident_helper/src/parsers/CpuFreqParser.cpp

+6 −6

Original line number	Diff line number	Diff line
		@@ -62,15 +62,15 @@ CpuFreqParser::Parse(const int in, const int out) const
		ProtoOutputStream proto;

		long jiffyHz = sysconf(_SC_CLK_TCK);
		proto.write(CpuFreq::JIFFY_HZ, (int)jiffyHz);
		proto.write(CpuFreqProto::JIFFY_HZ, (int)jiffyHz);

		for (int i=0; i<numCpus; i++) {
		long long token = proto.start(CpuFreq::CPU_FREQS);
		proto.write(CpuFreqStats::CPU_NAME, header[i+1]);
		long long token = proto.start(CpuFreqProto::CPU_FREQS);
		proto.write(CpuFreqProto::Stats::CPU_NAME, header[i+1]);
		for (vector<pair<int, long long>>::iterator it = cpucores[i].begin(); it != cpucores[i].end(); it++) {
		long long stateToken = proto.start(CpuFreqStats::TIMES);
		proto.write(CpuFreqStats::TimeInState::STATE_KHZ, it->first);
		proto.write(CpuFreqStats::TimeInState::TIME_JIFFY, it->second);
		long long stateToken = proto.start(CpuFreqProto::Stats::TIMES);
		proto.write(CpuFreqProto::Stats::TimeInState::STATE_KHZ, it->first);
		proto.write(CpuFreqProto::Stats::TimeInState::TIME_JIFFY, it->second);
		proto.end(stateToken);
		}
		proto.end(token);

cmds/incident_helper/src/parsers/CpuInfoParser.cpp

+22 −22

Original line number	Diff line number	Diff line
		@@ -54,11 +54,11 @@ CpuInfoParser::Parse(const int in, const int out) const
		bool nextToUsage = false;

		ProtoOutputStream proto;
		Table table(CpuInfo::Task::_FIELD_NAMES, CpuInfo::Task::_FIELD_IDS, CpuInfo::Task::_FIELD_COUNT);
		table.addEnumTypeMap("s", CpuInfo::Task::_ENUM_STATUS_NAMES,
		CpuInfo::Task::_ENUM_STATUS_VALUES, CpuInfo::Task::_ENUM_STATUS_COUNT);
		table.addEnumTypeMap("pcy", CpuInfo::Task::_ENUM_POLICY_NAMES,
		CpuInfo::Task::_ENUM_POLICY_VALUES, CpuInfo::Task::_ENUM_POLICY_COUNT);
		Table table(CpuInfoProto::Task::_FIELD_NAMES, CpuInfoProto::Task::_FIELD_IDS, CpuInfoProto::Task::_FIELD_COUNT);
		table.addEnumTypeMap("s", CpuInfoProto::Task::_ENUM_STATUS_NAMES,
		CpuInfoProto::Task::_ENUM_STATUS_VALUES, CpuInfoProto::Task::_ENUM_STATUS_COUNT);
		table.addEnumTypeMap("pcy", CpuInfoProto::Task::_ENUM_POLICY_NAMES,
		CpuInfoProto::Task::_ENUM_POLICY_VALUES, CpuInfoProto::Task::_ENUM_POLICY_COUNT);

		// parse line by line
		while (reader.readLine(&line)) {
		@@ -67,33 +67,33 @@ CpuInfoParser::Parse(const int in, const int out) const
		nline++;

		if (stripPrefix(&line, "Tasks:")) {
		writeSuffixLine(&proto, CpuInfo::TASK_STATS, line, COMMA_DELIMITER,
		CpuInfo::TaskStats::_FIELD_COUNT,
		CpuInfo::TaskStats::_FIELD_NAMES,
		CpuInfo::TaskStats::_FIELD_IDS);
		writeSuffixLine(&proto, CpuInfoProto::TASK_STATS, line, COMMA_DELIMITER,
		CpuInfoProto::TaskStats::_FIELD_COUNT,
		CpuInfoProto::TaskStats::_FIELD_NAMES,
		CpuInfoProto::TaskStats::_FIELD_IDS);
		continue;
		}
		if (stripPrefix(&line, "Mem:")) {
		writeSuffixLine(&proto, CpuInfo::MEM, line, COMMA_DELIMITER,
		CpuInfo::MemStats::_FIELD_COUNT,
		CpuInfo::MemStats::_FIELD_NAMES,
		CpuInfo::MemStats::_FIELD_IDS);
		writeSuffixLine(&proto, CpuInfoProto::MEM, line, COMMA_DELIMITER,
		CpuInfoProto::MemStats::_FIELD_COUNT,
		CpuInfoProto::MemStats::_FIELD_NAMES,
		CpuInfoProto::MemStats::_FIELD_IDS);
		continue;
		}
		if (stripPrefix(&line, "Swap:")) {
		writeSuffixLine(&proto, CpuInfo::SWAP, line, COMMA_DELIMITER,
		CpuInfo::MemStats::_FIELD_COUNT,
		CpuInfo::MemStats::_FIELD_NAMES,
		CpuInfo::MemStats::_FIELD_IDS);
		writeSuffixLine(&proto, CpuInfoProto::SWAP, line, COMMA_DELIMITER,
		CpuInfoProto::MemStats::_FIELD_COUNT,
		CpuInfoProto::MemStats::_FIELD_NAMES,
		CpuInfoProto::MemStats::_FIELD_IDS);
		nextToSwap = true;
		continue;
		}

		if (nextToSwap) {
		writeSuffixLine(&proto, CpuInfo::CPU_USAGE, line, DEFAULT_WHITESPACE,
		CpuInfo::CpuUsage::_FIELD_COUNT,
		CpuInfo::CpuUsage::_FIELD_NAMES,
		CpuInfo::CpuUsage::_FIELD_IDS);
		writeSuffixLine(&proto, CpuInfoProto::CPU_USAGE, line, DEFAULT_WHITESPACE,
		CpuInfoProto::CpuUsage::_FIELD_COUNT,
		CpuInfoProto::CpuUsage::_FIELD_NAMES,
		CpuInfoProto::CpuUsage::_FIELD_IDS);
		nextToUsage = true;
		nextToSwap = false;
		continue;
		@@ -138,7 +138,7 @@ CpuInfoParser::Parse(const int in, const int out) const
		continue;
		}

		long long token = proto.start(CpuInfo::TASKS);
		long long token = proto.start(CpuInfoProto::TASKS);
		for (int i=0; i<(int)record.size(); i++) {
		if (!table.insertField(&proto, header[i], record[i])) {
		fprintf(stderr, "[%s]Line %d fails to insert field %s with value %s\n",

cmds/incident_helper/src/parsers/KernelWakesParser.cpp

+4 −2

Original line number	Diff line number	Diff line
		@@ -33,7 +33,9 @@ KernelWakesParser::Parse(const int in, const int out) const
		int nline = 0;

		ProtoOutputStream proto;
		Table table(WakeupSourceProto::_FIELD_NAMES, WakeupSourceProto::_FIELD_IDS, WakeupSourceProto::_FIELD_COUNT);
		Table table(KernelWakeSourcesProto::WakeupSource::_FIELD_NAMES,
		KernelWakeSourcesProto::WakeupSource::_FIELD_IDS,
		KernelWakeSourcesProto::WakeupSource::_FIELD_COUNT);

		// parse line by line
		while (reader.readLine(&line)) {
		@@ -57,7 +59,7 @@ KernelWakesParser::Parse(const int in, const int out) const
		continue;
		}

		long long token = proto.start(KernelWakeSources::WAKEUP_SOURCES);
		long long token = proto.start(KernelWakeSourcesProto::WAKEUP_SOURCES);
		for (int i=0; i<(int)record.size(); i++) {
		if (!table.insertField(&proto, header[i], record[i])) {
		fprintf(stderr, "[%s]Line %d has bad value %s of %s\n",

cmds/incident_helper/src/parsers/PageTypeInfoParser.cpp

+13 −11

Original line number	Diff line number	Diff line
		@@ -33,7 +33,9 @@ PageTypeInfoParser::Parse(const int in, const int out) const
		header_t blockHeader;

		ProtoOutputStream proto;
		Table table(BlockProto::_FIELD_NAMES, BlockProto::_FIELD_IDS, BlockProto::_FIELD_COUNT);
		Table table(PageTypeInfoProto::Block::_FIELD_NAMES,
		PageTypeInfoProto::Block::_FIELD_IDS,
		PageTypeInfoProto::Block::_FIELD_COUNT);

		while (reader.readLine(&line)) {
		if (line.empty()) {
		@@ -44,11 +46,11 @@ PageTypeInfoParser::Parse(const int in, const int out) const

		if (stripPrefix(&line, "Page block order:")) {
		pageBlockOrder = toInt(line);
		proto.write(PageTypeInfo::PAGE_BLOCK_ORDER, pageBlockOrder);
		proto.write(PageTypeInfoProto::PAGE_BLOCK_ORDER, pageBlockOrder);
		continue;
		}
		if (stripPrefix(&line, "Pages per block:")) {
		proto.write(PageTypeInfo::PAGES_PER_BLOCK, toInt(line));
		proto.write(PageTypeInfoProto::PAGES_PER_BLOCK, toInt(line));
		continue;
		}
		if (stripPrefix(&line, "Free pages count per migrate type at order")) {
		@@ -62,14 +64,14 @@ PageTypeInfoParser::Parse(const int in, const int out) const

		record_t record = parseRecord(line, COMMA_DELIMITER);
		if (migrateTypeSession && record.size() == 3) {
		long long token = proto.start(PageTypeInfo::MIGRATE_TYPES);
		long long token = proto.start(PageTypeInfoProto::MIGRATE_TYPES);
		// expect part 0 starts with "Node"
		if (stripPrefix(&record[0], "Node")) {
		proto.write(MigrateTypeProto::NODE, toInt(record[0]));
		proto.write(PageTypeInfoProto::MigrateType::NODE, toInt(record[0]));
		} else return BAD_VALUE;
		// expect part 1 starts with "zone"
		if (stripPrefix(&record[1], "zone")) {
		proto.write(MigrateTypeProto::ZONE, record[1]);
		proto.write(PageTypeInfoProto::MigrateType::ZONE, record[1]);
		} else return BAD_VALUE;
		// expect part 2 starts with "type"
		if (stripPrefix(&record[2], "type")) {
		@@ -83,22 +85,22 @@ PageTypeInfoParser::Parse(const int in, const int out) const
		int pageCountsSize = pageBlockOrder + 2;
		if ((int)pageCounts.size() != pageCountsSize) return BAD_VALUE;

		proto.write(MigrateTypeProto::TYPE, pageCounts[0]);
		proto.write(PageTypeInfoProto::MigrateType::TYPE, pageCounts[0]);
		for (auto i=1; i<pageCountsSize; i++) {
		proto.write(MigrateTypeProto::FREE_PAGES_COUNT, toInt(pageCounts[i]));
		proto.write(PageTypeInfoProto::MigrateType::FREE_PAGES_COUNT, toInt(pageCounts[i]));
		}
		} else return BAD_VALUE;

		proto.end(token);
		} else if (!blockHeader.empty() && record.size() == 2) {
		long long token = proto.start(PageTypeInfo::BLOCKS);
		long long token = proto.start(PageTypeInfoProto::BLOCKS);
		if (stripPrefix(&record[0], "Node")) {
		proto.write(BlockProto::NODE, toInt(record[0]));
		proto.write(PageTypeInfoProto::Block::NODE, toInt(record[0]));
		} else return BAD_VALUE;

		if (stripPrefix(&record[1], "zone")) {
		record_t blockCounts = parseRecord(record[1]);
		proto.write(BlockProto::ZONE, blockCounts[0]);
		proto.write(PageTypeInfoProto::Block::ZONE, blockCounts[0]);

		for (size_t i=0; i<blockHeader.size(); i++) {
		if (!table.insertField(&proto, blockHeader[i], blockCounts[i+1])) {

cmds/incident_helper/src/parsers/ProcrankParser.cpp

+8 −8

Original line number	Diff line number	Diff line
		@@ -33,7 +33,7 @@ ProcrankParser::Parse(const int in, const int out) const
		int nline = 0;

		ProtoOutputStream proto;
		Table table(ProcessProto::_FIELD_NAMES, ProcessProto::_FIELD_IDS, ProcessProto::_FIELD_COUNT);
		Table table(ProcrankProto::Process::_FIELD_NAMES, ProcrankProto::Process::_FIELD_IDS, ProcrankProto::Process::_FIELD_COUNT);
		string zram, ram, total;

		// parse line by line
		@@ -66,7 +66,7 @@ ProcrankParser::Parse(const int in, const int out) const
		continue;
		}

		long long token = proto.start(Procrank::PROCESSES);
		long long token = proto.start(ProcrankProto::PROCESSES);
		for (int i=0; i<(int)record.size(); i++) {
		if (!table.insertField(&proto, header[i], record[i])) {
		fprintf(stderr, "[%s]Line %d has bad value %s of %s\n",
		@@ -77,23 +77,23 @@ ProcrankParser::Parse(const int in, const int out) const
		}

		// add summary
		long long token = proto.start(Procrank::SUMMARY);
		long long token = proto.start(ProcrankProto::SUMMARY);
		if (!total.empty()) {
		record = parseRecord(total);
		long long token = proto.start(SummaryProto::TOTAL);
		long long token = proto.start(ProcrankProto::Summary::TOTAL);
		for (int i=(int)record.size(); i>0; i--) {
		table.insertField(&proto, header[header.size() - i].c_str(), record[record.size() - i].c_str());
		}
		proto.end(token);
		}
		if (!zram.empty()) {
		long long token = proto.start(SummaryProto::ZRAM);
		proto.write(ZramProto::RAW_TEXT, zram);
		long long token = proto.start(ProcrankProto::Summary::ZRAM);
		proto.write(ProcrankProto::Summary::Zram::RAW_TEXT, zram);
		proto.end(token);
		}
		if (!ram.empty()) {
		long long token = proto.start(SummaryProto::RAM);
		proto.write(RamProto::RAW_TEXT, ram);
		long long token = proto.start(ProcrankProto::Summary::RAM);
		proto.write(ProcrankProto::Summary::Ram::RAW_TEXT, ram);
		proto.end(token);
		}
		proto.end(token);