Modify the scheduler to queue idle work between idle periods.

Source/platform/scheduler/Scheduler.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "platform/scheduler/Scheduler.h"
 
 #include "platform/PlatformThreadData.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/Task.h"
@@ skipping 121 matching lines @@
     ASSERT(isMainThread());
     m_currentFrameCommitted = false;
     m_estimatedNextBeginFrameSeconds = estimatedNextBeginFrameSeconds;
     // TODO: Schedule a deferred task here to run idle work if didCommitFrameToCompositor never gets called.
 }
 
 void Scheduler::didCommitFrameToCompositor()
 {
     ASSERT(isMainThread());
     m_currentFrameCommitted = true;
+    flushIncomingIdleTasks();
     maybePostMainThreadPendingIdleTask();
 }
 
 void Scheduler::postHighPriorityTaskInternal(const TraceLocation& location, const Task& task, const char* traceName)
 {
     m_mainThread->postTask(new MainThreadPendingHighPriorityTaskRunner(task, location, traceName));
     atomicIncrement(&m_highPriorityTaskCount);
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.scheduler"), "PendingHighPriorityTasks", m_highPriorityTaskCount);
 }
 
 void Scheduler::didRunHighPriorityTask()
 {
     atomicDecrement(&m_highPriorityTaskCount);
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.scheduler"), "PendingHighPriorityTasks", m_highPriorityTaskCount);
 }
 
 void Scheduler::postIdleTaskInternal(const TraceLocation& location, const IdleTask& idleTask, const char* traceName)
 {
-    Locker<Mutex> lock(m_pendingIdleTasksMutex);
-    m_pendingIdleTasks.append(internal::TracedIdleTask::Create(idleTask, location, traceName));
+    Locker<Mutex> lock(m_incomingIdleTasksMutex);
+    m_incomingIdleTasks.append(internal::TracedIdleTask::Create(idleTask, location, traceName));
 }
 
 void Scheduler::postTask(const TraceLocation& location, const Task& task)
 {
     m_mainThread->postTask(new MainThreadPendingTaskRunner(task, location, "Scheduler::MainThreadTask"));
 }
 
 void Scheduler::postInputTask(const TraceLocation& location, const Task& task)
 {
     postHighPriorityTaskInternal(location, task, "Scheduler::InputTask");
@@ skipping 21 matching lines @@
 void Scheduler::postIdleTask(const TraceLocation& location, const IdleTask& idleTask)
 {
     postIdleTaskInternal(location, idleTask, "Scheduler::IdleTask");
 }
 
 bool Scheduler::maybePostMainThreadPendingIdleTask()
 {
     ASSERT(isMainThread());
     TRACE_EVENT0("blink", "Scheduler::maybePostMainThreadPendingIdleTask");
     if (canRunIdleTask()) {
-        Locker<Mutex> lock(m_pendingIdleTasksMutex);
         if (!m_pendingIdleTasks.isEmpty()) {
             m_mainThread->postTask(new MainThreadPendingIdleTaskRunner());
             return true;
         }
     }
     return false;
 }
 
 void Scheduler::tickSharedTimer()
 {
@@ skipping 42 matching lines @@
     // other threads. We could use locks here, but this function is (sometimes) called a lot by
     // ThreadTimers::sharedTimerFiredInternal so we decided to use atomics + barrier loads here which
     // should be cheaper.
     // NOTE it's possible the barrier read is overkill here, since delayed yielding isn't a big deal.
     return acquireLoad(&m_highPriorityTaskCount) != 0;
 }
 
 bool Scheduler::maybeRunPendingIdleTask()
 {
     ASSERT(isMainThread());
-    if (!canRunIdleTask())
+    if (!canRunIdleTask() || m_pendingIdleTasks.isEmpty())
         return false;
 
-    takeFirstPendingIdleTask()->run();
+    m_pendingIdleTasks.takeFirst()->run();
     return true;
 }
 
-PassOwnPtr<internal::TracedIdleTask> Scheduler::takeFirstPendingIdleTask()
+void Scheduler::flushIncomingIdleTasks()
 {
-    Locker<Mutex> lock(m_pendingIdleTasksMutex);
-    ASSERT(!m_pendingIdleTasks.isEmpty());
-    return m_pendingIdleTasks.takeFirst();
+    ASSERT(isMainThread());
+    Locker<Mutex> lock(m_incomingIdleTasksMutex);

[Sami, 2014/10/10 17:31:31]

I'm trying to decide whether we should only do this when the pending queue
becomes empty. If we did that, we could potentially need to flush less, but we'd
run the risk of draining the pending queue and delaying posted tasks until the
next frame. WDYT?

[rmcilroy, 2014/10/13 11:41:19]

I don't think it would make much of a difference either way.  I'd prefer to keep
it this way for now since it's simpler, but happy to change to the other
approach once your CL lands if it makes it easier.

+    if (m_incomingIdleTasks.isEmpty())
+        return;
+

[picksi1, 2014/10/13 09:38:09]

Is it worth doing this empty check here? The following code will fall through
anyway and it bulks the code.

[rmcilroy, 2014/10/13 11:41:19]

Makes sense, dropped it.

+    while (!m_incomingIdleTasks.isEmpty()) {

[jochen (gone - plz use gerrit), 2014/10/13 08:09:11]

nit. no { }

what happens if the idle task immediately posts a new idle task?

Maybe make a copy of the queue first, and just process the queue?

[rmcilroy, 2014/10/13 11:41:19]

If the idle task immediately posts a new task it will go into the incoming task
queue and only get run after that is flushed to the pending tasks queue.  No
tasks can get posted while we hold the lock, and no idle tasks get executed
until we have finished with this flush function. 

I'm not sure what you mean about taking a copy of the queue - this is
effectively what we are doing by having a separate incoming and pending queue -
could you clarify what you mean here? 

+        m_pendingIdleTasks.append(m_incomingIdleTasks.takeFirst());
+    }

[picksi1, 2014/10/13 09:38:09]

Is there no quick way to append the entire queue here, rather than iterating
task by task?

[rmcilroy, 2014/10/13 11:41:19]

I couldn't find any faster append in Deque - let me know if you know of any?

 }
 
 double Scheduler::currentFrameDeadlineForIdleTasks() const
 {
     ASSERT(isMainThread());
     // TODO: Make idle time more fine-grain chunks when in Compositor priority.
     return m_estimatedNextBeginFrameSeconds;
 }
 
 bool Scheduler::canRunIdleTask() const
@@ skipping 23 matching lines @@
 {
     ASSERT(m_policyStateMutex.locked());
     if (schedulerPolicy == CompositorPriority)
         m_compositorPriorityPolicyEndTimeSeconds = Platform::current()->monotonicallyIncreasingTime() + kLowSchedulerPolicyAfterTouchTimeSeconds;
 
     releaseStore(&m_schedulerPolicy, schedulerPolicy);
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.scheduler"), "SchedulerPolicy", schedulerPolicy);
 }
 
 } // namespace blink