utils/benchmark/src/sysinfo.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 "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 #else
  23 #include <fcntl.h>
  24 #ifndef BENCHMARK_OS_FUCHSIA
  25 #include <sys/resource.h>
  26 #endif
  27 #include <sys/time.h>
  28 #include <sys/types.h>  // this header must be included before 'sys/sysctl.h' to avoid compilation error on FreeBSD
  29 #include <unistd.h>
  30 #if defined BENCHMARK_OS_FREEBSD || defined BENCHMARK_OS_MACOSX || \
  31     defined BENCHMARK_OS_NETBSD || defined BENCHMARK_OS_OPENBSD
  32 #define BENCHMARK_HAS_SYSCTL
  33 #include <sys/sysctl.h>
  34 #endif
  35 #endif
  36 #if defined(BENCHMARK_OS_SOLARIS)
  37 #include <kstat.h>
  38 #endif
  39
  40 #include <algorithm>
  41 #include <array>
  42 #include <bitset>
  43 #include <cerrno>
  44 #include <climits>
  45 #include <cstdint>
  46 #include <cstdio>
  47 #include <cstdlib>
  48 #include <cstring>
  49 #include <fstream>
  50 #include <iostream>
  51 #include <iterator>
  52 #include <limits>
  53 #include <memory>
  54 #include <sstream>
  55
  56 #include "check.h"
  57 #include "cycleclock.h"
  58 #include "internal_macros.h"
  59 #include "log.h"
  60 #include "sleep.h"
  61 #include "string_util.h"
  62
  63 namespace benchmark {
  64 namespace {
  65
  66 void PrintImp(std::ostream& out) { out << std::endl; }
  67
  68 template <class First, class... Rest>
  69 void PrintImp(std::ostream& out, First&& f, Rest&&... rest) {
  70   out << std::forward<First>(f);
  71   PrintImp(out, std::forward<Rest>(rest)...);
  72 }
  73
  74 template <class... Args>
  75 BENCHMARK_NORETURN void PrintErrorAndDie(Args&&... args) {
  76   PrintImp(std::cerr, std::forward<Args>(args)...);
  77   std::exit(EXIT_FAILURE);
  78 }
  79
  80 #ifdef BENCHMARK_HAS_SYSCTL
  81
  82 /// ValueUnion - A type used to correctly alias the byte-for-byte output of
  83 /// `sysctl` with the result type it's to be interpreted as.
  84 struct ValueUnion {
  85   union DataT {
  86     uint32_t uint32_value;
  87     uint64_t uint64_value;
  88     // For correct aliasing of union members from bytes.
  89     char bytes[8];
  90   };
  91   using DataPtr = std::unique_ptr<DataT, decltype(&std::free)>;
  92
  93   // The size of the data union member + its trailing array size.
  94   size_t Size;
  95   DataPtr Buff;
  96
  97  public:
  98   ValueUnion() : Size(0), Buff(nullptr, &std::free) {}
  99
 100   explicit ValueUnion(size_t BuffSize)
 101       : Size(sizeof(DataT) + BuffSize),
 102         Buff(::new (std::malloc(Size)) DataT(), &std::free) {}
 103
 104   ValueUnion(ValueUnion&& other) = default;
 105
 106   explicit operator bool() const { return bool(Buff); }
 107
 108   char* data() const { return Buff->bytes; }
 109
 110   std::string GetAsString() const { return std::string(data()); }
 111
 112   int64_t GetAsInteger() const {
 113     if (Size == sizeof(Buff->uint32_value))
 114       return static_cast<int32_t>(Buff->uint32_value);
 115     else if (Size == sizeof(Buff->uint64_value))
 116       return static_cast<int64_t>(Buff->uint64_value);
 117     BENCHMARK_UNREACHABLE();
 118   }
 119
 120   uint64_t GetAsUnsigned() const {
 121     if (Size == sizeof(Buff->uint32_value))
 122       return Buff->uint32_value;
 123     else if (Size == sizeof(Buff->uint64_value))
 124       return Buff->uint64_value;
 125     BENCHMARK_UNREACHABLE();
 126   }
 127
 128   template <class T, int N>
 129   std::array<T, N> GetAsArray() {
 130     const int ArrSize = sizeof(T) * N;
 131     CHECK_LE(ArrSize, Size);
 132     std::array<T, N> Arr;
 133     std::memcpy(Arr.data(), data(), ArrSize);
 134     return Arr;
 135   }
 136 };
 137
 138 ValueUnion GetSysctlImp(std::string const& Name) {
 139 #if defined BENCHMARK_OS_OPENBSD
 140   int mib[2];
 141
 142   mib[0] = CTL_HW;
 143   if ((Name == "hw.ncpu") || (Name == "hw.cpuspeed")){
 144     ValueUnion buff(sizeof(int));
 145
 146     if (Name == "hw.ncpu") {
 147       mib[1] = HW_NCPU;
 148     } else {
 149       mib[1] = HW_CPUSPEED;
 150     }
 151
 152     if (sysctl(mib, 2, buff.data(), &buff.Size, nullptr, 0) == -1) {
 153       return ValueUnion();
 154     }
 155     return buff;
 156   }
 157   return ValueUnion();
 158 #else
 159   size_t CurBuffSize = 0;
 160   if (sysctlbyname(Name.c_str(), nullptr, &CurBuffSize, nullptr, 0) == -1)
 161     return ValueUnion();
 162
 163   ValueUnion buff(CurBuffSize);
 164   if (sysctlbyname(Name.c_str(), buff.data(), &buff.Size, nullptr, 0) == 0)
 165     return buff;
 166   return ValueUnion();
 167 #endif
 168 }
 169
 170 BENCHMARK_MAYBE_UNUSED
 171 bool GetSysctl(std::string const& Name, std::string* Out) {
 172   Out->clear();
 173   auto Buff = GetSysctlImp(Name);
 174   if (!Buff) return false;
 175   Out->assign(Buff.data());
 176   return true;
 177 }
 178
 179 template <class Tp,
 180           class = typename std::enable_if<std::is_integral<Tp>::value>::type>
 181 bool GetSysctl(std::string const& Name, Tp* Out) {
 182   *Out = 0;
 183   auto Buff = GetSysctlImp(Name);
 184   if (!Buff) return false;
 185   *Out = static_cast<Tp>(Buff.GetAsUnsigned());
 186   return true;
 187 }
 188
 189 template <class Tp, size_t N>
 190 bool GetSysctl(std::string const& Name, std::array<Tp, N>* Out) {
 191   auto Buff = GetSysctlImp(Name);
 192   if (!Buff) return false;
 193   *Out = Buff.GetAsArray<Tp, N>();
 194   return true;
 195 }
 196 #endif
 197
 198 template <class ArgT>
 199 bool ReadFromFile(std::string const& fname, ArgT* arg) {
 200   *arg = ArgT();
 201   std::ifstream f(fname.c_str());
 202   if (!f.is_open()) return false;
 203   f >> *arg;
 204   return f.good();
 205 }
 206
 207 bool CpuScalingEnabled(int num_cpus) {
 208   // We don't have a valid CPU count, so don't even bother.
 209   if (num_cpus <= 0) return false;
 210 #ifndef BENCHMARK_OS_WINDOWS
 211   // On Linux, the CPUfreq subsystem exposes CPU information as files on the
 212   // local file system. If reading the exported files fails, then we may not be
 213   // running on Linux, so we silently ignore all the read errors.
 214   std::string res;
 215   for (int cpu = 0; cpu < num_cpus; ++cpu) {
 216     std::string governor_file =
 217         StrCat("/sys/devices/system/cpu/cpu", cpu, "/cpufreq/scaling_governor");
 218     if (ReadFromFile(governor_file, &res) && res != "performance") return true;
 219   }
 220 #endif
 221   return false;
 222 }
 223
 224 int CountSetBitsInCPUMap(std::string Val) {
 225   auto CountBits = [](std::string Part) {
 226     using CPUMask = std::bitset<sizeof(std::uintptr_t) * CHAR_BIT>;
 227     Part = "0x" + Part;
 228     CPUMask Mask(std::stoul(Part, nullptr, 16));
 229     return static_cast<int>(Mask.count());
 230   };
 231   size_t Pos;
 232   int total = 0;
 233   while ((Pos = Val.find(',')) != std::string::npos) {
 234     total += CountBits(Val.substr(0, Pos));
 235     Val = Val.substr(Pos + 1);
 236   }
 237   if (!Val.empty()) {
 238     total += CountBits(Val);
 239   }
 240   return total;
 241 }
 242
 243 BENCHMARK_MAYBE_UNUSED
 244 std::vector<CPUInfo::CacheInfo> GetCacheSizesFromKVFS() {
 245   std::vector<CPUInfo::CacheInfo> res;
 246   std::string dir = "/sys/devices/system/cpu/cpu0/cache/";
 247   int Idx = 0;
 248   while (true) {
 249     CPUInfo::CacheInfo info;
 250     std::string FPath = StrCat(dir, "index", Idx++, "/");
 251     std::ifstream f(StrCat(FPath, "size").c_str());
 252     if (!f.is_open()) break;
 253     std::string suffix;
 254     f >> info.size;
 255     if (f.fail())
 256       PrintErrorAndDie("Failed while reading file '", FPath, "size'");
 257     if (f.good()) {
 258       f >> suffix;
 259       if (f.bad())
 260         PrintErrorAndDie(
 261             "Invalid cache size format: failed to read size suffix");
 262       else if (f && suffix != "K")
 263         PrintErrorAndDie("Invalid cache size format: Expected bytes ", suffix);
 264       else if (suffix == "K")
 265         info.size *= 1000;
 266     }
 267     if (!ReadFromFile(StrCat(FPath, "type"), &info.type))
 268       PrintErrorAndDie("Failed to read from file ", FPath, "type");
 269     if (!ReadFromFile(StrCat(FPath, "level"), &info.level))
 270       PrintErrorAndDie("Failed to read from file ", FPath, "level");
 271     std::string map_str;
 272     if (!ReadFromFile(StrCat(FPath, "shared_cpu_map"), &map_str))
 273       PrintErrorAndDie("Failed to read from file ", FPath, "shared_cpu_map");
 274     info.num_sharing = CountSetBitsInCPUMap(map_str);
 275     res.push_back(info);
 276   }
 277
 278   return res;
 279 }
 280
 281 #ifdef BENCHMARK_OS_MACOSX
 282 std::vector<CPUInfo::CacheInfo> GetCacheSizesMacOSX() {
 283   std::vector<CPUInfo::CacheInfo> res;
 284   std::array<uint64_t, 4> CacheCounts{{0, 0, 0, 0}};
 285   GetSysctl("hw.cacheconfig", &CacheCounts);
 286
 287   struct {
 288     std::string name;
 289     std::string type;
 290     int level;
 291     uint64_t num_sharing;
 292   } Cases[] = {{"hw.l1dcachesize", "Data", 1, CacheCounts[1]},
 293                {"hw.l1icachesize", "Instruction", 1, CacheCounts[1]},
 294                {"hw.l2cachesize", "Unified", 2, CacheCounts[2]},
 295                {"hw.l3cachesize", "Unified", 3, CacheCounts[3]}};
 296   for (auto& C : Cases) {
 297     int val;
 298     if (!GetSysctl(C.name, &val)) continue;
 299     CPUInfo::CacheInfo info;
 300     info.type = C.type;
 301     info.level = C.level;
 302     info.size = val;
 303     info.num_sharing = static_cast<int>(C.num_sharing);
 304     res.push_back(std::move(info));
 305   }
 306   return res;
 307 }
 308 #elif defined(BENCHMARK_OS_WINDOWS)
 309 std::vector<CPUInfo::CacheInfo> GetCacheSizesWindows() {
 310   std::vector<CPUInfo::CacheInfo> res;
 311   DWORD buffer_size = 0;
 312   using PInfo = SYSTEM_LOGICAL_PROCESSOR_INFORMATION;
 313   using CInfo = CACHE_DESCRIPTOR;
 314
 315   using UPtr = std::unique_ptr<PInfo, decltype(&std::free)>;
 316   GetLogicalProcessorInformation(nullptr, &buffer_size);
 317   UPtr buff((PInfo*)malloc(buffer_size), &std::free);
 318   if (!GetLogicalProcessorInformation(buff.get(), &buffer_size))
 319     PrintErrorAndDie("Failed during call to GetLogicalProcessorInformation: ",
 320                      GetLastError());
 321
 322   PInfo* it = buff.get();
 323   PInfo* end = buff.get() + (buffer_size / sizeof(PInfo));
 324
 325   for (; it != end; ++it) {
 326     if (it->Relationship != RelationCache) continue;
 327     using BitSet = std::bitset<sizeof(ULONG_PTR) * CHAR_BIT>;
 328     BitSet B(it->ProcessorMask);
 329     // To prevent duplicates, only consider caches where CPU 0 is specified
 330     if (!B.test(0)) continue;
 331     CInfo* Cache = &it->Cache;
 332     CPUInfo::CacheInfo C;
 333     C.num_sharing = static_cast<int>(B.count());
 334     C.level = Cache->Level;
 335     C.size = Cache->Size;
 336     switch (Cache->Type) {
 337       case CacheUnified:
 338         C.type = "Unified";
 339         break;
 340       case CacheInstruction:
 341         C.type = "Instruction";
 342         break;
 343       case CacheData:
 344         C.type = "Data";
 345         break;
 346       case CacheTrace:
 347         C.type = "Trace";
 348         break;
 349       default:
 350         C.type = "Unknown";
 351         break;
 352     }
 353     res.push_back(C);
 354   }
 355   return res;
 356 }
 357 #endif
 358
 359 std::vector<CPUInfo::CacheInfo> GetCacheSizes() {
 360 #ifdef BENCHMARK_OS_MACOSX
 361   return GetCacheSizesMacOSX();
 362 #elif defined(BENCHMARK_OS_WINDOWS)
 363   return GetCacheSizesWindows();
 364 #else
 365   return GetCacheSizesFromKVFS();
 366 #endif
 367 }
 368
 369 int GetNumCPUs() {
 370 #ifdef BENCHMARK_HAS_SYSCTL
 371   int NumCPU = -1;
 372   if (GetSysctl("hw.ncpu", &NumCPU)) return NumCPU;
 373   fprintf(stderr, "Err: %s\n", strerror(errno));
 374   std::exit(EXIT_FAILURE);
 375 #elif defined(BENCHMARK_OS_WINDOWS)
 376   SYSTEM_INFO sysinfo;
 377   // Use memset as opposed to = {} to avoid GCC missing initializer false
 378   // positives.
 379   std::memset(&sysinfo, 0, sizeof(SYSTEM_INFO));
 380   GetSystemInfo(&sysinfo);
 381   return sysinfo.dwNumberOfProcessors;  // number of logical
 382                                         // processors in the current
 383                                         // group
 384 #elif defined(BENCHMARK_OS_SOLARIS)
 385   // Returns -1 in case of a failure.
 386   int NumCPU = sysconf(_SC_NPROCESSORS_ONLN);
 387   if (NumCPU < 0) {
 388     fprintf(stderr,
 389             "sysconf(_SC_NPROCESSORS_ONLN) failed with error: %s\n",
 390             strerror(errno));
 391   }
 392   return NumCPU;
 393 #else
 394   int NumCPUs = 0;
 395   int MaxID = -1;
 396   std::ifstream f("/proc/cpuinfo");
 397   if (!f.is_open()) {
 398     std::cerr << "failed to open /proc/cpuinfo\n";
 399     return -1;
 400   }
 401   const std::string Key = "processor";
 402   std::string ln;
 403   while (std::getline(f, ln)) {
 404     if (ln.empty()) continue;
 405     size_t SplitIdx = ln.find(':');
 406     std::string value;
 407     if (SplitIdx != std::string::npos) value = ln.substr(SplitIdx + 1);
 408     if (ln.size() >= Key.size() && ln.compare(0, Key.size(), Key) == 0) {
 409       NumCPUs++;
 410       if (!value.empty()) {
 411         int CurID = std::stoi(value);
 412         MaxID = std::max(CurID, MaxID);
 413       }
 414     }
 415   }
 416   if (f.bad()) {
 417     std::cerr << "Failure reading /proc/cpuinfo\n";
 418     return -1;
 419   }
 420   if (!f.eof()) {
 421     std::cerr << "Failed to read to end of /proc/cpuinfo\n";
 422     return -1;
 423   }
 424   f.close();
 425
 426   if ((MaxID + 1) != NumCPUs) {
 427     fprintf(stderr,
 428             "CPU ID assignments in /proc/cpuinfo seem messed up."
 429             " This is usually caused by a bad BIOS.\n");
 430   }
 431   return NumCPUs;
 432 #endif
 433   BENCHMARK_UNREACHABLE();
 434 }
 435
 436 double GetCPUCyclesPerSecond() {
 437 #if defined BENCHMARK_OS_LINUX || defined BENCHMARK_OS_CYGWIN
 438   long freq;
 439
 440   // If the kernel is exporting the tsc frequency use that. There are issues
 441   // where cpuinfo_max_freq cannot be relied on because the BIOS may be
 442   // exporintg an invalid p-state (on x86) or p-states may be used to put the
 443   // processor in a new mode (turbo mode). Essentially, those frequencies
 444   // cannot always be relied upon. The same reasons apply to /proc/cpuinfo as
 445   // well.
 446   if (ReadFromFile("/sys/devices/system/cpu/cpu0/tsc_freq_khz", &freq)
 447       // If CPU scaling is in effect, we want to use the *maximum* frequency,
 448       // not whatever CPU speed some random processor happens to be using now.
 449       || ReadFromFile("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq",
 450                       &freq)) {
 451     // The value is in kHz (as the file name suggests).  For example, on a
 452     // 2GHz warpstation, the file contains the value "2000000".
 453     return freq * 1000.0;
 454   }
 455
 456   const double error_value = -1;
 457   double bogo_clock = error_value;
 458
 459   std::ifstream f("/proc/cpuinfo");
 460   if (!f.is_open()) {
 461     std::cerr << "failed to open /proc/cpuinfo\n";
 462     return error_value;
 463   }
 464
 465   auto startsWithKey = [](std::string const& Value, std::string const& Key) {
 466     if (Key.size() > Value.size()) return false;
 467     auto Cmp = [&](char X, char Y) {
 468       return std::tolower(X) == std::tolower(Y);
 469     };
 470     return std::equal(Key.begin(), Key.end(), Value.begin(), Cmp);
 471   };
 472
 473   std::string ln;
 474   while (std::getline(f, ln)) {
 475     if (ln.empty()) continue;
 476     size_t SplitIdx = ln.find(':');
 477     std::string value;
 478     if (SplitIdx != std::string::npos) value = ln.substr(SplitIdx + 1);
 479     // When parsing the "cpu MHz" and "bogomips" (fallback) entries, we only
 480     // accept positive values. Some environments (virtual machines) report zero,
 481     // which would cause infinite looping in WallTime_Init.
 482     if (startsWithKey(ln, "cpu MHz")) {
 483       if (!value.empty()) {
 484         double cycles_per_second = std::stod(value) * 1000000.0;
 485         if (cycles_per_second > 0) return cycles_per_second;
 486       }
 487     } else if (startsWithKey(ln, "bogomips")) {
 488       if (!value.empty()) {
 489         bogo_clock = std::stod(value) * 1000000.0;
 490         if (bogo_clock < 0.0) bogo_clock = error_value;
 491       }
 492     }
 493   }
 494   if (f.bad()) {
 495     std::cerr << "Failure reading /proc/cpuinfo\n";
 496     return error_value;
 497   }
 498   if (!f.eof()) {
 499     std::cerr << "Failed to read to end of /proc/cpuinfo\n";
 500     return error_value;
 501   }
 502   f.close();
 503   // If we found the bogomips clock, but nothing better, we'll use it (but
 504   // we're not happy about it); otherwise, fallback to the rough estimation
 505   // below.
 506   if (bogo_clock >= 0.0) return bogo_clock;
 507
 508 #elif defined BENCHMARK_HAS_SYSCTL
 509   constexpr auto* FreqStr =
 510 #if defined(BENCHMARK_OS_FREEBSD) || defined(BENCHMARK_OS_NETBSD)
 511       "machdep.tsc_freq";
 512 #elif defined BENCHMARK_OS_OPENBSD
 513       "hw.cpuspeed";
 514 #else
 515       "hw.cpufrequency";
 516 #endif
 517   unsigned long long hz = 0;
 518 #if defined BENCHMARK_OS_OPENBSD
 519   if (GetSysctl(FreqStr, &hz)) return hz * 1000000;
 520 #else
 521   if (GetSysctl(FreqStr, &hz)) return hz;
 522 #endif
 523   fprintf(stderr, "Unable to determine clock rate from sysctl: %s: %s\n",
 524           FreqStr, strerror(errno));
 525
 526 #elif defined BENCHMARK_OS_WINDOWS
 527   // In NT, read MHz from the registry. If we fail to do so or we're in win9x
 528   // then make a crude estimate.
 529   DWORD data, data_size = sizeof(data);
 530   if (IsWindowsXPOrGreater() &&
 531       SUCCEEDED(
 532           SHGetValueA(HKEY_LOCAL_MACHINE,
 533                       "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
 534                       "~MHz", nullptr, &data, &data_size)))
 535     return static_cast<double>((int64_t)data *
 536                                (int64_t)(1000 * 1000));  // was mhz
 537 #elif defined (BENCHMARK_OS_SOLARIS)
 538   kstat_ctl_t *kc = kstat_open();
 539   if (!kc) {
 540     std::cerr << "failed to open /dev/kstat\n";
 541     return -1;
 542   }
 543   kstat_t *ksp = kstat_lookup(kc, (char*)"cpu_info", -1, (char*)"cpu_info0");
 544   if (!ksp) {
 545     std::cerr << "failed to lookup in /dev/kstat\n";
 546     return -1;
 547   }
 548   if (kstat_read(kc, ksp, NULL) < 0) {
 549     std::cerr << "failed to read from /dev/kstat\n";
 550     return -1;
 551   }
 552   kstat_named_t *knp =
 553       (kstat_named_t*)kstat_data_lookup(ksp, (char*)"current_clock_Hz");
 554   if (!knp) {
 555     std::cerr << "failed to lookup data in /dev/kstat\n";
 556     return -1;
 557   }
 558   if (knp->data_type != KSTAT_DATA_UINT64) {
 559     std::cerr << "current_clock_Hz is of unexpected data type: "
 560               << knp->data_type << "\n";
 561     return -1;
 562   }
 563   double clock_hz = knp->value.ui64;
 564   kstat_close(kc);
 565   return clock_hz;
 566 #endif
 567   // If we've fallen through, attempt to roughly estimate the CPU clock rate.
 568   const int estimate_time_ms = 1000;
 569   const auto start_ticks = cycleclock::Now();
 570   SleepForMilliseconds(estimate_time_ms);
 571   return static_cast<double>(cycleclock::Now() - start_ticks);
 572 }
 573
 574 }  // end namespace
 575
 576 const CPUInfo& CPUInfo::Get() {
 577   static const CPUInfo* info = new CPUInfo();
 578   return *info;
 579 }
 580
 581 CPUInfo::CPUInfo()
 582     : num_cpus(GetNumCPUs()),
 583       cycles_per_second(GetCPUCyclesPerSecond()),
 584       caches(GetCacheSizes()),
 585       scaling_enabled(CpuScalingEnabled(num_cpus)) {}
 586
 587 }  // end namespace benchmark