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 |
218 | |