Home | History | Annotate | Download | only in base 
      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     return 1;
     38   }
     39   return ncpu;
     40 #elif V8_OS_POSIX
     41   long result = sysconf(_SC_NPROCESSORS_ONLN);  // NOLINT(runtime/int)
     42   if (result == -1) {
     43     return 1;
     44   }
     45   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 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   long pages = sysconf(_SC_PHYS_PAGES);    // NOLINT(runtime/int)
     93   long page_size = sysconf(_SC_PAGESIZE);  // NOLINT(runtime/int)
     94   if (pages == -1 || page_size == -1) {
     95     return 0;
     96   }
     97   return static_cast<int64_t>(pages) * page_size;
     98 #endif
     99 }
    100 
    101 
    102 // static
    103 int64_t SysInfo::AmountOfVirtualMemory() {
    104 #if V8_OS_WIN
    105   return 0;
    106 #elif V8_OS_POSIX
    107   struct rlimit rlim;
    108   int result = getrlimit(RLIMIT_DATA, &rlim);
    109   if (result != 0) {
    110     return 0;
    111   }
    112   return (rlim.rlim_cur == RLIM_INFINITY) ? 0 : rlim.rlim_cur;
    113 #endif
    114 }
    115 
    116 }  // namespace base
    117 }  // namespace v8
    118