Split single slots buffer into per page slots buffers.

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 273 matching lines @@
 
   bool IsClean() {
     for (int i = 0; i < CellsCount(); i++) {
       if (cells()[i] != 0) return false;
     }
     return true;
   }
 };
 
 
+class SlotsBuffer;
+
 // MemoryChunk represents a memory region owned by a specific space.
 // It is divided into the header and the body. Chunk start is always
 // 1MB aligned. Start of the body is aligned so it can accomodate
 // any heap object.
 class MemoryChunk {
  public:
   // Only works if the pointer is in the first kPageSize of the MemoryChunk.
   static MemoryChunk* FromAddress(Address a) {
     return reinterpret_cast<MemoryChunk*>(OffsetFrom(a) & ~kAlignmentMask);
   }
@@ skipping 64 matching lines @@
     WAS_SWEPT_CONSERVATIVELY,
     ABOUT_TO_BE_FREED,
     POINTERS_TO_HERE_ARE_INTERESTING,
     POINTERS_FROM_HERE_ARE_INTERESTING,
     SCAN_ON_SCAVENGE,
     IN_FROM_SPACE,  // Mutually exclusive with IN_TO_SPACE.
     IN_TO_SPACE,    // All pages in new space has one of these two set.
     NEW_SPACE_BELOW_AGE_MARK,
     CONTAINS_ONLY_DATA,
     EVACUATION_CANDIDATE,
-    EVACUATED,
+    RESCAN_ON_EVACUATION,
+    WAS_SWEPT,
     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 kEvacuationCandidateOrNewSpaceMask =
-      (1 << EVACUATION_CANDIDATE) | (1 << IN_FROM_SPACE) | (1 << IN_TO_SPACE);
+  static const int kSkipEvacuationSlotsRecordingMask =
+      (1 << EVACUATION_CANDIDATE) |
+      (1 << RESCAN_ON_EVACUATION) |
+      (1 << IN_FROM_SPACE) |
+      (1 << IN_TO_SPACE);
 
 
   void SetFlag(int flag) {
     flags_ |= static_cast<uintptr_t>(1) << flag;
   }
 
   void ClearFlag(int flag) {
     flags_ &= ~(static_cast<uintptr_t>(1) << flag);
   }
 
@@ skipping 34 matching lines @@
 
   static const intptr_t kAlignment =
       (static_cast<uintptr_t>(1) << kPageSizeBits);
 
   static const intptr_t kAlignmentMask = kAlignment - 1;
 
   static const intptr_t kLiveBytesOffset =
       kPointerSize + kPointerSize + kPointerSize + kPointerSize +
       kPointerSize + kPointerSize + kIntSize;
 
-  static const size_t kHeaderSize = kLiveBytesOffset + kIntSize;
+  static const size_t kSlotsBufferOffset = kLiveBytesOffset + kIntSize;
+
+  static const size_t kHeaderSize = kSlotsBufferOffset + kPointerSize;
 
   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 44 matching lines @@
     return this->address() + (index << kPointerSizeLog2);
   }
 
   void InsertAfter(MemoryChunk* other);
   void Unlink();
 
   inline Heap* heap() { return heap_; }
 
   static const int kFlagsOffset = kPointerSize * 3;
 
+  bool IsEvacuationCandidate() { return IsFlagSet(EVACUATION_CANDIDATE); }
+
+  bool ShouldSkipEvacuationSlotRecording() {
+    return (flags_ & kSkipEvacuationSlotsRecordingMask) != 0;
+  }
+
+  inline SlotsBuffer* slots_buffer() {
+    return slots_buffer_;
+  }
+
+  inline SlotsBuffer** slots_buffer_address() {
+    return &slots_buffer_;
+  }
+
+  void MarkEvacuationCandidate() {
+    ASSERT(slots_buffer_ == NULL);
+    SetFlag(EVACUATION_CANDIDATE);
+  }
+
+  void ClearEvacuationCandidate() {
+    ASSERT(slots_buffer_ == NULL);
+    ClearFlag(EVACUATION_CANDIDATE);
+  }
+
+
  protected:
   MemoryChunk* next_chunk_;
   MemoryChunk* prev_chunk_;
   size_t size_;
   intptr_t flags_;
   // The identity of the owning space.  This is tagged as a failure pointer, but
   // no failure can be in an object, so this can be distinguished from any entry
   // 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_;
 
   static MemoryChunk* Initialize(Heap* heap,
                                  Address base,
                                  size_t size,
                                  Executability executable,
                                  Space* owner);
 
   friend class MemoryAllocator;
 };
 
@@ skipping 78 matching lines @@
 
   inline void ClearGCFields();
 
   static inline Page* Initialize(Heap* heap,
                                  MemoryChunk* chunk,
                                  Executability executable,
                                  PagedSpace* owner);
 
   void InitializeAsAnchor(PagedSpace* owner);
 
-  bool IsEvacuationCandidate() { return IsFlagSet(EVACUATION_CANDIDATE); }
+  bool WasSwept() { return IsFlagSet(WAS_SWEPT); }
 
-  bool IsEvacuationCandidateOrNewSpace() {
-    return (flags_ & kEvacuationCandidateOrNewSpaceMask) != 0;
-  }
+  void MarkSwept() { SetFlag(WAS_SWEPT); }
 
-  void MarkEvacuationCandidate() { SetFlag(EVACUATION_CANDIDATE); }
-
-  void ClearEvacuationCandidate() { ClearFlag(EVACUATION_CANDIDATE); }
-
-  bool WasEvacuated() { return IsFlagSet(EVACUATED); }
-
-  void MarkEvacuated() { SetFlag(EVACUATED); }
-
-  void ClearEvacuated() { ClearFlag(EVACUATED); }
+  void ClearSwept() { ClearFlag(WAS_SWEPT); }
 
   friend class MemoryAllocator;
 };
 
 
 STATIC_CHECK(sizeof(Page) <= MemoryChunk::kHeaderSize);
 
 
 class LargePage : public MemoryChunk {
  public:
@@ skipping 1267 matching lines @@
 //
 // The new space consists of a contiguous pair of semispaces.  It simply
 // forwards most functions to the appropriate semispace.
 
 class NewSpace : public Space {
  public:
   // Constructor.
   explicit NewSpace(Heap* heap)
     : Space(heap, NEW_SPACE, NOT_EXECUTABLE),
       to_space_(heap, kToSpace),
-      from_space_(heap, kFromSpace) {}
+      from_space_(heap, kFromSpace),
+      inline_allocation_limit_step_(0) {}
 
   // Sets up the new space using the given chunk.
   bool Setup(int max_semispace_size);
 
   // Tears down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
   void TearDown();
 
   // True if the space has been set up but not torn down.
   bool HasBeenSetup() {
@@ skipping 603 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_