xpcom/threads/LazyIdleThread.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "LazyIdleThread.h"
   8
   9 #include "nsIObserverService.h"
  10
  11 #include "GeckoProfiler.h"
  12 #include "nsComponentManagerUtils.h"
  13 #include "nsServiceManagerUtils.h"
  14 #include "nsThreadUtils.h"
  15 #include "mozilla/Services.h"
  16
  17 #ifdef DEBUG
  18 #define ASSERT_OWNING_THREAD()                                                 \
  19   PR_BEGIN_MACRO                                                               \
  20     nsIThread* currentThread = NS_GetCurrentThread();                          \
  21     if (currentThread) {                                                       \
  22       nsCOMPtr<nsISupports> current(do_QueryInterface(currentThread));         \
  23       nsCOMPtr<nsISupports> test(do_QueryInterface(mOwningThread));            \
  24       MOZ_ASSERT(current == test, "Wrong thread!");                            \
  25     }                                                                          \
  26   PR_END_MACRO
  27 #else
  28 #define ASSERT_OWNING_THREAD() /* nothing */
  29 #endif
  30
  31 namespace mozilla {
  32
  33 LazyIdleThread::LazyIdleThread(uint32_t aIdleTimeoutMS,
  34                                const nsCSubstring& aName,
  35                                ShutdownMethod aShutdownMethod,
  36                                nsIObserver* aIdleObserver)
  37 : mMutex("LazyIdleThread::mMutex"),
  38   mOwningThread(NS_GetCurrentThread()),
  39   mIdleObserver(aIdleObserver),
  40   mQueuedRunnables(nullptr),
  41   mIdleTimeoutMS(aIdleTimeoutMS),
  42   mPendingEventCount(0),
  43   mIdleNotificationCount(0),
  44   mShutdownMethod(aShutdownMethod),
  45   mShutdown(false),
  46   mThreadIsShuttingDown(false),
  47   mIdleTimeoutEnabled(true),
  48   mName(aName)
  49 {
  50   MOZ_ASSERT(mOwningThread, "Need owning thread!");
  51 }
  52
  53 LazyIdleThread::~LazyIdleThread()
  54 {
  55   ASSERT_OWNING_THREAD();
  56
  57   Shutdown();
  58 }
  59
  60 void
  61 LazyIdleThread::SetWeakIdleObserver(nsIObserver* aObserver)
  62 {
  63   ASSERT_OWNING_THREAD();
  64
  65   if (mShutdown) {
  66     NS_WARN_IF_FALSE(!aObserver,
  67                      "Setting an observer after Shutdown was called!");
  68     return;
  69   }
  70
  71   mIdleObserver = aObserver;
  72 }
  73
  74 void
  75 LazyIdleThread::DisableIdleTimeout()
  76 {
  77   ASSERT_OWNING_THREAD();
  78   if (!mIdleTimeoutEnabled) {
  79     return;
  80   }
  81   mIdleTimeoutEnabled = false;
  82
  83   if (mIdleTimer && NS_FAILED(mIdleTimer->Cancel())) {
  84     NS_WARNING("Failed to cancel timer!");
  85   }
  86
  87   MutexAutoLock lock(mMutex);
  88
  89   // Pretend we have a pending event to keep the idle timer from firing.
  90   MOZ_ASSERT(mPendingEventCount < UINT32_MAX, "Way too many!");
  91   mPendingEventCount++;
  92 }
  93
  94 void
  95 LazyIdleThread::EnableIdleTimeout()
  96 {
  97   ASSERT_OWNING_THREAD();
  98   if (mIdleTimeoutEnabled) {
  99     return;
 100   }
 101   mIdleTimeoutEnabled = true;
 102
 103   {
 104     MutexAutoLock lock(mMutex);
 105
 106     MOZ_ASSERT(mPendingEventCount, "Mismatched calls to observer methods!");
 107     --mPendingEventCount;
 108   }
 109
 110   if (mThread) {
 111     nsCOMPtr<nsIRunnable> runnable(new nsRunnable());
 112     if (NS_FAILED(Dispatch(runnable, NS_DISPATCH_NORMAL))) {
 113       NS_WARNING("Failed to dispatch!");
 114     }
 115   }
 116 }
 117
 118 void
 119 LazyIdleThread::PreDispatch()
 120 {
 121   MutexAutoLock lock(mMutex);
 122
 123   MOZ_ASSERT(mPendingEventCount < UINT32_MAX, "Way too many!");
 124   mPendingEventCount++;
 125 }
 126
 127 nsresult
 128 LazyIdleThread::EnsureThread()
 129 {
 130   ASSERT_OWNING_THREAD();
 131
 132   if (mShutdown) {
 133     return NS_ERROR_UNEXPECTED;
 134   }
 135
 136   if (mThread) {
 137     return NS_OK;
 138   }
 139
 140   MOZ_ASSERT(!mPendingEventCount, "Shouldn't have events yet!");
 141   MOZ_ASSERT(!mIdleNotificationCount, "Shouldn't have idle events yet!");
 142   MOZ_ASSERT(!mIdleTimer, "Should have killed this long ago!");
 143   MOZ_ASSERT(!mThreadIsShuttingDown, "Should have cleared that!");
 144
 145   nsresult rv;
 146
 147   if (mShutdownMethod == AutomaticShutdown && NS_IsMainThread()) {
 148     nsCOMPtr<nsIObserverService> obs =
 149       do_GetService(NS_OBSERVERSERVICE_CONTRACTID, &rv);
 150     NS_ENSURE_SUCCESS(rv, rv);
 151
 152     rv = obs->AddObserver(this, "xpcom-shutdown-threads", false);
 153     NS_ENSURE_SUCCESS(rv, rv);
 154   }
 155
 156   mIdleTimer = do_CreateInstance(NS_TIMER_CONTRACTID, &rv);
 157   NS_ENSURE_TRUE(mIdleTimer, NS_ERROR_FAILURE);
 158
 159   nsCOMPtr<nsIRunnable> runnable =
 160     NS_NewRunnableMethod(this, &LazyIdleThread::InitThread);
 161   NS_ENSURE_TRUE(runnable, NS_ERROR_FAILURE);
 162
 163   rv = NS_NewThread(getter_AddRefs(mThread), runnable);
 164   NS_ENSURE_SUCCESS(rv, rv);
 165
 166   return NS_OK;
 167 }
 168
 169 void
 170 LazyIdleThread::InitThread()
 171 {
 172   char aLocal;
 173   profiler_register_thread(mName.get(), &aLocal);
 174
 175   PR_SetCurrentThreadName(mName.get());
 176
 177   // Happens on mThread but mThread may not be set yet...
 178
 179   nsCOMPtr<nsIThreadInternal> thread(do_QueryInterface(NS_GetCurrentThread()));
 180   MOZ_ASSERT(thread, "This should always succeed!");
 181
 182   if (NS_FAILED(thread->SetObserver(this))) {
 183     NS_WARNING("Failed to set thread observer!");
 184   }
 185 }
 186
 187 void
 188 LazyIdleThread::CleanupThread()
 189 {
 190   nsCOMPtr<nsIThreadInternal> thread(do_QueryInterface(NS_GetCurrentThread()));
 191   MOZ_ASSERT(thread, "This should always succeed!");
 192
 193   if (NS_FAILED(thread->SetObserver(nullptr))) {
 194     NS_WARNING("Failed to set thread observer!");
 195   }
 196
 197   {
 198     MutexAutoLock lock(mMutex);
 199
 200     MOZ_ASSERT(!mThreadIsShuttingDown, "Shouldn't be true ever!");
 201     mThreadIsShuttingDown = true;
 202   }
 203
 204   profiler_unregister_thread();
 205 }
 206
 207 void
 208 LazyIdleThread::ScheduleTimer()
 209 {
 210   ASSERT_OWNING_THREAD();
 211
 212   bool shouldSchedule;
 213   {
 214     MutexAutoLock lock(mMutex);
 215
 216     MOZ_ASSERT(mIdleNotificationCount, "Should have at least one!");
 217     --mIdleNotificationCount;
 218
 219     shouldSchedule = !mIdleNotificationCount && !mPendingEventCount;
 220   }
 221
 222   if (NS_FAILED(mIdleTimer->Cancel())) {
 223     NS_WARNING("Failed to cancel timer!");
 224   }
 225
 226   if (shouldSchedule &&
 227       NS_FAILED(mIdleTimer->InitWithCallback(this, mIdleTimeoutMS,
 228                                              nsITimer::TYPE_ONE_SHOT))) {
 229     NS_WARNING("Failed to schedule timer!");
 230   }
 231 }
 232
 233 nsresult
 234 LazyIdleThread::ShutdownThread()
 235 {
 236   ASSERT_OWNING_THREAD();
 237
 238   // Before calling Shutdown() on the real thread we need to put a queue in
 239   // place in case a runnable is posted to the thread while it's in the
 240   // process of shutting down. This will be our queue.
 241   nsAutoTArray<nsCOMPtr<nsIRunnable>, 10> queuedRunnables;
 242
 243   nsresult rv;
 244
 245   if (mThread) {
 246     if (mShutdownMethod == AutomaticShutdown && NS_IsMainThread()) {
 247       nsCOMPtr<nsIObserverService> obs =
 248         mozilla::services::GetObserverService();
 249       NS_WARN_IF_FALSE(obs, "Failed to get observer service!");
 250
 251       if (obs &&
 252           NS_FAILED(obs->RemoveObserver(this, "xpcom-shutdown-threads"))) {
 253         NS_WARNING("Failed to remove observer!");
 254       }
 255     }
 256
 257     if (mIdleObserver) {
 258       mIdleObserver->Observe(static_cast<nsIThread*>(this), IDLE_THREAD_TOPIC,
 259                              nullptr);
 260     }
 261
 262 #ifdef DEBUG
 263     {
 264       MutexAutoLock lock(mMutex);
 265       MOZ_ASSERT(!mThreadIsShuttingDown, "Huh?!");
 266     }
 267 #endif
 268
 269     nsCOMPtr<nsIRunnable> runnable =
 270       NS_NewRunnableMethod(this, &LazyIdleThread::CleanupThread);
 271     NS_ENSURE_TRUE(runnable, NS_ERROR_FAILURE);
 272
 273     PreDispatch();
 274
 275     rv = mThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
 276     NS_ENSURE_SUCCESS(rv, rv);
 277
 278     // Put the temporary queue in place before calling Shutdown().
 279     mQueuedRunnables = &queuedRunnables;
 280
 281     if (NS_FAILED(mThread->Shutdown())) {
 282       NS_ERROR("Failed to shutdown the thread!");
 283     }
 284
 285     // Now unset the queue.
 286     mQueuedRunnables = nullptr;
 287
 288     mThread = nullptr;
 289
 290     {
 291       MutexAutoLock lock(mMutex);
 292
 293       MOZ_ASSERT(!mPendingEventCount, "Huh?!");
 294       MOZ_ASSERT(!mIdleNotificationCount, "Huh?!");
 295       MOZ_ASSERT(mThreadIsShuttingDown, "Huh?!");
 296       mThreadIsShuttingDown = false;
 297     }
 298   }
 299
 300   if (mIdleTimer) {
 301     rv = mIdleTimer->Cancel();
 302     NS_ENSURE_SUCCESS(rv, rv);
 303
 304     mIdleTimer = nullptr;
 305   }
 306
 307   // If our temporary queue has any runnables then we need to dispatch them.
 308   if (queuedRunnables.Length()) {
 309     // If the thread manager has gone away then these runnables will never run.
 310     if (mShutdown) {
 311       NS_ERROR("Runnables dispatched to LazyIdleThread will never run!");
 312       return NS_OK;
 313     }
 314
 315     // Re-dispatch the queued runnables.
 316     for (uint32_t index = 0; index < queuedRunnables.Length(); index++) {
 317       nsCOMPtr<nsIRunnable> runnable;
 318       runnable.swap(queuedRunnables[index]);
 319       MOZ_ASSERT(runnable, "Null runnable?!");
 320
 321       if (NS_FAILED(Dispatch(runnable, NS_DISPATCH_NORMAL))) {
 322         NS_ERROR("Failed to re-dispatch queued runnable!");
 323       }
 324     }
 325   }
 326
 327   return NS_OK;
 328 }
 329
 330 void
 331 LazyIdleThread::SelfDestruct()
 332 {
 333   MOZ_ASSERT(mRefCnt == 1, "Bad refcount!");
 334   delete this;
 335 }
 336
 337 NS_IMPL_ADDREF(LazyIdleThread)
 338
 339 NS_IMETHODIMP_(nsrefcnt)
 340 LazyIdleThread::Release()
 341 {
 342   nsrefcnt count = --mRefCnt;
 343   NS_LOG_RELEASE(this, count, "LazyIdleThread");
 344
 345   if (!count) {
 346     // Stabilize refcount.
 347     mRefCnt = 1;
 348
 349     nsCOMPtr<nsIRunnable> runnable =
 350       NS_NewNonOwningRunnableMethod(this, &LazyIdleThread::SelfDestruct);
 351     NS_WARN_IF_FALSE(runnable, "Couldn't make runnable!");
 352
 353     if (NS_FAILED(NS_DispatchToCurrentThread(runnable))) {
 354       MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
 355       // The only way this could fail is if we're in shutdown, and in that case
 356       // threads should have been joined already. Deleting here isn't dangerous
 357       // anymore because we won't spin the event loop waiting to join the
 358       // thread.
 359       SelfDestruct();
 360     }
 361   }
 362
 363   return count;
 364 }
 365
 366 NS_IMPL_QUERY_INTERFACE5(LazyIdleThread, nsIThread,
 367                          nsIEventTarget,
 368                          nsITimerCallback,
 369                          nsIThreadObserver,
 370                          nsIObserver)
 371
 372 NS_IMETHODIMP
 373 LazyIdleThread::Dispatch(nsIRunnable* aEvent,
 374                          uint32_t aFlags)
 375 {
 376   ASSERT_OWNING_THREAD();
 377
 378   // LazyIdleThread can't always support synchronous dispatch currently.
 379   NS_ENSURE_TRUE(aFlags == NS_DISPATCH_NORMAL, NS_ERROR_NOT_IMPLEMENTED);
 380
 381   // If our thread is shutting down then we can't actually dispatch right now.
 382   // Queue this runnable for later.
 383   if (UseRunnableQueue()) {
 384     mQueuedRunnables->AppendElement(aEvent);
 385     return NS_OK;
 386   }
 387
 388   nsresult rv = EnsureThread();
 389   NS_ENSURE_SUCCESS(rv, rv);
 390
 391   PreDispatch();
 392
 393   return mThread->Dispatch(aEvent, aFlags);
 394 }
 395
 396 NS_IMETHODIMP
 397 LazyIdleThread::IsOnCurrentThread(bool* aIsOnCurrentThread)
 398 {
 399   if (mThread) {
 400     return mThread->IsOnCurrentThread(aIsOnCurrentThread);
 401   }
 402
 403   *aIsOnCurrentThread = false;
 404   return NS_OK;
 405 }
 406
 407 NS_IMETHODIMP
 408 LazyIdleThread::GetPRThread(PRThread** aPRThread)
 409 {
 410   if (mThread) {
 411     return mThread->GetPRThread(aPRThread);
 412   }
 413
 414   *aPRThread = nullptr;
 415   return NS_ERROR_NOT_AVAILABLE;
 416 }
 417
 418 NS_IMETHODIMP
 419 LazyIdleThread::Shutdown()
 420 {
 421   ASSERT_OWNING_THREAD();
 422
 423   mShutdown = true;
 424
 425   nsresult rv = ShutdownThread();
 426   MOZ_ASSERT(!mThread, "Should have destroyed this by now!");
 427
 428   mIdleObserver = nullptr;
 429
 430   NS_ENSURE_SUCCESS(rv, rv);
 431
 432   return NS_OK;
 433 }
 434
 435 NS_IMETHODIMP
 436 LazyIdleThread::HasPendingEvents(bool* aHasPendingEvents)
 437 {
 438   // This is only supposed to be called from the thread itself so it's not
 439   // implemented here.
 440   NS_NOTREACHED("Shouldn't ever call this!");
 441   return NS_ERROR_UNEXPECTED;
 442 }
 443
 444 NS_IMETHODIMP
 445 LazyIdleThread::ProcessNextEvent(bool aMayWait,
 446                                  bool* aEventWasProcessed)
 447 {
 448   // This is only supposed to be called from the thread itself so it's not
 449   // implemented here.
 450   NS_NOTREACHED("Shouldn't ever call this!");
 451   return NS_ERROR_UNEXPECTED;
 452 }
 453
 454 NS_IMETHODIMP
 455 LazyIdleThread::Notify(nsITimer* aTimer)
 456 {
 457   ASSERT_OWNING_THREAD();
 458
 459   {
 460     MutexAutoLock lock(mMutex);
 461
 462     if (mPendingEventCount || mIdleNotificationCount) {
 463       // Another event was scheduled since this timer was set. Don't do
 464       // anything and wait for the timer to fire again.
 465       return NS_OK;
 466     }
 467   }
 468
 469   nsresult rv = ShutdownThread();
 470   NS_ENSURE_SUCCESS(rv, rv);
 471
 472   return NS_OK;
 473 }
 474
 475 NS_IMETHODIMP
 476 LazyIdleThread::OnDispatchedEvent(nsIThreadInternal* /*aThread */)
 477 {
 478   MOZ_ASSERT(NS_GetCurrentThread() == mOwningThread, "Wrong thread!");
 479   return NS_OK;
 480 }
 481
 482 NS_IMETHODIMP
 483 LazyIdleThread::OnProcessNextEvent(nsIThreadInternal* /* aThread */,
 484                                    bool /* aMayWait */,
 485                                    uint32_t /* aRecursionDepth */)
 486 {
 487   return NS_OK;
 488 }
 489
 490 NS_IMETHODIMP
 491 LazyIdleThread::AfterProcessNextEvent(nsIThreadInternal* /* aThread */,
 492                                       uint32_t /* aRecursionDepth */)
 493 {
 494   bool shouldNotifyIdle;
 495   {
 496     MutexAutoLock lock(mMutex);
 497
 498     MOZ_ASSERT(mPendingEventCount, "Mismatched calls to observer methods!");
 499     --mPendingEventCount;
 500
 501     if (mThreadIsShuttingDown) {
 502       // We're shutting down, no need to fire any timer.
 503       return NS_OK;
 504     }
 505
 506     shouldNotifyIdle = !mPendingEventCount;
 507     if (shouldNotifyIdle) {
 508       MOZ_ASSERT(mIdleNotificationCount < UINT32_MAX, "Way too many!");
 509       mIdleNotificationCount++;
 510     }
 511   }
 512
 513   if (shouldNotifyIdle) {
 514     nsCOMPtr<nsIRunnable> runnable =
 515       NS_NewRunnableMethod(this, &LazyIdleThread::ScheduleTimer);
 516     NS_ENSURE_TRUE(runnable, NS_ERROR_FAILURE);
 517
 518     nsresult rv = mOwningThread->Dispatch(runnable, NS_DISPATCH_NORMAL);
 519     NS_ENSURE_SUCCESS(rv, rv);
 520   }
 521
 522   return NS_OK;
 523 }
 524
 525 NS_IMETHODIMP
 526 LazyIdleThread::Observe(nsISupports* /* aSubject */,
 527                         const char*  aTopic,
 528                         const PRUnichar* /* aData */)
 529 {
 530   MOZ_ASSERT(NS_IsMainThread(), "Wrong thread!");
 531   MOZ_ASSERT(mShutdownMethod == AutomaticShutdown,
 532              "Should not receive notifications if not AutomaticShutdown!");
 533   MOZ_ASSERT(!strcmp("xpcom-shutdown-threads", aTopic), "Bad topic!");
 534
 535   Shutdown();
 536   return NS_OK;
 537 }
 538
 539 } // namespace mozilla