Oilpan: Split completeSweep() in idle tasks into chunks

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 591 matching lines @@
     if (threadState()->isMainThread())
         ScriptForbiddenScope::enter();
 
     Address result = lazySweepPages(allocationSize, gcInfoIndex);
 
     if (threadState()->isMainThread())
         ScriptForbiddenScope::exit();
     return result;
 }
 
+void BaseHeap::sweepUnsweptPage()
+{
+    BasePage* page = m_firstUnsweptPage;
+    if (page->isEmpty()) {
+        page->unlink(&m_firstUnsweptPage);
+        page->removeFromHeap();
+    } else {
+        // Sweep a page and move the page from m_firstUnsweptPages to
+        // m_firstPages.
+        page->sweep();
+        page->unlink(&m_firstUnsweptPage);
+        page->link(&m_firstPage);
+        page->markAsSwept();
+    }
+}
+
+bool BaseHeap::lazySweepWithDeadline(double deadlineSeconds)
+{
+    RELEASE_ASSERT(threadState()->isSweepingInProgress());
+    ASSERT(threadState()->sweepForbidden());
+
+    int pageCount = 1;
+    while (m_firstUnsweptPage) {
+        sweepUnsweptPage();
+        // It might be heavy to call Platform::current()->monotonicallyIncreasingTime()
+        // per page (i.e., 128 KB sweep or one LargeObject sweep), so we check
+        // the deadline per 10 pages.
+        if (pageCount % 10 == 0) {
+            if (deadlineSeconds <= Platform::current()->monotonicallyIncreasingTime()) {

[rmcilroy, 2015/03/31 13:01:30]

Could we add some slack here (e.g., deadlineSeconds - 0.01 <= currentTime)? Do
we have some idea for how much time sweeping a page takes in general?

[haraken, 2015/03/31 13:07:45]

That is a hard question to answer since the time totally depends on the page
contents (it might be just 10 LargeObjects; we can sweep them extremely quickly)
and the actual hardware.

What value do you recommend for the slack? 0.01 sounds too big to me because the
frame budget is less than 0.01 second in most cases, isn't it?

[rmcilroy, 2015/03/31 13:19:26]

Right I thought this might be the case.
Yes that's probably too big. I was thinking of about 1ms or so (0.001 seconds).
WDYT? Once this has landed it should be possible to see if the task is blowing
the budget in telemetry / tracing (I'm not sure whether you have telemetry
measurements which measure the idle time metrics, but you could do something
similar to the V8 benchmarks at
https://code.google.com/p/chromium/codesearch#chromium/src/tools/perf/measure...
if you wanted to track how well you keep to the budget / make use of idle time).

+                return false;
+            }
+        }
+        pageCount++;
+    }
+    return true;
+}
+
 void BaseHeap::completeSweep()
 {
     RELEASE_ASSERT(threadState()->isSweepingInProgress());
     ASSERT(threadState()->sweepForbidden());
 
-    if (threadState()->isMainThread())
-        ScriptForbiddenScope::enter();
-
     while (m_firstUnsweptPage) {
-        BasePage* page = m_firstUnsweptPage;
-        if (page->isEmpty()) {
-            page->unlink(&m_firstUnsweptPage);
-            page->removeFromHeap();
-        } else {
-            // Sweep a page and move the page from m_firstUnsweptPages to
-            // m_firstPages.
-            page->sweep();
-            page->unlink(&m_firstUnsweptPage);
-            page->link(&m_firstPage);
-            page->markAsSwept();
-        }
+        sweepUnsweptPage();
     }
-
-    if (threadState()->isMainThread())
-        ScriptForbiddenScope::exit();
 }
 
 NormalPageHeap::NormalPageHeap(ThreadState* state, int index)
     : BaseHeap(state, index)
     , m_currentAllocationPoint(nullptr)
     , m_remainingAllocationSize(0)
     , m_lastRemainingAllocationSize(0)
     , m_promptlyFreedSize(0)
 #if ENABLE(GC_PROFILING)
     , m_cumulativeAllocationSize(0)
@@ skipping 2201 matching lines @@
 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;
 double Heap::s_markingTimeInLastGC = 0.0;
 
 } // namespace blink