Changes that anticipate making semispaces contain more than one page.

src/spaces.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 378 matching lines @@
 
 void Page::InitializeAsAnchor(PagedSpace* owner) {
   set_owner(owner);
   set_prev_page(this);
   set_next_page(this);
 }
 
 
 NewSpacePage* NewSpacePage::Initialize(Heap* heap,
                                        Address start,
-                                       SemiSpaceId semispace_id) {
+                                       SemiSpace* semi_space) {
   MemoryChunk* chunk = MemoryChunk::Initialize(heap,
                                                start,
                                                Page::kPageSize,
                                                NOT_EXECUTABLE,
-                                               heap->new_space());
+                                               semi_space);
   chunk->set_next_chunk(NULL);
   chunk->set_prev_chunk(NULL);
   chunk->initialize_scan_on_scavenge(true);
-  bool in_to_space = (semispace_id != kFromSpace);
+  bool in_to_space = (semi_space->id() != kFromSpace);
   chunk->SetFlag(in_to_space ? MemoryChunk::IN_TO_SPACE
                              : MemoryChunk::IN_FROM_SPACE);
   ASSERT(!chunk->IsFlagSet(in_to_space ? MemoryChunk::IN_FROM_SPACE
                                        : MemoryChunk::IN_TO_SPACE));
   heap->incremental_marking()->SetNewSpacePageFlags(chunk);
   return static_cast<NewSpacePage*>(chunk);
 }
 
 
+void NewSpacePage::InitializeAsAnchor(SemiSpace* semi_space) {
+  set_owner(semi_space);
+  set_next_chunk(this);
+  set_prev_chunk(this);
+}
+
+
 MemoryChunk* MemoryChunk::Initialize(Heap* heap,
                                      Address base,
                                      size_t size,
                                      Executability executable,
                                      Space* owner) {
   MemoryChunk* chunk = FromAddress(base);
 
   ASSERT(base == chunk->address());
 
   chunk->heap_ = heap;
@@ skipping 504 matching lines @@
   heap()->isolate()->memory_allocator()->Unprotect(ToSpaceLow(), Capacity(),
                                                    to_space_.executable());
   heap()->isolate()->memory_allocator()->Unprotect(FromSpaceLow(), Capacity(),
                                                    from_space_.executable());
 }
 
 #endif
 
 
 void NewSpace::Flip() {
-  SemiSpace tmp = from_space_;
-  from_space_ = to_space_;
-  to_space_ = tmp;
-
-  // Copy GC flags from old active space (from-space) to new (to-space).
-  intptr_t flags = from_space_.current_page()->GetFlags();
-  to_space_.Flip(flags, NewSpacePage::kCopyOnFlipFlagsMask);
-
-  from_space_.Flip(0, 0);
+  SemiSpace::Swap(&from_space_, &to_space_);
 }
 
 
 void NewSpace::Grow() {
   ASSERT(Capacity() < MaximumCapacity());
   if (to_space_.Grow()) {
     // Only grow from space if we managed to grow to space.
     if (!from_space_.Grow()) {
       // If we managed to grow to space but couldn't grow from space,
       // attempt to shrink to space.
@@ skipping 25 matching lines @@
         V8::FatalProcessOutOfMemory("Failed to shrink new space.");
       }
     }
   }
   allocation_info_.limit = to_space_.high();
   ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
 }
 
 
 void NewSpace::ResetAllocationInfo() {
-  allocation_info_.top = to_space_.low();
+  to_space_.Reset();
+  allocation_info_.top = to_space_.page_low();
   allocation_info_.limit = to_space_.high();
   ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
 }
 
 
 #ifdef DEBUG
 // We do not use the SemispaceIterator because verification doesn't assume
 // that it works (it depends on the invariants we are checking).
 void NewSpace::Verify() {
   // The allocation pointer should be in the space or at the very end.
   ASSERT_SEMISPACE_ALLOCATION_INFO(allocation_info_, to_space_);
 
   // There should be objects packed in from the low address up to the
   // allocation pointer.
   Address current = to_space_.low();
   while (current < top()) {
     HeapObject* object = HeapObject::FromAddress(current);
 
     // The first word should be a map, and we expect all map pointers to
     // be in map space.
     Map* map = object->map();
-    ASSERT(map->IsMap());
-    ASSERT(heap()->map_space()->Contains(map));
+    CHECK(map->IsMap());
+    CHECK(heap()->map_space()->Contains(map));
 
     // The object should not be code or a map.
-    ASSERT(!object->IsMap());
-    ASSERT(!object->IsCode());
+    CHECK(!object->IsMap());
+    CHECK(!object->IsCode());
 
     // The object itself should look OK.
     object->Verify();
 
     // All the interior pointers should be contained in the heap.
     VerifyPointersVisitor visitor;
     int size = object->Size();
     object->IterateBody(map->instance_type(), size, &visitor);
 
     current += size;
   }
 
   // The allocation pointer should not be in the middle of an object.
   ASSERT(current == top());
+
+  // Check semi-spaces.
+  ASSERT_EQ(from_space_.id(), kFromSpace);
+  ASSERT_EQ(to_space_.id(), kToSpace);
+  from_space_.Verify();
+  to_space_.Verify();
 }
 #endif
 
 
 bool SemiSpace::Commit() {
   ASSERT(!is_committed());
   if (!heap()->isolate()->memory_allocator()->CommitBlock(
       start_, capacity_, executable())) {
     return false;
   }
   committed_ = true;
   // TODO(gc): When more than one page is present, initialize and
   // chain them all.
-  current_page_ = NewSpacePage::Initialize(heap(), start_, id_);
+  NewSpacePage* page = NewSpacePage::Initialize(heap(), start_, this);
+  page->InsertAfter(&anchor_);
+  current_page_ = anchor_.next_page();
   return true;
 }
 
 
 bool SemiSpace::Uncommit() {
   ASSERT(is_committed());
   if (!heap()->isolate()->memory_allocator()->UncommitBlock(
       start_, capacity_)) {
     return false;
   }
   committed_ = false;
   return true;
 }
 
 
