liblog: benchmarks use google-benchmark library (1520bd43) · Commits · e / os / android_system_core

liblog/tests/Android.mk

+3 −4

Original line number	Diff line number	Diff line
		@@ -24,13 +24,12 @@ test_module_prefix := liblog-
		test_tags := tests

		benchmark_c_flags := \
		-Ibionic/tests \
		-Wall -Wextra \
		-Wall \
		-Wextra \
		-Werror \
		-fno-builtin \

		benchmark_src_files := \
		benchmark_main.cpp \
		liblog_benchmark.cpp

		# Build benchmarks for the device. Run with:
		@@ -41,7 +40,7 @@ LOCAL_MODULE_TAGS := $(test_tags)
		LOCAL_CFLAGS += $(benchmark_c_flags)
		LOCAL_SHARED_LIBRARIES += liblog libm libbase
		LOCAL_SRC_FILES := $(benchmark_src_files)
		include $(BUILD_NATIVE_TEST)
		include $(BUILD_NATIVE_BENCHMARK)

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

liblog/tests/benchmark.h

deleted100644 → 0

+0 −147

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012-2014 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);
		}
		explicit 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)) = /* NOLINT */ \
		(::testing::Benchmark)::testing::BenchmarkFactory(#f, f) / NOLINT */

		#endif // BIONIC_BENCHMARK_H_

liblog/tests/benchmark_main.cpp

deleted100644 → 0

+0 −247

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2012-2014 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 <inttypes.h>
		#include <math.h>
		#include <regex.h>
		#include <stdio.h>
		#include <stdlib.h>

		#include <map>
		#include <string>
		#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 %10" PRIu64 " %10" PRIu64 "%s\n", full_name,
		static_cast<uint64_t>(iterations), mean, throughput);
		} else {
		printf("%-25s %10" PRIu64 " %10" PRIu64 "(\317\203%" PRIu64 ")%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;
		}