Name TaskScheduler's worker threads

base/task_scheduler/scheduler_thread_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_thread_pool_impl.h"
 
 #include <algorithm>
 #include <utility>

[fdoray, 2016/05/03 19:01:50]

#include <stddef.h> for size_t

[gab, 2016/05/04 18:11:37]

Done.

 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
+#include "base/strings/stringprintf.h"
 #include "base/task_scheduler/delayed_task_manager.h"
 #include "base/task_scheduler/task_tracker.h"
+#include "base/threading/platform_thread.h"
 #include "base/threading/thread_local.h"
 #include "base/threading/thread_restrictions.h"
 
 namespace base {
 namespace internal {
 
 namespace {
 
 // SchedulerThreadPool that owns the current thread, if any.
 LazyInstance<ThreadLocalPointer<const SchedulerThreadPool>>::Leaky
@@ skipping 145 matching lines @@
 
 }  // namespace
 
 class SchedulerThreadPoolImpl::SchedulerWorkerThreadDelegateImpl
     : public SchedulerWorkerThread::Delegate {
  public:
   // |outer| owns the worker thread for which this delegate is constructed.
   // |re_enqueue_sequence_callback| is invoked when ReEnqueueSequence() is
   // called with a non-single-threaded Sequence. |shared_priority_queue| is a
   // PriorityQueue whose transactions may overlap with the worker thread's
-  // single-threaded PriorityQueue's transactions.
+  // single-threaded PriorityQueue's transactions. |index| will be appended to
+  // this thread's name to uniquely identify it.
   SchedulerWorkerThreadDelegateImpl(
       SchedulerThreadPoolImpl* outer,
       const ReEnqueueSequenceCallback& re_enqueue_sequence_callback,
-      const PriorityQueue* shared_priority_queue);
+      const PriorityQueue* shared_priority_queue,
+      size_t index);
   ~SchedulerWorkerThreadDelegateImpl() override;
 
   PriorityQueue* single_threaded_priority_queue() {
     return &single_threaded_priority_queue_;
   }
 
   // SchedulerWorkerThread::Delegate:
   void OnMainEntry(SchedulerWorkerThread* worker_thread) override;
   scoped_refptr<Sequence> GetWork(
       SchedulerWorkerThread* worker_thread) override;
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override;
 
  private:
   SchedulerThreadPoolImpl* outer_;
   const ReEnqueueSequenceCallback re_enqueue_sequence_callback_;
 
   // Single-threaded PriorityQueue for the worker thread.
   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;
 
+  const size_t index_;
+
   DISALLOW_COPY_AND_ASSIGN(SchedulerWorkerThreadDelegateImpl);
 };
 
 SchedulerThreadPoolImpl::~SchedulerThreadPoolImpl() {
   // SchedulerThreadPool should never be deleted in production unless its
   // initialization failed.
   DCHECK(join_for_testing_returned_.IsSignaled() || worker_threads_.empty());
 }
 
 // static
 std::unique_ptr<SchedulerThreadPoolImpl> SchedulerThreadPoolImpl::Create(
+    StringPiece name,
     ThreadPriority thread_priority,
     size_t max_threads,
     IORestriction io_restriction,
     const ReEnqueueSequenceCallback& re_enqueue_sequence_callback,
     TaskTracker* task_tracker,
     DelayedTaskManager* delayed_task_manager) {
   std::unique_ptr<SchedulerThreadPoolImpl> thread_pool(
-      new SchedulerThreadPoolImpl(io_restriction, task_tracker,
+      new SchedulerThreadPoolImpl(name, io_restriction, task_tracker,
                                   delayed_task_manager));
   if (thread_pool->Initialize(thread_priority, max_threads,
                               re_enqueue_sequence_callback)) {
     return thread_pool;
   }
   return nullptr;
 }
 
 void SchedulerThreadPoolImpl::WaitForAllWorkerThreadsIdleForTesting() {
   AutoSchedulerLock auto_lock(idle_worker_threads_stack_lock_);
@@ skipping 121 matching lines @@
       worker_thread->WakeUp();
     else
       WakeUpOneThread();
   }
 }
 
 SchedulerThreadPoolImpl::SchedulerWorkerThreadDelegateImpl::
     SchedulerWorkerThreadDelegateImpl(
         SchedulerThreadPoolImpl* outer,
         const ReEnqueueSequenceCallback& re_enqueue_sequence_callback,
-        const PriorityQueue* shared_priority_queue)
+        const PriorityQueue* shared_priority_queue,
+        size_t index)
     : outer_(outer),
       re_enqueue_sequence_callback_(re_enqueue_sequence_callback),
