Ignore soft heap limit when reserving space.

src/heap.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1026 matching lines @@
   // Performs garbage collection operation.
   // Returns whether there is a chance that another major GC could
   // collect more garbage.
   inline bool CollectGarbage(AllocationSpace space,
                              const char* gc_reason = NULL);
 
   static const int kNoGCFlags = 0;
   static const int kMakeHeapIterableMask = 1;
   static const int kReduceMemoryFootprintMask = 2;
 
+  inline bool AbortIncrementalMarkingAndCollectGarbage(

[Michael Starzinger, 2012/03/07 15:52:42]

Could we make this a static helper method in heap.cc? Because I really want to
avoid adding yet another entry method which people need to understand when
requesting a GC. I already hate CollectAllAvailableGarbage().

[ulan, 2012/03/07 16:04:30]

Done.

+      AllocationSpace space, const char* gc_reason = NULL) {
+    mark_compact_collector()->SetFlags(kMakeHeapIterableMask);
+    bool result = CollectGarbage(space, gc_reason);
+    mark_compact_collector()->SetFlags(kNoGCFlags);
+    return result;
+  }
+
   // Performs a full garbage collection.  If (flags & kMakeHeapIterableMask) is
   // non-zero, then the slower precise sweeper is used, which leaves the heap
   // in a state where we can iterate over the heap visiting all objects.
   void CollectAllGarbage(int flags, const char* gc_reason = NULL);
 
   // Last hope GC, should try to squeeze as much as possible.
   void CollectAllAvailableGarbage(const char* gc_reason = NULL);
 
   // Check whether the heap is currently iterable.
   bool IsHeapIterable();
@@ skipping 278 matching lines @@
   // True if we have reached the allocation limit in the old generation that
   // should force the next GC (caused normally) to be a full one.
   inline bool OldGenerationPromotionLimitReached() {
     return PromotedTotalSize() > old_gen_promotion_limit_;
   }
 
   inline intptr_t OldGenerationSpaceAvailable() {
     return old_gen_allocation_limit_ - PromotedTotalSize();
   }
 
+  inline intptr_t OldGenerationCapacityAvailable() {
+    return max_old_generation_size_ - PromotedTotalSize();
+  }
+
   static const intptr_t kMinimumPromotionLimit = 5 * Page::kPageSize;
   static const intptr_t kMinimumAllocationLimit =
       8 * (Page::kPageSize > MB ? Page::kPageSize : MB);
 
   // When we sweep lazily we initially guess that there is no garbage on the
   // heap and set the limits for the next GC accordingly.  As we sweep we find
   // out that some of the pages contained garbage and we have to adjust
   // downwards the size of the heap.  This means the limits that control the
   // timing of the next GC also need to be adjusted downwards.
   void LowerOldGenLimits(intptr_t adjustment) {
@@ skipping 1306 matching lines @@
   AssertNoAllocation no_alloc;  // i.e. no gc allowed.
 
  private:
   DISALLOW_IMPLICIT_CONSTRUCTORS(PathTracer);
 };
 #endif  // DEBUG || LIVE_OBJECT_LIST
 
 } }  // namespace v8::internal
 
 #endif  // V8_HEAP_H_