[tracing] Adding class-wise memory statistics to blink gc memory dumps

Source/platform/heap/Heap.h

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 77 matching lines @@
 #else
 #define FILL_ZERO_IF_PRODUCTION(address, size) memset((address), 0, (size))
 #define FILL_ZERO_IF_NOT_PRODUCTION(address, size) do { } while (false)
 #endif
 
 class CallbackStack;
 class FreePagePool;
 class NormalPageHeap;
 class OrphanedPagePool;
 class PageMemory;
+class WebProcessMemoryDump;
 
 #if ENABLE(GC_PROFILING)
 class TracedValue;
 #endif
 
 // HeapObjectHeader is 4 byte (32 bit) that has the following layout:
 //
 // | gcInfoIndex (14 bit) | DOM mark bit (1 bit) | size (14 bit) | dead bit (1 bit) | freed bit (1 bit) | mark bit (1 bit) |
 //
 // - For non-large objects, 14 bit is enough for |size| because the blink
@@ skipping 286 matching lines @@
     // Check if the given address points to an object in this
     // heap page. If so, find the start of that object and mark it
     // using the given Visitor. Otherwise do nothing. The pointer must
     // be within the same aligned blinkPageSize as the this-pointer.
     //
     // This is used during conservative stack scanning to
     // conservatively mark all objects that could be referenced from
     // the stack.
     virtual void checkAndMarkPointer(Visitor*, Address) = 0;
     virtual void markOrphaned();
+
+    virtual void takeSnapshot(String dumpName, size_t pageIndex, ThreadState::GCSnapshotInfo&) = 0;
 #if ENABLE(GC_PROFILING)
     virtual const GCInfo* findGCInfo(Address) = 0;
     virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*) = 0;
     virtual void incrementMarkedObjectsAge() = 0;
     virtual void countMarkedObjects(ClassAgeCountsMap&) = 0;
     virtual void countObjectsToSweep(ClassAgeCountsMap&) = 0;
 #endif
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
     virtual bool contains(Address) = 0;
 #endif
@@ skipping 60 matching lines @@
     virtual bool isEmpty() override;
     virtual void removeFromHeap() override;
     virtual void sweep() override;
     virtual void makeConsistentForGC() override;
     virtual void makeConsistentForMutator() override;
 #if defined(ADDRESS_SANITIZER)
     virtual void poisonObjects(ObjectsToPoison, Poisoning) override;
 #endif
     virtual void checkAndMarkPointer(Visitor*, Address) override;
     virtual void markOrphaned() override;
+
+    void takeSnapshot(String dumpBaseName, size_t pageIndex, ThreadState::GCSnapshotInfo&) override;
 #if ENABLE(GC_PROFILING)
     const GCInfo* findGCInfo(Address) override;
     void snapshot(TracedValue*, ThreadState::SnapshotInfo*) override;
     void incrementMarkedObjectsAge() override;
     void countMarkedObjects(ClassAgeCountsMap&) override;
     void countObjectsToSweep(ClassAgeCountsMap&) override;
 #endif
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
     // Returns true for the whole blinkPageSize page that the page is on, even
     // for the header, and the unmapped guard page at the start. That ensures
@@ skipping 44 matching lines @@
     virtual void removeFromHeap() override;
     virtual void sweep() override;
     virtual void makeConsistentForGC() override;
     virtual void makeConsistentForMutator() override;
 #if defined(ADDRESS_SANITIZER)
     virtual void poisonObjects(ObjectsToPoison, Poisoning) override;
 #endif
     virtual void checkAndMarkPointer(Visitor*, Address) override;
     virtual void markOrphaned() override;
 
+    void takeSnapshot(String dumpBaseName, size_t pageIndex, ThreadState::GCSnapshotInfo&) override;
 #if ENABLE(GC_PROFILING)
     const GCInfo* findGCInfo(Address) override;
     void snapshot(TracedValue*, ThreadState::SnapshotInfo*) override;
     void incrementMarkedObjectsAge() override;
     void countMarkedObjects(ClassAgeCountsMap&) override;
     void countObjectsToSweep(ClassAgeCountsMap&) override;
 #endif
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
     // Returns true for any address that is on one of the pages that this
     // large object uses. That ensures that we can use a negative result to
@@ skipping 85 matching lines @@
 public:
     FreeList();
 
     void addToFreeList(Address, size_t);
     void clear();
 
     // Returns a bucket number for inserting a FreeListEntry of a given size.
     // All FreeListEntries in the given bucket, n, have size >= 2^n.
     static int bucketIndexForSize(size_t);
 
+    void takeSnapshot(const String& dumpBaseName);
 #if ENABLE(GC_PROFILING)
     struct PerBucketFreeListStats {
         size_t entryCount;
         size_t freeSize;
 
         PerBucketFreeListStats() : entryCount(0), freeSize(0) { }
     };
 
     void getFreeSizeStats(PerBucketFreeListStats bucketStats[], size_t& totalSize) const;
 #endif
@@ skipping 13 matching lines @@
 //
 // BaseHeap is a parent class of NormalPageHeap and LargeObjectHeap.
 // NormalPageHeap represents a heap that contains NormalPages
 // and LargeObjectHeap represents a heap that contains LargeObjectPages.
 class PLATFORM_EXPORT BaseHeap {
 public:
     BaseHeap(ThreadState*, int);
     virtual ~BaseHeap();
     void cleanupPages();
 
-    void takeSnapshot(const String& dumpBaseName);
+    void takeSnapshot(const String& dumpBaseName, ThreadState::GCSnapshotInfo&);
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
     BasePage* findPageFromAddress(Address);
 #endif
+    virtual void takeFreelistSnapshot(const String& dumpBaseName) { };
 #if ENABLE(GC_PROFILING)
     void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
     virtual void snapshotFreeList(TracedValue&) { };
 
     void countMarkedObjects(ClassAgeCountsMap&) const;
     void countObjectsToSweep(ClassAgeCountsMap&) const;
     void incrementMarkedObjectsAge();
 #endif
 
     virtual void clearFreeLists() { }
@@ skipping 39 matching lines @@
     {
         ASSERT(findPageFromAddress(address));
         ASSERT(findPageFromAddress(address + size - 1));
         m_freeList.addToFreeList(address, size);
     }
     virtual void clearFreeLists() override;
 #if ENABLE(ASSERT)
     virtual bool isConsistentForGC() override;
     bool pagesToBeSweptContains(Address);
 #endif
+    void takeFreelistSnapshot(const String& dumpBaseName) override;
 #if ENABLE(GC_PROFILING)
     void snapshotFreeList(TracedValue&) override;
 #endif
 
     Address allocateObject(size_t allocationSize, size_t gcInfoIndex);
 
     void freePage(NormalPage*);
 
     bool coalesce();
     void promptlyFreeObject(HeapObjectHeader*);
@@ skipping 630 matching lines @@
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     return address;
 }
 
 } // namespace blink
 
 #endif // Heap_h