TaskScheduler: Record TaskScheduler.NumTasksBeforeDetach.* from OnDetach().

base/task_scheduler/scheduler_worker_pool_impl.cc

 // Copyright 2016 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 "base/task_scheduler/scheduler_worker_pool_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 219 matching lines @@
       const ReEnqueueSequenceCallback& re_enqueue_sequence_callback,
       const PriorityQueue* shared_priority_queue,
       int index);
   ~SchedulerWorkerDelegateImpl() override;
 
   PriorityQueue* single_threaded_priority_queue() {
     return &single_threaded_priority_queue_;
   }
 
   // SchedulerWorker::Delegate:
-  void OnMainEntry(SchedulerWorker* worker,
-                   const TimeDelta& detach_duration) override;
+  void OnMainEntry(SchedulerWorker* worker) override;
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override;
   void DidRunTaskWithPriority(TaskPriority task_priority,
                               const TimeDelta& task_latency) override;
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override;
   TimeDelta GetSleepTimeout() override;
   bool CanDetach(SchedulerWorker* worker) override;
+  void OnDetach() override;
 
   void RegisterSingleThreadTaskRunner() {
     // No barrier as barriers only affect sequential consistency which is
     // irrelevant in a single variable use case (they don't force an immediate
     // flush anymore than atomics do by default).
     subtle::NoBarrier_AtomicIncrement(&num_single_threaded_runners_, 1);
   }
 
   void UnregisterSingleThreadTaskRunner() {
     subtle::NoBarrier_AtomicIncrement(&num_single_threaded_runners_, -1);
   }
 
  private:
   SchedulerWorkerPoolImpl* outer_;
   const ReEnqueueSequenceCallback re_enqueue_sequence_callback_;
 
   // Single-threaded PriorityQueue for the worker.
   PriorityQueue single_threaded_priority_queue_;
 
   // True if the last Sequence returned by GetWork() was extracted from
   // |single_threaded_priority_queue_|.
   bool last_sequence_is_single_threaded_ = false;
 
+  // Time of the last detach.
+  TimeTicks last_detach_time_;
+
   // Time when GetWork() first returned nullptr.
   TimeTicks idle_start_time_;
 
   // Indicates whether the last call to GetWork() returned nullptr.
   bool last_get_work_returned_nullptr_ = false;
 
   // Indicates whether the SchedulerWorker was detached since the last call to
   // GetWork().
   bool did_detach_since_last_get_work_ = false;
 
