Merge "liblogcat: measure performance" (8a3a1660) · Commits · e / os / android_system_core

logcat/tests/Android.mk

+5 −3

Original line number	Diff line number	Diff line
		@@ -27,11 +27,12 @@ test_c_flags := \
		-fno-builtin \

		# -----------------------------------------------------------------------------
		# Benchmarks (actually a gTest where the result code does not matter)
		# Benchmarks
		# ----------------------------------------------------------------------------

		benchmark_src_files := \
		logcat_benchmark.cpp
		logcat_benchmark.cpp \
		exec_benchmark.cpp \

		# Build benchmarks for the device. Run with:
		# adb shell /data/nativetest/logcat-benchmarks/logcat-benchmarks
		@@ -40,7 +41,8 @@ LOCAL_MODULE := $(test_module_prefix)benchmarks
		LOCAL_MODULE_TAGS := $(test_tags)
		LOCAL_CFLAGS += $(test_c_flags)
		LOCAL_SRC_FILES := $(benchmark_src_files)
		include $(BUILD_NATIVE_TEST)
		LOCAL_SHARED_LIBRARIES := libbase liblogcat
		include $(BUILD_NATIVE_BENCHMARK)

		# -----------------------------------------------------------------------------
		# Unit tests.

logcat/tests/exec_benchmark.cpp

0 → 100644

+96 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2017 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 <stdio.h>

		#include <android-base/file.h>
		#include <benchmark/benchmark.h>
		#include <log/logcat.h>

		// Dump the statistics and report results

		static void logcat_popen_libc(benchmark::State& state, const char* cmd) {
		while (state.KeepRunning()) {
		FILE* fp = popen(cmd, "r");
		std::string ret;
		android::base::ReadFdToString(fileno(fp), &ret);
		pclose(fp);
		}
		}

		static void BM_logcat_stat_popen_libc(benchmark::State& state) {
		logcat_popen_libc(state, "logcat -b all -S");
		}
		BENCHMARK(BM_logcat_stat_popen_libc);

		static void logcat_popen_liblogcat(benchmark::State& state, const char* cmd) {
		while (state.KeepRunning()) {
		android_logcat_context ctx;
		FILE* fp = android_logcat_popen(&ctx, cmd);
		std::string ret;
		android::base::ReadFdToString(fileno(fp), &ret);
		android_logcat_pclose(&ctx, fp);
		}
		}

		static void BM_logcat_stat_popen_liblogcat(benchmark::State& state) {
		logcat_popen_liblogcat(state, "logcat -b all -S");
		}
		BENCHMARK(BM_logcat_stat_popen_liblogcat);

		static void logcat_system_libc(benchmark::State& state, const char* cmd) {
		while (state.KeepRunning()) {
		system(cmd);
		}
		}

		static void BM_logcat_stat_system_libc(benchmark::State& state) {
		logcat_system_libc(state, "logcat -b all -S >/dev/null 2>/dev/null");
		}
		BENCHMARK(BM_logcat_stat_system_libc);

		static void logcat_system_liblogcat(benchmark::State& state, const char* cmd) {
		while (state.KeepRunning()) {
		android_logcat_system(cmd);
		}
		}

		static void BM_logcat_stat_system_liblogcat(benchmark::State& state) {
		logcat_system_liblogcat(state, "logcat -b all -S >/dev/null 2>/dev/null");
		}
		BENCHMARK(BM_logcat_stat_system_liblogcat);

		// Dump the logs and report results

		static void BM_logcat_dump_popen_libc(benchmark::State& state) {
		logcat_popen_libc(state, "logcat -b all -d");
		}
		BENCHMARK(BM_logcat_dump_popen_libc);

		static void BM_logcat_dump_popen_liblogcat(benchmark::State& state) {
		logcat_popen_liblogcat(state, "logcat -b all -d");
		}
		BENCHMARK(BM_logcat_dump_popen_liblogcat);

		static void BM_logcat_dump_system_libc(benchmark::State& state) {
		logcat_system_libc(state, "logcat -b all -d >/dev/null 2>/dev/null");
		}
		BENCHMARK(BM_logcat_dump_system_libc);

		static void BM_logcat_dump_system_liblogcat(benchmark::State& state) {
		logcat_system_liblogcat(state, "logcat -b all -d >/dev/null 2>/dev/null");
		}
		BENCHMARK(BM_logcat_dump_system_liblogcat);

