Multi-page growing and shrinking new-space

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 1511 matching lines @@
   inline void set_prev_page(NewSpacePage* page) {
     set_prev_chunk(page);
   }
 
   SemiSpace* semi_space() {
     return reinterpret_cast<SemiSpace*>(owner());
   }
 
   bool is_anchor() { return !this->InNewSpace(); }
 
+  static bool IsAtStart(Address addr) {
+    return (reinterpret_cast<intptr_t>(addr) & Page::kPageAlignmentMask)
+        == kObjectStartOffset;
+  }
+
+  static bool IsAtEnd(Address addr) {
+    return (reinterpret_cast<intptr_t>(addr) & Page::kPageAlignmentMask) == 0;
+  }
+
   // Finds the NewSpacePage containg the given address.
   static inline NewSpacePage* FromAddress(Address address_in_page) {
     Address page_start =
         reinterpret_cast<Address>(reinterpret_cast<uintptr_t>(address_in_page) &
                                   ~Page::kPageAlignmentMask);
     NewSpacePage* page = reinterpret_cast<NewSpacePage*>(page_start);
     ASSERT(page->InNewSpace());
     return page;
   }
 
@@ skipping 84 matching lines @@
     return anchor_.prev_page()->body_limit();
   }
 
   // Returns one past the end address of the current page of the space.
   Address page_high() {
     return current_page_->body_limit();
   }
 
   bool AdvancePage() {
     NewSpacePage* next_page = current_page_->next_page();
-    if (next_page == &anchor_) return false;
+    if (next_page == anchor()) return false;
     current_page_ = next_page;
     return true;
   }
 
   // Resets the space to using the first page.
   void Reset();
 
   // Age mark accessors.
   Address age_mark() { return age_mark_; }
   void set_age_mark(Address mark);
@@ skipping 19 matching lines @@
 
 #ifdef ENABLE_HEAP_PROTECTION
   // Protect/unprotect the space by marking it read-only/writable.
   virtual void Protect() {}
   virtual void Unprotect() {}
 #endif
 
 #ifdef DEBUG
   virtual void Print();
   virtual void Verify();
-  static void ValidateRange(Address from, Address to);
+  // Validate a range of of addresses in a SemiSpace.
+  // The "from" address must be on a page prior to the "to" address,
+  // in the linked page order, or it must be earlier on the same page.
+  static void AssertValidRange(Address from, Address to);
+#else
+  // Do nothing.
+  inline static void AssertValidRange(Address from, Address to) {}
 #endif
 
   // Returns the current capacity of the semi space.
   int Capacity() { return capacity_; }
 
   // Returns the maximum capacity of the semi space.
   int MaximumCapacity() { return maximum_capacity_; }
 
   // Returns the initial capacity of the semi space.
   int InitialCapacity() { return initial_capacity_; }
@@ skipping 53 matching lines @@
   // Iterate over all of allocated to-space, with a custome size function.
   SemiSpaceIterator(NewSpace* space, HeapObjectCallback size_func);
   // Iterate over part of allocated to-space, from start to the end
   // of allocation.
   SemiSpaceIterator(NewSpace* space, Address start);
   // Iterate from one address to another in the same semi-space.
   SemiSpaceIterator(Address from, Address to);
 
   HeapObject* Next() {
     if (current_ == limit_) return NULL;
-    if (current_ == current_page_limit_) {
-      NewSpacePage* page = NewSpacePage::FromAddress(current_ - 1);
+    if (NewSpacePage::IsAtEnd(current_)) {
+      NewSpacePage* page = NewSpacePage::FromLimit(current_);
       page = page->next_page();
       ASSERT(!page->is_anchor());
       current_ = page->body();
       if (current_ == limit_) return NULL;
     }
 
     HeapObject* object = HeapObject::FromAddress(current_);
     int size = (size_func_ == NULL) ? object->Size() : size_func_(object);
 
     current_ += size;
     return object;
   }
 
   // Implementation of the ObjectIterator functions.
   virtual HeapObject* next_object() { return Next(); }
 
  private:
   void Initialize(Address start,
                   Address end,
                   HeapObjectCallback size_func);
 
   // The current iteration point.
   Address current_;
-  // The end of the current page.
-  Address current_page_limit_;
   // The end of iteration.
   Address limit_;
   // The callback function.
   HeapObjectCallback size_func_;
 };
 
 
 // -----------------------------------------------------------------------------
 // A PageIterator iterates the pages in a semi-space.
 class NewSpacePageIterator BASE_EMBEDDED {
  public:
+  // Make an iterator that runs over all pages in to-space.
+  explicit inline NewSpacePageIterator(NewSpace* space);
+
   // Make an iterator that runs over all pages in the given semispace,
   // even those not used in allocation.
   explicit inline NewSpacePageIterator(SemiSpace* space);
+
   // Make iterator that iterates from the page containing start
   // to the page that contains limit in the same semispace.
   inline NewSpacePageIterator(Address start, Address limit);
 
   inline bool has_next();
   inline NewSpacePage* next();
 
  private:
   NewSpacePage* prev_page_;  // Previous page returned.
   // Next page that will be returned.  Cached here so that we can use this
@@ skipping 139 matching lines @@
   Address* allocation_limit_address() { return &allocation_info_.limit; }
 
   MUST_USE_RESULT MaybeObject* AllocateRaw(int size_in_bytes) {
     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;
+    inline_allocation_limit_step_ = step;
     if (step == 0) {
       allocation_info_.limit = to_space_.page_high();
     } else {
       allocation_info_.limit = Min(
-          allocation_info_.top + inline_alloction_limit_step_,
+          allocation_info_.top + inline_allocation_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,
   // or to zap it).
   Address FromSpacePageLow() { return from_space_.page_low(); }
   Address FromSpaceLow() { return from_space_.space_low(); }
   Address FromSpaceHigh() { return from_space_.space_high(); }
@@ skipping 72 matching lines @@
   bool CommitFromSpaceIfNeeded() {
     if (from_space_.is_committed()) return true;
     return from_space_.Commit();
   }
 
   bool UncommitFromSpace() {
     if (!from_space_.is_committed()) return true;
     return from_space_.Uncommit();
   }
 
-  inline intptr_t inline_alloction_limit_step() {
-    return inline_alloction_limit_step_;
+  inline intptr_t inline_allocation_limit_step() {
+    return inline_allocation_limit_step_;
   }
 
-  NewSpacePage* ActivePage() {
-    return to_space_.current_page();
-  }
-
-  NewSpacePage* InactivePage() {
-    return from_space_.current_page();
-  }
+  SemiSpace* active_space() { return &to_space_; }
 
  private:
   // Update allocation info to match the current to-space page.
   void UpdateAllocationInfo();
 
   Address chunk_base_;
   uintptr_t chunk_size_;
 
   // The semispaces.
   SemiSpace to_space_;
   SemiSpace from_space_;
 
   // 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_;
+  intptr_t inline_allocation_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.
   MUST_USE_RESULT inline MaybeObject* AllocateRawInternal(int size_in_bytes);
@@ skipping 366 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_