Simplify object stats tracker a bit.

src/mark-compact.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 926 matching lines @@
   return HeapObject::cast(first);
 }
 
 
 class StaticMarkingVisitor : public StaticVisitorBase {
  public:
   static inline void IterateBody(Map* map, HeapObject* obj) {
     table_.GetVisitor(map)(map, obj);
   }
 
-  static void ObjectStatsVisitBase(StaticVisitorBase::VisitorId id,
-                                   Map* map, HeapObject* obj);
-
-  static void ObjectStatsCountFixedArray(
-      FixedArrayBase* fixed_array,
-      FixedArraySubInstanceType fast_type,
-      FixedArraySubInstanceType dictionary_type);
-
-  template<StaticMarkingVisitor::VisitorId id>
-  class ObjectStatsTracker {
-   public:
-    static inline void Visit(Map* map, HeapObject* obj);
-  };
-
   static void Initialize();
 
   INLINE(static void VisitPointer(Heap* heap, Object** p)) {
     MarkObjectByPointer(heap->mark_compact_collector(), p, p);
   }
 
   INLINE(static void VisitPointers(Heap* heap, Object** start, Object** end)) {
     // Mark all objects pointed to in [start, end).
     const int kMinRangeForMarkingRecursion = 64;
     if (end - start >= kMinRangeForMarkingRecursion) {
@@ skipping 118 matching lines @@
   };
 
   typedef FlexibleBodyVisitor<StaticMarkingVisitor,
                               JSObject::BodyDescriptor,
                               void> JSObjectVisitor;
 
   typedef FlexibleBodyVisitor<StaticMarkingVisitor,
                               StructBodyDescriptor,
                               void> StructObjectVisitor;
 
+  template<StaticVisitorBase::VisitorId id>
+  static inline void TrackObjectStatsAndVisit(Map* map, HeapObject* obj);
+
+  static inline void TrackObjectStatsAndVisitBase(
+      StaticVisitorBase::VisitorId id, Map* map, HeapObject* obj);
+
   static void VisitJSWeakMap(Map* map, HeapObject* object) {
     MarkCompactCollector* collector = map->GetHeap()->mark_compact_collector();
     JSWeakMap* weak_map = reinterpret_cast<JSWeakMap*>(object);
 
     // Enqueue weak map in linked list of encountered weak maps.
     if (weak_map->next() == Smi::FromInt(0)) {
       weak_map->set_next(collector->encountered_weak_maps());
       collector->set_encountered_weak_maps(weak_map);
     }
 
@@ skipping 391 matching lines @@
 
   #undef SLOT_ADDR
 
   typedef void (*Callback)(Map* map, HeapObject* object);
 
   static VisitorDispatchTable<Callback> table_;
   static VisitorDispatchTable<Callback> non_count_table_;
 };
 
 
-void StaticMarkingVisitor::ObjectStatsCountFixedArray(
+static void ObjectStatsCountFixedArray(
     FixedArrayBase* fixed_array,
     FixedArraySubInstanceType fast_type,
     FixedArraySubInstanceType dictionary_type) {
   Heap* heap = fixed_array->map()->GetHeap();
   if (fixed_array->map() != heap->fixed_cow_array_map() &&
       fixed_array->map() != heap->fixed_double_array_map() &&
       fixed_array != heap->empty_fixed_array()) {
     if (fixed_array->IsDictionary()) {
       heap->RecordObjectStats(FIXED_ARRAY_TYPE,
                               dictionary_type,
                               fixed_array->Size());
     } else {
       heap->RecordObjectStats(FIXED_ARRAY_TYPE,
                               fast_type,
                               fixed_array->Size());
     }
   }
 }
 
 
-void StaticMarkingVisitor::ObjectStatsVisitBase(
+void StaticMarkingVisitor::TrackObjectStatsAndVisitBase(
     StaticVisitorBase::VisitorId id, Map* map, HeapObject* obj) {
   Heap* heap = map->GetHeap();
   int object_size = obj->Size();
   heap->RecordObjectStats(map->instance_type(), -1, object_size);
   non_count_table_.GetVisitorById(id)(map, obj);
   if (obj->IsJSObject()) {
     JSObject* object = JSObject::cast(obj);
     ObjectStatsCountFixedArray(object->elements(),
                                DICTIONARY_ELEMENTS_SUB_TYPE,
                                FAST_ELEMENTS_SUB_TYPE);
     ObjectStatsCountFixedArray(object->properties(),
                                DICTIONARY_PROPERTIES_SUB_TYPE,
                                FAST_PROPERTIES_SUB_TYPE);
   }
 }
 
 
-template<StaticMarkingVisitor::VisitorId id>
-void StaticMarkingVisitor::ObjectStatsTracker<id>::Visit(
-    Map* map, HeapObject* obj) {
-  ObjectStatsVisitBase(id, map, obj);
+template<StaticVisitorBase::VisitorId id>
+void StaticMarkingVisitor::TrackObjectStatsAndVisit(Map* map, HeapObject* obj) {
+  TrackObjectStatsAndVisitBase(id, map, obj);
 }
 
 
 template<>
-class StaticMarkingVisitor::ObjectStatsTracker<
-  StaticMarkingVisitor::kVisitMap> {
- public:
-  static inline void Visit(Map* map, HeapObject* obj) {
-    Heap* heap = map->GetHeap();
-    Map* map_obj = Map::cast(obj);
-    ASSERT(map->instance_type() == MAP_TYPE);
-    DescriptorArray* array = map_obj->instance_descriptors();
-    if (array != heap->empty_descriptor_array()) {
-      int fixed_array_size = array->Size();
-      heap->RecordObjectStats(FIXED_ARRAY_TYPE,
-                              DESCRIPTOR_ARRAY_SUB_TYPE,
-                              fixed_array_size);
-    }
-    if (map_obj->HasTransitionArray()) {
-      int fixed_array_size = map_obj->transitions()->Size();
-      heap->RecordObjectStats(FIXED_ARRAY_TYPE,
-                              TRANSITION_ARRAY_SUB_TYPE,
-                              fixed_array_size);
-    }
-    if (map_obj->code_cache() != heap->empty_fixed_array()) {
-      heap->RecordObjectStats(
-          FIXED_ARRAY_TYPE,
-          MAP_CODE_CACHE_SUB_TYPE,
-          FixedArray::cast(map_obj->code_cache())->Size());
-    }
-    ObjectStatsVisitBase(kVisitMap, map, obj);
+void StaticMarkingVisitor::TrackObjectStatsAndVisit<
+    StaticMarkingVisitor::kVisitMap>(Map* map, HeapObject* obj) {
+  Heap* heap = map->GetHeap();
+  Map* map_obj = Map::cast(obj);
+  ASSERT(map->instance_type() == MAP_TYPE);
+  DescriptorArray* array = map_obj->instance_descriptors();
+  if (array != heap->empty_descriptor_array()) {
+    int fixed_array_size = array->Size();
+    heap->RecordObjectStats(FIXED_ARRAY_TYPE,
+                            DESCRIPTOR_ARRAY_SUB_TYPE,
+                            fixed_array_size);
   }
-};
+  if (map_obj->HasTransitionArray()) {
+    int fixed_array_size = map_obj->transitions()->Size();
+    heap->RecordObjectStats(FIXED_ARRAY_TYPE,
+                            TRANSITION_ARRAY_SUB_TYPE,
+                            fixed_array_size);
+  }
+  if (map_obj->code_cache() != heap->empty_fixed_array()) {
+    heap->RecordObjectStats(
+        FIXED_ARRAY_TYPE,
+        MAP_CODE_CACHE_SUB_TYPE,
+        FixedArray::cast(map_obj->code_cache())->Size());
+  }
+  TrackObjectStatsAndVisitBase(kVisitMap, map, obj);
+}
 
 
 template<>
-class StaticMarkingVisitor::ObjectStatsTracker<
-  StaticMarkingVisitor::kVisitCode> {
- public:
-  static inline void Visit(Map* map, HeapObject* obj) {
-    Heap* heap = map->GetHeap();
-    int object_size = obj->Size();
-    ASSERT(map->instance_type() == CODE_TYPE);
-    heap->RecordObjectStats(CODE_TYPE, Code::cast(obj)->kind(), object_size);
-    ObjectStatsVisitBase(kVisitCode, map, obj);
-  }
-};
+void StaticMarkingVisitor::TrackObjectStatsAndVisit<
+    StaticMarkingVisitor::kVisitCode>(Map* map, HeapObject* obj) {
+  Heap* heap = map->GetHeap();
+  int object_size = obj->Size();
+  ASSERT(map->instance_type() == CODE_TYPE);
+  heap->RecordObjectStats(CODE_TYPE, Code::cast(obj)->kind(), object_size);
+  TrackObjectStatsAndVisitBase(kVisitCode, map, obj);
+}
 
 
 template<>
-class StaticMarkingVisitor::ObjectStatsTracker<
-  StaticMarkingVisitor::kVisitSharedFunctionInfo> {
- public:
-  static inline void Visit(Map* map, HeapObject* obj) {
-    Heap* heap = map->GetHeap();
-    SharedFunctionInfo* sfi = SharedFunctionInfo::cast(obj);
-    if (sfi->scope_info() != heap->empty_fixed_array()) {
-      heap->RecordObjectStats(
-          FIXED_ARRAY_TYPE,
-          SCOPE_INFO_SUB_TYPE,
-          FixedArray::cast(sfi->scope_info())->Size());
-    }
-    ObjectStatsVisitBase(kVisitSharedFunctionInfo, map, obj);
+void StaticMarkingVisitor::TrackObjectStatsAndVisit<
+    StaticMarkingVisitor::kVisitSharedFunctionInfo>(Map* map, HeapObject* obj) {
+  Heap* heap = map->GetHeap();
+  SharedFunctionInfo* sfi = SharedFunctionInfo::cast(obj);
+  if (sfi->scope_info() != heap->empty_fixed_array()) {
+    heap->RecordObjectStats(
+        FIXED_ARRAY_TYPE,
+        SCOPE_INFO_SUB_TYPE,
+        FixedArray::cast(sfi->scope_info())->Size());
   }
-};
+  TrackObjectStatsAndVisitBase(kVisitSharedFunctionInfo, map, obj);
+}
 
 
 template<>
-class StaticMarkingVisitor::ObjectStatsTracker<
-  StaticMarkingVisitor::kVisitFixedArray> {
- public:
-  static inline void Visit(Map* map, HeapObject* obj) {
-    Heap* heap = map->GetHeap();
-    FixedArray* fixed_array = FixedArray::cast(obj);
-    if (fixed_array == heap->symbol_table()) {
-      heap->RecordObjectStats(
-          FIXED_ARRAY_TYPE,
-          SYMBOL_TABLE_SUB_TYPE,
-          fixed_array->Size());
-    }
-    ObjectStatsVisitBase(kVisitFixedArray, map, obj);
+void StaticMarkingVisitor::TrackObjectStatsAndVisit<
+    StaticMarkingVisitor::kVisitFixedArray>(Map* map, HeapObject* obj) {
+  Heap* heap = map->GetHeap();
+  FixedArray* fixed_array = FixedArray::cast(obj);
+  if (fixed_array == heap->symbol_table()) {
+    heap->RecordObjectStats(
+        FIXED_ARRAY_TYPE,
+        SYMBOL_TABLE_SUB_TYPE,
+        fixed_array->Size());
   }
-};
+  TrackObjectStatsAndVisitBase(kVisitFixedArray, map, obj);
+}
 
 
 void StaticMarkingVisitor::Initialize() {
   table_.Register(kVisitShortcutCandidate,
                   &FixedBodyVisitor<StaticMarkingVisitor,
                   ConsString::BodyDescriptor,
                   void>::Visit);
 
   table_.Register(kVisitConsString,
                   &FixedBodyVisitor<StaticMarkingVisitor,
@@ skipping 55 matching lines @@
       kVisitJSObjectGeneric>();
 
   table_.RegisterSpecializations<StructObjectVisitor,
       kVisitStruct,
       kVisitStructGeneric>();
 
   if (FLAG_track_gc_object_stats) {
     // Copy the visitor table to make call-through possible.
     non_count_table_.CopyFrom(&table_);
 #define VISITOR_ID_COUNT_FUNCTION(id)                                   \
-    table_.Register(kVisit##id, ObjectStatsTracker<kVisit##id>::Visit);
+    table_.Register(kVisit##id, TrackObjectStatsAndVisit<kVisit##id>);
     VISITOR_ID_LIST(VISITOR_ID_COUNT_FUNCTION)
 #undef VISITOR_ID_COUNT_FUNCTION
   }
 }
 
 
 VisitorDispatchTable<StaticMarkingVisitor::Callback>
   StaticMarkingVisitor::table_;
 VisitorDispatchTable<StaticMarkingVisitor::Callback>
   StaticMarkingVisitor::non_count_table_;
@@ skipping 2557 matching lines @@
   while (buffer != NULL) {
     SlotsBuffer* next_buffer = buffer->next();
     DeallocateBuffer(buffer);
     buffer = next_buffer;
   }
   *buffer_address = NULL;
 }
 
 
 } }  // namespace v8::internal