henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2004 The WebRTC Project Authors. All rights reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #include "rtc_base/thread.h" |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 12 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 13 | #if defined(WEBRTC_WIN) |
| 14 | #include <comdef.h> |
| 15 | #elif defined(WEBRTC_POSIX) |
| 16 | #include <time.h> |
| 17 | #endif |
| 18 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 19 | #include "rtc_base/checks.h" |
| 20 | #include "rtc_base/logging.h" |
| 21 | #include "rtc_base/nullsocketserver.h" |
| 22 | #include "rtc_base/platform_thread.h" |
| 23 | #include "rtc_base/stringutils.h" |
| 24 | #include "rtc_base/timeutils.h" |
| 25 | #include "rtc_base/trace_event.h" |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 26 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 27 | namespace rtc { |
| 28 | |
| 29 | ThreadManager* ThreadManager::Instance() { |
Andrew MacDonald | 469c2c0 | 2015-05-22 17:50:26 -0700 | [diff] [blame] | 30 | RTC_DEFINE_STATIC_LOCAL(ThreadManager, thread_manager, ()); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 31 | return &thread_manager; |
| 32 | } |
| 33 | |
nisse | 7866cfe | 2017-04-26 01:45:31 -0700 | [diff] [blame] | 34 | ThreadManager::~ThreadManager() { |
| 35 | // By above RTC_DEFINE_STATIC_LOCAL. |
| 36 | RTC_NOTREACHED() << "ThreadManager should never be destructed."; |
| 37 | } |
| 38 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 39 | // static |
| 40 | Thread* Thread::Current() { |
nisse | 7866cfe | 2017-04-26 01:45:31 -0700 | [diff] [blame] | 41 | ThreadManager* manager = ThreadManager::Instance(); |
| 42 | Thread* thread = manager->CurrentThread(); |
| 43 | |
| 44 | #ifndef NO_MAIN_THREAD_WRAPPING |
| 45 | // Only autowrap the thread which instantiated the ThreadManager. |
| 46 | if (!thread && manager->IsMainThread()) { |
tommi | e725159 | 2017-07-14 14:44:46 -0700 | [diff] [blame] | 47 | thread = new Thread(SocketServer::CreateDefault()); |
nisse | 7866cfe | 2017-04-26 01:45:31 -0700 | [diff] [blame] | 48 | thread->WrapCurrentWithThreadManager(manager, true); |
| 49 | } |
| 50 | #endif |
| 51 | |
| 52 | return thread; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 53 | } |
| 54 | |
| 55 | #if defined(WEBRTC_POSIX) |
kthelgason | 61abe15 | 2017-03-29 02:32:36 -0700 | [diff] [blame] | 56 | #if !defined(WEBRTC_MAC) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 57 | ThreadManager::ThreadManager() { |
nisse | 7866cfe | 2017-04-26 01:45:31 -0700 | [diff] [blame] | 58 | main_thread_ref_ = CurrentThreadRef(); |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 59 | pthread_key_create(&key_, nullptr); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 60 | } |
kthelgason | 61abe15 | 2017-03-29 02:32:36 -0700 | [diff] [blame] | 61 | #endif |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 62 | |
| 63 | Thread *ThreadManager::CurrentThread() { |
| 64 | return static_cast<Thread *>(pthread_getspecific(key_)); |
| 65 | } |
| 66 | |
| 67 | void ThreadManager::SetCurrentThread(Thread *thread) { |
| 68 | pthread_setspecific(key_, thread); |
| 69 | } |
| 70 | #endif |
| 71 | |
| 72 | #if defined(WEBRTC_WIN) |
| 73 | ThreadManager::ThreadManager() { |
nisse | 7866cfe | 2017-04-26 01:45:31 -0700 | [diff] [blame] | 74 | main_thread_ref_ = CurrentThreadRef(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 75 | key_ = TlsAlloc(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 76 | } |
| 77 | |
| 78 | Thread *ThreadManager::CurrentThread() { |
| 79 | return static_cast<Thread *>(TlsGetValue(key_)); |
| 80 | } |
| 81 | |
| 82 | void ThreadManager::SetCurrentThread(Thread *thread) { |
| 83 | TlsSetValue(key_, thread); |
| 84 | } |
| 85 | #endif |
| 86 | |
| 87 | Thread *ThreadManager::WrapCurrentThread() { |
| 88 | Thread* result = CurrentThread(); |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 89 | if (nullptr == result) { |
tommi | e725159 | 2017-07-14 14:44:46 -0700 | [diff] [blame] | 90 | result = new Thread(SocketServer::CreateDefault()); |
jiayl@webrtc.org | ba737cb | 2014-09-18 16:45:21 +0000 | [diff] [blame] | 91 | result->WrapCurrentWithThreadManager(this, true); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 92 | } |
| 93 | return result; |
| 94 | } |
| 95 | |
| 96 | void ThreadManager::UnwrapCurrentThread() { |
| 97 | Thread* t = CurrentThread(); |
| 98 | if (t && !(t->IsOwned())) { |
| 99 | t->UnwrapCurrent(); |
| 100 | delete t; |
| 101 | } |
| 102 | } |
| 103 | |
nisse | 7866cfe | 2017-04-26 01:45:31 -0700 | [diff] [blame] | 104 | bool ThreadManager::IsMainThread() { |
| 105 | return IsThreadRefEqual(CurrentThreadRef(), main_thread_ref_); |
| 106 | } |
| 107 | |
henrike@webrtc.org | 92a9bac | 2014-07-14 22:03:57 +0000 | [diff] [blame] | 108 | Thread::ScopedDisallowBlockingCalls::ScopedDisallowBlockingCalls() |
| 109 | : thread_(Thread::Current()), |
| 110 | previous_state_(thread_->SetAllowBlockingCalls(false)) { |
| 111 | } |
| 112 | |
| 113 | Thread::ScopedDisallowBlockingCalls::~ScopedDisallowBlockingCalls() { |
nisse | ede5da4 | 2017-01-12 05:15:36 -0800 | [diff] [blame] | 114 | RTC_DCHECK(thread_->IsCurrent()); |
henrike@webrtc.org | 92a9bac | 2014-07-14 22:03:57 +0000 | [diff] [blame] | 115 | thread_->SetAllowBlockingCalls(previous_state_); |
| 116 | } |
| 117 | |
tommi | e725159 | 2017-07-14 14:44:46 -0700 | [diff] [blame] | 118 | // DEPRECATED. |
danilchap | bebf54c | 2016-04-28 01:32:48 -0700 | [diff] [blame] | 119 | Thread::Thread() : Thread(SocketServer::CreateDefault()) {} |
| 120 | |
| 121 | Thread::Thread(SocketServer* ss) |
jbauch | 25d1f28 | 2016-02-05 00:25:02 -0800 | [diff] [blame] | 122 | : MessageQueue(ss, false), |
fischman@webrtc.org | e5063b1 | 2014-05-23 17:28:50 +0000 | [diff] [blame] | 123 | running_(true, false), |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 124 | #if defined(WEBRTC_WIN) |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 125 | thread_(nullptr), |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 126 | thread_id_(0), |
| 127 | #endif |
henrike@webrtc.org | 92a9bac | 2014-07-14 22:03:57 +0000 | [diff] [blame] | 128 | owned_(true), |
| 129 | blocking_calls_allowed_(true) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 130 | SetName("Thread", this); // default name |
danilchap | bebf54c | 2016-04-28 01:32:48 -0700 | [diff] [blame] | 131 | DoInit(); |
| 132 | } |
| 133 | |
| 134 | Thread::Thread(std::unique_ptr<SocketServer> ss) |
| 135 | : MessageQueue(std::move(ss), false), |
| 136 | running_(true, false), |
| 137 | #if defined(WEBRTC_WIN) |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 138 | thread_(nullptr), |
danilchap | bebf54c | 2016-04-28 01:32:48 -0700 | [diff] [blame] | 139 | thread_id_(0), |
| 140 | #endif |
| 141 | owned_(true), |
| 142 | blocking_calls_allowed_(true) { |
| 143 | SetName("Thread", this); // default name |
| 144 | DoInit(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 145 | } |
| 146 | |
| 147 | Thread::~Thread() { |
| 148 | Stop(); |
jbauch | 25d1f28 | 2016-02-05 00:25:02 -0800 | [diff] [blame] | 149 | DoDestroy(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 150 | } |
| 151 | |
nisse | 7866cfe | 2017-04-26 01:45:31 -0700 | [diff] [blame] | 152 | bool Thread::IsCurrent() const { |
| 153 | return ThreadManager::Instance()->CurrentThread() == this; |
| 154 | } |
| 155 | |
danilchap | bebf54c | 2016-04-28 01:32:48 -0700 | [diff] [blame] | 156 | std::unique_ptr<Thread> Thread::CreateWithSocketServer() { |
| 157 | return std::unique_ptr<Thread>(new Thread(SocketServer::CreateDefault())); |
| 158 | } |
| 159 | |
| 160 | std::unique_ptr<Thread> Thread::Create() { |
| 161 | return std::unique_ptr<Thread>( |
| 162 | new Thread(std::unique_ptr<SocketServer>(new NullSocketServer()))); |
| 163 | } |
| 164 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 165 | bool Thread::SleepMs(int milliseconds) { |
henrike@webrtc.org | 92a9bac | 2014-07-14 22:03:57 +0000 | [diff] [blame] | 166 | AssertBlockingIsAllowedOnCurrentThread(); |
| 167 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 168 | #if defined(WEBRTC_WIN) |
| 169 | ::Sleep(milliseconds); |
| 170 | return true; |
| 171 | #else |
| 172 | // POSIX has both a usleep() and a nanosleep(), but the former is deprecated, |
| 173 | // so we use nanosleep() even though it has greater precision than necessary. |
| 174 | struct timespec ts; |
| 175 | ts.tv_sec = milliseconds / 1000; |
| 176 | ts.tv_nsec = (milliseconds % 1000) * 1000000; |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 177 | int ret = nanosleep(&ts, nullptr); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 178 | if (ret != 0) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 179 | RTC_LOG_ERR(LS_WARNING) << "nanosleep() returning early"; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 180 | return false; |
| 181 | } |
| 182 | return true; |
| 183 | #endif |
| 184 | } |
| 185 | |
| 186 | bool Thread::SetName(const std::string& name, const void* obj) { |
fischman@webrtc.org | e5063b1 | 2014-05-23 17:28:50 +0000 | [diff] [blame] | 187 | if (running()) return false; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 188 | name_ = name; |
| 189 | if (obj) { |
| 190 | char buf[16]; |
| 191 | sprintfn(buf, sizeof(buf), " 0x%p", obj); |
| 192 | name_ += buf; |
| 193 | } |
| 194 | return true; |
| 195 | } |
| 196 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 197 | bool Thread::Start(Runnable* runnable) { |
nisse | ede5da4 | 2017-01-12 05:15:36 -0800 | [diff] [blame] | 198 | RTC_DCHECK(owned_); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 199 | if (!owned_) return false; |
nisse | ede5da4 | 2017-01-12 05:15:36 -0800 | [diff] [blame] | 200 | RTC_DCHECK(!running()); |
fischman@webrtc.org | e5063b1 | 2014-05-23 17:28:50 +0000 | [diff] [blame] | 201 | if (running()) return false; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 202 | |
André Susano Pinto | 02a5797 | 2016-07-22 13:30:05 +0200 | [diff] [blame] | 203 | Restart(); // reset IsQuitting() if the thread is being restarted |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 204 | |
| 205 | // Make sure that ThreadManager is created on the main thread before |
| 206 | // we start a new thread. |
| 207 | ThreadManager::Instance(); |
| 208 | |
| 209 | ThreadInit* init = new ThreadInit; |
| 210 | init->thread = this; |
| 211 | init->runnable = runnable; |
| 212 | #if defined(WEBRTC_WIN) |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 213 | thread_ = CreateThread(nullptr, 0, PreRun, init, 0, &thread_id_); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 214 | if (thread_) { |
fischman@webrtc.org | e5063b1 | 2014-05-23 17:28:50 +0000 | [diff] [blame] | 215 | running_.Set(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 216 | } else { |
| 217 | return false; |
| 218 | } |
| 219 | #elif defined(WEBRTC_POSIX) |
| 220 | pthread_attr_t attr; |
| 221 | pthread_attr_init(&attr); |
| 222 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 223 | int error_code = pthread_create(&thread_, &attr, PreRun, init); |
| 224 | if (0 != error_code) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 225 | RTC_LOG(LS_ERROR) << "Unable to create pthread, error " << error_code; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 226 | return false; |
| 227 | } |
fischman@webrtc.org | e5063b1 | 2014-05-23 17:28:50 +0000 | [diff] [blame] | 228 | running_.Set(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 229 | #endif |
| 230 | return true; |
| 231 | } |
| 232 | |
jiayl@webrtc.org | ba737cb | 2014-09-18 16:45:21 +0000 | [diff] [blame] | 233 | bool Thread::WrapCurrent() { |
| 234 | return WrapCurrentWithThreadManager(ThreadManager::Instance(), true); |
| 235 | } |
| 236 | |
| 237 | void Thread::UnwrapCurrent() { |
| 238 | // Clears the platform-specific thread-specific storage. |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 239 | ThreadManager::Instance()->SetCurrentThread(nullptr); |
jiayl@webrtc.org | ba737cb | 2014-09-18 16:45:21 +0000 | [diff] [blame] | 240 | #if defined(WEBRTC_WIN) |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 241 | if (thread_ != nullptr) { |
jiayl@webrtc.org | ba737cb | 2014-09-18 16:45:21 +0000 | [diff] [blame] | 242 | if (!CloseHandle(thread_)) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 243 | RTC_LOG_GLE(LS_ERROR) |
| 244 | << "When unwrapping thread, failed to close handle."; |
jiayl@webrtc.org | ba737cb | 2014-09-18 16:45:21 +0000 | [diff] [blame] | 245 | } |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 246 | thread_ = nullptr; |
jiayl@webrtc.org | ba737cb | 2014-09-18 16:45:21 +0000 | [diff] [blame] | 247 | } |
| 248 | #endif |
| 249 | running_.Reset(); |
| 250 | } |
| 251 | |
| 252 | void Thread::SafeWrapCurrent() { |
| 253 | WrapCurrentWithThreadManager(ThreadManager::Instance(), false); |
| 254 | } |
| 255 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 256 | void Thread::Join() { |
fischman@webrtc.org | e5063b1 | 2014-05-23 17:28:50 +0000 | [diff] [blame] | 257 | if (running()) { |
nisse | ede5da4 | 2017-01-12 05:15:36 -0800 | [diff] [blame] | 258 | RTC_DCHECK(!IsCurrent()); |
jiayl@webrtc.org | 1fd362c | 2014-09-26 16:57:07 +0000 | [diff] [blame] | 259 | if (Current() && !Current()->blocking_calls_allowed_) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 260 | RTC_LOG(LS_WARNING) << "Waiting for the thread to join, " |
| 261 | << "but blocking calls have been disallowed"; |
jiayl@webrtc.org | 1fd362c | 2014-09-26 16:57:07 +0000 | [diff] [blame] | 262 | } |
| 263 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 264 | #if defined(WEBRTC_WIN) |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 265 | RTC_DCHECK(thread_ != nullptr); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 266 | WaitForSingleObject(thread_, INFINITE); |
| 267 | CloseHandle(thread_); |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 268 | thread_ = nullptr; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 269 | thread_id_ = 0; |
| 270 | #elif defined(WEBRTC_POSIX) |
| 271 | void *pv; |
| 272 | pthread_join(thread_, &pv); |
| 273 | #endif |
fischman@webrtc.org | e5063b1 | 2014-05-23 17:28:50 +0000 | [diff] [blame] | 274 | running_.Reset(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 275 | } |
| 276 | } |
| 277 | |
henrike@webrtc.org | 92a9bac | 2014-07-14 22:03:57 +0000 | [diff] [blame] | 278 | bool Thread::SetAllowBlockingCalls(bool allow) { |
nisse | ede5da4 | 2017-01-12 05:15:36 -0800 | [diff] [blame] | 279 | RTC_DCHECK(IsCurrent()); |
henrike@webrtc.org | 92a9bac | 2014-07-14 22:03:57 +0000 | [diff] [blame] | 280 | bool previous = blocking_calls_allowed_; |
| 281 | blocking_calls_allowed_ = allow; |
| 282 | return previous; |
| 283 | } |
| 284 | |
| 285 | // static |
| 286 | void Thread::AssertBlockingIsAllowedOnCurrentThread() { |
tfarina | a41ab93 | 2015-10-30 16:08:48 -0700 | [diff] [blame] | 287 | #if !defined(NDEBUG) |
henrike@webrtc.org | 92a9bac | 2014-07-14 22:03:57 +0000 | [diff] [blame] | 288 | Thread* current = Thread::Current(); |
nisse | ede5da4 | 2017-01-12 05:15:36 -0800 | [diff] [blame] | 289 | RTC_DCHECK(!current || current->blocking_calls_allowed_); |
henrike@webrtc.org | 92a9bac | 2014-07-14 22:03:57 +0000 | [diff] [blame] | 290 | #endif |
| 291 | } |
| 292 | |
deadbeef | dc20e26 | 2017-01-31 15:10:44 -0800 | [diff] [blame] | 293 | // static |
kthelgason | 61abe15 | 2017-03-29 02:32:36 -0700 | [diff] [blame] | 294 | #if !defined(WEBRTC_MAC) |
deadbeef | dc20e26 | 2017-01-31 15:10:44 -0800 | [diff] [blame] | 295 | #if defined(WEBRTC_WIN) |
| 296 | DWORD WINAPI Thread::PreRun(LPVOID pv) { |
| 297 | #else |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 298 | void* Thread::PreRun(void* pv) { |
deadbeef | dc20e26 | 2017-01-31 15:10:44 -0800 | [diff] [blame] | 299 | #endif |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 300 | ThreadInit* init = static_cast<ThreadInit*>(pv); |
| 301 | ThreadManager::Instance()->SetCurrentThread(init->thread); |
Tommi | ea14f0a | 2015-05-18 13:51:06 +0200 | [diff] [blame] | 302 | rtc::SetCurrentThreadName(init->thread->name_.c_str()); |
kthelgason | de6adbe | 2017-02-22 00:42:11 -0800 | [diff] [blame] | 303 | if (init->runnable) { |
| 304 | init->runnable->Run(init->thread); |
| 305 | } else { |
| 306 | init->thread->Run(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 307 | } |
kthelgason | de6adbe | 2017-02-22 00:42:11 -0800 | [diff] [blame] | 308 | delete init; |
| 309 | #ifdef WEBRTC_WIN |
| 310 | return 0; |
| 311 | #else |
| 312 | return nullptr; |
| 313 | #endif |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 314 | } |
kthelgason | 61abe15 | 2017-03-29 02:32:36 -0700 | [diff] [blame] | 315 | #endif |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 316 | |
| 317 | void Thread::Run() { |
| 318 | ProcessMessages(kForever); |
| 319 | } |
| 320 | |
| 321 | bool Thread::IsOwned() { |
| 322 | return owned_; |
| 323 | } |
| 324 | |
| 325 | void Thread::Stop() { |
| 326 | MessageQueue::Quit(); |
| 327 | Join(); |
| 328 | } |
| 329 | |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 330 | void Thread::Send(const Location& posted_from, |
| 331 | MessageHandler* phandler, |
| 332 | uint32_t id, |
| 333 | MessageData* pdata) { |
André Susano Pinto | 02a5797 | 2016-07-22 13:30:05 +0200 | [diff] [blame] | 334 | if (IsQuitting()) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 335 | return; |
| 336 | |
| 337 | // Sent messages are sent to the MessageHandler directly, in the context |
| 338 | // of "thread", like Win32 SendMessage. If in the right context, |
| 339 | // call the handler directly. |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 340 | Message msg; |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 341 | msg.posted_from = posted_from; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 342 | msg.phandler = phandler; |
| 343 | msg.message_id = id; |
| 344 | msg.pdata = pdata; |
| 345 | if (IsCurrent()) { |
| 346 | phandler->OnMessage(&msg); |
| 347 | return; |
| 348 | } |
| 349 | |
jiayl@webrtc.org | 3987b6d | 2014-09-24 17:14:05 +0000 | [diff] [blame] | 350 | AssertBlockingIsAllowedOnCurrentThread(); |
| 351 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 352 | AutoThread thread; |
| 353 | Thread *current_thread = Thread::Current(); |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 354 | RTC_DCHECK(current_thread != nullptr); // AutoThread ensures this |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 355 | |
| 356 | bool ready = false; |
| 357 | { |
| 358 | CritScope cs(&crit_); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 359 | _SendMessage smsg; |
| 360 | smsg.thread = current_thread; |
| 361 | smsg.msg = msg; |
| 362 | smsg.ready = &ready; |
| 363 | sendlist_.push_back(smsg); |
| 364 | } |
| 365 | |
| 366 | // Wait for a reply |
jbauch | 9ccedc3 | 2016-02-25 01:14:56 -0800 | [diff] [blame] | 367 | WakeUpSocketServer(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 368 | |
| 369 | bool waited = false; |
| 370 | crit_.Enter(); |
| 371 | while (!ready) { |
| 372 | crit_.Leave(); |
jiayl@webrtc.org | 3987b6d | 2014-09-24 17:14:05 +0000 | [diff] [blame] | 373 | // We need to limit "ReceiveSends" to |this| thread to avoid an arbitrary |
| 374 | // thread invoking calls on the current thread. |
| 375 | current_thread->ReceiveSendsFromThread(this); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 376 | current_thread->socketserver()->Wait(kForever, false); |
| 377 | waited = true; |
| 378 | crit_.Enter(); |
| 379 | } |
| 380 | crit_.Leave(); |
| 381 | |
| 382 | // Our Wait loop above may have consumed some WakeUp events for this |
| 383 | // MessageQueue, that weren't relevant to this Send. Losing these WakeUps can |
| 384 | // cause problems for some SocketServers. |
| 385 | // |
| 386 | // Concrete example: |
| 387 | // Win32SocketServer on thread A calls Send on thread B. While processing the |
| 388 | // message, thread B Posts a message to A. We consume the wakeup for that |
| 389 | // Post while waiting for the Send to complete, which means that when we exit |
| 390 | // this loop, we need to issue another WakeUp, or else the Posted message |
| 391 | // won't be processed in a timely manner. |
| 392 | |
| 393 | if (waited) { |
| 394 | current_thread->socketserver()->WakeUp(); |
| 395 | } |
| 396 | } |
| 397 | |
| 398 | void Thread::ReceiveSends() { |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 399 | ReceiveSendsFromThread(nullptr); |
jiayl@webrtc.org | 3987b6d | 2014-09-24 17:14:05 +0000 | [diff] [blame] | 400 | } |
| 401 | |
| 402 | void Thread::ReceiveSendsFromThread(const Thread* source) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 403 | // Receive a sent message. Cleanup scenarios: |
| 404 | // - thread sending exits: We don't allow this, since thread can exit |
| 405 | // only via Join, so Send must complete. |
| 406 | // - thread receiving exits: Wakeup/set ready in Thread::Clear() |
| 407 | // - object target cleared: Wakeup/set ready in Thread::Clear() |
jiayl@webrtc.org | 3987b6d | 2014-09-24 17:14:05 +0000 | [diff] [blame] | 408 | _SendMessage smsg; |
| 409 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 410 | crit_.Enter(); |
jiayl@webrtc.org | 3987b6d | 2014-09-24 17:14:05 +0000 | [diff] [blame] | 411 | while (PopSendMessageFromThread(source, &smsg)) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 412 | crit_.Leave(); |
jiayl@webrtc.org | 3987b6d | 2014-09-24 17:14:05 +0000 | [diff] [blame] | 413 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 414 | smsg.msg.phandler->OnMessage(&smsg.msg); |
jiayl@webrtc.org | 3987b6d | 2014-09-24 17:14:05 +0000 | [diff] [blame] | 415 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 416 | crit_.Enter(); |
| 417 | *smsg.ready = true; |
| 418 | smsg.thread->socketserver()->WakeUp(); |
| 419 | } |
| 420 | crit_.Leave(); |
| 421 | } |
| 422 | |
jiayl@webrtc.org | 3987b6d | 2014-09-24 17:14:05 +0000 | [diff] [blame] | 423 | bool Thread::PopSendMessageFromThread(const Thread* source, _SendMessage* msg) { |
| 424 | for (std::list<_SendMessage>::iterator it = sendlist_.begin(); |
| 425 | it != sendlist_.end(); ++it) { |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 426 | if (it->thread == source || source == nullptr) { |
jiayl@webrtc.org | 3987b6d | 2014-09-24 17:14:05 +0000 | [diff] [blame] | 427 | *msg = *it; |
| 428 | sendlist_.erase(it); |
| 429 | return true; |
| 430 | } |
| 431 | } |
| 432 | return false; |
| 433 | } |
| 434 | |
Taylor Brandstetter | 5d97a9a | 2016-06-10 14:17:27 -0700 | [diff] [blame] | 435 | void Thread::InvokeInternal(const Location& posted_from, |
| 436 | MessageHandler* handler) { |
| 437 | TRACE_EVENT2("webrtc", "Thread::Invoke", "src_file_and_line", |
| 438 | posted_from.file_and_line(), "src_func", |
| 439 | posted_from.function_name()); |
| 440 | Send(posted_from, handler); |
tommi@webrtc.org | 7c64ed2 | 2015-03-17 14:25:37 +0000 | [diff] [blame] | 441 | } |
| 442 | |
Peter Boström | 0c4e06b | 2015-10-07 12:23:21 +0200 | [diff] [blame] | 443 | void Thread::Clear(MessageHandler* phandler, |
| 444 | uint32_t id, |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 445 | MessageList* removed) { |
| 446 | CritScope cs(&crit_); |
| 447 | |
| 448 | // Remove messages on sendlist_ with phandler |
| 449 | // Object target cleared: remove from send list, wakeup/set ready |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 450 | // if sender not null. |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 451 | |
| 452 | std::list<_SendMessage>::iterator iter = sendlist_.begin(); |
| 453 | while (iter != sendlist_.end()) { |
| 454 | _SendMessage smsg = *iter; |
| 455 | if (smsg.msg.Match(phandler, id)) { |
| 456 | if (removed) { |
| 457 | removed->push_back(smsg.msg); |
| 458 | } else { |
| 459 | delete smsg.msg.pdata; |
| 460 | } |
| 461 | iter = sendlist_.erase(iter); |
| 462 | *smsg.ready = true; |
| 463 | smsg.thread->socketserver()->WakeUp(); |
| 464 | continue; |
| 465 | } |
| 466 | ++iter; |
| 467 | } |
| 468 | |
| 469 | MessageQueue::Clear(phandler, id, removed); |
| 470 | } |
| 471 | |
kthelgason | 61abe15 | 2017-03-29 02:32:36 -0700 | [diff] [blame] | 472 | #if !defined(WEBRTC_MAC) |
| 473 | // Note that these methods have a separate implementation for mac and ios |
kjellander | e96c45b | 2017-06-30 10:45:21 -0700 | [diff] [blame] | 474 | // defined in webrtc/rtc_base/thread_darwin.mm. |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 475 | bool Thread::ProcessMessages(int cmsLoop) { |
deadbeef | 22e0814 | 2017-06-12 14:30:28 -0700 | [diff] [blame] | 476 | // Using ProcessMessages with a custom clock for testing and a time greater |
| 477 | // than 0 doesn't work, since it's not guaranteed to advance the custom |
| 478 | // clock's time, and may get stuck in an infinite loop. |
| 479 | RTC_DCHECK(GetClockForTesting() == nullptr || cmsLoop == 0 || |
| 480 | cmsLoop == kForever); |
Honghai Zhang | 82d7862 | 2016-05-06 11:29:15 -0700 | [diff] [blame] | 481 | int64_t msEnd = (kForever == cmsLoop) ? 0 : TimeAfter(cmsLoop); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 482 | int cmsNext = cmsLoop; |
| 483 | |
| 484 | while (true) { |
kthelgason | de6adbe | 2017-02-22 00:42:11 -0800 | [diff] [blame] | 485 | Message msg; |
| 486 | if (!Get(&msg, cmsNext)) |
| 487 | return !IsQuitting(); |
| 488 | Dispatch(&msg); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 489 | |
kthelgason | de6adbe | 2017-02-22 00:42:11 -0800 | [diff] [blame] | 490 | if (cmsLoop != kForever) { |
| 491 | cmsNext = static_cast<int>(TimeUntil(msEnd)); |
| 492 | if (cmsNext < 0) |
| 493 | return true; |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 494 | } |
| 495 | } |
| 496 | } |
kthelgason | 61abe15 | 2017-03-29 02:32:36 -0700 | [diff] [blame] | 497 | #endif |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 498 | |
jiayl@webrtc.org | ba737cb | 2014-09-18 16:45:21 +0000 | [diff] [blame] | 499 | bool Thread::WrapCurrentWithThreadManager(ThreadManager* thread_manager, |
| 500 | bool need_synchronize_access) { |
fischman@webrtc.org | e5063b1 | 2014-05-23 17:28:50 +0000 | [diff] [blame] | 501 | if (running()) |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 502 | return false; |
jiayl@webrtc.org | ba737cb | 2014-09-18 16:45:21 +0000 | [diff] [blame] | 503 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 504 | #if defined(WEBRTC_WIN) |
jiayl@webrtc.org | ba737cb | 2014-09-18 16:45:21 +0000 | [diff] [blame] | 505 | if (need_synchronize_access) { |
| 506 | // We explicitly ask for no rights other than synchronization. |
| 507 | // This gives us the best chance of succeeding. |
| 508 | thread_ = OpenThread(SYNCHRONIZE, FALSE, GetCurrentThreadId()); |
| 509 | if (!thread_) { |
Mirko Bonadei | 675513b | 2017-11-09 11:09:25 +0100 | [diff] [blame] | 510 | RTC_LOG_GLE(LS_ERROR) << "Unable to get handle to thread."; |
jiayl@webrtc.org | ba737cb | 2014-09-18 16:45:21 +0000 | [diff] [blame] | 511 | return false; |
| 512 | } |
| 513 | thread_id_ = GetCurrentThreadId(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 514 | } |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 515 | #elif defined(WEBRTC_POSIX) |
| 516 | thread_ = pthread_self(); |
| 517 | #endif |
jiayl@webrtc.org | ba737cb | 2014-09-18 16:45:21 +0000 | [diff] [blame] | 518 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 519 | owned_ = false; |
fischman@webrtc.org | e5063b1 | 2014-05-23 17:28:50 +0000 | [diff] [blame] | 520 | running_.Set(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 521 | thread_manager->SetCurrentThread(this); |
| 522 | return true; |
| 523 | } |
| 524 | |
tommi | e725159 | 2017-07-14 14:44:46 -0700 | [diff] [blame] | 525 | AutoThread::AutoThread() : Thread(SocketServer::CreateDefault()) { |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 526 | if (!ThreadManager::Instance()->CurrentThread()) { |
| 527 | ThreadManager::Instance()->SetCurrentThread(this); |
| 528 | } |
| 529 | } |
| 530 | |
| 531 | AutoThread::~AutoThread() { |
| 532 | Stop(); |
Steve Anton | 3b80aac | 2017-10-19 10:17:12 -0700 | [diff] [blame] | 533 | DoDestroy(); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 534 | if (ThreadManager::Instance()->CurrentThread() == this) { |
deadbeef | 37f5ecf | 2017-02-27 14:06:41 -0800 | [diff] [blame] | 535 | ThreadManager::Instance()->SetCurrentThread(nullptr); |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 536 | } |
| 537 | } |
| 538 | |
nisse | 7eaa4ea | 2017-05-08 05:25:41 -0700 | [diff] [blame] | 539 | AutoSocketServerThread::AutoSocketServerThread(SocketServer* ss) |
| 540 | : Thread(ss) { |
| 541 | old_thread_ = ThreadManager::Instance()->CurrentThread(); |
| 542 | rtc::ThreadManager::Instance()->SetCurrentThread(this); |
| 543 | if (old_thread_) { |
| 544 | MessageQueueManager::Remove(old_thread_); |
| 545 | } |
| 546 | } |
| 547 | |
| 548 | AutoSocketServerThread::~AutoSocketServerThread() { |
| 549 | RTC_DCHECK(ThreadManager::Instance()->CurrentThread() == this); |
| 550 | // Some tests post destroy messages to this thread. To avoid memory |
| 551 | // leaks, we have to process those messages. In particular |
| 552 | // P2PTransportChannelPingTest, relying on the message posted in |
| 553 | // cricket::Connection::Destroy. |
| 554 | ProcessMessages(0); |
Steve Anton | 3b80aac | 2017-10-19 10:17:12 -0700 | [diff] [blame] | 555 | // Stop and destroy the thread before clearing it as the current thread. |
| 556 | // Sometimes there are messages left in the MessageQueue that will be |
| 557 | // destroyed by DoDestroy, and sometimes the destructors of the message and/or |
| 558 | // its contents rely on this thread still being set as the current thread. |
| 559 | Stop(); |
| 560 | DoDestroy(); |
nisse | 7eaa4ea | 2017-05-08 05:25:41 -0700 | [diff] [blame] | 561 | rtc::ThreadManager::Instance()->SetCurrentThread(old_thread_); |
| 562 | if (old_thread_) { |
| 563 | MessageQueueManager::Add(old_thread_); |
| 564 | } |
| 565 | } |
| 566 | |
henrike@webrtc.org | f048872 | 2014-05-13 18:00:26 +0000 | [diff] [blame] | 567 | } // namespace rtc |