Refactor snapshot writer's forward list into a reusable class.

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 924 matching lines @@
 
 
 SnapshotWriter::SnapshotWriter(Snapshot::Kind kind,
                                uint8_t** buffer,
                                ReAlloc alloc,
                                intptr_t initial_size)
     : BaseWriter(buffer, alloc, initial_size),
       kind_(kind),
       object_store_(Isolate::Current()->object_store()),
       class_table_(Isolate::Current()->class_table()),
-      forward_list_(),
+      forward_list_(kMaxPredefinedObjectIds),
       exception_type_(Exceptions::kNone),
       exception_msg_(NULL) {
 }
 
 
 void SnapshotWriter::WriteObject(RawObject* rawobj) {
   WriteObjectImpl(rawobj);
   WriteForwardedObjects();
 }
 
@@ skipping 84 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 = MarkObject(raw, kIsNotSerialized);
+    intptr_t object_id = forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
 
     RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
 
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(object_id);
 
     // 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 = MarkObject(raw, kIsNotSerialized);
+    intptr_t object_id = forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
 
     RawArray* rawarray = reinterpret_cast<RawArray*>(raw);
 
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(object_id);
 
     // 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 = MarkObject(raw, kIsSerialized);
+  intptr_t object_id = 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_);                                \
       return;                                                                  \
     }                                                                          \
 
     CLASS_LIST_NO_OBJECT(SNAPSHOT_WRITE)
 #undef SNAPSHOT_WRITE
@@ skipping 57 matching lines @@
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 uword SnapshotWriter::GetObjectTags(RawObject* raw) {
   uword tags = raw->ptr()->tags_;
   if (SerializedHeaderTag::decode(tags) == kObjectId) {
     intptr_t id = SerializedHeaderData::decode(tags);
-    return forward_list_[id - kMaxPredefinedObjectIds]->tags();
+    return forward_list_.NodeForObjectId(id)->tags();
   } else {
     return tags;
   }
 }
 
 
