Bug 1746361 - Gecko Profiler: Track wrapped runnables throughout the tree. r=gerald

The Runnable markers in the profilers are handy, but miss many types of
runnables. This includes most of those that wrap another runnable and run that
at a (possibly) later time.

AbstractThread, TaskDispatcher and TaskQueue does this for e.g. tail dispatched
tasks.

TaskQueueWrapper does this when wrapping webrtc tasks (and Mozilla Runnables) to
be run in a Mozilla TaskQueue with some overhead on the stack.

DelayedRunnable wraps a runnable to be run after a timeout.

It would perhaps be better in many cases to ignore the intermediate runnables,
but I haven't seen a straight forward way to achieve this.

More detailed data could be added on a case by case basis, for instance the
delay for a DelayedRunnable (incl. actual vs. target delay) or the scope of a
task in which a tail-dispatched runnable was dispatched. But this is also true
for the status quo (for instance the time from dispatch to run) so I leave these
ideas as future work.

Differential Revision: https://phabricator.services.mozilla.com/D135027

Author: Pehrsons

dom/media/webrtc/libwebrtcglue/TaskQueueWrapper.h

@@ -8,6 +8,7 @@
 
 #include "api/task_queue/task_queue_factory.h"
 #include "mozilla/DataMutex.h"
+#include "mozilla/ProfilerRunnable.h"
 #include "mozilla/TaskQueue.h"
 #include "VideoUtils.h"
 
