Create a separate space for global property cells

src/spaces.cc

 // 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 1427 matching lines @@
       FreeListNode* cur_node = FreeListNode::FromAddress(cur_addr);
       if (cur_node == node) return true;
       cur_addr = cur_node->next();
     }
   }
   return false;
 }
 #endif
 
 
-MapSpaceFreeList::MapSpaceFreeList(AllocationSpace owner) {
-  owner_ = owner;
-  Reset();
+FixedSizeFreeList::FixedSizeFreeList(AllocationSpace owner, int object_size)
+    : owner_(owner), object_size_(object_size) {
+      Reset();
 }
 
 
-void MapSpaceFreeList::Reset() {
+void FixedSizeFreeList::Reset() {
   available_ = 0;
   head_ = NULL;
 }
 
 
-void MapSpaceFreeList::Free(Address start) {
+void FixedSizeFreeList::Free(Address start) {
 #ifdef DEBUG
-  for (int i = 0; i < Map::kSize; i += kPointerSize) {
+  for (int i = 0; i < object_size_; i += kPointerSize) {
     Memory::Address_at(start + i) = kZapValue;
   }
 #endif
   ASSERT(!FLAG_always_compact);  // We only use the freelists with mark-sweep.
   FreeListNode* node = FreeListNode::FromAddress(start);
-  node->set_size(Map::kSize);
+  node->set_size(object_size_);
   node->set_next(head_);
   head_ = node->address();
-  available_ += Map::kSize;
+  available_ += object_size_;
 }
 
 
-Object* MapSpaceFreeList::Allocate() {
+Object* FixedSizeFreeList::Allocate() {
   if (head_ == NULL) {
-    return Failure::RetryAfterGC(Map::kSize, owner_);
+    return Failure::RetryAfterGC(object_size_, owner_);
   }
 
   ASSERT(!FLAG_always_compact);  // We only use the freelists with mark-sweep.
   FreeListNode* node = FreeListNode::FromAddress(head_);
   head_ = node->next();
-  available_ -= Map::kSize;
+  available_ -= object_size_;
   return node;
 }
 
 
 // -----------------------------------------------------------------------------
 // OldSpace implementation
 
 void OldSpace::PrepareForMarkCompact(bool will_compact) {
   if (will_compact) {
     // Reset relocation info.  During a compacting collection, everything in
@@ skipping 486 matching lines @@
                    p->AllocationTop());
     PrintF("\n");
   }
 }
 
 
 void OldSpace::PrintRSet() { DoPrintRSet("old"); }
 #endif
 
 // -----------------------------------------------------------------------------
-// MapSpace implementation
+// PagedSpaceForFixedSizedObjects implementation
 
-void MapSpace::PrepareForMarkCompact(bool will_compact) {
+void PagedSpaceForFixedSizedObjects::PrepareForMarkCompact(bool will_compact) {
   if (will_compact) {
     // Reset relocation info.
     MCResetRelocationInfo();
 
-    // Initialize map index entry.
-    int page_count = 0;
-    PageIterator it(this, PageIterator::ALL_PAGES);
-    while (it.has_next()) {
-      ASSERT_MAP_PAGE_INDEX(page_count);
-
-      Page* p = it.next();
-      ASSERT(p->mc_page_index == page_count);
-
-      page_addresses_[page_count++] = p->address();
-    }
-
     // During a compacting collection, everything in the space is considered
     // 'available' (set by the call to MCResetRelocationInfo) and we will
     // rediscover live and wasted bytes during the collection.
     ASSERT(Available() == Capacity());
   } else {
     // During a non-compacting collection, everything below the linear
     // allocation pointer except wasted top-of-page blocks is considered
     // allocated and we will rediscover available bytes during the
     // collection.
     accounting_stats_.AllocateBytes(free_list_.available());
   }
 
   // Clear the free list before a full GC---it will be rebuilt afterward.
   free_list_.Reset();
 }
 
 
-void MapSpace::MCCommitRelocationInfo() {
+void PagedSpaceForFixedSizedObjects::MCCommitRelocationInfo() {
   // Update fast allocation info.
   allocation_info_.top = mc_forwarding_info_.top;
   allocation_info_.limit = mc_forwarding_info_.limit;
   ASSERT(allocation_info_.VerifyPagedAllocation());
 
   // The space is compacted and we haven't yet wasted any space.
   ASSERT(Waste() == 0);
 
   // Update allocation_top of each page in use and compute waste.
   int computed_size = 0;
   PageIterator it(this, PageIterator::PAGES_USED_BY_MC);
   while (it.has_next()) {
     Page* page = it.next();
     Address page_top = page->AllocationTop();
     computed_size += page_top - page->ObjectAreaStart();
     if (it.has_next()) {
       accounting_stats_.WasteBytes(page->ObjectAreaEnd() - page_top);
     }
   }
 
   // Make sure the computed size - based on the used portion of the
   // pages in use - matches the size we adjust during allocation.
   ASSERT(computed_size == Size());
 }
 
 
 // Slow case for normal allocation. Try in order: (1) allocate in the next
 // page in the space, (2) allocate off the space's free list, (3) expand the
 // space, (4) fail.
-HeapObject* MapSpace::SlowAllocateRaw(int size_in_bytes) {
+HeapObject* PagedSpaceForFixedSizedObjects::SlowAllocateRaw(int size_in_bytes) {
+  ASSERT_EQ(object_size_, size_in_bytes);
   // Linear allocation in this space has failed.  If there is another page
   // in the space, move to that page and allocate there.  This allocation
   // should succeed.
   Page* current_page = TopPageOf(allocation_info_);
   if (current_page->next_page()->is_valid()) {
     return AllocateInNextPage(current_page, size_in_bytes);
   }
 
   // There is no next page in this space.  Try free list allocation.  The
-  // map space free list implicitly assumes that all free blocks are map
-  // sized.
-  if (size_in_bytes == Map::kSize) {
+  // space free list implicitly assumes that all free blocks are of the fixed
+  // size.
+  if (size_in_bytes == object_size_) {
     Object* result = free_list_.Allocate();
     if (!result->IsFailure()) {
       accounting_stats_.AllocateBytes(size_in_bytes);
       return HeapObject::cast(result);
     }
   }
 
   // Free list allocation failed and there is no next page.  Fail if we have
   // hit the old generation size limit that should cause a garbage
   // collection.
   if (!Heap::always_allocate() && Heap::OldGenerationAllocationLimitReached()) {
     return NULL;
   }
 
   // Try to expand the space and allocate in the new next page.
   ASSERT(!current_page->next_page()->is_valid());
   if (Expand(current_page)) {
     return AllocateInNextPage(current_page, size_in_bytes);
   }
 
   // Finally, fail.
   return NULL;
 }
 
 
 // Move to the next page (there is assumed to be one) and allocate there.
 // The top of page block is always wasted, because it is too small to hold a
 // map.
-HeapObject* MapSpace::AllocateInNextPage(Page* current_page,
-                                         int size_in_bytes) {
+HeapObject* PagedSpaceForFixedSizedObjects::AllocateInNextPage(
+    Page* current_page, int size_in_bytes) {
   ASSERT(current_page->next_page()->is_valid());
-  ASSERT(current_page->ObjectAreaEnd() - allocation_info_.top == kPageExtra);
-  accounting_stats_.WasteBytes(kPageExtra);
+  ASSERT(current_page->ObjectAreaEnd() - allocation_info_.top == page_extra_);
+  ASSERT_EQ(object_size_, size_in_bytes);
+  accounting_stats_.WasteBytes(page_extra_);
   SetAllocationInfo(&allocation_info_, current_page->next_page());
   return AllocateLinearly(&allocation_info_, size_in_bytes);
 }
 
 
 #ifdef DEBUG
 // We do not assume that the PageIterator works, because it depends on the
 // invariants we are checking during verification.
-void MapSpace::Verify() {
+void PagedSpaceForFixedSizedObjects::Verify() {
   // The allocation pointer should be valid, and it should be in a page in the
   // space.
   ASSERT(allocation_info_.VerifyPagedAllocation());
   Page* top_page = Page::FromAllocationTop(allocation_info_.top);
   ASSERT(MemoryAllocator::IsPageInSpace(top_page, this));
 
   // Loop over all the pages.
   bool above_allocation_top = false;
   Page* current_page = first_page_;
   while (current_page->is_valid()) {
     if (above_allocation_top) {
       // We don't care what's above the allocation top.
     } else {
       // Unless this is the last page in the space containing allocated
       // objects, the allocation top should be at a constant offset from the
       // object area end.
       Address top = current_page->AllocationTop();
       if (current_page == top_page) {
         ASSERT(top == allocation_info_.top);
         // The next page will be above the allocation top.
         above_allocation_top = true;
       } else {
-        ASSERT(top == current_page->ObjectAreaEnd() - kPageExtra);
+        ASSERT(top == current_page->ObjectAreaEnd() - page_extra_);
       }
 
       // It should be packed with objects from the bottom to the top.
       Address current = current_page->ObjectAreaStart();
       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));
 
-        // The object should be a map or a byte array.
-        ASSERT(object->IsMap() || object->IsByteArray());
+        // Verify the object in the space.
+        VerifyObject(object);
 
         // The object itself should look OK.
         object->Verify();
 
         // All the interior pointers should be contained in the heap and
         // have their remembered set bits set if they point to new space.
         VerifyPointersAndRSetVisitor 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);
     }
 
     current_page = current_page->next_page();
   }
 }
 
 
-void MapSpace::ReportStatistics() {
+void PagedSpaceForFixedSizedObjects::ReportStatistics() {
   int pct = Available() * 100 / Capacity();
   PrintF("  capacity: %d, waste: %d, available: %d, %%%d\n",
          Capacity(), Waste(), Available(), pct);
 
   // Report remembered set statistics.
   int rset_marked_pointers = 0;
   int cross_gen_pointers = 0;
 
   PageIterator page_it(this, PageIterator::PAGES_IN_USE);
   while (page_it.has_next()) {
@@ skipping 26 matching lines @@
   PrintF("  rset-marked pointers %d, to-new-space %d (%%%d)\n",
             rset_marked_pointers, cross_gen_pointers, pct);
 
   ClearHistograms();
   HeapObjectIterator obj_it(this);
   while (obj_it.has_next()) { CollectHistogramInfo(obj_it.next()); }
   ReportHistogram(false);
 }
 
 
-void MapSpace::PrintRSet() { DoPrintRSet("map"); }
+void PagedSpaceForFixedSizedObjects::PrintRSet() { DoPrintRSet(name_); }
+#endif
+
+
+// -----------------------------------------------------------------------------
+// MapSpace implementation
+
+void MapSpace::PrepareForMarkCompact(bool will_compact) {
+  // Call prepare of the super class.
+  PagedSpaceForFixedSizedObjects::PrepareForMarkCompact(will_compact);
+
+  if (will_compact) {
+    // Initialize map index entry.
+    int page_count = 0;
+    PageIterator it(this, PageIterator::ALL_PAGES);
+    while (it.has_next()) {
+      ASSERT_MAP_PAGE_INDEX(page_count);
+
+      Page* p = it.next();
+      ASSERT(p->mc_page_index == page_count);
+
+      page_addresses_[page_count++] = p->address();
+    }
+  }
+}
+
+
+#ifdef DEBUG
+void MapSpace::VerifyObject(HeapObject* object) {
+  // The object should be a map or a byte array.
+  ASSERT(object->IsMap() || object->IsByteArray());
+}
+#endif
+
+
+// -----------------------------------------------------------------------------
+// GlobalPropertyCellSpace implementation
+
+#ifdef DEBUG
+void GlobalPropertyCellSpace::VerifyObject(HeapObject* object) {
+  // The object should be a global object property cell or a byte array.
+  ASSERT(object->IsJSGlobalPropertyCell() || object->IsByteArray());
+}
 #endif
 
 
 // -----------------------------------------------------------------------------
 // LargeObjectIterator
 
 LargeObjectIterator::LargeObjectIterator(LargeObjectSpace* space) {
   current_ = space->first_chunk_;
   size_func_ = NULL;
 }
@@ skipping 400 matching lines @@
                      reinterpret_cast<Object**>(object->address()
                                                 + Page::kObjectAreaSize),
                      allocation_top);
       PrintF("\n");
     }
   }
 }
 #endif  // DEBUG
 
 } }  // namespace v8::internal