logcat/tests/logcat_benchmark.cpp

+43 −38

Original line number	Diff line number	Diff line
		@@ -18,16 +18,19 @@
		#include <stdlib.h>
		#include <string.h>

		#include <gtest/gtest.h>
		#include <benchmark/benchmark.h>

		static const char begin[] = "--------- beginning of ";

		TEST(logcat, sorted_order) {
		static void BM_logcat_sorted_order(benchmark::State& state) {
		FILE* fp;

		ASSERT_TRUE(NULL != (fp = popen(
		if (!state.KeepRunning()) return;

		fp = popen(
		"logcat -v time -b radio -b events -b system -b main -d 2>/dev/null",
		"r")));
		"r");
		if (!fp) return;

		class timestamp {
		private:
		@@ -40,38 +43,33 @@ TEST(logcat, sorted_order) {
		bool ok;

		public:
		void init(const char *buffer)
		{
		void init(const char* buffer) {
		ok = false;
		if (buffer != NULL) {
		ok = sscanf(buffer, "%d-%d %d:%d:%d.%d ",
		&month, &day, &hour, &minute, &second, &millisecond) == 6;
		ok = sscanf(buffer, "%d-%d %d:%d:%d.%d ", &month, &day, &hour,
		&minute, &second, &millisecond) == 6;
		}
		}

		explicit timestamp(const char *buffer)
		{
		explicit timestamp(const char* buffer) {
		init(buffer);
		}

		bool operator< (timestamp &T)
		{
		return !ok \|\| !T.ok
		\|\| (month < T.month)
		\|\| ((month == T.month)
		&& ((day < T.day)
		\|\| ((day == T.day)
		&& ((hour < T.hour)
		\|\| ((hour == T.hour)
		&& ((minute < T.minute)
		\|\| ((minute == T.minute)
		&& ((second < T.second)
		\|\| ((second == T.second)
		&& (millisecond < T.millisecond))))))))));
		bool operator<(timestamp& T) {
		return !ok \|\| !T.ok \|\| (month < T.month) \|\|
		((month == T.month) &&
		((day < T.day) \|\|
		((day == T.day) &&
		((hour < T.hour) \|\|
		((hour == T.hour) &&
		((minute < T.minute) \|\|
		((minute == T.minute) &&
		((second < T.second) \|\|
		((second == T.second) &&
		(millisecond < T.millisecond))))))))));
		}

		bool valid(void)
		{
		bool valid(void) {
		return ok;
		}
		} last(NULL);
		@@ -114,15 +112,22 @@ TEST(logcat, sorted_order) {

		// Allow few fails, happens with readers active
		fprintf(stderr, "%s: %d/%d out of order entries\n",
		(next_lt_last)
		? ((next_lt_last <= max_ok)
		? "WARNING"
		: "ERROR")
		(next_lt_last) ? ((next_lt_last <= max_ok) ? "WARNING" : "ERROR")
		: "INFO",
		next_lt_last, count);

		EXPECT_GE(max_ok, next_lt_last);
		if (next_lt_last > max_ok) {
		fprintf(stderr, "EXPECT_GE(max_ok=%d, next_lt_last=%d)\n", max_ok,
		next_lt_last);
		}

		// sample statistically too small
		EXPECT_LT(100, count);
		if (count < 100) {
		fprintf(stderr, "EXPECT_LT(100, count=%d)\n", count);
		}

		state.KeepRunning();
		}
		BENCHMARK(BM_logcat_sorted_order);

		BENCHMARK_MAIN();