src/v8/src/base/sys-info.cc

   1 // Copyright 2014 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "src/base/sys-info.h"
   6
   7 #if V8_OS_POSIX
   8 #include <sys/resource.h>
   9 #include <sys/stat.h>
  10 #include <sys/time.h>
  11 #include <sys/types.h>
  12 #include <unistd.h>
  13 #endif
  14
  15 #if V8_OS_BSD
  16 #include <sys/sysctl.h>
  17 #endif
  18
  19 #include <limits>
  20
  21 #include "src/base/logging.h"
  22 #include "src/base/macros.h"
  23 #if V8_OS_WIN
  24 #include "src/base/win32-headers.h"
  25 #endif
  26
  27 namespace v8 {
  28 namespace base {
  29
  30 // static
  31 int SysInfo::NumberOfProcessors() {
  32 #if V8_OS_OPENBSD
  33   int mib[2] = {CTL_HW, HW_NCPU};
  34   int ncpu = 0;
  35   size_t len = sizeof(ncpu);
  36   if (sysctl(mib, arraysize(mib), &ncpu, &len, NULL, 0) != 0) {
  37     UNREACHABLE();
  38     return 1;
  39   }
  40   return ncpu;
  41 #elif V8_OS_POSIX
  42   long result = sysconf(_SC_NPROCESSORS_ONLN);  // NOLINT(runtime/int)
  43   if (result == -1) {
  44     UNREACHABLE();
  45     return 1;
  46   }
  47   return static_cast<int>(result);
  48 #elif V8_OS_WIN
  49   SYSTEM_INFO system_info = {0};
  50   ::GetNativeSystemInfo(&system_info);
  51   return static_cast<int>(system_info.dwNumberOfProcessors);
  52 #endif
  53 }
  54
  55
  56 // static
  57 int64_t SysInfo::AmountOfPhysicalMemory() {
  58 #if V8_OS_MACOSX
  59   int mib[2] = {CTL_HW, HW_MEMSIZE};
  60   int64_t memsize = 0;
  61   size_t len = sizeof(memsize);
  62   if (sysctl(mib, arraysize(mib), &memsize, &len, NULL, 0) != 0) {
  63     UNREACHABLE();
  64     return 0;
  65   }
  66   return memsize;
  67 #elif V8_OS_FREEBSD
  68   int pages, page_size;
  69   size_t size = sizeof(pages);
  70   sysctlbyname("vm.stats.vm.v_page_count", &pages, &size, NULL, 0);
  71   sysctlbyname("vm.stats.vm.v_page_size", &page_size, &size, NULL, 0);
  72   if (pages == -1 || page_size == -1) {
  73     UNREACHABLE();
  74     return 0;
  75   }
  76   return static_cast<int64_t>(pages) * page_size;
  77 #elif V8_OS_CYGWIN || V8_OS_WIN
  78   MEMORYSTATUSEX memory_info;
  79   memory_info.dwLength = sizeof(memory_info);
  80   if (!GlobalMemoryStatusEx(&memory_info)) {
  81     UNREACHABLE();
  82     return 0;
  83   }
  84   int64_t result = static_cast<int64_t>(memory_info.ullTotalPhys);
  85   if (result < 0) result = std::numeric_limits<int64_t>::max();
  86   return result;
  87 #elif V8_OS_QNX
  88   struct stat stat_buf;
  89   if (stat("/proc", &stat_buf) != 0) {
  90     UNREACHABLE();
  91     return 0;
  92   }
  93   return static_cast<int64_t>(stat_buf.st_size);
  94 #elif V8_OS_NACL
  95   // No support for _SC_PHYS_PAGES, assume 2GB.
  96   return static_cast<int64_t>(1) << 31;
  97 #elif V8_OS_POSIX
  98   long pages = sysconf(_SC_PHYS_PAGES);    // NOLINT(runtime/int)
  99   long page_size = sysconf(_SC_PAGESIZE);  // NOLINT(runtime/int)
 100   if (pages == -1 || page_size == -1) {
 101     UNREACHABLE();
 102     return 0;
 103   }
 104   return static_cast<int64_t>(pages) * page_size;
 105 #endif
 106 }
 107
 108
 109 // static
 110 int64_t SysInfo::AmountOfVirtualMemory() {
 111 #if V8_OS_NACL || V8_OS_WIN
 112   return 0;
 113 #elif V8_OS_POSIX
 114   struct rlimit rlim;
 115   int result = getrlimit(RLIMIT_DATA, &rlim);
 116   if (result != 0) {
 117     UNREACHABLE();
 118     return 0;
 119   }
 120   return (rlim.rlim_cur == RLIM_INFINITY) ? 0 : rlim.rlim_cur;
 121 #endif
 122 }
 123
 124 }  // namespace base
 125 }  // namespace v8