Oilpan: tweak heuristics for forcing conservative GC.

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 261 matching lines @@
 
     // 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.
@@ skipping 245 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; }
+
     static WTF::ThreadSpecific<ThreadState*>* s_threadSpecific;
     static SafePointBarrier* s_safePointBarrier;
 
     // This variable is flipped to true after all threads are stoped
     // and outermost GC has started.
     static bool s_inGC;
 
     // We can't create a static member of type ThreadState here
     // because it will introduce global constructor and destructor.
     // We would like to manage lifetime of the ThreadState attached
@@ skipping 19 matching lines @@
     size_t m_noAllocationCount;
     bool m_inGC;
     BaseHeap* m_heaps[NumberOfHeaps];
     OwnPtr<HeapContainsCache> m_heapContainsCache;
     HeapStats m_stats;
     HeapStats m_statsAfterLastGC;
 
     Vector<OwnPtr<CleanupTask> > m_cleanupTasks;
     bool m_isTerminating;
 
+    bool m_lowCollectionRate;
+
     CallbackStack* m_weakCallbackStack;
 
 #if defined(ADDRESS_SANITIZER)
     void* m_asanFakeStack;
 #endif
 };
 
 template<ThreadAffinity affinity> class ThreadStateFor;
 
 template<> class ThreadStateFor<MainThreadOnly> {
@@ skipping 113 matching lines @@
     // HeapPage header. We use some of the bits to determine
     // 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;
 };
 
 }
 
 #endif // ThreadState_h