TaskScheduler: Bump thread priority during shutdown.

base/task_scheduler/scheduler_worker.cc

Index: base/task_scheduler/scheduler_worker.cc
diff --git a/base/task_scheduler/scheduler_worker.cc b/base/task_scheduler/scheduler_worker.cc
index 5a2a7d6a92b96272e1d148edeaec2c4a1782b672..5fb65c05d0162c9c96fa3389b9a72453e93aabab 100644
--- a/base/task_scheduler/scheduler_worker.cc
+++ b/base/task_scheduler/scheduler_worker.cc
@@ -10,6 +10,7 @@
 
 #include "base/logging.h"
 #include "base/task_scheduler/task_tracker.h"
+#include "build/build_config.h"
 
 namespace base {
 namespace internal {
@@ -39,6 +40,9 @@ class SchedulerWorker::Thread : public PlatformThread::Delegate {
     while (!outer_->task_tracker_->IsShutdownComplete() &&
            !outer_->ShouldExitForTesting()) {
       DCHECK(outer_);
+
+      SetThreadPriority(GetDesiredThreadPriority());
+
       // Get the sequence containing the next task to execute.
       scoped_refptr<Sequence> sequence = outer_->delegate_->GetWork(outer_);
       if (!sequence) {
@@ -91,17 +95,17 @@ class SchedulerWorker::Thread : public PlatformThread::Delegate {
 
  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() {
@@ -117,6 +121,36 @@ class SchedulerWorker::Thread : public PlatformThread::Delegate {
     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_;
+  }
+
+  void SetThreadPriority(ThreadPriority desired_thread_priority) {
+    if (desired_thread_priority == current_thread_priority_)
+      return;
+
+#if defined(OS_LINUX)
+    if (static_cast<int>(desired_thread_priority) >
+        static_cast<int>(current_thread_priority_)) {

[gab, 2016/07/21 21:29:51]

If we can't bring it up, we shouldn't bring it down (i.e. don't do any of this
on Linux -- and we probably also won't do priorities at all because of
SCHED_PRIO_INHERIT IIUC).

[fdoray, 2016/07/22 12:56:32]

Done. I disabled this method completely on Linux.

Another reason not to do priorities at all on Linux (in addition to
SCHED_PRIO_INHERIT) would be that we can't bump the priority of BACKGROUND
threads during shutdown. In a separate CL, we should disable all code related to
priorities on Linux (i.e. we shouldn't allow creating a BACKGROUND worker).

[gab, 2016/07/22 13:33:26]

An alternate option is to detach the BACKGROUND threads on shutdown (as long as
we have logic for the foreground pool to pickup BACKGROUND work during
shutdown).

+      // Increasing the thread priority requires the CAP_SYS_NICE capability on
+      // Linux.
+      return;
+    }
+#endif  // defined(OS_LINUX)
+
+    PlatformThread::SetCurrentThreadPriority(desired_thread_priority);
+    current_thread_priority_ = desired_thread_priority;
+  }
+
   PlatformThreadHandle thread_handle_;
 
   SchedulerWorker* outer_;
@@ -124,6 +158,10 @@ class SchedulerWorker::Thread : public PlatformThread::Delegate {
   // 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);
 };