Support large objects in the serializer/deserializer.

src/serialize.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_SERIALIZE_H_
 #define V8_SERIALIZE_H_
 
 #include "src/compiler.h"
 #include "src/hashmap.h"
 #include "src/heap-profiler.h"
@@ skipping 130 matching lines @@
 
 // The Serializer/Deserializer class is a common superclass for Serializer and
 // Deserializer which is used to store common constants and methods used by
 // both.
 class SerializerDeserializer: public ObjectVisitor {
  public:
   static void Iterate(Isolate* isolate, ObjectVisitor* visitor);
 
   static int nop() { return kNop; }
 
+  // No reservation for large object space necessary.
+  static const int kNumberOfReservedSpaces = LO_SPACE;
+  static const int kNumberOfSpaces = INVALID_SPACE;
+
  protected:
   // Where the pointed-to object can be found:
   enum Where {
     kNewObject = 0,  // Object is next in snapshot.
-    // 1-6                             One per space.
+    // 1-7                             One per space.
     kRootArray = 0x9,             // Object is found in root array.
     kPartialSnapshotCache = 0xa,  // Object is in the cache.
     kExternalReference = 0xb,     // Pointer to an external reference.
     kSkip = 0xc,                  // Skip n bytes.
     kBuiltin = 0xd,               // Builtin code object.
     kAttachedReference = 0xe,     // Object is described in an attached list.
     kNop = 0xf,                   // Does nothing, used to pad.
     kBackref = 0x10,              // Object is described relative to end.
-    // 0x11-0x16                       One per space.
+    // 0x11-0x17                       One per space.
     kBackrefWithSkip = 0x18,  // Object is described relative to end.
-    // 0x19-0x1e                       One per space.
+    // 0x19-0x1f                       One per space.
     // 0x20-0x3f                       Used by misc. tags below.
     kPointedToMask = 0x3f
   };
 
   // How to code the pointer to the object.
   enum HowToCode {
     kPlain = 0,                          // Straight pointer.
     // What this means depends on the architecture:
     kFromCode = 0x40,                    // A pointer inlined in code.
     kHowToCodeMask = 0x40
@@ skipping 41 matching lines @@
     DCHECK(byte_code >= kConstantRepeat && byte_code <= 0x7f);
     return byte_code - 0x72;
   }
   static const int kRootArrayConstants = 0xa0;
   // 0xa0-0xbf            Things from the first 32 elements of the root array.
   static const int kRootArrayNumberOfConstantEncodings = 0x20;
   static int RootArrayConstantFromByteCode(int byte_code) {
     return byte_code & 0x1f;
   }
 
-  static const int kNumberOfSpaces = LO_SPACE;
   static const int kAnyOldSpace = -1;
 
   // A bitmask for getting the space out of an instruction.
   static const int kSpaceMask = 7;
+  STATIC_ASSERT(kNumberOfSpaces <= kSpaceMask + 1);
 };
 
 
 // A Deserializer reads a snapshot and reconstructs the Object graph it defines.
 class Deserializer: public SerializerDeserializer {
  public:
   // Create a deserializer from a snapshot byte source.
   explicit Deserializer(SnapshotByteSource* source);
 
   virtual ~Deserializer();
 
   // Deserialize the snapshot into an empty heap.
   void Deserialize(Isolate* isolate);
 
   // Deserialize a single object and the objects reachable from it.
   void DeserializePartial(Isolate* isolate, Object** root);
 
   void set_reservation(int space_number, int reservation) {
     DCHECK(space_number >= 0);
-    DCHECK(space_number <= LAST_SPACE);
+    DCHECK(space_number < kNumberOfReservedSpaces);
     reservations_[space_number] = reservation;
   }
 
+  void set_large_objects_total_size(int size) {
+    large_objects_total_size_ = size;
+  }
+
   void FlushICacheForNewCodeObjects();
 
   // Serialized user code reference certain objects that are provided in a list
   // By calling this method, we assume that we are deserializing user code.
   void SetAttachedObjects(Vector<Handle<Object> >* attached_objects) {
     attached_objects_ = attached_objects;
   }
 
   bool deserializing_user_code() { return attached_objects_ != NULL; }
 
@@ skipping 14 matching lines @@
   // object, i.e. if we are writing a series of tagged values that are not on
   // the heap.
   void ReadChunk(
       Object** start, Object** end, int space, Address object_address);
   void ReadObject(int space_number, Object** write_back);
 
   // Special handling for serialized code like hooking up internalized strings.
   HeapObject* ProcessNewObjectFromSerializedCode(HeapObject* obj);
   Object* ProcessBackRefInSerializedCode(Object* obj);
 
-  // This routine both allocates a new object, and also keeps
-  // track of where objects have been allocated so that we can
-  // fix back references when deserializing.
+  // We know the space requirements before deserialization and can
+  // pre-allocate that reserved space. During deserialization, all we need
+  // to do is to bump up the pointer for each space in the reserved
+  // space. This is also used for fixing back references.
+  // Since multiple large objects cannot be folded into one large object
+  // space allocation, we have to do an actual allocation when deserializing
+  // each allocation. Instead of tracking offset for back references, we
+  // reference large objects by index.
   Address Allocate(int space_index, int size) {
-    Address address = high_water_[space_index];
-    high_water_[space_index] = address + size;
-    return address;
+    if (space_index == LO_SPACE) {
+      Executability exec = static_cast<Executability>(source_->GetInt());
+      HeapObject* obj = isolate_->heap()->ForceAllocateLargeObject(size, exec);
+      deserialized_large_objects_.Add(obj);
+      return obj->address();
+    } else {
+      DCHECK(space_index < kNumberOfReservedSpaces);
+      Address address = high_water_[space_index];
+      high_water_[space_index] = address + size;
+      return address;
+    }
   }
 
   // This returns the address of an object that has been described in the
   // snapshot as being offset bytes back in a particular space.
   HeapObject* GetAddressFromEnd(int space) {
     int offset = source_->GetInt();
+    if (space == LO_SPACE) return deserialized_large_objects_[offset];
     offset <<= kObjectAlignmentBits;
     return HeapObject::FromAddress(high_water_[space] - offset);
   }
 
   // Cached current isolate.
   Isolate* isolate_;
 
   // Objects from the attached object descriptions in the serialized user code.
   Vector<Handle<Object> >* attached_objects_;
 
   SnapshotByteSource* source_;
   // This is the address of the next object that will be allocated in each
   // space.  It is used to calculate the addresses of back-references.
-  Address high_water_[LAST_SPACE + 1];
+  Address high_water_[kNumberOfReservedSpaces];
 
-  int reservations_[LAST_SPACE + 1];
+  int reservations_[kNumberOfReservedSpaces];
   static const intptr_t kUninitializedReservation = -1;
 
   ExternalReferenceDecoder* external_reference_decoder_;
 
+  List<HeapObject*> deserialized_large_objects_;
+  int large_objects_total_size_;
+
   DISALLOW_COPY_AND_ASSIGN(Deserializer);
 };
 
 
 // Mapping objects to their location after deserialization.
 // This is used during building, but not at runtime by V8.
 class SerializationAddressMapper {
  public:
   SerializationAddressMapper()
       : no_allocation_(),
@@ skipping 43 matching lines @@
 
 // There can be only one serializer per V8 process.
 class Serializer : public SerializerDeserializer {
  public:
   Serializer(Isolate* isolate, SnapshotByteSink* sink);
   ~Serializer();
   void VisitPointers(Object** start, Object** end);
   // You can call this after serialization to find out how much space was used
   // in each space.
   int CurrentAllocationAddress(int space) const {
-    DCHECK(space < kNumberOfSpaces);
+    if (space == LO_SPACE) return 0;
+    DCHECK(space < kNumberOfReservedSpaces);
     return fullness_[space];
   }
 
   Isolate* isolate() const { return isolate_; }
 
   SerializationAddressMapper* address_mapper() { return &address_mapper_; }
   void PutRoot(int index,
                HeapObject* object,
                HowToCode how,
                WhereToPoint where,
                int skip);
 
+  int large_objects_total_size() const { return large_objects_total_size_; }
+
  protected:
   static const int kInvalidRootIndex = -1;
 
   int RootIndex(HeapObject* heap_object, HowToCode from);
   intptr_t root_index_wave_front() { return root_index_wave_front_; }
   void set_root_index_wave_front(intptr_t value) {
     DCHECK(value >= root_index_wave_front_);
     root_index_wave_front_ = value;
   }
 
@@ skipping 50 matching lines @@
                                HowToCode how_to_code,
                                WhereToPoint where_to_point,
                                int skip) = 0;
   void SerializeReferenceToPreviousObject(HeapObject* heap_object,
                                           HowToCode how_to_code,
                                           WhereToPoint where_to_point,
                                           int skip);
   void InitializeAllocators();
   // This will return the space for an object.
   static int SpaceOfObject(HeapObject* object);
+  int AllocateLargeObject(int size);
   int Allocate(int space, int size);
   int EncodeExternalReference(Address addr) {
     return external_reference_encoder_->Encode(addr);
   }
 
   int SpaceAreaSize(int space);
 
   // Some roots should not be serialized, because their actual value depends on
   // absolute addresses and they are reset after deserialization, anyway.
   bool ShouldBeSkipped(Object** current);
 
   Isolate* isolate_;
   // Keep track of the fullness of each space in order to generate
   // relative addresses for back references.
-  int fullness_[LAST_SPACE + 1];
+  int fullness_[kNumberOfReservedSpaces];
   SnapshotByteSink* sink_;
   ExternalReferenceEncoder* external_reference_encoder_;
 
   SerializationAddressMapper address_mapper_;
   intptr_t root_index_wave_front_;
   void Pad();
 
   friend class ObjectSerializer;
   friend class Deserializer;
 
   // We may not need the code address map for logging for every instance
   // of the serializer.  Initialize it on demand.
   void InitializeCodeAddressMap();
 
  private:
   CodeAddressMap* code_address_map_;
+  int seen_large_objects_index_;

[mvstanton, 2014/09/22 14:32:14]

A comment on the meaning of seen_large_objects_index_ would be great.

+  int large_objects_total_size_;
   DISALLOW_COPY_AND_ASSIGN(Serializer);
 };
 
 
 class PartialSerializer : public Serializer {
  public:
   PartialSerializer(Isolate* isolate,
                     Serializer* startup_snapshot_serializer,
                     SnapshotByteSink* sink)
     : Serializer(isolate, sink),
@@ skipping 150 matching lines @@
     int payload_length = GetHeaderValue(kPayloadLengthOffset);
     DCHECK_EQ(script_data_->data() + script_data_->length(),
               Payload() + payload_length);
     return payload_length;
   }
 
   int GetReservation(int space) const {
     return GetHeaderValue(kReservationsOffset + space);
   }
 
