Oilpan: Consider PartitionAlloc's memory usage when triggering a GC

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 1003 matching lines @@
     static void increaseAllocatedObjectSize(size_t delta) { atomicAdd(&s_allocatedObjectSize, static_cast<long>(delta)); }
     static void decreaseAllocatedObjectSize(size_t delta) { atomicSubtract(&s_allocatedObjectSize, static_cast<long>(delta)); }
     static size_t allocatedObjectSize() { return acquireLoad(&s_allocatedObjectSize); }
     static void increaseMarkedObjectSize(size_t delta) { atomicAdd(&s_markedObjectSize, static_cast<long>(delta)); }
     static size_t markedObjectSize() { return acquireLoad(&s_markedObjectSize); }
     static void increaseAllocatedSpace(size_t delta) { atomicAdd(&s_allocatedSpace, static_cast<long>(delta)); }
     static void decreaseAllocatedSpace(size_t delta) { atomicSubtract(&s_allocatedSpace, static_cast<long>(delta)); }
     static size_t allocatedSpace() { return acquireLoad(&s_allocatedSpace); }
     static size_t estimatedLiveObjectSize() { return acquireLoad(&s_estimatedLiveObjectSize); }
     static void setEstimatedLiveObjectSize(size_t size) { releaseStore(&s_estimatedLiveObjectSize, size); }
+    static size_t externalObjectSizeAtLastGC() { return acquireLoad(&s_externalObjectSizeAtLastGC); }
 
     static double estimatedMarkingTime();
     static void reportMemoryUsageHistogram();
 
-    // On object allocation, register the object's externally allocated memory.
-    static void increaseExternallyAllocatedBytes(size_t);
-    static size_t externallyAllocatedBytes() { return acquireLoad(&s_externallyAllocatedBytes); }
-
-    // On object tracing, register the object's externally allocated memory (as still live.)
-    static void increaseExternallyAllocatedBytesAlive(size_t delta)
-    {
-        ASSERT(ThreadState::current()->isInGC());
-        s_externallyAllocatedBytesAlive += delta;
-    }
-    static size_t externallyAllocatedBytesAlive() { return s_externallyAllocatedBytesAlive; }
-
-    static void requestUrgentGC();
-    static void clearUrgentGC() { releaseStore(&s_requestedUrgentGC, 0); }
-    static bool isUrgentGCRequested() { return acquireLoad(&s_requestedUrgentGC); }
-
 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(nullptr), m_right(nullptr) { }
         ~RegionTree()
         {
             delete m_left;
             delete m_right;
@@ skipping 18 matching lines @@
     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_markedObjectSize;
     static size_t s_estimatedLiveObjectSize;
-    static size_t s_externallyAllocatedBytes;
-    static size_t s_externallyAllocatedBytesAlive;
-    static unsigned s_requestedUrgentGC;
+    static size_t s_externalObjectSizeAtLastGC;
     static double s_estimatedMarkingTimePerByte;
 
     friend class ThreadState;
 };
 
 // We use sized heaps for normal pages to improve memory locality.
 // It seems that the same type of objects are likely to be accessed together,
 // which means that we want to group objects by type. That's why we provide
 // dedicated heaps for popular types (e.g., Node, CSSValue), but it's not
 // practical to prepare dedicated heaps for all types. Thus we group objects
@@ skipping 376 matching lines @@
     // TODO(haraken): We don't support reallocate() for finalizable objects.
     ASSERT(!Heap::gcInfo(previousHeader->gcInfoIndex())->hasFinalizer());
     ASSERT(previousHeader->gcInfoIndex() == GCInfoTrait<T>::index());
     size_t copySize = previousHeader->payloadSize();
     if (copySize > size)
         copySize = size;
     memcpy(address, previous, copySize);
     return address;
 }
 
-inline void Heap::increaseExternallyAllocatedBytes(size_t delta)
-{
-    // Flag GC urgency on a 50% increase in external allocation
-    // since the last GC, but not for less than 100M.
-    //
-    // FIXME: consider other, 'better' policies (e.g., have the count of
-    // heap objects with external allocations be taken into
-    // account, ...) The overall goal here is to trigger a
-    // GC such that it considerably lessens memory pressure
-    // for a renderer process, when absolutely needed.
-    size_t externalBytesAllocatedSinceLastGC = atomicAdd(&s_externallyAllocatedBytes, static_cast<long>(delta));
-    if (LIKELY(externalBytesAllocatedSinceLastGC < 100 * 1024 * 1024))
-        return;
-
-    if (UNLIKELY(isUrgentGCRequested()))
-        return;
-
-    size_t externalBytesAliveAtLastGC = externallyAllocatedBytesAlive();
-    if (UNLIKELY(externalBytesAllocatedSinceLastGC > externalBytesAliveAtLastGC / 2))
-        Heap::requestUrgentGC();
-}
-
 template<bool needsTracing, WTF::WeakHandlingFlag weakHandlingFlag, WTF::ShouldWeakPointersBeMarkedStrongly strongify, typename T, typename Traits> struct CollectionBackingTraceTrait;
 template<typename T, typename Traits = WTF::VectorTraits<T>> class HeapVectorBacking;
 template<typename Table> class HeapHashTableBacking {
 public:
     static void finalize(void* pointer);
     void finalizeGarbageCollectedObject() { finalize(this); }
 };
 
 class HeapAllocatorQuantizer {
 public:
@@ skipping 710 matching lines @@
     Value* table = reinterpret_cast<Value*>(pointer);
     for (unsigned i = 0; i < length; ++i) {
         if (!Table::isEmptyOrDeletedBucket(table[i]))
             table[i].~Value();
     }
 }
 
 } // namespace blink
 
 #endif // Heap_h