[heap] ObjectStats: Account for headers when computing HashTable overhead

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/counters.h"
 #include "src/heap/heap-inl.h"
 #include "src/isolate.h"
 #include "src/macro-assembler.h"
@@ skipping 256 matching lines @@
     }
   }
 }
 
 template <class HashTable>
 void ObjectStatsCollector::RecordHashTableHelper(HeapObject* parent,
                                                  HashTable* array,
                                                  int subtype) {
   int used = array->NumberOfElements() * HashTable::kEntrySize;
   CHECK_GE(array->Size(), used);
-  size_t overhead = array->Size() - used;
+  size_t overhead = array->Size() - used -
+                    HashTable::kElementsStartIndex * kPointerSize -
+                    FixedArray::kHeaderSize;
   RecordFixedArrayHelper(parent, array, subtype, overhead);
 }
 
 void ObjectStatsCollector::RecordJSObjectDetails(JSObject* object) {
   size_t overhead = 0;
   FixedArrayBase* elements = object->elements();
   if (CanRecordFixedArray(heap_, elements) && !IsCowArray(heap_, elements)) {
     if (elements->IsDictionary() && SameLiveness(object, elements)) {
       SeededNumberDictionary* dict = SeededNumberDictionary::cast(elements);
       RecordHashTableHelper(object, dict, DICTIONARY_ELEMENTS_SUB_TYPE);
     } else {
       if (IsFastHoleyElementsKind(object->GetElementsKind())) {
         int used = object->GetFastElementsUsage() * kPointerSize;
         if (object->GetElementsKind() == FAST_HOLEY_DOUBLE_ELEMENTS) used *= 2;
         CHECK_GE(elements->Size(), used);
-        overhead = elements->Size() - used;
+        overhead = elements->Size() - used - FixedArray::kHeaderSize;
       }
       stats_->RecordFixedArraySubTypeStats(elements, FAST_ELEMENTS_SUB_TYPE,
                                            elements->Size(), overhead);
     }
   }
 
   overhead = 0;
   FixedArrayBase* properties = object->properties();
   if (CanRecordFixedArray(heap_, properties) &&
       SameLiveness(object, properties) && !IsCowArray(heap_, properties)) {
@@ skipping 11 matching lines @@
     JSWeakCollection* obj) {
   if (obj->table()->IsHashTable()) {
     ObjectHashTable* table = ObjectHashTable::cast(obj->table());
     int used = table->NumberOfElements() * ObjectHashTable::kEntrySize;
     size_t overhead = table->Size() - used;
     RecordFixedArrayHelper(obj, table, JS_WEAK_COLLECTION_SUB_TYPE, overhead);
   }
 }
 
 void ObjectStatsCollector::RecordJSCollectionDetails(JSObject* obj) {
+  // The JS versions use a different HashTable implementation that cannot use
+  // the regular helper. Since overall impact is usually small just record
+  // without overhead.
   if (obj->IsJSMap()) {
-    RecordHashTableHelper(nullptr,
-                          OrderedHashMap::cast(JSMap::cast(obj)->table()),
-                          JS_COLLECTION_SUB_TYPE);
+    RecordFixedArrayHelper(nullptr, FixedArray::cast(JSMap::cast(obj)->table()),
+                           JS_COLLECTION_SUB_TYPE, 0);
   }
   if (obj->IsJSSet()) {
-    RecordHashTableHelper(nullptr,
-                          OrderedHashSet::cast(JSSet::cast(obj)->table()),
-                          JS_COLLECTION_SUB_TYPE);
+    RecordFixedArrayHelper(nullptr, FixedArray::cast(JSSet::cast(obj)->table()),
+                           JS_COLLECTION_SUB_TYPE, 0);
   }
 }
 
 void ObjectStatsCollector::RecordScriptDetails(Script* obj) {
   Object* infos = WeakFixedArray::cast(obj->shared_function_infos());
   if (infos->IsWeakFixedArray())
     RecordFixedArrayHelper(obj, WeakFixedArray::cast(infos),
                            SHARED_FUNCTION_INFOS_SUB_TYPE, 0);
 }
 
@@ skipping 114 matching lines @@
   }
   if (array->IsNativeContext()) {
     Context* native_ctx = Context::cast(array);
     RecordHashTableHelper(array, native_ctx->template_instantiations_cache(),
                           TEMPLATE_INSTANTIATIONS_CACHE_SUB_TYPE);
   }
 }
 
 }  // namespace internal
 }  // namespace v8