[heap] ObjectStats: Various new categories

src/heap/object-stats.cc

 // 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.
 
 #include "src/heap/object-stats.h"
 
+#include "src/compilation-cache.h"
 #include "src/counters.h"
 #include "src/heap/heap-inl.h"
 #include "src/isolate.h"
 #include "src/macro-assembler.h"
 #include "src/utils.h"
 
 namespace v8 {
 namespace internal {
 
 static base::LazyMutex object_stats_mutex = LAZY_MUTEX_INITIALIZER;
@@ skipping 149 matching lines @@
 
 void ObjectStatsCollector::CollectStatistics(HeapObject* obj) {
   Map* map = obj->map();
 
   // Record for the InstanceType.
   int object_size = obj->Size();
   stats_->RecordObjectStats(map->instance_type(), object_size);
 
   // Record specific sub types where possible.
   if (obj->IsMap()) RecordMapDetails(Map::cast(obj));
+  if (obj->IsObjectTemplateInfo() || obj->IsFunctionTemplateInfo()) {
+    RecordTemplateInfoDetails(TemplateInfo::cast(obj));
+  }
   if (obj->IsBytecodeArray()) {
     RecordBytecodeArrayDetails(BytecodeArray::cast(obj));
   }
   if (obj->IsCode()) RecordCodeDetails(Code::cast(obj));
   if (obj->IsSharedFunctionInfo()) {
     RecordSharedFunctionInfoDetails(SharedFunctionInfo::cast(obj));
   }
   if (obj->IsFixedArray()) RecordFixedArrayDetails(FixedArray::cast(obj));
   if (obj->IsJSObject()) RecordJSObjectDetails(JSObject::cast(obj));
   if (obj->IsJSWeakCollection()) {
     RecordJSWeakCollectionDetails(JSWeakCollection::cast(obj));
   }
   if (obj->IsJSCollection()) {
     RecordJSCollectionDetails(JSObject::cast(obj));
   }
   if (obj->IsJSFunction()) RecordJSFunctionDetails(JSFunction::cast(obj));
   if (obj->IsScript()) RecordScriptDetails(Script::cast(obj));
 }
 
+class ObjectStatsCollector::CompilationCacheTableVisitor
+    : public ObjectVisitor {
+ public:
+  explicit CompilationCacheTableVisitor(ObjectStatsCollector* parent)
+      : parent_(parent) {}
+
+  void VisitPointers(Object** start, Object** end) override {
+    for (Object** current = start; current < end; current++) {
+      HeapObject* obj = HeapObject::cast(*current);
+      if (obj->IsUndefined(parent_->heap_->isolate())) continue;
+      CHECK(obj->IsCompilationCacheTable());
+      parent_->RecordHashTableHelper(nullptr, CompilationCacheTable::cast(obj),
+                                     COMPILATION_CACHE_TABLE_SUB_TYPE);
+    }
+  }
+
+ private:
+  ObjectStatsCollector* parent_;
+};
+
 void ObjectStatsCollector::CollectGlobalStatistics() {
   // Global FixedArrays.
   RecordFixedArrayHelper(nullptr, heap_->weak_new_space_object_to_code_list(),
                          WEAK_NEW_SPACE_OBJECT_TO_CODE_SUB_TYPE, 0);
   RecordFixedArrayHelper(nullptr, heap_->serialized_templates(),
                          SERIALIZED_TEMPLATES_SUB_TYPE, 0);
   RecordFixedArrayHelper(nullptr, heap_->number_string_cache(),
                          NUMBER_STRING_CACHE_SUB_TYPE, 0);
   RecordFixedArrayHelper(nullptr, heap_->single_character_string_cache(),
                          SINGLE_CHARACTER_STRING_CACHE_SUB_TYPE, 0);
@@ skipping 14 matching lines @@
   // Global hash tables.
   RecordHashTableHelper(nullptr, heap_->string_table(), STRING_TABLE_SUB_TYPE);
   RecordHashTableHelper(nullptr, heap_->weak_object_to_code_table(),
                         OBJECT_TO_CODE_SUB_TYPE);
   RecordHashTableHelper(nullptr, heap_->code_stubs(),
                         CODE_STUBS_TABLE_SUB_TYPE);
   RecordHashTableHelper(nullptr, heap_->intrinsic_function_names(),
                         INTRINSIC_FUNCTION_NAMES_SUB_TYPE);
   RecordHashTableHelper(nullptr, heap_->empty_properties_dictionary(),
                         EMPTY_PROPERTIES_DICTIONARY_SUB_TYPE);
+  CompilationCache* compilation_cache = heap_->isolate()->compilation_cache();
+  CompilationCacheTableVisitor v(this);
+  compilation_cache->Iterate(&v);
 }
 
 static bool CanRecordFixedArray(Heap* heap, FixedArrayBase* array) {
   return array->map()->instance_type() == FIXED_ARRAY_TYPE &&
          array->map() != heap->fixed_double_array_map() &&
          array != heap->empty_fixed_array() &&
          array != heap->empty_byte_array() &&
          array != heap->empty_literals_array() &&
          array != heap->empty_sloppy_arguments_elements() &&
          array != heap->empty_slow_element_dictionary() &&
@@ skipping 120 matching lines @@
       RecordFixedArrayHelper(array, array->GetEnumCache(), ENUM_CACHE_SUB_TYPE,
                              0);
     }
     if (array->HasEnumIndicesCache()) {
       RecordFixedArrayHelper(array, array->GetEnumIndicesCache(),
                              ENUM_INDICES_CACHE_SUB_TYPE, 0);
     }
   }
 
   if (map_obj->has_code_cache()) {
-    RecordFixedArrayHelper(map_obj, map_obj->code_cache(),
-                           MAP_CODE_CACHE_SUB_TYPE, 0);
+    FixedArray* code_cache = map_obj->code_cache();
+    if (code_cache->IsCodeCacheHashTable()) {
+      RecordHashTableHelper(map_obj, CodeCacheHashTable::cast(code_cache),
+                            MAP_CODE_CACHE_SUB_TYPE);
+    } else {
+      RecordFixedArrayHelper(map_obj, code_cache, MAP_CODE_CACHE_SUB_TYPE, 0);
+    }
   }
 
   for (DependentCode* cur_dependent_code = map_obj->dependent_code();
        cur_dependent_code != heap_->empty_fixed_array();
        cur_dependent_code = DependentCode::cast(
            cur_dependent_code->get(DependentCode::kNextLinkIndex))) {
     RecordFixedArrayHelper(map_obj, cur_dependent_code, DEPENDENT_CODE_SUB_TYPE,
                            0);
   }
 
   if (map_obj->is_prototype_map()) {
     if (map_obj->prototype_info()->IsPrototypeInfo()) {
       PrototypeInfo* info = PrototypeInfo::cast(map_obj->prototype_info());
       Object* users = info->prototype_users();
       if (users->IsWeakFixedArray()) {
         RecordFixedArrayHelper(map_obj, WeakFixedArray::cast(users),
                                PROTOTYPE_USERS_SUB_TYPE, 0);
       }
     }
   }
 }
 
