base: Extend cgroup adjustments to both cpuset and schedtune.

base/threading/platform_thread_linux.cc

 // Copyright (c) 2012 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/threading/platform_thread.h"
 
 #include <errno.h>
 #include <sched.h>
 #include <stddef.h>
 
@@ skipping 11 matching lines @@
 #include <sys/prctl.h>
 #include <sys/resource.h>
 #include <sys/time.h>
 #include <sys/types.h>
 #include <unistd.h>
 #endif
 
 namespace base {
 namespace {
 #if !defined(OS_NACL)
-const FilePath::CharType kCpusetDirectory[] =
-    FILE_PATH_LITERAL("/sys/fs/cgroup/cpuset/chrome");
+const FilePath::CharType kCgroupDirectory[] =
+    FILE_PATH_LITERAL("/sys/fs/cgroup");
 
-FilePath ThreadPriorityToCpusetDirectory(ThreadPriority priority) {
-  FilePath cpuset_filepath(kCpusetDirectory);
+FilePath ThreadPriorityToCgroupDirectory(const FilePath& cgroup_filepath,
+                                         ThreadPriority priority) {
   switch (priority) {
     case ThreadPriority::NORMAL:
-      return cpuset_filepath;
+      return cgroup_filepath;
     case ThreadPriority::BACKGROUND:
-      return cpuset_filepath.Append(FILE_PATH_LITERAL("non-urgent"));
+      return cgroup_filepath.Append(FILE_PATH_LITERAL("non-urgent"));
     case ThreadPriority::DISPLAY:
     case ThreadPriority::REALTIME_AUDIO:
-      return cpuset_filepath.Append(FILE_PATH_LITERAL("urgent"));
+      return cgroup_filepath.Append(FILE_PATH_LITERAL("urgent"));
   }
   NOTREACHED();
   return FilePath();
 }
 
-void SetThreadCpuset(PlatformThreadId thread_id,
-                     const FilePath& cpuset_directory) {
-  // Silently ignore request if cpuset directory doesn't exist.
-  if (!DirectoryExists(cpuset_directory))
-    return;
-  FilePath tasks_filepath = cpuset_directory.Append(FILE_PATH_LITERAL("tasks"));
+void SetThreadCgroup(PlatformThreadId thread_id,
+                     const FilePath& cgroup_directory) {
+  FilePath tasks_filepath = cgroup_directory.Append(FILE_PATH_LITERAL("tasks"));
   std::string tid = IntToString(thread_id);
   int bytes_written = WriteFile(tasks_filepath, tid.c_str(), tid.size());
   if (bytes_written != static_cast<int>(tid.size())) {
     DVLOG(1) << "Failed to add " << tid << " to " << tasks_filepath.value();
   }
 }
+
+void SetThreadCgroupForThreadPriority(PlatformThreadId thread_id,
+                                      const FilePath& cgroup_filepath,
+                                      ThreadPriority priority) {
+  // Append "chrome" suffix.
+  FilePath cgroup_directory = ThreadPriorityToCgroupDirectory(
+      cgroup_filepath.Append(FILE_PATH_LITERAL("chrome")), priority);
+
+  // Silently ignore request if cgroup directory doesn't exist.
+  if (!DirectoryExists(cgroup_directory))
+    return;
+
+  SetThreadCgroup(thread_id, cgroup_directory);
+}
+
+void SetThreadCgroupsForThreadPriority(PlatformThreadId thread_id,
+                                       ThreadPriority priority) {
+  FilePath cgroup_filepath(kCgroupDirectory);
+  SetThreadCgroupForThreadPriority(
+      thread_id, cgroup_filepath.Append(FILE_PATH_LITERAL("cpuset")), priority);
+  SetThreadCgroupForThreadPriority(
+      thread_id, cgroup_filepath.Append(FILE_PATH_LITERAL("schedtune")),
+      priority);
+}
 #endif
 }  // namespace
 
 namespace internal {
 
 namespace {
 #if !defined(OS_NACL)
 const struct sched_param kRealTimePrio = {8};
 #endif
 }  // namespace
 
 const ThreadPriorityToNiceValuePair kThreadPriorityToNiceValueMap[4] = {
     {ThreadPriority::BACKGROUND, 10},
     {ThreadPriority::NORMAL, 0},
     {ThreadPriority::DISPLAY, -8},
     {ThreadPriority::REALTIME_AUDIO, -10},
 };
 
 bool SetCurrentThreadPriorityForPlatform(ThreadPriority priority) {
 #if !defined(OS_NACL)
-  FilePath cpuset_directory = ThreadPriorityToCpusetDirectory(priority);
-  SetThreadCpuset(PlatformThread::CurrentId(), cpuset_directory);
+  SetThreadCgroupsForThreadPriority(PlatformThread::CurrentId(), priority);
   return priority == ThreadPriority::REALTIME_AUDIO &&
          pthread_setschedparam(pthread_self(), SCHED_RR, &kRealTimePrio) == 0;
 #else
   return false;
 #endif
 }
 
 bool GetCurrentThreadPriorityForPlatform(ThreadPriority* priority) {
 #if !defined(OS_NACL)
   int maybe_sched_rr = 0;
@@ skipping 38 matching lines @@
 
 #if !defined(OS_NACL)
 // static
 void PlatformThread::SetThreadPriority(PlatformThreadId thread_id,
                                        ThreadPriority priority) {
   // Changing current main threads' priority is not permitted in favor of
   // security, this interface is restricted to change only non-main thread
   // priority.
   CHECK_NE(thread_id, getpid());
 
-  FilePath cpuset_directory = ThreadPriorityToCpusetDirectory(priority);
-  SetThreadCpuset(thread_id, cpuset_directory);
+  SetThreadCgroupsForThreadPriority(thread_id, priority);
 
   const int nice_setting = internal::ThreadPriorityToNiceValue(priority);
   if (setpriority(PRIO_PROCESS, thread_id, nice_setting)) {
     DVPLOG(1) << "Failed to set nice value of thread (" << thread_id << ") to "
               << nice_setting;
   }
 }
 #endif  //  !defined(OS_NACL)
 
 void InitThreading() {}
 
 void TerminateOnThread() {}
 
 size_t GetDefaultThreadStackSize(const pthread_attr_t& attributes) {
 #if !defined(THREAD_SANITIZER)
   return 0;
 #else
   // ThreadSanitizer bloats the stack heavily. Evidence has been that the
   // default stack size isn't enough for some browser tests.
   return 2 * (1 << 23);  // 2 times 8192K (the default stack size on Linux).
 #endif
 }
 
 }  // namespace base