vmservice: basic object graph serialization.

runtime/vm/object_graph.cc

 // Copyright (c) 2014, 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/object_graph.h"
 
 #include "vm/dart.h"
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
 #include "vm/raw_object.h"
+#include "vm/reusable_handles.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 // The state of a pre-order, depth-first traversal of an object graph.
 // When a node is visited, *all* its children are pushed to the stack at once.
 // We insert a sentinel between the node and its children on the stack, to
 // remember that the node has been visited. The node is kept on the stack while
 // its children are processed, to give the visitor a complete chain of parents.
 //
@@ skipping 341 matching lines @@
 
 
 intptr_t ObjectGraph::InboundReferences(Object* obj, const Array& references) {
   Object& scratch = Object::Handle();
   NoGCScope no_gc_scope_;
   InboundReferencesVisitor visitor(isolate(), obj->raw(), references, &scratch);
   isolate()->heap()->IterateObjects(&visitor);
   return visitor.length();
 }
 
+
+void WritePtr(RawObject* raw, WriteStream* stream) {
+  ASSERT(raw->IsHeapObject());
+  ASSERT(raw->IsOldObject());
+  uword addr = RawObject::ToAddr(raw);
+  ASSERT(Utils::IsAligned(addr, kObjectAlignment));
+  // TODO(koda): Use delta-encoding/back-references to compress this.
+  stream->WriteUnsigned(addr / kObjectAlignment);
+}
+
+
+class WritePointerVisitor : public ObjectPointerVisitor {
+ public:
+  WritePointerVisitor(Isolate* isolate, WriteStream* stream)
+      : ObjectPointerVisitor(isolate), stream_(stream), count_(0) {}
+  virtual void VisitPointers(RawObject** first, RawObject** last) {
+    for (RawObject** current = first; current <= last; ++current) {
+      if (!(*current)->IsHeapObject() || (*current == Object::null())) {
+        // Ignore smis and nulls for now.
+        // TODO(koda): To track which field each pointer corresponds to,
+        // we'll need to encode which fields were omitted here.

[Cutch, 2014/12/02 16:46:26]

Just curious: Why not send tagged pointers over the wire and include a sentinel
null object?

[koda, 2014/12/02 18:47:12]

1. For now, we mainly care about the graph shape and retained sizes. In the
future, we will probably have sentinels for all VM-heap objects (possibly
reusing some code from snapshot system).

2. Dividing by kObjectAlignment allows the ids to fit into Smis on the
Observatory side. Added a comment on this.

+        continue;
+      }
+      WritePtr(*current, stream_);
+      ++count_;
+    }
+  }
+
+  intptr_t count() const { return count_; }
+
+ private:
+  WriteStream* stream_;
+  intptr_t count_;
+};
+
+
+void WriteHeader(RawObject* raw, intptr_t size, intptr_t cid,
+                 WriteStream* stream) {
+  WritePtr(raw, stream);
+  ASSERT(Utils::IsAligned(size, kObjectAlignment));
+  stream->WriteUnsigned(size);
+  stream->WriteUnsigned(cid);
+}
+
+
+class WriteGraphVisitor : public ObjectGraph::Visitor {
+ public:
+  WriteGraphVisitor(Isolate* isolate, WriteStream* stream)
+    : stream_(stream), ptr_writer_(isolate, stream), count_(0) {}
+
+  virtual Direction VisitObject(ObjectGraph::StackIterator* it) {
+    RawObject* raw_obj = it->Get();
+    Isolate* isolate = Isolate::Current();
+    REUSABLE_OBJECT_HANDLESCOPE(isolate);
+    Object& obj = isolate->ObjectHandle();
+    obj = raw_obj;
+    // Each object is a header + a zero-terminated list of its neighbors.
+    WriteHeader(raw_obj, raw_obj->Size(), obj.GetClassId(), stream_);
+    raw_obj->VisitPointers(&ptr_writer_);
+    stream_->WriteUnsigned(0);
+    ++count_;
+    return kProceed;
+  }
+
+  intptr_t count() const { return count_; }
+
+ private:
+  WriteStream* stream_;
+  WritePointerVisitor ptr_writer_;
+  intptr_t count_;
+};
+
+
+void ObjectGraph::Serialize(WriteStream* stream) {
+  // Current encoding assumes objects do not move, so promote everything to old.
+  isolate()->heap()->new_space()->Evacuate();
+  WriteGraphVisitor visitor(isolate(), stream);
+  stream->WriteUnsigned(0);
+  stream->WriteUnsigned(0);
+  stream->WriteUnsigned(0);
+  {
+    WritePointerVisitor ptr_writer(isolate(), stream);
+    isolate()->VisitObjectPointers(&ptr_writer, false, false);
+  }
+  stream->WriteUnsigned(0);
+  IterateObjects(&visitor);
+  OS::PrintErr("%" Pd "\n", visitor.count());

[Cutch, 2014/12/02 16:46:26]

Remove before submitting

[koda, 2014/12/02 18:47:12]

Done.

+}
+
 }  // namespace dart