• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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