Oilpan: Make the GC heuristics saner

Source/platform/heap/Heap.cpp

 /*
  * 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 439 matching lines @@
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::enter();
 
     Address result = lazySweepPages(allocationSize, gcInfoIndex);
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::exit();
 
     Heap::reportMemoryUsageForTracing();
-
     return result;
 }
 
 void BaseHeap::sweepUnsweptPage()
 {
     BasePage* page = m_firstUnsweptPage;
     if (page->isEmpty()) {
         page->unlink(&m_firstUnsweptPage);
         page->removeFromHeap();
     } else {
@@ skipping 410 matching lines @@
     ASSERT(allocationSize > remainingAllocationSize());
     ASSERT(allocationSize >= allocationGranularity);
 
 #if ENABLE(GC_PROFILING)
     threadState()->snapshotFreeListIfNecessary();
 #endif
 
     // Ideally we want to update the persistent count every time a persistent
     // handle is created or destructed, but that is heavy. So we do the update
     // only in outOfLineAllocate().
-    threadState()->updatePersistentCounters();
+    threadState()->updateWrapperCounters();
 
     // 1. If this allocation is big enough, allocate a large object.
     if (allocationSize >= largeObjectSizeThreshold) {
         // TODO(sof): support eagerly finalized large objects, if ever needed.
         RELEASE_ASSERT(heapIndex() != ThreadState::EagerSweepHeapIndex);
         LargeObjectHeap* largeObjectHeap = static_cast<LargeObjectHeap*>(threadState()->heap(ThreadState::LargeObjectHeapIndex));
         Address largeObject = largeObjectHeap->allocateLargeObjectPage(allocationSize, gcInfoIndex);
         ASAN_MARK_LARGE_VECTOR_CONTAINER(this, largeObject);
         return largeObject;
     }
@@ skipping 1025 matching lines @@
     s_postMarkingCallbackStack = new CallbackStack();
     s_globalWeakCallbackStack = new CallbackStack();
     s_ephemeronStack = new CallbackStack();
     s_heapDoesNotContainCache = new HeapDoesNotContainCache();
     s_freePagePool = new FreePagePool();
     s_orphanedPagePool = new OrphanedPagePool();
     s_allocatedSpace = 0;
     s_allocatedObjectSize = 0;
     s_objectSizeAtLastGC = 0;
     s_markedObjectSize = 0;
-    s_persistentCount = 0;
-    s_persistentCountAtLastGC = 0;
-    s_collectedPersistentCount = 0;
+    s_markedObjectSizeAtLastCompleteSweep = 1024 * 1024;
+    s_wrapperCount = 0;
+    s_wrapperCountAtLastGC = 0;
+    s_collectedWrapperCount = 0;
     s_partitionAllocSizeAtLastGC = WTF::Partitions::totalSizeOfCommittedPages();
-    // Initially, the total heap size is very small. Thus we'll hit the GC
-    // condition (i.e., 50% increase on the heap size etc) even if we don't
-    // take into account the memory usage explained by the collected persistent
-    // handles. So it is OK to set a large initial value.
-    s_heapSizePerPersistent = 1024 * 1024;
     s_estimatedMarkingTimePerByte = 0.0;
 
     GCInfoTable::init();
 
     if (Platform::current() && Platform::current()->currentThread())
         Platform::current()->registerMemoryDumpProvider(BlinkGCMemoryDumpProvider::instance());
 }
 
 void Heap::shutdown()
 {
@@ skipping 441 matching lines @@
         observedMaxSizeInMB = sizeInMB;
     }
 }
 
 void Heap::reportMemoryUsageForTracing()
 {
     // These values are divided by 1024 to avoid overflow in practical cases (TRACE_COUNTER values are 32-bit ints).
     // They are capped to INT_MAX just in case.
     TRACE_COUNTER1("blink_gc", "Heap::allocatedObjectSizeKB", std::min(Heap::allocatedObjectSize() / 1024, static_cast<size_t>(INT_MAX)));
     TRACE_COUNTER1("blink_gc", "Heap::markedObjectSizeKB", std::min(Heap::markedObjectSize() / 1024, static_cast<size_t>(INT_MAX)));
+    TRACE_COUNTER1("blink_gc", "Heap::markedObjectSizeAtLastCompleteSweepKB", std::min(Heap::markedObjectSizeAtLastCompleteSweep() / 1024, static_cast<size_t>(INT_MAX)));
     TRACE_COUNTER1("blink_gc", "Heap::allocatedSpaceKB", std::min(Heap::allocatedSpace() / 1024, static_cast<size_t>(INT_MAX)));
     TRACE_COUNTER1("blink_gc", "Heap::objectSizeAtLastGCKB", std::min(Heap::objectSizeAtLastGC() / 1024, static_cast<size_t>(INT_MAX)));
-    TRACE_COUNTER1("blink_gc", "Heap::persistentCount", std::min(Heap::persistentCount(), static_cast<size_t>(INT_MAX)));
-    TRACE_COUNTER1("blink_gc", "Heap::persistentCountAtLastGC", std::min(Heap::persistentCountAtLastGC(), static_cast<size_t>(INT_MAX)));
-    TRACE_COUNTER1("blink_gc", "Heap::collectedPersistentCount", std::min(Heap::collectedPersistentCount(), static_cast<size_t>(INT_MAX)));
-    TRACE_COUNTER1("blink_gc", "Heap::heapSizePerPersistent", std::min(Heap::heapSizePerPersistent(), static_cast<size_t>(INT_MAX)));
+    TRACE_COUNTER1("blink_gc", "Heap::wrapperCount", std::min(Heap::wrapperCount(), static_cast<size_t>(INT_MAX)));
+    TRACE_COUNTER1("blink_gc", "Heap::wrapperCountAtLastGC", std::min(Heap::wrapperCountAtLastGC(), static_cast<size_t>(INT_MAX)));
+    TRACE_COUNTER1("blink_gc", "Heap::collectedWrapperCount", std::min(Heap::collectedWrapperCount(), static_cast<size_t>(INT_MAX)));
     TRACE_COUNTER1("blink_gc", "Heap::partitionAllocSizeAtLastGCKB", std::min(Heap::partitionAllocSizeAtLastGC() / 1024, static_cast<size_t>(INT_MAX)));
     TRACE_COUNTER1("blink_gc", "Partitions::totalSizeOfCommittedPagesKB", std::min(WTF::Partitions::totalSizeOfCommittedPages() / 1024, static_cast<size_t>(INT_MAX)));
 }
 
 size_t Heap::objectPayloadSizeForTesting()
 {
     size_t objectPayloadSize = 0;
     for (ThreadState* state : ThreadState::attachedThreads()) {
         state->setGCState(ThreadState::GCRunning);
         state->makeConsistentForGC();
@@ skipping 97 matching lines @@
     delete current;
 }
 
 void Heap::resetHeapCounters()
 {
     ASSERT(ThreadState::current()->isInGC());
 
     Heap::reportMemoryUsageForTracing();
 
     s_objectSizeAtLastGC = s_allocatedObjectSize + s_markedObjectSize;
+    s_partitionAllocSizeAtLastGC = WTF::Partitions::totalSizeOfCommittedPages();
+    s_wrapperCountAtLastGC = s_wrapperCount;
     s_allocatedObjectSize = 0;
     s_markedObjectSize = 0;
-    s_partitionAllocSizeAtLastGC = WTF::Partitions::totalSizeOfCommittedPages();
-    s_persistentCountAtLastGC = s_persistentCount;
-    s_collectedPersistentCount = 0;
+    s_collectedWrapperCount = 0;
 }
 
 CallbackStack* Heap::s_markingStack;
 CallbackStack* Heap::s_postMarkingCallbackStack;
 CallbackStack* Heap::s_globalWeakCallbackStack;
 CallbackStack* Heap::s_ephemeronStack;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = nullptr;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_objectSizeAtLastGC = 0;
 size_t Heap::s_markedObjectSize = 0;
-size_t Heap::s_persistentCount = 0;
-size_t Heap::s_persistentCountAtLastGC = 0;
-size_t Heap::s_collectedPersistentCount = 0;
+size_t Heap::s_markedObjectSizeAtLastCompleteSweep = 0;
+size_t Heap::s_wrapperCount = 0;
+size_t Heap::s_wrapperCountAtLastGC = 0;
+size_t Heap::s_collectedWrapperCount = 0;
 size_t Heap::s_partitionAllocSizeAtLastGC = 0;
-size_t Heap::s_heapSizePerPersistent = 0;
 double Heap::s_estimatedMarkingTimePerByte = 0.0;
 
 } // namespace blink