Two-page newspace.

src/mark-compact.cc

 // 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 96 matching lines @@
   }
 }
 
 
 static void VerifyMarking(Page* p) {
   VerifyMarking(p->ObjectAreaStart(), p->ObjectAreaEnd());
 }
 
 
 static void VerifyMarking(NewSpace* space) {
-  VerifyMarking(space->bottom(), space->top());
+  Address end = space->top();
+  NewSpacePageIterator it(space->bottom(), end);
+  // The bottom position is at the start of its page. Allows us to use
+  // page->body() as start of range on all pages.
+  ASSERT_EQ(space->bottom(),
+            NewSpacePage::FromAddress(space->bottom())->body());
+  while (it.has_next()) {
+    NewSpacePage* page = it.next();
+    Address limit = it.has_next() ? page->body_limit() : end;
+    VerifyMarking(page->body(), limit);
+  }
 }
 
 
 static void VerifyMarking(PagedSpace* space) {
   PageIterator it(space);
 
   while (it.has_next()) {
     VerifyMarking(it.next());
   }
 }
@@ skipping 1562 matching lines @@
     incremental_marking->marking_deque()->ClearOverflowed();
   } else {
     // Abort any pending incremental activities e.g. incremental sweeping.
     incremental_marking->Abort();
   }
 
 #ifdef DEBUG
   ASSERT(state_ == PREPARE_GC);
   state_ = MARK_LIVE_OBJECTS;
 #endif
