- Removed a few indirections by making the two SemiSpaces...

src/spaces.h

 // Copyright 2006-2008 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 860 matching lines @@
 
 // -----------------------------------------------------------------------------
 // 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.
 
 class SemiSpace : public Space {
  public:
-  // 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.
-  SemiSpace(int initial_capacity,
-            int maximum_capacity,
-            AllocationSpace id);
-  virtual ~SemiSpace() {}
+  // Constructor.
+  SemiSpace() :Space(NEW_SPACE, NOT_EXECUTABLE) {

[Kevin Millikin (Chromium), 2008/10/17 09:02:41]

A space (character) before 'Space'?

+    start_ = NULL;
+    age_mark_ = NULL;
+  }
 
   // Sets up the semispace using the given chunk.
-  bool Setup(Address start, int size);
+  bool Setup(Address start, int initial_capacity, int maximum_capacity);
 
   // Tear down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
   void TearDown();
 
   // True if the space has been set up but not torn down.
   bool HasBeenSetup() { return start_ != NULL; }
 
   // Double the size of the semispace by committing extra virtual memory.
   // Assumes that the caller has checked that the semispace has not reached
@@ skipping 105 matching lines @@
 
 
 // -----------------------------------------------------------------------------
 // The young generation space.
 //
 // The new space consists of a contiguous pair of semispaces.  It simply
 // forwards most functions to the appropriate semispace.
 
 class NewSpace : public Space {
  public:
-  // Create a new space with a given allocation capacity (ie, the capacity of
-  // *one* of the semispaces).  The constructor does not allocate heap memory
-  // from the OS.  When the space is set up, it is given a contiguous chunk of
-  // memory of size 2 * semispace_capacity.  To support fast containment
-  // testing in the new space, the size of this chunk must be a power of two
-  // and it must be aligned to its size.
-  NewSpace(int initial_semispace_capacity,
-           int maximum_semispace_capacity,
-           AllocationSpace id);
-  virtual ~NewSpace() {}
+  // Constructor.
+  NewSpace() : Space(NEW_SPACE, NOT_EXECUTABLE) {}
 
   // Sets up the new space using the given chunk.
   bool Setup(Address start, int size);
 
   // Tears down the space.  Heap memory was not allocated by the space, so it
   // is not deallocated here.
   void TearDown();
 
   // True if the space has been set up but not torn down.
   bool HasBeenSetup() {
-    return to_space_->HasBeenSetup() && from_space_->HasBeenSetup();
+    return to_space_.HasBeenSetup() && from_space_.HasBeenSetup();
   }
 
   // Flip the pair of spaces.
   void Flip();
 
   // Doubles the capacity of the semispaces.  Assumes that they are not at
   // their maximum capacity.  Returns a flag indicating success or failure.
   bool Double();
 
   // True if the address or object lies in the address range of either
@@ skipping 12 matching lines @@
   int Capacity() { return capacity_; }
   // Return the available bytes without growing in the active semispace.
   int Available() { return Capacity() - Size(); }
 
   // Return the maximum capacity of a semispace.
   int MaximumCapacity() { return maximum_capacity_; }
 
   // Return the address of the allocation pointer in the active semispace.
   Address top() { return allocation_info_.top; }
   // Return the address of the first object in the active semispace.
-  Address bottom() { return to_space_->low(); }
+  Address bottom() { return to_space_.low(); }
 
   // Get the age mark of the inactive semispace.
-  Address age_mark() { return from_space_->age_mark(); }
+  Address age_mark() { return from_space_.age_mark(); }
   // Set the age mark in the active semispace.
-  void set_age_mark(Address mark) { to_space_->set_age_mark(mark); }
+  void set_age_mark(Address mark) { to_space_.set_age_mark(mark); }
 
   // The start address of the space and a bit mask. Anding an address in the
   // new space with the mask will result in the start address.
   Address start() { return start_; }
   uint32_t mask() { return address_mask_; }
 
   // The allocation top and limit addresses.
   Address* allocation_top_address() { return &allocation_info_.top; }
   Address* allocation_limit_address() { return &allocation_info_.limit; }
 
@@ skipping 10 matching lines @@
   // Reset the allocation pointer to the beginning of the active semispace.
   void ResetAllocationInfo();
   // Reset the reloction pointer to the bottom of the inactive semispace in
   // preparation for mark-compact collection.
   void MCResetRelocationInfo();
   // Update the allocation pointer in the active semispace after a
   // mark-compact collection.
   void MCCommitRelocationInfo();
 
   // Get the extent of the inactive semispace (for use as a marking stack).
-  Address FromSpaceLow() { return from_space_->low(); }
-  Address FromSpaceHigh() { return from_space_->high(); }
+  Address FromSpaceLow() { return from_space_.low(); }
+  Address FromSpaceHigh() { return from_space_.high(); }
 
   // Get the extent of the active semispace (to sweep newly copied objects
   // during a scavenge collection).
-  Address ToSpaceLow() { return to_space_->low(); }
-  Address ToSpaceHigh() { return to_space_->high(); }
+  Address ToSpaceLow() { return to_space_.low(); }
+  Address ToSpaceHigh() { return to_space_.high(); }
 
   // Offsets from the beginning of the semispaces.
   int ToSpaceOffsetForAddress(Address a) {
-    return to_space_->SpaceOffsetForAddress(a);
+    return to_space_.SpaceOffsetForAddress(a);
   }
   int FromSpaceOffsetForAddress(Address a) {
-    return from_space_->SpaceOffsetForAddress(a);
+    return from_space_.SpaceOffsetForAddress(a);
   }
 
   // True if the object is a heap object in the address range of the
   // respective semispace (not necessarily below the allocation pointer of the
   // semispace).
-  bool ToSpaceContains(Object* o) { return to_space_->Contains(o); }
-  bool FromSpaceContains(Object* o) { return from_space_->Contains(o); }
+  bool ToSpaceContains(Object* o) { return to_space_.Contains(o); }
+  bool FromSpaceContains(Object* o) { return from_space_.Contains(o); }
 
-  bool ToSpaceContains(Address a) { return to_space_->Contains(a); }
-  bool FromSpaceContains(Address a) { return from_space_->Contains(a); }
+  bool ToSpaceContains(Address a) { return to_space_.Contains(a); }
+  bool FromSpaceContains(Address a) { return from_space_.Contains(a); }
 
 #ifdef DEBUG
   // Verify the active semispace.
   virtual void Verify();
   // Print the active semispace.
-  virtual void Print() { to_space_->Print(); }
+  virtual void Print() { to_space_.Print(); }
 #endif
 
 #if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
   // Iterates the active semispace to collect statistics.
   void CollectStatistics();
   // Reports previously collected statistics of the active semispace.
   void ReportStatistics();
   // Clears previously collected statistics.
   void ClearHistograms();
 
   // Record the allocation or promotion of a heap object.  Note that we don't
   // record every single allocation, but only those that happen in the
   // to space during a scavenge GC.
   void RecordAllocation(HeapObject* obj);
   void RecordPromotion(HeapObject* obj);
 #endif
 
  private:
   // The current and maximum capacities of a semispace.
   int capacity_;
   int maximum_capacity_;
 
   // The semispaces.
-  SemiSpace* to_space_;
-  SemiSpace* from_space_;
+  SemiSpace to_space_;
+  SemiSpace from_space_;
 
   // Start address and bit mask for containment testing.
   Address start_;
   uint32_t address_mask_;
   uint32_t object_mask_;
   uint32_t object_expected_;
 
   // Allocation pointer and limit for normal allocation and allocation during
   // mark-compact collection.
   AllocationInfo allocation_info_;
@@ skipping 494 matching lines @@
 
  private:
   LargeObjectChunk* current_;
   HeapObjectCallback size_func_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_SPACES_H_