Allow partial scanning of large arrays in order to avoid

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 375 matching lines @@
     EVACUATION_CANDIDATE,
     RESCAN_ON_EVACUATION,
 
     // Pages swept precisely can be iterated, hitting only the live objects.
     // Whereas those swept conservatively cannot be iterated over. Both flags
     // indicate that marking bits have been cleared by the sweeper, otherwise
     // marking bits are still intact.
     WAS_SWEPT_PRECISELY,
     WAS_SWEPT_CONSERVATIVELY,
 
+    // Used for large objects only.  Indicates that the object has been
+    // partially scanned by the incremental mark-sweep GC.  Objects that have
+    // been partially scanned are marked black so that the write barrier
+    // triggers for them, and they are counted as live bytes.  If the mutator
+    // writes to them they may be turned grey and subtracted from the live byte
+    // list.  They move back to the marking deque either by an iteration over
+    // the large object space or in the write barrier.
+    IS_PARTIALLY_SCANNED,
+
     // Last flag, keep at bottom.
     NUM_MEMORY_CHUNK_FLAGS
   };
 
 
   static const int kPointersToHereAreInterestingMask =
       1 << POINTERS_TO_HERE_ARE_INTERESTING;
 
   static const int kPointersFromHereAreInterestingMask =
       1 << POINTERS_FROM_HERE_ARE_INTERESTING;
 
   static const int kEvacuationCandidateMask =
       1 << EVACUATION_CANDIDATE;
 
   static const int kSkipEvacuationSlotsRecordingMask =
       (1 << EVACUATION_CANDIDATE) |
       (1 << RESCAN_ON_EVACUATION) |
       (1 << IN_FROM_SPACE) |
       (1 << IN_TO_SPACE);
 
+  static const int kIsPartiallyScannedMask = 1 << IS_PARTIALLY_SCANNED;
+
+  void SetPartiallyScannedProgress(int progress) {
+    SetFlag(IS_PARTIALLY_SCANNED);
+    partially_scanned_progress_ = progress;
+  }
+
+  bool IsPartiallyScanned() {
+    return IsFlagSet(IS_PARTIALLY_SCANNED);
+  }
+
+  void SetCompletelyScanned() {
+    ClearFlag(IS_PARTIALLY_SCANNED);
+  }
+
+  int PartiallyScannedProgress() {
+    ASSERT(IsPartiallyScanned());
+    return partially_scanned_progress_;
+  }
 
   void SetFlag(int flag) {
     flags_ |= static_cast<uintptr_t>(1) << flag;
   }
 
   void ClearFlag(int flag) {
     flags_ &= ~(static_cast<uintptr_t>(1) << flag);
   }
 
   void SetFlagTo(int flag, bool value) {
@@ skipping 55 matching lines @@
 
   static const intptr_t kSizeOffset = kPointerSize + kPointerSize;
 
   static const intptr_t kLiveBytesOffset =
      kSizeOffset + kPointerSize + kPointerSize + kPointerSize +
      kPointerSize + kPointerSize +
      kPointerSize + kPointerSize + kPointerSize + kIntSize;
 
   static const size_t kSlotsBufferOffset = kLiveBytesOffset + kIntSize;
 
-  static const size_t kHeaderSize =
-      kSlotsBufferOffset + kPointerSize + kPointerSize;
+  static const size_t kPartiallyScannedProgress =
+        kSlotsBufferOffset + kPointerSize + kPointerSize;
+
+  static const size_t kHeaderSize = kPartiallyScannedProgress + kIntSize;
 
   static const int kBodyOffset =
     CODE_POINTER_ALIGN(MAP_POINTER_ALIGN(kHeaderSize + Bitmap::kSize));
 
   // The start offset of the object area in a page. Aligned to both maps and
   // code alignment to be suitable for both.  Also aligned to 32 words because
   // the marking bitmap is arranged in 32 bit chunks.
   static const int kObjectStartAlignment = 32 * kPointerSize;
   static const int kObjectStartOffset = kBodyOffset - 1 +
       (kObjectStartAlignment - (kBodyOffset - 1) % kObjectStartAlignment);
@@ skipping 115 matching lines @@
   // in a fixed array.
   Address owner_;
   Heap* heap_;
   // Used by the store buffer to keep track of which pages to mark scan-on-
   // scavenge.
   int store_buffer_counter_;
   // Count of bytes marked black on page.
   int live_byte_count_;
   SlotsBuffer* slots_buffer_;
   SkipList* skip_list_;
+  int partially_scanned_progress_;
 
   static MemoryChunk* Initialize(Heap* heap,
                                  Address base,
                                  size_t size,
                                  Address area_start,
                                  Address area_end,
                                  Executability executable,
                                  Space* owner);
 
   friend class MemoryAllocator;
@@ skipping 2011 matching lines @@
   }
   // Must be small, since an iteration is used for lookup.
   static const int kMaxComments = 64;
 };
 #endif
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_