Revert "liblog: Add liblog test suite" (20727bab) · Commits · e / os / android_system_core

include/log/log.h

+0 −49

Original line number	Diff line number	Diff line
		@@ -552,55 +552,6 @@ typedef enum log_id {
		#define sizeof_log_id_t sizeof(typeof_log_id_t)
		#define typeof_log_id_t unsigned char

		/* Currently helper to liblog unit tests, expect wider use. */
		#define NS_PER_SEC 1000000000ULL
		#ifdef __cplusplus
		typedef struct log_time : public timespec {
		public:
		log_time(void)
		{
		}
		log_time(const char *T)
		{
		const uint8_t c = (const uint8_t ) T;
		tv_sec = c[0] \| (c[1] << 8) \| (c[2] << 16) \| (c[3] << 24);
		tv_nsec = c[4] \| (c[5] << 8) \| (c[6] << 16) \| (c[7] << 24);
		}
		bool operator== (log_time &T)
		{
		return (tv_sec == T.tv_sec) && (tv_nsec == T.tv_nsec);
		}
		bool operator!= (log_time &T)
		{
		return !(*this == T);
		}
		bool operator< (log_time &T)
		{
		return (tv_sec < T.tv_sec)
		\|\| ((tv_sec == T.tv_sec) && (tv_nsec < T.tv_nsec));
		}
		bool operator>= (log_time &T)
		{
		return !(*this < T);
		}
		bool operator> (log_time &T)
		{
		return (tv_sec > T.tv_sec)
		\|\| ((tv_sec == T.tv_sec) && (tv_nsec > T.tv_nsec));
		}
		bool operator<= (log_time &T)
		{
		return !(*this > T);
		}
		uint64_t nsec(void)
		{
		return static_cast<uint64_t>(tv_sec) * NS_PER_SEC + tv_nsec;
		}
		} log_time_t;
		#else
		typedef struct timespec log_time_t;
		#endif

		/*
		* Send a simple string to the log.
		*/

liblog/Android.mk

+0 −2

Original line number	Diff line number	Diff line
		@@ -80,5 +80,3 @@ include $(CLEAR_VARS)
		LOCAL_MODULE := liblog
		LOCAL_WHOLE_STATIC_LIBRARIES := liblog
		include $(BUILD_SHARED_LIBRARY)

		include $(call first-makefiles-under,$(LOCAL_PATH))

liblog/tests/Android.mk

deleted100644 → 0

+0 −77

Original line number	Diff line number	Diff line
		#
		# Copyright (C) 2013 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.
		#

		LOCAL_PATH := $(call my-dir)

		# -----------------------------------------------------------------------------
		# Benchmarks.
		# -----------------------------------------------------------------------------

		test_module_prefix := liblog-
		test_tags := tests

		benchmark_c_flags := \
		-Ibionic/tests \
		-Wall -Wextra \
		-Werror \
		-fno-builtin \
		-std=gnu++11

		benchmark_src_files := \
		benchmark_main.cpp \
		liblog_benchmark.cpp \

		# Build benchmarks for the device. Run with:
		# adb shell liblog-benchmarks
		include $(CLEAR_VARS)
		LOCAL_MODULE := $(test_module_prefix)benchmarks
		LOCAL_MODULE_TAGS := $(test_tags)
		LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
		LOCAL_CFLAGS += $(benchmark_c_flags)
		LOCAL_SHARED_LIBRARIES += liblog libm
		LOCAL_SRC_FILES := $(benchmark_src_files)
		ifndef LOCAL_SDK_VERSION
		LOCAL_C_INCLUDES += bionic bionic/libstdc++/include external/stlport/stlport
		LOCAL_SHARED_LIBRARIES += libstlport
		endif
		LOCAL_MODULE_PATH := $(TARGET_OUT_DATA_NATIVE_TESTS)/$(LOCAL_MODULE)
		include $(BUILD_EXECUTABLE)

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

		test_c_flags := \
		-fstack-protector-all \
		-g \
		-Wall -Wextra \
		-Werror \
		-fno-builtin \

		test_src_files := \
		liblog_test.cpp \

		# Build tests for the device (with .so). Run with:
		# adb shell /data/nativetest/liblog-unit-tests/liblog-unit-tests
		include $(CLEAR_VARS)
		LOCAL_MODULE := $(test_module_prefix)unit-tests
		LOCAL_MODULE_TAGS := $(test_tags)
		LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/Android.mk
		LOCAL_CFLAGS += $(test_c_flags)
		LOCAL_LDLIBS := -lpthread
		LOCAL_SHARED_LIBRARIES := liblog
		LOCAL_SRC_FILES := $(test_src_files)
		include $(BUILD_NATIVE_TEST)

liblog/tests/benchmark.h

deleted100644 → 0

+0 −147

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012-2013 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 <stdint.h>
		#include <stdio.h>
		#include <stdlib.h>
		#include <string.h>

		#include <vector>

		#ifndef BIONIC_BENCHMARK_H_
		#define BIONIC_BENCHMARK_H_

		namespace testing {

		class Benchmark;
		template <typename T> class BenchmarkWantsArg;
		template <typename T> class BenchmarkWithArg;

		void BenchmarkRegister(Benchmark* bm);
		int PrettyPrintInt(char* str, int len, unsigned int arg);

		class Benchmark {
		public:
		Benchmark(const char* name, void (*fn)(int)) : name_(strdup(name)), fn_(fn) {
		BenchmarkRegister(this);
		}
		Benchmark(const char* name) : name_(strdup(name)), fn_(NULL) {}

		virtual ~Benchmark() {
		free(name_);
		}

		const char* Name() { return name_; }
		virtual const char* ArgName() { return NULL; }
		virtual void RunFn(int iterations) { fn_(iterations); }

		protected:
		char* name_;

		private:
		void (*fn_)(int);
		};

		template <typename T>
		class BenchmarkWantsArgBase : public Benchmark {
		public:
		BenchmarkWantsArgBase(const char* name, void (*fn)(int, T)) : Benchmark(name) {
		fn_arg_ = fn;
		}

		BenchmarkWantsArgBase<T>* Arg(const char* arg_name, T arg) {
		BenchmarkRegister(new BenchmarkWithArg<T>(name_, fn_arg_, arg_name, arg));
		return this;
		}

		protected:
		virtual void RunFn(int) { printf("can't run arg benchmark %s without arg\n", Name()); }
		void (*fn_arg_)(int, T);
		};

		template <typename T>
		class BenchmarkWithArg : public BenchmarkWantsArg<T> {
		public:
		BenchmarkWithArg(const char* name, void (fn)(int, T), const char arg_name, T arg) :
		BenchmarkWantsArg<T>(name, fn), arg_(arg) {
		arg_name_ = strdup(arg_name);
		}

		virtual ~BenchmarkWithArg() {
		free(arg_name_);
		}

		virtual const char* ArgName() { return arg_name_; }

		protected:
		virtual void RunFn(int iterations) { BenchmarkWantsArg<T>::fn_arg_(iterations, arg_); }

		private:
		T arg_;
		char* arg_name_;
		};

		template <typename T>
		class BenchmarkWantsArg : public BenchmarkWantsArgBase<T> {
		public:
		BenchmarkWantsArg<T>(const char* name, void (*fn)(int, T)) :
		BenchmarkWantsArgBase<T>(name, fn) { }
		};

		template <>
		class BenchmarkWantsArg<int> : public BenchmarkWantsArgBase<int> {
		public:
		BenchmarkWantsArg<int>(const char* name, void (*fn)(int, int)) :
		BenchmarkWantsArgBase<int>(name, fn) { }

		BenchmarkWantsArg<int>* Arg(int arg) {
		char arg_name[100];
		PrettyPrintInt(arg_name, sizeof(arg_name), arg);
		BenchmarkRegister(new BenchmarkWithArg<int>(name_, fn_arg_, arg_name, arg));
		return this;
		}
		};

		static inline Benchmark* BenchmarkFactory(const char* name, void (*fn)(int)) {
		return new Benchmark(name, fn);
		}

		template <typename T>
		static inline BenchmarkWantsArg<T>* BenchmarkFactory(const char* name, void (*fn)(int, T)) {
		return new BenchmarkWantsArg<T>(name, fn);
		}

		} // namespace testing

		template <typename T>
		static inline void BenchmarkAddArg(::testing::Benchmark* b, const char* name, T arg) {
		::testing::BenchmarkWantsArg<T>* ba;
		ba = static_cast< ::testing::BenchmarkWantsArg<T>* >(b);
		ba->Arg(name, arg);
		}

		void SetBenchmarkBytesProcessed(uint64_t);
		void ResetBenchmarkTiming(void);
		void StopBenchmarkTiming(void);
		void StartBenchmarkTiming(void);
		void StartBenchmarkTiming(uint64_t);
		void StopBenchmarkTiming(uint64_t);

		#define BENCHMARK(f) \
		static ::testing::Benchmark* _benchmark_##f __attribute__((unused)) = \
		(::testing::Benchmark*)::testing::BenchmarkFactory(#f, f)

		#endif // BIONIC_BENCHMARK_H_

liblog/tests/benchmark_main.cpp

deleted100644 → 0

+0 −245

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

		#include <regex.h>
		#include <stdio.h>
		#include <stdlib.h>

		#include <string>
		#include <map>
		#include <vector>

		static uint64_t gBytesProcessed;
		static uint64_t gBenchmarkTotalTimeNs;
		static uint64_t gBenchmarkTotalTimeNsSquared;
		static uint64_t gBenchmarkNum;
		static uint64_t gBenchmarkStartTimeNs;

		typedef std::vector< ::testing::Benchmark* > BenchmarkList;
		static BenchmarkList* gBenchmarks;

		static int Round(int n) {
		int base = 1;
		while (base*10 < n) {
		base *= 10;
		}
		if (n < 2*base) {
		return 2*base;
		}
		if (n < 5*base) {
		return 5*base;
		}
		return 10*base;
		}

		static uint64_t NanoTime() {
		struct timespec t;
		t.tv_sec = t.tv_nsec = 0;
		clock_gettime(CLOCK_MONOTONIC, &t);
		return static_cast<uint64_t>(t.tv_sec) * 1000000000ULL + t.tv_nsec;
		}

		namespace testing {

		int PrettyPrintInt(char* str, int len, unsigned int arg)
		{
		if (arg >= (1<<30) && arg % (1<<30) == 0) {
		return snprintf(str, len, "%uGi", arg/(1<<30));
		} else if (arg >= (1<<20) && arg % (1<<20) == 0) {
		return snprintf(str, len, "%uMi", arg/(1<<20));
		} else if (arg >= (1<<10) && arg % (1<<10) == 0) {
		return snprintf(str, len, "%uKi", arg/(1<<10));
		} else if (arg >= 1000000000 && arg % 1000000000 == 0) {
		return snprintf(str, len, "%uG", arg/1000000000);
		} else if (arg >= 1000000 && arg % 1000000 == 0) {
		return snprintf(str, len, "%uM", arg/1000000);
		} else if (arg >= 1000 && arg % 1000 == 0) {
		return snprintf(str, len, "%uK", arg/1000);
		} else {
		return snprintf(str, len, "%u", arg);
		}
		}

		bool ShouldRun(Benchmark* b, int argc, char* argv[]) {
		if (argc == 1) {
		return true; // With no arguments, we run all benchmarks.
		}
		// Otherwise, we interpret each argument as a regular expression and
		// see if any of our benchmarks match.
		for (int i = 1; i < argc; i++) {
		regex_t re;
		if (regcomp(&re, argv[i], 0) != 0) {
		fprintf(stderr, "couldn't compile \"%s\" as a regular expression!\n", argv[i]);
		exit(EXIT_FAILURE);
		}
		int match = regexec(&re, b->Name(), 0, NULL, 0);
		regfree(&re);
		if (match != REG_NOMATCH) {
		return true;
		}
		}
		return false;
		}

		void BenchmarkRegister(Benchmark* b) {
		if (gBenchmarks == NULL) {
		gBenchmarks = new BenchmarkList;
		}
		gBenchmarks->push_back(b);
		}

		void RunRepeatedly(Benchmark* b, int iterations) {
		gBytesProcessed = 0;
		ResetBenchmarkTiming();
		uint64_t StartTimeNs = NanoTime();
		b->RunFn(iterations);
		// Catch us if we fail to log anything.
		if ((gBenchmarkTotalTimeNs == 0)
		&& (StartTimeNs != 0)
		&& (gBenchmarkStartTimeNs == 0)) {
		gBenchmarkTotalTimeNs = NanoTime() - StartTimeNs;
		}
		}

		void Run(Benchmark* b) {
		// run once in case it's expensive
		unsigned iterations = 1;
		uint64_t s = NanoTime();
		RunRepeatedly(b, iterations);
		s = NanoTime() - s;
		while (s < 2e9 && gBenchmarkTotalTimeNs < 1e9 && iterations < 1e9) {
		unsigned last = iterations;
		if (gBenchmarkTotalTimeNs/iterations == 0) {
		iterations = 1e9;
		} else {
		iterations = 1e9 / (gBenchmarkTotalTimeNs/iterations);
		}
		iterations = std::max(last + 1, std::min(iterations + iterations/2, 100*last));
		iterations = Round(iterations);
		s = NanoTime();
		RunRepeatedly(b, iterations);
		s = NanoTime() - s;
		}

		char throughput[100];
		throughput[0] = '\0';
		if (gBenchmarkTotalTimeNs > 0 && gBytesProcessed > 0) {
		double mib_processed = static_cast<double>(gBytesProcessed)/1e6;
		double seconds = static_cast<double>(gBenchmarkTotalTimeNs)/1e9;
		snprintf(throughput, sizeof(throughput), " %8.2f MiB/s", mib_processed/seconds);
		}

		char full_name[100];
		snprintf(full_name, sizeof(full_name), "%s%s%s", b->Name(),
		b->ArgName() ? "/" : "",
		b->ArgName() ? b->ArgName() : "");

		uint64_t mean = gBenchmarkTotalTimeNs / iterations;
		uint64_t sdev = 0;
		if (gBenchmarkNum == iterations) {
		mean = gBenchmarkTotalTimeNs / gBenchmarkNum;
		uint64_t nXvariance = gBenchmarkTotalTimeNsSquared * gBenchmarkNum
		- (gBenchmarkTotalTimeNs * gBenchmarkTotalTimeNs);
		sdev = (sqrt((double)nXvariance) / gBenchmarkNum / gBenchmarkNum) + 0.5;
		}
		if (mean > (10000 * sdev)) {
		printf("%-25s %10llu %10llu%s\n", full_name,
		static_cast<uint64_t>(iterations), mean, throughput);
		} else {
		printf("%-25s %10llu %10llu(\317\203%llu)%s\n", full_name,
		static_cast<uint64_t>(iterations), mean, sdev, throughput);
		}
		fflush(stdout);
		}

		} // namespace testing

		void SetBenchmarkBytesProcessed(uint64_t x) {
		gBytesProcessed = x;
		}

		void ResetBenchmarkTiming() {
		gBenchmarkStartTimeNs = 0;
		gBenchmarkTotalTimeNs = 0;
		gBenchmarkTotalTimeNsSquared = 0;
		gBenchmarkNum = 0;
		}

		void StopBenchmarkTiming(void) {
		if (gBenchmarkStartTimeNs != 0) {
		int64_t diff = NanoTime() - gBenchmarkStartTimeNs;
		gBenchmarkTotalTimeNs += diff;
		gBenchmarkTotalTimeNsSquared += diff * diff;
		++gBenchmarkNum;
		}
		gBenchmarkStartTimeNs = 0;
		}

		void StartBenchmarkTiming(void) {
		if (gBenchmarkStartTimeNs == 0) {
		gBenchmarkStartTimeNs = NanoTime();
		}
		}

		void StopBenchmarkTiming(uint64_t NanoTime) {
		if (gBenchmarkStartTimeNs != 0) {
		int64_t diff = NanoTime - gBenchmarkStartTimeNs;
		gBenchmarkTotalTimeNs += diff;
		gBenchmarkTotalTimeNsSquared += diff * diff;
		if (NanoTime != 0) {
		++gBenchmarkNum;
		}
		}
		gBenchmarkStartTimeNs = 0;
		}

		void StartBenchmarkTiming(uint64_t NanoTime) {
		if (gBenchmarkStartTimeNs == 0) {
		gBenchmarkStartTimeNs = NanoTime;
		}
		}

		int main(int argc, char* argv[]) {
		if (gBenchmarks->empty()) {
		fprintf(stderr, "No benchmarks registered!\n");
		exit(EXIT_FAILURE);
		}

		bool need_header = true;
		for (auto b : *gBenchmarks) {
		if (ShouldRun(b, argc, argv)) {
		if (need_header) {
		printf("%-25s %10s %10s\n", "", "iterations", "ns/op");
		fflush(stdout);
		need_header = false;
		}
		Run(b);
		}
		}

		if (need_header) {
		fprintf(stderr, "No matching benchmarks!\n");
		fprintf(stderr, "Available benchmarks:\n");
		for (auto b : *gBenchmarks) {
		fprintf(stderr, " %s\n", b->Name());
		}
		exit(EXIT_FAILURE);
		}

		return 0;
		}