[heap] ObjectStats: Cleanup and more FIXED_ARRAY sub types

src/heap/object-stats.h

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HEAP_OBJECT_STATS_H_
 #define V8_HEAP_OBJECT_STATS_H_
 
 #include <set>
 
 #include "src/base/ieee754.h"
@@ skipping 42 matching lines @@
            code_age_index < OBJECT_STATS_COUNT);
     object_counts_[code_sub_type_index]++;
     object_sizes_[code_sub_type_index] += size;
     object_counts_[code_age_index]++;
     object_sizes_[code_age_index] += size;
     const int idx = HistogramIndexFromSize(size);
     size_histogram_[code_sub_type_index][idx]++;
     size_histogram_[code_age_index][idx]++;
   }
 
-  void RecordFixedArraySubTypeStats(FixedArrayBase* array, int array_sub_type,
+  bool RecordFixedArraySubTypeStats(FixedArrayBase* array, int array_sub_type,
                                     size_t size, size_t over_allocated) {
     auto it = visited_fixed_array_sub_types_.insert(array);
-    if (!it.second) return;
+    if (!it.second) return false;
     DCHECK(array_sub_type <= LAST_FIXED_ARRAY_SUB_TYPE);
     object_counts_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type]++;
     object_sizes_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type] += size;
     size_histogram_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type]
                    [HistogramIndexFromSize(size)]++;
-    over_allocated_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type] +=
-        over_allocated;
-    over_allocated_histogram_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type]
-                             [HistogramIndexFromSize(over_allocated)]++;
+    if (over_allocated > 0) {
+      over_allocated_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type] +=
+          over_allocated;
+      over_allocated_histogram_[FIRST_FIXED_ARRAY_SUB_TYPE + array_sub_type]
+                               [HistogramIndexFromSize(over_allocated)]++;
+    }
+    return true;
   }
 
   size_t object_count_last_gc(size_t index) {
     return object_counts_last_time_[index];
   }
 
   size_t object_size_last_gc(size_t index) {
     return object_sizes_last_time_[index];
   }
 
@@ skipping 24 matching lines @@
   size_t over_allocated_[OBJECT_STATS_COUNT];
   // Detailed histograms by InstanceType.
   size_t size_histogram_[OBJECT_STATS_COUNT][kNumberOfBuckets];
   size_t over_allocated_histogram_[OBJECT_STATS_COUNT][kNumberOfBuckets];
 
   std::set<FixedArrayBase*> visited_fixed_array_sub_types_;
 };
 
 class ObjectStatsCollector {
  public:
-  static void CollectStatistics(ObjectStats* stats, HeapObject* obj);
+  ObjectStatsCollector(Heap* heap, ObjectStats* stats)
+      : heap_(heap), stats_(stats) {}
+
+  void CollectGlobalStatistics();
+  void CollectStatistics(HeapObject* obj);
 
  private:
-  static void RecordMapDetails(ObjectStats* stats, Heap* heap, HeapObject* obj);
-  static void RecordCodeDetails(ObjectStats* stats, Heap* heap,
-                                HeapObject* obj);
-  static void RecordSharedFunctionInfoDetails(ObjectStats* stats, Heap* heap,
-                                              HeapObject* obj);
-  static void RecordFixedArrayDetails(ObjectStats* stats, Heap* heap,
-                                      HeapObject* obj);
+  void RecordCodeDetails(Code* code);
+  void RecordFixedArrayDetails(FixedArray* array);
+  void RecordJSCollectionDetails(JSObject* obj);
+  void RecordJSFunctionDetails(JSFunction* function);
+  void RecordJSObjectDetails(JSObject* object);
+  void RecordJSWeakCollectionDetails(JSWeakCollection* obj);
+  void RecordMapDetails(Map* map);
+  void RecordScriptDetails(Script* obj);
+  void RecordSharedFunctionInfoDetails(SharedFunctionInfo* sfi);
 
-  static void RecordJSObjectDetails(ObjectStats* stats, Heap* heap,
-                                    JSObject* object);
-  static void RecordJSWeakCollectionDetails(ObjectStats* stats, Heap* heap,
-                                            JSWeakCollection* obj);
-  static void RecordScriptDetails(ObjectStats* stats, Heap* heap, Script* obj);
-
-  static void RecordFixedArrayHelper(ObjectStats* stats, Heap* heap,
-                                     HeapObject* parent, FixedArray* array,
-                                     int subtype, size_t overhead);
+  bool RecordFixedArrayHelper(HeapObject* parent, FixedArray* array,
+                              int subtype, size_t overhead);
+  void RecursivelyRecordFixedArrayHelper(HeapObject* parent, FixedArray* array,
+                                         int subtype);
+  template <class HashTable>
+  void RecordHashTableHelper(HeapObject* parent, HashTable* array, int subtype);
+  Heap* heap_;
+  ObjectStats* stats_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_HEAP_OBJECT_STATS_H_