Oilpan: Refactor the way we calculate heap statistics

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 19 matching lines @@
 
 #ifndef Heap_h
 #define Heap_h
 
 #include "platform/PlatformExport.h"
 #include "platform/heap/AddressSanitizer.h"
 #include "platform/heap/ThreadState.h"
 #include "platform/heap/Visitor.h"
 #include "public/platform/WebThread.h"
 #include "wtf/Assertions.h"
+#include "wtf/Atomics.h"
 #include "wtf/HashCountedSet.h"
 #include "wtf/LinkedHashSet.h"
 #include "wtf/ListHashSet.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/ThreadSafeRefCounted.h"
 
 #include <stdint.h>
 
 // FIXME: We temporarily disable parallel marking because the current
@@ skipping 59 matching lines @@
 #endif
 
 const int numberOfPagesToConsiderForCoalescing = 100;
 
 enum CallbackInvocationMode {
     GlobalMarking,
     ThreadLocalMarking,
 };
 
 class CallbackStack;
-class HeapStats;
 class PageMemory;
 template<ThreadAffinity affinity> class ThreadLocalPersistents;
 template<typename T, typename RootsAccessor = ThreadLocalPersistents<ThreadingTrait<T>::Affinity > > class Persistent;
 
 #if ENABLE(GC_PROFILE_HEAP)
 class TracedValue;
 #endif
 
 PLATFORM_EXPORT size_t osPageSize();
 
@@ skipping 126 matching lines @@
     size_t payloadSize() { return heapObjectHeader()->payloadSize(); }
 
     Header* heapObjectHeader()
     {
         Address headerAddress = address() + sizeof(LargeHeapObject<Header>) + headerPadding<Header>();
         return reinterpret_cast<Header*>(headerAddress);
     }
 
     bool isMarked();
     void unmark();
-    void getStatsForTesting(HeapStats&);
+    size_t objectPayloadSizeForTesting();
     void mark(Visitor*);
     void finalize();
     void setDeadMark();
     virtual void markOrphaned()
     {
         // Zap the payload with a recognizable value to detect any incorrect
         // cross thread pointer usage.
         memset(payload(), orphanedZapValue, payloadSize());
         BaseHeapPage::markOrphaned();
     }
@@ skipping 250 matching lines @@
         return address() + sizeof(*this) + headerPadding<Header>();
     }
 
     static size_t payloadSize()
     {
         return (blinkPagePayloadSize() - sizeof(HeapPage) - headerPadding<Header>()) & ~allocationMask;
     }
 
     Address end() { return payload() + payloadSize(); }
 
-    void getStatsForTesting(HeapStats&);
+    size_t objectPayloadSizeForTesting();
     void clearLiveAndMarkDead();
-    void sweep(HeapStats*, ThreadHeap<Header>*);
+    void sweep(ThreadHeap<Header>*);
     void clearObjectStartBitMap();
     void finalize(Header*);
     virtual void checkAndMarkPointer(Visitor*, Address) override;
 #if ENABLE(GC_PROFILE_MARKING)
     const GCInfo* findGCInfo(Address) override;
 #endif
 #if ENABLE(GC_PROFILE_HEAP)
     virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*);
 #endif
 
@@ skipping 146 matching lines @@
 #if ENABLE(GC_PROFILE_MARKING)
     virtual const GCInfo* findGCInfoOfLargeHeapObject(Address) = 0;
 #endif
 
 #if ENABLE(GC_PROFILE_HEAP)
     virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*) = 0;
 #endif
 
     // Sweep this part of the Blink heap. This finalizes dead objects
     // and builds freelists for all the unused memory.
-    virtual void sweep(HeapStats*) = 0;
+    virtual void sweep() = 0;
     virtual void postSweepProcessing() = 0;
 
     virtual void clearFreeLists() = 0;
     virtual void clearLiveAndMarkDead() = 0;
 
     virtual void makeConsistentForSweeping() = 0;
 #if ENABLE(ASSERT)
     virtual bool isConsistentForSweeping() = 0;
 #endif