+  int GetLargeObjectsTotalSize() const {
+    return GetHeaderValue(kLargeObjectsTotalSizeOffset);
+  }
+
  private:
   void SetHeaderValue(int offset, int value) {
     reinterpret_cast<int*>(const_cast<byte*>(script_data_->data()))[offset] =
         value;
   }
 
   int GetHeaderValue(int offset) const {
     return reinterpret_cast<const int*>(script_data_->data())[offset];
   }
 
   bool IsSane(String* source);
 
   int CheckSum(String* source);
 
   // The data header consists of int-sized entries:
   // [0] version hash
   // [1] number of code stub keys
   // [2] payload length
   // [3..9] reservation sizes for spaces from NEW_SPACE to PROPERTY_CELL_SPACE.
   static const int kCheckSumOffset = 0;
   static const int kNumCodeStubKeysOffset = 1;
   static const int kPayloadLengthOffset = 2;
-  static const int kReservationsOffset = 3;
+  static const int kLargeObjectsTotalSizeOffset = 3;
+  static const int kReservationsOffset = 4;
 
-  static const int kNumSpaces = PROPERTY_CELL_SPACE - NEW_SPACE + 1;
-  static const int kHeaderEntries = kReservationsOffset + kNumSpaces;
+  static const int kHeaderEntries =
+      kReservationsOffset + SerializerDeserializer::kNumberOfReservedSpaces;
   static const int kHeaderSize = kHeaderEntries * kIntSize;
 
   // Following the header, we store, in sequential order
   // - code stub keys
   // - serialization payload
 
   ScriptData* script_data_;
   bool owns_script_data_;
 };
 } }  // namespace v8::internal
 
 #endif  // V8_SERIALIZE_H_