Allow partial scanning of large arrays in order to avoid

src/mark-compact.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 222 matching lines @@
       array_[bottom_] = object;
     }
   }
 
   HeapObject** array() { return array_; }
   int bottom() { return bottom_; }
   int top() { return top_; }
   int mask() { return mask_; }
   void set_top(int top) { top_ = top; }
 
+  int space_left() {
+    // If we already overflowed we may as well just say there is lots of
+    // space left.
+    if (overflowed_) return mask_ + 1;
+    if (IsEmpty()) return mask_ + 1;
+    if (IsFull()) return 0;
+    return (bottom_ - top_) & mask_;
+  }
+
+#ifdef DEBUG
+  const char* Status() {
+    if (overflowed_) return "Overflowed";
+    if (IsEmpty()) return "Empty";
+    if (IsFull()) return "Full";
+    int oct = (((top_ - bottom_) & mask_) * 8) / (mask_ + 1);
+    switch (oct) {
+      case 0: return "Almost empty";
+      case 1: return "1/8 full";
+      case 2: return "2/8 full";
+      case 3: return "3/8 full";
+      case 4: return "4/8 full";
+      case 5: return "5/8 full";
+      case 6: return "6/8 full";
+      case 7: return "7/8 full";
+    }
+    return "??";
+  }
+#endif
+
  private:
   HeapObject** array_;
   // array_[(top - 1) & mask_] is the top element in the deque.  The Deque is
   // empty when top_ == bottom_.  It is full when top_ + 1 == bottom
   // (mod mask + 1).
   int top_;
   int bottom_;
   int mask_;
   bool overflowed_;
 
@@ skipping 422 matching lines @@
   // Mark objects reachable (transitively) from objects in the marking stack
   // or overflowed in the heap.
   void ProcessMarkingDeque();
 
   // Mark objects reachable (transitively) from objects in the marking
   // stack.  This function empties the marking stack, but may leave
   // overflowed objects in the heap, in which case the marking stack's
   // overflow flag will be set.
   void EmptyMarkingDeque();
 
+  // Find the large objects that are not completely scanned, but have been
+  // postponed to later.
+  void FillMarkingDequeFromLargePostponedArrays();
+
   // Refill the marking stack with overflowed objects from the heap.  This
   // function either leaves the marking stack full or clears the overflow
   // flag on the marking stack.
   void RefillMarkingDeque();
 
   // After reachable maps have been marked process per context object
   // literal map caches removing unmarked entries.
   void ProcessMapCaches();
 
   // Callback function for telling whether the object *p is an unmarked
@@ skipping 66 matching lines @@
 
   friend class Heap;
 };
 
 
 const char* AllocationSpaceName(AllocationSpace space);
 
 } }  // namespace v8::internal
 
 #endif  // V8_MARK_COMPACT_H_