utils/benchmark/src/timers.cc

   1 // Copyright 2015 Google Inc. All rights reserved.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 #include "timers.h"
  16 #include "internal_macros.h"
  17
  18 #ifdef BENCHMARK_OS_WINDOWS
  19 #include <shlwapi.h>
  20 #undef StrCat  // Don't let StrCat in string_util.h be renamed to lstrcatA
  21 #include <versionhelpers.h>
  22 #include <windows.h>
  23 #else
  24 #include <fcntl.h>
  25 #ifndef BENCHMARK_OS_FUCHSIA
  26 #include <sys/resource.h>
  27 #endif
  28 #include <sys/time.h>
  29 #include <sys/types.h>  // this header must be included before 'sys/sysctl.h' to avoid compilation error on FreeBSD
  30 #include <unistd.h>
  31 #if defined BENCHMARK_OS_FREEBSD || defined BENCHMARK_OS_MACOSX
  32 #include <sys/sysctl.h>
  33 #endif
  34 #if defined(BENCHMARK_OS_MACOSX)
  35 #include <mach/mach_init.h>
  36 #include <mach/mach_port.h>
  37 #include <mach/thread_act.h>
  38 #endif
  39 #endif
  40
  41 #ifdef BENCHMARK_OS_EMSCRIPTEN
  42 #include <emscripten.h>
  43 #endif
  44
  45 #include <cerrno>
  46 #include <cstdint>
  47 #include <cstdio>
  48 #include <cstdlib>
  49 #include <cstring>
  50 #include <ctime>
  51 #include <iostream>
  52 #include <limits>
  53 #include <mutex>
  54
  55 #include "check.h"
  56 #include "log.h"
  57 #include "sleep.h"
  58 #include "string_util.h"
  59
  60 namespace benchmark {
  61
  62 // Suppress unused warnings on helper functions.
  63 #if defined(__GNUC__)
  64 #pragma GCC diagnostic ignored "-Wunused-function"
  65 #endif
  66
  67 namespace {
  68 #if defined(BENCHMARK_OS_WINDOWS)
  69 double MakeTime(FILETIME const& kernel_time, FILETIME const& user_time) {
  70   ULARGE_INTEGER kernel;
  71   ULARGE_INTEGER user;
  72   kernel.HighPart = kernel_time.dwHighDateTime;
  73   kernel.LowPart = kernel_time.dwLowDateTime;
  74   user.HighPart = user_time.dwHighDateTime;
  75   user.LowPart = user_time.dwLowDateTime;
  76   return (static_cast<double>(kernel.QuadPart) +
  77           static_cast<double>(user.QuadPart)) *
  78          1e-7;
  79 }
  80 #elif !defined(BENCHMARK_OS_FUCHSIA)
  81 double MakeTime(struct rusage const& ru) {
  82   return (static_cast<double>(ru.ru_utime.tv_sec) +
  83           static_cast<double>(ru.ru_utime.tv_usec) * 1e-6 +
  84           static_cast<double>(ru.ru_stime.tv_sec) +
  85           static_cast<double>(ru.ru_stime.tv_usec) * 1e-6);
  86 }
  87 #endif
  88 #if defined(BENCHMARK_OS_MACOSX)
  89 double MakeTime(thread_basic_info_data_t const& info) {
  90   return (static_cast<double>(info.user_time.seconds) +
  91           static_cast<double>(info.user_time.microseconds) * 1e-6 +
  92           static_cast<double>(info.system_time.seconds) +
  93           static_cast<double>(info.system_time.microseconds) * 1e-6);
  94 }
  95 #endif
  96 #if defined(CLOCK_PROCESS_CPUTIME_ID) || defined(CLOCK_THREAD_CPUTIME_ID)
  97 double MakeTime(struct timespec const& ts) {
  98   return ts.tv_sec + (static_cast<double>(ts.tv_nsec) * 1e-9);
  99 }
 100 #endif
 101
 102 BENCHMARK_NORETURN static void DiagnoseAndExit(const char* msg) {
 103   std::cerr << "ERROR: " << msg << std::endl;
 104   std::exit(EXIT_FAILURE);
 105 }
 106
 107 }  // end namespace
 108
 109 double ProcessCPUUsage() {
 110 #if defined(BENCHMARK_OS_WINDOWS)
 111   HANDLE proc = GetCurrentProcess();
 112   FILETIME creation_time;
 113   FILETIME exit_time;
 114   FILETIME kernel_time;
 115   FILETIME user_time;
 116   if (GetProcessTimes(proc, &creation_time, &exit_time, &kernel_time,
 117                       &user_time))
 118     return MakeTime(kernel_time, user_time);
 119   DiagnoseAndExit("GetProccessTimes() failed");
 120 #elif defined(BENCHMARK_OS_EMSCRIPTEN)
 121   // clock_gettime(CLOCK_PROCESS_CPUTIME_ID, ...) returns 0 on Emscripten.
 122   // Use Emscripten-specific API. Reported CPU time would be exactly the
 123   // same as total time, but this is ok because there aren't long-latency
 124   // syncronous system calls in Emscripten.
 125   return emscripten_get_now() * 1e-3;
 126 #elif defined(CLOCK_PROCESS_CPUTIME_ID) && !defined(BENCHMARK_OS_MACOSX)
 127   // FIXME We want to use clock_gettime, but its not available in MacOS 10.11. See
 128   // https://github.com/google/benchmark/pull/292
 129   struct timespec spec;
 130   if (clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &spec) == 0)
 131     return MakeTime(spec);
 132   DiagnoseAndExit("clock_gettime(CLOCK_PROCESS_CPUTIME_ID, ...) failed");
 133 #else
 134   struct rusage ru;
 135   if (getrusage(RUSAGE_SELF, &ru) == 0) return MakeTime(ru);
 136   DiagnoseAndExit("getrusage(RUSAGE_SELF, ...) failed");
 137 #endif
 138 }
 139
 140 double ThreadCPUUsage() {
 141 #if defined(BENCHMARK_OS_WINDOWS)
 142   HANDLE this_thread = GetCurrentThread();
 143   FILETIME creation_time;
 144   FILETIME exit_time;
 145   FILETIME kernel_time;
 146   FILETIME user_time;
 147   GetThreadTimes(this_thread, &creation_time, &exit_time, &kernel_time,
 148                  &user_time);
 149   return MakeTime(kernel_time, user_time);
 150 #elif defined(BENCHMARK_OS_MACOSX)
 151   // FIXME We want to use clock_gettime, but its not available in MacOS 10.11. See
 152   // https://github.com/google/benchmark/pull/292
 153   mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
 154   thread_basic_info_data_t info;
 155   mach_port_t thread = pthread_mach_thread_np(pthread_self());
 156   if (thread_info(thread, THREAD_BASIC_INFO, (thread_info_t)&info, &count) ==
 157       KERN_SUCCESS) {
 158     return MakeTime(info);
 159   }
 160   DiagnoseAndExit("ThreadCPUUsage() failed when evaluating thread_info");
 161 #elif defined(BENCHMARK_OS_EMSCRIPTEN)
 162   // Emscripten doesn't support traditional threads
 163   return ProcessCPUUsage();
 164 #elif defined(BENCHMARK_OS_RTEMS)
 165   // RTEMS doesn't support CLOCK_THREAD_CPUTIME_ID. See
 166   // https://github.com/RTEMS/rtems/blob/master/cpukit/posix/src/clockgettime.c
 167   return ProcessCPUUsage();
 168 #elif defined(BENCHMARK_OS_SOLARIS)
 169   struct rusage ru;
 170   if (getrusage(RUSAGE_LWP, &ru) == 0) return MakeTime(ru);
 171   DiagnoseAndExit("getrusage(RUSAGE_LWP, ...) failed");
 172 #elif defined(CLOCK_THREAD_CPUTIME_ID)
 173   struct timespec ts;
 174   if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts) == 0) return MakeTime(ts);
 175   DiagnoseAndExit("clock_gettime(CLOCK_THREAD_CPUTIME_ID, ...) failed");
 176 #else
 177 #error Per-thread timing is not available on your system.
 178 #endif
 179 }
 180
 181 namespace {
 182
 183 std::string DateTimeString(bool local) {
 184   typedef std::chrono::system_clock Clock;
 185   std::time_t now = Clock::to_time_t(Clock::now());
 186   const std::size_t kStorageSize = 128;
 187   char storage[kStorageSize];
 188   std::size_t written;
 189
 190   if (local) {
 191 #if defined(BENCHMARK_OS_WINDOWS)
 192     written =
 193         std::strftime(storage, sizeof(storage), "%x %X", ::localtime(&now));
 194 #else
 195     std::tm timeinfo;
 196     ::localtime_r(&now, &timeinfo);
 197     written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
 198 #endif
 199   } else {
 200 #if defined(BENCHMARK_OS_WINDOWS)
 201     written = std::strftime(storage, sizeof(storage), "%x %X", ::gmtime(&now));
 202 #else
 203     std::tm timeinfo;
 204     ::gmtime_r(&now, &timeinfo);
 205     written = std::strftime(storage, sizeof(storage), "%F %T", &timeinfo);
 206 #endif
 207   }
 208   CHECK(written < kStorageSize);
 209   ((void)written);  // prevent unused variable in optimized mode.
 210   return std::string(storage);
 211 }
 212
 213 }  // end namespace
 214
 215 std::string LocalDateTimeString() { return DateTimeString(true); }
 216
 217 }  // end namespace benchmark