dom/workers/JSExecutionManager.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=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 "mozilla/dom/JSExecutionManager.h"
   8
   9 #include "WorkerCommon.h"
  10 #include "WorkerPrivate.h"
  11
  12 #include "mozilla/dom/DocGroup.h"
  13 #include "mozilla/StaticPrefs_dom.h"
  14 #include "mozilla/StaticPtr.h"
  15
  16 namespace mozilla::dom {
  17
  18 JSExecutionManager* JSExecutionManager::mCurrentMTManager;
  19
  20 const uint32_t kTimeSliceExpirationMS = 50;
  21
  22 using RequestState = JSExecutionManager::RequestState;
  23
  24 static StaticRefPtr<JSExecutionManager> sSABSerializationManager;
  25
  26 void JSExecutionManager::Initialize() {
  27   if (StaticPrefs::dom_workers_serialized_sab_access()) {
  28     sSABSerializationManager = MakeRefPtr<JSExecutionManager>(1);
  29   }
  30 }
  31
  32 void JSExecutionManager::Shutdown() { sSABSerializationManager = nullptr; }
  33
  34 JSExecutionManager* JSExecutionManager::GetSABSerializationManager() {
  35   return sSABSerializationManager.get();
  36 }
  37
  38 RequestState JSExecutionManager::RequestJSThreadExecution() {
  39   if (NS_IsMainThread()) {
  40     return RequestJSThreadExecutionMainThread();
  41   }
  42
  43   WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
  44
  45   if (!workerPrivate || workerPrivate->GetExecutionGranted()) {
  46     return RequestState::ExecutingAlready;
  47   }
  48
  49   MutexAutoLock lock(mExecutionQueueMutex);
  50   MOZ_ASSERT(mMaxRunning >= mRunning);
  51
  52   if ((mExecutionQueue.size() + (mMainThreadAwaitingExecution ? 1 : 0)) <
  53       size_t(mMaxRunning - mRunning)) {
  54     // There's slots ready for things to run, execute right away.
  55     workerPrivate->SetExecutionGranted(true);
  56     workerPrivate->ScheduleTimeSliceExpiration(kTimeSliceExpirationMS);
  57
  58     mRunning++;
  59     return RequestState::Granted;
  60   }
  61
  62   mExecutionQueue.push_back(workerPrivate);
  63
  64   TimeStamp waitStart = TimeStamp::Now();
  65
  66   while (mRunning >= mMaxRunning || (workerPrivate != mExecutionQueue.front() ||
  67                                      mMainThreadAwaitingExecution)) {
  68     // If there is no slots available, the main thread is awaiting permission
  69     // or we are not first in line for execution, wait until notified.
  70     mExecutionQueueCondVar.Wait(TimeDuration::FromMilliseconds(500));
  71     if ((TimeStamp::Now() - waitStart) > TimeDuration::FromSeconds(20)) {
  72       // Crash so that these types of situations are actually caught in the
  73       // crash reporter.
  74       MOZ_CRASH();
  75     }
  76   }
  77
  78   workerPrivate->SetExecutionGranted(true);
  79   workerPrivate->ScheduleTimeSliceExpiration(kTimeSliceExpirationMS);
  80
  81   mExecutionQueue.pop_front();
  82   mRunning++;
  83   if (mRunning < mMaxRunning) {
  84     // If a thread woke up before that wasn't first in line it will have gone
  85     // back to sleep, if there's more slots available, wake it now.
  86     mExecutionQueueCondVar.NotifyAll();
  87   }
  88
  89   return RequestState::Granted;
  90 }
  91
  92 void JSExecutionManager::YieldJSThreadExecution() {
  93   if (NS_IsMainThread()) {
  94     MOZ_ASSERT(mMainThreadIsExecuting);
  95     mMainThreadIsExecuting = false;
  96
  97     MutexAutoLock lock(mExecutionQueueMutex);
  98     mRunning--;
  99     mExecutionQueueCondVar.NotifyAll();
 100     return;
 101   }
 102
 103   WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
 104
 105   if (!workerPrivate) {
 106     return;
 107   }
 108
 109   MOZ_ASSERT(workerPrivate->GetExecutionGranted());
 110
 111   workerPrivate->CancelTimeSliceExpiration();
 112
 113   MutexAutoLock lock(mExecutionQueueMutex);
 114   mRunning--;
 115   mExecutionQueueCondVar.NotifyAll();
 116   workerPrivate->SetExecutionGranted(false);
 117 }
 118
 119 bool JSExecutionManager::YieldJSThreadExecutionIfGranted() {
 120   if (NS_IsMainThread()) {
 121     if (mMainThreadIsExecuting) {
 122       YieldJSThreadExecution();
 123       return true;
 124     }
 125     return false;
 126   }
 127
 128   WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
 129
 130   if (workerPrivate && workerPrivate->GetExecutionGranted()) {
 131     YieldJSThreadExecution();
 132     return true;
 133   }
 134
 135   return false;
 136 }
 137
 138 RequestState JSExecutionManager::RequestJSThreadExecutionMainThread() {
 139   MOZ_ASSERT(NS_IsMainThread());
 140
 141   if (mMainThreadIsExecuting) {
 142     return RequestState::ExecutingAlready;
 143   }
 144
 145   MutexAutoLock lock(mExecutionQueueMutex);
 146   MOZ_ASSERT(mMaxRunning >= mRunning);
 147
 148   if ((mMaxRunning - mRunning) > 0) {
 149     // If there's any slots available run, the main thread always takes
 150     // precedence over any worker threads.
 151     mRunning++;
 152     mMainThreadIsExecuting = true;
 153     return RequestState::Granted;
 154   }
 155
 156   mMainThreadAwaitingExecution = true;
 157
 158   TimeStamp waitStart = TimeStamp::Now();
 159
 160   while (mRunning >= mMaxRunning) {
 161     if ((TimeStamp::Now() - waitStart) > TimeDuration::FromSeconds(20)) {
 162       // Crash so that these types of situations are actually caught in the
 163       // crash reporter.
 164       MOZ_CRASH();
 165     }
 166     mExecutionQueueCondVar.Wait(TimeDuration::FromMilliseconds(500));
 167   }
 168
 169   mMainThreadAwaitingExecution = false;
 170   mMainThreadIsExecuting = true;
 171
 172   mRunning++;
 173   if (mRunning < mMaxRunning) {
 174     // If a thread woke up before that wasn't first in line it will have gone
 175     // back to sleep, if there's more slots available, wake it now.
 176     mExecutionQueueCondVar.NotifyAll();
 177   }
 178
 179   return RequestState::Granted;
 180 }
 181
 182 AutoRequestJSThreadExecution::AutoRequestJSThreadExecution(
 183     nsIGlobalObject* aGlobalObject, bool aIsMainThread) {
 184   JSExecutionManager* manager = nullptr;
 185
 186   mIsMainThread = aIsMainThread;
 187   if (mIsMainThread) {
 188     mOldGrantingManager = JSExecutionManager::mCurrentMTManager;
 189
 190     nsPIDOMWindowInner* innerWindow = nullptr;
 191     if (aGlobalObject) {
 192       innerWindow = aGlobalObject->AsInnerWindow();
 193     }
 194
 195     DocGroup* docGroup = nullptr;
 196     if (innerWindow) {
 197       docGroup = innerWindow->GetDocGroup();
 198     }
 199
 200     if (docGroup) {
 201       manager = docGroup->GetExecutionManager();
 202     }
 203
 204     if (JSExecutionManager::mCurrentMTManager == manager) {
 205       return;
 206     }
 207
 208     if (JSExecutionManager::mCurrentMTManager) {
 209       JSExecutionManager::mCurrentMTManager->YieldJSThreadExecution();
 210       JSExecutionManager::mCurrentMTManager = nullptr;
 211     }
 212   } else {
 213     WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
 214
 215     if (workerPrivate) {
 216       manager = workerPrivate->GetExecutionManager();
 217     }
 218   }
 219
 220   if (manager &&
 221       (manager->RequestJSThreadExecution() == RequestState::Granted)) {
 222     if (NS_IsMainThread()) {
 223       // Make sure we restore permission on destruction if needed.
 224       JSExecutionManager::mCurrentMTManager = manager;
 225     }
 226     mExecutionGrantingManager = std::move(manager);
 227   }
 228 }
 229
 230 AutoYieldJSThreadExecution::AutoYieldJSThreadExecution() {
 231   JSExecutionManager* manager = nullptr;
 232
 233   if (NS_IsMainThread()) {
 234     manager = JSExecutionManager::mCurrentMTManager;
 235   } else {
 236     WorkerPrivate* workerPrivate = GetCurrentThreadWorkerPrivate();
 237
 238     if (workerPrivate) {
 239       manager = workerPrivate->GetExecutionManager();
 240     }
 241   }
 242
 243   if (manager && manager->YieldJSThreadExecutionIfGranted()) {
 244     mExecutionGrantingManager = std::move(manager);
 245     if (NS_IsMainThread()) {
 246       JSExecutionManager::mCurrentMTManager = nullptr;
 247     }
 248   }
 249 }
 250
 251 }  // namespace mozilla::dom