Implement idle task scheduling.

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/Task.h"
 #include "platform/ThreadTimers.h"
 #include "platform/TraceEvent.h"
 #include "public/platform/Platform.h"
 #include "wtf/MainThread.h"
 
 namespace blink {
 
 namespace {
 
 // The time we should stay in CompositorPriority mode for, after a touch event.
 double kLowSchedulerPolicyAfterTouchTimeSeconds = 0.1;
 
-// Can be created from any thread.
-// Note if the scheduler gets shutdown, this may be run after.
-class MainThreadIdleTaskAdapter : public WebThread::Task {
-public:
-    MainThreadIdleTaskAdapter(const Scheduler::IdleTask& idleTask, double allottedTimeMs, const TraceLocation& location)
-        : m_idleTask(idleTask)
-        , m_allottedTimeMs(allottedTimeMs)
-        , m_location(location)
-    {
-    }
-
-    // WebThread::Task implementation.
-    virtual void run() OVERRIDE
-    {
-        TRACE_EVENT2("blink", "MainThreadIdleTaskAdapter::run",
-            "src_file", m_location.fileName(),
-            "src_func", m_location.functionName());
-        m_idleTask(m_allottedTimeMs);
-    }
-
-private:
-    Scheduler::IdleTask m_idleTask;
-    double m_allottedTimeMs;
-    TraceLocation m_location;
-};
-
 } // namespace
 
 // Typically only created from compositor or render threads.
 // Note if the scheduler gets shutdown, this may be run after.
 class Scheduler::MainThreadPendingHighPriorityTaskRunner : public WebThread::Task {
 public:
     MainThreadPendingHighPriorityTaskRunner()
     {
         ASSERT(Scheduler::shared());
     }
@@ skipping 21 matching lines @@
         const Scheduler::Task& task, const TraceLocation& location, const char* traceName)
         : m_task(task, location, traceName)
     {
         ASSERT(Scheduler::shared());
     }
 
     // WebThread::Task implementation.
     virtual void run() OVERRIDE
     {
         Scheduler* scheduler = Scheduler::shared();
-        // FIXME: This check should't be necessary, tasks should not outlive blink.
+        // FIXME: This check shouldn't be necessary, tasks should not outlive blink.
         ASSERT(scheduler);
         if (scheduler)
-            Scheduler::shared()->runPendingHighPriorityTasksIfInCompositorPriority();
+            scheduler->runPendingHighPriorityTasksIfInCompositorPriority();
+
         m_task.run();
     }
 
-    TracedTask m_task;
+private:
+    TracedStandardTask m_task;
 };
 
+
+// Can be created from any thread.
+// Note if the scheduler gets shutdown, this may be run after.
+class Scheduler::MainThreadPendingIdleTaskRunner : public WebThread::Task {
+public:
+    MainThreadPendingIdleTaskRunner(const TracedIdleTask& idleTask)
+        : m_idleTask(idleTask)
+    {
+        ASSERT(Scheduler::shared());
+    }
+
+    // WebThread::Task implementation.
+    virtual void run() OVERRIDE
+    {
+        Scheduler* scheduler = Scheduler::shared();
+        // FIXME: This check shouldn't be necessary, tasks should not outlive blink.
+        ASSERT(scheduler);
+        if (scheduler) {
+            scheduler->runPendingHighPriorityTasksIfInCompositorPriority();
+
+            if (scheduler->canRunIdleTask()) {
+                m_idleTask.run();
+                // Run the next idle task if possible.
+                scheduler->maybeExecuteIdleTask();
+            } else {
+                scheduler->repostIdleTask(m_idleTask);
+            }
+        }
+    }
+
+private:
+    TracedIdleTask m_idleTask;
+};
+
+
 Scheduler* Scheduler::s_sharedScheduler = nullptr;
 
 void Scheduler::initializeOnMainThread()
 {
     s_sharedScheduler = new Scheduler();
 }
 
 void Scheduler::shutdown()
 {
     delete s_sharedScheduler;
     s_sharedScheduler = nullptr;
 }
 
 Scheduler* Scheduler::shared()
 {
     return s_sharedScheduler;
 }
 
 Scheduler::Scheduler()
     : m_sharedTimerFunction(nullptr)
     , m_mainThread(blink::Platform::current()->currentThread())
     , m_compositorPriorityPolicyEndTimeSeconds(0)
+    , m_currentFrameDeadlineSeconds(0)
     , m_highPriorityTaskCount(0)
     , m_highPriorityTaskRunnerPosted(false)
     , m_schedulerPolicy(Normal)
 {
 }
 
 Scheduler::~Scheduler()
 {
     while (hasPendingHighPriorityWork()) {
         swapQueuesAndRunPendingTasks();
     }
 }
 