+void ObjectStatsCollector::RecordTemplateInfoDetails(TemplateInfo* obj) {
+  if (obj->property_accessors()->IsFixedArray()) {
+    RecordFixedArrayHelper(obj, FixedArray::cast(obj->property_accessors()),
+                           TEMPLATE_INFO_SUB_TYPE, 0);
+  }
+  if (obj->property_list()->IsFixedArray()) {
+    RecordFixedArrayHelper(obj, FixedArray::cast(obj->property_list()),
+                           TEMPLATE_INFO_SUB_TYPE, 0);
+  }
+}
+
 void ObjectStatsCollector::RecordBytecodeArrayDetails(BytecodeArray* obj) {
   RecordFixedArrayHelper(obj, obj->constant_pool(),
                          BYTECODE_ARRAY_CONSTANT_POOL_SUB_TYPE, 0);
   RecordFixedArrayHelper(obj, obj->handler_table(),
                          BYTECODE_ARRAY_HANDLER_TABLE_SUB_TYPE, 0);
 }
 
 void ObjectStatsCollector::RecordCodeDetails(Code* code) {
   stats_->RecordCodeSubTypeStats(code->kind(), code->GetAge(), code->Size());
   RecordFixedArrayHelper(code, code->deoptimization_data(),
                          DEOPTIMIZATION_DATA_SUB_TYPE, 0);
+  if (code->kind() == Code::Kind::OPTIMIZED_FUNCTION) {
+    DeoptimizationInputData* input_data =
+        DeoptimizationInputData::cast(code->deoptimization_data());
+    RecordFixedArrayHelper(code->deoptimization_data(),
+                           input_data->LiteralArray(),
+                           OPTIMIZED_CODE_LITERALS_SUB_TYPE, 0);
+  }
   RecordFixedArrayHelper(code, code->handler_table(), HANDLER_TABLE_SUB_TYPE,
                          0);
   int const mode_mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT);
   for (RelocIterator it(code, mode_mask); !it.done(); it.next()) {
     RelocInfo::Mode mode = it.rinfo()->rmode();
     if (mode == RelocInfo::EMBEDDED_OBJECT) {
       Object* target = it.rinfo()->target_object();
       if (target->IsFixedArray()) {
         RecursivelyRecordFixedArrayHelper(code, FixedArray::cast(target),
                                           EMBEDDED_OBJECT_SUB_TYPE);
@@ skipping 69 matching lines @@
                           SLOW_TEMPLATE_INSTANTIATIONS_CACHE_SUB_TYPE);
     FixedArray* fast_cache = native_ctx->fast_template_instantiations_cache();
     stats_->RecordFixedArraySubTypeStats(
         fast_cache, FAST_TEMPLATE_INSTANTIATIONS_CACHE_SUB_TYPE,
         fast_cache->Size(), 0);
   }
 }
 
 }  // namespace internal
 }  // namespace v8