Allow Oilpan heap objects account for their external allocations.

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 2421 matching lines @@
 #endif
 
     // Disallow allocation during garbage collection (but not during the
     // finalization that happens when the gcScope is torn down).
     ThreadState::NoAllocationScope noAllocationScope(state);
 
     preGC();
     s_markingVisitor->configureEagerTraceLimit();
     ASSERT(s_markingVisitor->canTraceEagerly());
 
-    Heap::resetMarkedObjectSize();
-    Heap::resetAllocatedObjectSize();
+    Heap::resetHeapCounters();
 
     // 1. Trace persistent roots.
     ThreadState::visitPersistentRoots(s_markingVisitor);
 
     // 2. Trace objects reachable from the persistent roots including
     // ephemerons.
     processMarkingStack(s_markingVisitor);
 
     // 3. Trace objects reachable from the stack.  We do this independent of the
     // given stackState since other threads might have a different stack state.
@@ skipping 354 matching lines @@
         add(current->m_left, context);
         current->m_left = nullptr;
     }
     if (current->m_right) {
         add(current->m_right, context);
         current->m_right = nullptr;
     }
     delete current;
 }
 
+void Heap::resetHeapCounters()
+{
+    ASSERT(ThreadState::current()->isInGC());
+
+    s_allocatedObjectSize = 0;
+    s_markedObjectSize = 0;
+
+    // Similarly, reset the amount of externally allocated memory.
+    s_externallyAllocatedBytes = 0;
+    s_externallyAllocatedBytesAlive = 0;
+
+    s_requestedUrgentGC = false;
+}
+
+void Heap::increaseExternallyAllocatedBytes(size_t delta)
+{
+    atomicAdd(&s_externallyAllocatedBytes, static_cast<long>(delta));

[haraken, 2015/02/19 23:47:43]

You can use the return value of atomicAdd, instead of looking up
externallyAllocatedBytes in 2846 again.

Then you can write:

  size_t externalBytesSinceGC = atomicAdd(&s_externallyAllocatedBytes,
static_cast<long>(delta));
  if (LIKELY(externalBytesSinceGC < 100 * 1024 * 1024))
    return;

and thus reduce the cost of this method (I think
Heap::increaseExternallyAllocatedBytes must be light-weight). You can inline
this part if necessary.

[sof, 2015/02/20 09:33:49]

Inlined and tidied.

+
+    if (isGCUrgentlyRequested())
+        return;
+
+    // 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.
+    size_t externalBytesSinceGC = externallyAllocatedBytes();

[haraken, 2015/02/19 23:47:43]

externalBytesSinceLastGC

+    if (externalBytesSinceGC < 100 * 1024 * 1024)
+        return;
+
+    size_t externalBytesAlive = externallyAllocatedBytesAlive();
+
+    // The urgent-gc flag will be considered the next time an out-of-line
+    // allocation is made. Bump allocations from the current block will
+    // go ahead until it can no longer service an allocation request.
+    //
+    // FIXME: if that delays urgently needed GCs for too long, consider
+    // flushing out per-heap "allocation points" to trigger the GC
+    // right away.
+    if (externalBytesSinceGC > externalBytesAlive / 2)
+        Heap::requestUrgentGC();
+}
+
 Visitor* Heap::s_markingVisitor;
 CallbackStack* Heap::s_markingStack;
 CallbackStack* Heap::s_postMarkingCallbackStack;
 CallbackStack* Heap::s_weakCallbackStack;
 CallbackStack* Heap::s_ephemeronStack;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 FreePagePool* Heap::s_freePagePool;
 OrphanedPagePool* Heap::s_orphanedPagePool;
 Heap::RegionTree* Heap::s_regionTree = nullptr;
 size_t Heap::s_allocatedObjectSize = 0;
 size_t Heap::s_allocatedSpace = 0;
 size_t Heap::s_markedObjectSize = 0;
 
+size_t Heap::s_externallyAllocatedBytes = 0;
+size_t Heap::s_externallyAllocatedBytesAlive = 0;
+unsigned Heap::s_requestedUrgentGC = false;
+
 } // namespace blink