-void Scheduler::willBeginFrame(const WebBeginFrameArgs& args)
+void Scheduler::willBeginFrame(double frameDeadlineSeconds)
 {
-    // TODO: Use frame deadline and interval to schedule idle tasks.
+    m_currentFrameCommitted = false;
+    m_currentFrameDeadlineSeconds = frameDeadlineSeconds;
+
+    // TODO: Schedule a deferred task here to run idle work if didCommitFrameToCompositor never get's called
 }
 
 void Scheduler::didCommitFrameToCompositor()
 {
-    // TODO: Trigger the frame deadline immediately.
-}
-
-void Scheduler::scheduleIdleTask(const TraceLocation& location, const IdleTask& idleTask)
-{
-    // TODO: send a real allottedTime here.
-    m_mainThread->postTask(new MainThreadIdleTaskAdapter(idleTask, 0, location));
+    m_currentFrameCommitted = true;
+    maybeExecuteIdleTask();
 }
 
 void Scheduler::postHighPriorityTaskInternal(const TraceLocation& location, const Task& task, const char* traceName)
 {
     Locker<Mutex> lock(m_pendingTasksMutex);
 
-    m_pendingHighPriorityTasks.append(TracedTask(task, location, traceName));
+    m_pendingHighPriorityTasks.append(TracedStandardTask(task, location, traceName));
     atomicIncrement(&m_highPriorityTaskCount);
     maybePostMainThreadPendingHighPriorityTaskRunner();
     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_pendingTasksMutex);
