Report expected task queueing time via UMA

components/scheduler/base/task_queue_manager.cc

 // 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 "components/scheduler/base/task_queue_manager.h"
 
 #include <queue>
 #include <set>
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "components/scheduler/base/real_time_domain.h"
 #include "components/scheduler/base/task_queue_impl.h"
 #include "components/scheduler/base/task_queue_manager_delegate.h"
 #include "components/scheduler/base/task_queue_selector.h"
+#include "components/scheduler/base/task_time_tracker.h"
 #include "components/scheduler/base/work_queue.h"
 #include "components/scheduler/base/work_queue_sets.h"
 
 namespace scheduler {
 
 namespace {
 const size_t kRecordRecordTaskDelayHistogramsEveryNTasks = 10;
 
 void RecordDelayedTaskLateness(base::TimeDelta lateness) {
   UMA_HISTOGRAM_TIMES("RendererScheduler.TaskQueueManager.DelayedTaskLateness",
                       lateness);
 }
 
 void RecordImmediateTaskQueueingDuration(tracked_objects::Duration duration) {
   UMA_HISTOGRAM_TIMES(
       "RendererScheduler.TaskQueueManager.ImmediateTaskQueueingDuration",
       base::TimeDelta::FromMilliseconds(duration.InMilliseconds()));
 }
 }
 
 TaskQueueManager::TaskQueueManager(
     scoped_refptr<TaskQueueManagerDelegate> delegate,
     const char* tracing_category,
     const char* disabled_by_default_tracing_category,
-    const char* disabled_by_default_verbose_tracing_category)
+    const char* disabled_by_default_verbose_tracing_category,
+    TaskTimeTracker* task_time_tracker)
     : real_time_domain_(new RealTimeDomain(tracing_category)),
       delegate_(delegate),
       task_was_run_on_quiescence_monitored_queue_(false),
       work_batch_size_(1),
       task_count_(0),
+      task_time_tracker_(task_time_tracker),
+      do_work_depth_(0),
       tracing_category_(tracing_category),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
       disabled_by_default_verbose_tracing_category_(
           disabled_by_default_verbose_tracing_category),
       currently_executing_task_queue_(nullptr),
       observer_(nullptr),
       deletion_sentinel_(new DeletionSentinel()),
       weak_factory_(this) {
   DCHECK(delegate->RunsTasksOnCurrentThread());
@@ skipping 110 matching lines @@
   // De-duplicate DoWork posts.
   if (!main_thread_pending_wakeups_.insert(run_time).second)
     return;
   delegate_->PostDelayedTask(
       from_here, base::Bind(&TaskQueueManager::DoWork,
                             weak_factory_.GetWeakPtr(), run_time, true),
       delay);
 }
 
 void TaskQueueManager::DoWork(base::TimeTicks run_time, bool from_main_thread) {
+  do_work_depth_++;

[Sami, 2016/07/05 14:40:38]

Could we use a base::AutoReset for this? (might not work in the case where the
TQM is deleted by a task.)

[tdresser, 2016/07/05 15:52:20]

Alex pointed out this isn't needed.

   DCHECK(main_thread_checker_.CalledOnValidThread());
   TRACE_EVENT1(tracing_category_, "TaskQueueManager::DoWork",
                "from_main_thread", from_main_thread);
   if (from_main_thread) {
     main_thread_pending_wakeups_.erase(run_time);
   } else {
     base::AutoLock lock(other_thread_lock_);
     other_thread_pending_wakeups_.erase(run_time);
   }
 
   if (!delegate_->IsNested())
     queues_to_delete_.clear();
 
   // Pass false and nullptr to UpdateWorkQueues here to prevent waking up a
   // pump-after-wakeup queue.
   UpdateWorkQueues(false, nullptr);
 
   internal::TaskQueueImpl::Task previous_task;
+  base::TimeTicks task_start_time;
+  if (do_work_depth_ == 1 && from_main_thread)

[Sami, 2016/07/05 14:40:38]

Why the check for |from_main_thread|? That flag says which thread this task was
posted from -- all tasks run on the main thread.

[tdresser, 2016/07/05 20:09:38]

Done.

+    task_start_time = real_time_domain()->Now();
+
   for (int i = 0; i < work_batch_size_; i++) {
     internal::WorkQueue* work_queue;
     if (!SelectWorkQueueToService(&work_queue)) {
       break;
     }
 
     bool should_trigger_wakeup = work_queue->task_queue()->wakeup_policy() ==
                                  TaskQueue::WakeupPolicy::CAN_WAKE_OTHER_QUEUES;
+
     switch (ProcessTaskFromWorkQueue(work_queue, &previous_task)) {
       case ProcessTaskResult::DEFERRED:
         // If a task was deferred, try again with another task. Note that this
         // means deferred tasks (i.e. non-nestable tasks) will never trigger
         // queue wake-ups.
         continue;
       case ProcessTaskResult::EXECUTED:
         break;
       case ProcessTaskResult::TASK_QUEUE_MANAGER_DELETED:
         return;  // The TaskQueueManager got deleted, we must bail out.
     }
+    if (do_work_depth_ == 1 && from_main_thread) {

[alex clarke (OOO till 29th), 2016/07/05 13:47:45]

Isn't do_work_depth_ == 1  equivalent to !delegate_->IsNested() ?

[tdresser, 2016/07/05 14:30:13]

Awesome, thanks.

+      // Only report top level task durations.
+      base::TimeTicks task_end_time = real_time_domain()->Now();
+      task_time_tracker_->ReportTaskTime(task_start_time, task_end_time);
+      task_start_time = task_end_time;
+    }
+
     work_queue = nullptr; // The queue may have been unregistered.
 
     UpdateWorkQueues(should_trigger_wakeup, &previous_task);
 
     // Only run a single task per batch in nested run loops so that we can
     // properly exit the nested loop when someone calls RunLoop::Quit().
     if (delegate_->IsNested())
       break;
   }
 
   // TODO(alexclarke): Consider refactoring the above loop to terminate only
   // when there's no more work left to be done, rather than posting a
   // continuation task.
   if (!selector_.EnabledWorkQueuesEmpty() || TryAdvanceTimeDomains())
     MaybeScheduleImmediateWork(FROM_HERE);
+  do_work_depth_--;
 }
 
 bool TaskQueueManager::TryAdvanceTimeDomains() {
   bool can_advance = false;
   for (TimeDomain* time_domain : time_domains_) {
     can_advance |= time_domain->MaybeAdvanceTime();
   }
   return can_advance;
 }
 
@@ skipping 170 matching lines @@
     internal::WorkQueue* work_queue) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   DCHECK(!work_queue->Empty());
   if (observer_) {
     observer_->OnTriedToExecuteBlockedTask(*work_queue->task_queue(),
                                            *work_queue->GetFrontTask());
   }
 }
 
 }  // namespace scheduler