Allow Oilpan heap objects account for their external allocations.

Source/platform/heap/ThreadState.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 655 matching lines @@
 #endif
 }
 
 // FIXME: We should improve the GC heuristics.
 // These heuristics affect performance significantly.
 bool ThreadState::shouldForceConservativeGC()
 {
     if (UNLIKELY(m_gcForbiddenCount))
         return false;
 
+    if (Heap::isUrgentGCRequested())
+        return true;
+
     size_t newSize = Heap::allocatedObjectSize();
     if (newSize >= 300 * 1024 * 1024) {
         // If we consume too much memory, trigger a conservative GC
         // on a 50% increase in size since the last GC. This is a safe guard
         // to avoid OOM.
         return newSize > Heap::markedObjectSize() / 2;
     }
     if (m_didV8GCAfterLastGC && m_collectionRate > 0.5) {
         // If we had a V8 GC after the last Oilpan GC and the last collection
         // rate was higher than 50%, trigger a conservative GC on a 200%
         // increase in size since the last GC, but not for less than 4 MB.
         return newSize >= 4 * 1024 * 1024 && newSize > 2 * Heap::markedObjectSize();
     }
     // Otherwise, trigger a conservative GC on a 400% increase in size since
     // the last GC, but not for less than 32 MB. We set the higher limit in
     // this case because Oilpan GC is unlikely to collect a lot of objects
     // without having a V8 GC.
     return newSize >= 32 * 1024 * 1024 && newSize > 4 * Heap::markedObjectSize();
 }
 
 void ThreadState::scheduleGCIfNeeded()
 {
     checkThread();
     // Allocation is allowed during sweeping, but those allocations should not
     // trigger nested GCs
-    if (isSweepingInProgress())
-        return;
+    if (isSweepingInProgress()) {
+        if (!Heap::isUrgentGCRequested() || !isSweepingScheduled())

[haraken, 2015/02/23 16:40:29]

Sorry to bug you a lot of times on this... I reconsidered but am not yet sure
why we need the '|| !isSweepingScheduled()' check.

Even if we don't have the check, Heap::collectGarbage() will make the heap
consistent (by makeConsitentForSweeping) before starting the next GC, so the
nested GC won't cause any issue.

If we interpret Heap::isUrgentGCRequested() as a signal to indicate that "Please
trigger a conservative GC right now even if the current sweeping is not yet
complete", it seems more straightforward just to trigger a conservative GC
without any additional check.

(The reason I'm skeptical about the check is that the check means that we treat
Sweeping and SweepingAndPreciseGCScheduled differently. There should be no
difference between the two states in a case where an urgent GC is requested (we
should just trigger an urgent GC immediately), so I think we should just remove
the check.)

[sof, 2015/02/23 20:47:05]

Yes, we don't want to make a distinction between the "pure" sweeping state and
the sweeping-and-scheduled-gc ones here. I'm getting these GC states mixed up,
somehow.

Removed the check; sorry about all these iterations (fatigue setting in, i
suppose.) 

+            return;
+        // Urgent GC requested with only a GC scheduled; fall through
+        // and have it be serviced by a conservative GC.
+    }
     ASSERT(!sweepForbidden());
 
-    if (shouldForceConservativeGC())
-        Heap::collectGarbage(ThreadState::HeapPointersOnStack, ThreadState::GCWithoutSweep);
-    else if (shouldSchedulePreciseGC())
+    if (shouldForceConservativeGC()) {
+        // If GC is deemed urgent, eagerly sweep and finalize any external allocations right away.
+        GCType gcType = Heap::isUrgentGCRequested() ? GCWithSweep : GCWithoutSweep;
+        Heap::collectGarbage(HeapPointersOnStack, gcType);
+        return;
+    }
+    if (shouldSchedulePreciseGC())
         schedulePreciseGC();
     else if (shouldScheduleIdleGC())
         scheduleIdleGC();
 }
 
 void ThreadState::performIdleGC(double deadlineSeconds)
 {
     ASSERT(isMainThread());
 
     m_hasPendingIdleTask = false;
@@ skipping 553 matching lines @@
         json->beginArray(it->key.ascii().data());
         for (size_t age = 0; age <= maxHeapObjectAge; ++age)
             json->pushInteger(it->value.ages[age]);
         json->endArray();
     }
     TRACE_EVENT_OBJECT_SNAPSHOT_WITH_ID(TRACE_DISABLED_BY_DEFAULT("blink_gc"), statsName, this, json.release());
 }
 #endif
 
 } // namespace blink