You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@quickstep.apache.org by hb...@apache.org on 2017/01/17 19:31:44 UTC
[50/51] [partial] incubator-quickstep git commit: Added shell script
to download prerequisite third party libs
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/benchmark/include/benchmark/benchmark.h
----------------------------------------------------------------------
diff --git a/third_party/benchmark/include/benchmark/benchmark.h b/third_party/benchmark/include/benchmark/benchmark.h
deleted file mode 100644
index 5da915e..0000000
--- a/third_party/benchmark/include/benchmark/benchmark.h
+++ /dev/null
@@ -1,537 +0,0 @@
-// 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) {
- while (state.KeepRunning())
- 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";
- while (state.KeepRunning())
- std::string copy(x);
-}
-BENCHMARK(BM_StringCopy);
-
-// Augment the main() program to invoke benchmarks if specified
-// via the --benchmarks 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();
- 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_x()]; char* dst = new char[state.range_x()];
- memset(src, 'x', state.range_x());
- while (state.KeepRunning())
- memcpy(dst, src, state.range_x());
- state.SetBytesProcessed(int64_t_t(state.iterations) * int64(state.range_x()));
- 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) {
- while (state.KeepRunning()) {
- state.PauseTiming();
- set<int> data = ConstructRandomSet(state.range_x());
- state.ResumeTiming();
- for (int j = 0; j < state.rangeY; ++j)
- data.insert(RandomNumber());
- }
-}
-BENCHMARK(BM_SetInsert)
- ->ArgPair(1<<10, 1)
- ->ArgPair(1<<10, 8)
- ->ArgPair(1<<10, 64)
- ->ArgPair(1<<10, 512)
- ->ArgPair(8<<10, 1)
- ->ArgPair(8<<10, 8)
- ->ArgPair(8<<10, 64)
- ->ArgPair(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)->RangePair(1<<10, 8<<10, 1, 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 benchmark::internal::Benchmark* CustomArguments(
- benchmark::internal::Benchmark* b) {
- for (int i = 0; i <= 10; ++i)
- for (int j = 32; j <= 1024*1024; j *= 8)
- b = b->ArgPair(i, j);
- return b;
-}
-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;
- while (state.KeepRunning()) {
- for (int i = state.range_x(); i--; )
- q.push(v);
- for (int e = state.range_x(); e--; )
- q.Wait(&v);
- }
- // actually messages, not bytes:
- state.SetBytesProcessed(
- static_cast<int64_t>(state.iterations())*state.range_x());
-}
-BENCHMARK_TEMPLATE(BM_Sequential, WaitQueue<int>)->Range(1<<0, 1<<10);
-
-In a multithreaded test, it is guaranteed that none of the threads will start
-until all have called KeepRunning, and all will have finished before KeepRunning
-returns false. 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.
- }
- while (state.KeepRunning()) {
- // Run the test as normal.
- }
- if (state.thread_index == 0) {
- // Teardown code here.
- }
-}
-BENCHMARK(BM_MultiThreaded)->Threads(4);
-*/
-
-#ifndef BENCHMARK_BENCHMARK_H_
-#define BENCHMARK_BENCHMARK_H_
-
-#include <stdint.h>
-
-#include <functional>
-#include <memory>
-#include <string>
-#include <thread>
-#include <vector>
-#include <mutex>
-
-#include "macros.h"
-
-namespace benchmark {
-class BenchmarkReporter;
-
-void Initialize(int* argc, const char** argv);
-
-// Otherwise, run all benchmarks specified by the --benchmark_filter flag,
-// and exit after running the benchmarks.
-void RunSpecifiedBenchmarks(const BenchmarkReporter* reporter = nullptr);
-
-// ------------------------------------------------------
-// Routines that can be called from within a benchmark
-
-// If this routine is called, peak memory allocation past this point in the
-// benchmark is reported at the end of the benchmark report line. (It is
-// computed by running the benchmark once with a single iteration and a memory
-// tracer.)
-// TODO(dominic)
-// void MemoryUsage();
-
-// If a particular benchmark is I/O bound, or if for some reason CPU
-// timings are not representative, call this method from within the
-// benchmark routine. If called, the elapsed time will be used to
-// control how many iterations are run, and in the printing of
-// items/second or MB/seconds values. If not called, the cpu time
-// used by the benchmark will be used.
-void UseRealTime();
-
-namespace internal {
-class Benchmark;
-class BenchmarkFamilies;
-}
-
-// State is passed to a running Benchmark and contains state for the
-// benchmark to use.
-class State {
- public:
- // Returns true iff the benchmark should continue through another iteration.
- bool KeepRunning();
-
- void PauseTiming();
- void ResumeTiming();
-
- // Set the number of bytes processed by the current benchmark
- // execution. This routine is typically called once at the end of a
- // throughput oriented benchmark. If this routine is called with a
- // value > 0, the report is printed in MB/sec instead of nanoseconds
- // per iteration.
- //
- // REQUIRES: a benchmark has exited its KeepRunning loop.
- void SetBytesProcessed(int64_t bytes);
-
- // If this routine is called with items > 0, then an items/s
- // label is printed on the benchmark report line for the currently
- // executing benchmark. It is typically called at the end of a processing
- // benchmark where a processing items/second output is desired.
- //
- // REQUIRES: a benchmark has exited its KeepRunning loop.
- void SetItemsProcessed(int64_t items);
-
- // If this routine is called, the specified label is printed at the
- // end of the benchmark report line for the currently executing
- // benchmark. Example:
- // static void BM_Compress(benchmark::State& state) {
- // ...
- // double compress = input_size / output_size;
- // state.SetLabel(StringPrintf("compress:%.1f%%", 100.0*compression));
- // }
- // Produces output that looks like:
- // BM_Compress 50 50 14115038 compress:27.3%
- //
- // REQUIRES: a benchmark has exited its KeepRunning loop.
- void SetLabel(const std::string& label);
-
- // Range arguments for this run. CHECKs if the argument has been set.
- int range_x() const;
- int range_y() const;
-
- int64_t iterations() const { return total_iterations_; }
-
- const int thread_index;
-
- private:
- class FastClock;
- struct SharedState;
- struct ThreadStats;
-
- State(FastClock* clock, SharedState* s, int t);
- bool StartRunning();
- bool FinishInterval();
- bool MaybeStop();
- void NewInterval();
- bool AllStarting();
-
- static void* RunWrapper(void* arg);
- void Run();
- void RunAsThread();
- void Wait();
-
- enum EState {
- STATE_INITIAL, // KeepRunning hasn't been called
- STATE_STARTING, // KeepRunning called, waiting for other threads
- STATE_RUNNING, // Running and being timed
- STATE_STOPPING, // Not being timed but waiting for other threads
- STATE_STOPPED // Stopped
- };
-
- EState state_;
-
- FastClock* clock_;
-
- // State shared by all BenchmarkRun objects that belong to the same
- // BenchmarkInstance
- SharedState* shared_;
-
- std::thread thread_;
-
- // Custom label set by the user.
- std::string label_;
-
- // Each State object goes through a sequence of measurement intervals. By
- // default each interval is approx. 100ms in length. The following stats are
- // kept for each interval.
- int64_t iterations_;
- double start_cpu_;
- double start_time_;
- int64_t stop_time_micros_;
-
- double start_pause_cpu_;
- double pause_cpu_time_;
- double start_pause_real_;
- double pause_real_time_;
-
- // Total number of iterations for all finished runs.
- int64_t total_iterations_;
-
- // Approximate time in microseconds for one interval of execution.
- // Dynamically adjusted as needed.
- int64_t interval_micros_;
-
- // True if the current interval is the continuation of a previous one.
- bool is_continuation_;
-
- std::unique_ptr<ThreadStats> stats_;
-
- friend class internal::Benchmark;
- BENCHMARK_DISALLOW_COPY_AND_ASSIGN(State);
-};
-
-// 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 BenchmarkReporter {
- public:
- struct Context {
- int num_cpus;
- double mhz_per_cpu;
- // std::string cpu_info;
- bool cpu_scaling_enabled;
-
- // The number of chars in the longest benchmark name.
- size_t name_field_width;
- };
-
- struct Run {
- Run()
- : thread_index(-1),
- iterations(1),
- real_accumulated_time(0),
- cpu_accumulated_time(0),
- bytes_per_second(0),
- items_per_second(0),
- max_heapbytes_used(0) {}
-
- std::string benchmark_name;
- std::string report_label;
- int thread_index;
- int64_t iterations;
- double real_accumulated_time;
- double cpu_accumulated_time;
-
- // Zero if not set by benchmark.
- double bytes_per_second;
- double items_per_second;
-
- // This is set to 0.0 if memory tracing is not enabled.
- double max_heapbytes_used;
- };
-
- // Called once for every suite of benchmarks run.
- // The parameter "context" contains information that the
- // reporter may wish to use when generating its report, for example the
- // platform under which the benchmarks are running. The benchmark run is
- // never started if this function returns false, allowing the reporter
- // to skip runs based on the context information.
- virtual bool ReportContext(const Context& context) const = 0;
-
- // Called once for each group of benchmark runs, gives information about
- // cpu-time and heap memory usage during the benchmark run.
- // Note that all the grouped benchmark runs should refer to the same
- // benchmark, thus have the same name.
- virtual void ReportRuns(const std::vector<Run>& report) const = 0;
-
- virtual ~BenchmarkReporter() {}
-};
-
-namespace internal {
-
-typedef std::function<void(State&)> BenchmarkFunction;
-
-// Run all benchmarks whose name is a partial match for the regular
-// expression in "spec". The results of benchmark runs are fed to "reporter".
-void RunMatchingBenchmarks(const std::string& spec,
- const BenchmarkReporter* reporter);
-
-// Extract the list of benchmark names that match the specified regular
-// expression.
-void FindMatchingBenchmarkNames(const std::string& re,
- std::vector<std::string>* benchmark_names);
-
-// ------------------------------------------------------
-// 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 {
- public:
- // The Benchmark takes ownership of the Callback pointed to by f.
- Benchmark(const char* name, BenchmarkFunction f);
-
- ~Benchmark();
-
- // Note: the following methods all return "this" so that multiple
- // method calls can be chained together in one expression.
-
- // Run this benchmark once with "x" as the extra argument passed
- // to the function.
- // REQUIRES: The function passed to the constructor must accept an arg1.
- Benchmark* Arg(int x);
-
- // Run this benchmark once for a number of values picked from the
- // range [start..limit]. (start and limit are always picked.)
- // REQUIRES: The function passed to the constructor must accept an arg1.
- Benchmark* Range(int start, int limit);
-
- // Run this benchmark once for every value in the range [start..limit]
- // REQUIRES: The function passed to the constructor must accept an arg1.
- Benchmark* DenseRange(int start, int limit);
-
- // Run this benchmark once with "x,y" as the extra arguments passed
- // to the function.
- // REQUIRES: The function passed to the constructor must accept arg1,arg2.
- Benchmark* ArgPair(int x, int y);
-
- // Pick a set of values A from the range [lo1..hi1] and a set
- // of values B from the range [lo2..hi2]. Run the benchmark for
- // every pair of values in the cartesian product of A and B
- // (i.e., for all combinations of the values in A and B).
- // REQUIRES: The function passed to the constructor must accept arg1,arg2.
- Benchmark* RangePair(int lo1, int hi1, int lo2, int hi2);
-
- // Pass this benchmark object to *func, which can customize
- // the benchmark by calling various methods like Arg, ArgPair,
- // Threads, etc.
- Benchmark* Apply(void (*func)(Benchmark* benchmark));
-
- // Support for running multiple copies of the same benchmark concurrently
- // in multiple threads. This may be useful when measuring the scaling
- // of some piece of code.
-
- // Run one instance of this benchmark concurrently in t threads.
- Benchmark* Threads(int t);
-
- // Pick a set of values T from [min_threads,max_threads].
- // min_threads and max_threads are always included in T. Run this
- // benchmark once for each value in T. The benchmark run for a
- // particular value t consists of t threads running the benchmark
- // function concurrently. For example, consider:
- // BENCHMARK(Foo)->ThreadRange(1,16);
- // This will run the following benchmarks:
- // Foo in 1 thread
- // Foo in 2 threads
- // Foo in 4 threads
- // Foo in 8 threads
- // Foo in 16 threads
- Benchmark* ThreadRange(int min_threads, int max_threads);
-
- // Equivalent to ThreadRange(NumCPUs(), NumCPUs())
- Benchmark* ThreadPerCpu();
-
- // -------------------------------
- // Following methods are not useful for clients
-
- // Used inside the benchmark implementation
- struct Instance;
-
- // Measure the overhead of an empty benchmark to subtract later.
- static void MeasureOverhead();
-
- private:
- friend class BenchmarkFamilies;
-
- std::vector<Benchmark::Instance> CreateBenchmarkInstances(size_t rangeXindex,
- size_t rangeYindex);
-
- std::string name_;
- BenchmarkFunction function_;
- size_t registration_index_;
- std::vector<int> rangeX_;
- std::vector<int> rangeY_;
- std::vector<int> thread_counts_;
- std::mutex mutex_;
-
- // Special value placed in thread_counts_ to stand for NumCPUs()
- static const int kNumCpuMarker = -1;
-
- // Special value used to indicate that no range is required.
- static const size_t kNoRangeIndex = std::numeric_limits<size_t>::max();
- static const int kNoRange = std::numeric_limits<int>::max();
-
- static void AddRange(std::vector<int>* dst, int lo, int hi, int mult);
- static double MeasurePeakHeapMemory(const Instance& b);
- static void RunInstance(const Instance& b, const BenchmarkReporter* br);
- friend class ::benchmark::State;
- friend struct ::benchmark::internal::Benchmark::Instance;
- friend void ::benchmark::internal::RunMatchingBenchmarks(
- const std::string&, const BenchmarkReporter*);
- BENCHMARK_DISALLOW_COPY_AND_ASSIGN(Benchmark);
-};
-
-// ------------------------------------------------------
-// Internal implementation details follow; please ignore
-
-// Simple reporter that outputs benchmark data to the console. This is the
-// default reporter used by RunSpecifiedBenchmarks().
-class ConsoleReporter : public BenchmarkReporter {
- public:
- virtual bool ReportContext(const Context& context) const;
- virtual void ReportRuns(const std::vector<Run>& reports) const;
-
- private:
- std::string PrintMemoryUsage(double bytes) const;
- virtual void PrintRunData(const Run& report) const;
- mutable size_t name_field_width_;
-};
-
-} // end namespace internal
-} // end namespace benchmark
-
-// ------------------------------------------------------
-// Macro to register benchmarks
-
-// Helpers for generating unique variable names
-#define BENCHMARK_CONCAT(a, b, c) BENCHMARK_CONCAT2(a, b, c)
-#define BENCHMARK_CONCAT2(a, b, c) a##b##c
-
-#define BENCHMARK(n) \
- static ::benchmark::internal::Benchmark* BENCHMARK_CONCAT( \
- __benchmark_, n, __LINE__) BENCHMARK_UNUSED = \
- (new ::benchmark::internal::Benchmark(#n, n))
-
-// Old-style macros
-#define BENCHMARK_WITH_ARG(n, a) BENCHMARK(n)->Arg((a))
-#define BENCHMARK_WITH_ARG2(n, a1, a2) BENCHMARK(n)->ArgPair((a1), (a2))
-#define BENCHMARK_RANGE(n, lo, hi) BENCHMARK(n)->Range((lo), (hi))
-#define BENCHMARK_RANGE2(n, l1, h1, l2, h2) \
- BENCHMARK(n)->RangePair((l1), (h1), (l2), (h2))
-
-// 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_TEMPLATE(n, a) \
- static ::benchmark::internal::Benchmark* BENCHMARK_CONCAT( \
- __benchmark_, n, __LINE__) BENCHMARK_UNUSED = \
- (new ::benchmark::internal::Benchmark(#n "<" #a ">", n<a>))
-
-#define BENCHMARK_TEMPLATE2(n, a, b) \
- static ::benchmark::internal::Benchmark* BENCHMARK_CONCAT( \
- __benchmark_, n, __LINE__) BENCHMARK_UNUSED = \
- (new ::benchmark::internal::Benchmark(#n "<" #a "," #b ">", n<a, b>))
-
-#endif // BENCHMARK_BENCHMARK_H_
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/benchmark/include/benchmark/macros.h
----------------------------------------------------------------------
diff --git a/third_party/benchmark/include/benchmark/macros.h b/third_party/benchmark/include/benchmark/macros.h
deleted file mode 100644
index 5e75ed3..0000000
--- a/third_party/benchmark/include/benchmark/macros.h
+++ /dev/null
@@ -1,44 +0,0 @@
-// 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.
-#ifndef BENCHMARK_MACROS_H_
-#define BENCHMARK_MACROS_H_
-
-#if __cplusplus < 201103L
-# define BENCHMARK_DISALLOW_COPY_AND_ASSIGN(TypeName) \
- TypeName(const TypeName&); \
- TypeName& operator=(const TypeName&)
-#else
-# define BENCHMARK_DISALLOW_COPY_AND_ASSIGN(TypeName) \
- TypeName(const TypeName&) = delete; \
- TypeName& operator=(const TypeName&) = delete
-#endif
-
-#if defined(__GNUC__)
-# define BENCHMARK_UNUSED __attribute__((unused))
-# define BENCHMARK_ALWAYS_INLINE __attribute__((always_inline))
-#elif defined(_MSC_VER) && !defined(__clang__)
-# define BENCHMARK_UNUSED
-# define BENCHMARK_ALWAYS_INLINE __forceinline
-#else
-# define BENCHMARK_UNUSED
-# define BENCHMARK_ALWAYS_INLINE
-#endif
-
-#if defined(__GNUC__)
-# define BENCHMARK_BUILTIN_EXPECT(x, y) __builtin_expect(x, y)
-#else
-# define BENCHMARK_BUILTIN_EXPECT(x, y) x
-#endif
-
-#endif // BENCHMARK_MACROS_H_
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/benchmark/src/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/third_party/benchmark/src/CMakeLists.txt b/third_party/benchmark/src/CMakeLists.txt
deleted file mode 100644
index 5f22510..0000000
--- a/third_party/benchmark/src/CMakeLists.txt
+++ /dev/null
@@ -1,44 +0,0 @@
-# Allow the source files to find headers in src/
-include_directories(${PROJECT_SOURCE_DIR}/src)
-
-# Define the source files
-set(SOURCE_FILES "benchmark.cc" "colorprint.cc" "commandlineflags.cc"
- "log.cc" "sleep.cc" "string_util.cc" "sysinfo.cc"
- "walltime.cc")
-# Determine the correct regular expression engine to use
-if(HAVE_STD_REGEX)
- set(RE_FILES "re_std.cc")
-elseif(HAVE_GNU_POSIX_REGEX)
- set(RE_FILES "re_posix.cc")
-elseif(HAVE_POSIX_REGEX)
- set(RE_FILES "re_posix.cc")
-else()
- message(FATAL_ERROR "Failed to determine the source files for the regular expression backend")
-endif()
-
-# Build the benchmark library
-if (BENCHMARK_ENABLE_SHARED)
- add_library(benchmark SHARED ${SOURCE_FILES} ${RE_FILES})
- find_package(Threads REQUIRED)
- target_link_libraries(benchmark ${CMAKE_THREAD_LIBS_INIT})
-else()
- add_library(benchmark STATIC ${SOURCE_FILES} ${RE_FILES})
-endif()
-
-set_target_properties(benchmark PROPERTIES
- OUTPUT_NAME "benchmark"
- VERSION ${GENERIC_LIB_VERSION}
- SOVERSION ${GENERIC_LIB_SOVERSION}
- )
-
-# Install target (will install the library to specified CMAKE_INSTALL_PREFIX variable)
-install(
- TARGETS benchmark
- ARCHIVE DESTINATION lib
- LIBRARY DESTINATION lib
- COMPONENT library)
-
-install(
- DIRECTORY "${PROJECT_SOURCE_DIR}/include/benchmark"
- DESTINATION include
- FILES_MATCHING PATTERN "*.*h")
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/benchmark/src/arraysize.h
----------------------------------------------------------------------
diff --git a/third_party/benchmark/src/arraysize.h b/third_party/benchmark/src/arraysize.h
deleted file mode 100644
index 3a7c0c7..0000000
--- a/third_party/benchmark/src/arraysize.h
+++ /dev/null
@@ -1,36 +0,0 @@
-#ifndef BENCHMARK_ARRAYSIZE_H_
-#define BENCHMARK_ARRAYSIZE_H_
-
-#include <cstddef>
-
-#include "internal_macros.h"
-
-namespace benchmark {
-namespace internal {
-// The arraysize(arr) macro returns the # of elements in an array arr.
-// The expression is a compile-time constant, and therefore can be
-// used in defining new arrays, for example. If you use arraysize on
-// a pointer by mistake, you will get a compile-time error.
-//
-
-
-// This template function declaration is used in defining arraysize.
-// Note that the function doesn't need an implementation, as we only
-// use its type.
-template <typename T, size_t N>
-char (&ArraySizeHelper(T (&array)[N]))[N];
-
-// That gcc wants both of these prototypes seems mysterious. VC, for
-// its part, can't decide which to use (another mystery). Matching of
-// template overloads: the final frontier.
-#ifndef COMPILER_MSVC
-template <typename T, size_t N>
-char (&ArraySizeHelper(const T (&array)[N]))[N];
-#endif
-
-#define arraysize(array) (sizeof(::benchmark::internal::ArraySizeHelper(array)))
-
-} // end namespace internal
-} // end namespace benchmark
-
-#endif // BENCHMARK_ARRAYSIZE_H_
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/benchmark/src/benchmark.cc
----------------------------------------------------------------------
diff --git a/third_party/benchmark/src/benchmark.cc b/third_party/benchmark/src/benchmark.cc
deleted file mode 100644
index d4f6f1b..0000000
--- a/third_party/benchmark/src/benchmark.cc
+++ /dev/null
@@ -1,1188 +0,0 @@
-// 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.
-
-#include "benchmark/benchmark.h"
-#include "arraysize.h"
-#include "check.h"
-#include "colorprint.h"
-#include "commandlineflags.h"
-#include "internal_macros.h"
-#include "log.h"
-#include "re.h"
-#include "sleep.h"
-#include "stat.h"
-#include "string_util.h"
-#include "sysinfo.h"
-#include "walltime.h"
-
-#include <sys/time.h>
-#include <string.h>
-
-#include <algorithm>
-#include <atomic>
-#include <condition_variable>
-#include <iostream>
-#include <memory>
-#include <mutex>
-#include <thread>
-#include <sstream>
-
-DEFINE_string(benchmark_filter, ".",
- "A regular expression that specifies the set of benchmarks "
- "to execute. If this flag is empty, no benchmarks are run. "
- "If this flag is the string \"all\", all benchmarks linked "
- "into the process are run.");
-
-DEFINE_int32(benchmark_iterations, 0,
- "Total number of iterations per benchmark. 0 means the benchmarks "
- "are time-based.");
-
-DEFINE_double(benchmark_min_time, 0.5,
- "Minimum number of seconds we should run benchmark before "
- "results are considered significant. For cpu-time based "
- "tests, this is the lower bound on the total cpu time "
- "used by all threads that make up the test. For real-time "
- "based tests, this is the lower bound on the elapsed time "
- "of the benchmark execution, regardless of number of "
- "threads.");
-
-DEFINE_bool(benchmark_memory_usage, false,
- "Report memory usage for all benchmarks");
-
-DEFINE_int32(benchmark_repetitions, 1,
- "The number of runs of each benchmark. If greater than 1, the "
- "mean and standard deviation of the runs will be reported.");
-
-DEFINE_int32(v, 0, "The level of verbose logging to output");
-DEFINE_bool(color_print, true, "Enables colorized logging.");
-
-// Will be non-empty if heap checking is turned on, which would
-// invalidate any benchmarks.
-DECLARE_string(heap_check);
-
-// The ""'s catch people who don't pass in a literal for "str"
-#define strliterallen(str) (sizeof("" str "") - 1)
-
-// Must use a string literal for prefix.
-#define memprefix(str, len, prefix) \
- ((((len) >= strliterallen(prefix)) && \
- memcmp(str, prefix, strliterallen(prefix)) == 0) \
- ? str + strliterallen(prefix) \
- : NULL)
-
-namespace benchmark {
-namespace {
-// For non-dense Range, intermediate values are powers of kRangeMultiplier.
-static const int kRangeMultiplier = 8;
-
-std::mutex starting_mutex;
-std::condition_variable starting_cv;
-
-bool running_benchmark = false;
-
-// Should this benchmark report memory usage?
-bool get_memory_usage;
-
-// Should this benchmark base decisions off of real time rather than
-// cpu time?
-bool use_real_time;
-
-// Overhead of an empty benchmark.
-double overhead = 0.0;
-
-// Return prefix to print in front of each reported line
-const char* Prefix() {
-#ifdef NDEBUG
- return "";
-#else
- return "DEBUG: ";
-#endif
-}
-
-// TODO
-// static internal::MallocCounter *benchmark_mc;
-
-bool CpuScalingEnabled() {
- // On Linux, the CPUfreq subsystem exposes CPU information as files on the
- // local file system. If reading the exported files fails, then we may not be
- // running on Linux, so we silently ignore all the read errors.
- for (int cpu = 0, num_cpus = NumCPUs(); cpu < num_cpus; ++cpu) {
- std::stringstream ss;
- ss << "/sys/devices/system/cpu/cpu" << cpu << "/cpufreq/scaling_governor";
- std::string governor_file = ss.str();
- FILE* file = fopen(governor_file.c_str(), "r");
- if (!file) break;
- char buff[16];
- size_t bytes_read = fread(buff, 1, sizeof(buff), file);
- fclose(file);
- if (memprefix(buff, bytes_read, "performance") == NULL) return true;
- }
- return false;
-}
-
-// Given a collection of reports, computes their mean and stddev.
-// REQUIRES: all runs in "reports" must be from the same benchmark.
-void ComputeStats(const std::vector<BenchmarkReporter::Run>& reports,
- BenchmarkReporter::Run* mean_data,
- BenchmarkReporter::Run* stddev_data) {
- // Accumulators.
- Stat1_d real_accumulated_time_stat;
- Stat1_d cpu_accumulated_time_stat;
- Stat1_d items_per_second_stat;
- Stat1_d bytes_per_second_stat;
- Stat1_d iterations_stat;
- Stat1MinMax_d max_heapbytes_used_stat;
-
- // Populate the accumulators.
- for (std::vector<BenchmarkReporter::Run>::const_iterator it = reports.begin();
- it != reports.end(); ++it) {
- CHECK_EQ(reports[0].benchmark_name, it->benchmark_name);
- real_accumulated_time_stat +=
- Stat1_d(it->real_accumulated_time / it->iterations, it->iterations);
- cpu_accumulated_time_stat +=
- Stat1_d(it->cpu_accumulated_time / it->iterations, it->iterations);
- items_per_second_stat += Stat1_d(it->items_per_second, it->iterations);
- bytes_per_second_stat += Stat1_d(it->bytes_per_second, it->iterations);
- iterations_stat += Stat1_d(it->iterations, it->iterations);
- max_heapbytes_used_stat +=
- Stat1MinMax_d(it->max_heapbytes_used, it->iterations);
- }
-
- // Get the data from the accumulator to BenchmarkRunData's. In the
- // computations below we must multiply by the number of iterations since
- // PrintRunData will divide by it.
- mean_data->benchmark_name = reports[0].benchmark_name + "_mean";
- mean_data->iterations = iterations_stat.Mean();
- mean_data->real_accumulated_time = real_accumulated_time_stat.Mean() *
- mean_data->iterations;
- mean_data->cpu_accumulated_time = cpu_accumulated_time_stat.Mean() *
- mean_data->iterations;
- mean_data->bytes_per_second = bytes_per_second_stat.Mean();
- mean_data->items_per_second = items_per_second_stat.Mean();
- mean_data->max_heapbytes_used = max_heapbytes_used_stat.Max();
-
- // Only add label to mean/stddev if it is same for all runs
- mean_data->report_label = reports[0].report_label;
- for (size_t i = 1; i < reports.size(); i++) {
- if (reports[i].report_label != reports[0].report_label) {
- mean_data->report_label = "";
- break;
- }
- }
-
- stddev_data->benchmark_name = reports[0].benchmark_name + "_stddev";
- stddev_data->report_label = mean_data->report_label;
- stddev_data->iterations = iterations_stat.StdDev();
- // The value of iterations_stat.StdDev() above may be 0 if all the repetitions
- // have the same number of iterations. Blindly multiplying by 0 in the
- // computation of real/cpu_accumulated_time below would lead to 0/0 in
- // PrintRunData. So we skip the multiplication in this case and PrintRunData
- // skips the division.
- if (stddev_data->iterations == 0) {
- stddev_data->real_accumulated_time = real_accumulated_time_stat.StdDev();
- stddev_data->cpu_accumulated_time = cpu_accumulated_time_stat.StdDev();
- } else {
- stddev_data->real_accumulated_time = real_accumulated_time_stat.StdDev() *
- stddev_data->iterations;
- stddev_data->cpu_accumulated_time = cpu_accumulated_time_stat.StdDev() *
- stddev_data->iterations;
- }
- stddev_data->bytes_per_second = bytes_per_second_stat.StdDev();
- stddev_data->items_per_second = items_per_second_stat.StdDev();
- stddev_data->max_heapbytes_used = max_heapbytes_used_stat.StdDev();
-}
-} // namespace
-
-namespace internal {
-
-// Class for managing registered benchmarks. Note that each registered
-// benchmark identifies a family of related benchmarks to run.
-class BenchmarkFamilies {
- public:
- static BenchmarkFamilies* GetInstance();
-
- // Registers a benchmark family and returns the index assigned to it.
- size_t AddBenchmark(Benchmark* family);
-
- // Unregisters a family at the given index.
- void RemoveBenchmark(size_t index);
-
- // Extract the list of benchmark instances that match the specified
- // regular expression.
- void FindBenchmarks(const std::string& re,
- std::vector<Benchmark::Instance>* benchmarks);
- private:
- BenchmarkFamilies();
- ~BenchmarkFamilies();
-
- std::vector<Benchmark*> families_;
- std::mutex mutex_;
-};
-
-BenchmarkFamilies* BenchmarkFamilies::GetInstance() {
- static BenchmarkFamilies instance;
- return &instance;
-}
-
-BenchmarkFamilies::BenchmarkFamilies() { }
-
-BenchmarkFamilies::~BenchmarkFamilies() {
- for (internal::Benchmark* family : families_) {
- delete family;
- }
-}
-
-size_t BenchmarkFamilies::AddBenchmark(Benchmark* family) {
- std::lock_guard<std::mutex> l(mutex_);
- // This loop attempts to reuse an entry that was previously removed to avoid
- // unncessary growth of the vector.
- for (size_t index = 0; index < families_.size(); ++index) {
- if (families_[index] == nullptr) {
- families_[index] = family;
- return index;
- }
- }
- size_t index = families_.size();
- families_.push_back(family);
- return index;
-}
-
-void BenchmarkFamilies::RemoveBenchmark(size_t index) {
- std::lock_guard<std::mutex> l(mutex_);
- families_[index] = NULL;
- // Don't shrink families_ here, we might be called by the destructor of
- // BenchmarkFamilies which iterates over the vector.
-}
-
-void BenchmarkFamilies::FindBenchmarks(
- const std::string& spec,
- std::vector<Benchmark::Instance>* benchmarks) {
- // Make regular expression out of command-line flag
- Regex re;
- std::string re_error;
- if (!re.Init(spec, &re_error)) {
- std::cerr << "Could not compile benchmark re: " << re_error << std::endl;
- return;
- }
-
- std::lock_guard<std::mutex> l(mutex_);
- for (internal::Benchmark* family : families_) {
- if (family == nullptr) continue; // Family was deleted
-
- // Match against filter.
- if (!re.Match(family->name_)) {
- VLOG(1) << "Skipping " << family->name_ << "\n";
- continue;
- }
-
- std::vector<Benchmark::Instance> instances;
- if (family->rangeX_.empty() && family->rangeY_.empty()) {
- instances = family->CreateBenchmarkInstances(
- Benchmark::kNoRangeIndex, Benchmark::kNoRangeIndex);
- std::copy(instances.begin(), instances.end(),
- std::back_inserter(*benchmarks));
- } else if (family->rangeY_.empty()) {
- for (size_t x = 0; x < family->rangeX_.size(); ++x) {
- instances = family->CreateBenchmarkInstances(
- x, Benchmark::kNoRangeIndex);
- std::copy(instances.begin(), instances.end(),
- std::back_inserter(*benchmarks));
- }
- } else {
- for (size_t x = 0; x < family->rangeX_.size(); ++x) {
- for (size_t y = 0; y < family->rangeY_.size(); ++y) {
- instances = family->CreateBenchmarkInstances(x, y);
- std::copy(instances.begin(), instances.end(),
- std::back_inserter(*benchmarks));
- }
- }
- }
- }
-}
-
-std::string ConsoleReporter::PrintMemoryUsage(double bytes) const {
- if (!get_memory_usage || bytes < 0.0) return "";
-
- std::stringstream ss;
- ss << " " << HumanReadableNumber(bytes) << "B peak-mem";
- return ss.str();
-}
-
-bool ConsoleReporter::ReportContext(const BenchmarkReporter::Context& context)
- const {
- name_field_width_ = context.name_field_width;
-
- std::cout << "Benchmarking on " << context.num_cpus << " X "
- << context.mhz_per_cpu << " MHz CPU"
- << ((context.num_cpus > 1) ? "s" : "") << "\n";
-
- int remainder_ms;
- std::cout << walltime::Print(walltime::Now(), "%Y/%m/%d-%H:%M:%S",
- true, // use local timezone
- &remainder_ms) << "\n";
-
- // Show details of CPU model, caches, TLBs etc.
- // if (!context.cpu_info.empty())
- // std::cout << "CPU: " << context.cpu_info.c_str();
-
- if (context.cpu_scaling_enabled) {
- std::cerr << "CPU scaling is enabled: Benchmark timings may be noisy.\n";
- }
-
- int output_width = fprintf(stdout, "%s%-*s %10s %10s %10s\n",
- Prefix(), int(name_field_width_), "Benchmark",
- "Time(ns)", "CPU(ns)", "Iterations");
- std::cout << std::string(output_width - 1, '-').c_str() << "\n";
-
- return true;
-}
-
-void ConsoleReporter::ReportRuns(
- const std::vector<BenchmarkReporter::Run>& reports) const {
- for (std::vector<BenchmarkReporter::Run>::const_iterator it = reports.begin();
- it != reports.end(); ++it) {
- CHECK_EQ(reports[0].benchmark_name, it->benchmark_name);
- PrintRunData(*it);
- }
-
- // We don't report aggregated data if there was a single run.
- if (reports.size() < 2) return;
-
- BenchmarkReporter::Run mean_data;
- BenchmarkReporter::Run stddev_data;
- ComputeStats(reports, &mean_data, &stddev_data);
-
- PrintRunData(mean_data);
- PrintRunData(stddev_data);
-}
-
-void ConsoleReporter::PrintRunData(const BenchmarkReporter::Run& result) const {
- // Format bytes per second
- std::string rate;
- if (result.bytes_per_second > 0) {
- std::stringstream ss;
- ss << " " << HumanReadableNumber(result.bytes_per_second) << "B/s";
- rate = ss.str();
- }
-
- // Format items per second
- std::string items;
- if (result.items_per_second > 0) {
- std::stringstream ss;
- ss << " " << HumanReadableNumber(result.items_per_second) << " items/s";
- items = ss.str();
- }
-
- ColorPrintf(COLOR_DEFAULT, "%s", Prefix());
- ColorPrintf(COLOR_GREEN, "%-*s ",
- name_field_width_, result.benchmark_name.c_str());
- if (result.iterations == 0) {
- ColorPrintf(COLOR_YELLOW, "%10.0f %10.0f ",
- result.real_accumulated_time * 1e9,
- result.cpu_accumulated_time * 1e9);
- } else {
- ColorPrintf(COLOR_YELLOW, "%10.0f %10.0f ",
- (result.real_accumulated_time * 1e9) /
- (static_cast<double>(result.iterations)),
- (result.cpu_accumulated_time * 1e9) /
- (static_cast<double>(result.iterations)));
- }
- ColorPrintf(COLOR_CYAN, "%10lld", result.iterations);
- ColorPrintf(COLOR_DEFAULT, "%*s %*s %s %s\n",
- 13, rate.c_str(),
- 18, items.c_str(),
- result.report_label.c_str(),
- PrintMemoryUsage(result.max_heapbytes_used).c_str());
-}
-
-/* TODO(dominic)
-void MemoryUsage() {
- // if (benchmark_mc) {
- // benchmark_mc->Reset();
- //} else {
- get_memory_usage = true;
- //}
-}
-*/
-
-void PrintUsageAndExit() {
- fprintf(stdout,
- "benchmark [--benchmark_filter=<regex>]\n"
- " [--benchmark_iterations=<iterations>]\n"
- " [--benchmark_min_time=<min_time>]\n"
- //" [--benchmark_memory_usage]\n"
- " [--benchmark_repetitions=<num_repetitions>]\n"
- " [--color_print={true|false}]\n"
- " [--v=<verbosity>]\n");
- exit(0);
-}
-
-void ParseCommandLineFlags(int* argc, const char** argv) {
- for (int i = 1; i < *argc; ++i) {
- if (ParseStringFlag(argv[i], "benchmark_filter", &FLAGS_benchmark_filter) ||
- ParseInt32Flag(argv[i], "benchmark_iterations",
- &FLAGS_benchmark_iterations) ||
- ParseDoubleFlag(argv[i], "benchmark_min_time",
- &FLAGS_benchmark_min_time) ||
- // TODO(dominic)
- // ParseBoolFlag(argv[i], "gbenchmark_memory_usage",
- // &FLAGS_gbenchmark_memory_usage) ||
- ParseInt32Flag(argv[i], "benchmark_repetitions",
- &FLAGS_benchmark_repetitions) ||
- ParseBoolFlag(argv[i], "color_print", &FLAGS_color_print) ||
- ParseInt32Flag(argv[i], "v", &FLAGS_v)) {
- for (int j = i; j != *argc; ++j) argv[j] = argv[j + 1];
-
- --(*argc);
- --i;
- } else if (IsFlag(argv[i], "help"))
- PrintUsageAndExit();
- }
-}
-
-} // end namespace internal
-
-// A clock that provides a fast mechanism to check if we're nearly done.
-class State::FastClock {
- public:
- enum Type {
- REAL_TIME,
- CPU_TIME
- };
- explicit FastClock(Type type)
- : type_(type),
- approx_time_(NowMicros()),
- bg_done_(false),
- bg_(BGThreadWrapper, this) { }
-
- ~FastClock() {
- {
- std::unique_lock<std::mutex> l(bg_mutex_);
- bg_done_ = true;
- bg_cond_.notify_one();
- }
- bg_.join();
- }
-
- // Returns true if the current time is guaranteed to be past "when_micros".
- // This method is very fast.
- inline bool HasReached(int64_t when_micros) {
- return std::atomic_load(&approx_time_) >= when_micros;
- }
-
- // Returns the current time in microseconds past the epoch.
- int64_t NowMicros() const {
- double t = 0;
- switch (type_) {
- case REAL_TIME:
- t = walltime::Now();
- break;
- case CPU_TIME:
- t = MyCPUUsage() + ChildrenCPUUsage();
- break;
- }
- return static_cast<int64_t>(t * kNumMicrosPerSecond);
- }
-
- // Reinitialize if necessary (since clock type may be change once benchmark
- // function starts running - see UseRealTime).
- void InitType(Type type) {
- type_ = type;
- std::lock_guard<std::mutex> l(bg_mutex_);
- std::atomic_store(&approx_time_, NowMicros());
- }
-
- private:
- Type type_;
- std::atomic<int64_t> approx_time_; // Last time measurement taken by bg_
- bool bg_done_; // This is used to signal background thread to exit
- std::mutex bg_mutex_;
- std::condition_variable bg_cond_;
- std::thread bg_; // Background thread that updates last_time_ once every ms
-
- static void* BGThreadWrapper(void* that) {
- ((FastClock*)that)->BGThread();
- return NULL;
- }
-
- void BGThread() {
- std::unique_lock<std::mutex> l(bg_mutex_);
- while (!bg_done_)
- {
- // Set timeout to 1 ms.
- bg_cond_.wait_for(l, std::chrono::milliseconds(1));
- std::atomic_store(&approx_time_, NowMicros());
- }
- }
-
- BENCHMARK_DISALLOW_COPY_AND_ASSIGN(FastClock);
-};
-
-struct State::ThreadStats {
- int64_t bytes_processed;
- int64_t items_processed;
-
- ThreadStats() { Reset(); }
-
- void Reset() {
- bytes_processed = 0;
- items_processed = 0;
- }
-
- void Add(const ThreadStats& other) {
- bytes_processed += other.bytes_processed;
- items_processed += other.items_processed;
- }
-};
-
-namespace internal {
-
-// Information kept per benchmark we may want to run
-struct Benchmark::Instance {
- Instance()
- : bm(nullptr),
- threads(1),
- rangeXset(false),
- rangeX(kNoRange),
- rangeYset(false),
- rangeY(kNoRange) {}
-
- std::string name;
- Benchmark* bm;
- int threads; // Number of concurrent threads to use
-
- bool rangeXset;
- int rangeX;
- bool rangeYset;
- int rangeY;
-
- bool multithreaded() const { return !bm->thread_counts_.empty(); }
-};
-
-} // end namespace internal
-
-struct State::SharedState {
- const internal::Benchmark::Instance* instance;
- std::mutex mu;
- std::condition_variable cond;
- int starting; // Number of threads that have entered STARTING state
- int stopping; // Number of threads that have entered STOPPING state
- int exited; // Number of threads that have complete exited
- int threads; // Number of total threads that are running concurrently
- ThreadStats stats;
- std::vector<BenchmarkReporter::Run> runs; // accumulated runs
- std::string label;
-
- explicit SharedState(const internal::Benchmark::Instance* b)
- : instance(b),
- starting(0),
- stopping(0),
- exited(0),
- threads(b == nullptr ? 1 : b->threads) { }
-
- BENCHMARK_DISALLOW_COPY_AND_ASSIGN(SharedState);
-};
-
-namespace internal {
-
-Benchmark::Benchmark(const char* name, BenchmarkFunction f)
- : name_(name), function_(f) {
- registration_index_ = BenchmarkFamilies::GetInstance()->AddBenchmark(this);
-}
-
-Benchmark::~Benchmark() {
- BenchmarkFamilies::GetInstance()->RemoveBenchmark(registration_index_);
-}
-
-Benchmark* Benchmark::Arg(int x) {
- std::lock_guard<std::mutex> l(mutex_);
- rangeX_.push_back(x);
- return this;
-}
-
-Benchmark* Benchmark::Range(int start, int limit) {
- std::vector<int> arglist;
- AddRange(&arglist, start, limit, kRangeMultiplier);
-
- std::lock_guard<std::mutex> l(mutex_);
- for (size_t i = 0; i < arglist.size(); ++i) rangeX_.push_back(arglist[i]);
- return this;
-}
-
-Benchmark* Benchmark::DenseRange(int start, int limit) {
- CHECK_GE(start, 0);
- CHECK_LE(start, limit);
- std::lock_guard<std::mutex> l(mutex_);
- for (int arg = start; arg <= limit; ++arg) rangeX_.push_back(arg);
- return this;
-}
-
-Benchmark* Benchmark::ArgPair(int x, int y) {
- std::lock_guard<std::mutex> l(mutex_);
- rangeX_.push_back(x);
- rangeY_.push_back(y);
- return this;
-}
-
-Benchmark* Benchmark::RangePair(int lo1, int hi1, int lo2, int hi2) {
- std::vector<int> arglist1, arglist2;
- AddRange(&arglist1, lo1, hi1, kRangeMultiplier);
- AddRange(&arglist2, lo2, hi2, kRangeMultiplier);
-
- std::lock_guard<std::mutex> l(mutex_);
- rangeX_.resize(arglist1.size());
- std::copy(arglist1.begin(), arglist1.end(), rangeX_.begin());
- rangeY_.resize(arglist2.size());
- std::copy(arglist2.begin(), arglist2.end(), rangeY_.begin());
- return this;
-}
-
-Benchmark* Benchmark::Apply(void (*custom_arguments)(Benchmark* benchmark)) {
- custom_arguments(this);
- return this;
-}
-
-Benchmark* Benchmark::Threads(int t) {
- CHECK_GT(t, 0);
- std::lock_guard<std::mutex> l(mutex_);
- thread_counts_.push_back(t);
- return this;
-}
-
-Benchmark* Benchmark::ThreadRange(int min_threads, int max_threads) {
- CHECK_GT(min_threads, 0);
- CHECK_GE(max_threads, min_threads);
-
- std::lock_guard<std::mutex> l(mutex_);
- AddRange(&thread_counts_, min_threads, max_threads, 2);
- return this;
-}
-
-Benchmark* Benchmark::ThreadPerCpu() {
- std::lock_guard<std::mutex> l(mutex_);
- thread_counts_.push_back(NumCPUs());
- return this;
-}
-
-void Benchmark::AddRange(std::vector<int>* dst, int lo, int hi, int mult) {
- CHECK_GE(lo, 0);
- CHECK_GE(hi, lo);
-
- // Add "lo"
- dst->push_back(lo);
-
- // Now space out the benchmarks in multiples of "mult"
- for (int32_t i = 1; i < std::numeric_limits<int32_t>::max() / mult;
- i *= mult) {
- if (i >= hi) break;
- if (i > lo) dst->push_back(i);
- }
- // Add "hi" (if different from "lo")
- if (hi != lo) dst->push_back(hi);
-}
-
-std::vector<Benchmark::Instance> Benchmark::CreateBenchmarkInstances(
- size_t rangeXindex, size_t rangeYindex) {
- // Special list of thread counts to use when none are specified
- std::vector<int> one_thread;
- one_thread.push_back(1);
-
- std::vector<Benchmark::Instance> instances;
-
- const bool is_multithreaded = (!thread_counts_.empty());
- const std::vector<int>& thread_counts =
- (is_multithreaded ? thread_counts_ : one_thread);
- for (int num_threads : thread_counts) {
- Instance instance;
- instance.name = name_;
- instance.bm = this;
- instance.threads = num_threads;
-
- if (rangeXindex != kNoRangeIndex) {
- instance.rangeX = rangeX_[rangeXindex];
- instance.rangeXset = true;
- AppendHumanReadable(instance.rangeX, &instance.name);
- }
- if (rangeYindex != kNoRangeIndex) {
- instance.rangeY = rangeY_[rangeYindex];
- instance.rangeYset = true;
- AppendHumanReadable(instance.rangeY, &instance.name);
- }
-
- // Add the number of threads used to the name
- if (is_multithreaded) {
- std::stringstream ss;
- ss << "/threads:" << instance.threads;
- instance.name += ss.str();
- }
-
- instances.push_back(instance);
- }
-
- return instances;
-}
-
-void Benchmark::MeasureOverhead() {
- State::FastClock clock(State::FastClock::CPU_TIME);
- State::SharedState state(nullptr);
- State runner(&clock, &state, 0);
- while (runner.KeepRunning()) {
- }
- overhead = state.runs[0].real_accumulated_time /
- static_cast<double>(state.runs[0].iterations);
- VLOG(1) << "Per-iteration overhead for doing nothing: " << overhead << "\n";
-}
-
-void Benchmark::RunInstance(const Instance& b, const BenchmarkReporter* br) {
- use_real_time = false;
- running_benchmark = true;
- // get_memory_usage = FLAGS_gbenchmark_memory_usage;
- State::FastClock clock(State::FastClock::CPU_TIME);
-
- // Initialize the test runners.
- State::SharedState state(&b);
- {
- std::vector<std::unique_ptr<State>> runners;
- for (int i = 0; i < b.threads; ++i)
- runners.push_back(std::unique_ptr<State>(new State(&clock, &state, i)));
-
- // Run them all.
- for (int i = 0; i < b.threads; ++i) {
- if (b.multithreaded())
- runners[i]->RunAsThread();
- else
- runners[i]->Run();
- }
- if (b.multithreaded()) {
- for (int i = 0; i < b.threads; ++i) runners[i]->Wait();
- }
- }
- /*
- double mem_usage = 0;
- if (get_memory_usage) {
- // Measure memory usage
- Notification mem_done;
- BenchmarkRun mem_run;
- BenchmarkRun::SharedState mem_shared(&b, 1);
- mem_run.Init(&clock, &mem_shared, 0);
- {
- testing::MallocCounter mc(testing::MallocCounter::THIS_THREAD_ONLY);
- benchmark_mc = &mc;
- mem_run.Run(&mem_done);
- mem_done.WaitForNotification();
- benchmark_mc = NULL;
- mem_usage = mc.PeakHeapGrowth();
- }
- }
- */
- running_benchmark = false;
-
- for (BenchmarkReporter::Run& report : state.runs) {
- double seconds = (use_real_time ? report.real_accumulated_time
- : report.cpu_accumulated_time);
- report.benchmark_name = b.name;
- report.report_label = state.label;
- report.bytes_per_second = state.stats.bytes_processed / seconds;
- report.items_per_second = state.stats.items_processed / seconds;
- report.max_heapbytes_used = MeasurePeakHeapMemory(b);
- }
-
- br->ReportRuns(state.runs);
-}
-
-// Run the specified benchmark, measure its peak memory usage, and
-// return the peak memory usage.
-double Benchmark::MeasurePeakHeapMemory(const Instance&) {
- if (!get_memory_usage) return 0.0;
- double bytes = 0.0;
- /* TODO(dominich)
- // Should we do multi-threaded runs?
- const int num_threads = 1;
- const int num_iters = 1;
- {
- // internal::MallocCounter mc(internal::MallocCounter::THIS_THREAD_ONLY);
- running_benchmark = true;
- timer_manager = new TimerManager(1, NULL);
- // benchmark_mc = &mc;
- timer_manager->StartTimer();
-
- b.Run(num_iters);
-
- running_benchmark = false;
- delete timer_manager;
- timer_manager = NULL;
- // benchmark_mc = NULL;
- // bytes = mc.PeakHeapGrowth();
- }
- */
- return bytes;
-}
-
-} // end namespace internal
-
-State::State(FastClock* clock, SharedState* s, int t)
- : thread_index(t),
- state_(STATE_INITIAL),
- clock_(clock),
- shared_(s),
- iterations_(0),
- start_cpu_(0.0),
- start_time_(0.0),
- stop_time_micros_(0.0),
- start_pause_cpu_(0.0),
- pause_cpu_time_(0.0),
- start_pause_real_(0.0),
- pause_real_time_(0.0),
- total_iterations_(0),
- interval_micros_(static_cast<int64_t>(kNumMicrosPerSecond *
- FLAGS_benchmark_min_time /
- FLAGS_benchmark_repetitions)),
- is_continuation_(false),
- stats_(new ThreadStats()) {
- CHECK(clock != nullptr);
- CHECK(s != nullptr);
-}
-
-bool State::KeepRunning() {
- // Fast path
- if ((FLAGS_benchmark_iterations == 0 &&
- !clock_->HasReached(stop_time_micros_ +
- kNumMicrosPerSecond * pause_real_time_)) ||
- iterations_ < FLAGS_benchmark_iterations) {
- ++iterations_;
- return true;
- }
-
- // To block thread 0 until all other threads exit, we have a signal exit
- // point for KeepRunning() to return false. The fast path above always
- // returns true.
- bool ret = false;
- switch (state_) {
- case STATE_INITIAL:
- ret = StartRunning();
- break;
- case STATE_STARTING:
- CHECK(false);
- ret = true;
- break;
- case STATE_RUNNING:
- ret = FinishInterval();
- break;
- case STATE_STOPPING:
- ret = MaybeStop();
- break;
- case STATE_STOPPED:
- CHECK(false);
- ret = true;
- break;
- }
-
- if (!ret && shared_->threads > 1 && thread_index == 0){
- std::unique_lock<std::mutex> l(shared_->mu);
-
- // Block until all other threads have exited. We can then safely cleanup
- // without other threads continuing to access shared variables inside the
- // user-provided run function.
- while (shared_->exited < shared_->threads - 1) {
- shared_->cond.wait(l);
- }
- }
-
- if (ret) {
- ++iterations_;
- }
- return ret;
-}
-
-void State::PauseTiming() {
- start_pause_cpu_ = MyCPUUsage() + ChildrenCPUUsage();
- start_pause_real_ = walltime::Now();
-}
-
-void State::ResumeTiming() {
- pause_cpu_time_ += MyCPUUsage() + ChildrenCPUUsage() - start_pause_cpu_;
- pause_real_time_ += walltime::Now() - start_pause_real_;
-}
-
-void State::SetBytesProcessed(int64_t bytes) {
- CHECK_EQ(STATE_STOPPED, state_);
- std::lock_guard<std::mutex> l(shared_->mu);
- stats_->bytes_processed = bytes;
-}
-
-void State::SetItemsProcessed(int64_t items) {
- CHECK_EQ(STATE_STOPPED, state_);
- std::lock_guard<std::mutex> l(shared_->mu);
- stats_->items_processed = items;
-}
-
-void State::SetLabel(const std::string& label) {
- CHECK_EQ(STATE_STOPPED, state_);
- std::lock_guard<std::mutex> l(shared_->mu);
- shared_->label = label;
-}
-
-int State::range_x() const {
- CHECK(shared_->instance->rangeXset);
- /*
- <<
- "Failed to get range_x as it was not set. Did you register your "
- "benchmark with a range parameter?";
- */
- return shared_->instance->rangeX;
-}
-
-int State::range_y() const {
- CHECK(shared_->instance->rangeYset);
- /* <<
- "Failed to get range_y as it was not set. Did you register your "
- "benchmark with a range parameter?";
- */
- return shared_->instance->rangeY;
-}
-
-bool State::StartRunning() {
- bool last_thread = false;
- {
- std::lock_guard<std::mutex> l(shared_->mu);
- CHECK_EQ(state_, STATE_INITIAL);
- state_ = STATE_STARTING;
- is_continuation_ = false;
- CHECK_LT(shared_->starting, shared_->threads);
- ++shared_->starting;
- last_thread = shared_->starting == shared_->threads;
- }
-
- if (last_thread) {
- clock_->InitType(use_real_time ? FastClock::REAL_TIME
- : FastClock::CPU_TIME);
- {
- std::lock_guard<std::mutex> l(starting_mutex);
- starting_cv.notify_all();
- }
- } else {
- std::unique_lock<std::mutex> l(starting_mutex);
- starting_cv.wait(l);
- }
- CHECK_EQ(state_, STATE_STARTING);
- state_ = STATE_RUNNING;
-
- NewInterval();
- return true;
-}
-
-void State::NewInterval() {
- stop_time_micros_ = clock_->NowMicros() + interval_micros_;
- if (!is_continuation_) {
- VLOG(1) << "Starting new interval; stopping in " << interval_micros_
- << "\n";
- iterations_ = 0;
- pause_cpu_time_ = 0;
- pause_real_time_ = 0;
- start_cpu_ = MyCPUUsage() + ChildrenCPUUsage();
- start_time_ = walltime::Now();
- } else {
- VLOG(1) << "Continuing interval; stopping in " << interval_micros_
- << "\n";
- }
-}
-
-bool State::FinishInterval() {
- if ((FLAGS_benchmark_iterations != 0 &&
- iterations_ <
- FLAGS_benchmark_iterations / FLAGS_benchmark_repetitions) ||
- iterations_ < 1) {
- interval_micros_ *= 2;
- VLOG(1) << "Not enough iterations in interval; "
- << "Trying again for " << interval_micros_ << " useconds.\n";
- is_continuation_ = false;
- NewInterval();
- return true;
- }
-
- BenchmarkReporter::Run data;
- data.iterations = iterations_;
- data.thread_index = thread_index;
-
- const double accumulated_time = walltime::Now() - start_time_;
- const double total_overhead = overhead * iterations_;
- CHECK_LT(pause_real_time_, accumulated_time);
- CHECK_LT(pause_real_time_ + total_overhead, accumulated_time);
- data.real_accumulated_time =
- accumulated_time - (pause_real_time_ + total_overhead);
- data.cpu_accumulated_time = (MyCPUUsage() + ChildrenCPUUsage()) -
- (pause_cpu_time_ + start_cpu_);
- total_iterations_ += iterations_;
-
- bool keep_going = false;
- {
- std::lock_guard<std::mutex> l(shared_->mu);
-
- // Either replace the last or add a new data point.
- if (is_continuation_)
- shared_->runs.back() = data;
- else
- shared_->runs.push_back(data);
-
- if (FLAGS_benchmark_iterations != 0) {
- // If we need more iterations, run another interval as a continuation.
- keep_going = total_iterations_ < FLAGS_benchmark_iterations;
- is_continuation_ = keep_going;
- } else {
- // If this is a repetition, run another interval as a new data point.
- keep_going = shared_->runs.size() <
- static_cast<size_t>(FLAGS_benchmark_repetitions);
- is_continuation_ = !keep_going;
- }
-
- if (!keep_going) {
- ++shared_->stopping;
- if (shared_->stopping < shared_->threads) {
- // Other threads are still running, so continue running but without
- // timing to present an expected background load to the other threads.
- state_ = STATE_STOPPING;
- keep_going = true;
- } else {
- state_ = STATE_STOPPED;
- }
- }
- }
-
- if (state_ == STATE_RUNNING) NewInterval();
- return keep_going;
-}
-
-bool State::MaybeStop() {
- std::lock_guard<std::mutex> l(shared_->mu);
- if (shared_->stopping < shared_->threads) {
- CHECK_EQ(state_, STATE_STOPPING);
- return true;
- }
- state_ = STATE_STOPPED;
- return false;
-}
-
-void State::Run() {
- stats_->Reset();
- shared_->instance->bm->function_(*this);
- {
- std::lock_guard<std::mutex> l(shared_->mu);
- shared_->stats.Add(*stats_);
- }
-}
-
-void State::RunAsThread() {
- thread_ = std::thread(State::RunWrapper, this);
-}
-
-void State::Wait() {
- if (thread_.joinable()) {
- thread_.join();
- }
-}
-
-// static
-void* State::RunWrapper(void* arg) {
- State* that = (State*)arg;
- CHECK(that != nullptr);
- that->Run();
-
- std::lock_guard<std::mutex> l(that->shared_->mu);
-
- that->shared_->exited++;
- if (that->thread_index > 0 &&
- that->shared_->exited == that->shared_->threads - 1) {
- // All threads but thread 0 have exited the user-provided run function.
- // Thread 0 can now wake up and exit.
- that->shared_->cond.notify_one();
- }
-
- return nullptr;
-}
-
-namespace internal {
-
-void RunMatchingBenchmarks(const std::string& spec,
- const BenchmarkReporter* reporter) {
- if (spec.empty()) return;
-
- std::vector<internal::Benchmark::Instance> benchmarks;
- BenchmarkFamilies::GetInstance()->FindBenchmarks(spec, &benchmarks);
-
- // Determine the width of the name field using a minimum width of 10.
- // Also determine max number of threads needed.
- size_t name_field_width = 10;
- for (const internal::Benchmark::Instance& benchmark : benchmarks) {
- // Add width for _stddev and threads:XX
- if (benchmark.threads > 1 && FLAGS_benchmark_repetitions > 1) {
- name_field_width =
- std::max<size_t>(name_field_width, benchmark.name.size() + 17);
- } else if (benchmark.threads > 1) {
- name_field_width =
- std::max<size_t>(name_field_width, benchmark.name.size() + 10);
- } else if (FLAGS_benchmark_repetitions > 1) {
- name_field_width =
- std::max<size_t>(name_field_width, benchmark.name.size() + 7);
- } else {
- name_field_width =
- std::max<size_t>(name_field_width, benchmark.name.size());
- }
- }
-
- // Print header here
- BenchmarkReporter::Context context;
- context.num_cpus = NumCPUs();
- context.mhz_per_cpu = CyclesPerSecond() / 1000000.0f;
- // context.cpu_info = base::CompactCPUIDInfoString();
- context.cpu_scaling_enabled = CpuScalingEnabled();
- context.name_field_width = name_field_width;
-
- if (reporter->ReportContext(context))
- for (internal::Benchmark::Instance& benchmark : benchmarks)
- Benchmark::RunInstance(benchmark, reporter);
-}
-
-void FindMatchingBenchmarkNames(const std::string& spec,
- std::vector<std::string>* benchmark_names) {
- if (spec.empty()) return;
-
- std::vector<internal::Benchmark::Instance> benchmarks;
- BenchmarkFamilies::GetInstance()->FindBenchmarks(spec, &benchmarks);
- std::transform(benchmarks.begin(), benchmarks.end(), benchmark_names->begin(),
- [](const internal::Benchmark::Instance& b) { return b.name; });
-}
-
-} // end namespace internal
-
-void RunSpecifiedBenchmarks(const BenchmarkReporter* reporter /*= nullptr*/) {
- std::string spec = FLAGS_benchmark_filter;
- if (spec.empty() || spec == "all")
- spec = "."; // Regexp that matches all benchmarks
- internal::ConsoleReporter default_reporter;
- internal::RunMatchingBenchmarks(
- spec, reporter == nullptr ? &default_reporter : reporter);
-}
-
-void UseRealTime() { use_real_time = true; }
-
-void Initialize(int* argc, const char** argv) {
- internal::ParseCommandLineFlags(argc, argv);
- internal::SetLogLevel(FLAGS_v);
- // Ensure walltime is initialized by a single thread by forcing the
- // initialization.
- walltime::Now();
- internal::Benchmark::MeasureOverhead();
-}
-
-} // end namespace benchmark
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/benchmark/src/check.h
----------------------------------------------------------------------
diff --git a/third_party/benchmark/src/check.h b/third_party/benchmark/src/check.h
deleted file mode 100644
index 2b04cd2..0000000
--- a/third_party/benchmark/src/check.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef CHECK_H_
-#define CHECK_H_
-
-#include <cstdlib>
-#include <ostream>
-
-#include "internal_macros.h"
-#include "log.h"
-
-namespace benchmark {
-namespace internal {
-
-// CheckHandler is the class constructed by failing CHECK macros. CheckHandler
-// will log information about the failures and abort when it is destructed.
-class CheckHandler {
-public:
- CheckHandler(const char* check, const char* file, const char* func, int line)
- : log_(GetErrorLogInstance())
- {
- log_ << file << ":" << line << ": " << func << ": Check `"
- << check << "' failed. ";
- }
-
- std::ostream& GetLog() {
- return log_;
- }
-
- BENCHMARK_NORETURN ~CheckHandler() {
- log_ << std::endl;
- std::abort();
- }
-
-private:
- std::ostream& log_;
-};
-
-} // end namespace internal
-} // end namespace benchmark
-
-// The CHECK macro returns a std::ostream object that can have extra information
-// written to it.
-#ifndef NDEBUG
-# define CHECK(b) (b ? ::benchmark::internal::GetNullLogInstance() \
- : ::benchmark::internal::CheckHandler( \
- #b, __FILE__, __func__, __LINE__).GetLog())
-#else
-# define CHECK(b) ::benchmark::internal::GetNullLogInstance()
-#endif
-
-#define CHECK_EQ(a, b) CHECK((a) == (b))
-#define CHECK_NE(a, b) CHECK((a) != (b))
-#define CHECK_GE(a, b) CHECK((a) >= (b))
-#define CHECK_LE(a, b) CHECK((a) <= (b))
-#define CHECK_GT(a, b) CHECK((a) > (b))
-#define CHECK_LT(a, b) CHECK((a) < (b))
-
-#endif // CHECK_H_
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/benchmark/src/colorprint.cc
----------------------------------------------------------------------
diff --git a/third_party/benchmark/src/colorprint.cc b/third_party/benchmark/src/colorprint.cc
deleted file mode 100644
index 783797b..0000000
--- a/third_party/benchmark/src/colorprint.cc
+++ /dev/null
@@ -1,111 +0,0 @@
-// 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.
-
-#include "colorprint.h"
-
-#include <cstdarg>
-
-#include "commandlineflags.h"
-#include "internal_macros.h"
-
-DECLARE_bool(color_print);
-
-namespace benchmark {
-namespace {
-#ifdef OS_WINDOWS
-typedef WORD PlatformColorCode;
-#else
-typedef const char* PlatformColorCode;
-#endif
-
-PlatformColorCode GetPlatformColorCode(LogColor color) {
-#ifdef OS_WINDOWS
- switch (color) {
- case COLOR_RED:
- return FOREGROUND_RED;
- case COLOR_GREEN:
- return FOREGROUND_GREEN;
- case COLOR_YELLOW:
- return FOREGROUND_RED | FOREGROUND_GREEN;
- case COLOR_BLUE:
- return FOREGROUND_BLUE;
- case COLOR_MAGENTA:
- return FOREGROUND_BLUE | FOREGROUND_RED;
- case COLOR_CYAN:
- return FOREGROUND_BLUE | FOREGROUND_GREEN;
- case COLOR_WHITE: // fall through to default
- default:
- return 0;
- }
-#else
- switch (color) {
- case COLOR_RED:
- return "1";
- case COLOR_GREEN:
- return "2";
- case COLOR_YELLOW:
- return "3";
- case COLOR_BLUE:
- return "4";
- case COLOR_MAGENTA:
- return "5";
- case COLOR_CYAN:
- return "6";
- case COLOR_WHITE:
- return "7";
- default:
- return NULL;
- };
-#endif
-}
-} // end namespace
-
-void ColorPrintf(LogColor color, const char* fmt, ...) {
- va_list args;
- va_start(args, fmt);
-
- if (!FLAGS_color_print) {
- vprintf(fmt, args);
- va_end(args);
- return;
- }
-
-#ifdef OS_WINDOWS
- const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE);
-
- // Gets the current text color.
- CONSOLE_SCREEN_BUFFER_INFO buffer_info;
- GetConsoleScreenBufferInfo(stdout_handle, &buffer_info);
- const WORD old_color_attrs = buffer_info.wAttributes;
-
- // We need to flush the stream buffers into the console before each
- // SetConsoleTextAttribute call lest it affect the text that is already
- // printed but has not yet reached the console.
- fflush(stdout);
- SetConsoleTextAttribute(stdout_handle,
- GetPlatformColorCode(color) | FOREGROUND_INTENSITY);
- vprintf(fmt, args);
-
- fflush(stdout);
- // Restores the text color.
- SetConsoleTextAttribute(stdout_handle, old_color_attrs);
-#else
- const char* color_code = GetPlatformColorCode(color);
- if (color_code) fprintf(stdout, "\033[0;3%sm", color_code);
- vprintf(fmt, args);
- printf("\033[m"); // Resets the terminal to default.
-#endif
- va_end(args);
-}
-} // end namespace benchmark
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/benchmark/src/colorprint.h
----------------------------------------------------------------------
diff --git a/third_party/benchmark/src/colorprint.h b/third_party/benchmark/src/colorprint.h
deleted file mode 100644
index 54d1f66..0000000
--- a/third_party/benchmark/src/colorprint.h
+++ /dev/null
@@ -1,19 +0,0 @@
-#ifndef BENCHMARK_COLORPRINT_H_
-#define BENCHMARK_COLORPRINT_H_
-
-namespace benchmark {
-enum LogColor {
- COLOR_DEFAULT,
- COLOR_RED,
- COLOR_GREEN,
- COLOR_YELLOW,
- COLOR_BLUE,
- COLOR_MAGENTA,
- COLOR_CYAN,
- COLOR_WHITE
-};
-
-void ColorPrintf(LogColor color, const char* fmt, ...);
-} // end namespace benchmark
-
-#endif // BENCHMARK_COLORPRINT_H_
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/benchmark/src/commandlineflags.cc
----------------------------------------------------------------------
diff --git a/third_party/benchmark/src/commandlineflags.cc b/third_party/benchmark/src/commandlineflags.cc
deleted file mode 100644
index 06246e9..0000000
--- a/third_party/benchmark/src/commandlineflags.cc
+++ /dev/null
@@ -1,220 +0,0 @@
-// 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.
-
-#include "commandlineflags.h"
-
-#include <cstdlib>
-#include <cstring>
-#include <iostream>
-#include <limits>
-
-namespace benchmark {
-// Parses 'str' for a 32-bit signed integer. If successful, writes
-// the result to *value and returns true; otherwise leaves *value
-// unchanged and returns false.
-bool ParseInt32(const std::string& src_text, const char* str, int32_t* value) {
- // Parses the environment variable as a decimal integer.
- char* end = NULL;
- const long long_value = strtol(str, &end, 10); // NOLINT
-
- // Has strtol() consumed all characters in the string?
- if (*end != '\0') {
- // No - an invalid character was encountered.
- std::cerr << src_text << " is expected to be a 32-bit integer, "
- << "but actually has value \"" << str << "\".\n";
- return false;
- }
-
- // Is the parsed value in the range of an Int32?
- const int32_t result = static_cast<int32_t>(long_value);
- if (long_value == std::numeric_limits<long>::max() ||
- long_value == std::numeric_limits<long>::min() ||
- // The parsed value overflows as a long. (strtol() returns
- // LONG_MAX or LONG_MIN when the input overflows.)
- result != long_value
- // The parsed value overflows as an Int32.
- ) {
- std::cerr << src_text << " is expected to be a 32-bit integer, "
- << "but actually has value \"" << str << "\", "
- << "which overflows.\n";
- return false;
- }
-
- *value = result;
- return true;
-}
-
-// Parses 'str' for a double. If successful, writes the result to *value and
-// returns true; otherwise leaves *value unchanged and returns false.
-bool ParseDouble(const std::string& src_text, const char* str, double* value) {
- // Parses the environment variable as a decimal integer.
- char* end = NULL;
- const double double_value = strtod(str, &end); // NOLINT
-
- // Has strtol() consumed all characters in the string?
- if (*end != '\0') {
- // No - an invalid character was encountered.
- std::cerr << src_text << " is expected to be a double, "
- << "but actually has value \"" << str << "\".\n";
- return false;
- }
-
- *value = double_value;
- return true;
-}
-
-inline const char* GetEnv(const char* name) {
-#if defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
- // Environment variables which we programmatically clear will be set to the
- // empty string rather than unset (NULL). Handle that case.
- const char* const env = getenv(name);
- return (env != NULL && env[0] != '\0') ? env : NULL;
-#else
- return getenv(name);
-#endif
-}
-
-// Returns the name of the environment variable corresponding to the
-// given flag. For example, FlagToEnvVar("foo") will return
-// "BENCHMARK_FOO" in the open-source version.
-static std::string FlagToEnvVar(const char* flag) {
- const std::string flag_str(flag);
-
- std::string env_var;
- for (size_t i = 0; i != flag_str.length(); ++i)
- env_var += ::toupper(flag_str.c_str()[i]);
-
- return "BENCHMARK_" + env_var;
-}
-
-// Reads and returns the Boolean environment variable corresponding to
-// the given flag; if it's not set, returns default_value.
-//
-// The value is considered true iff it's not "0".
-bool BoolFromEnv(const char* flag, bool default_value) {
- const std::string env_var = FlagToEnvVar(flag);
- const char* const string_value = GetEnv(env_var.c_str());
- return string_value == NULL ? default_value : strcmp(string_value, "0") != 0;
-}
-
-// Reads and returns a 32-bit integer stored in the environment
-// variable corresponding to the given flag; if it isn't set or
-// doesn't represent a valid 32-bit integer, returns default_value.
-int32_t Int32FromEnv(const char* flag, int32_t default_value) {
- const std::string env_var = FlagToEnvVar(flag);
- const char* const string_value = GetEnv(env_var.c_str());
- if (string_value == NULL) {
- // The environment variable is not set.
- return default_value;
- }
-
- int32_t result = default_value;
- if (!ParseInt32(std::string("Environment variable ") + env_var, string_value,
- &result)) {
- std::cout << "The default value " << default_value << " is used.\n";
- return default_value;
- }
-
- return result;
-}
-
-// Reads and returns the string environment variable corresponding to
-// the given flag; if it's not set, returns default_value.
-const char* StringFromEnv(const char* flag, const char* default_value) {
- const std::string env_var = FlagToEnvVar(flag);
- const char* const value = GetEnv(env_var.c_str());
- return value == NULL ? default_value : value;
-}
-
-// Parses a string as a command line flag. The string should have
-// the format "--flag=value". When def_optional is true, the "=value"
-// part can be omitted.
-//
-// Returns the value of the flag, or NULL if the parsing failed.
-const char* ParseFlagValue(const char* str, const char* flag,
- bool def_optional) {
- // str and flag must not be NULL.
- if (str == NULL || flag == NULL) return NULL;
-
- // The flag must start with "--".
- const std::string flag_str = std::string("--") + std::string(flag);
- const size_t flag_len = flag_str.length();
- if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL;
-
- // Skips the flag name.
- const char* flag_end = str + flag_len;
-
- // When def_optional is true, it's OK to not have a "=value" part.
- if (def_optional && (flag_end[0] == '\0')) return flag_end;
-
- // If def_optional is true and there are more characters after the
- // flag name, or if def_optional is false, there must be a '=' after
- // the flag name.
- if (flag_end[0] != '=') return NULL;
-
- // Returns the string after "=".
- return flag_end + 1;
-}
-
-bool ParseBoolFlag(const char* str, const char* flag, bool* value) {
- // Gets the value of the flag as a string.
- const char* const value_str = ParseFlagValue(str, flag, true);
-
- // Aborts if the parsing failed.
- if (value_str == NULL) return false;
-
- // Converts the string value to a bool.
- *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F');
- return true;
-}
-
-bool ParseInt32Flag(const char* str, const char* flag, int32_t* value) {
- // Gets the value of the flag as a string.
- const char* const value_str = ParseFlagValue(str, flag, false);
-
- // Aborts if the parsing failed.
- if (value_str == NULL) return false;
-
- // Sets *value to the value of the flag.
- return ParseInt32(std::string("The value of flag --") + flag, value_str,
- value);
-}
-
-bool ParseDoubleFlag(const char* str, const char* flag, double* value) {
- // Gets the value of the flag as a string.
- const char* const value_str = ParseFlagValue(str, flag, false);
-
- // Aborts if the parsing failed.
- if (value_str == NULL) return false;
-
- // Sets *value to the value of the flag.
- return ParseDouble(std::string("The value of flag --") + flag, value_str,
- value);
-}
-
-bool ParseStringFlag(const char* str, const char* flag, std::string* value) {
- // Gets the value of the flag as a string.
- const char* const value_str = ParseFlagValue(str, flag, false);
-
- // Aborts if the parsing failed.
- if (value_str == NULL) return false;
-
- *value = value_str;
- return true;
-}
-
-bool IsFlag(const char* str, const char* flag) {
- return (ParseFlagValue(str, flag, true) != NULL);
-}
-} // end namespace benchmark
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/benchmark/src/commandlineflags.h
----------------------------------------------------------------------
diff --git a/third_party/benchmark/src/commandlineflags.h b/third_party/benchmark/src/commandlineflags.h
deleted file mode 100644
index 34b9c6f..0000000
--- a/third_party/benchmark/src/commandlineflags.h
+++ /dev/null
@@ -1,76 +0,0 @@
-#ifndef BENCHMARK_COMMANDLINEFLAGS_H_
-#define BENCHMARK_COMMANDLINEFLAGS_H_
-
-#include <cstdint>
-#include <string>
-
-// Macro for referencing flags.
-#define FLAG(name) FLAGS_##name
-
-// Macros for declaring flags.
-#define DECLARE_bool(name) extern bool FLAG(name)
-#define DECLARE_int32(name) extern int32_t FLAG(name)
-#define DECLARE_int64(name) extern int64_t FLAG(name)
-#define DECLARE_double(name) extern double FLAG(name)
-#define DECLARE_string(name) extern std::string FLAG(name)
-
-// Macros for defining flags.
-#define DEFINE_bool(name, default_val, doc) bool FLAG(name) = (default_val)
-#define DEFINE_int32(name, default_val, doc) int32_t FLAG(name) = (default_val)
-#define DEFINE_int64(name, default_val, doc) int64_t FLAG(name) = (default_val)
-#define DEFINE_double(name, default_val, doc) double FLAG(name) = (default_val)
-#define DEFINE_string(name, default_val, doc) \
- std::string FLAG(name) = (default_val)
-
-namespace benchmark {
-// Parses 'str' for a 32-bit signed integer. If successful, writes the result
-// to *value and returns true; otherwise leaves *value unchanged and returns
-// false.
-bool ParseInt32(const std::string& src_text, const char* str, int32_t* value);
-
-// Parses a bool/Int32/string from the environment variable
-// corresponding to the given Google Test flag.
-bool BoolFromEnv(const char* flag, bool default_val);
-int32_t Int32FromEnv(const char* flag, int32_t default_val);
-double DoubleFromEnv(const char* flag, double default_val);
-const char* StringFromEnv(const char* flag, const char* default_val);
-
-// Parses a string for a bool flag, in the form of either
-// "--flag=value" or "--flag".
-//
-// In the former case, the value is taken as true as long as it does
-// not start with '0', 'f', or 'F'.
-//
-// In the latter case, the value is taken as true.
-//
-// On success, stores the value of the flag in *value, and returns
-// true. On failure, returns false without changing *value.
-bool ParseBoolFlag(const char* str, const char* flag, bool* value);
-
-// Parses a string for an Int32 flag, in the form of
-// "--flag=value".
-//
-// On success, stores the value of the flag in *value, and returns
-// true. On failure, returns false without changing *value.
-bool ParseInt32Flag(const char* str, const char* flag, int32_t* value);
-
-// Parses a string for a Double flag, in the form of
-// "--flag=value".
-//
-// On success, stores the value of the flag in *value, and returns
-// true. On failure, returns false without changing *value.
-bool ParseDoubleFlag(const char* str, const char* flag, double* value);
-
-// Parses a string for a string flag, in the form of
-// "--flag=value".
-//
-// On success, stores the value of the flag in *value, and returns
-// true. On failure, returns false without changing *value.
-bool ParseStringFlag(const char* str, const char* flag, std::string* value);
-
-// Returns true if the string matches the flag.
-bool IsFlag(const char* str, const char* flag);
-
-} // end namespace benchmark
-
-#endif // BENCHMARK_COMMANDLINEFLAGS_H_
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/benchmark/src/cycleclock.h
----------------------------------------------------------------------
diff --git a/third_party/benchmark/src/cycleclock.h b/third_party/benchmark/src/cycleclock.h
deleted file mode 100644
index 5b28417..0000000
--- a/third_party/benchmark/src/cycleclock.h
+++ /dev/null
@@ -1,134 +0,0 @@
-// ----------------------------------------------------------------------
-// CycleClock
-// A CycleClock tells you the current time in Cycles. The "time"
-// is actually time since power-on. This is like time() but doesn't
-// involve a system call and is much more precise.
-//
-// NOTE: Not all cpu/platform/kernel combinations guarantee that this
-// clock increments at a constant rate or is synchronized across all logical
-// cpus in a system.
-//
-// If you need the above guarantees, please consider using a different
-// API. There are efforts to provide an interface which provides a millisecond
-// granularity and implemented as a memory read. A memory read is generally
-// cheaper than the CycleClock for many architectures.
-//
-// Also, in some out of order CPU implementations, the CycleClock is not
-// serializing. So if you're trying to count at cycles granularity, your
-// data might be inaccurate due to out of order instruction execution.
-// ----------------------------------------------------------------------
-
-#ifndef BENCHMARK_CYCLECLOCK_H_
-#define BENCHMARK_CYCLECLOCK_H_
-
-#include <cstdint>
-
-#include "benchmark/macros.h"
-#include "internal_macros.h"
-
-#if defined(OS_MACOSX)
-#include <mach/mach_time.h>
-#endif
-// For MSVC, we want to use '_asm rdtsc' when possible (since it works
-// with even ancient MSVC compilers), and when not possible the
-// __rdtsc intrinsic, declared in <intrin.h>. Unfortunately, in some
-// environments, <windows.h> and <intrin.h> have conflicting
-// declarations of some other intrinsics, breaking compilation.
-// Therefore, we simply declare __rdtsc ourselves. See also
-// http://connect.microsoft.com/VisualStudio/feedback/details/262047
-#if defined(COMPILER_MSVC) && !defined(_M_IX86)
-extern "C" uint64_t __rdtsc();
-#pragma intrinsic(__rdtsc)
-#endif
-#include <sys/time.h>
-
-namespace benchmark {
-// NOTE: only i386 and x86_64 have been well tested.
-// PPC, sparc, alpha, and ia64 are based on
-// http://peter.kuscsik.com/wordpress/?p=14
-// with modifications by m3b. See also
-// https://setisvn.ssl.berkeley.edu/svn/lib/fftw-3.0.1/kernel/cycle.h
-namespace cycleclock {
-// This should return the number of cycles since power-on. Thread-safe.
-inline BENCHMARK_ALWAYS_INLINE int64_t Now() {
-#if defined(OS_MACOSX)
- // this goes at the top because we need ALL Macs, regardless of
- // architecture, to return the number of "mach time units" that
- // have passed since startup. See sysinfo.cc where
- // InitializeSystemInfo() sets the supposed cpu clock frequency of
- // macs to the number of mach time units per second, not actual
- // CPU clock frequency (which can change in the face of CPU
- // frequency scaling). Also note that when the Mac sleeps, this
- // counter pauses; it does not continue counting, nor does it
- // reset to zero.
- return mach_absolute_time();
-#elif defined(__i386__)
- int64_t ret;
- __asm__ volatile("rdtsc" : "=A"(ret));
- return ret;
-#elif defined(__x86_64__) || defined(__amd64__)
- uint64_t low, high;
- __asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
- return (high << 32) | low;
-#elif defined(__powerpc__) || defined(__ppc__)
- // This returns a time-base, which is not always precisely a cycle-count.
- int64_t tbl, tbu0, tbu1;
- asm("mftbu %0" : "=r"(tbu0));
- asm("mftb %0" : "=r"(tbl));
- asm("mftbu %0" : "=r"(tbu1));
- tbl &= -static_cast<int64>(tbu0 == tbu1);
- // high 32 bits in tbu1; low 32 bits in tbl (tbu0 is garbage)
- return (tbu1 << 32) | tbl;
-#elif defined(__sparc__)
- int64_t tick;
- asm(".byte 0x83, 0x41, 0x00, 0x00");
- asm("mov %%g1, %0" : "=r"(tick));
- return tick;
-#elif defined(__ia64__)
- int64_t itc;
- asm("mov %0 = ar.itc" : "=r"(itc));
- return itc;
-#elif defined(COMPILER_MSVC) && defined(_M_IX86)
- // Older MSVC compilers (like 7.x) don't seem to support the
- // __rdtsc intrinsic properly, so I prefer to use _asm instead
- // when I know it will work. Otherwise, I'll use __rdtsc and hope
- // the code is being compiled with a non-ancient compiler.
- _asm rdtsc
-#elif defined(COMPILER_MSVC)
- return __rdtsc();
-#elif defined(__ARM_ARCH)
-#if (__ARM_ARCH >= 6) // V6 is the earliest arch that has a standard cyclecount
- uint32_t pmccntr;
- uint32_t pmuseren;
- uint32_t pmcntenset;
- // Read the user mode perf monitor counter access permissions.
- asm("mrc p15, 0, %0, c9, c14, 0" : "=r"(pmuseren));
- if (pmuseren & 1) { // Allows reading perfmon counters for user mode code.
- asm("mrc p15, 0, %0, c9, c12, 1" : "=r"(pmcntenset));
- if (pmcntenset & 0x80000000ul) { // Is it counting?
- asm("mrc p15, 0, %0, c9, c13, 0" : "=r"(pmccntr));
- // The counter is set up to count every 64th cycle
- return static_cast<int64_t>(pmccntr) * 64; // Should optimize to << 6
- }
- }
-#endif
- struct timeval tv;
- gettimeofday(&tv, NULL);
- return static_cast<int64_t>(tv.tv_sec) * 1000000 + tv.tv_usec;
-#elif defined(__mips__)
- // mips apparently only allows rdtsc for superusers, so we fall
- // back to gettimeofday. It's possible clock_gettime would be better.
- struct timeval tv;
- gettimeofday(&tv, NULL);
- return static_cast<int64_t>(tv.tv_sec) * 1000000 + tv.tv_usec;
-#else
-// The soft failover to a generic implementation is automatic only for ARM.
-// For other platforms the developer is expected to make an attempt to create
-// a fast implementation and use generic version if nothing better is available.
-#error You need to define CycleTimer for your OS and CPU
-#endif
-}
-} // end namespace cycleclock
-} // end namespace benchmark
-
-#endif // BENCHMARK_CYCLECLOCK_H_
http://git-wip-us.apache.org/repos/asf/incubator-quickstep/blob/bb3371c3/third_party/benchmark/src/internal_macros.h
----------------------------------------------------------------------
diff --git a/third_party/benchmark/src/internal_macros.h b/third_party/benchmark/src/internal_macros.h
deleted file mode 100644
index 6667a2e..0000000
--- a/third_party/benchmark/src/internal_macros.h
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifndef BENCHMARK_INTERNAL_MACROS_H_
-#define BENCHMARK_INTERNAL_MACROS_H_
-
-#include "benchmark/macros.h"
-
-#ifndef __has_feature
-# define __has_feature(x) 0
-#endif
-
-#if __has_feature(cxx_attributes)
-# define BENCHMARK_NORETURN [[noreturn]]
-#elif defined(__GNUC__)
-# define BENCHMARK_NORETURN __attribute__((noreturn))
-#else
-# define BENCHMARK_NORETURN
-#endif
-
-#if defined(__CYGWIN__)
-# define OS_CYGWIN 1
-#elif defined(_WIN32)
-# define OS_WINDOWS 1
-#elif defined(__APPLE__)
-// TODO(ericwf) This doesn't actually check that it is a Mac OSX system. Just
-// that it is an apple system.
-# define OS_MACOSX 1
-#elif defined(__FreeBSD__)
-# define OS_FREEBSD 1
-#elif defined(__linux__)
-# define OS_LINUX 1
-#endif
-
-#if defined(__clang__)
-# define COMPILER_CLANG
-#elif defined(_MSC_VER)
-# define COMPILER_MSVC
-#elif defined(__GNUC__)
-# define COMPILER_GCC
-#endif
-
-#endif // BENCHMARK_INTERNAL_MACROS_H_