-      single_threaded_priority_queue_(shared_priority_queue) {}
+      single_threaded_priority_queue_(shared_priority_queue),
+      index_(index) {}
 
 SchedulerThreadPoolImpl::SchedulerWorkerThreadDelegateImpl::
     ~SchedulerWorkerThreadDelegateImpl() = default;
 
 void SchedulerThreadPoolImpl::SchedulerWorkerThreadDelegateImpl::OnMainEntry(
     SchedulerWorkerThread* worker_thread) {
 #if DCHECK_IS_ON()
   // Wait for |outer_->threads_created_| to avoid traversing
   // |outer_->worker_threads_| while it is being filled by Initialize().
   outer_->threads_created_.Wait();
   DCHECK(ContainsWorkerThread(outer_->worker_threads_, worker_thread));
 #endif
 
+  PlatformThread::SetName(StringPrintf("%sWorker%u/%d", outer_->name_.c_str(),
+                                       index_, PlatformThread::CurrentId()));

[fdoray, 2016/05/03 19:01:50]

Why is it useful to have index + thread id? I think thread id is the most useful
as it can be correlated with crash dumps / debuggers.

[robliao, 2016/05/03 23:35:38]

Doesn't the debugger generate this for you too?
0:001> ~
   0  Id: 2324.2ea4 Suspend: 1 Teb: 00000000`7efdb000 Unfrozen "This is my
thread!"
.  1  Id: 2324.2e80 Suspend: 1 Teb: 00000000`7efd8000 Unfrozen

[gab, 2016/05/04 18:11:37]

Agreed, I initially added the index to have a unique name, then realized the
pattern of other threads (e.g. SequencedWorkerPool) was to add /ThreadID, but
now that I'm looking closer the /ThreadID is a feature of chrome://tracing, not
the actual name of the thread I think so removed (in which case I think keeping
the index is better for unique names though).
This is debugger dependent. Naming the threads is cross-platform (and there is a
rumor on windows that I can only share offline that make this worthwhile :-)).

+
   DCHECK(!tls_current_worker_thread.Get().Get());
   DCHECK(!tls_current_thread_pool.Get().Get());
   tls_current_worker_thread.Get().Set(worker_thread);
   tls_current_thread_pool.Get().Set(outer_);
 
   ThreadRestrictions::SetIOAllowed(outer_->io_restriction_ ==
                                    IORestriction::ALLOWED);
 }
 
 scoped_refptr<Sequence>
@@ skipping 61 matching lines @@
     single_threaded_priority_queue_.BeginTransaction()->Push(
         std::move(sequence), sequence_sort_key);
   } else {
     // |re_enqueue_sequence_callback_| will determine in which PriorityQueue
     // |sequence| must be enqueued.
     re_enqueue_sequence_callback_.Run(std::move(sequence));
   }
 }
 
 SchedulerThreadPoolImpl::SchedulerThreadPoolImpl(
+    StringPiece name,
     IORestriction io_restriction,
     TaskTracker* task_tracker,
     DelayedTaskManager* delayed_task_manager)
-    : io_restriction_(io_restriction),
+    : name_(name.as_string()),
+      io_restriction_(io_restriction),
       idle_worker_threads_stack_lock_(shared_priority_queue_.container_lock()),
       idle_worker_threads_stack_cv_for_testing_(
           idle_worker_threads_stack_lock_.CreateConditionVariable()),
       join_for_testing_returned_(true, false),
 #if DCHECK_IS_ON()
       threads_created_(true, false),
 #endif
       task_tracker_(task_tracker),
       delayed_task_manager_(delayed_task_manager) {
   DCHECK(task_tracker_);
   DCHECK(delayed_task_manager_);
 }
 
 bool SchedulerThreadPoolImpl::Initialize(
     ThreadPriority thread_priority,
     size_t max_threads,
     const ReEnqueueSequenceCallback& re_enqueue_sequence_callback) {
   AutoSchedulerLock auto_lock(idle_worker_threads_stack_lock_);
 
   DCHECK(worker_threads_.empty());
 
   for (size_t i = 0; i < max_threads; ++i) {
     std::unique_ptr<SchedulerWorkerThread> worker_thread =
         SchedulerWorkerThread::Create(
-            thread_priority,
-            WrapUnique(new SchedulerWorkerThreadDelegateImpl(
-                this, re_enqueue_sequence_callback, &shared_priority_queue_)),
+            thread_priority, WrapUnique(new SchedulerWorkerThreadDelegateImpl(
+                                 this, re_enqueue_sequence_callback,
+                                 &shared_priority_queue_, i)),
             task_tracker_);
     if (!worker_thread)
       break;
     idle_worker_threads_stack_.Push(worker_thread.get());
     worker_threads_.push_back(std::move(worker_thread));
   }
 
 #if DCHECK_IS_ON()
   threads_created_.Signal();
 #endif
@@ skipping 22 matching lines @@
 }
 
 void SchedulerThreadPoolImpl::RemoveFromIdleWorkerThreadsStack(
     SchedulerWorkerThread* worker_thread) {
   AutoSchedulerLock auto_lock(idle_worker_threads_stack_lock_);
   idle_worker_threads_stack_.Remove(worker_thread);
 }
 
 }  // namespace internal
 }  // namespace base