@@ -25,8 +26,8 @@ namespace mozilla {
  */
 class TaskQueueWrapper : public webrtc::TaskQueueBase {
  public:
-  explicit TaskQueueWrapper(RefPtr<TaskQueue> aTaskQueue)
-      : mTaskQueue(std::move(aTaskQueue)) {}
+  TaskQueueWrapper(RefPtr<TaskQueue> aTaskQueue, nsCString aName)
+      : mTaskQueue(std::move(aTaskQueue)), mName(std::move(aName)) {}
   ~TaskQueueWrapper() = default;
 
   void Delete() override {
@@ -44,18 +45,22 @@ class TaskQueueWrapper : public webrtc::TaskQueueBase {
 
   already_AddRefed<Runnable> CreateTaskRunner(
       std::unique_ptr<webrtc::QueuedTask> aTask) {
-    return NS_NewRunnableFunction("TaskQueueWrapper::CreateTaskRunner",
-                                  [this, task = std::move(aTask)]() mutable {
-                                    CurrentTaskQueueSetter current(this);
-                                    auto hasShutdown = mHasShutdown.Lock();
-                                    if (*hasShutdown) {
-                                      return;
-                                    }
-                                    bool toDelete = task->Run();
-                                    if (!toDelete) {
-                                      task.release();
-                                    }
-                                  });
+    return NS_NewRunnableFunction(
+        "TaskQueueWrapper::CreateTaskRunner",
+        [this, task = std::move(aTask),
+         name = nsPrintfCString("TQ %s: webrtc::QueuedTask",
+                                mName.get())]() mutable {
+          CurrentTaskQueueSetter current(this);
+          auto hasShutdown = mHasShutdown.Lock();
+          if (*hasShutdown) {
+            return;
+          }
+          AUTO_PROFILE_FOLLOWING_RUNNABLE(name);
+          bool toDelete = task->Run();
+          if (!toDelete) {
+            task.release();
+          }
+        });
   }
 
   already_AddRefed<Runnable> CreateTaskRunner(nsCOMPtr<nsIRunnable> aRunnable) {
@@ -67,6 +72,7 @@ class TaskQueueWrapper : public webrtc::TaskQueueBase {
           if (*hasShutdown) {
             return;
           }
+          AUTO_PROFILE_FOLLOWING_RUNNABLE(runnable);
           runnable->Run();
         });
   }
@@ -88,6 +94,7 @@ class TaskQueueWrapper : public webrtc::TaskQueueBase {
   }
 
   const RefPtr<TaskQueue> mTaskQueue;
+  const nsCString mName;
 
   // This is a recursive mutex because a TaskRunner holding this mutex while
   // running its runnable may end up running other - tail dispatched - runnables
@@ -119,7 +126,7 @@ class SharedThreadPoolWebRtcTaskQueueFactory : public webrtc::TaskQueueFactory {
     nsCString name(aName.data(), aName.size());
     auto taskQueue = MakeRefPtr<TaskQueue>(GetMediaThreadPool(aThreadType),
                                            name.get(), aSupportTailDispatch);
-    return MakeUnique<TaskQueueWrapper>(std::move(taskQueue));
+    return MakeUnique<TaskQueueWrapper>(std::move(taskQueue), std::move(name));
   }
 
   std::unique_ptr<webrtc::TaskQueueBase, webrtc::TaskQueueDeleter>

media/webrtc/signaling/gtest/mediapipeline_unittest.cpp

@@ -52,8 +52,10 @@ namespace {
 class MainAsCurrent : public TaskQueueWrapper {
  public:
   MainAsCurrent()
-      : TaskQueueWrapper(MakeRefPtr<TaskQueue>(
-            do_AddRef(GetMainThreadEventTarget()), "MainAsCurrentTaskQueue")),
+      : TaskQueueWrapper(
+            MakeRefPtr<TaskQueue>(do_AddRef(GetMainThreadEventTarget()),
+                                  "MainAsCurrentTaskQueue"),
+            "MainAsCurrent"_ns),
         mSetter(this) {
     MOZ_RELEASE_ASSERT(NS_IsMainThread());
   }

xpcom/threads/AbstractThread.cpp

@@ -10,6 +10,7 @@
 #include "mozilla/DelayedRunnable.h"
 #include "mozilla/Maybe.h"
 #include "mozilla/MozPromise.h"  // We initialize the MozPromise logging in this file.
+#include "mozilla/ProfilerRunnable.h"
 #include "mozilla/StateWatching.h"  // We initialize the StateWatching logging in this file.
 #include "mozilla/StaticPtr.h"
 #include "mozilla/TaskDispatcher.h"
@@ -208,6 +209,7 @@ class XPCOMThreadWrapper final : public AbstractThread,
       MOZ_ASSERT(mThread == AbstractThread::GetCurrent());
       MOZ_ASSERT(mThread->IsCurrentThreadIn());
       SerialEventTargetGuard guard(mThread);
+      AUTO_PROFILE_FOLLOWING_RUNNABLE(mRunnable);
       return mRunnable->Run();
     }
 

xpcom/threads/DelayedRunnable.cpp

@@ -6,6 +6,8 @@
 
 #include "DelayedRunnable.h"
 
+#include "mozilla/ProfilerRunnable.h"
+
 namespace mozilla {
 
 DelayedRunnable::DelayedRunnable(already_AddRefed<nsIEventTarget> aTarget,
@@ -65,6 +67,7 @@ NS_IMETHODIMP DelayedRunnable::Notify(nsITimer* aTimer) {
 
 nsresult DelayedRunnable::DoRun() {
   nsCOMPtr<nsIRunnable> r = std::move(mWrappedRunnable);
+  AUTO_PROFILE_FOLLOWING_RUNNABLE(r);
   return r->Run();
 }
 

xpcom/threads/TaskDispatcher.h

@@ -11,6 +11,7 @@
 
 #  include "mozilla/AbstractThread.h"
 #  include "mozilla/Maybe.h"
+#  include "mozilla/ProfilerRunnable.h"
 #  include "mozilla/UniquePtr.h"
 #  include "nsIDirectTaskDispatcher.h"
 #  include "nsISupportsImpl.h"
@@ -39,6 +40,7 @@ class SimpleTaskQueue {
     while (!queue.empty()) {
       nsCOMPtr<nsIRunnable> r = std::move(queue.front());
       queue.pop();
+      AUTO_PROFILE_FOLLOWING_RUNNABLE(r);
       r->Run();
     }
   }
@@ -224,6 +226,7 @@ class AutoTaskDispatcher : public TaskDispatcher {
       MaybeDrainDirectTasks();
 
       for (size_t i = 0; i < mTasks->mRegularTasks.Length(); ++i) {
+        AUTO_PROFILE_FOLLOWING_RUNNABLE(mTasks->mRegularTasks[i]);
         mTasks->mRegularTasks[i]->Run();
 
         // Scope direct tasks tightly to the task that generated them.

xpcom/threads/TaskQueue.cpp

@@ -7,6 +7,7 @@
 #include "mozilla/TaskQueue.h"
 
 #include "mozilla/DelayedRunnable.h"
+#include "mozilla/ProfilerRunnable.h"
 #include "nsThreadUtils.h"
 
 namespace mozilla {
@@ -201,6 +202,7 @@ nsresult TaskQueue::Runner::Run() {
     {
       LogRunnable::Run log(event.event);
 
+      AUTO_PROFILE_FOLLOWING_RUNNABLE(event.event);
       event.event->Run();
 
       // Drop the reference to event. The event will hold a reference to the