Support slots recording for compaction during incremental marking.

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 374 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,
     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);
+
+
   void SetFlag(int flag) {
     flags_ |= (1 << flag);
   }
 
   void ClearFlag(int flag) {
     flags_ &= ~(1 << flag);
   }
 
   void SetFlagTo(int flag, bool value) {
     if (value) {
@@ skipping 194 matching lines @@
   static inline Page* Initialize(Heap* heap,
                                  MemoryChunk* chunk,
                                  Executability executable,
                                  PagedSpace* owner);
 
   void InitializeAsAnchor(PagedSpace* owner);
 
   bool IsEvacuationCandidate() { return IsFlagSet(EVACUATION_CANDIDATE); }
 
   bool IsEvacuationCandidateOrNewSpace() {
-    intptr_t mask = (1 << EVACUATION_CANDIDATE) |
-        (1 << IN_FROM_SPACE) |
-        (1 << IN_TO_SPACE);
-    return (flags_ & mask) != 0;
+    return (flags_ & kEvacuationCandidateOrNewSpaceMask) != 0;
   }
 
   void MarkEvacuationCandidate() { SetFlag(EVACUATION_CANDIDATE); }
 
   void ClearEvacuationCandidate() { ClearFlag(EVACUATION_CANDIDATE); }
 
+  bool WasEvacuated() { return IsFlagSet(EVACUATED); }
+
+  void MarkEvacuated() { SetFlag(EVACUATED); }
+
+  void ClearEvacuated() { ClearFlag(EVACUATED); }
+
   friend class MemoryAllocator;
 };
 
 
 STATIC_CHECK(sizeof(Page) <= MemoryChunk::kHeaderSize);
 
 
 class LargePage : public MemoryChunk {
  public:
   HeapObject* GetObject() {
@@ skipping 396 matching lines @@
 
 
 // -----------------------------------------------------------------------------
 // A space has a circular list of pages. The next page can be accessed via
 // Page::next_page() call.
 
 // An abstraction of allocation and relocation pointers in a page-structured
 // space.
 class AllocationInfo {
  public:
+  AllocationInfo() : top(NULL), limit(NULL) {
+  }
+
   Address top;  // Current allocation top.
   Address limit;  // Current allocation limit.
 
 #ifdef DEBUG
   bool VerifyPagedAllocation() {
     // TODO(gc): Make this type-correct. NewSpacePage isn't a Page,
     // but NewSpace still uses AllocationInfo.
     return (Page::FromAllocationTop(top) == Page::FromAllocationTop(limit))
         && (top <= limit);
   }
@@ skipping 173 matching lines @@
   bool IsVeryLong();
 #endif
 
   void CountFreeListItems(Page* p, intptr_t* sizes);
 
  private:
   // The size range of blocks, in bytes.
   static const int kMinBlockSize = 3 * kPointerSize;
   static const int kMaxBlockSize = Page::kMaxHeapObjectSize;
 
+  FreeListNode* PickNodeFromList(FreeListNode** list, int* node_size);
+
+  FreeListNode* FindNodeFor(int size_in_bytes, int* node_size);
+
   PagedSpace* owner_;
   Heap* heap_;
 
   // Total available bytes in all blocks on this free list.
   int available_;
 
   static const int kSmallListMin = 0x20 * kPointerSize;
   static const int kSmallListMax = 0xff * kPointerSize;
   static const int kMediumListMax = 0x7ff * kPointerSize;
   static const int kLargeListMax = 0x3fff * kPointerSize;
@@ skipping 175 matching lines @@
 
   bool AdvanceSweeper(intptr_t bytes_to_sweep);
 
   bool IsSweepingComplete() {
     return !first_unswept_page_->is_valid();
   }
 
   Page* FirstPage() { return anchor_.next_page(); }
   Page* LastPage() { return anchor_.prev_page(); }
 
-
   bool IsFragmented(Page* p) {
     intptr_t sizes[4];
     free_list_.CountFreeListItems(p, sizes);
 
     intptr_t ratio =
         (sizes[0] * 5 + sizes[1]) * 100 / Page::kObjectAreaSize;
 
     if (FLAG_trace_fragmentation) {
       PrintF("%p: %d (%.2f%%) %d (%.2f%%) %d (%.2f%%) %d (%.2f%%) %s\n",
              reinterpret_cast<void*>(p),
              sizes[0],
              static_cast<double>(sizes[0] * 100) / Page::kObjectAreaSize,
              sizes[1],
              static_cast<double>(sizes[1] * 100) / Page::kObjectAreaSize,
              sizes[2],
              static_cast<double>(sizes[2] * 100) / Page::kObjectAreaSize,
              sizes[3],
              static_cast<double>(sizes[3] * 100) / Page::kObjectAreaSize,
              (ratio > 15) ? "[fragmented]" : "");
     }
 
     return ratio > 15;
   }
 
+  void EvictEvacuationCandidatesFromFreeLists();
+
  protected:
   // Maximum capacity of this space.
   intptr_t max_capacity_;
 
   // Accounting information for this space.
   AllocationStats accounting_stats_;
 
   // The dummy page that anchors the double linked list of pages.
   Page anchor_;
 
@@ skipping 712 matching lines @@
            Executability executable)
       : PagedSpace(heap, max_capacity, id, executable) {
     page_extra_ = 0;
   }
 
   // The limit of allocation for a page in this space.
   virtual Address PageAllocationLimit(Page* page) {
     return page->ObjectAreaEnd();
   }
 
-  // Prepare for full garbage collection.  Resets the relocation pointer and
-  // clears the free list.
-  virtual void PrepareForMarkCompact();
-
  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).page_low() <= (info).top             \
          && (info).top <= (space).page_high()         \
@@ skipping 321 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_