- Dump Smi objects into the heap profile.

runtime/vm/heap_profiler.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/heap_profiler.h"
 
 #include "vm/dart_api_state.h"
 #include "vm/object.h"
 #include "vm/raw_object.h"
 #include "vm/stack_frame.h"
@@ skipping 106 matching lines @@
     : write_callback_(callback),
       output_stream_(stream),
       heap_dump_record_(NULL) {
   WriteHeader();
   WriteStackTrace();
   heap_dump_record_ = new Record(kHeapDump, this);
 }
 
 
 HeapProfiler::~HeapProfiler() {
+  for (std::set<const RawSmi*>::iterator it = smi_table_.begin();

[cshapiro, 2013/01/12 02:52:26]

You might consider using this idiom...

  for_each(smi_table_.begin(), 
           smi_table_.end(),
           bind1st(mem_fun(&HeapProfiler::WriteSmiDump), this)

+       it != smi_table_.end();
+       ++it) {
+    WriteSmiDump(*it);
+  }
   delete heap_dump_record_;
 }
 
 
 const RawObject* HeapProfiler::ObjectId(const RawObject* raw_obj) {
   if (!raw_obj->IsHeapObject()) {
     // To describe an immediate object in HPROF we record its value
     // and write fake INSTANCE_DUMP subrecord in the HEAP_DUMP record.
     const RawSmi* raw_smi = reinterpret_cast<const RawSmi*>(raw_obj);
     if (smi_table_.find(raw_smi) == smi_table_.end()) {
@@ skipping 422 matching lines @@
         ASSERT(raw_field->ptr()->name_ != String::null());
         // field name string ID
         sub.WriteObjectId(StringId(raw_field->ptr()->name_));
         // type of field
         sub.Write8(kObject);
       }
     }
   }
 }
 
+// INSTANCE DUMP - 0x21

[cshapiro, 2013/01/12 02:52:26]

We probably do not need to repeat this documentation.

My preference would be to rename this method "WriteSmiInstanceDump" and move it
just below the WriteInstanceDump method.  This is the pattern I followed for the
"Fake" methods I just added (WriteFakeInstanceDump, etc.).

[Ivan Posva, 2013/01/14 23:38:42]

Done.

+//
+// Format:
+//  ID - object ID
+//  u4 - stack trace serial number
+//  ID - class object ID
+//  u4 - number of bytes that follow
+//  [value]* - instance field values (this class, followed by super class, etc)
+void HeapProfiler::WriteSmiDump(const RawSmi* raw_smi) {
+  ASSERT(!raw_smi->IsHeapObject());
+  SubRecord sub(kInstanceDump, this);
+  // object ID
+  sub.WriteObjectId(raw_smi);

[siva, 2013/01/14 23:50:13]

Since we are writing out smi values as an object id can this potentially collide
with other object ids that we emit out (e.g a class id)

[Ivan Posva, 2013/01/14 23:53:38]

IDs from the heap profiler dump perspective are the tagged addresses, so we
never get into the VM internal Cid and Smi conflict.

[cshapiro, 2013/01/14 23:55:22]

It should not.  We use an object's address as its it, tag included.  I use some
magic small odd values (small enough that they would fit on page 0) to designate
non-existent classes to keep this convention consistent even when real heap
addresses are unused.

+  // stack trace serial number
+  sub.Write32(0);
+  // class object ID
+  sub.WriteObjectId(Isolate::Current()->class_table()->At(kSmiCid));
+  // number of bytes that follow
+  sub.Write32(0);
+}
+
 
 // INSTANCE DUMP - 0x21
 //
 // Format:
 //  ID - object ID
 //  u4 - stack trace serial number
 //  ID - class object ID
 //  u4 - number of bytes that follow
 //  [value]* - instance field values (this class, followed by super class, etc)
 void HeapProfiler::WriteInstanceDump(const RawObject* raw_obj) {
+  ASSERT(raw_obj->IsHeapObject());
   SubRecord sub(kInstanceDump, this);
   // object ID
   sub.WriteObjectId(raw_obj);
   // stack trace serial number
   sub.Write32(0);
   // class object ID
   sub.WriteObjectId(ClassId(GetClass(raw_obj)));
   // number of bytes that follow
   intptr_t num_instance_fields = 0;
   for (const RawClass* cls = GetClass(raw_obj);
@@ skipping 130 matching lines @@
   RawObject* raw_obj = handle->raw();
   visitor_->VisitPointer(&raw_obj);
 }
 
 
 void HeapProfilerObjectVisitor::VisitObject(RawObject* raw_obj) {
   profiler_->WriteObject(raw_obj);
 }
 
 }  // namespace dart