+void SemiSpace::Reset() {
+  ASSERT(anchor_.next_page() != &anchor_);
+  current_page_ = anchor_.next_page();
+}
+
+
+void SemiSpace::Swap(SemiSpace* from, SemiSpace* to) {
+  // We won't be swapping semispaces without data in them.
+  ASSERT(from->anchor_.next_page() != &from->anchor_);
+  ASSERT(to->anchor_.next_page() != &to->anchor_);
+
+  // Swap bits.
+  SemiSpace tmp = *from;
+  *from = *to;
+  *to = tmp;
+
+  // Fixup back-pointers to the page list anchor now that its address
+  // has changed.
+  // Swap to/from-space bits on pages.
+  // Copy GC flags from old active space (from-space) to new (to-space).
+  intptr_t flags = from->current_page()->GetFlags();
+  to->FlipPages(flags, NewSpacePage::kCopyOnFlipFlagsMask);
+
+  from->FlipPages(0, 0);
+}
+
+
 // -----------------------------------------------------------------------------
 // SemiSpace implementation
 
 bool SemiSpace::Setup(Address start,
                       int initial_capacity,
                       int maximum_capacity) {
   // Creates a space in the young generation. The constructor does not
   // allocate memory from the OS.  A SemiSpace is given a contiguous chunk of
   // memory of size 'capacity' when set up, and does not grow or shrink
   // otherwise.  In the mark-compact collector, the memory region of the from
@@ skipping 63 matching lines @@
   ASSERT(IsAligned(delta, OS::AllocateAlignment()));
   if (!heap()->isolate()->memory_allocator()->UncommitBlock(
       high() - delta, delta)) {
     return false;
   }
   capacity_ = new_capacity;
   return true;
 }
 
 
-void SemiSpace::Flip(intptr_t flags, intptr_t mask) {
+void SemiSpace::FlipPages(intptr_t flags, intptr_t mask) {
+  anchor_.set_owner(this);
+  // Fixup back-pointers to anchor. Address of anchor changes
+  // when we swap.
+  anchor_.prev_page()->set_next_page(&anchor_);
+  anchor_.next_page()->set_prev_page(&anchor_);
+
   bool becomes_to_space = (id_ == kFromSpace);
   id_ = becomes_to_space ? kToSpace : kFromSpace;
-  NewSpacePage* page = NewSpacePage::FromAddress(start_);
-  while (page != NULL) {
+  NewSpacePage* page = anchor_.next_page();
+  while (page != &anchor_) {
+    page->set_owner(this);
     page->SetFlags(flags, mask);
     if (becomes_to_space) {
       page->ClearFlag(MemoryChunk::IN_FROM_SPACE);
       page->SetFlag(MemoryChunk::IN_TO_SPACE);
     } else {
       page->SetFlag(MemoryChunk::IN_FROM_SPACE);
       page->ClearFlag(MemoryChunk::IN_TO_SPACE);
     }
     page = page->next_page();
   }
 }
 
 #ifdef DEBUG
 void SemiSpace::Print() { }
 
 
-void SemiSpace::Verify() { }
+void SemiSpace::Verify() {
+  bool is_from_space = (id_ == kFromSpace);
+  NewSpacePage* page = anchor_.next_page();
+  CHECK(anchor_.semi_space() == this);
+  while (page != &anchor_) {
+    CHECK(page->semi_space() == this);
+    CHECK(page->InNewSpace());
+    CHECK(page->IsFlagSet(is_from_space ? MemoryChunk::IN_FROM_SPACE
+                                        : MemoryChunk::IN_TO_SPACE));
+    CHECK(!page->IsFlagSet(is_from_space ? MemoryChunk::IN_TO_SPACE
+                                         : MemoryChunk::IN_FROM_SPACE));
+    CHECK(page->prev_page()->next_page() == page);
+    page = page->next_page();
+  }
+}
 #endif
 
 
 // -----------------------------------------------------------------------------
 // SemiSpaceIterator implementation.
 SemiSpaceIterator::SemiSpaceIterator(NewSpace* space) {
   Initialize(space, space->bottom(), space->top(), NULL);
 }
 
 
@@ skipping 1111 matching lines @@
   for (HeapObject* obj = obj_it.Next(); obj != NULL; obj = obj_it.Next()) {
     if (obj->IsCode()) {
       Code* code = Code::cast(obj);
       isolate->code_kind_statistics()[code->kind()] += code->Size();
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal