Lower heap size limits on systems that are short of virtual memory.

Review URL: http://codereview.chromium.org/7020020

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@8133 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

diff --git a/src/heap.cc b/src/heap.cc
index 1b46184..87b62b7 100644 (file)
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -152,6 +152,29 @@ Heap::Heap()
   max_semispace_size_ = reserved_semispace_size_ = V8_MAX_SEMISPACE_SIZE;
 #endif
 
+  intptr_t max_virtual = OS::MaxVirtualMemory();
+
+  if (max_virtual > 0) {
+    intptr_t half = max_virtual >> 1;
+    intptr_t quarter = max_virtual >> 2;
+    // If we have limits on the amount of virtual memory we can use then we may
+    // be forced to lower the allocation limits.  We reserve one quarter of the
+    // memory for young space and off-heap data.  The rest is distributed as
+    // described below.
+    if (code_range_size_ > 0) {
+      // Reserve a quarter of the memory for the code range.  The old space
+      // heap gets the remaining half.  There is some unavoidable double
+      // counting going on here since the heap size is measured in committed
+      // virtual memory and the code range is only reserved virtual memory.
+      code_range_size_ = Min(code_range_size_, quarter);
+      max_old_generation_size_ = Min(max_old_generation_size_, half);
+    } else {
+      // Reserve three quarters of the memory for the old space heap including
+      // the executable code.
+      max_old_generation_size_ = Min(max_old_generation_size_, half + quarter);
+    }
+  }
+
   memset(roots_, 0, sizeof(roots_[0]) * kRootListLength);
   global_contexts_list_ = NULL;
   mark_compact_collector_.heap_ = this;

diff --git a/src/platform-posix.cc b/src/platform-posix.cc
index c4b0fb8..83f6c81 100644 (file)
--- a/src/platform-posix.cc
+++ b/src/platform-posix.cc
@@ -54,6 +54,18 @@
 namespace v8 {
 namespace internal {
 
+
+// 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;
+  return limit.rlim_cur;
+}
+
+
 // ----------------------------------------------------------------------------
 // Math functions
 

diff --git a/src/platform-win32.cc b/src/platform-win32.cc
index 8673f04..83264a9 100644 (file)
--- a/src/platform-win32.cc
+++ b/src/platform-win32.cc
@@ -44,6 +44,11 @@
 namespace v8 {
 namespace internal {
 
+intptr_t OS::MaxVirtualMemory() {
+  return 0;
+}
+
+
 // Test for finite value - usually defined in math.h
 int isfinite(double x) {
   return _finite(x);

diff --git a/src/platform.h b/src/platform.h
index 725008a..0237379 100644 (file)
--- a/src/platform.h
+++ b/src/platform.h
@@ -288,6 +288,10 @@ class OS {
   // positions indicated by the members of the CpuFeature enum from globals.h
   static uint64_t CpuFeaturesImpliedByPlatform();
 
+  // 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();