[heap] New API for increasing the heap limit for debugging.

src/heap/heap.h

 // Copyright 2012 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_HEAP_HEAP_H_
 #define V8_HEAP_HEAP_H_
 
 #include <cmath>
 #include <map>
 
@@ skipping 932 matching lines @@
   }
 
   bool IsMemoryConstrainedDevice() {
     return max_old_generation_size_ <= kMaxOldSpaceSizeMediumMemoryDevice;
   }
 
   bool HighMemoryPressure() {
     return memory_pressure_level_.Value() != MemoryPressureLevel::kNone;
   }
 
+  void IncreaseHeapLimitForDebugging() {
+    const size_t kDebugHeapSizeFactor = 4;
+    size_t max_limit = std::numeric_limits<size_t>::max() / 4;
+    max_old_generation_size_ =
+        Max(max_old_generation_size_,
+            Min(max_limit, max_old_generation_size_ * kDebugHeapSizeFactor));

[Hannes Payer (out of office), 2016/12/22 11:50:29]

Isn't the requirement on 32-bit to stay within 2G to support dev tools?

[ulan, 2016/12/22 14:04:51]

Yes, max_limit is 1GB on 32-bit.

+  }
+
+  void RestoreOriginalHeapLimit() {
+    // Do not set the limit lower than the live size + some slack.
+    size_t min_limit = SizeOfObjects() + SizeOfObjects() / 4;

[Hannes Payer (out of office), 2016/12/22 11:50:29]

If the restoring of the initial max_old_generation_size_ fails, we are going to
run now with a larger max size. Is that a problem?

[ulan, 2016/12/22 14:04:51]

Yep, we have no choice there. It is probably ok, because the increase is
requested by the user in devtools.

[Hannes Payer (out of office), 2016/12/23 07:49:56]

We could try to set it at the end of a full gc and retry until we reached the
original maximum. Do you think that makes sense?

[ulan, 2016/12/27 12:41:35]

It makes sense as mitigation, but there is no guarantee that GC can reduce heap
to the original maximum. Let's for now keep it simple :)

+    max_old_generation_size_ =
+        Min(max_old_generation_size_,
+            Max(initial_max_old_generation_size_, min_limit));
+  }
+
   // ===========================================================================
   // Initialization. ===========================================================
   // ===========================================================================
 
   // Configure heap size in MB before setup. Return false if the heap has been
   // set up already.
   bool ConfigureHeap(size_t max_semi_space_size, size_t max_old_space_size,
                      size_t max_executable_size, size_t code_range_size);
   bool ConfigureHeapDefault();
 
@@ skipping 1161 matching lines @@
   // This can be calculated directly from a pointer to the heap; however, it is
   // more expedient to get at the isolate directly from within Heap methods.
   Isolate* isolate_;
 
   Object* roots_[kRootListLength];
 
   size_t code_range_size_;
   size_t max_semi_space_size_;
   size_t initial_semispace_size_;
   size_t max_old_generation_size_;
+  size_t initial_max_old_generation_size_;
   size_t initial_old_generation_size_;
   bool old_generation_size_configured_;
   size_t max_executable_size_;
   size_t maximum_committed_;
 
   // For keeping track of how much data has survived
   // scavenge since last new space expansion.
   size_t survived_since_last_expansion_;
 
   // ... and since the last scavenge.
@@ skipping 516 matching lines @@
   friend class LargeObjectSpace;
   friend class NewSpace;
   friend class PagedSpace;
   DISALLOW_COPY_AND_ASSIGN(AllocationObserver);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_HEAP_H_