Create a separate space for global property cells

src/serialize.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 26 matching lines @@
 #include "runtime.h"
 #include "serialize.h"
 #include "stub-cache.h"
 #include "v8threads.h"
 
 namespace v8 {
 namespace internal {
 
 // Encoding: a RelativeAddress must be able to fit in a pointer:
 // it is encoded as an Address with (from MS to LS bits):
-// 27 bits identifying a word in the space, in one of three formats:
-// - MAP and OLD spaces: 16 bits of page number, 11 bits of word offset in page
-// - NEW space:          27 bits of word offset
-// - LO space:           27 bits of page number
-// 3 bits to encode the AllocationSpace (special values for code in LO space)
+// 26 bits identifying a word in the space, in one of three formats:
+// - MAP and OLD spaces: 15 bits of page number, 11 bits of word offset in page
+// - NEW space:          26 bits of word offset
+// - LO space:           26 bits of page number
+// 4 bits to encode the AllocationSpace (special values for code in LO space)
 // 2 bits identifying this as a HeapObject
 
 const int kSpaceShift = kHeapObjectTagSize;
 const int kSpaceBits = kSpaceTagSize;
 const int kSpaceMask = kSpaceTagMask;
 
 // These value are used instead of space numbers when serializing/
 // deserializing.  They indicate an object that is in large object space, but
 // should be treated specially.
 // Make the pages executable on platforms that support it:
@@ skipping 96 matching lines @@
     if (space_ == kLOSpacePointer) return LO_SPACE;
     return static_cast<AllocationSpace>(space_);
   }
   int page_index() const { return page_index_; }
   int page_offset() const { return page_offset_; }
 
   bool in_paged_space() const {
     return space_ == CODE_SPACE ||
            space_ == OLD_POINTER_SPACE ||
            space_ == OLD_DATA_SPACE ||
-           space_ == MAP_SPACE;
+           space_ == MAP_SPACE ||
+           space_ == GLOBAL_PROPERTY_CELL_SPACE;
   }
 
   void next_address(int offset) { page_offset_ += offset; }
   void next_page(int init_offset = 0) {
     page_index_++;
     page_offset_ = init_offset;
   }
 
 #ifdef DEBUG
   void Verify();
@@ skipping 15 matching lines @@
   int page_offset_;
 };
 
 
 Address RelativeAddress::Encode() const {
   ASSERT(page_index_ >= 0);
   int word_offset = 0;
   int result = 0;
   switch (space_) {
     case MAP_SPACE:
+    case GLOBAL_PROPERTY_CELL_SPACE:
     case OLD_POINTER_SPACE:
     case OLD_DATA_SPACE:
     case CODE_SPACE:
       ASSERT_EQ(0, page_index_ & ~kPageMask);
       word_offset = page_offset_ >> kObjectAlignmentBits;
       ASSERT_EQ(0, word_offset & ~kOffsetMask);
       result = (page_index_ << kPageShift) | (word_offset << kOffsetShift);
       break;
     case NEW_SPACE:
       ASSERT_EQ(0, page_index_);
@@ skipping 14 matching lines @@
   result |= (space_ << kSpaceShift) | kHeapObjectTag;
   return reinterpret_cast<Address>(result);
 }
 
 
 #ifdef DEBUG
 void RelativeAddress::Verify() {
   ASSERT(page_offset_ >= 0 && page_index_ >= 0);
   switch (space_) {
     case MAP_SPACE:
+    case GLOBAL_PROPERTY_CELL_SPACE:
     case OLD_POINTER_SPACE:
     case OLD_DATA_SPACE:
     case CODE_SPACE:
       ASSERT(Page::kObjectStartOffset <= page_offset_ &&
              page_offset_ <= Page::kPageSize);
       break;
     case NEW_SPACE:
       ASSERT(page_index_ == 0);
       break;
     case LO_SPACE:
@@ skipping 36 matching lines @@
   RelativeAddress Allocate(int size, GCTreatment special_gc_treatment);
 
  private:
   RelativeAddress current_;
 };
 
 
 void SimulatedHeapSpace::InitEmptyHeap(AllocationSpace space) {
   switch (space) {
     case MAP_SPACE:
+    case GLOBAL_PROPERTY_CELL_SPACE:
     case OLD_POINTER_SPACE:
     case OLD_DATA_SPACE:
     case CODE_SPACE:
       current_ = RelativeAddress(space, 0, Page::kObjectStartOffset);
       break;
     case NEW_SPACE:
     case LO_SPACE:
       current_ = RelativeAddress(space, 0, 0);
       break;
   }
 }
 
 
 void SimulatedHeapSpace::InitCurrentHeap(AllocationSpace space) {
   switch (space) {
     case MAP_SPACE:
+    case GLOBAL_PROPERTY_CELL_SPACE:
     case OLD_POINTER_SPACE:
     case OLD_DATA_SPACE:
     case CODE_SPACE: {
       PagedSpace* ps;
       if (space == MAP_SPACE) {
         ps = Heap::map_space();
+      } else if (space == GLOBAL_PROPERTY_CELL_SPACE) {
+        ps = Heap::global_property_cell_space();
       } else if (space == OLD_POINTER_SPACE) {
         ps = Heap::old_pointer_space();
       } else if (space == OLD_DATA_SPACE) {
         ps = Heap::old_data_space();
       } else {
         ASSERT(space == CODE_SPACE);
         ps = Heap::code_space();
       }
       Address top = ps->top();
       Page* top_page = Page::FromAllocationTop(top);
@@ skipping 780 matching lines @@
   writer_->PutC('S');
   writer_->PutC('[');
   writer_->PutInt(Heap::old_pointer_space()->Size() +
                   Heap::new_space()->Size());
   writer_->PutC('|');
   writer_->PutInt(Heap::old_data_space()->Size() + Heap::new_space()->Size());
   writer_->PutC('|');
   writer_->PutInt(Heap::code_space()->Size() + Heap::new_space()->Size());
   writer_->PutC('|');
   writer_->PutInt(Heap::map_space()->Size());
+  writer_->PutC('|');
+  writer_->PutInt(Heap::global_property_cell_space()->Size());
   writer_->PutC(']');
   // Write global handles.
   writer_->PutC('G');
   writer_->PutC('[');
   GlobalHandlesRetriever ghr(&global_handles_);
   GlobalHandles::IterateRoots(&ghr);
   for (int i = 0; i < global_handles_.length(); i++) {
     writer_->PutC('N');
   }
   writer_->PutC(']');
@@ skipping 162 matching lines @@
 //------------------------------------------------------------------------------
 // Implementation of Deserializer
 
 
 static const int kInitArraySize = 32;
 
 
 Deserializer::Deserializer(const byte* str, int len)
   : reader_(str, len),
     map_pages_(kInitArraySize),
+    global_property_cell_pages_(kInitArraySize),
     old_pointer_pages_(kInitArraySize),
     old_data_pages_(kInitArraySize),
     code_pages_(kInitArraySize),
     large_objects_(kInitArraySize),
     global_handles_(4) {
   root_ = true;
   roots_ = 0;
   objects_ = 0;
   reference_decoder_ = NULL;
 #ifdef DEBUG
@@ skipping 152 matching lines @@
   reader_.ExpectC('[');
   InitPagedSpace(Heap::old_pointer_space(),
                  reader_.GetInt(),
                  &old_pointer_pages_);
   reader_.ExpectC('|');
   InitPagedSpace(Heap::old_data_space(), reader_.GetInt(), &old_data_pages_);
   reader_.ExpectC('|');
   InitPagedSpace(Heap::code_space(), reader_.GetInt(), &code_pages_);
   reader_.ExpectC('|');
   InitPagedSpace(Heap::map_space(), reader_.GetInt(), &map_pages_);
+  reader_.ExpectC('|');
+  InitPagedSpace(Heap::global_property_cell_space(), reader_.GetInt(),
+                 &global_property_cell_pages_);
   reader_.ExpectC(']');
   // Create placeholders for global handles later to be fill during
   // IterateRoots.
   reader_.ExpectC('G');
   reader_.ExpectC('[');
   int c = reader_.GetC();
   while (c != ']') {
     ASSERT(c == 'N');
     global_handles_.Add(GlobalHandles::Create(NULL).location());
     c = reader_.GetC();
@@ skipping 112 matching lines @@
   ASSERT(o->IsHeapObject());
 
   switch (GetSpace(encoded)) {
     // For Map space and Old space, we cache the known Pages in map_pages,
     // old_pointer_pages and old_data_pages. Even though MapSpace keeps a list
     // of page addresses, we don't rely on it since GetObject uses AllocateRaw,
     // and that appears not to update the page list.
     case MAP_SPACE:
       return ResolvePaged(PageIndex(encoded), PageOffset(encoded),
                           Heap::map_space(), &map_pages_);
+    case GLOBAL_PROPERTY_CELL_SPACE:
+      return ResolvePaged(PageIndex(encoded), PageOffset(encoded),
+                          Heap::global_property_cell_space(),
+                          &global_property_cell_pages_);
     case OLD_POINTER_SPACE:
       return ResolvePaged(PageIndex(encoded), PageOffset(encoded),
                           Heap::old_pointer_space(), &old_pointer_pages_);
     case OLD_DATA_SPACE:
       return ResolvePaged(PageIndex(encoded), PageOffset(encoded),
                           Heap::old_data_space(), &old_data_pages_);
     case CODE_SPACE:
       return ResolvePaged(PageIndex(encoded), PageOffset(encoded),
                           Heap::code_space(), &code_pages_);
     case NEW_SPACE:
@@ skipping 19 matching lines @@
         ASSERT(index < large_objects_.length());
       }
       return large_objects_[index];  // s.page_offset() is ignored.
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 } }  // namespace v8::internal