Updates incremental marking pass to collect object statistics.

Object statistics were collected during the mark compact phase. If
an incremental marking happened before mark compact phase then most
of the objects are already visited and hence this phase does not collect
accurate statistics. This cl updates incremental marking pass to collect
object statistics along with mark compact phase.

BUG=

Review-Url: https://codereview.chromium.org/1943423002
Cr-Commit-Position: refs/heads/master@{#36678}

src/heap/heap.h

@@ -2254,7 +2254,7 @@ class Heap {
   friend class MarkCompactCollector;
   friend class MarkCompactMarkingVisitor;
   friend class NewSpace;
-  friend class ObjectStatsVisitor;
+  friend class ObjectStatsCollector;
   friend class Page;
   friend class Scavenger;
   friend class StoreBuffer;

src/heap/incremental-marking.cc

@@ -10,8 +10,9 @@
 #include "src/heap/gc-idle-time-handler.h"
 #include "src/heap/gc-tracer.h"
 #include "src/heap/mark-compact-inl.h"
-#include "src/heap/objects-visiting.h"
+#include "src/heap/object-stats.h"
 #include "src/heap/objects-visiting-inl.h"
+#include "src/heap/objects-visiting.h"
 #include "src/tracing/trace-event.h"
 #include "src/v8.h"
 
@@ -175,6 +176,9 @@ class IncrementalMarkingMarkingVisitor
     table_.Register(kVisitFixedArray, &VisitFixedArrayIncremental);
     table_.Register(kVisitNativeContext, &VisitNativeContextIncremental);
     table_.Register(kVisitJSRegExp, &VisitJSRegExp);
+    if (FLAG_track_gc_object_stats) {
+      IncrementalMarkingObjectStatsVisitor::Initialize(&table_);
+    }
   }
 
   static const int kProgressBarScanningChunk = 32 * 1024;

src/heap/mark-compact.cc

@@ -1299,7 +1299,7 @@ void MarkCompactMarkingVisitor::Initialize() {
   table_.Register(kVisitJSRegExp, &VisitRegExpAndFlushCode);
 
   if (FLAG_track_gc_object_stats) {
-    ObjectStatsVisitor::Initialize(&table_);
+    MarkCompactObjectStatsVisitor::Initialize(&table_);
   }
 }
 
@@ -2280,6 +2280,10 @@ void MarkCompactCollector::MarkLiveObjects() {
     } else {
       // Abort any pending incremental activities e.g. incremental sweeping.
       incremental_marking->Stop();
+      if (FLAG_track_gc_object_stats) {
+        // Clear object stats collected during incremental marking.
+        heap()->object_stats_->ClearObjectStats();
+      }
       if (marking_deque_.in_use()) {
         marking_deque_.Uninitialize(true);
       }

src/heap/object-stats.cc

@@ -134,8 +134,7 @@ void ObjectStats::CheckpointObjectStats() {
 
 Isolate* ObjectStats::isolate() { return heap()->isolate(); }
 
-
-void ObjectStatsVisitor::CountFixedArray(
+void ObjectStatsCollector::CountFixedArray(
     FixedArrayBase* fixed_array, FixedArraySubInstanceType fast_type,
     FixedArraySubInstanceType dictionary_type) {
   Heap* heap = fixed_array->map()->GetHeap();
@@ -152,12 +151,32 @@ void ObjectStatsVisitor::CountFixedArray(
   }
 }
 
+void ObjectStatsCollector::CollectStatistics(StaticVisitorBase::VisitorId id,
+                                             Map* map, HeapObject* obj) {
+  // Record any type specific statistics here.
+  switch (id) {
+    case StaticVisitorBase::kVisitMap:
+      RecordMapStats(map, obj);
+      break;
+    case StaticVisitorBase::kVisitCode:
+      RecordCodeStats(map, obj);
+      break;
+    case StaticVisitorBase::kVisitSharedFunctionInfo:
+      RecordSharedFunctionInfoStats(map, obj);
+      break;
+    case StaticVisitorBase::kVisitFixedArray:
+      RecordFixedArrayStats(map, obj);
+      break;
+    default:
+      break;
+  }
 
-void ObjectStatsVisitor::VisitBase(VisitorId id, Map* map, HeapObject* obj) {
   Heap* heap = map->GetHeap();
   int object_size = obj->Size();
   heap->object_stats_->RecordObjectStats(map->instance_type(), object_size);
-  table_.GetVisitorById(id)(map, obj);
+}
+
+void ObjectStatsCollector::CollectFixedArrayStatistics(HeapObject* obj) {
   if (obj->IsJSObject()) {
     JSObject* object = JSObject::cast(obj);
     CountFixedArray(object->elements(), DICTIONARY_ELEMENTS_SUB_TYPE,
@@ -167,16 +186,7 @@ void ObjectStatsVisitor::VisitBase(VisitorId id, Map* map, HeapObject* obj) {
   }
 }
 
-
-template <ObjectStatsVisitor::VisitorId id>
-void ObjectStatsVisitor::Visit(Map* map, HeapObject* obj) {
-  VisitBase(id, map, obj);
-}
-
-
-template <>
-void ObjectStatsVisitor::Visit<ObjectStatsVisitor::kVisitMap>(Map* map,
-                                                              HeapObject* obj) {
+void ObjectStatsCollector::RecordMapStats(Map* map, HeapObject* obj) {
   Heap* heap = map->GetHeap();
   Map* map_obj = Map::cast(obj);
   DCHECK(map->instance_type() == MAP_TYPE);
@@ -191,50 +201,55 @@ void ObjectStatsVisitor::Visit<ObjectStatsVisitor::kVisitMap>(Map* map,
     heap->object_stats_->RecordFixedArraySubTypeStats(MAP_CODE_CACHE_SUB_TYPE,
                                                       cache->Size());
   }
-  VisitBase(kVisitMap, map, obj);
 }
 
-
-template <>
-void ObjectStatsVisitor::Visit<ObjectStatsVisitor::kVisitCode>(
-    Map* map, HeapObject* obj) {
+void ObjectStatsCollector::RecordCodeStats(Map* map, HeapObject* obj) {
   Heap* heap = map->GetHeap();
   int object_size = obj->Size();
   DCHECK(map->instance_type() == CODE_TYPE);
   Code* code_obj = Code::cast(obj);
   heap->object_stats_->RecordCodeSubTypeStats(code_obj->kind(),
                                               code_obj->GetAge(), object_size);
-  VisitBase(kVisitCode, map, obj);
 }
 
-
-template <>
-void ObjectStatsVisitor::Visit<ObjectStatsVisitor::kVisitSharedFunctionInfo>(
-    Map* map, HeapObject* obj) {
+void ObjectStatsCollector::RecordSharedFunctionInfoStats(Map* map,
+                                                         HeapObject* obj) {
   Heap* heap = map->GetHeap();
   SharedFunctionInfo* sfi = SharedFunctionInfo::cast(obj);
   if (sfi->scope_info() != heap->empty_fixed_array()) {
     heap->object_stats_->RecordFixedArraySubTypeStats(
         SCOPE_INFO_SUB_TYPE, FixedArray::cast(sfi->scope_info())->Size());
   }
-  VisitBase(kVisitSharedFunctionInfo, map, obj);
 }
 
-
-template <>
-void ObjectStatsVisitor::Visit<ObjectStatsVisitor::kVisitFixedArray>(
-    Map* map, HeapObject* obj) {
+void ObjectStatsCollector::RecordFixedArrayStats(Map* map, HeapObject* obj) {
   Heap* heap = map->GetHeap();
   FixedArray* fixed_array = FixedArray::cast(obj);
   if (fixed_array == heap->string_table()) {
     heap->object_stats_->RecordFixedArraySubTypeStats(STRING_TABLE_SUB_TYPE,
                                                       fixed_array->Size());
   }
-  VisitBase(kVisitFixedArray, map, obj);
 }
 
+void MarkCompactObjectStatsVisitor::Initialize(
+    VisitorDispatchTable<Callback>* original) {
+  // Copy the original visitor table to make call-through possible. After we
+  // preserved a copy locally, we patch the original table to call us.
+  table_.CopyFrom(original);
+#define COUNT_FUNCTION(id) original->Register(kVisit##id, Visit<kVisit##id>);
+  VISITOR_ID_LIST(COUNT_FUNCTION)
+#undef COUNT_FUNCTION
+}
 
-void ObjectStatsVisitor::Initialize(VisitorDispatchTable<Callback>* original) {
+template <MarkCompactObjectStatsVisitor::VisitorId id>
+void MarkCompactObjectStatsVisitor::Visit(Map* map, HeapObject* obj) {
+  ObjectStatsCollector::CollectStatistics(id, map, obj);
+  table_.GetVisitorById(id)(map, obj);
+  ObjectStatsCollector::CollectFixedArrayStatistics(obj);
+}
+
+void IncrementalMarkingObjectStatsVisitor::Initialize(
+    VisitorDispatchTable<Callback>* original) {
   // Copy the original visitor table to make call-through possible. After we
   // preserved a copy locally, we patch the original table to call us.
   table_.CopyFrom(original);
@@ -243,5 +258,12 @@ void ObjectStatsVisitor::Initialize(VisitorDispatchTable<Callback>* original) {
 #undef COUNT_FUNCTION
 }
 
+template <IncrementalMarkingObjectStatsVisitor::VisitorId id>
+void IncrementalMarkingObjectStatsVisitor::Visit(Map* map, HeapObject* obj) {
+  ObjectStatsCollector::CollectStatistics(id, map, obj);
+  table_.GetVisitorById(id)(map, obj);
+  ObjectStatsCollector::CollectFixedArrayStatistics(obj);
+}
+
 }  // namespace internal
 }  // namespace v8

src/heap/object-stats.h

@@ -81,16 +81,34 @@ class ObjectStats {
   size_t object_sizes_last_time_[OBJECT_STATS_COUNT];
 };
 
-
-class ObjectStatsVisitor : public StaticMarkingVisitor<ObjectStatsVisitor> {
+class ObjectStatsCollector {
  public:
-  static void Initialize(VisitorDispatchTable<Callback>* original);
-
-  static void VisitBase(VisitorId id, Map* map, HeapObject* obj);
+  static void CollectStatistics(StaticVisitorBase::VisitorId id, Map* map,
+                                HeapObject* obj);
+  static void CollectFixedArrayStatistics(HeapObject* obj);
 
   static void CountFixedArray(FixedArrayBase* fixed_array,
                               FixedArraySubInstanceType fast_type,
                               FixedArraySubInstanceType dictionary_type);
+  static void RecordMapStats(Map* map, HeapObject* obj);
+  static void RecordCodeStats(Map* map, HeapObject* obj);
+  static void RecordSharedFunctionInfoStats(Map* map, HeapObject* obj);
+  static void RecordFixedArrayStats(Map* map, HeapObject* obj);
+};
+
+class MarkCompactObjectStatsVisitor
+    : public StaticMarkingVisitor<MarkCompactObjectStatsVisitor> {
+ public:
+  static void Initialize(VisitorDispatchTable<Callback>* original);
+
+  template <VisitorId id>
+  static inline void Visit(Map* map, HeapObject* obj);
+};
+
+class IncrementalMarkingObjectStatsVisitor
+    : public StaticMarkingVisitor<IncrementalMarkingObjectStatsVisitor> {
+ public:
+  static void Initialize(VisitorDispatchTable<Callback>* original);
 
   template <VisitorId id>
   static inline void Visit(Map* map, HeapObject* obj);