Oilpan: Implement mark/sweep stats collection for free list profiler.

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 454 matching lines @@
 #if defined(ADDRESS_SANITIZER)
         // This needs to zap poisoned memory as well.
         // Force unpoison memory before memset.
         ASAN_UNPOISON_MEMORY_REGION(payload(), payloadSize());
 #endif
         memset(payload(), orphanedZapValue, payloadSize());
         BaseHeapPage::markOrphaned();
     }
 #if ENABLE(GC_PROFILING)
     const GCInfo* findGCInfo(Address) override;
-#endif
-#if ENABLE(GC_PROFILING)
     virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
+    void incrementMarkedObjectsAge();
+    void countMarkedObjects(ClassAgeCountsMap&);
+    void countObjectsToSweep(ClassAgeCountsMap&);
 #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
     // the result can be used to populate the negative page cache.
     virtual bool contains(Address addr) override
     {
         Address blinkPageStart = roundToBlinkPageStart(address());
         ASSERT(blinkPageStart == address() - WTF::kSystemPageSize); // Page is at aligned address plus guard page size.
         return blinkPageStart <= addr && addr < blinkPageStart + blinkPageSize;
@@ skipping 49 matching lines @@
     virtual void sweep() override;
     virtual void markUnmarkedObjectsDead() override;
     virtual void checkAndMarkPointer(Visitor*, Address) override;
     virtual void markOrphaned() override
     {
         // Zap the payload with a recognizable value to detect any incorrect
         // cross thread pointer usage.
         memset(payload(), orphanedZapValue, payloadSize());
         BaseHeapPage::markOrphaned();
     }
+
 #if ENABLE(GC_PROFILING)
     virtual const GCInfo* findGCInfo(Address) override;
     virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*) override;
+    void incrementMarkedObjectsAge();
+    void countMarkedObjects(ClassAgeCountsMap&);
+    void countObjectsToSweep(ClassAgeCountsMap&);
 #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
     // populate the negative page cache.
     virtual bool contains(Address object) override
     {
         return roundToBlinkPageStart(address()) <= object && object < roundToBlinkPageEnd(address() + size());
     }
 #endif
     virtual size_t size()
@@ skipping 141 matching lines @@
     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);
 
 #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
 
 private:
     int m_biggestFreeListIndex;
 
     // All FreeListEntries in the nth list have size >= 2^n.
     FreeListEntry* m_freeLists[blinkPageSizeLog2];
@@ skipping 15 matching lines @@
 public:
     ThreadHeap(ThreadState*, int);
     ~ThreadHeap();
     void cleanupPages();
 
 #if ENABLE(ASSERT) || ENABLE(GC_PROFILING)
     BaseHeapPage* findPageFromAddress(Address);
 #endif
 #if ENABLE(GC_PROFILING)
     void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
+    void incrementMarkedObjectsAge();
 #endif
 
     void clearFreeLists();
     void makeConsistentForSweeping();
 #if ENABLE(ASSERT)
     bool isConsistentForSweeping();
 #endif
     size_t objectPayloadSizeForTesting();
 
     ThreadState* threadState() { return m_threadState; }
@@ skipping 19 matching lines @@
     void freePage(HeapPage*);
     void freeLargeObject(LargeObject*);
 
     void promptlyFreeObject(HeapObjectHeader*);
     bool expandObject(HeapObjectHeader*, size_t);
     void shrinkObject(HeapObjectHeader*, size_t);
     void decreasePromptlyFreedSize(size_t size) { m_promptlyFreedSize -= size; }
 
 #if ENABLE(GC_PROFILING)
     void snapshotFreeList(TracedValue&);
+
+    void countMarkedObjects(ClassAgeCountsMap&) const;
+    void countObjectsToSweep(ClassAgeCountsMap&) const;
 #endif
 
 private:
     Address outOfLineAllocate(size_t allocationSize, size_t gcInfoIndex);
     Address currentAllocationPoint() const { return m_currentAllocationPoint; }
     size_t remainingAllocationSize() const { return m_remainingAllocationSize; }
     bool hasCurrentAllocationArea() const { return currentAllocationPoint() && remainingAllocationSize(); }
     inline void setAllocationPoint(Address, size_t);
     void updateRemainingAllocationSize();
     Address allocateFromFreeList(size_t, size_t gcInfoIndex);
@@ skipping 1654 matching lines @@
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapVector<T, inlineCapacity>> : public GCInfoTrait<Vector<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, size_t inlineCapacity>
 struct GCInfoTrait<HeapDeque<T, inlineCapacity>> : public GCInfoTrait<Deque<T, inlineCapacity, HeapAllocator>> { };
 template<typename T, typename U, typename V>
 struct GCInfoTrait<HeapHashCountedSet<T, U, V>> : public GCInfoTrait<HashCountedSet<T, U, V, HeapAllocator>> { };
 
 } // namespace blink
 
 #endif // Heap_h