base: Support setting thread priorities generically.

base/threading/platform_thread_posix.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 "base/lazy_instance.h"
@@ skipping 10 matching lines @@
 #endif
 
 #if defined(OS_LINUX)
 #include <sys/prctl.h>
 #include <sys/resource.h>
 #include <sys/syscall.h>
 #include <sys/time.h>
 #include <unistd.h>
 #endif
 
-#if defined(OS_ANDROID)
-#include <sys/resource.h>
-#include "base/android/thread_utils.h"
-#include "jni/ThreadUtils_jni.h"
-#endif
-
 // TODO(bbudge) Use time.h when NaCl toolchain supports _POSIX_TIMERS
 #if defined(OS_NACL)
 #include <sys/nacl_syscalls.h>
 #endif
 
 namespace base {
 
-#if defined(OS_MACOSX)
 void InitThreading();
-#endif
+void InitOnThread();
+void TerminateOnThread();
+size_t GetDefaultThreadStackSize(const pthread_attr_t& attributes);
 
 namespace {
 
 struct ThreadParams {
   PlatformThread::Delegate* delegate;
   bool joinable;
   ThreadPriority priority;
 };
 
-void SetCurrentThreadPriority(ThreadPriority priority) {
-#if defined(OS_LINUX) || defined(OS_ANDROID)
-  switch (priority) {
-    case kThreadPriority_Normal:
-      NOTREACHED() << "Don't reset priority as not all processes can.";
-      break;
-    case kThreadPriority_RealtimeAudio:
-#if defined(OS_LINUX)
-      const int kNiceSetting = -10;
-      // Linux isn't posix compliant with setpriority(2), it will set a thread
-      // priority if it is passed a tid, not affecting the rest of the threads
-      // in the process.  Setting this priority will only succeed if the user
-      // has been granted permission to adjust nice values on the system.
-      if (setpriority(PRIO_PROCESS, PlatformThread::CurrentId(), kNiceSetting))
-        DVLOG(1) << "Failed to set nice value of thread to " << kNiceSetting;
-#elif defined(OS_ANDROID)
-      JNIEnv* env = base::android::AttachCurrentThread();
-      Java_ThreadUtils_setThreadPriorityAudio(env, PlatformThread::CurrentId());
-#endif  // defined(OS_LINUX)
-      break;
-  }
-#else  // !defined(OS_LINUX) && !defined(OS_ANDROID)
-  PlatformThread::SetThreadPriority(pthread_self(), priority);
-#endif
-}
-
 void* ThreadFunc(void* params) {
-#if defined(OS_ANDROID)
-  // Threads on linux/android may inherit their priority from the thread
-  // where they were created. This sets all threads to the default.
-  // TODO(epenner): Move thread priorities to base. (crbug.com/170549)
-  if (setpriority(PRIO_PROCESS, PlatformThread::CurrentId(), 0))
-    DVLOG(1) << "Failed to reset initial thread nice value to zero.";
-#endif
+  base::InitOnThread();
   ThreadParams* thread_params = static_cast<ThreadParams*>(params);
   PlatformThread::Delegate* delegate = thread_params->delegate;
   if (!thread_params->joinable)
     base::ThreadRestrictions::SetSingletonAllowed(false);
 
-  // If there is a non-default priority for this thread, set it now.
-  if (thread_params->priority != kThreadPriority_Normal)
-    SetCurrentThreadPriority(thread_params->priority);
+  if (thread_params->priority != kThreadPriority_Normal) {
+    PlatformThread::SetThreadPriority(pthread_self(),
+                                      PlatformThread::CurrentId(),
+                                      thread_params->priority);
+  }
 
   delete thread_params;
   delegate->ThreadMain();
-#if defined(OS_ANDROID)
-  base::android::DetachFromVM();
-#endif
+  base::TerminateOnThread();
   return NULL;
 }
 
 bool CreateThread(size_t stack_size, bool joinable,
                   PlatformThread::Delegate* delegate,
                   PlatformThreadHandle* thread_handle,
                   ThreadPriority priority) {
-#if defined(OS_MACOSX)
   base::InitThreading();
-#endif  // OS_MACOSX
 
   bool success = false;
   pthread_attr_t attributes;
   pthread_attr_init(&attributes);
 
   // Pthreads are joinable by default, so only specify the detached attribute if
   // the thread should be non-joinable.
   if (!joinable) {
     pthread_attr_setdetachstate(&attributes, PTHREAD_CREATE_DETACHED);
   }
 
-#if defined(OS_MACOSX) && !defined(OS_IOS)
-  // The Mac OS X default for a pthread stack size is 512kB.
-  // Libc-594.1.4/pthreads/pthread.c's pthread_attr_init uses
-  // DEFAULT_STACK_SIZE for this purpose.
-  //
-  // 512kB isn't quite generous enough for some deeply recursive threads that
-  // otherwise request the default stack size by specifying 0. Here, adopt
-  // glibc's behavior as on Linux, which is to use the current stack size
-  // limit (ulimit -s) as the default stack size. See
-  // glibc-2.11.1/nptl/nptl-init.c's __pthread_initialize_minimal_internal. To
-  // avoid setting the limit below the Mac OS X default or the minimum usable
-  // stack size, these values are also considered. If any of these values
-  // can't be determined, or if stack size is unlimited (ulimit -s unlimited),
-  // stack_size is left at 0 to get the system default.
-  //
-  // Mac OS X normally only applies ulimit -s to the main thread stack. On
-  // contemporary OS X and Linux systems alike, this value is generally 8MB
-  // or in that neighborhood.
-  if (stack_size == 0) {
-    size_t default_stack_size;
-    struct rlimit stack_rlimit;
-    if (pthread_attr_getstacksize(&attributes, &default_stack_size) == 0 &&
-        getrlimit(RLIMIT_STACK, &stack_rlimit) == 0 &&
-        stack_rlimit.rlim_cur != RLIM_INFINITY) {
-      stack_size = std::max(std::max(default_stack_size,
-                                     static_cast<size_t>(PTHREAD_STACK_MIN)),
-                            static_cast<size_t>(stack_rlimit.rlim_cur));
-    }
-  }
-#endif  // OS_MACOSX && !OS_IOS
+  // Get a better default if available.
+  if (stack_size == 0)
+    stack_size = base::GetDefaultThreadStackSize(attributes);
 
   if (stack_size > 0)
     pthread_attr_setstacksize(&attributes, stack_size);
 
   ThreadParams* params = new ThreadParams;
   params->delegate = delegate;
   params->joinable = joinable;
   params->priority = priority;
 
   int err = pthread_create(thread_handle, &attributes, ThreadFunc, params);
@@ skipping 46 matching lines @@
   // NOTE: TimeDelta's microseconds are int64s while timespec's
   // nanoseconds are longs, so this unpacking must prevent overflow.
   sleep_time.tv_sec = duration.InSeconds();
   duration -= TimeDelta::FromSeconds(sleep_time.tv_sec);
   sleep_time.tv_nsec = duration.InMicroseconds() * 1000;  // nanoseconds
 
   while (nanosleep(&sleep_time, &remaining) == -1 && errno == EINTR)
     sleep_time = remaining;
 }
 
-#if defined(OS_LINUX)
-// static
-void PlatformThread::SetName(const char* name) {
-  ThreadIdNameManager::GetInstance()->SetName(CurrentId(), name);
-  tracked_objects::ThreadData::InitializeThreadContext(name);
-
-  // On linux we can get the thread names to show up in the debugger by setting
-  // the process name for the LWP.  We don't want to do this for the main
-  // thread because that would rename the process, causing tools like killall
-  // to stop working.
-  if (PlatformThread::CurrentId() == getpid())
-    return;
-
-  // http://0pointer.de/blog/projects/name-your-threads.html
-  // Set the name for the LWP (which gets truncated to 15 characters).
-  // Note that glibc also has a 'pthread_setname_np' api, but it may not be
-  // available everywhere and it's only benefit over using prctl directly is
-  // that it can set the name of threads other than the current thread.
-  int err = prctl(PR_SET_NAME, name);
-  // We expect EPERM failures in sandboxed processes, just ignore those.
-  if (err < 0 && errno != EPERM)
-    DPLOG(ERROR) << "prctl(PR_SET_NAME)";
-}
-#elif defined(OS_MACOSX)
-// Mac is implemented in platform_thread_mac.mm.
-#else
-// static
-void PlatformThread::SetName(const char* name) {
-  ThreadIdNameManager::GetInstance()->SetName(CurrentId(), name);
-  tracked_objects::ThreadData::InitializeThreadContext(name);
-
-  // (This should be relatively simple to implement for the BSDs; I
-  // just don't have one handy to test the code on.)
-}
-#endif  // defined(OS_LINUX)
-
 // static
 const char* PlatformThread::GetName() {
   return ThreadIdNameManager::GetInstance()->GetName(CurrentId());
 }
 
 // static
 bool PlatformThread::Create(size_t stack_size, Delegate* delegate,
                             PlatformThreadHandle* thread_handle) {
   return CreateThread(stack_size, true /* joinable thread */,
                       delegate, thread_handle, kThreadPriority_Normal);
@@ skipping 18 matching lines @@
 
 // static
 void PlatformThread::Join(PlatformThreadHandle thread_handle) {
   // Joining another thread may block the current thread for a long time, since
   // the thread referred to by |thread_handle| may still be running long-lived /
   // blocking tasks.
   base::ThreadRestrictions::AssertIOAllowed();
   pthread_join(thread_handle, NULL);
 }
 
-#if !defined(OS_MACOSX) && !defined(OS_ANDROID)
-// Mac OS X uses lower-level mach APIs and Android uses Java APIs.
+#if !defined(OS_LINUX) && !defined(OS_MACOSX)
 // static
-void PlatformThread::SetThreadPriority(PlatformThreadHandle, ThreadPriority) {
-  // TODO(crogers): Implement, see http://crbug.com/116172
+void PlatformThread::SetName(const char* name) {
+  ThreadIdNameManager::GetInstance()->SetName(CurrentId(), name);
+  tracked_objects::ThreadData::InitializeThreadContext(name);
+
+  // (This should be relatively simple to implement for the BSDs; I
+  // just don't have one handy to test the code on.)
 }
 #endif
 
-#if defined(OS_ANDROID)
-bool RegisterThreadUtils(JNIEnv* env) {
-  return RegisterNativesImpl(env);
+#if !defined(OS_MACOSX) && !defined(OS_LINUX) && !defined(OS_ANDROID)
+void PlatformThread::SetThreadPriority(PlatformThreadHandle,
+                                       PlatformThreadId id,
+                                       ThreadPriority priority) {
 }
-#endif  // defined(OS_ANDROID)
+#endif
+
+#if !defined(OS_MACOSX)

[jar (doing other things), 2013/05/03 23:54:07]

This section is still messy (lines 193-230) with all these ifdefs on platform
(even though you now have several platform specific files).

Effectively, you're defining some no-op implementations for some platforms. 
This smells a lot like the situation where a base class is defined, and derived
class (for each platform) optionally provide virtual replacements for some
methods.

Certainly performance in the calls to these thread initialization and
termination methods is not critical.

WDYT?

[epennerAtGoogle, 2013/05/04 01:09:45]

Yes, I really did this for code clarity as opposed to complete removal of
#ifdefs. I do think it's a lot more readable this way.

As a first option, these defaults wouldn't need to be here if I knew all the
platforms we need to support. But in PlatformThread::CurrentId() there are
several platforms (Solaris?!) that I didn't add custom files for that I don't
want to break.

As a second option, the using virtual methods would also solve the #ifdefs, but
that's a pretty big change? I don't think it's worth doing that just for the
customized bits of the Posix implementation, but if the entire PlatformThread
interface was "thunked" into a virtual class that would be more clean probably.
In that case the new methods I have added would become new virtuals in the
default Posix implementation.

Would you like me to proceed with "thunking" the entire PlatformThread
interface? That will be a pure refactor so I'd want to do it in a different CL.
I can do it before or after this change.

+void InitThreading() {
+}
+#endif
+
+#if !defined(OS_ANDROID)
+void InitOnThread() {
+}
+#endif
+
+#if !defined(OS_ANDROID)
+void TerminateOnThread() {
+}
+#endif
+
+#if !defined(OS_MACOSX) && !defined(OS_IOS)
+size_t GetDefaultThreadStackSize(const pthread_attr_t& attributes) {
+  return 0;
+}
+#endif
 
 }  // namespace base