Adding flow traces for blink scheduler events

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"
@@ skipping 55 matching lines @@
         scheduler->swapQueuesRunPendingTasksAndAllowHighPriorityTaskRunnerPosting();
     }
 };
 
 
 // Can be created from any thread.
 // Note if the scheduler gets shutdown, this may be run after.
 class Scheduler::MainThreadPendingTaskRunner : public WebThread::Task {
 public:
     MainThreadPendingTaskRunner(
-        const Scheduler::Task& task, const TraceLocation& location)
-        : m_task(task, location)
+        const Scheduler::Task& task, const TraceLocation& location, const char* traceName, int flowTraceID)
+        : m_task(task, location, traceName, flowTraceID)
     {
         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.
         ASSERT(scheduler);
         if (scheduler)
             Scheduler::shared()->swapQueuesAndRunPendingTasks();
         m_task.run();
     }
 
-    Scheduler::TracedTask m_task;
+    TracedTask m_task;
 };
 
 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_highPriorityTaskCount(0)
+    // flow trace ID begins as the 'this' pointer to help ensure different scheduler

[Sami, 2014/09/01 13:51:29]

nit: Start with capital 'f'.

[picksi1, 2014/09/01 15:02:32]

Done.

+    // instances don't generate identical IDs
+    , m_nextFlowTraceID(static_cast<int>(reinterpret_cast<intptr_t>(this)))
     , m_highPriorityTaskRunnerPosted(false)
 {
 }
 
 Scheduler::~Scheduler()
 {
     while (hasPendingHighPriorityWork()) {
         swapQueuesAndRunPendingTasks();
     }
 }
 
+int Scheduler::generateFlowTraceID()
+{
+    return atomicIncrement(&m_nextFlowTraceID);
+}
+
 void Scheduler::scheduleIdleTask(const TraceLocation& location, const IdleTask& idleTask)
 {
     // TODO: send a real allottedTime here.
     m_mainThread->postTask(new MainThreadIdleTaskAdapter(idleTask, 0, location));
 }
 
+void Scheduler::postHighPriorityTaskInternal(const TraceLocation& location, const Task& task, const char * traceName)

[Sami, 2014/09/01 13:51:29]

No space before "*". I think "git cl format" may be able to sort these out
automatically.

[picksi1, 2014/09/01 15:02:32]

Done. FYI "git cl format" messed up indentation of follow-on lines (e.g. when
parameters to a function are split across lines), indenting the additional
parameters to line up with the first parameter, not a 4-space indentation.

+{
+    Locker<Mutex> lock(m_pendingTasksMutex);
+
+    m_pendingHighPriorityTasks.append(TracedTask(task, location, traceName, generateFlowTraceID()));
+    atomicIncrement(&m_highPriorityTaskCount);
+    maybePostMainThreadPendingHighPriorityTaskRunner();
+}
+
 void Scheduler::postTask(const TraceLocation& location, const Task& task)
 {
-    m_mainThread->postTask(new MainThreadPendingTaskRunner(task, location));
+    m_mainThread->postTask(new MainThreadPendingTaskRunner(task, location, "Scheduler::MainThreadTask", generateFlowTraceID()));
 }
 
 void Scheduler::postInputTask(const TraceLocation& location, const Task& task)
 {
-    Locker<Mutex> lock(m_pendingTasksMutex);
-    m_pendingHighPriorityTasks.append(TracedTask(task, location));
-    atomicIncrement(&m_highPriorityTaskCount);
-    maybePostMainThreadPendingHighPriorityTaskRunner();
+    postHighPriorityTaskInternal(location, task, "Scheduler::InputTask");
 }
 
 void Scheduler::postCompositorTask(const TraceLocation& location, const Task& task)
 {
-    Locker<Mutex> lock(m_pendingTasksMutex);
-    m_pendingHighPriorityTasks.append(TracedTask(task, location));
-    atomicIncrement(&m_highPriorityTaskCount);
-    maybePostMainThreadPendingHighPriorityTaskRunner();
+    postHighPriorityTaskInternal(location, task, "Scheduler::CompositorTask");
 }
 
 void Scheduler::maybePostMainThreadPendingHighPriorityTaskRunner()
 {
     ASSERT(m_pendingTasksMutex.locked());
     if (m_highPriorityTaskRunnerPosted)
         return;
     m_mainThread->postTask(new MainThreadPendingHighPriorityTaskRunner());
     m_highPriorityTaskRunnerPosted = true;
 }
@@ skipping 85 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;
 }
 
-void Scheduler::TracedTask::run()
-{
-    TRACE_EVENT2("blink", "TracedTask::run",
-        "src_file", m_location.fileName(),
-        "src_func", m_location.functionName());
-    m_task();
-}
-
 } // namespace blink