Send allocation stats with each class and show in class view.

runtime/vm/class_table.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/class_table.h"
 #include "vm/flags.h"
 #include "vm/freelist.h"
 #include "vm/heap.h"
 #include "vm/object.h"
 #include "vm/raw_object.h"
@@ skipping 222 matching lines @@
   // Remember how much was allocated so we can subtract this from the result
   // when printing.
   last_reset.new_count = recent.new_count;
   last_reset.new_size = recent.new_size;
   last_reset.old_count = recent.old_count;
   last_reset.old_size = recent.old_size;
   accumulated.Reset();
 }
 
 
-void ClassHeapStats::PrintTOJSONArray(const Class& cls, JSONArray* array) {
-  JSONObject obj(array);
-  obj.AddProperty("type", "ClassHeapStats");
-  obj.AddPropertyF("id", "allocationprofile/%" Pd "", cls.id());
-  obj.AddProperty("class", cls);
+void ClassHeapStats::PrintToJSONObject(const Class& cls,
+                                       JSONObject* obj) const {
+  obj->AddProperty("type", "ClassHeapStats");
+  obj->AddPropertyF("id", "allocationprofile/%" Pd "", cls.id());
+  obj->AddProperty("class", cls);
   {
-    JSONArray new_stats(&obj, "new");
+    JSONArray new_stats(obj, "new");
     new_stats.AddValue(pre_gc.new_count);
     new_stats.AddValue(pre_gc.new_size);
     new_stats.AddValue(post_gc.new_count);
     new_stats.AddValue(post_gc.new_size);
     new_stats.AddValue(recent.new_count);
     new_stats.AddValue(recent.new_size);
     new_stats.AddValue64(accumulated.new_count + recent.new_count -
                          last_reset.new_count);
     new_stats.AddValue64(accumulated.new_size + recent.new_size -
                          last_reset.new_size);
   }
   {
-    JSONArray old_stats(&obj, "old");
+    JSONArray old_stats(obj, "old");
     old_stats.AddValue(pre_gc.old_count);
     old_stats.AddValue(pre_gc.old_size);
     old_stats.AddValue(post_gc.old_count);
     old_stats.AddValue(post_gc.old_size);
     old_stats.AddValue(recent.old_count);
     old_stats.AddValue(recent.old_size);
     old_stats.AddValue64(accumulated.old_count + recent.old_count -
                          last_reset.old_count);
     old_stats.AddValue64(accumulated.old_size + recent.old_size -
                          last_reset.old_size);
   }
 }
 
 
 void ClassTable::UpdateAllocatedNew(intptr_t cid, intptr_t size) {
-  ClassHeapStats* stats = StatsAt(cid);
+  ClassHeapStats* stats = PreliminaryStatsAt(cid);
   ASSERT(stats != NULL);
   ASSERT(size != 0);
   stats->recent.AddNew(size);
 }
 
 
 void ClassTable::UpdateAllocatedOld(intptr_t cid, intptr_t size) {
-  ClassHeapStats* stats = StatsAt(cid);
+  ClassHeapStats* stats = PreliminaryStatsAt(cid);
   ASSERT(stats != NULL);
   ASSERT(size != 0);
   stats->recent.AddOld(size);
 }
 
 
 bool ClassTable::ShouldUpdateSizeForClassId(intptr_t cid) {
   return !RawObject::IsVariableSizeClassId(cid);
 }
 
 
-ClassHeapStats* ClassTable::StatsAt(intptr_t cid) {
+ClassHeapStats* ClassTable::PreliminaryStatsAt(intptr_t cid) {
   ASSERT(cid > 0);
   if (cid < kNumPredefinedCids) {
     return &predefined_class_heap_stats_table_[cid];
   }
   ASSERT(cid < top_);
   return &class_heap_stats_table_[cid];
 }
 
 
+ClassHeapStats* ClassTable::StatsWithUpdatedSize(intptr_t cid) {
+  if (!HasValidClassAt(cid) || (cid == kFreeListElement) || (cid == kSmiCid)) {
+    return NULL;
+  }
+  Class& cls = Class::Handle(At(cid));
+  if (!(cls.is_finalized() || cls.is_prefinalized())) {
+    // Not finalized.
+    return NULL;
+  }
+  ClassHeapStats* stats = PreliminaryStatsAt(cid);
+  if (ShouldUpdateSizeForClassId(cid)) {
+    stats->UpdateSize(cls.instance_size());
+  }
+  return stats;
+}
+
+
 void ClassTable::ResetCountersOld() {
   for (intptr_t i = 0; i < kNumPredefinedCids; i++) {
     predefined_class_heap_stats_table_[i].ResetAtOldGC();
   }
   for (intptr_t i = kNumPredefinedCids; i < top_; i++) {
     class_heap_stats_table_[i].ResetAtOldGC();
   }
 }
 
 
@@ skipping 27 matching lines @@
   {
     JSONObject heaps(&obj, "heaps");
     {
       heap->PrintToJSONObject(Heap::kNew, &heaps);
     }
     {
       heap->PrintToJSONObject(Heap::kOld, &heaps);
     }
   }
   {
+    JSONArray arr(&obj, "members");
     Class& cls = Class::Handle();
-    JSONArray arr(&obj, "members");
-    for (intptr_t i = 1; i < kNumPredefinedCids; i++) {
-      if (!HasValidClassAt(i) || (i == kFreeListElement) || (i == kSmiCid)) {
-        continue;
+    for (intptr_t i = 1; i < top_; i++) {
+      const ClassHeapStats* stats = StatsWithUpdatedSize(i);
+      if (stats != NULL) {
+        JSONObject obj(&arr);
+        cls = At(i);
+        stats->PrintToJSONObject(cls, &obj);
       }
-      cls = At(i);
-      if (!(cls.is_finalized() || cls.is_prefinalized())) {
-        // Not finalized.
-        continue;
-      }
-      if (ShouldUpdateSizeForClassId(i)) {
-        intptr_t instance_size = cls.instance_size();
-        predefined_class_heap_stats_table_[i].UpdateSize(instance_size);
-      }
-      predefined_class_heap_stats_table_[i].PrintTOJSONArray(cls, &arr);
-    }
-    for (intptr_t i = kNumPredefinedCids; i < top_; i++) {
-      if (!HasValidClassAt(i)) {
-        continue;
-      }
-      cls = At(i);
-      if (!(cls.is_finalized() || cls.is_prefinalized())) {
-        // Not finalized.
-        continue;
-      }
-      if (ShouldUpdateSizeForClassId(i)) {
-        intptr_t instance_size = cls.instance_size();
-        class_heap_stats_table_[i].UpdateSize(instance_size);
-      }
-      class_heap_stats_table_[i].PrintTOJSONArray(cls, &arr);
     }
   }
 }
 
 
 void ClassTable::ResetAllocationAccumulators() {
-  Class& cls = Class::Handle();
-  for (intptr_t i = 1; i < kNumPredefinedCids; i++) {
-    if (!HasValidClassAt(i) || (i == kFreeListElement) || (i == kSmiCid)) {
-      continue;
+  for (intptr_t i = 1; i < top_; i++) {
+    ClassHeapStats* stats = StatsWithUpdatedSize(i);
+    if (stats != NULL) {
+      stats->ResetAccumulator();
     }
-    cls = At(i);
-    if (!(cls.is_finalized() || cls.is_prefinalized())) {
-      // Not finalized.
-      continue;
-    }
-    // Update size before resetting accumulator.
-    if (ShouldUpdateSizeForClassId(i)) {
-      intptr_t instance_size = cls.instance_size();
-      predefined_class_heap_stats_table_[i].UpdateSize(instance_size);
-    }
-    predefined_class_heap_stats_table_[i].ResetAccumulator();
-  }
-  for (intptr_t i = kNumPredefinedCids; i < top_; i++) {
-    if (!HasValidClassAt(i)) {
-      continue;
-    }
-    cls = At(i);
-    if (!(cls.is_finalized() || cls.is_prefinalized())) {
-      // Not finalized.
-      continue;
-    }
-    // Update size before resetting accumulator.
-    if (ShouldUpdateSizeForClassId(i)) {
-      intptr_t instance_size = cls.instance_size();
-      class_heap_stats_table_[i].UpdateSize(instance_size);
-    }
-    class_heap_stats_table_[i].ResetAccumulator();
   }
 }
 
 
 void ClassTable::UpdateLiveOld(intptr_t cid, intptr_t size) {
-  ClassHeapStats* stats = StatsAt(cid);
+  ClassHeapStats* stats = PreliminaryStatsAt(cid);
   ASSERT(stats != NULL);
   ASSERT(size >= 0);
   stats->post_gc.AddOld(size);
 }
 
 
 void ClassTable::UpdateLiveNew(intptr_t cid, intptr_t size) {
-  ClassHeapStats* stats = StatsAt(cid);
+  ClassHeapStats* stats = PreliminaryStatsAt(cid);
   ASSERT(stats != NULL);
   ASSERT(size >= 0);
   stats->post_gc.AddNew(size);
 }
 
 
 }  // namespace dart