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
60namespace benchmark {
61
62// Suppress unused warnings on helper functions.
63#if defined(__GNUC__)
64#pragma GCC diagnostic ignored "-Wunused-function"
65#endif
66
67namespace {
68#if defined(BENCHMARK_OS_WINDOWS)
69double 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)
81double 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)
89double 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)
97double MakeTime(struct timespec const& ts) {
98  return ts.tv_sec + (static_cast<double>(ts.tv_nsec) * 1e-9);
99}
100#endif
101
102BENCHMARK_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
109double 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
140double 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
181namespace {
182
183std::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
215std::string LocalDateTimeString() { return DateTimeString(true); }
216
217}  // end namespace benchmark
218