Revert of Oilpan: Refactor the way we calculate heap statistics

Source/platform/heap/ThreadState.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 277 matching lines @@
 // We don't have any type-based mappings to the CollectionBackingHeap.
 
 // Each typed-heap maps the respective type to its heap.
 #define DEFINE_TYPED_HEAP_TRAIT(Type)                                   \
     class Type;                                                         \
     template<>                                                          \
     struct HeapTypeTrait<class Type> : public HeapIndexTrait<Type##Heap> { };
 FOR_EACH_TYPED_HEAP(DEFINE_TYPED_HEAP_TRAIT)
 #undef DEFINE_TYPED_HEAP_TRAIT
 
+// A HeapStats structure keeps track of the amount of memory allocated
+// for a Blink heap and how much of that memory is used for actual
+// Blink objects. These stats are used in the heuristics to determine
+// when to perform garbage collections.
+class HeapStats {
+public:
+    HeapStats() : m_totalObjectSpace(0), m_totalAllocatedSpace(0) { }
+
+    size_t totalObjectSpace() const { return m_totalObjectSpace; }
+    size_t totalAllocatedSpace() const { return m_totalAllocatedSpace; }
+
+    void add(HeapStats* other)
+    {
+        m_totalObjectSpace += other->m_totalObjectSpace;
+        m_totalAllocatedSpace += other->m_totalAllocatedSpace;
+    }
+
+    void inline increaseObjectSpace(size_t newObjectSpace)
+    {
+        m_totalObjectSpace += newObjectSpace;
+    }
+
+    void inline decreaseObjectSpace(size_t deadObjectSpace)
+    {
+        m_totalObjectSpace -= deadObjectSpace;
+    }
+
+    void inline increaseAllocatedSpace(size_t newAllocatedSpace)
+    {
+        m_totalAllocatedSpace += newAllocatedSpace;
+    }
+
+    void inline decreaseAllocatedSpace(size_t deadAllocatedSpace)
+    {
+        m_totalAllocatedSpace -= deadAllocatedSpace;
+    }
+
+    void clear()
+    {
+        m_totalObjectSpace = 0;
+        m_totalAllocatedSpace = 0;
+    }
+
+    bool operator==(const HeapStats& other)
+    {
+        return m_totalAllocatedSpace == other.m_totalAllocatedSpace
+            && m_totalObjectSpace == other.m_totalObjectSpace;
+    }
+
+private:
+    size_t m_totalObjectSpace; // Actually contains objects that may be live, not including headers.
+    size_t m_totalAllocatedSpace; // Allocated from the OS.
+
+    friend class HeapTester;
+};
+
 class PLATFORM_EXPORT ThreadState {
     WTF_MAKE_NONCOPYABLE(ThreadState);
 public:
     // When garbage collecting we need to know whether or not there
     // can be pointers to Blink GC managed objects on the stack for
     // each thread. When threads reach a safe point they record
     // whether or not they have pointers on the stack.
     enum StackState {
         NoHeapPointersOnStack,
         HeapPointersOnStack
@@ skipping 77 matching lines @@
         return reinterpret_cast<ThreadState*>(s_mainThreadStateStorage);
     }
 
     bool isMainThread() const { return this == mainThreadState(); }
     inline bool checkThread() const
     {
         ASSERT(m_thread == currentThread());
         return true;
     }
 
-    // If gcRequested returns true when a thread returns to its event
-    // loop the thread will initiate a garbage collection.
-    bool gcRequested();
-    void setGCRequested();
-    void clearGCRequested();
-
     // shouldGC and shouldForceConservativeGC implement the heuristics
     // that are used to determine when to collect garbage. If
     // shouldForceConservativeGC returns true, we force the garbage
     // collection immediately. Otherwise, if shouldGC returns true, we
     // record that we should garbage collect the next time we return
     // to the event loop. If both return false, we don't need to
     // collect garbage at this point.
     bool shouldGC();
     bool shouldForceConservativeGC();
+    bool increasedEnoughToGC(size_t, size_t);
+    bool increasedEnoughToForceConservativeGC(size_t, size_t);
+
+    // If gcRequested returns true when a thread returns to its event
+    // loop the thread will initiate a garbage collection.
+    bool gcRequested();
+    void setGCRequested();
+    void clearGCRequested();
 
     // Was the last GC forced for testing? This is set when garbage collection
     // is forced for testing and there are pointers on the stack. It remains
     // set until a garbage collection is triggered with no pointers on the stack.
     // This is used for layout tests that trigger GCs and check if objects are
     // dead at a given point in time. That only reliably works when we get
     // precise GCs with no conservative stack scanning.
     void setForcePreciseGCForTesting(bool);
     bool forcePreciseGCForTesting();
 
@@ skipping 228 matching lines @@
 
         size_t getClassTag(const GCInfo*);
     };
 
     void snapshot();
 #endif
 
     void pushWeakObjectPointerCallback(void*, WeakPointerCallback);
     bool popAndInvokeWeakPointerCallback(Visitor*);
 