@@ skipping 193 matching lines @@
         int index)
     : outer_(outer),
       re_enqueue_sequence_callback_(re_enqueue_sequence_callback),
       single_threaded_priority_queue_(shared_priority_queue),
       index_(index) {}
 
 SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::
     ~SchedulerWorkerDelegateImpl() = default;
 
 void SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::OnMainEntry(
-    SchedulerWorker* worker,
-    const TimeDelta& detach_duration) {
+    SchedulerWorker* worker) {
 #if DCHECK_IS_ON()
   // Wait for |outer_->workers_created_| to avoid traversing
   // |outer_->workers_| while it is being filled by Initialize().
   outer_->workers_created_.Wait();
   DCHECK(ContainsWorker(outer_->workers_, worker));
 #endif
 
   DCHECK_EQ(num_tasks_since_last_wait_, 0U);
 
-  // Record histograms if the worker detached in the past.
-  if (!detach_duration.is_max()) {
-    outer_->detach_duration_histogram_->AddTime(detach_duration);
-    outer_->num_tasks_before_detach_histogram_->Add(
-        num_tasks_since_last_detach_);
-    num_tasks_since_last_detach_ = 0;
-    did_detach_since_last_get_work_ = true;
+  if (!last_detach_time_.is_null()) {
+    outer_->detach_duration_histogram_->AddTime(TimeTicks::Now() -
+                                                last_detach_time_);
   }
 
   PlatformThread::SetName(
       StringPrintf("TaskScheduler%sWorker%d", outer_->name_.c_str(), index_));
 
   DCHECK(!tls_current_worker.Get().Get());
   DCHECK(!tls_current_worker_pool.Get().Get());
   tls_current_worker.Get().Set(worker);
   tls_current_worker_pool.Get().Set(outer_);
 
   // New threads haven't run GetWork() yet, so reset the |idle_start_time_|.
   idle_start_time_ = TimeTicks();
 
   ThreadRestrictions::SetIOAllowed(
       outer_->io_restriction_ ==
           SchedulerWorkerPoolParams::IORestriction::ALLOWED);
 }
 
 scoped_refptr<Sequence>
 SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::GetWork(
     SchedulerWorker* worker) {
   DCHECK(ContainsWorker(outer_->workers_, worker));
 
   // Record the TaskScheduler.NumTasksBetweenWaits histogram if the
   // SchedulerWorker waited on its WaitableEvent since the last GetWork().
   //
-  // Note: When GetWork() returns nullptr for the first time after returning a
-  // Sequence, SchedulerWorker waits on its WaitableEvent. When the wait stops
-  // (either because WakeUp() was called or because the sleep timeout expired),
-  // GetWork() is called and the histogram is recorded. If GetWork() returns
-  // nullptr again, the SchedulerWorker may detach.
-  // |did_detach_since_last_get_work_| is set to true from OnMainEntry() if the
-  // SchedulerWorker detaches and wakes up again. The next call to GetWork()
-  // won't record the histogram (which is correct since the SchedulerWorker
-  // didn't wait on its WaitableEvent since the last time the histogram was
-  // recorded).
+  // Note: When GetWork() starts returning nullptr, the SchedulerWorker waits on
+  // its WaitableEvent. When it wakes up (either because WakeUp() was called or
+  // because the sleep timeout expired), it calls GetWork() again. The code
+  // below records the histogram and, if GetWork() returns nullptr again, the
+  // SchedulerWorker may detach. If that happens,
+  // |did_detach_since_last_get_work_| is set to true and the next call to
+  // GetWork() won't record the histogram  (which is correct since the
+  // SchedulerWorker didn't wait on its WaitableEvent since the last time the
+  // histogram was recorded).
   if (last_get_work_returned_nullptr_ && !did_detach_since_last_get_work_) {
     outer_->num_tasks_between_waits_histogram_->Add(num_tasks_since_last_wait_);
     num_tasks_since_last_wait_ = 0;
   }
 
   scoped_refptr<Sequence> sequence;
   {
     std::unique_ptr<PriorityQueue::Transaction> shared_transaction(
         outer_->shared_priority_queue_.BeginTransaction());
     std::unique_ptr<PriorityQueue::Transaction> single_threaded_transaction(
@@ skipping 104 matching lines @@
   // created by the worker.
   const bool can_detach =
       !idle_start_time_.is_null() &&
       (TimeTicks::Now() - idle_start_time_) > outer_->suggested_reclaim_time_ &&
       worker != outer_->PeekAtIdleWorkersStack() &&
       !subtle::NoBarrier_Load(&num_single_threaded_runners_) &&
       outer_->CanWorkerDetachForTesting();
   return can_detach;
 }
 
+void SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::OnDetach() {
+  DCHECK(!did_detach_since_last_get_work_);
+  outer_->num_tasks_before_detach_histogram_->Add(num_tasks_since_last_detach_);
+  num_tasks_since_last_detach_ = 0;
+  did_detach_since_last_get_work_ = true;
+  last_detach_time_ = TimeTicks::Now();
+}
+
 SchedulerWorkerPoolImpl::SchedulerWorkerPoolImpl(
     StringPiece name,
     SchedulerWorkerPoolParams::IORestriction io_restriction,
     const TimeDelta& suggested_reclaim_time,
     TaskTracker* task_tracker,
     DelayedTaskManager* delayed_task_manager)
     : name_(name.as_string()),
       io_restriction_(io_restriction),
       suggested_reclaim_time_(suggested_reclaim_time),
       idle_workers_stack_lock_(shared_priority_queue_.container_lock()),
       idle_workers_stack_cv_for_testing_(
           idle_workers_stack_lock_.CreateConditionVariable()),
       join_for_testing_returned_(WaitableEvent::ResetPolicy::MANUAL,
                                  WaitableEvent::InitialState::NOT_SIGNALED),
 #if DCHECK_IS_ON()
       workers_created_(WaitableEvent::ResetPolicy::MANUAL,
                        WaitableEvent::InitialState::NOT_SIGNALED),
 #endif
       // Mimics the UMA_HISTOGRAM_LONG_TIMES macro.
       detach_duration_histogram_(Histogram::FactoryTimeGet(
           kDetachDurationHistogramPrefix + name_ + kPoolNameSuffix,
           TimeDelta::FromMilliseconds(1),
           TimeDelta::FromHours(1),
           50,
           HistogramBase::kUmaTargetedHistogramFlag)),
-      // Mimics the UMA_HISTOGRAM_COUNTS_1000 macro. A SchedulerWorker is
-      // expected to run between zero and a few hundreds of tasks before
-      // detaching. When it runs more than 1000 tasks, there is no need to know
-      // the exact number of tasks that ran.
+      // Mimics the UMA_HISTOGRAM_COUNTS_1000 macro. When a worker runs more
+      // than 1000 tasks before detaching, there is no need to know the exact
+      // number of tasks that ran.
       num_tasks_before_detach_histogram_(Histogram::FactoryGet(
           kNumTasksBeforeDetachHistogramPrefix + name_ + kPoolNameSuffix,
           1,
           1000,
           50,
           HistogramBase::kUmaTargetedHistogramFlag)),
       // Mimics the UMA_HISTOGRAM_COUNTS_100 macro. A SchedulerWorker is
       // expected to run between zero and a few tens of tasks between waits.
       // When it runs more than 100 tasks, there is no need to know the exact
       // number of tasks that ran.
@@ skipping 85 matching lines @@
   AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
   idle_workers_stack_.Remove(worker);
 }
 
 bool SchedulerWorkerPoolImpl::CanWorkerDetachForTesting() {
   return !worker_detachment_disallowed_.IsSet();
 }
 
 }  // namespace internal
 }  // namespace base