Exponentially increase incremental marking factor each 512 steps.

src/spaces.h

 // Copyright 2011 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 1613 matching lines @@
 
   INLINE(Address MarkbitIndexToAddress(uint32_t index)) {
     return reinterpret_cast<Address>(index << kPointerSizeLog2);
   }
 
   // The allocation top and limit addresses.
   Address* allocation_top_address() { return &allocation_info_.top; }
   Address* allocation_limit_address() { return &allocation_info_.limit; }
 
   MUST_USE_RESULT MaybeObject* AllocateRaw(int size_in_bytes) {
-    return AllocateRawInternal(size_in_bytes, &allocation_info_);
+    return AllocateRawInternal(size_in_bytes);
   }
 
   // Reset the allocation pointer to the beginning of the active semispace.
   void ResetAllocationInfo();
 
+  void LowerInlineAllocationLimit(intptr_t step) {
+    inline_alloction_limit_step_ = step;
+    allocation_info_.limit = Min(
+        allocation_info_.top + inline_alloction_limit_step_,
+        allocation_info_.limit);
+    top_on_previous_step_ = allocation_info_.top;
+  }
+
   // Get the extent of the inactive semispace (for use as a marking stack).
   Address FromSpaceLow() { return from_space_.low(); }
   Address FromSpaceHigh() { return from_space_.high(); }
 
   // Get the extent of the active semispace (to sweep newly copied objects
   // during a scavenge collection).
   Address ToSpaceLow() { return to_space_.low(); }
   Address ToSpaceHigh() { return to_space_.high(); }
 
   // Offsets from the beginning of the semispaces.
@@ skipping 70 matching lines @@
   // Start address and bit mask for containment testing.
   Address start_;
   uintptr_t address_mask_;
   uintptr_t object_mask_;
   uintptr_t object_expected_;
 
   // Allocation pointer and limit for normal allocation and allocation during
   // mark-compact collection.
   AllocationInfo allocation_info_;
 
+  // When incremental marking is active we will set allocation_info_.limit
+  // to be lower than actual limit and then will gradually increase it
+  // in steps to guarantee that we do incremental marking steps even
+  // when all allocation is performed from inlined generated code.
+  intptr_t inline_alloction_limit_step_;
+
+  Address top_on_previous_step_;
+
 #if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
   HistogramInfo* allocated_histogram_;
   HistogramInfo* promoted_histogram_;
 #endif
 
-  // Implementation of AllocateRaw and MCAllocateRaw.
-  MUST_USE_RESULT inline MaybeObject* AllocateRawInternal(
-      int size_in_bytes,
-      AllocationInfo* alloc_info);
+  // Implementation of AllocateRaw.
+  MUST_USE_RESULT inline MaybeObject* AllocateRawInternal(int size_in_bytes);
 
   friend class SemiSpaceIterator;
 
  public:
   TRACK_MEMORY("NewSpace")
 };
 
 
 // -----------------------------------------------------------------------------
 // Old object space (excluding map objects)
@@ skipping 16 matching lines @@
 
   // Prepare for full garbage collection.  Resets the relocation pointer and
   // clears the free list.
   virtual void PrepareForMarkCompact(bool will_compact);
 
  public:
   TRACK_MEMORY("OldSpace")
 };
 
 
+// For contiguous spaces, top should be in the space (or at the end) and limit
+// should be the end of the space.
+#define ASSERT_SEMISPACE_ALLOCATION_INFO(info, space) \
+  ASSERT((space).low() <= (info).top                  \
+         && (info).top <= (space).high()              \
+         && (info).limit <= (space).high())
+
+
 // -----------------------------------------------------------------------------
 // Old space for objects of a fixed size
 
 class FixedSpace : public PagedSpace {
  public:
   FixedSpace(intptr_t max_capacity,
              AllocationSpace id,
              int object_size_in_bytes,
              const char* name)
       : PagedSpace(max_capacity, id, NOT_EXECUTABLE),
@@ skipping 216 matching lines @@
 
  private:
   LargePage* current_;
   HeapObjectCallback size_func_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_