"src/base/safe_conversions_impl.h",
"src/base/safe_math.h",
"src/base/safe_math_impl.h",
+ "src/base/sys-info.cc",
+ "src/base/sys-info.h",
"src/base/utils/random-number-generator.cc",
"src/base/utils/random-number-generator.h",
]
} // namespace
-int OS::NumberOfProcessorsOnline() {
- return static_cast<int>(sysconf(_SC_NPROCESSORS_ONLN));
-}
-
-
-// Maximum size of the virtual memory. 0 means there is no artificial
-// limit.
-
-intptr_t OS::MaxVirtualMemory() {
- struct rlimit limit;
- int result = getrlimit(RLIMIT_DATA, &limit);
- if (result != 0) return 0;
-#if V8_OS_NACL
- // The NaCl compiler doesn't like resource.h constants.
- if (static_cast<int>(limit.rlim_cur) == -1) return 0;
-#else
- if (limit.rlim_cur == RLIM_INFINITY) return 0;
-#endif
- return limit.rlim_cur;
-}
-
-
-uint64_t OS::TotalPhysicalMemory() {
-#if V8_OS_MACOSX
- int mib[2];
- mib[0] = CTL_HW;
- mib[1] = HW_MEMSIZE;
- int64_t size = 0;
- size_t len = sizeof(size);
- if (sysctl(mib, 2, &size, &len, NULL, 0) != 0) {
- UNREACHABLE();
- return 0;
- }
- return static_cast<uint64_t>(size);
-#elif V8_OS_FREEBSD
- int pages, page_size;
- size_t size = sizeof(pages);
- sysctlbyname("vm.stats.vm.v_page_count", &pages, &size, NULL, 0);
- sysctlbyname("vm.stats.vm.v_page_size", &page_size, &size, NULL, 0);
- if (pages == -1 || page_size == -1) {
- UNREACHABLE();
- return 0;
- }
- return static_cast<uint64_t>(pages) * page_size;
-#elif V8_OS_CYGWIN
- MEMORYSTATUS memory_info;
- memory_info.dwLength = sizeof(memory_info);
- if (!GlobalMemoryStatus(&memory_info)) {
- UNREACHABLE();
- return 0;
- }
- return static_cast<uint64_t>(memory_info.dwTotalPhys);
-#elif V8_OS_QNX
- struct stat stat_buf;
- if (stat("/proc", &stat_buf) != 0) {
- UNREACHABLE();
- return 0;
- }
- return static_cast<uint64_t>(stat_buf.st_size);
-#else
- intptr_t pages = sysconf(_SC_PHYS_PAGES);
- intptr_t page_size = sysconf(_SC_PAGESIZE);
- if (pages == -1 || page_size == -1) {
- UNREACHABLE();
- return 0;
- }
- return static_cast<uint64_t>(pages) * page_size;
-#endif
-}
-
-
int OS::ActivationFrameAlignment() {
#if V8_TARGET_ARCH_ARM
// On EABI ARM targets this is required for fp correctness in the
} // namespace
-intptr_t OS::MaxVirtualMemory() {
- return 0;
-}
-
-
class TimezoneCache {
public:
TimezoneCache() : initialized_(false) { }
}
-uint64_t OS::TotalPhysicalMemory() {
- MEMORYSTATUSEX memory_info;
- memory_info.dwLength = sizeof(memory_info);
- if (!GlobalMemoryStatusEx(&memory_info)) {
- UNREACHABLE();
- return 0;
- }
-
- return static_cast<uint64_t>(memory_info.ullTotalPhys);
-}
-
-
#else // __MINGW32__
std::vector<OS::SharedLibraryAddress> OS::GetSharedLibraryAddresses() {
return std::vector<OS::SharedLibraryAddress>();
#endif // __MINGW32__
-int OS::NumberOfProcessorsOnline() {
- SYSTEM_INFO info;
- GetSystemInfo(&info);
- return info.dwNumberOfProcessors;
-}
-
-
double OS::nan_value() {
#ifdef _MSC_VER
return std::numeric_limits<double>::quiet_NaN();
// using --never-compact) if accurate profiling is desired.
static void SignalCodeMovingGC();
- // Returns the number of processors online.
- static int NumberOfProcessorsOnline();
-
- // The total amount of physical memory available on the current system.
- static uint64_t TotalPhysicalMemory();
-
- // Maximum size of the virtual memory. 0 means there is no artificial
- // limit.
- static intptr_t MaxVirtualMemory();
-
// Returns the double constant NAN
static double nan_value();
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/base/sys-info.h"
+
+#if V8_OS_POSIX
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
+#if V8_OS_BSD
+#include <sys/sysctl.h>
+#endif
+
+#include <limits>
+
+#include "src/base/logging.h"
+#include "src/base/macros.h"
+#if V8_OS_WIN
+#include "src/base/win32-headers.h"
+#endif
+
+namespace v8 {
+namespace base {
+
+// static
+int SysInfo::NumberOfProcessors() {
+#if V8_OS_OPENBSD
+ int mib[2] = {CTL_HW, HW_NCPU};
+ int ncpu = 0;
+ size_t len = sizeof(ncpu);
+ if (sysctl(mib, arraysize(mib), &ncpu, &len, NULL, 0) != 0) {
+ UNREACHABLE();
+ return 1;
+ }
+ return ncpu;
+#elif V8_OS_POSIX
+ long result = sysconf(_SC_NPROCESSORS_ONLN); // NOLINT(runtime/int)
+ if (result == -1) {
+ UNREACHABLE();
+ return 1;
+ }
+ return static_cast<int>(result);
+#elif V8_OS_WIN
+ SYSTEM_INFO system_info = {0};
+ ::GetNativeSystemInfo(&system_info);
+ return static_cast<int>(system_info.dwNumberOfProcessors);
+#endif
+}
+
+
+// static
+int64_t SysInfo::AmountOfPhysicalMemory() {
+#if V8_OS_MACOSX
+ int mib[2] = {CTL_HW, HW_MEMSIZE};
+ int64_t memsize = 0;
+ size_t len = sizeof(memsize);
+ if (sysctl(mib, arraysize(mib), &memsize, &len, NULL, 0) != 0) {
+ UNREACHABLE();
+ return 0;
+ }
+ return memsize;
+#elif V8_OS_FREEBSD
+ int pages, page_size;
+ size_t size = sizeof(pages);
+ sysctlbyname("vm.stats.vm.v_page_count", &pages, &size, NULL, 0);
+ sysctlbyname("vm.stats.vm.v_page_size", &page_size, &size, NULL, 0);
+ if (pages == -1 || page_size == -1) {
+ UNREACHABLE();
+ return 0;
+ }
+ return static_cast<int64_t>(pages) * page_size;
+#elif V8_OS_CYGWIN || V8_OS_WIN
+ MEMORYSTATUSEX memory_info;
+ memory_info.dwLength = sizeof(memory_info);
+ if (!GlobalMemoryStatusEx(&memory_info)) {
+ UNREACHABLE();
+ return 0;
+ }
+ int64_t result = static_cast<int64_t>(memory_info.ullTotalPhys);
+ if (result < 0) result = std::numeric_limits<int64_t>::max();
+ return result;
+#elif V8_OS_QNX
+ struct stat stat_buf;
+ if (stat("/proc", &stat_buf) != 0) {
+ UNREACHABLE();
+ return 0;
+ }
+ return static_cast<int64_t>(stat_buf.st_size);
+#elif V8_OS_POSIX
+ long pages = sysconf(_SC_PHYS_PAGES); // NOLINT(runtime/int)
+ long page_size = sysconf(_SC_PAGESIZE); // NOLINT(runtime/int)
+ if (pages == -1 || page_size == -1) {
+ UNREACHABLE();
+ return 0;
+ }
+ return static_cast<int64_t>(pages) * page_size;
+#endif
+}
+
+
+// static
+int64_t SysInfo::AmountOfVirtualMemory() {
+#if V8_OS_NACL || V8_OS_WIN
+ return 0;
+#elif V8_OS_POSIX
+ struct rlimit rlim;
+ int result = getrlimit(RLIMIT_DATA, &rlim);
+ if (result != 0) {
+ UNREACHABLE();
+ return 0;
+ }
+ return (rlim.rlim_cur == RLIM_INFINITY) ? 0 : rlim.rlim_cur;
+#endif
+}
+
+} // namespace base
+} // namespace v8
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef V8_BASE_SYS_INFO_H_
+#define V8_BASE_SYS_INFO_H_
+
+#include "include/v8stdint.h"
+#include "src/base/build_config.h"
+
+namespace v8 {
+namespace base {
+
+class SysInfo V8_FINAL {
+ public:
+ // Returns the number of logical processors/core on the current machine.
+ static int NumberOfProcessors();
+
+ // Returns the number of bytes of physical memory on the current machine.
+ static int64_t AmountOfPhysicalMemory();
+
+ // Returns the number of bytes of virtual memory of this process. A return
+ // value of zero means that there is no limit on the available virtual memory.
+ static int64_t AmountOfVirtualMemory();
+};
+
+} // namespace base
+} // namespace v8
+
+#endif // V8_BASE_SYS_INFO_H_
#include "src/base/cpu.h"
#include "src/base/logging.h"
#include "src/base/platform/platform.h"
+#include "src/base/sys-info.h"
#include "src/d8-debug.h"
#include "src/debug.h"
#include "src/natives.h"
Isolate* isolate = Isolate::New();
#ifndef V8_SHARED
v8::ResourceConstraints constraints;
- constraints.ConfigureDefaults(base::OS::TotalPhysicalMemory(),
- base::OS::MaxVirtualMemory(),
- base::OS::NumberOfProcessorsOnline());
+ constraints.ConfigureDefaults(base::SysInfo::AmountOfPhysicalMemory(),
+ base::SysInfo::AmountOfVirtualMemory(),
+ base::SysInfo::NumberOfProcessors());
v8::SetResourceConstraints(isolate, &constraints);
#endif
DumbLineEditor dumb_line_editor(isolate);
#include "src/ast.h"
#include "src/base/platform/platform.h"
+#include "src/base/sys-info.h"
#include "src/base/utils/random-number-generator.h"
#include "src/bootstrapper.h"
#include "src/codegen.h"
if (max_available_threads_ < 1) {
// Choose the default between 1 and 4.
max_available_threads_ =
- Max(Min(base::OS::NumberOfProcessorsOnline(), 4), 1);
+ Max(Min(base::SysInfo::NumberOfProcessors(), 4), 1);
}
if (!FLAG_job_based_sweeping) {
#include "src/base/logging.h"
#include "src/base/platform/platform.h"
+#include "src/base/sys-info.h"
#include "src/libplatform/worker-thread.h"
namespace v8 {
void DefaultPlatform::SetThreadPoolSize(int thread_pool_size) {
base::LockGuard<base::Mutex> guard(&lock_);
DCHECK(thread_pool_size >= 0);
- if (thread_pool_size < 1)
- thread_pool_size = base::OS::NumberOfProcessorsOnline();
+ if (thread_pool_size < 1) {
+ thread_pool_size = base::SysInfo::NumberOfProcessors();
+ }
thread_pool_size_ =
std::max(std::min(thread_pool_size, kMaxThreadPoolSize), 1);
}
'platform/platform-unittest.cc',
'platform/semaphore-unittest.cc',
'platform/time-unittest.cc',
+ 'sys-info-unittest.cc',
'utils/random-number-generator-unittest.cc',
],
'conditions': [
}
-TEST(OS, NumberOfProcessorsOnline) {
- EXPECT_GT(OS::NumberOfProcessorsOnline(), 0);
-}
-
-
namespace {
class SelfJoinThread V8_FINAL : public Thread {
--- /dev/null
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/base/sys-info.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace v8 {
+namespace base {
+
+TEST(SysInfoTest, NumberOfProcessors) {
+ EXPECT_LT(0, SysInfo::NumberOfProcessors());
+}
+
+
+TEST(SysInfoTest, AmountOfPhysicalMemory) {
+ EXPECT_LT(0, SysInfo::AmountOfPhysicalMemory());
+}
+
+
+TEST(SysInfoTest, AmountOfVirtualMemory) {
+ EXPECT_LE(0, SysInfo::AmountOfVirtualMemory());
+}
+
+} // namespace base
+} // namespace v8
'../../src/base/safe_conversions_impl.h',
'../../src/base/safe_math.h',
'../../src/base/safe_math_impl.h',
+ '../../src/base/sys-info.cc',
+ '../../src/base/sys-info.h',
'../../src/base/utils/random-number-generator.cc',
'../../src/base/utils/random-number-generator.h',
],