TaskScheduler: Bump thread priority during shutdown.

base/task_scheduler/scheduler_worker.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.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/logging.h"
 #include "base/task_scheduler/task_tracker.h"
+#include "build/build_config.h"
 
 namespace base {
 namespace internal {
 
 class SchedulerWorker::Thread : public PlatformThread::Delegate {
  public:
   ~Thread() override = default;
 
   static std::unique_ptr<Thread> Create(SchedulerWorker* outer) {
     std::unique_ptr<Thread> thread(new Thread(outer));
     thread->Initialize();
     if (thread->thread_handle_.is_null())
       return nullptr;
     return thread;
   }
 
   // PlatformThread::Delegate.
   void ThreadMain() override {
     // Set if this thread was detached.
     std::unique_ptr<Thread> detached_thread;
 
     outer_->delegate_->OnMainEntry(outer_);
 
     // A SchedulerWorker starts out waiting for work.
     WaitForWork();
 
     while (!outer_->task_tracker_->IsShutdownComplete() &&
            !outer_->ShouldExitForTesting()) {
       DCHECK(outer_);
+
+#if !defined(OS_LINUX)
+      UpdateThreadPriority(GetDesiredThreadPriority());
+#endif
+
       // Get the sequence containing the next task to execute.
       scoped_refptr<Sequence> sequence = outer_->delegate_->GetWork(outer_);
       if (!sequence) {
         if (outer_->delegate_->CanDetach(outer_)) {
           detached_thread = outer_->Detach();
           if (detached_thread) {
             DCHECK_EQ(detached_thread.get(), this);
             PlatformThread::Detach(thread_handle_);
             outer_ = nullptr;
             break;
@@ skipping 32 matching lines @@
   }
 
   void Join() { PlatformThread::Join(thread_handle_); }
 
   void WakeUp() { wake_up_event_.Signal(); }
 
   bool IsWakeUpPending() { return wake_up_event_.IsSignaled(); }
 
  private:
   Thread(SchedulerWorker* outer)
-    : outer_(outer),
-      wake_up_event_(WaitableEvent::ResetPolicy::MANUAL,
-                     WaitableEvent::InitialState::NOT_SIGNALED) {
+      : outer_(outer),
+        wake_up_event_(WaitableEvent::ResetPolicy::MANUAL,
+                       WaitableEvent::InitialState::NOT_SIGNALED),
+        current_thread_priority_(GetDesiredThreadPriority()) {
     DCHECK(outer_);
   }
 
   void Initialize() {
     constexpr size_t kDefaultStackSize = 0;
-    PlatformThread::CreateWithPriority(kDefaultStackSize, this,
-                                       &thread_handle_,
-                                       outer_->thread_priority_);
+    PlatformThread::CreateWithPriority(kDefaultStackSize, this, &thread_handle_,
+                                       current_thread_priority_);
   }
 
   void WaitForWork() {
     DCHECK(outer_);
     const TimeDelta sleep_time = outer_->delegate_->GetSleepTimeout();
     if (sleep_time.is_max()) {
       // Calling TimedWait with TimeDelta::Max is not recommended per
       // http://crbug.com/465948.
       wake_up_event_.Wait();
     } else {
       wake_up_event_.TimedWait(sleep_time);
     }
     wake_up_event_.Reset();
   }
 
+  // Returns the desired thread priority based on the worker priority and the
+  // current shutdown state.
+  ThreadPriority GetDesiredThreadPriority() {
+    DCHECK(outer_);
+
+    if (outer_->task_tracker_->HasShutdownStarted() &&
+        static_cast<int>(outer_->thread_priority_) <
+            static_cast<int>(ThreadPriority::NORMAL)) {
+      return ThreadPriority::NORMAL;
+    }
+    return outer_->thread_priority_;
+  }
+
+  // Increasing the thread priority requires the CAP_SYS_NICE capability on
+  // Linux.
+#if !defined(OS_LINUX)
+  void UpdateThreadPriority(ThreadPriority desired_thread_priority) {
+    if (desired_thread_priority == current_thread_priority_)
+      return;
+
+    PlatformThread::SetCurrentThreadPriority(desired_thread_priority);
+    current_thread_priority_ = desired_thread_priority;
+  }
+#endif  // !defined(OS_LINUX)
+
   PlatformThreadHandle thread_handle_;
 
   SchedulerWorker* outer_;
 
   // Event signaled to wake up this thread.
   WaitableEvent wake_up_event_;
 
+  // Current priority of this thread. May be different from
+  // |outer_->thread_priority_| during shutdown.
+  ThreadPriority current_thread_priority_;
+
   DISALLOW_COPY_AND_ASSIGN(Thread);
 };
 
 std::unique_ptr<SchedulerWorker> SchedulerWorker::Create(
     ThreadPriority thread_priority,
     std::unique_ptr<Delegate> delegate,
     TaskTracker* task_tracker,
     InitialState initial_state) {
   std::unique_ptr<SchedulerWorker> worker(
       new SchedulerWorker(thread_priority, std::move(delegate), task_tracker));
@@ skipping 76 matching lines @@
   CreateThread();
 }
 
 bool SchedulerWorker::ShouldExitForTesting() const {
   AutoSchedulerLock auto_lock(should_exit_for_testing_lock_);
   return should_exit_for_testing_;
 }
 
 }  // namespace internal
 }  // namespace base