-  // The to space contains live objects, the from space is used as a marking
-  // stack.
-  Address marking_deque_start = heap()->new_space()->FromSpaceLow();
+  // The to space contains live objects, a page in from space is used as a
+  // marking stack.
+  Address marking_deque_start = heap()->new_space()->FromSpacePageLow();
   Address marking_deque_end = heap()->new_space()->FromSpaceHigh();
   if (FLAG_force_marking_deque_overflows) {
     marking_deque_end = marking_deque_start + 64 * kPointerSize;
   }
   marking_deque_.Initialize(marking_deque_start,
                             marking_deque_end);
   ASSERT(!marking_deque_.overflowed());
 
   if (incremental_marking_overflowed) {
     // There are overflowed objects left in the heap after incremental marking.
@@ skipping 207 matching lines @@
 // to new space.  We should clear them to avoid encountering them during next
 // pointer iteration.  This is an issue if the store buffer overflows and we
 // have to scan the entire old space, including dead objects, looking for
 // pointers to new space.
 static void MigrateObject(Heap* heap,
                           Address dst,
                           Address src,
                           int size,
                           bool to_old_space) {
   if (to_old_space) {
-    HEAP->CopyBlockToOldSpaceAndUpdateWriteBarrier(dst, src, size);
+    heap->CopyBlockToOldSpaceAndUpdateWriteBarrier(dst, src, size);
   } else {
     heap->CopyBlock(dst, src, size);
   }
   Memory::Address_at(src) = dst;
 }
 
 
 class StaticPointersToNewGenUpdatingVisitor : public
   StaticNewSpaceVisitor<StaticPointersToNewGenUpdatingVisitor> {
  public:
@@ skipping 116 matching lines @@
     }
   }
 
   return false;
 }
 
 
 void MarkCompactCollector::SweepNewSpace(NewSpace* space) {
   heap_->CheckNewSpaceExpansionCriteria();
 
+  // Store allocation range before flipping semispaces.
   Address from_bottom = space->bottom();
   Address from_top = space->top();
 
   // Flip the semispaces.  After flipping, to space is empty, from space has
   // live objects.
   space->Flip();
   space->ResetAllocationInfo();
 
-  int size = 0;
   int survivors_size = 0;
 
   // First pass: traverse all objects in inactive semispace, remove marks,
   // migrate live objects and write forwarding addresses.  This stage puts
   // new entries in the store buffer and may cause some pages to be marked
   // scan-on-scavenge.
-  for (Address current = from_bottom; current < from_top; current += size) {
-    HeapObject* object = HeapObject::FromAddress(current);
-
+  SemiSpaceIterator from_it(from_bottom, from_top);
+  for (HeapObject* object = from_it.Next();
+       object != NULL;
+       object = from_it.Next()) {
     MarkBit mark_bit = Marking::MarkBitFrom(object);
     if (mark_bit.Get()) {
       mark_bit.Clear();
       heap_->mark_compact_collector()->tracer()->decrement_marked_count();
 
-      size = object->Size();
+      int size = object->Size();
       survivors_size += size;
 
       // Aggressively promote young survivors to the old space.
       if (TryPromoteObject(heap_, object, size)) {
         continue;
       }
 
       // Promotion failed. Just migrate object to another semispace.
-      // Allocation cannot fail at this point: semispaces are of equal size.
-      Object* target = space->AllocateRaw(size)->ToObjectUnchecked();
-
+      MaybeObject* allocation = space->AllocateRaw(size);
+      if (allocation->IsFailure()) {
+        if (!space->AddFreshPage()) {
+          // Shouldn't happen. We are sweeping linearly, and to-space
+          // has the same number of pages as from-space, so there is
+          // always room.
+          UNREACHABLE();
+        }
+        allocation = space->AllocateRaw(size);
+        ASSERT(!allocation->IsFailure());
+      }
+      Object* target = allocation->ToObjectUnchecked();
       MigrateObject(heap_,
                     HeapObject::cast(target)->address(),
-                    current,
+                    object->address(),
                     size,
                     false);
     } else {
       // Process the dead object before we write a NULL into its header.
       LiveObjectList::ProcessNonLive(object);
 
-      size = object->Size();
       // Mark dead objects in the new space with null in their map field.
-      Memory::Address_at(current) = NULL;
+      Memory::Address_at(object->address()) = NULL;
     }
   }
 
   // Second pass: find pointers to new space and update them.
   PointersToNewGenUpdatingVisitor updating_visitor(heap_);
 
   // Update pointers in to space.
-  Address current = space->bottom();
-  while (current < space->top()) {
-    HeapObject* object = HeapObject::FromAddress(current);
-    current +=
-        StaticPointersToNewGenUpdatingVisitor::IterateBody(object->map(),
-                                                           object);
+  SemiSpaceIterator to_it(space->bottom(), space->top());
+  for (HeapObject* object = to_it.Next();
+       object != NULL;
+       object = to_it.Next()) {
+    StaticPointersToNewGenUpdatingVisitor::IterateBody(object->map(),
+                                                       object);
   }
 
   // Update roots.
   heap_->IterateRoots(&updating_visitor, VISIT_ALL_IN_SWEEP_NEWSPACE);
   LiveObjectList::IterateElements(&updating_visitor);
 
   {
     StoreBufferRebuildScope scope(heap_,
                                   heap_->store_buffer(),
                                   &Heap::ScavengeStoreBufferCallback);
@@ skipping 576 matching lines @@
       live_objects_size += size;
     }
   }
   return live_objects_size;
 }
 
 
 int MarkCompactCollector::IterateLiveObjects(
     NewSpace* space, LiveObjectCallback size_f) {
   ASSERT(MARK_LIVE_OBJECTS < state_ && state_ <= RELOCATE_OBJECTS);
-  return IterateLiveObjectsInRange(space->bottom(), space->top(), size_f);
+  int accumulator = 0;
+  Address end = space->top();
+  NewSpacePageIterator it(space->bottom(), end);
+  // The bottom is at the start of its page.
+  ASSERT_EQ(space->bottom(),
+            NewSpacePage::FromAddress(space->bottom())->body());
+  while (it.has_next()) {
+    NewSpacePage* page = it.next();
+    Address start = page->body();
+    Address limit = it.has_next() ? page->body_limit() : end;
+    accumulator += IterateLiveObjectsInRange(start, limit, size_f);
+  }
+  return accumulator;
 }
 
 
 int MarkCompactCollector::IterateLiveObjects(
     PagedSpace* space, LiveObjectCallback size_f) {
   ASSERT(MARK_LIVE_OBJECTS < state_ && state_ <= RELOCATE_OBJECTS);
   // TODO(gc): Do a mark-sweep first with precise sweeping.
   int total = 0;
   PageIterator it(space);
   while (it.has_next()) {
@@ skipping 36 matching lines @@
 }
 
 
 void MarkCompactCollector::Initialize() {
   StaticPointersToNewGenUpdatingVisitor::Initialize();
   StaticMarkingVisitor::Initialize();
 }
 
 
 } }  // namespace v8::internal