Create a new paged heap space for global property cells. The new...

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 24 matching lines @@
 #include "natives.h"
 #include "platform.h"
 #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)
-// 2 bits identifying this as a HeapObject
+// 32-bit encoding: a RelativeAddress must be able to fit in a
+// pointer: it is encoded as an Address with (from LS to MS bits):
+// - 2 bits identifying this as a HeapObject.
+// - 4 bits to encode the AllocationSpace (including special values for
+//   code and fixed arrays in LO space)
+// - 27 bits identifying a word in the space, in one of three formats:
+// - paged 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
 
 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:
-const int kLOSpaceExecutable = LAST_SPACE + 1;
-// Reserve space for write barrier bits (for objects that can contain
-// references to new space):
-const int kLOSpacePointer = LAST_SPACE + 2;
-
+const int kSpaceBits = 4;
+const int kSpaceMask = (1 << kSpaceBits) - 1;
 
 const int kOffsetShift = kSpaceShift + kSpaceBits;
 const int kOffsetBits = 11;
 const int kOffsetMask = (1 << kOffsetBits) - 1;
 
+const int kPageShift = kOffsetShift + kOffsetBits;
 const int kPageBits = 32 - (kOffsetBits + kSpaceBits + kHeapObjectTagSize);
-const int kPageShift = kOffsetShift + kOffsetBits;
 const int kPageMask = (1 << kPageBits) - 1;
 
 const int kPageAndOffsetShift = kOffsetShift;
 const int kPageAndOffsetBits = kPageBits + kOffsetBits;
 const int kPageAndOffsetMask = (1 << kPageAndOffsetBits) - 1;
 
+// These values are special allocation space tags used for
+// serialization.
+// Mar the pages executable on platforms that support it.
+const int kLargeCode = LAST_SPACE + 1;
+// Allocate extra remembered-set bits.
+const int kLargeFixedArray = LAST_SPACE + 2;
+
 
 static inline AllocationSpace GetSpace(Address addr) {
   const intptr_t encoded = reinterpret_cast<intptr_t>(addr);
   int space_number = (static_cast<int>(encoded >> kSpaceShift) & kSpaceMask);
-  if (space_number == kLOSpaceExecutable) space_number = LO_SPACE;
-  else if (space_number == kLOSpacePointer) space_number = LO_SPACE;
+  if (space_number > LAST_SPACE) space_number = LO_SPACE;
   return static_cast<AllocationSpace>(space_number);
 }
 
 
 static inline bool IsLargeExecutableObject(Address addr) {
   const intptr_t encoded = reinterpret_cast<intptr_t>(addr);
   const int space_number =
       (static_cast<int>(encoded >> kSpaceShift) & kSpaceMask);
-  return (space_number == kLOSpaceExecutable);
+  return (space_number == kLargeCode);
 }
 
 
 static inline bool IsLargeFixedArray(Address addr) {
   const intptr_t encoded = reinterpret_cast<intptr_t>(addr);
   const int space_number =
       (static_cast<int>(encoded >> kSpaceShift) & kSpaceMask);
-  return (space_number == kLOSpacePointer);
+  return (space_number == kLargeFixedArray);
 }
 
 
 static inline int PageIndex(Address addr) {
   const intptr_t encoded = reinterpret_cast<intptr_t>(addr);
   return static_cast<int>(encoded >> kPageShift) & kPageMask;
 }
 
 
 static inline int PageOffset(Address addr) {
@@ skipping 27 matching lines @@
 // HeapObjects. The encoded Addresses are also encoded as HeapObjects
 // and allow for marking (is_marked() see mark(), clear_mark()...) as
 // used by the Mark-Compact collector.
 
 class RelativeAddress {
  public:
   RelativeAddress(AllocationSpace space,
                   int page_index,
                   int page_offset)
   : space_(space), page_index_(page_index), page_offset_(page_offset)  {
+    // Assert that the space encoding (plus the two pseudo-spaces for
+    // special large objects) fits in the available bits.
+    ASSERT(((LAST_SPACE + 2) & ~kSpaceMask) == 0);
     ASSERT(space <= LAST_SPACE && space >= 0);
   }
 
   // Return the encoding of 'this' as an Address. Decode with constructor.
   Address Encode() const;
 
   AllocationSpace space() const {
-    if (space_ == kLOSpaceExecutable) return LO_SPACE;
-    if (space_ == kLOSpacePointer) return LO_SPACE;
+    if (space_ > LAST_SPACE) 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_ == 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();
 #endif
 
   void set_to_large_code_object() {
     ASSERT(space_ == LO_SPACE);
-    space_ = kLOSpaceExecutable;
+    space_ = kLargeCode;
   }
   void set_to_large_fixed_array() {
     ASSERT(space_ == LO_SPACE);
-    space_ = kLOSpacePointer;
+    space_ = kLargeFixedArray;
   }
 
 
  private:
   int space_;
   int page_index_;
   int page_offset_;
 };
 
 
 Address RelativeAddress::Encode() const {
   ASSERT(page_index_ >= 0);
   int word_offset = 0;
   int result = 0;
   switch (space_) {
     case MAP_SPACE:
+    case 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_);
       word_offset = page_offset_ >> kObjectAlignmentBits;
       ASSERT_EQ(0, word_offset & ~kPageAndOffsetMask);
       result = word_offset << kPageAndOffsetShift;
       break;
     case LO_SPACE:
-    case kLOSpaceExecutable:
-    case kLOSpacePointer:
+    case kLargeCode:
+    case kLargeFixedArray:
       ASSERT_EQ(0, page_offset_);
       ASSERT_EQ(0, page_index_ & ~kPageAndOffsetMask);
       result = page_index_ << kPageAndOffsetShift;
       break;
   }
   // OR in AllocationSpace and kHeapObjectTag
   ASSERT_EQ(0, space_ & ~kSpaceMask);
   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 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:
-    case kLOSpaceExecutable:
-    case kLOSpacePointer:
+    case kLargeCode:
+    case kLargeFixedArray:
       ASSERT(page_offset_ == 0);
       break;
   }
 }
 #endif
 
 enum GCTreatment {
   DataObject,     // Object that cannot contain a reference to new space.
   PointerObject,  // Object that can contain a reference to new space.
   CodeObject      // Object that contains executable code.
@@ skipping 24 matching lines @@
   RelativeAddress Allocate(int size, GCTreatment special_gc_treatment);
 
  private:
   RelativeAddress current_;
 };
 
 
 void SimulatedHeapSpace::InitEmptyHeap(AllocationSpace space) {
   switch (space) {
     case MAP_SPACE:
+    case 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 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 == CELL_SPACE) {
+        ps = Heap::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 788 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::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),
+    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::cell_space(), reader_.GetInt(), &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 CELL_SPACE:
+      return ResolvePaged(PageIndex(encoded), PageOffset(encoded),
+                          Heap::cell_space(), &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