Merge "liblog: benchmarks use google-benchmark library" am: 962566095f (c5b3c1ee) · Commits · e / os / android_system_core

liblog/tests/Android.mk

+3 −4

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

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

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

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

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

liblog/tests/benchmark.h

deleted100644 → 0

+0 −147

Original line number	Original line	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	Original line	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;
	}

liblog/tests/liblog_benchmark.cpp

+130 −158

File changed.

Preview size limit exceeded, changes collapsed.