Multi-page growing and shrinking new-space

src/spaces-inl.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 45 matching lines @@
   prev_page_ = next_page_;
   next_page_ = next_page_->next_page();
   return prev_page_;
 }
 
 
 // -----------------------------------------------------------------------------
 // NewSpacePageIterator
 
 
+NewSpacePageIterator::NewSpacePageIterator(NewSpace* space)
+    : prev_page_(NewSpacePage::FromAddress(space->ToSpaceLow())->prev_page()),
+      next_page_(NewSpacePage::FromAddress(space->ToSpaceLow())),
+      last_page_(NewSpacePage::FromLimit(space->ToSpaceHigh())) { }
+
 NewSpacePageIterator::NewSpacePageIterator(SemiSpace* space)
-    : prev_page_(&space->anchor_),
+    : prev_page_(space->anchor()),
       next_page_(prev_page_->next_page()),
       last_page_(prev_page_->prev_page()) { }
 
-  NewSpacePageIterator::NewSpacePageIterator(Address start, Address limit)
+NewSpacePageIterator::NewSpacePageIterator(Address start, Address limit)
     : prev_page_(NewSpacePage::FromAddress(start)->prev_page()),
       next_page_(NewSpacePage::FromAddress(start)),
       last_page_(NewSpacePage::FromLimit(limit)) {
-#ifdef DEBUG
-    SemiSpace::ValidateRange(start, limit);
-#endif
+  SemiSpace::AssertValidRange(start, limit);
 }
 
 
 bool NewSpacePageIterator::has_next() {
   return prev_page_ != last_page_;
 }
 
 
 NewSpacePage* NewSpacePageIterator::next() {
   ASSERT(has_next());
@@ skipping 191 matching lines @@
 
 // -----------------------------------------------------------------------------
 // NewSpace
 
 MaybeObject* NewSpace::AllocateRawInternal(int size_in_bytes) {
   Address old_top = allocation_info_.top;
   Address new_top = old_top + size_in_bytes;
   if (new_top > allocation_info_.limit) {
     Address high = to_space_.page_high();
     if (allocation_info_.limit < high) {
+      // Incremental marking has lowered the limit to get a
+      // chance to do a step.
       allocation_info_.limit = Min(
-          allocation_info_.limit + inline_alloction_limit_step_,
+          allocation_info_.limit + inline_allocation_limit_step_,
           high);
       int bytes_allocated = new_top - top_on_previous_step_;
       heap()->incremental_marking()->Step(bytes_allocated);
       top_on_previous_step_ = new_top;
       return AllocateRawInternal(size_in_bytes);
     } else if (AddFreshPage()) {
       // Switched to new page. Try allocating again.
       int bytes_allocated = old_top - top_on_previous_step_;
       heap()->incremental_marking()->Step(bytes_allocated);
       top_on_previous_step_ = to_space_.page_low();
@@ skipping 37 matching lines @@
 bool FreeListNode::IsFreeListNode(HeapObject* object) {
   // TODO(gc) ISOLATES MERGE
   return object->map() == HEAP->raw_unchecked_free_space_map()
       || object->map() == HEAP->raw_unchecked_one_pointer_filler_map()
       || object->map() == HEAP->raw_unchecked_two_pointer_filler_map();
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_INL_H_