Line data    Source code

       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       59496 : 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             :     return 1;
      38             :   }
      39             :   return ncpu;
      40             : #elif V8_OS_POSIX
      41       59496 :   long result = sysconf(_SC_NPROCESSORS_ONLN);  // NOLINT(runtime/int)
      42       59496 :   if (result == -1) {
      43             :     return 1;
      44             :   }
      45       59496 :   return static_cast<int>(result);
      46             : #elif V8_OS_WIN
      47             :   SYSTEM_INFO system_info = {};
      48             :   ::GetNativeSystemInfo(&system_info);
      49             :   return static_cast<int>(system_info.dwNumberOfProcessors);
      50             : #endif
      51             : }
      52             : 
      53             : 
      54             : // static
      55       28619 : int64_t SysInfo::AmountOfPhysicalMemory() {
      56             : #if V8_OS_MACOSX
      57             :   int mib[2] = {CTL_HW, HW_MEMSIZE};
      58             :   int64_t memsize = 0;
      59             :   size_t len = sizeof(memsize);
      60             :   if (sysctl(mib, arraysize(mib), &memsize, &len, NULL, 0) != 0) {
      61             :     return 0;
      62             :   }
      63             :   return memsize;
      64             : #elif V8_OS_FREEBSD
      65             :   int pages, page_size;
      66             :   size_t size = sizeof(pages);
      67             :   sysctlbyname("vm.stats.vm.v_page_count", &pages, &size, NULL, 0);
      68             :   sysctlbyname("vm.stats.vm.v_page_size", &page_size, &size, NULL, 0);
      69             :   if (pages == -1 || page_size == -1) {
      70             :     return 0;
      71             :   }
      72             :   return static_cast<int64_t>(pages) * page_size;
      73             : #elif V8_OS_CYGWIN || V8_OS_WIN
      74             :   MEMORYSTATUSEX memory_info;
      75             :   memory_info.dwLength = sizeof(memory_info);
      76             :   if (!GlobalMemoryStatusEx(&memory_info)) {
      77             :     return 0;
      78             :   }
      79             :   int64_t result = static_cast<int64_t>(memory_info.ullTotalPhys);
      80             :   if (result < 0) result = std::numeric_limits<int64_t>::max();
      81             :   return result;
      82             : #elif V8_OS_QNX
      83             :   struct stat stat_buf;
      84             :   if (stat("/proc", &stat_buf) != 0) {
      85             :     return 0;
      86             :   }
      87             :   return static_cast<int64_t>(stat_buf.st_size);
      88             : #elif V8_OS_AIX
      89             :   int64_t result = sysconf(_SC_AIX_REALMEM);
      90             :   return static_cast<int64_t>(result) * 1024L;
      91             : #elif V8_OS_POSIX
      92       28619 :   long pages = sysconf(_SC_PHYS_PAGES);    // NOLINT(runtime/int)
      93       28619 :   long page_size = sysconf(_SC_PAGESIZE);  // NOLINT(runtime/int)
      94       28619 :   if (pages == -1 || page_size == -1) {
      95             :     return 0;
      96             :   }
      97       28619 :   return static_cast<int64_t>(pages) * page_size;
      98             : #endif
      99             : }
     100             : 
     101             : 
     102             : // static
     103       28619 : int64_t SysInfo::AmountOfVirtualMemory() {
     104             : #if V8_OS_WIN
     105             :   return 0;
     106             : #elif V8_OS_POSIX
     107             :   struct rlimit rlim;
     108       28619 :   int result = getrlimit(RLIMIT_DATA, &rlim);
     109       28619 :   if (result != 0) {
     110             :     return 0;
     111             :   }
     112       28619 :   return (rlim.rlim_cur == RLIM_INFINITY) ? 0 : rlim.rlim_cur;
     113             : #endif
     114             : }
     115             : 
     116             : }  // namespace base
     117             : }  // namespace v8