-    virtual void getStatsForTesting(HeapStats&) = 0;
+    virtual size_t objectPayloadSizeForTesting() = 0;
 
     virtual void updateRemainingAllocationSize() = 0;
 
     virtual void prepareHeapForTermination() = 0;
 
     virtual int normalPageCount() = 0;
 
     virtual PassOwnPtr<BaseHeap> split(int normalPages) = 0;
     virtual void merge(PassOwnPtr<BaseHeap> other) = 0;
 };
@@ skipping 39 matching lines @@
     virtual void cleanupPages() override;
 
     virtual BaseHeapPage* heapPageFromAddress(Address) override;
 #if ENABLE(GC_PROFILE_MARKING)
     virtual const GCInfo* findGCInfoOfLargeHeapObject(Address) override;
 #endif
 #if ENABLE(GC_PROFILE_HEAP)
     virtual void snapshot(TracedValue*, ThreadState::SnapshotInfo*) override;
 #endif
 
-    virtual void sweep(HeapStats*) override;
+    virtual void sweep() override;
     virtual void postSweepProcessing() override;
 
     virtual void clearFreeLists() override;
     virtual void clearLiveAndMarkDead() override;
 
     virtual void makeConsistentForSweeping() override;
 #if ENABLE(ASSERT)
     virtual bool isConsistentForSweeping() override;
 #endif
-    virtual void getStatsForTesting(HeapStats&) override;
+    virtual size_t objectPayloadSizeForTesting() override;
 
     virtual void updateRemainingAllocationSize() override;
 
     ThreadState* threadState() { return m_threadState; }
-    HeapStats& stats() { return m_threadState->stats(); }
 
     void addToFreeList(Address address, size_t size)
     {
         ASSERT(heapPageFromAddress(address));
         ASSERT(heapPageFromAddress(address + size - 1));
         m_freeList.addToFreeList(address, size);
     }
 
     inline Address allocate(size_t, const GCInfo*);
     inline static size_t roundedAllocationSize(size_t size)
@@ skipping 32 matching lines @@
     bool allocateFromFreeList(size_t);
 
     void freeLargeObject(LargeHeapObject<Header>*, LargeHeapObject<Header>**);
     void allocatePage(const GCInfo*);
 
 #if ENABLE(ASSERT)
     bool pagesToBeSweptContains(Address);
     bool pagesAllocatedDuringSweepingContains(Address);
 #endif
 
-    void sweepNormalPages(HeapStats*);
-    void sweepLargePages(HeapStats*);
+    void sweepNormalPages();
+    void sweepLargePages();
     bool coalesce(size_t);
 
     Address m_currentAllocationPoint;
     size_t m_remainingAllocationSize;
     size_t m_lastRemainingAllocationSize;
 
     HeapPage<Header>* m_firstPage;
     LargeHeapObject<Header>* m_firstLargeHeapObject;
 
     HeapPage<Header>* m_firstPageAllocatedDuringSweeping;
@@ skipping 100 matching lines @@
     static void dumpPathToObjectOnNextGC(void* p);
 
     // Forcibly find GCInfo of the object at Address.
     // This is slow and should only be used for debug purposes.
     // It involves finding the heap page and scanning the heap page for an object header.
     static const GCInfo* findGCInfo(Address);
 
     static String createBacktraceString();
 #endif
 
