Prioritizing input and compositor tasks in the blink scheduler.

Source/platform/scheduler/Scheduler.h

Index: Source/platform/scheduler/Scheduler.h
diff --git a/Source/platform/scheduler/Scheduler.h b/Source/platform/scheduler/Scheduler.h
index c492e580aa17268afe30b6c439a9c08acd08638f..69ad86d00abdbe0a24c7d90ef6d0837e742e0370 100644
--- a/Source/platform/scheduler/Scheduler.h
+++ b/Source/platform/scheduler/Scheduler.h
@@ -6,8 +6,12 @@
 #define Scheduler_h
 
 #include "platform/PlatformExport.h"
+#include "platform/TraceLocation.h"
+#include "platform/scheduler/AtomicRingbuffer.h"
+#include "wtf/Deque.h"
 #include "wtf/Functional.h"
 #include "wtf/Noncopyable.h"
+#include "wtf/ThreadingPrimitives.h"
 
 namespace blink {
 class WebThread;
@@ -35,9 +39,11 @@ public:
     // to be run on the main thread. They can be called from any thread.
     void postInputTask(const TraceLocation&, const Task&);
     void postCompositorTask(const TraceLocation&, const Task&);
-    void postTask(const TraceLocation&, const Task&); // For generic (low priority) tasks.
     void postIdleTask(const IdleTask&); // For non-critical tasks which may be reordered relative to other task types.
 
+    // For generic (low priority) tasks, can only be called from the main thread.
+    void postTask(const TraceLocation&, const Task&);
+
     // Returns true if there is high priority work pending on the main thread
     // and the caller should yield to let the scheduler service that work.
     // Can be called on the main thread.
@@ -49,11 +55,13 @@ public:
     void setSharedTimerFireInterval(double);
     void stopSharedTimer();
 
+    void runPendingTasks();
+    void allowMainThreadTaskPosting();
+
 private:
     Scheduler();
     ~Scheduler();
 
-    void scheduleTask(const TraceLocation&, const Task&);
     void scheduleIdleTask(const IdleTask&);
 
     static void sharedTimerAdapter();
@@ -62,6 +70,31 @@ private:
     static Scheduler* s_sharedScheduler;
     blink::WebThread* m_mainThread;
 
+    class TracedTask {
+    public:
+        TracedTask(Task task, TraceLocation location) : m_task(task), m_location(location) { }

[Sami, 2014/08/06 10:19:52]

nit: Initializer style.

[alexclarke, 2014/08/07 12:08:06]

Done.

+
+        void run();
+
+    private:
+        Task m_task;
+        TraceLocation m_location;
+    };
+
+    // The input and compositor task queues can be posted to from any thread.
+    AtomicRingBuffer<TracedTask, 128> m_pendingInputTasks;

[Sami, 2014/08/06 10:19:52]

One pattern we could steal from cc/ is to put members into different structs
depending on which thread they are accessed from. For example, there's a
MainThreadOnly struct and a main() function that returns a reference to it and
also asserts the caller is on the main thread. Maybe here we could have a struct
for the shared state and everything else would be main thread only. WDYT?

[alexclarke, 2014/08/07 12:08:06]

I quite like that pattern, however I don't think we need it yet.  I've found a
way to eliminate the need for the WTF::Deque - if one of the ring buffers
becomes full, we'll fall back to using the MainThreadTaskAdapter to process
tasks, so it's now safe for m_pendingLowPriorityTasks to be an AtomicRingBuffer
since it no longer spinlocks when full.

+    AtomicRingBuffer<TracedTask, 128> m_pendingCompositorTasks;
+
+    // Blink tasks can only be posted on the main thread.
+    WTF::Deque<TracedTask> m_pendingBlinkTasks;

[Sami, 2014/08/06 10:19:52]

m_pendingLowPriorityTasks or something?

[alexclarke, 2014/08/07 12:08:06]

Done.

+
+    volatile int m_mainThreadTaskPosted;
+    volatile int m_blinkShouldNotYield;
+
+    void setBlinkShouldYield();

[Sami, 2014/08/06 10:19:52]

How about setHighPriorityWorkPending to match shouldYieldForHighPriorityWork?

[alexclarke, 2014/08/07 12:08:06]

I've decided not to use atomics, nailing down all the corner cases was getting
too complicated.

+    void clearBlinkShouldYield();
+    void maybePostTaskLoopOnMainThread();
+
     void (*m_sharedTimerFunction)();
 };