Make newspace semispaces be single page-sized memory chunks.

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 373 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) {
+  MemoryChunk* chunk = MemoryChunk::Initialize(heap,
+                                               start,
+                                               Page::kPageSize,
+                                               NOT_EXECUTABLE,
+                                               heap->new_space());
+  return static_cast<NewSpacePage*>(chunk);
+}
+
+
 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 602 matching lines @@
 #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_);
   return true;
 }
 
 
 bool SemiSpace::Uncommit() {
   ASSERT(is_committed());
   if (!heap()->isolate()->memory_allocator()->UncommitBlock(
       start_, capacity_)) {
     return false;
   }
   committed_ = false;
   return true;
 }
 
 
 // -----------------------------------------------------------------------------
 // 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
   // space is used as the marking stack. It requires contiguous memory
   // addresses.
+  ASSERT(maximum_capacity >= Page::kPageSize);
+  if (initial_capacity < Page::kPageSize) {
+    initial_capacity = Page::kPageSize;
+  } else {
+    initial_capacity &= ~Page::kPageAlignmentMask;
+  }
   initial_capacity_ = initial_capacity;
   capacity_ = initial_capacity;
   maximum_capacity_ = maximum_capacity;
   committed_ = false;
-
   start_ = start;
   address_mask_ = ~(maximum_capacity - 1);
   object_mask_ = address_mask_ | kHeapObjectTagMask;
   object_expected_ = reinterpret_cast<uintptr_t>(start) | kHeapObjectTag;
   age_mark_ = start_;
 
   return Commit();
 }
 
 
 void SemiSpace::TearDown() {
   start_ = NULL;
   capacity_ = 0;
 }
 
 
 bool SemiSpace::Grow() {
+  return false;  // TODO(gc): Temporary hack while semispaces are only one page.
   // Double the semispace size but only up to maximum capacity.
   int maximum_extra = maximum_capacity_ - capacity_;
   int extra = Min(RoundUp(capacity_, static_cast<int>(OS::AllocateAlignment())),
                   maximum_extra);
   if (!heap()->isolate()->memory_allocator()->CommitBlock(
       high(), extra, executable())) {
     return false;
   }
   capacity_ += extra;
   return true;
 }
 
 
 bool SemiSpace::GrowTo(int new_capacity) {
+  return false;  // TODO(gc): Temporary hack while semispaces are only one page.
   ASSERT(new_capacity <= maximum_capacity_);
   ASSERT(new_capacity > capacity_);
   size_t delta = new_capacity - capacity_;
   ASSERT(IsAligned(delta, OS::AllocateAlignment()));
   if (!heap()->isolate()->memory_allocator()->CommitBlock(
       high(), delta, executable())) {
     return false;
   }
   capacity_ = new_capacity;
   return true;
 }
 
 
 bool SemiSpace::ShrinkTo(int new_capacity) {
+  return false;  // TODO(gc): Temporary hack while semispaces are only one page.
   ASSERT(new_capacity >= initial_capacity_);
   ASSERT(new_capacity < capacity_);
   size_t delta = capacity_ - new_capacity;
   ASSERT(IsAligned(delta, OS::AllocateAlignment()));
   if (!heap()->isolate()->memory_allocator()->UncommitBlock(
       high() - delta, delta)) {
     return false;
   }
   capacity_ = new_capacity;
   return true;
@@ skipping 19 matching lines @@
                                      HeapObjectCallback size_func) {
   Initialize(space, space->bottom(), space->top(), size_func);
 }
 
 
 SemiSpaceIterator::SemiSpaceIterator(NewSpace* space, Address start) {
   Initialize(space, start, space->top(), NULL);
 }
 
 
-void SemiSpaceIterator::Initialize(NewSpace* space, Address start,
+void SemiSpaceIterator::Initialize(NewSpace* space,
+                                   Address start,
                                    Address end,
                                    HeapObjectCallback size_func) {
   ASSERT(space->ToSpaceContains(start));
   ASSERT(space->ToSpaceLow() <= end
          && end <= space->ToSpaceHigh());
   space_ = &space->to_space_;
   current_ = start;
+  NewSpacePage* page = NewSpacePage::FromAddress(start);
+  current_page_limit_ = page->body() + page->body_size();
+  if (current_page_limit_ > end) current_page_limit_ = end;
   limit_ = end;
   size_func_ = size_func;
 }
 
 
 #ifdef DEBUG
 // heap_histograms is shared, always clear it before using it.
 static void ClearHistograms() {
   Isolate* isolate = Isolate::Current();
   // We reset the name each time, though it hasn't changed.
@@ skipping 1038 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