-    // Collect heap stats for all threads attached to the Blink
-    // garbage collector. Should only be called during garbage
-    // collection where threads are known to be at safe points.
-    static void getStats(HeapStats*);
-
-    static void getStatsForTesting(HeapStats*);
+    static size_t objectPayloadSizeForTesting();
 
     static void getHeapSpaceSize(uint64_t*, uint64_t*);
 
     static void makeConsistentForSweeping();
 
 #if ENABLE(ASSERT)
     static bool isConsistentForSweeping();
 #endif
 
     static void flushHeapDoesNotContainCache();
 
     // Return true if the last GC found a pointer into a heap page
     // during conservative scanning.
     static bool lastGCWasConservative() { return s_lastGCWasConservative; }
 
     static FreePagePool* freePagePool() { return s_freePagePool; }
     static OrphanedPagePool* orphanedPagePool() { return s_orphanedPagePool; }
 
     // This look-up uses the region search tree and a negative contains cache to
     // provide an efficient mapping from arbitrary addresses to the containing
     // heap-page if one exists.
     static BaseHeapPage* lookup(Address);
     static void addPageMemoryRegion(PageMemoryRegion*);
     static void removePageMemoryRegion(PageMemoryRegion*);
 
+    static void resetAllocatedObjectSize() { s_allocatedObjectSize = 0; }

[sof, 2014/11/14 12:44:20]

Add a comment to make it clearer why this doesn't have to be an atomic operation
also?

[haraken, 2014/11/14 15:15:00]

Added ASSERT(ThreadState::isAnyThreadInGC()).

[sof, 2014/11/14 16:37:21]

An assert is even better. I suppose there isn't a finer-grained condition to
test for here.

Could we make some of these static methods private?

[haraken, 2014/11/17 01:05:02]

Done.

+    static void increaseAllocatedObjectSize(size_t delta) { atomicAdd(&s_allocatedObjectSize, delta); }
+    static void decreaseAllocatedObjectSize(size_t delta) { atomicSubtract(&s_allocatedObjectSize, delta); }
+    static size_t allocatedObjectSize() { return s_allocatedObjectSize; }
+    static void resetLiveObjectSize() { s_liveObjectSize = 0; }
+    static void increaseLiveObjectSize(size_t delta) { atomicAdd(&s_liveObjectSize, delta); }
+    static size_t liveObjectSize() { return s_liveObjectSize; }
+    static void increaseAllocatedSpace(size_t delta) { atomicAdd(&s_allocatedSpace, delta); }
+    static void decreaseAllocatedSpace(size_t delta) { atomicSubtract(&s_allocatedSpace, delta); }
+    static size_t allocatedSpace() { return s_allocatedSpace; }
+
 private:
     // A RegionTree is a simple binary search tree of PageMemoryRegions sorted
     // by base addresses.
     class RegionTree {
     public:
         explicit RegionTree(PageMemoryRegion* region) : m_region(region), m_left(0), m_right(0) { }
         ~RegionTree()
         {
             delete m_left;
             delete m_right;
@@ skipping 12 matching lines @@
     static CallbackStack* s_markingStack;
     static CallbackStack* s_postMarkingCallbackStack;
     static CallbackStack* s_weakCallbackStack;
     static CallbackStack* s_ephemeronStack;
     static HeapDoesNotContainCache* s_heapDoesNotContainCache;
     static bool s_shutdownCalled;
     static bool s_lastGCWasConservative;
     static FreePagePool* s_freePagePool;
     static OrphanedPagePool* s_orphanedPagePool;
     static RegionTree* s_regionTree;
+    static size_t s_allocatedSpace;
+    static size_t s_allocatedObjectSize;
+    static size_t s_liveObjectSize;
     friend class ThreadState;
 };
 
 // The NoAllocationScope class is used in debug mode to catch unwanted
 // allocations. E.g. allocations during GC.
 template<ThreadAffinity Affinity>
 class NoAllocationScope {
 public:
     NoAllocationScope() : m_active(true) { enter(); }
 
@@ skipping 1379 matching lines @@
 };
 
 template<typename T>
 struct IfWeakMember<WeakMember<T> > {
     static bool isDead(Visitor* visitor, const WeakMember<T>& t) { return !visitor->isAlive(t.get()); }
 };
 
 } // namespace blink
 
 #endif // Heap_h