Make newspace semispaces be single page-sized memory chunks.

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 1392 matching lines @@
 
   const char* name() { return name_; }
   void set_name(const char* name) { name_ = name; }
 
  private:
   const char* name_;
 };
 #endif
 
 
+class NewSpacePage : public MemoryChunk {
+ public:
+  inline NewSpacePage* next_page() const {
+    return static_cast<NewSpacePage*>(next_chunk());
+  }
+
+  inline void set_next_page(NewSpacePage* page) {
+    set_next_chunk(page);
+  }
+ private:
+  // Finds the NewSpacePage containg the given address.
+  static NewSpacePage* FromAddress(Address address_in_page) {
+    Address page_start =
+        reinterpret_cast<Address>(reinterpret_cast<uintptr_t>(address_in_page) &
+                                  ~Page::kPageAlignmentMask);
+    return reinterpret_cast<NewSpacePage*>(page_start);
+  }
+
+  static NewSpacePage* Initialize(Heap* heap, Address start);
+
+  friend class SemiSpace;
+  friend class SemiSpaceIterator;
+};
+
+
 // -----------------------------------------------------------------------------
 // SemiSpace in young generation
 //
-// A semispace is a contiguous chunk of memory. The mark-compact collector
-// uses the memory in the from space as a marking stack when tracing live
-// objects.
+// A semispace is a contiguous chunk of memory holding page-like memory
+// chunks. The mark-compact collector  uses the memory of the first page in
+// the from space as a marking stack when tracing live objects.
 
 class SemiSpace : public Space {
  public:
   // Constructor.
   explicit SemiSpace(Heap* heap) : Space(heap, NEW_SPACE, NOT_EXECUTABLE) {
     start_ = NULL;
     age_mark_ = NULL;
   }
 
   // Sets up the semispace using the given chunk.
@@ skipping 15 matching lines @@
   // Grow the semispace to the new capacity.  The new capacity
   // requested must be larger than the current capacity.
   bool GrowTo(int new_capacity);
 
   // Shrinks the semispace to the new capacity.  The new capacity
   // requested must be more than the amount of used memory in the
   // semispace and less than the current capacity.
   bool ShrinkTo(int new_capacity);
 
   // Returns the start address of the space.
-  Address low() { return start_; }
+  Address low() {
+    return NewSpacePage::FromAddress(start_)->body();
+  }
+
   // Returns one past the end address of the space.
-  Address high() { return low() + capacity_; }
+  Address high() {
+    // TODO(gc): Change when there is more than one page.
+    return current_page_->body() + current_page_->body_size();
+  }
 
   // Age mark accessors.
   Address age_mark() { return age_mark_; }
   void set_age_mark(Address mark) { age_mark_ = mark; }
 
   // True if the address is in the address range of this semispace (not
   // necessarily below the allocation pointer).
   bool Contains(Address a) {
     return (reinterpret_cast<uintptr_t>(a) & address_mask_)
            == reinterpret_cast<uintptr_t>(start_);
@@ skipping 19 matching lines @@
 
   virtual bool ReserveSpace(int bytes) {
     UNREACHABLE();
     return false;
   }
 
   bool is_committed() { return committed_; }
   bool Commit();
   bool Uncommit();
 
+  NewSpacePage* first_page() { return NewSpacePage::FromAddress(start_); }
+  NewSpacePage* current_page() { return current_page_; }
+
 #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();
 #endif
@@ skipping 18 matching lines @@
   // Used to govern object promotion during mark-compact collection.
   Address age_mark_;
 
   // Masks and comparison values to test for containment in this semispace.
   uintptr_t address_mask_;
   uintptr_t object_mask_;
   uintptr_t object_expected_;
 
   bool committed_;
 
+  NewSpacePage* current_page_;
+
  public:
   TRACK_MEMORY("SemiSpace")
 };
 
 
 // A SemiSpaceIterator is an ObjectIterator that iterates over the active
 // semispace of the heap's new space.  It iterates over the objects in the
 // semispace from a given start address (defaulting to the bottom of the
 // semispace) to the top of the semispace.  New objects allocated after the
 // iterator is created are not iterated.
 class SemiSpaceIterator : public ObjectIterator {
  public:
   // Create an iterator over the objects in the given space.  If no start
   // address is given, the iterator starts from the bottom of the space.  If
   // no size function is given, the iterator calls Object::Size().
   explicit SemiSpaceIterator(NewSpace* space);
   SemiSpaceIterator(NewSpace* space, HeapObjectCallback size_func);
   SemiSpaceIterator(NewSpace* space, Address start);
 
   HeapObject* next() {
+    if (current_ == current_page_limit_) {
+      // TODO(gc): Add something here when we have more than one page.
+    }
     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(NewSpace* space,
                   Address start,
                   Address end,
                   HeapObjectCallback size_func);
 
   // The semispace.
   SemiSpace* space_;
   // 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_;
 };
 
 
 // -----------------------------------------------------------------------------
 // The young generation space.
 //
@@ skipping 578 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_