-intptr_t SnapshotWriter::MarkObject(RawObject* raw, SerializeState state) {
+intptr_t ForwardList::MarkAndAddObject(RawObject* raw, SerializeState state) {
   NoGCScope no_gc;
-  intptr_t object_id = forward_list_.length() + kMaxPredefinedObjectIds;
+  intptr_t object_id = next_object_id();
   ASSERT(object_id <= kMaxObjectId);
   uword value = 0;
   value = SerializedHeaderTag::update(kObjectId, value);
   value = SerializedHeaderData::update(object_id, value);
   uword tags = raw->ptr()->tags_;
   ASSERT(SerializedHeaderTag::decode(tags) != kObjectId);
   raw->ptr()->tags_ = value;
-  ForwardObjectNode* node = new ForwardObjectNode(raw, tags, state);
+  Node* node = new Node(raw, tags, state);
   ASSERT(node != NULL);
-  forward_list_.Add(node);
+  nodes_.Add(node);
   return object_id;
 }
 
 
-void SnapshotWriter::UnmarkAll() {
+void ForwardList::UnmarkAll() const {
   NoGCScope no_gc;
-  for (intptr_t i = 0; i < forward_list_.length(); i++) {
-    RawObject* raw = forward_list_[i]->raw();
-    raw->ptr()->tags_ = forward_list_[i]->tags();  // Restore original tags.
+  for (intptr_t id = first_object_id(); id < next_object_id(); ++id) {
+    const Node* node = NodeForObjectId(id);
+    RawObject* raw = node->raw();
+    raw->ptr()->tags_ = node->tags();  // Restore original tags.
   }
 }
 
 
 bool SnapshotWriter::CheckAndWritePredefinedObject(RawObject* rawobj) {
   // Check if object can be written in one of the following ways:
   // - Smi: the Smi value is written as is (last bit is not tagged).
   // - VM internal class (from VM isolate): (index of class in vm isolate | 0x3)
   // - Object that has already been written: (negative id in stream | 0x3)
 
@@ skipping 80 matching lines @@
 
 void SnapshotWriter::WriteObjectImpl(RawObject* raw) {
   // First check if object can be written as a simple predefined type.
   if (CheckAndWritePredefinedObject(raw)) {
     return;
   }
 
   // Object is being serialized, add it to the forward ref list and mark
   // it so that future references to this object in the snapshot will use
   // an object id, instead of trying to serialize it again.
-  MarkObject(raw, kIsSerialized);
+  forward_list_.MarkAndAddObject(raw, kIsSerialized);
 
   WriteInlinedObject(raw);
 }
 
 
 void SnapshotWriter::WriteInlinedObject(RawObject* raw) {
   // Now write the object out inline in the stream as follows:
   // - Object is seen for the first time (inlined as follows):
   //    (object size in multiples of kObjectAlignment | 0x1)
   //    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_[object_id - kMaxPredefinedObjectIds]->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 (class_id >= kNumPredefinedCids) {
     WriteInstance(object_id, raw, cls, tags);
     return;
   }
   switch (class_id) {
 #define SNAPSHOT_WRITE(clazz)                                                  \
     case clazz::kClassId: {                                                    \
@@ skipping 31 matching lines @@
       WriteInstance(object_id, raw, cls, tags);
       return;
     }
 #undef SNAPSHOT_WRITE
     default: break;
   }
   UNREACHABLE();
 }
 
 
+class WriteInlinedObjectVisitor : public ObjectVisitor {
+ public:
+  explicit WriteInlinedObjectVisitor(SnapshotWriter* writer)
+      : ObjectVisitor(Isolate::Current()), writer_(writer) {}
+
+  virtual void VisitObject(RawObject* obj) {
+    writer_->WriteInlinedObject(obj);
+  }
+
+ private:
+  SnapshotWriter* writer_;
+};
+
+
 void SnapshotWriter::WriteForwardedObjects() {
+  WriteInlinedObjectVisitor visitor(this);
+  forward_list_.SerializeAll(&visitor);
+}
+
+
+void ForwardList::SerializeAll(ObjectVisitor* writer) {
   // Write out all objects that were added to the forward list and have
   // not been serialized yet. These would typically be fields of instance
   // objects, arrays or immutable arrays (this is done in order to avoid
   // deep recursive calls to WriteObjectImpl).
   // NOTE: The forward list might grow as we process the list.
-  for (intptr_t i = 0; i < forward_list_.length(); i++) {
-    if (!forward_list_[i]->is_serialized()) {
+#ifdef DEBUG
+  for (intptr_t i = first_object_id(); i < first_unprocessed_object_id_; ++i) {
+    ASSERT(NodeForObjectId(i)->is_serialized());
+  }
+#endif  // DEBUG
+  for (intptr_t id = first_unprocessed_object_id_;
+       id < next_object_id();
+       ++id) {
+    if (!NodeForObjectId(id)->is_serialized()) {
       // Write the object out in the stream.
-      RawObject* raw = forward_list_[i]->raw();
-      WriteInlinedObject(raw);
+      RawObject* raw = NodeForObjectId(id)->raw();
+      writer->VisitObject(raw);
 
       // Mark object as serialized.
-      forward_list_[i]->set_state(kIsSerialized);
+      NodeForObjectId(id)->set_state(kIsSerialized);
     }
   }
+  first_unprocessed_object_id_ = next_object_id();
 }
 
 
 void SnapshotWriter::WriteClassId(RawClass* cls) {
   ASSERT(kind_ != Snapshot::kFull);
   int class_id = cls->ptr()->id_;
   ASSERT(!IsSingletonClassId(class_id) && !IsObjectStoreClassId(class_id));
   // TODO(5411462): Should restrict this to only core-lib classes in this
   // case.
   // Write out the class and tags information.
@@ skipping 100 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 = MarkObject(raw, kIsNotSerialized);
+  intptr_t object_id = forward_list_.MarkAndAddObject(raw, kIsNotSerialized);
 
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(object_id);
 
   // Indicate this is an instance object.
   WriteIntptrValue(SerializedHeaderData::encode(kInstanceObjectId));
 
   // Write out the class information for this object.
   WriteObjectImpl(cls);
 }
@@ skipping 61 matching lines @@
     NoGCScope no_gc;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart