Merge branch 'master' into remove-check

README.md

@@ -44,7 +44,8 @@ static void BM_memcpy(benchmark::State& state) {
   memset(src, 'x', state.range_x());
   while (state.KeepRunning())
     memcpy(dst, src, state.range_x());
-  state.SetBytesProcessed(int64_t(state.iterations) * int64_t(state.range_x()));
+  state.SetBytesProcessed(int64_t(state.iterations()) *
+                          int64_t(state.range_x()));
   delete[] src;
   delete[] dst;
 }

include/benchmark/benchmark_api.h

@@ -42,7 +42,8 @@ static void BM_memcpy(benchmark::State& state) {
   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()));
+  state.SetBytesProcessed(int64_t(state.iterations()) *
+                          int64_t(state.range_x()));
   delete[] src; delete[] dst;
 }
 BENCHMARK(BM_memcpy)->Arg(8)->Arg(64)->Arg(512)->Arg(1<<10)->Arg(8<<10);
@@ -89,8 +90,7 @@ BENCHMARK(BM_SetInsert)->RangePair(1<<10, 8<<10, 1, 512);
 static void 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;
+      b->ArgPair(i, j);
 }
 BENCHMARK(BM_SetInsert)->Apply(CustomArguments);
 
@@ -151,7 +151,7 @@ BENCHMARK(BM_MultiThreaded)->Threads(4);
 namespace benchmark {
 class BenchmarkReporter;
 
-void Initialize(int* argc, const char** argv);
+void Initialize(int* argc, char** argv);
 
 // Otherwise, run all benchmarks specified by the --benchmark_filter flag,
 // and exit after running the benchmarks.
@@ -593,10 +593,10 @@ protected:                                                  \
 
 
 // Helper macro to create a main routine in a test that runs the benchmarks
-#define BENCHMARK_MAIN()                             \
-  int main(int argc, const char** argv) {            \
-    ::benchmark::Initialize(&argc, argv);            \
-    ::benchmark::RunSpecifiedBenchmarks();           \
+#define BENCHMARK_MAIN()                   \
+  int main(int argc, char** argv) {        \
+    ::benchmark::Initialize(&argc, argv);  \
+    ::benchmark::RunSpecifiedBenchmarks(); \
   }
 
 #endif  // BENCHMARK_BENCHMARK_API_H_

include/benchmark/macros.h

@@ -27,12 +27,16 @@
 #if defined(__GNUC__)
 # define BENCHMARK_UNUSED __attribute__((unused))
 # define BENCHMARK_ALWAYS_INLINE __attribute__((always_inline))
+# define BENCHMARK_NOEXCEPT noexcept
 #elif defined(_MSC_VER) && !defined(__clang__)
 # define BENCHMARK_UNUSED
 # define BENCHMARK_ALWAYS_INLINE __forceinline
+# define BENCHMARK_NOEXCEPT
+# define __func__ __FUNCTION__
 #else
 # define BENCHMARK_UNUSED
 # define BENCHMARK_ALWAYS_INLINE
+# define BENCHMARK_NOEXCEPT
 #endif
 
 #if defined(__GNUC__)

include/benchmark/reporter.h

@@ -49,7 +49,7 @@ class BenchmarkReporter {
 
     std::string benchmark_name;
     std::string report_label;  // Empty if not set by benchmark.
-    size_t iterations;
+    int64_t iterations;
     double real_accumulated_time;
     double cpu_accumulated_time;
 

src/benchmark.cc

@@ -15,11 +15,11 @@
 #include "benchmark/benchmark.h"
 #include "internal_macros.h"
 
-#include <sys/time.h>
 #ifndef OS_WINDOWS
+#include <sys/time.h>
 #include <sys/resource.h>
-#endif
 #include <unistd.h>
+#endif
 
 #include <cstdlib>
 #include <cstring>
@@ -863,7 +863,7 @@ void PrintUsageAndExit() {
   exit(0);
 }
 
-void ParseCommandLineFlags(int* argc, const char** argv) {
+void ParseCommandLineFlags(int* argc, char** argv) {
   using namespace benchmark;
   for (int i = 1; i < *argc; ++i) {
     if (
@@ -904,7 +904,7 @@ Benchmark* RegisterBenchmarkInternal(Benchmark* bench) {
 
 } // end namespace internal
 
-void Initialize(int* argc, const char** argv) {
+void Initialize(int* argc, char** argv) {
   internal::ParseCommandLineFlags(argc, argv);
   internal::SetLogLevel(FLAGS_v);
   // TODO remove this. It prints some output the first time it is called.

src/cycleclock.h

@@ -40,7 +40,10 @@
 extern "C" uint64_t __rdtsc();
 #pragma intrinsic(__rdtsc)
 #endif
+
+#ifndef OS_WINDOWS
 #include <sys/time.h>
+#endif
 
 namespace benchmark {
 // NOTE: only i386 and x86_64 have been well tested.

src/json_reporter.cc

@@ -44,12 +44,6 @@ std::string FormatKV(std::string const& key, int64_t value) {
   return ss.str();
 }
 
-std::string FormatKV(std::string const& key, std::size_t value) {
-  std::stringstream ss;
-  ss << '"' << key << "\": " << value;
-  return ss.str();
-}
-
 int64_t RoundDouble(double v) {
     return static_cast<int64_t>(v + 0.5);
 }

src/reporter.cc

@@ -33,7 +33,7 @@ void BenchmarkReporter::ComputeStats(
   Stat1_d items_per_second_stat;
   // All repetitions should be run with the same number of iterations so we
   // can take this information from the first benchmark.
-  std::size_t const run_iterations = reports.front().iterations;
+  int64_t const run_iterations = reports.front().iterations;
 
   // Populate the accumulators.
   for (Run const& run : reports) {

src/string_util.h

@@ -4,6 +4,7 @@
 #include <string>
 #include <sstream>
 #include <utility>
+#include "internal_macros.h"
 
 namespace benchmark {
 
@@ -14,7 +15,7 @@ std::string HumanReadableNumber(double n);
 std::string StringPrintF(const char* format, ...);
 
 inline std::ostream&
-StringCatImp(std::ostream& out) noexcept
+StringCatImp(std::ostream& out) BENCHMARK_NOEXCEPT
 {
   return out;
 }

src/sysinfo.cc

@@ -305,7 +305,7 @@ static double MyCPUUsageRUsage() {
   user.HighPart = user_time.dwHighDateTime;
   user.LowPart = user_time.dwLowDateTime;
   return (static_cast<double>(kernel.QuadPart) +
-          static_cast<double>(user.QuadPart)) / 1.0E-7;
+          static_cast<double>(user.QuadPart)) * 1e-7;
 #endif  // OS_WINDOWS
 }
 
@@ -394,6 +394,7 @@ int NumCPUs(void) {
        : nullptr)
 
 bool CpuScalingEnabled() {
+#ifndef OS_WINDOWS
   // 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.
@@ -407,6 +408,7 @@ bool CpuScalingEnabled() {
     fclose(file);
     if (memprefix(buff, bytes_read, "performance") == nullptr) return true;
   }
+#endif
   return false;
 }
 

src/walltime.cc

@@ -12,9 +12,16 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include "benchmark/macros.h"
+#include "internal_macros.h"
 #include "walltime.h"
 
+#if defined(OS_WINDOWS)
+#include <time.h>
+#include <winsock.h> // for timeval
+#else
 #include <sys/time.h>
+#endif
 
 #include <cstdio>
 #include <cstdint>
@@ -50,7 +57,7 @@ struct ChooseSteadyClock<false> {
 
 struct ChooseClockType {
 #if defined(HAVE_STEADY_CLOCK)
-  typedef typename ChooseSteadyClock<>::type type;
+  typedef ChooseSteadyClock<>::type type;
 #else
   typedef std::chrono::high_resolution_clock type;
 #endif
@@ -86,7 +93,22 @@ private:
 
   WallTime Slow() const {
     struct timeval tv;
+#if defined(OS_WINDOWS)
+    FILETIME    file_time;
+    SYSTEMTIME  system_time;
+    ULARGE_INTEGER ularge;
+    const unsigned __int64 epoch = 116444736000000000LL;
+
+    GetSystemTime(&system_time);
+    SystemTimeToFileTime(&system_time, &file_time);
+    ularge.LowPart = file_time.dwLowDateTime;
+    ularge.HighPart = file_time.dwHighDateTime;
+
+    tv.tv_sec = (long)((ularge.QuadPart - epoch) / (10L * 1000 * 1000));
+    tv.tv_usec = (long)(system_time.wMilliseconds * 1000);
+#else
     gettimeofday(&tv, nullptr);
+#endif
     return tv.tv_sec + tv.tv_usec * 1e-6;
   }
 
@@ -94,8 +116,6 @@ private:
   static_assert(sizeof(float) <= sizeof(int32_t),
                "type sizes don't allow the drift_adjust hack");
 
-  static constexpr double kMaxErrorInterval = 100e-6;
-
   WallTime base_walltime_;
   int64_t base_cycletime_;
   int64_t cycles_per_second_;
@@ -141,6 +161,7 @@ WallTimeImp::WallTimeImp()
       cycles_per_second_(0), seconds_per_cycle_(0.0),
       last_adjust_time_(0), drift_adjust_(0),
       max_interval_cycles_(0) {
+  const double kMaxErrorInterval = 100e-6;
   cycles_per_second_ = static_cast<int64_t>(CyclesPerSecond());
   CHECK(cycles_per_second_ != 0);
   seconds_per_cycle_ = 1.0 / cycles_per_second_;
@@ -207,15 +228,27 @@ std::string DateTimeString(bool local) {
   typedef std::chrono::system_clock Clock;
   std::time_t now = Clock::to_time_t(Clock::now());
   char storage[128];
+  std::size_t written;
 
-  std::tm timeinfo;
-  std::memset(&timeinfo, 0, sizeof(std::tm));
   if (local) {
-    localtime_r(&now, &timeinfo);
+#if defined(OS_WINDOWS)
+    written = std::strftime(storage, sizeof(storage), "%x %X", ::localtime(&now));
+#else
+    std::tm timeinfo;
+    std::memset(&timeinfo, 0, sizeof(std::tm));
+    ::localtime_r(&now, &timeinfo);
+    written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
+#endif
   } else {
-    gmtime_r(&now, &timeinfo);
+#if defined(OS_WINDOWS)
+    written = std::strftime(storage, sizeof(storage), "%x %X", ::gmtime(&now));
+#else
+    std::tm timeinfo;
+    std::memset(&timeinfo, 0, sizeof(std::tm));
+    ::gmtime_r(&now, &timeinfo);
+    written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
+#endif
   }
-  std::size_t written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
   CHECK(written < arraysize(storage));
   ((void)written); // prevent unused variable in optimized mode.
   return std::string(storage);

test/filter_test.cc

@@ -67,7 +67,7 @@ BENCHMARK(BM_FooBa);
 
 
 
-int main(int argc, const char* argv[]) {
+int main(int argc, char* argv[]) {
   benchmark::Initialize(&argc, argv);
 
   TestReporter test_reporter;
@@ -82,4 +82,3 @@ int main(int argc, const char* argv[]) {
     return -1;
   }
 }
-

test/options_test.cc

@@ -15,4 +15,12 @@ BENCHMARK(BM_basic)->UseRealTime();
 BENCHMARK(BM_basic)->ThreadRange(2, 4);
 BENCHMARK(BM_basic)->ThreadPerCpu();
 
+void CustomArgs(benchmark::internal::Benchmark* b) {
+  for (int i = 0; i < 10; ++i) {
+    b->Arg(i);
+  }
+}
+
+BENCHMARK(BM_basic)->Apply(CustomArgs);
+
 BENCHMARK_MAIN()