+    m_pendingIdleTasks.append(TracedIdleTask(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");
 }
 
 void Scheduler::didReceiveInputEvent()
 {
     enterSchedulerPolicy(CompositorPriority);
 }
 
 void Scheduler::postCompositorTask(const TraceLocation& location, const Task& task)
 {
     postHighPriorityTaskInternal(location, task, "Scheduler::CompositorTask");
 }
 
 void Scheduler::postIpcTask(const TraceLocation& location, const Task& task)
 {
     // FIXME: we want IPCs to be high priority, but we can't currently do that because some of them can take a very long
     // time to process. These need refactoring but we need to add some infrastructure to identify them.
     m_mainThread->postTask(new MainThreadPendingTaskRunner(task, location, "Scheduler::IpcTask"));
 }
 
+void Scheduler::postIdleTask(const TraceLocation& location, const IdleTask& idleTask)
+{
+    postIdleTaskInternal(location, idleTask, "Scheduler::IdleTask");
+}
+
 void Scheduler::maybePostMainThreadPendingHighPriorityTaskRunner()
 {
     ASSERT(m_pendingTasksMutex.locked());
     if (m_highPriorityTaskRunnerPosted)
         return;
     m_mainThread->postTask(new MainThreadPendingHighPriorityTaskRunner());
     m_highPriorityTaskRunnerPosted = true;
 }
 
-void Scheduler::postIdleTask(const TraceLocation& location, const IdleTask& idleTask)
-{
-    scheduleIdleTask(location, idleTask);
-}
 
 void Scheduler::tickSharedTimer()
 {
     TRACE_EVENT0("blink", "Scheduler::tickSharedTimer");
 
     // Run any high priority tasks that are queued up, otherwise the blink timers will yield immediately.
     bool workDone = runPendingHighPriorityTasksIfInCompositorPriority();
     m_sharedTimerFunction();
 
     // The blink timers may have just yielded, so run any high priority tasks that where queued up
@@ skipping 11 matching lines @@
     return swapQueuesAndRunPendingTasks();
 }
 
 bool Scheduler::swapQueuesAndRunPendingTasks()
 {
     ASSERT(isMainThread());
 
     // These locks guard against another thread posting input or compositor tasks while we swap the buffers.
     // One the buffers have been swapped we can safely access the returned deque without having to lock.
     m_pendingTasksMutex.lock();
-    Deque<TracedTask>& highPriorityTasks = m_pendingHighPriorityTasks.swapBuffers();
+    Deque<TracedStandardTask>& highPriorityTasks = m_pendingHighPriorityTasks.swapBuffers();
     maybeEnterNormalSchedulerPolicy();
     m_pendingTasksMutex.unlock();
     return executeHighPriorityTasks(highPriorityTasks);
 }
 
 void Scheduler::swapQueuesRunPendingTasksAndAllowHighPriorityTaskRunnerPosting()
 {
     ASSERT(isMainThread());
 
     // These locks guard against another thread posting input or compositor tasks while we swap the buffers.
     // One the buffers have been swapped we can safely access the returned deque without having to lock.
     m_pendingTasksMutex.lock();
-    Deque<TracedTask>& highPriorityTasks = m_pendingHighPriorityTasks.swapBuffers();
+    Deque<TracedStandardTask>& highPriorityTasks = m_pendingHighPriorityTasks.swapBuffers();
     m_highPriorityTaskRunnerPosted = false;
     maybeEnterNormalSchedulerPolicy();
     m_pendingTasksMutex.unlock();
     executeHighPriorityTasks(highPriorityTasks);
 }
 
 void Scheduler::maybeEnterNormalSchedulerPolicy()
 {
     ASSERT(isMainThread());
     ASSERT(m_pendingTasksMutex.locked());
 
     // Go back to the normal scheduler policy if enough time has elapsed.
     if (schedulerPolicy() == CompositorPriority && Platform::current()->monotonicallyIncreasingTime() > m_compositorPriorityPolicyEndTimeSeconds)
         enterSchedulerPolicyLocked(Normal);
 }
 
-bool Scheduler::executeHighPriorityTasks(Deque<TracedTask>& highPriorityTasks)
+bool Scheduler::executeHighPriorityTasks(Deque<TracedStandardTask>& highPriorityTasks)
 {
     TRACE_EVENT0("blink", "Scheduler::executeHighPriorityTasks");
     int highPriorityTasksExecuted = 0;
     while (!highPriorityTasks.isEmpty()) {
         highPriorityTasks.takeFirst().run();
         highPriorityTasksExecuted++;
     }
 
     int highPriorityTaskCount = atomicSubtract(&m_highPriorityTaskCount, highPriorityTasksExecuted);
     ASSERT_UNUSED(highPriorityTaskCount, highPriorityTaskCount >= 0);
     TRACE_COUNTER1(TRACE_DISABLED_BY_DEFAULT("blink.scheduler"), "PendingHighPriorityTasks", m_highPriorityTaskCount);
     return highPriorityTasksExecuted > 0;
 }
 
+bool Scheduler::maybeExecuteIdleTask()
+{
+    TRACE_EVENT0("blink", "Scheduler::maybeExecuteIdleTask");
+    if (canRunIdleTask()) {
+        Locker<Mutex> lock(m_pendingTasksMutex);
+        if (!m_pendingIdleTasks.isEmpty()) {
+            m_mainThread->postTask(new MainThreadPendingIdleTaskRunner(m_pendingIdleTasks.takeFirst()));
+            return true;
+        }
+    }

[picksi1, 2014/09/30 09:13:51]

Is this function correctly named? It isn't actually executing the idle task -
it's asking the main thread to try and run it at some future point. 

Does the canRunIdleTask() make sense here? Isn't this function only called if
canRunIdleTask()==true, and the actual task will only be executed following a
subsequent canRunIdleTask() check anyway.

[rmcilroy, 2014/09/30 09:56:19]

Yes it's tricky to name - I originally had maybeScheduleIdleTask but felt that
was confusing (since the task is already scheduled to be executed).  I've
renamed to maybePostMainThreadPendingIdleTask in order to fit with
maybePostMainThreadPendingHighPriorityTaskRunner. WDYT?
No, this can be called from didCommitFrameToCompositor after the deadline for
the next frame has already passed, or from MainThreadPendingIdleTaskRunner after
it has run a task, which may have caused the current time to move passed the
deadline.  I think it makes most sense to check canRunIdleTask here explicitly
rather than having to ensure we check it explicitly before calling this
function.

[picksi1, 2014/09/30 12:34:00]

maybePostMainThreadPendingHighPriorityTaskRunner() is a mouthful but is clear as
to what it's doing! LGTM.

+    return false;
+}
+
+void Scheduler::repostIdleTask(const TracedIdleTask& idleTask)
+{
+    Locker<Mutex> lock(m_pendingTasksMutex);
+    // Post at the front since the task didn't get a chance to run.
+    m_pendingIdleTasks.prepend(idleTask);
+}
+

[picksi1, 2014/09/30 09:13:51]

Should this be called repostAtFront (etc) or something that makes clear what
it's doing?

[rmcilroy, 2014/09/30 09:56:19]

Done.

 void Scheduler::sharedTimerAdapter()
 {
     shared()->tickSharedTimer();
 }
 
 void Scheduler::setSharedTimerFiredFunction(void (*function)())
 {
     m_sharedTimerFunction = function;
     blink::Platform::current()->setSharedTimerFiredFunction(function ? &Scheduler::sharedTimerAdapter : nullptr);
 }
@@ skipping 20 matching lines @@
 bool Scheduler::hasPendingHighPriorityWork() const
 {
     // This method is expected to be run on the main thread, but the high priority tasks will be posted by
     // 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;
 }
 
+double Scheduler::currentFrameDeadlineSeconds() const
+{
+    return m_currentFrameDeadlineSeconds;
+}
+
+bool Scheduler::canRunIdleTask() const
+{
+    return m_currentFrameCommitted && (m_currentFrameDeadlineSeconds > Platform::current()->monotonicallyIncreasingTime());
+}
+
 Scheduler::SchedulerPolicy Scheduler::schedulerPolicy() const
 {
     ASSERT(isMainThread());
     // It's important not to miss the transition from normal to low latency mode, otherwise we're likely to
     // delay the processing of input tasks. Since that transition is triggered by a different thread, we
     // need either a lock or a memory barrier, and the memory barrier is probably cheaper.
     return static_cast<SchedulerPolicy>(acquireLoad(&m_schedulerPolicy));
 }
 
 void Scheduler::enterSchedulerPolicy(SchedulerPolicy schedulerPolicy)
 {
     Locker<Mutex> lock(m_pendingTasksMutex);
     enterSchedulerPolicyLocked(schedulerPolicy);
 }
 
 void Scheduler::enterSchedulerPolicyLocked(SchedulerPolicy schedulerPolicy)
 {
     ASSERT(m_pendingTasksMutex.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