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 "internal_macros.h"
16
17 #ifdef BENCHMARK_OS_WINDOWS
18 #include <shlwapi.h>
19 #undef StrCat // Don't let StrCat in string_util.h be renamed to lstrcatA
20 #include <versionhelpers.h>
21 #include <windows.h>
22
23 #include <codecvt>
24 #else
25 #include <fcntl.h>
26 #if !defined(BENCHMARK_OS_FUCHSIA) && !defined(BENCHMARK_OS_QURT)
27 #include <sys/resource.h>
28 #endif
29 #include <sys/time.h>
30 #include <sys/types.h> // this header must be included before 'sys/sysctl.h' to avoid compilation error on FreeBSD
31 #include <unistd.h>
32 #if defined BENCHMARK_OS_FREEBSD || defined BENCHMARK_OS_MACOSX || \
33 defined BENCHMARK_OS_NETBSD || defined BENCHMARK_OS_OPENBSD || \
34 defined BENCHMARK_OS_DRAGONFLY
35 #define BENCHMARK_HAS_SYSCTL
36 #include <sys/sysctl.h>
37 #endif
38 #endif
39 #if defined(BENCHMARK_OS_SOLARIS)
40 #include <kstat.h>
41 #include <netdb.h>
42 #endif
43 #if defined(BENCHMARK_OS_QNX)
44 #include <sys/syspage.h>
45 #endif
46 #if defined(BENCHMARK_OS_QURT)
47 #include <qurt.h>
48 #endif
49 #if defined(BENCHMARK_HAS_PTHREAD_AFFINITY)
50 #include <pthread.h>
51 #endif
52
53 #include <algorithm>
54 #include <array>
55 #include <bitset>
56 #include <cerrno>
57 #include <climits>
58 #include <cstdint>
59 #include <cstdio>
60 #include <cstdlib>
61 #include <cstring>
62 #include <fstream>
63 #include <iostream>
64 #include <iterator>
65 #include <limits>
66 #include <locale>
67 #include <memory>
68 #include <random>
69 #include <sstream>
70 #include <utility>
71
72 #include "benchmark/benchmark.h"
73 #include "check.h"
74 #include "cycleclock.h"
75 #include "internal_macros.h"
76 #include "log.h"
77 #include "string_util.h"
78 #include "timers.h"
79
80 namespace benchmark {
81 namespace {
82
PrintImp(std::ostream & out)83 void PrintImp(std::ostream& out) { out << std::endl; }
84
85 template <class First, class... Rest>
PrintImp(std::ostream & out,First && f,Rest &&...rest)86 void PrintImp(std::ostream& out, First&& f, Rest&&... rest) {
87 out << std::forward<First>(f);
88 PrintImp(out, std::forward<Rest>(rest)...);
89 }
90
91 template <class... Args>
PrintErrorAndDie(Args &&...args)92 BENCHMARK_NORETURN void PrintErrorAndDie(Args&&... args) {
93 PrintImp(std::cerr, std::forward<Args>(args)...);
94 std::exit(EXIT_FAILURE);
95 }
96
97 #ifdef BENCHMARK_HAS_SYSCTL
98
99 /// ValueUnion - A type used to correctly alias the byte-for-byte output of
100 /// `sysctl` with the result type it's to be interpreted as.
101 struct ValueUnion {
102 union DataT {
103 int32_t int32_value;
104 int64_t int64_value;
105 // For correct aliasing of union members from bytes.
106 char bytes[8];
107 };
108 using DataPtr = std::unique_ptr<DataT, decltype(&std::free)>;
109
110 // The size of the data union member + its trailing array size.
111 std::size_t size;
112 DataPtr buff;
113
114 public:
ValueUnionbenchmark::__anonf7ca495f0111::ValueUnion115 ValueUnion() : size(0), buff(nullptr, &std::free) {}
116
ValueUnionbenchmark::__anonf7ca495f0111::ValueUnion117 explicit ValueUnion(std::size_t buff_size)
118 : size(sizeof(DataT) + buff_size),
119 buff(::new (std::malloc(size)) DataT(), &std::free) {}
120
121 ValueUnion(ValueUnion&& other) = default;
122
operator boolbenchmark::__anonf7ca495f0111::ValueUnion123 explicit operator bool() const { return bool(buff); }
124
databenchmark::__anonf7ca495f0111::ValueUnion125 char* data() const { return buff->bytes; }
126
GetAsStringbenchmark::__anonf7ca495f0111::ValueUnion127 std::string GetAsString() const { return std::string(data()); }
128
GetAsIntegerbenchmark::__anonf7ca495f0111::ValueUnion129 int64_t GetAsInteger() const {
130 if (size == sizeof(buff->int32_value))
131 return buff->int32_value;
132 else if (size == sizeof(buff->int64_value))
133 return buff->int64_value;
134 BENCHMARK_UNREACHABLE();
135 }
136
137 template <class T, int N>
GetAsArraybenchmark::__anonf7ca495f0111::ValueUnion138 std::array<T, N> GetAsArray() {
139 const int arr_size = sizeof(T) * N;
140 BM_CHECK_LE(arr_size, size);
141 std::array<T, N> arr;
142 std::memcpy(arr.data(), data(), arr_size);
143 return arr;
144 }
145 };
146
GetSysctlImp(std::string const & name)147 ValueUnion GetSysctlImp(std::string const& name) {
148 #if defined BENCHMARK_OS_OPENBSD
149 int mib[2];
150
151 mib[0] = CTL_HW;
152 if ((name == "hw.ncpu") || (name == "hw.cpuspeed")) {
153 ValueUnion buff(sizeof(int));
154
155 if (name == "hw.ncpu") {
156 mib[1] = HW_NCPU;
157 } else {
158 mib[1] = HW_CPUSPEED;
159 }
160
161 if (sysctl(mib, 2, buff.data(), &buff.Size, nullptr, 0) == -1) {
162 return ValueUnion();
163 }
164 return buff;
165 }
166 return ValueUnion();
167 #else
168 std::size_t cur_buff_size = 0;
169 if (sysctlbyname(name.c_str(), nullptr, &cur_buff_size, nullptr, 0) == -1)
170 return ValueUnion();
171
172 ValueUnion buff(cur_buff_size);
173 if (sysctlbyname(name.c_str(), buff.data(), &buff.size, nullptr, 0) == 0)
174 return buff;
175 return ValueUnion();
176 #endif
177 }
178
179 BENCHMARK_MAYBE_UNUSED
GetSysctl(std::string const & name,std::string * out)180 bool GetSysctl(std::string const& name, std::string* out) {
181 out->clear();
182 auto buff = GetSysctlImp(name);
183 if (!buff) return false;
184 out->assign(buff.data());
185 return true;
186 }
187
188 template <class Tp,
189 class = typename std::enable_if<std::is_integral<Tp>::value>::type>
GetSysctl(std::string const & name,Tp * out)190 bool GetSysctl(std::string const& name, Tp* out) {
191 *out = 0;
192 auto buff = GetSysctlImp(name);
193 if (!buff) return false;
194 *out = static_cast<Tp>(buff.GetAsInteger());
195 return true;
196 }
197
198 template <class Tp, size_t N>
GetSysctl(std::string const & name,std::array<Tp,N> * out)199 bool GetSysctl(std::string const& name, std::array<Tp, N>* out) {
200 auto buff = GetSysctlImp(name);
201 if (!buff) return false;
202 *out = buff.GetAsArray<Tp, N>();
203 return true;
204 }
205 #endif
206
207 template <class ArgT>
ReadFromFile(std::string const & fname,ArgT * arg)208 bool ReadFromFile(std::string const& fname, ArgT* arg) {
209 *arg = ArgT();
210 std::ifstream f(fname.c_str());
211 if (!f.is_open()) return false;
212 f >> *arg;
213 return f.good();
214 }
215
CpuScaling(int num_cpus)216 CPUInfo::Scaling CpuScaling(int num_cpus) {
217 // We don't have a valid CPU count, so don't even bother.
218 if (num_cpus <= 0) return CPUInfo::Scaling::UNKNOWN;
219 #if defined(BENCHMARK_OS_QNX)
220 return CPUInfo::Scaling::UNKNOWN;
221 #elif !defined(BENCHMARK_OS_WINDOWS)
222 // On Linux, the CPUfreq subsystem exposes CPU information as files on the
223 // local file system. If reading the exported files fails, then we may not be
224 // running on Linux, so we silently ignore all the read errors.
225 std::string res;
226 for (int cpu = 0; cpu < num_cpus; ++cpu) {
227 std::string governor_file =
228 StrCat("/sys/devices/system/cpu/cpu", cpu, "/cpufreq/scaling_governor");
229 if (ReadFromFile(governor_file, &res) && res != "performance")
230 return CPUInfo::Scaling::ENABLED;
231 }
232 return CPUInfo::Scaling::DISABLED;
233 #else
234 return CPUInfo::Scaling::UNKNOWN;
235 #endif
236 }
237
CountSetBitsInCPUMap(std::string val)238 int CountSetBitsInCPUMap(std::string val) {
239 auto CountBits = [](std::string part) {
240 using CPUMask = std::bitset<sizeof(std::uintptr_t) * CHAR_BIT>;
241 part = "0x" + part;
242 CPUMask mask(benchmark::stoul(part, nullptr, 16));
243 return static_cast<int>(mask.count());
244 };
245 std::size_t pos;
246 int total = 0;
247 while ((pos = val.find(',')) != std::string::npos) {
248 total += CountBits(val.substr(0, pos));
249 val = val.substr(pos + 1);
250 }
251 if (!val.empty()) {
252 total += CountBits(val);
253 }
254 return total;
255 }
256
257 BENCHMARK_MAYBE_UNUSED
GetCacheSizesFromKVFS()258 std::vector<CPUInfo::CacheInfo> GetCacheSizesFromKVFS() {
259 std::vector<CPUInfo::CacheInfo> res;
260 std::string dir = "/sys/devices/system/cpu/cpu0/cache/";
261 int idx = 0;
262 while (true) {
263 CPUInfo::CacheInfo info;
264 std::string fpath = StrCat(dir, "index", idx++, "/");
265 std::ifstream f(StrCat(fpath, "size").c_str());
266 if (!f.is_open()) break;
267 std::string suffix;
268 f >> info.size;
269 if (f.fail())
270 PrintErrorAndDie("Failed while reading file '", fpath, "size'");
271 if (f.good()) {
272 f >> suffix;
273 if (f.bad())
274 PrintErrorAndDie(
275 "Invalid cache size format: failed to read size suffix");
276 else if (f && suffix != "K")
277 PrintErrorAndDie("Invalid cache size format: Expected bytes ", suffix);
278 else if (suffix == "K")
279 info.size *= 1024;
280 }
281 if (!ReadFromFile(StrCat(fpath, "type"), &info.type))
282 PrintErrorAndDie("Failed to read from file ", fpath, "type");
283 if (!ReadFromFile(StrCat(fpath, "level"), &info.level))
284 PrintErrorAndDie("Failed to read from file ", fpath, "level");
285 std::string map_str;
286 if (!ReadFromFile(StrCat(fpath, "shared_cpu_map"), &map_str))
287 PrintErrorAndDie("Failed to read from file ", fpath, "shared_cpu_map");
288 info.num_sharing = CountSetBitsInCPUMap(map_str);
289 res.push_back(info);
290 }
291
292 return res;
293 }
294
295 #ifdef BENCHMARK_OS_MACOSX
GetCacheSizesMacOSX()296 std::vector<CPUInfo::CacheInfo> GetCacheSizesMacOSX() {
297 std::vector<CPUInfo::CacheInfo> res;
298 std::array<int, 4> cache_counts{{0, 0, 0, 0}};
299 GetSysctl("hw.cacheconfig", &cache_counts);
300
301 struct {
302 std::string name;
303 std::string type;
304 int level;
305 int num_sharing;
306 } cases[] = {{"hw.l1dcachesize", "Data", 1, cache_counts[1]},
307 {"hw.l1icachesize", "Instruction", 1, cache_counts[1]},
308 {"hw.l2cachesize", "Unified", 2, cache_counts[2]},
309 {"hw.l3cachesize", "Unified", 3, cache_counts[3]}};
310 for (auto& c : cases) {
311 int val;
312 if (!GetSysctl(c.name, &val)) continue;
313 CPUInfo::CacheInfo info;
314 info.type = c.type;
315 info.level = c.level;
316 info.size = val;
317 info.num_sharing = c.num_sharing;
318 res.push_back(std::move(info));
319 }
320 return res;
321 }
322 #elif defined(BENCHMARK_OS_WINDOWS)
GetCacheSizesWindows()323 std::vector<CPUInfo::CacheInfo> GetCacheSizesWindows() {
324 std::vector<CPUInfo::CacheInfo> res;
325 DWORD buffer_size = 0;
326 using PInfo = SYSTEM_LOGICAL_PROCESSOR_INFORMATION;
327 using CInfo = CACHE_DESCRIPTOR;
328
329 using UPtr = std::unique_ptr<PInfo, decltype(&std::free)>;
330 GetLogicalProcessorInformation(nullptr, &buffer_size);
331 UPtr buff(static_cast<PInfo*>(std::malloc(buffer_size)), &std::free);
332 if (!GetLogicalProcessorInformation(buff.get(), &buffer_size))
333 PrintErrorAndDie("Failed during call to GetLogicalProcessorInformation: ",
334 GetLastError());
335
336 PInfo* it = buff.get();
337 PInfo* end = buff.get() + (buffer_size / sizeof(PInfo));
338
339 for (; it != end; ++it) {
340 if (it->Relationship != RelationCache) continue;
341 using BitSet = std::bitset<sizeof(ULONG_PTR) * CHAR_BIT>;
342 BitSet b(it->ProcessorMask);
343 // To prevent duplicates, only consider caches where CPU 0 is specified
344 if (!b.test(0)) continue;
345 const CInfo& cache = it->Cache;
346 CPUInfo::CacheInfo C;
347 C.num_sharing = static_cast<int>(b.count());
348 C.level = cache.Level;
349 C.size = cache.Size;
350 C.type = "Unknown";
351 switch (cache.Type) {
352 case CacheUnified:
353 C.type = "Unified";
354 break;
355 case CacheInstruction:
356 C.type = "Instruction";
357 break;
358 case CacheData:
359 C.type = "Data";
360 break;
361 case CacheTrace:
362 C.type = "Trace";
363 break;
364 }
365 res.push_back(C);
366 }
367 return res;
368 }
369 #elif BENCHMARK_OS_QNX
GetCacheSizesQNX()370 std::vector<CPUInfo::CacheInfo> GetCacheSizesQNX() {
371 std::vector<CPUInfo::CacheInfo> res;
372 struct cacheattr_entry* cache = SYSPAGE_ENTRY(cacheattr);
373 uint32_t const elsize = SYSPAGE_ELEMENT_SIZE(cacheattr);
374 int num = SYSPAGE_ENTRY_SIZE(cacheattr) / elsize;
375 for (int i = 0; i < num; ++i) {
376 CPUInfo::CacheInfo info;
377 switch (cache->flags) {
378 case CACHE_FLAG_INSTR:
379 info.type = "Instruction";
380 info.level = 1;
381 break;
382 case CACHE_FLAG_DATA:
383 info.type = "Data";
384 info.level = 1;
385 break;
386 case CACHE_FLAG_UNIFIED:
387 info.type = "Unified";
388 info.level = 2;
389 break;
390 case CACHE_FLAG_SHARED:
391 info.type = "Shared";
392 info.level = 3;
393 break;
394 default:
395 continue;
396 break;
397 }
398 info.size = cache->line_size * cache->num_lines;
399 info.num_sharing = 0;
400 res.push_back(std::move(info));
401 cache = SYSPAGE_ARRAY_ADJ_OFFSET(cacheattr, cache, elsize);
402 }
403 return res;
404 }
405 #endif
406
GetCacheSizes()407 std::vector<CPUInfo::CacheInfo> GetCacheSizes() {
408 #ifdef BENCHMARK_OS_MACOSX
409 return GetCacheSizesMacOSX();
410 #elif defined(BENCHMARK_OS_WINDOWS)
411 return GetCacheSizesWindows();
412 #elif defined(BENCHMARK_OS_QNX)
413 return GetCacheSizesQNX();
414 #elif defined(BENCHMARK_OS_QURT)
415 return std::vector<CPUInfo::CacheInfo>();
416 #else
417 return GetCacheSizesFromKVFS();
418 #endif
419 }
420
GetSystemName()421 std::string GetSystemName() {
422 #if defined(BENCHMARK_OS_WINDOWS)
423 std::string str;
424 static constexpr int COUNT = MAX_COMPUTERNAME_LENGTH + 1;
425 TCHAR hostname[COUNT] = {'\0'};
426 DWORD DWCOUNT = COUNT;
427 if (!GetComputerName(hostname, &DWCOUNT)) return std::string("");
428 #ifndef UNICODE
429 str = std::string(hostname, DWCOUNT);
430 #else
431 // `WideCharToMultiByte` returns `0` when conversion fails.
432 int len = WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, hostname,
433 DWCOUNT, NULL, 0, NULL, NULL);
434 str.resize(len);
435 WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, hostname, DWCOUNT, &str[0],
436 str.size(), NULL, NULL);
437 #endif
438 return str;
439 #elif defined(BENCHMARK_OS_QURT)
440 std::string str = "Hexagon DSP";
441 qurt_arch_version_t arch_version_struct;
442 if (qurt_sysenv_get_arch_version(&arch_version_struct) == QURT_EOK) {
443 str += " v";
444 str += std::to_string(arch_version_struct.arch_version);
445 }
446 return str;
447 #else
448 #ifndef HOST_NAME_MAX
449 #ifdef BENCHMARK_HAS_SYSCTL // BSD/Mac doesn't have HOST_NAME_MAX defined
450 #define HOST_NAME_MAX 64
451 #elif defined(BENCHMARK_OS_NACL)
452 #define HOST_NAME_MAX 64
453 #elif defined(BENCHMARK_OS_QNX)
454 #define HOST_NAME_MAX 154
455 #elif defined(BENCHMARK_OS_RTEMS)
456 #define HOST_NAME_MAX 256
457 #elif defined(BENCHMARK_OS_SOLARIS)
458 #define HOST_NAME_MAX MAXHOSTNAMELEN
459 #else
460 #pragma message("HOST_NAME_MAX not defined. using 64")
461 #define HOST_NAME_MAX 64
462 #endif
463 #endif // def HOST_NAME_MAX
464 char hostname[HOST_NAME_MAX];
465 int retVal = gethostname(hostname, HOST_NAME_MAX);
466 if (retVal != 0) return std::string("");
467 return std::string(hostname);
468 #endif // Catch-all POSIX block.
469 }
470
GetNumCPUs()471 int GetNumCPUs() {
472 #ifdef BENCHMARK_HAS_SYSCTL
473 int num_cpu = -1;
474 if (GetSysctl("hw.ncpu", &num_cpu)) return num_cpu;
475 fprintf(stderr, "Err: %s\n", strerror(errno));
476 std::exit(EXIT_FAILURE);
477 #elif defined(BENCHMARK_OS_WINDOWS)
478 SYSTEM_INFO sysinfo;
479 // Use memset as opposed to = {} to avoid GCC missing initializer false
480 // positives.
481 std::memset(&sysinfo, 0, sizeof(SYSTEM_INFO));
482 GetSystemInfo(&sysinfo);
483 return sysinfo.dwNumberOfProcessors; // number of logical
484 // processors in the current
485 // group
486 #elif defined(BENCHMARK_OS_SOLARIS)
487 // Returns -1 in case of a failure.
488 long num_cpu = sysconf(_SC_NPROCESSORS_ONLN);
489 if (num_cpu < 0) {
490 fprintf(stderr, "sysconf(_SC_NPROCESSORS_ONLN) failed with error: %s\n",
491 strerror(errno));
492 }
493 return (int)num_cpu;
494 #elif defined(BENCHMARK_OS_QNX)
495 return static_cast<int>(_syspage_ptr->num_cpu);
496 #elif defined(BENCHMARK_OS_QURT)
497 qurt_sysenv_max_hthreads_t hardware_threads;
498 if (qurt_sysenv_get_max_hw_threads(&hardware_threads) != QURT_EOK) {
499 hardware_threads.max_hthreads = 1;
500 }
501 return hardware_threads.max_hthreads;
502 #else
503 int num_cpus = 0;
504 int max_id = -1;
505 std::ifstream f("/proc/cpuinfo");
506 if (!f.is_open()) {
507 std::cerr << "failed to open /proc/cpuinfo\n";
508 return -1;
509 }
510 const std::string Key = "processor";
511 std::string ln;
512 while (std::getline(f, ln)) {
513 if (ln.empty()) continue;
514 std::size_t split_idx = ln.find(':');
515 std::string value;
516 #if defined(__s390__)
517 // s390 has another format in /proc/cpuinfo
518 // it needs to be parsed differently
519 if (split_idx != std::string::npos)
520 value = ln.substr(Key.size() + 1, split_idx - Key.size() - 1);
521 #else
522 if (split_idx != std::string::npos) value = ln.substr(split_idx + 1);
523 #endif
524 if (ln.size() >= Key.size() && ln.compare(0, Key.size(), Key) == 0) {
525 num_cpus++;
526 if (!value.empty()) {
527 const int cur_id = benchmark::stoi(value);
528 max_id = std::max(cur_id, max_id);
529 }
530 }
531 }
532 if (f.bad()) {
533 std::cerr << "Failure reading /proc/cpuinfo\n";
534 return -1;
535 }
536 if (!f.eof()) {
537 std::cerr << "Failed to read to end of /proc/cpuinfo\n";
538 return -1;
539 }
540 f.close();
541
542 if ((max_id + 1) != num_cpus) {
543 fprintf(stderr,
544 "CPU ID assignments in /proc/cpuinfo seem messed up."
545 " This is usually caused by a bad BIOS.\n");
546 }
547 return num_cpus;
548 #endif
549 BENCHMARK_UNREACHABLE();
550 }
551
552 class ThreadAffinityGuard final {
553 public:
ThreadAffinityGuard()554 ThreadAffinityGuard() : reset_affinity(SetAffinity()) {
555 if (!reset_affinity)
556 std::cerr << "***WARNING*** Failed to set thread affinity. Estimated CPU "
557 "frequency may be incorrect."
558 << std::endl;
559 }
560
~ThreadAffinityGuard()561 ~ThreadAffinityGuard() {
562 if (!reset_affinity) return;
563
564 #if defined(BENCHMARK_HAS_PTHREAD_AFFINITY)
565 int ret = pthread_setaffinity_np(self, sizeof(previous_affinity),
566 &previous_affinity);
567 if (ret == 0) return;
568 #elif defined(BENCHMARK_OS_WINDOWS_WIN32)
569 DWORD_PTR ret = SetThreadAffinityMask(self, previous_affinity);
570 if (ret != 0) return;
571 #endif // def BENCHMARK_HAS_PTHREAD_AFFINITY
572 PrintErrorAndDie("Failed to reset thread affinity");
573 }
574
575 ThreadAffinityGuard(ThreadAffinityGuard&&) = delete;
576 ThreadAffinityGuard(const ThreadAffinityGuard&) = delete;
577 ThreadAffinityGuard& operator=(ThreadAffinityGuard&&) = delete;
578 ThreadAffinityGuard& operator=(const ThreadAffinityGuard&) = delete;
579
580 private:
SetAffinity()581 bool SetAffinity() {
582 #if defined(BENCHMARK_HAS_PTHREAD_AFFINITY)
583 int ret;
584 self = pthread_self();
585 ret = pthread_getaffinity_np(self, sizeof(previous_affinity),
586 &previous_affinity);
587 if (ret != 0) return false;
588
589 cpu_set_t affinity;
590 memcpy(&affinity, &previous_affinity, sizeof(affinity));
591
592 bool is_first_cpu = true;
593
594 for (int i = 0; i < CPU_SETSIZE; ++i)
595 if (CPU_ISSET(i, &affinity)) {
596 if (is_first_cpu)
597 is_first_cpu = false;
598 else
599 CPU_CLR(i, &affinity);
600 }
601
602 if (is_first_cpu) return false;
603
604 ret = pthread_setaffinity_np(self, sizeof(affinity), &affinity);
605 return ret == 0;
606 #elif defined(BENCHMARK_OS_WINDOWS_WIN32)
607 self = GetCurrentThread();
608 DWORD_PTR mask = static_cast<DWORD_PTR>(1) << GetCurrentProcessorNumber();
609 previous_affinity = SetThreadAffinityMask(self, mask);
610 return previous_affinity != 0;
611 #else
612 return false;
613 #endif // def BENCHMARK_HAS_PTHREAD_AFFINITY
614 }
615
616 #if defined(BENCHMARK_HAS_PTHREAD_AFFINITY)
617 pthread_t self;
618 cpu_set_t previous_affinity;
619 #elif defined(BENCHMARK_OS_WINDOWS_WIN32)
620 HANDLE self;
621 DWORD_PTR previous_affinity;
622 #endif // def BENCHMARK_HAS_PTHREAD_AFFINITY
623 bool reset_affinity;
624 };
625
GetCPUCyclesPerSecond(CPUInfo::Scaling scaling)626 double GetCPUCyclesPerSecond(CPUInfo::Scaling scaling) {
627 // Currently, scaling is only used on linux path here,
628 // suppress diagnostics about it being unused on other paths.
629 (void)scaling;
630
631 #if defined BENCHMARK_OS_LINUX || defined BENCHMARK_OS_CYGWIN
632 long freq;
633
634 // If the kernel is exporting the tsc frequency use that. There are issues
635 // where cpuinfo_max_freq cannot be relied on because the BIOS may be
636 // exporintg an invalid p-state (on x86) or p-states may be used to put the
637 // processor in a new mode (turbo mode). Essentially, those frequencies
638 // cannot always be relied upon. The same reasons apply to /proc/cpuinfo as
639 // well.
640 if (ReadFromFile("/sys/devices/system/cpu/cpu0/tsc_freq_khz", &freq)
641 // If CPU scaling is disabled, use the *current* frequency.
642 // Note that we specifically don't want to read cpuinfo_cur_freq,
643 // because it is only readable by root.
644 || (scaling == CPUInfo::Scaling::DISABLED &&
645 ReadFromFile("/sys/devices/system/cpu/cpu0/cpufreq/scaling_cur_freq",
646 &freq))
647 // Otherwise, if CPU scaling may be in effect, we want to use
648 // the *maximum* frequency, not whatever CPU speed some random processor
649 // happens to be using now.
650 || ReadFromFile("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq",
651 &freq)) {
652 // The value is in kHz (as the file name suggests). For example, on a
653 // 2GHz warpstation, the file contains the value "2000000".
654 return freq * 1000.0;
655 }
656
657 const double error_value = -1;
658 double bogo_clock = error_value;
659
660 std::ifstream f("/proc/cpuinfo");
661 if (!f.is_open()) {
662 std::cerr << "failed to open /proc/cpuinfo\n";
663 return error_value;
664 }
665
666 auto StartsWithKey = [](std::string const& Value, std::string const& Key) {
667 if (Key.size() > Value.size()) return false;
668 auto Cmp = [&](char X, char Y) {
669 return std::tolower(X) == std::tolower(Y);
670 };
671 return std::equal(Key.begin(), Key.end(), Value.begin(), Cmp);
672 };
673
674 std::string ln;
675 while (std::getline(f, ln)) {
676 if (ln.empty()) continue;
677 std::size_t split_idx = ln.find(':');
678 std::string value;
679 if (split_idx != std::string::npos) value = ln.substr(split_idx + 1);
680 // When parsing the "cpu MHz" and "bogomips" (fallback) entries, we only
681 // accept positive values. Some environments (virtual machines) report zero,
682 // which would cause infinite looping in WallTime_Init.
683 if (StartsWithKey(ln, "cpu MHz")) {
684 if (!value.empty()) {
685 double cycles_per_second = benchmark::stod(value) * 1000000.0;
686 if (cycles_per_second > 0) return cycles_per_second;
687 }
688 } else if (StartsWithKey(ln, "bogomips")) {
689 if (!value.empty()) {
690 bogo_clock = benchmark::stod(value) * 1000000.0;
691 if (bogo_clock < 0.0) bogo_clock = error_value;
692 }
693 }
694 }
695 if (f.bad()) {
696 std::cerr << "Failure reading /proc/cpuinfo\n";
697 return error_value;
698 }
699 if (!f.eof()) {
700 std::cerr << "Failed to read to end of /proc/cpuinfo\n";
701 return error_value;
702 }
703 f.close();
704 // If we found the bogomips clock, but nothing better, we'll use it (but
705 // we're not happy about it); otherwise, fallback to the rough estimation
706 // below.
707 if (bogo_clock >= 0.0) return bogo_clock;
708
709 #elif defined BENCHMARK_HAS_SYSCTL
710 constexpr auto* freqStr =
711 #if defined(BENCHMARK_OS_FREEBSD) || defined(BENCHMARK_OS_NETBSD)
712 "machdep.tsc_freq";
713 #elif defined BENCHMARK_OS_OPENBSD
714 "hw.cpuspeed";
715 #elif defined BENCHMARK_OS_DRAGONFLY
716 "hw.tsc_frequency";
717 #else
718 "hw.cpufrequency";
719 #endif
720 unsigned long long hz = 0;
721 #if defined BENCHMARK_OS_OPENBSD
722 if (GetSysctl(freqStr, &hz)) return hz * 1000000;
723 #else
724 if (GetSysctl(freqStr, &hz)) return hz;
725 #endif
726 fprintf(stderr, "Unable to determine clock rate from sysctl: %s: %s\n",
727 freqStr, strerror(errno));
728 fprintf(stderr,
729 "This does not affect benchmark measurements, only the "
730 "metadata output.\n");
731
732 #elif defined BENCHMARK_OS_WINDOWS_WIN32
733 // In NT, read MHz from the registry. If we fail to do so or we're in win9x
734 // then make a crude estimate.
735 DWORD data, data_size = sizeof(data);
736 if (IsWindowsXPOrGreater() &&
737 SUCCEEDED(
738 SHGetValueA(HKEY_LOCAL_MACHINE,
739 "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
740 "~MHz", nullptr, &data, &data_size)))
741 return static_cast<double>(static_cast<int64_t>(data) *
742 static_cast<int64_t>(1000 * 1000)); // was mhz
743 #elif defined(BENCHMARK_OS_SOLARIS)
744 kstat_ctl_t* kc = kstat_open();
745 if (!kc) {
746 std::cerr << "failed to open /dev/kstat\n";
747 return -1;
748 }
749 kstat_t* ksp = kstat_lookup(kc, const_cast<char*>("cpu_info"), -1,
750 const_cast<char*>("cpu_info0"));
751 if (!ksp) {
752 std::cerr << "failed to lookup in /dev/kstat\n";
753 return -1;
754 }
755 if (kstat_read(kc, ksp, NULL) < 0) {
756 std::cerr << "failed to read from /dev/kstat\n";
757 return -1;
758 }
759 kstat_named_t* knp = (kstat_named_t*)kstat_data_lookup(
760 ksp, const_cast<char*>("current_clock_Hz"));
761 if (!knp) {
762 std::cerr << "failed to lookup data in /dev/kstat\n";
763 return -1;
764 }
765 if (knp->data_type != KSTAT_DATA_UINT64) {
766 std::cerr << "current_clock_Hz is of unexpected data type: "
767 << knp->data_type << "\n";
768 return -1;
769 }
770 double clock_hz = knp->value.ui64;
771 kstat_close(kc);
772 return clock_hz;
773 #elif defined(BENCHMARK_OS_QNX)
774 return static_cast<double>((int64_t)(SYSPAGE_ENTRY(cpuinfo)->speed) *
775 (int64_t)(1000 * 1000));
776 #elif defined(BENCHMARK_OS_QURT)
777 // QuRT doesn't provide any API to query Hexagon frequency.
778 return 1000000000;
779 #endif
780 // If we've fallen through, attempt to roughly estimate the CPU clock rate.
781
782 // Make sure to use the same cycle counter when starting and stopping the
783 // cycle timer. We just pin the current thread to a cpu in the previous
784 // affinity set.
785 ThreadAffinityGuard affinity_guard;
786
787 static constexpr double estimate_time_s = 1.0;
788 const double start_time = ChronoClockNow();
789 const auto start_ticks = cycleclock::Now();
790
791 // Impose load instead of calling sleep() to make sure the cycle counter
792 // works.
793 using PRNG = std::minstd_rand;
794 using Result = PRNG::result_type;
795 PRNG rng(static_cast<Result>(start_ticks));
796
797 Result state = 0;
798
799 do {
800 static constexpr size_t batch_size = 10000;
801 rng.discard(batch_size);
802 state += rng();
803
804 } while (ChronoClockNow() - start_time < estimate_time_s);
805
806 DoNotOptimize(state);
807
808 const auto end_ticks = cycleclock::Now();
809 const double end_time = ChronoClockNow();
810
811 return static_cast<double>(end_ticks - start_ticks) / (end_time - start_time);
812 // Reset the affinity of current thread when the lifetime of affinity_guard
813 // ends.
814 }
815
GetLoadAvg()816 std::vector<double> GetLoadAvg() {
817 #if (defined BENCHMARK_OS_FREEBSD || defined(BENCHMARK_OS_LINUX) || \
818 defined BENCHMARK_OS_MACOSX || defined BENCHMARK_OS_NETBSD || \
819 defined BENCHMARK_OS_OPENBSD || defined BENCHMARK_OS_DRAGONFLY) && \
820 !(defined(__ANDROID__) && __ANDROID_API__ < 29)
821 static constexpr int kMaxSamples = 3;
822 std::vector<double> res(kMaxSamples, 0.0);
823 const int nelem = getloadavg(res.data(), kMaxSamples);
824 if (nelem < 1) {
825 res.clear();
826 } else {
827 res.resize(nelem);
828 }
829 return res;
830 #else
831 return {};
832 #endif
833 }
834
835 } // end namespace
836
Get()837 const CPUInfo& CPUInfo::Get() {
838 static const CPUInfo* info = new CPUInfo();
839 return *info;
840 }
841
CPUInfo()842 CPUInfo::CPUInfo()
843 : num_cpus(GetNumCPUs()),
844 scaling(CpuScaling(num_cpus)),
845 cycles_per_second(GetCPUCyclesPerSecond(scaling)),
846 caches(GetCacheSizes()),
847 load_avg(GetLoadAvg()) {}
848
Get()849 const SystemInfo& SystemInfo::Get() {
850 static const SystemInfo* info = new SystemInfo();
851 return *info;
852 }
853
SystemInfo()854 SystemInfo::SystemInfo() : name(GetSystemName()) {}
855 } // end namespace benchmark
856