5% smaller snapshots by omitting object ids when possible

runtime/vm/snapshot.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
@@ skipping 29 matching lines @@
           class_id == kNullCid);
 }
 
 
 static bool IsObjectStoreTypeId(intptr_t index) {
   // Check if this is a type which is stored in the object store.
   return (index >= kObjectType && index <= kArrayType);
 }
 
 
+static bool IsSplitClassId(intptr_t class_id) {
+  // Return whether this class is serialized in two steps: first a reference,
+  // with sufficient information to allocate a correctly sized object, and then
+  // later inline with complete contents.
+  return class_id >= kNumPredefinedCids ||
+         class_id == kArrayCid ||
+         class_id == kImmutableArrayCid ||
+         RawObject::IsTypedDataViewClassId(class_id);
+}
+
+
 static intptr_t ClassIdFromObjectId(intptr_t object_id) {
   ASSERT(object_id > kClassIdsOffset);
   intptr_t class_id = (object_id - kClassIdsOffset);
   return class_id;
 }
 
 
 static intptr_t ObjectIdFromClassId(intptr_t class_id) {
   ASSERT((class_id > kIllegalCid) && (class_id < kNumPredefinedCids));
   ASSERT(!RawObject::IsTypedDataViewClassId(class_id));
@@ skipping 154 matching lines @@
 
 RawObject* SnapshotReader::ReadObjectImpl() {
   int64_t value = Read<int64_t>();
   if ((value & kSmiTagMask) == kSmiTag) {
     return NewInteger(value);
   }
   return ReadObjectImpl(value);
 }
 
 
+intptr_t SnapshotReader::NextAvailableObjectId() const {
+  return backward_references_.length() + kMaxPredefinedObjectIds;
+}
+
+
 RawObject* SnapshotReader::ReadObjectImpl(intptr_t header_value) {
   ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
   if (IsVMIsolateObject(header_value)) {
     return ReadVMIsolateObject(header_value);
   } else {
     if (SerializedHeaderTag::decode(header_value) == kObjectId) {
       return ReadIndexedObject(SerializedHeaderData::decode(header_value));
     }
     ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
-    return ReadInlinedObject(SerializedHeaderData::decode(header_value));
+    intptr_t object_id = SerializedHeaderData::decode(header_value);
+    if (object_id == kOmittedObjectId) {
+      object_id = NextAvailableObjectId();
+    }
+    return ReadInlinedObject(object_id);
   }
 }
 
 
 RawObject* SnapshotReader::ReadObjectRef() {
   int64_t header_value = Read<int64_t>();
   if ((header_value & kSmiTagMask) == kSmiTag) {
     return NewInteger(header_value);
   }
   ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
   if (IsVMIsolateObject(header_value)) {
     return ReadVMIsolateObject(header_value);
   } else if (SerializedHeaderTag::decode(header_value) == kObjectId) {
     return ReadIndexedObject(SerializedHeaderData::decode(header_value));
   }
   ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
   intptr_t object_id = SerializedHeaderData::decode(header_value);
+  if (object_id == kOmittedObjectId) {
+    object_id = NextAvailableObjectId();
+  }
   ASSERT(GetBackRef(object_id) == NULL);
 
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
 
   // Since we are only reading an object reference, If it is an instance kind
   // then we only need to figure out the class of the object and allocate an
   // instance of it. The individual fields will be read later.
   if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     Instance& result = Instance::ZoneHandle(isolate(), Instance::null());
@@ skipping 779 matching lines @@
   ASSERT(class_id == raw->GetClassId());
   if (class_id >= kNumPredefinedCids) {
     WriteInstanceRef(raw, cls);
     return;
   }
   if (class_id == kArrayCid) {
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
-    intptr_t object_id = forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
+    forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
 
     RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
 
     // Write out the serialization header value for this object.
-    WriteInlinedObjectHeader(object_id);
+    WriteInlinedObjectHeader(kOmittedObjectId);
 
     // Write out the class information.
     WriteIndexedObject(kArrayCid);
 
     // Write out the length field.
     Write<RawObject*>(rawarray->ptr()->length_);
 
     return;
   }
   if (class_id == kImmutableArrayCid) {
     // Object is being referenced, add it to the forward ref list and mark
     // it so that future references to this object in the snapshot will use
     // this object id. Mark it as not having been serialized yet so that we
     // will serialize the object when we go through the forward list.
-    intptr_t object_id = forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
+    forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
 
     RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
 
     // Write out the serialization header value for this object.
-    WriteInlinedObjectHeader(object_id);
+    WriteInlinedObjectHeader(kOmittedObjectId);
 
     // Write out the class information.
     WriteIndexedObject(kImmutableArrayCid);
 
     // Write out the length field.
     Write<RawObject*>(rawarray->ptr()->length_);
 
     return;
   }
   if (RawObject::IsTypedDataViewClassId(class_id)) {
     WriteInstanceRef(raw, cls);
     return;
   }
   // Object is being referenced, add it to the forward ref list and mark
   // it so that future references to this object in the snapshot will use
   // this object id. Mark it as not having been serialized yet so that we
   // will serialize the object when we go through the forward list.
-  intptr_t object_id = forward_list_.MarkAndAddObject(raw, kIsSerialized);
+  forward_list_.MarkAndAddObject(raw, kIsSerialized);
   switch (class_id) {
 #define SNAPSHOT_WRITE(clazz)                                                  \
     case clazz::kClassId: {                                                    \
       Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(raw);                \
-      raw_obj->WriteTo(this, object_id, kind_);                                \
+      raw_obj->WriteTo(this, kOmittedObjectId, kind_);                         \
       return;                                                                  \
     }                                                                          \
 
     CLASS_LIST_NO_OBJECT(SNAPSHOT_WRITE)
 #undef SNAPSHOT_WRITE
 #define SNAPSHOT_WRITE(clazz)                                                  \
     case kTypedData##clazz##Cid:                                               \
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_WRITE) {
       RawTypedData* raw_obj = reinterpret_cast<RawTypedData*>(raw);
-      raw_obj->WriteTo(this, object_id, kind_);
+      raw_obj->WriteTo(this, kOmittedObjectId, kind_);
       return;
     }
 #undef SNAPSHOT_WRITE
 #define SNAPSHOT_WRITE(clazz)                                                  \
     case kExternalTypedData##clazz##Cid:                                       \
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_WRITE) {
       RawExternalTypedData* raw_obj =
         reinterpret_cast<RawExternalTypedData*>(raw);
-      raw_obj->WriteTo(this, object_id, kind_);
+      raw_obj->WriteTo(this, kOmittedObjectId, kind_);
       return;
     }
 #undef SNAPSHOT_WRITE
     default: break;
   }
   UNREACHABLE();
 }
 
 
 void FullSnapshotWriter::WriteFullSnapshot() {
@@ skipping 181 matching lines @@
   //    serialized fields of the object
   //    ......
   NoGCScope no_gc;
   uword tags = raw->ptr()->tags_;
   ASSERT(SerializedHeaderTag::decode(tags) == kObjectId);
   intptr_t object_id = SerializedHeaderData::decode(tags);
   tags = forward_list_.NodeForObjectId(object_id)->tags();
   RawClass* cls = class_table_->At(RawObject::ClassIdTag::decode(tags));
   intptr_t class_id = cls->ptr()->id_;
 
+  if (!IsSplitClassId(class_id)) {
+    object_id = kOmittedObjectId;
+  }
+
   if (class_id >= kNumPredefinedCids) {
     WriteInstance(object_id, raw, cls, tags);
     return;
   }
   switch (class_id) {
 #define SNAPSHOT_WRITE(clazz)                                                  \
     case clazz::kClassId: {                                                    \
       Raw##clazz* raw_obj = reinterpret_cast<Raw##clazz*>(raw);                \
       raw_obj->WriteTo(this, object_id, kind_);                                \
       return;                                                                  \
@@ skipping 192 matching lines @@
 
 
 void SnapshotWriter::WriteInstanceRef(RawObject* raw, RawClass* cls) {
   // First check if object is a closure or has native fields.
   CheckIfSerializable(cls);
 
   // Object is being referenced, add it to the forward ref list and mark
   // it so that future references to this object in the snapshot will use
   // this object id. Mark it as not having been serialized yet so that we
   // will serialize the object when we go through the forward list.
-  intptr_t object_id = forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
+  forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
 
   // Write out the serialization header value for this object.
-  WriteInlinedObjectHeader(object_id);
+  WriteInlinedObjectHeader(kOmittedObjectId);
 
   // Indicate this is an instance object.
   WriteIntptrValue(SerializedHeaderData::encode(kInstanceObjectId));
 
   // Write out the class information for this object.
   WriteObjectImpl(cls);
 }
 
 
 void SnapshotWriter::ThrowException(Exceptions::ExceptionType type,
@@ skipping 58 matching lines @@
     NoGCScope no_gc;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart