Record task durations on Renderer Main & Compositor threads.

base/debug/task_annotator.cc

Index: base/debug/task_annotator.cc
diff --git a/base/debug/task_annotator.cc b/base/debug/task_annotator.cc
index 10c563614508f6f1fe6b975468e8ec464c7e0f3b..41f6caecbad188b129b5e0ff1295713bf4061b4d 100644
--- a/base/debug/task_annotator.cc
+++ b/base/debug/task_annotator.cc
@@ -8,10 +8,32 @@
 
 #include "base/debug/activity_tracker.h"
 #include "base/debug/alias.h"
+#include "base/metrics/histogram_functions.h"
 #include "base/pending_task.h"
 #include "base/trace_event/trace_event.h"
 #include "base/tracked_objects.h"
 
+namespace {
+
+void RecordCPUTimeUMA(tracked_objects::ThreadData* thread_data,
+                      base::TimeDelta duration) {
+  if (!thread_data)
+    return;
+
+  if (duration.InMillisecondsF() == 0)
+    return;
+
+  if (!thread_data->task_length_recording_enabled_for_uma())

[Sami, 2017/07/26 20:36:38]

Can we swap this before the previous 'if' since this is more likely to early
out?

+    return;
+
+  // TODO - this is slow.

[Sami, 2017/07/26 20:36:38]

TODO(tdresser)

In any case we probably can't land this as is given Bruce's recent findings
about debug string prints during video playback.

[tdresser, 2017/07/27 19:18:05]

Oops, yeah, I meant to call this out as something I was wondering about.

I can imagine a solution in which we use some kind of integer thread type
identifier, and a STATIC_HISTOGRAM_POINTER_GROUP, which would make this much
faster, but most approaches to this would result in some awkward layering
violations.

We could have the "max thread id" get passed to the task annotator at some
point, have a big enum listing possible thread types, and use those here instead
of string manipulation. 

We'd then need to populate a vector where the index indicates the histogram
name, and use a STATIC_HISTOGRAM_POINTER_GROUP.

Pretty messy, but could work.

Thoughts?

[Sami, 2017/08/04 15:46:32]

Yeah, this is pretty tough from a layering perspective. A parallel case that
comes to mind is the tracing thread sorting index:

https://cs.chromium.org/chromium/src/base/trace_event/trace_log.h?l=320&gs=cp...

Maybe we could merge and generalize that with InitializeThreadContext()? We'd
still need to have a registry of ids somewhere for that to work however.

Alternatively we could compute a small hash of the thread name (possibly at
compile time) and use that as the id (and DCHECK that none of the names
collide).

+  base::UmaHistogramCustomCounts(
+      "Scheduling.TaskTime." + thread_data->sanitized_thread_name(),
+      duration.InMicroseconds(), 1, 1000 * 1000, 50);
+}
+
+}  // namespace
+
 namespace base {
 namespace debug {
 
@@ -59,6 +81,9 @@ void TaskAnnotator::RunTask(const char* queue_function,
   std::move(pending_task->task).Run();
 
   stopwatch.Stop();
+
+  RecordCPUTimeUMA(stopwatch.GetThreadData(), stopwatch.RunDuration());
+
   tracked_objects::ThreadData::TallyRunOnNamedThreadIfTracking(*pending_task,
                                                                stopwatch);
 }