-    size_t objectPayloadSizeForTesting();
+    void getStats(HeapStats&);
+    void getStatsForTesting(HeapStats&);
+    HeapStats& stats() { return m_stats; }
 
     void setupHeapsForTermination();
 
     void registerSweepingTask();
     void unregisterSweepingTask();
 
     // Request to call a pref-finalizer of the target object before the object
     // is destructed.  The class T must have USING_PRE_FINALIZER().  The
     // argument should be |*this|.  Registering a lot of objects affects GC
     // performance.  We should register an object only if the object really
@@ skipping 54 matching lines @@
     // When ThreadState is detaching from non-main thread its
     // heap is expected to be empty (because it is going away).
     // Perform registered cleanup tasks and garbage collection
     // to sweep away any objects that are left on this heap.
     // We assert that nothing must remain after this cleanup.
     // If assertion does not hold we crash as we are potentially
     // in the dangling pointer situation.
     void cleanup();
     void cleanupPages();
 
+    void setLowCollectionRate(bool value) { m_lowCollectionRate = value; }
+
     void performPendingSweepInParallel();
     void waitUntilSweepersDone();
     void unregisterPreFinalizerInternal(void*);
     void invokePreFinalizers(Visitor&);
 
     static WTF::ThreadSpecific<ThreadState*>* s_threadSpecific;
     static uintptr_t s_mainThreadStackStart;
     static uintptr_t s_mainThreadUnderestimatedStackSize;
     static SafePointBarrier* s_safePointBarrier;
 
@@ skipping 19 matching lines @@
     Vector<Address> m_safePointStackCopy;
     bool m_atSafePoint;
     Vector<Interruptor*> m_interruptors;
     bool m_gcRequested;
     bool m_forcePreciseGCForTesting;
     volatile int m_sweepRequested;
     bool m_sweepInProgress;
     size_t m_noAllocationCount;
     bool m_inGC;
     BaseHeap* m_heaps[NumberOfHeaps];
+    HeapStats m_stats;
+    HeapStats m_statsAfterLastGC;
 
     Vector<OwnPtr<CleanupTask> > m_cleanupTasks;
     bool m_isTerminating;
 
     bool m_shouldFlushHeapDoesNotContainCache;
     bool m_lowCollectionRate;
 
     OwnPtr<WebThread> m_sweeperThread;
     int m_numberOfSweeperTasks;
     Mutex m_sweepMutex;
@@ skipping 129 matching lines @@
     // whether the page is part of a terminting thread or
     // if the page is traced after being terminated (orphaned).
     uintptr_t m_terminating : 1;
     uintptr_t m_tracedAfterOrphaned : 1;
     uintptr_t m_promptlyFreedSize : 17; // == blinkPageSizeLog2
 };
 
 } // namespace blink
 
 #endif // ThreadState_h