// Copyright 2015 Google Inc. All rights reserved. // // 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. // Support for registering benchmarks for functions. /* Example usage: // Define a function that executes the code to be measured a // specified number of times: static void BM_StringCreation(benchmark::State& state) { for (auto _ : state) std::string empty_string; } // Register the function as a benchmark BENCHMARK(BM_StringCreation); // Define another benchmark static void BM_StringCopy(benchmark::State& state) { std::string x = "hello"; for (auto _ : state) std::string copy(x); } BENCHMARK(BM_StringCopy); // Augment the main() program to invoke benchmarks if specified // via the --benchmark_filter command line flag. E.g., // my_unittest --benchmark_filter=all // my_unittest --benchmark_filter=BM_StringCreation // my_unittest --benchmark_filter=String // my_unittest --benchmark_filter='Copy|Creation' int main(int argc, char** argv) { benchmark::Initialize(&argc, argv); benchmark::RunSpecifiedBenchmarks(); benchmark::Shutdown(); return 0; } // Sometimes a family of microbenchmarks can be implemented with // just one routine that takes an extra argument to specify which // one of the family of benchmarks to run. For example, the following // code defines a family of microbenchmarks for measuring the speed // of memcpy() calls of different lengths: static void BM_memcpy(benchmark::State& state) { char* src = new char[state.range(0)]; char* dst = new char[state.range(0)]; memset(src, 'x', state.range(0)); for (auto _ : state) memcpy(dst, src, state.range(0)); state.SetBytesProcessed(state.iterations() * state.range(0)); delete[] src; delete[] dst; } BENCHMARK(BM_memcpy)->Arg(8)->Arg(64)->Arg(512)->Arg(1<<10)->Arg(8<<10); // The preceding code is quite repetitive, and can be replaced with the // following short-hand. The following invocation will pick a few // appropriate arguments in the specified range and will generate a // microbenchmark for each such argument. BENCHMARK(BM_memcpy)->Range(8, 8<<10); // You might have a microbenchmark that depends on two inputs. For // example, the following code defines a family of microbenchmarks for // measuring the speed of set insertion. static void BM_SetInsert(benchmark::State& state) { set<int> data; for (auto _ : state) { state.PauseTiming(); data = ConstructRandomSet(state.range(0)); state.ResumeTiming(); for (int j = 0; j < state.range(1); ++j) data.insert(RandomNumber()); } } BENCHMARK(BM_SetInsert) ->Args({1<<10, 128}) ->Args({2<<10, 128}) ->Args({4<<10, 128}) ->Args({8<<10, 128}) ->Args({1<<10, 512}) ->Args({2<<10, 512}) ->Args({4<<10, 512}) ->Args({8<<10, 512}); // The preceding code is quite repetitive, and can be replaced with // the following short-hand. The following macro will pick a few // appropriate arguments in the product of the two specified ranges // and will generate a microbenchmark for each such pair. BENCHMARK(BM_SetInsert)->Ranges({{1<<10, 8<<10}, {128, 512}}); // For more complex patterns of inputs, passing a custom function // to Apply allows programmatic specification of an // arbitrary set of arguments to run the microbenchmark on. // The following example enumerates a dense range on // one parameter, and a sparse range on the second. static void CustomArguments(benchmark::internal::Benchmark* b) { for (int i = 0; i <= 10; ++i) for (int j = 32; j <= 1024*1024; j *= 8) b->Args({i, j}); } BENCHMARK(BM_SetInsert)->Apply(CustomArguments); // Templated microbenchmarks work the same way: // Produce then consume 'size' messages 'iters' times // Measures throughput in the absence of multiprogramming. template <class Q> int BM_Sequential(benchmark::State& state) { Q q; typename Q::value_type v; for (auto _ : state) { for (int i = state.range(0); i--; ) q.push(v); for (int e = state.range(0); e--; ) q.Wait(&v); } // actually messages, not bytes: state.SetBytesProcessed(state.iterations() * state.range(0)); } BENCHMARK_TEMPLATE(BM_Sequential, WaitQueue<int>)->Range(1<<0, 1<<10); Use `Benchmark::MinTime(double t)` to set the minimum time used to run the benchmark. This option overrides the `benchmark_min_time` flag. void BM_test(benchmark::State& state) { ... body ... } BENCHMARK(BM_test)->MinTime(2.0); // Run for at least 2 seconds. In a multithreaded test, it is guaranteed that none of the threads will start until all have reached the loop start, and all will have finished before any thread exits the loop body. As such, any global setup or teardown you want to do can be wrapped in a check against the thread index: static void BM_MultiThreaded(benchmark::State& state) { if (state.thread_index() == 0) { // Setup code here. } for (auto _ : state) { // Run the test as normal. } if (state.thread_index() == 0) { // Teardown code here. } } BENCHMARK(BM_MultiThreaded)->Threads(4); If a benchmark runs a few milliseconds it may be hard to visually compare the measured times, since the output data is given in nanoseconds per default. In order to manually set the time unit, you can specify it manually: BENCHMARK(BM_test)->Unit(benchmark::kMillisecond); */ #ifndef BENCHMARK_BENCHMARK_H_ #define BENCHMARK_BENCHMARK_H_ // The _MSVC_LANG check should detect Visual Studio 2015 Update 3 and newer. #if __cplusplus >= 201103L || (defined(_MSVC_LANG) && _MSVC_LANG >= 201103L) #define BENCHMARK_HAS_CXX11 #endif // This _MSC_VER check should detect VS 2017 v15.3 and newer. #if __cplusplus >= 201703L || \ (defined(_MSC_VER) && _MSC_VER >= 1911 && _MSVC_LANG >= 201703L) #define BENCHMARK_HAS_CXX17 #endif #include <stdint.h> #include <algorithm> #include <cassert> #include <cstddef> #include <iosfwd> #include <limits> #include <map> #include <set> #include <string> #include <utility> #include <vector> #include "benchmark/export.h" #if defined(BENCHMARK_HAS_CXX11) #include <atomic> #include <initializer_list> #include <type_traits> #include <utility> #endif #if defined(_MSC_VER) #include <intrin.h> // for _ReadWriteBarrier #endif #ifndef BENCHMARK_HAS_CXX11 #define BENCHMARK_DISALLOW_COPY_AND_ASSIGN … #else #define BENCHMARK_DISALLOW_COPY_AND_ASSIGN(TypeName) … #endif #ifdef BENCHMARK_HAS_CXX17 #define BENCHMARK_UNUSED … #elif defined(__GNUC__) || defined(__clang__) #define BENCHMARK_UNUSED … #else #define BENCHMARK_UNUSED #endif // Used to annotate functions, methods and classes so they // are not optimized by the compiler. Useful for tests // where you expect loops to stay in place churning cycles #if defined(__clang__) #define BENCHMARK_DONT_OPTIMIZE … #elif defined(__GNUC__) || defined(__GNUG__) #define BENCHMARK_DONT_OPTIMIZE … #else // MSVC & Intel do not have a no-optimize attribute, only line pragmas #define BENCHMARK_DONT_OPTIMIZE #endif #if defined(__GNUC__) || defined(__clang__) #define BENCHMARK_ALWAYS_INLINE … #elif defined(_MSC_VER) && !defined(__clang__) #define BENCHMARK_ALWAYS_INLINE … #define __func__ __FUNCTION__ #else #define BENCHMARK_ALWAYS_INLINE #endif #define BENCHMARK_INTERNAL_TOSTRING2(x) … #define BENCHMARK_INTERNAL_TOSTRING(x) … // clang-format off #if (defined(__GNUC__) && !defined(__NVCC__) && !defined(__NVCOMPILER)) || defined(__clang__) #define BENCHMARK_BUILTIN_EXPECT(x, y) … #define BENCHMARK_DEPRECATED_MSG(msg) … #define BENCHMARK_DISABLE_DEPRECATED_WARNING … #define BENCHMARK_RESTORE_DEPRECATED_WARNING … #elif defined(__NVCOMPILER) #define BENCHMARK_BUILTIN_EXPECT … #define BENCHMARK_DEPRECATED_MSG … #define BENCHMARK_DISABLE_DEPRECATED_WARNING … #define BENCHMARK_RESTORE_DEPRECATED_WARNING … #else #define BENCHMARK_BUILTIN_EXPECT … #define BENCHMARK_DEPRECATED_MSG … #define BENCHMARK_WARNING_MSG … #define BENCHMARK_DISABLE_DEPRECATED_WARNING #define BENCHMARK_RESTORE_DEPRECATED_WARNING #endif // clang-format on #if defined(__GNUC__) && !defined(__clang__) #define BENCHMARK_GCC_VERSION … #endif #ifndef __has_builtin #define __has_builtin … #endif #if defined(__GNUC__) || __has_builtin(__builtin_unreachable) #define BENCHMARK_UNREACHABLE() … #elif defined(_MSC_VER) #define BENCHMARK_UNREACHABLE … #else #define BENCHMARK_UNREACHABLE … #endif #ifdef BENCHMARK_HAS_CXX11 #define BENCHMARK_OVERRIDE … #else #define BENCHMARK_OVERRIDE #endif #if defined(_MSC_VER) #pragma warning(push) // C4251: <symbol> needs to have dll-interface to be used by clients of class #pragma warning(disable : 4251) #endif namespace benchmark { class BenchmarkReporter; // Default number of minimum benchmark running time in seconds. const char kDefaultMinTimeStr[] = …; BENCHMARK_EXPORT void PrintDefaultHelp(); BENCHMARK_EXPORT void Initialize(int* argc, char** argv, void (*HelperPrinterf)() = PrintDefaultHelp); BENCHMARK_EXPORT void Shutdown(); // Report to stdout all arguments in 'argv' as unrecognized except the first. // Returns true there is at least on unrecognized argument (i.e. 'argc' > 1). BENCHMARK_EXPORT bool ReportUnrecognizedArguments(int argc, char** argv); // Returns the current value of --benchmark_filter. BENCHMARK_EXPORT std::string GetBenchmarkFilter(); // Sets a new value to --benchmark_filter. (This will override this flag's // current value). // Should be called after `benchmark::Initialize()`, as // `benchmark::Initialize()` will override the flag's value. BENCHMARK_EXPORT void SetBenchmarkFilter(std::string value); // Returns the current value of --v (command line value for verbosity). BENCHMARK_EXPORT int32_t GetBenchmarkVerbosity(); // Creates a default display reporter. Used by the library when no display // reporter is provided, but also made available for external use in case a // custom reporter should respect the `--benchmark_format` flag as a fallback BENCHMARK_EXPORT BenchmarkReporter* CreateDefaultDisplayReporter(); // Generate a list of benchmarks matching the specified --benchmark_filter flag // and if --benchmark_list_tests is specified return after printing the name // of each matching benchmark. Otherwise run each matching benchmark and // report the results. // // spec : Specify the benchmarks to run. If users do not specify this arg, // then the value of FLAGS_benchmark_filter // will be used. // // The second and third overload use the specified 'display_reporter' and // 'file_reporter' respectively. 'file_reporter' will write to the file // specified // by '--benchmark_output'. If '--benchmark_output' is not given the // 'file_reporter' is ignored. // // RETURNS: The number of matching benchmarks. BENCHMARK_EXPORT size_t RunSpecifiedBenchmarks(); BENCHMARK_EXPORT size_t RunSpecifiedBenchmarks(std::string spec); BENCHMARK_EXPORT size_t RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter); BENCHMARK_EXPORT size_t RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter, std::string spec); BENCHMARK_EXPORT size_t RunSpecifiedBenchmarks( BenchmarkReporter* display_reporter, BenchmarkReporter* file_reporter); BENCHMARK_EXPORT size_t RunSpecifiedBenchmarks(BenchmarkReporter* display_reporter, BenchmarkReporter* file_reporter, std::string spec); // TimeUnit is passed to a benchmark in order to specify the order of magnitude // for the measured time. enum TimeUnit { … }; BENCHMARK_EXPORT TimeUnit GetDefaultTimeUnit(); // Sets the default time unit the benchmarks use // Has to be called before the benchmark loop to take effect BENCHMARK_EXPORT void SetDefaultTimeUnit(TimeUnit unit); // If a MemoryManager is registered (via RegisterMemoryManager()), // it can be used to collect and report allocation metrics for a run of the // benchmark. class MemoryManager { … }; // Register a MemoryManager instance that will be used to collect and report // allocation measurements for benchmark runs. BENCHMARK_EXPORT void RegisterMemoryManager(MemoryManager* memory_manager); // Add a key-value pair to output as part of the context stanza in the report. BENCHMARK_EXPORT void AddCustomContext(const std::string& key, const std::string& value); namespace internal { class Benchmark; class BenchmarkImp; class BenchmarkFamilies; BENCHMARK_EXPORT std::map<std::string, std::string>*& GetGlobalContext(); BENCHMARK_EXPORT void UseCharPointer(char const volatile*); // Take ownership of the pointer and register the benchmark. Return the // registered benchmark. BENCHMARK_EXPORT Benchmark* RegisterBenchmarkInternal(Benchmark*); // Ensure that the standard streams are properly initialized in every TU. BENCHMARK_EXPORT int InitializeStreams(); BENCHMARK_UNUSED static int stream_init_anchor = …; } // namespace internal #if (!defined(__GNUC__) && !defined(__clang__)) || defined(__pnacl__) || \ defined(__EMSCRIPTEN__) #define BENCHMARK_HAS_NO_INLINE_ASSEMBLY #endif // Force the compiler to flush pending writes to global memory. Acts as an // effective read/write barrier #ifdef BENCHMARK_HAS_CXX11 inline BENCHMARK_ALWAYS_INLINE void ClobberMemory() { … } #endif // The DoNotOptimize(...) function can be used to prevent a value or // expression from being optimized away by the compiler. This function is // intended to add little to no overhead. // See: https://youtu.be/nXaxk27zwlk?t=2441 #ifndef BENCHMARK_HAS_NO_INLINE_ASSEMBLY #if !defined(__GNUC__) || defined(__llvm__) || defined(__INTEL_COMPILER) template <class Tp> BENCHMARK_DEPRECATED_MSG( "The const-ref version of this method can permit " "undesired compiler optimizations in benchmarks") inline BENCHMARK_ALWAYS_INLINE void DoNotOptimize(Tp const& value) { … } template <class Tp> inline BENCHMARK_ALWAYS_INLINE void DoNotOptimize(Tp& value) { … } #ifdef BENCHMARK_HAS_CXX11 template <class Tp> inline BENCHMARK_ALWAYS_INLINE void DoNotOptimize(Tp&& value) { … } #endif #elif defined(BENCHMARK_HAS_CXX11) && (__GNUC__ >= 5) // Workaround for a bug with full argument copy overhead with GCC. // See: #1340 and https://gcc.gnu.org/bugzilla/show_bug.cgi?id=105519 template <class Tp> BENCHMARK_DEPRECATED_MSG( "The const-ref version of this method can permit " "undesired compiler optimizations in benchmarks") inline BENCHMARK_ALWAYS_INLINE typename std::enable_if<std::is_trivially_copyable<Tp>::value && (sizeof(Tp) <= sizeof(Tp*))>::type DoNotOptimize(Tp const& value) { asm volatile("" : : "r,m"(value) : "memory"); } template <class Tp> BENCHMARK_DEPRECATED_MSG( "The const-ref version of this method can permit " "undesired compiler optimizations in benchmarks") inline BENCHMARK_ALWAYS_INLINE typename std::enable_if<!std::is_trivially_copyable<Tp>::value || (sizeof(Tp) > sizeof(Tp*))>::type DoNotOptimize(Tp const& value) { asm volatile("" : : "m"(value) : "memory"); } template <class Tp> inline BENCHMARK_ALWAYS_INLINE typename std::enable_if<std::is_trivially_copyable<Tp>::value && (sizeof(Tp) <= sizeof(Tp*))>::type DoNotOptimize(Tp& value) { asm volatile("" : "+m,r"(value) : : "memory"); } template <class Tp> inline BENCHMARK_ALWAYS_INLINE typename std::enable_if<!std::is_trivially_copyable<Tp>::value || (sizeof(Tp) > sizeof(Tp*))>::type DoNotOptimize(Tp& value) { asm volatile("" : "+m"(value) : : "memory"); } template <class Tp> inline BENCHMARK_ALWAYS_INLINE typename std::enable_if<std::is_trivially_copyable<Tp>::value && (sizeof(Tp) <= sizeof(Tp*))>::type DoNotOptimize(Tp&& value) { asm volatile("" : "+m,r"(value) : : "memory"); } template <class Tp> inline BENCHMARK_ALWAYS_INLINE typename std::enable_if<!std::is_trivially_copyable<Tp>::value || (sizeof(Tp) > sizeof(Tp*))>::type DoNotOptimize(Tp&& value) { asm volatile("" : "+m"(value) : : "memory"); } #else // Fallback for GCC < 5. Can add some overhead because the compiler is forced // to use memory operations instead of operations with registers. // TODO: Remove if GCC < 5 will be unsupported. template <class Tp> BENCHMARK_DEPRECATED_MSG( "The const-ref version of this method can permit " "undesired compiler optimizations in benchmarks") inline BENCHMARK_ALWAYS_INLINE void DoNotOptimize(Tp const& value) { asm volatile("" : : "m"(value) : "memory"); } template <class Tp> inline BENCHMARK_ALWAYS_INLINE void DoNotOptimize(Tp& value) { asm volatile("" : "+m"(value) : : "memory"); } #ifdef BENCHMARK_HAS_CXX11 template <class Tp> inline BENCHMARK_ALWAYS_INLINE void DoNotOptimize(Tp&& value) { asm volatile("" : "+m"(value) : : "memory"); } #endif #endif #ifndef BENCHMARK_HAS_CXX11 inline BENCHMARK_ALWAYS_INLINE void ClobberMemory() { asm volatile("" : : : "memory"); } #endif #elif defined(_MSC_VER) template <class Tp> BENCHMARK_DEPRECATED_MSG( "The const-ref version of this method can permit " "undesired compiler optimizations in benchmarks") inline BENCHMARK_ALWAYS_INLINE void DoNotOptimize(Tp const& value) { internal::UseCharPointer(&reinterpret_cast<char const volatile&>(value)); _ReadWriteBarrier(); } #ifndef BENCHMARK_HAS_CXX11 inline BENCHMARK_ALWAYS_INLINE void ClobberMemory() { _ReadWriteBarrier(); } #endif #else template <class Tp> BENCHMARK_DEPRECATED_MSG( "The const-ref version of this method can permit " "undesired compiler optimizations in benchmarks") inline BENCHMARK_ALWAYS_INLINE void DoNotOptimize(Tp const& value) { internal::UseCharPointer(&reinterpret_cast<char const volatile&>(value)); } // FIXME Add ClobberMemory() for non-gnu and non-msvc compilers, before C++11. #endif // This class is used for user-defined counters. class Counter { … }; // A helper for user code to create unforeseen combinations of Flags, without // having to do this cast manually each time, or providing this operator. Counter::Flags inline operator|(const Counter::Flags& LHS, const Counter::Flags& RHS) { … } // This is the container for the user-defined counters. UserCounters; // BigO is passed to a benchmark in order to specify the asymptotic // computational // complexity for the benchmark. In case oAuto is selected, complexity will be // calculated automatically to the best fit. enum BigO { … }; IterationCount; enum StatisticUnit { … }; // BigOFunc is passed to a benchmark in order to specify the asymptotic // computational complexity for the benchmark. BigOFunc; // StatisticsFunc is passed to a benchmark in order to compute some descriptive // statistics over all the measurements of some type StatisticsFunc; namespace internal { struct Statistics { … }; class BenchmarkInstance; class ThreadTimer; class ThreadManager; class PerfCountersMeasurement; enum AggregationReportMode #if defined(BENCHMARK_HAS_CXX11) : unsigned #else #endif { … }; enum Skipped #if defined(BENCHMARK_HAS_CXX11) : unsigned #endif { … }; } // namespace internal // State is passed to a running Benchmark and contains state for the // benchmark to use. class BENCHMARK_EXPORT State { … }; inline BENCHMARK_ALWAYS_INLINE bool State::KeepRunning() { … } inline BENCHMARK_ALWAYS_INLINE bool State::KeepRunningBatch(IterationCount n) { … } inline BENCHMARK_ALWAYS_INLINE bool State::KeepRunningInternal(IterationCount n, bool is_batch) { … } struct State::StateIterator { … }; inline BENCHMARK_ALWAYS_INLINE State::StateIterator State::begin() { … } inline BENCHMARK_ALWAYS_INLINE State::StateIterator State::end() { … } namespace internal { Function; // ------------------------------------------------------ // Benchmark registration object. The BENCHMARK() macro expands // into an internal::Benchmark* object. Various methods can // be called on this object to change the properties of the benchmark. // Each method returns "this" so that multiple method calls can // chained into one expression. class BENCHMARK_EXPORT Benchmark { … }; } // namespace internal // Create and register a benchmark with the specified 'name' that invokes // the specified functor 'fn'. // // RETURNS: A pointer to the registered benchmark. internal::Benchmark* RegisterBenchmark(const std::string& name, internal::Function* fn); #if defined(BENCHMARK_HAS_CXX11) template <class Lambda> internal::Benchmark* RegisterBenchmark(const std::string& name, Lambda&& fn); #endif // Remove all registered benchmarks. All pointers to previously registered // benchmarks are invalidated. BENCHMARK_EXPORT void ClearRegisteredBenchmarks(); namespace internal { // The class used to hold all Benchmarks created from static function. // (ie those created using the BENCHMARK(...) macros. class BENCHMARK_EXPORT FunctionBenchmark : public Benchmark { … }; #ifdef BENCHMARK_HAS_CXX11 template <class Lambda> class LambdaBenchmark : public Benchmark { … }; #endif } // namespace internal inline internal::Benchmark* RegisterBenchmark(const std::string& name, internal::Function* fn) { … } #ifdef BENCHMARK_HAS_CXX11 template <class Lambda> internal::Benchmark* RegisterBenchmark(const std::string& name, Lambda&& fn) { … } #endif #if defined(BENCHMARK_HAS_CXX11) && \ (!defined(BENCHMARK_GCC_VERSION) || BENCHMARK_GCC_VERSION >= 409) template <class Lambda, class... Args> internal::Benchmark* RegisterBenchmark(const std::string& name, Lambda&& fn, Args&&... args) { … } #else #define BENCHMARK_HAS_NO_VARIADIC_REGISTER_BENCHMARK #endif // The base class for all fixture tests. class Fixture : public internal::Benchmark { … }; } // namespace benchmark // ------------------------------------------------------ // Macro to register benchmarks // Check that __COUNTER__ is defined and that __COUNTER__ increases by 1 // every time it is expanded. X + 1 == X + 0 is used in case X is defined to be // empty. If X is empty the expression becomes (+1 == +0). #if defined(__COUNTER__) && (__COUNTER__ + 1 == __COUNTER__ + 0) #define BENCHMARK_PRIVATE_UNIQUE_ID … #else #define BENCHMARK_PRIVATE_UNIQUE_ID … #endif // Helpers for generating unique variable names #ifdef BENCHMARK_HAS_CXX11 #define BENCHMARK_PRIVATE_NAME(...) … #else #define BENCHMARK_PRIVATE_NAME … #endif // BENCHMARK_HAS_CXX11 #define BENCHMARK_PRIVATE_CONCAT(a, b, c) … #define BENCHMARK_PRIVATE_CONCAT2(a, b, c) … // Helper for concatenation with macro name expansion #define BENCHMARK_PRIVATE_CONCAT_NAME(BaseClass, Method) … #define BENCHMARK_PRIVATE_DECLARE(n) … #ifdef BENCHMARK_HAS_CXX11 #define BENCHMARK(...) … #else #define BENCHMARK … #endif // BENCHMARK_HAS_CXX11 // Old-style macros #define BENCHMARK_WITH_ARG(n, a) … #define BENCHMARK_WITH_ARG2(n, a1, a2) … #define BENCHMARK_WITH_UNIT(n, t) … #define BENCHMARK_RANGE(n, lo, hi) … #define BENCHMARK_RANGE2(n, l1, h1, l2, h2) … #ifdef BENCHMARK_HAS_CXX11 // Register a benchmark which invokes the function specified by `func` // with the additional arguments specified by `...`. // // For example: // // template <class ...ExtraArgs>` // void BM_takes_args(benchmark::State& state, ExtraArgs&&... extra_args) { // [...] //} // /* Registers a benchmark named "BM_takes_args/int_string_test` */ // BENCHMARK_CAPTURE(BM_takes_args, int_string_test, 42, std::string("abc")); #define BENCHMARK_CAPTURE(func, test_case_name, ...) … #endif // BENCHMARK_HAS_CXX11 // This will register a benchmark for a templatized function. For example: // // template<int arg> // void BM_Foo(int iters); // // BENCHMARK_TEMPLATE(BM_Foo, 1); // // will register BM_Foo<1> as a benchmark. #define BENCHMARK_TEMPLATE1(n, a) … #define BENCHMARK_TEMPLATE2(n, a, b) … #ifdef BENCHMARK_HAS_CXX11 #define BENCHMARK_TEMPLATE(n, ...) … #else #define BENCHMARK_TEMPLATE … #endif #define BENCHMARK_PRIVATE_DECLARE_F(BaseClass, Method) … #define BENCHMARK_TEMPLATE1_PRIVATE_DECLARE_F(BaseClass, Method, a) … #define BENCHMARK_TEMPLATE2_PRIVATE_DECLARE_F(BaseClass, Method, a, b) … #ifdef BENCHMARK_HAS_CXX11 #define BENCHMARK_TEMPLATE_PRIVATE_DECLARE_F(BaseClass, Method, ...) … #else #define BENCHMARK_TEMPLATE_PRIVATE_DECLARE_F … #endif #define BENCHMARK_DEFINE_F(BaseClass, Method) … #define BENCHMARK_TEMPLATE1_DEFINE_F(BaseClass, Method, a) … #define BENCHMARK_TEMPLATE2_DEFINE_F(BaseClass, Method, a, b) … #ifdef BENCHMARK_HAS_CXX11 #define BENCHMARK_TEMPLATE_DEFINE_F(BaseClass, Method, ...) … #else #define BENCHMARK_TEMPLATE_DEFINE_F … #endif #define BENCHMARK_REGISTER_F(BaseClass, Method) … #define BENCHMARK_PRIVATE_REGISTER_F(TestName) … // This macro will define and register a benchmark within a fixture class. #define BENCHMARK_F(BaseClass, Method) … #define BENCHMARK_TEMPLATE1_F(BaseClass, Method, a) … #define BENCHMARK_TEMPLATE2_F(BaseClass, Method, a, b) … #ifdef BENCHMARK_HAS_CXX11 #define BENCHMARK_TEMPLATE_F(BaseClass, Method, ...) … #else #define BENCHMARK_TEMPLATE_F … #endif // Helper macro to create a main routine in a test that runs the benchmarks // Note the workaround for Hexagon simulator passing argc != 0, argv = NULL. #define BENCHMARK_MAIN() … // ------------------------------------------------------ // Benchmark Reporters namespace benchmark { struct BENCHMARK_EXPORT CPUInfo { … }; // Adding Struct for System Information struct BENCHMARK_EXPORT SystemInfo { … }; // BenchmarkName contains the components of the Benchmark's name // which allows individual fields to be modified or cleared before // building the final name using 'str()'. struct BENCHMARK_EXPORT BenchmarkName { … }; // Interface for custom benchmark result printers. // By default, benchmark reports are printed to stdout. However an application // can control the destination of the reports by calling // RunSpecifiedBenchmarks and passing it a custom reporter object. // The reporter object must implement the following interface. class BENCHMARK_EXPORT BenchmarkReporter { … }; // Simple reporter that outputs benchmark data to the console. This is the // default reporter used by RunSpecifiedBenchmarks(). class BENCHMARK_EXPORT ConsoleReporter : public BenchmarkReporter { … }; class BENCHMARK_EXPORT JSONReporter : public BenchmarkReporter { … }; class BENCHMARK_EXPORT BENCHMARK_DEPRECATED_MSG( "The CSV Reporter will be removed in a future release") CSVReporter : public BenchmarkReporter { … }; inline const char* GetTimeUnitString(TimeUnit unit) { … } inline double GetTimeUnitMultiplier(TimeUnit unit) { … } // Creates a list of integer values for the given range and multiplier. // This can be used together with ArgsProduct() to allow multiple ranges // with different multipliers. // Example: // ArgsProduct({ // CreateRange(0, 1024, /*multi=*/32), // CreateRange(0, 100, /*multi=*/4), // CreateDenseRange(0, 4, /*step=*/1), // }); BENCHMARK_EXPORT std::vector<int64_t> CreateRange(int64_t lo, int64_t hi, int multi); // Creates a list of integer values for the given range and step. BENCHMARK_EXPORT std::vector<int64_t> CreateDenseRange(int64_t start, int64_t limit, int step); } // namespace benchmark #if defined(_MSC_VER) #pragma warning(pop) #endif #endif // BENCHMARK_BENCHMARK_H_
Codebase Browser
chromium