Replace the stop_event_ in PlatformThread with an atomic flag

webrtc/base/platform_thread.cc

 /*
  *  Copyright (c) 2015 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/base/platform_thread.h"
 
+#include "webrtc/base/atomicops.h"
 #include "webrtc/base/checks.h"
 
 #if defined(WEBRTC_LINUX)
 #include <sys/prctl.h>
 #include <sys/syscall.h>
 #endif
 
 namespace rtc {
 
 PlatformThreadId CurrentThreadId() {
@@ skipping 66 matching lines @@
   pthread_attr_t attr;
 };
 #endif  // defined(WEBRTC_WIN)
 }
 
 PlatformThread::PlatformThread(ThreadRunFunction func,
                                void* obj,
                                const char* thread_name)
     : run_function_(func),
       obj_(obj),
-      name_(thread_name ? thread_name : "webrtc"),
-#if defined(WEBRTC_WIN)
-      stop_(false),
-      thread_(NULL),
-      thread_id_(0) {
-#else
-      stop_event_(false, false),
-      thread_(0) {
-#endif  // defined(WEBRTC_WIN)
+      name_(thread_name ? thread_name : "webrtc") {
   RTC_DCHECK(func);
   RTC_DCHECK(name_.length() < 64);
 }
 
 PlatformThread::~PlatformThread() {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
 #if defined(WEBRTC_WIN)
   RTC_DCHECK(!thread_);
   RTC_DCHECK(!thread_id_);
 #endif  // defined(WEBRTC_WIN)
@@ skipping 62 matching lines @@
 #if defined(WEBRTC_WIN)
   // Set stop_ to |true| on the worker thread.
   bool queued = QueueAPC(&RaiseFlag, reinterpret_cast<ULONG_PTR>(&stop_));
   // Queuing the APC can fail if the thread is being terminated.
   RTC_CHECK(queued || GetLastError() == ERROR_GEN_FAILURE);
   WaitForSingleObject(thread_, INFINITE);
   CloseHandle(thread_);
   thread_ = nullptr;
   thread_id_ = 0;
 #else
-  stop_event_.Set();
+  RTC_CHECK_EQ(1, AtomicOps::Increment(&stop_flag_));
   RTC_CHECK_EQ(0, pthread_join(thread_, nullptr));
+  AtomicOps::ReleaseStore(&stop_flag_, 0);
   thread_ = 0;
 #endif  // defined(WEBRTC_WIN)
 }
 
+// TODO(tommi): Deprecate the loop behavior in PlatformThread.
+// * Introduce a new callback type that returns void.
+// * Remove potential for a busy loop in PlatformThread.
+// * Delegate the responsibility for how to stop the thread, to the
+//   implementation that actually uses the thread.
+// All implementations will need to be aware of how the thread should be stopped
+// and encouraging a busy polling loop, can be costly in terms of power and cpu.
 void PlatformThread::Run() {
   if (!name_.empty())
     rtc::SetCurrentThreadName(name_.c_str());
+#if !defined(WEBRTC_MAC) && !defined(WEBRTC_WIN)
+  const struct timespec ts_null = {0};
+#endif
   do {
     // The interface contract of Start/Stop is that for a successful call to
     // Start, there should be at least one call to the run function.  So we
     // call the function before checking |stop_|.
     if (!run_function_(obj_))
       break;
 #if defined(WEBRTC_WIN)
     // Alertable sleep to permit RaiseFlag to run and update |stop_|.
     SleepEx(0, true);
   } while (!stop_);
 #else
-  } while (!stop_event_.Wait(0));
+#if defined(WEBRTC_MAC)
+    sched_yield();
+#else
+    nanosleep(&ts_null, nullptr);
+#endif
+  } while (!AtomicOps::AcquireLoad(&stop_flag_));
 #endif  // defined(WEBRTC_WIN)
 }
 
 bool PlatformThread::SetPriority(ThreadPriority priority) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(IsRunning());
 #if defined(WEBRTC_WIN)
   return SetThreadPriority(thread_, priority) != FALSE;
 #elif defined(__native_client__)
   // Setting thread priorities is not supported in NaCl.
@@ skipping 47 matching lines @@
 #if defined(WEBRTC_WIN)
 bool PlatformThread::QueueAPC(PAPCFUNC function, ULONG_PTR data) {
   RTC_DCHECK(thread_checker_.CalledOnValidThread());
   RTC_DCHECK(IsRunning());
 
   return QueueUserAPC(function, thread_, data) != FALSE;
 }
 #endif
 
 }  // namespace rtc