/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=8 sts=2 et sw=2 tw=80: */ /* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
// The io pool spends a lot of its time blocking on io, so we want to offload // these jobs on a lower priority if available.
rv = ioPool->SetQoSForThreads(nsIThread::QOS_PRIORITY_LOW);
NS_ENSURE_SUCCESS(
rv, rv); // note: currently infallible, keeping this for brevity.
// Use potentially more conservative stack size.
rv = ioPool->SetThreadStackSize(nsIThreadManager::kThreadPoolStackSize);
NS_ENSURE_SUCCESS(rv, rv);
// Thread limit of 4 makes deadlock during synchronous dispatch less likely. // TODO: This pool is meant to host blocking (file, network) IO, so we might // want to configure an even higher limit to allow more parallel operations // to find another thread. But first we should audit the existing uses of // NS_DISPATCH_EVENT_MAY_BLOCK if they are not just CPU heavy runnables.
rv = ioPool->SetThreadLimit(4);
NS_ENSURE_SUCCESS(rv, rv);
NS_IMETHODIMP
BackgroundEventTarget::Dispatch(already_AddRefed<nsIRunnable> aRunnable,
uint32_t aFlags) { // Select the right destination and clear the special flag. bool mayBlock = bool(aFlags & NS_DISPATCH_EVENT_MAY_BLOCK);
nsCOMPtr<nsIThreadPool>& pool = mayBlock ? mIOPool : mPool;
uint32_t flags = aFlags & ~NS_DISPATCH_EVENT_MAY_BLOCK;
// If an event is dispatched with NS_DISPATCH_AT_END, it is intended to run // on the same thread on the same pool it is dispatched from, but we might // not want to run the event on the same pool depending on the above choice. // If we dispatch an event with NS_DISPATCH_AT_END to the wrong pool, the // pool may not process the event in a timely fashion or even deadlock. if (flags & NS_DISPATCH_AT_END && !pool->IsOnCurrentThread()) {
flags &= ~NS_DISPATCH_AT_END;
}
extern"C" { // This uses the C language linkage because it's exposed to Rust // via the xpcom/rust/moz_task crate. bool NS_IsMainThread() { return sTLSIsMainThread.get(); }
}
void NS_SetMainThread() { if (!sTLSIsMainThread.init()) {
MOZ_CRASH();
}
sTLSIsMainThread.set(true);
MOZ_ASSERT(NS_IsMainThread()); // We initialize the SerialEventTargetGuard's TLS here for simplicity as it // needs to be initialized around the same time you would initialize // sTLSIsMainThread.
SerialEventTargetGuard::InitTLS();
nsThreadPool::InitTLS();
}
nsresult nsThreadManager::Init() { // Initialize perfetto if on Android.
InitPerfetto();
// Child processes need to initialize the thread manager before they // initialize XPCOM in order to set up the crash reporter. This leads to // situations where we get initialized twice.
{
OffTheBooksMutexAutoLock lock(mMutex); if (mState > State::eUninit) { return NS_OK;
}
}
if (PR_NewThreadPrivateIndex(&mCurThreadIndex, ReleaseThread) == PR_FAILURE) { return NS_ERROR_FAILURE;
}
// Initialize idle handling.
nsCOMPtr<nsIIdlePeriod> idlePeriod = new MainThreadIdlePeriod();
TaskController::Get()->SetIdleTaskManager( new IdleTaskManager(idlePeriod.forget()));
// Create main thread queue that forwards events to TaskController and // construct main thread.
UniquePtr<EventQueue> queue = MakeUnique<EventQueue>(true);
RefPtr<ThreadEventQueue> synchronizedQueue = new ThreadEventQueue(std::move(queue), true);
mMainThread = new nsThread(WrapNotNull(synchronizedQueue), nsThread::MAIN_THREAD,
{0, false, false, Some(W3_LONGTASK_BUSY_WINDOW_MS)});
bool taskQueuesShutdown = false; // It's fine to capture everything by reference in the Then handler since it // runs before we exit the nested event loop, thanks to the SpinEventLoopUntil // below.
ShutdownPromise::All(mMainThread, promises)->Then(mMainThread, __func__, [&] {
backgroundEventTarget->FinishShutdown();
taskQueuesShutdown = true;
});
// Wait for task queues to shutdown, so we don't shut down the underlying // threads of the background event target in the block below, thereby // preventing the task queues from emptying, preventing the shutdown promises // from resolving, and prevent anything checking `taskQueuesShutdown` from // working.
mozilla::SpinEventLoopUntil( "nsThreadManager::Shutdown"_ns, [&]() { return taskQueuesShutdown; },
mMainThread);
{ // Prevent new nsThreads from being created, and collect a list of threads // which need to be shut down. // // We don't prevent new thread creation until we've shut down background // task queues, to ensure that they are able to start thread pool threads // for shutdown tasks.
nsTArray<RefPtr<nsThread>> threadsToShutdown;
{
OffTheBooksMutexAutoLock lock(mMutex);
mState = State::eShutdown;
for (auto* thread : mThreadList) { if (thread->ShutdownRequired()) {
threadsToShutdown.AppendElement(thread);
}
}
}
// It's tempting to walk the list of threads here and tell them each to stop // accepting new events, but that could lead to badness if one of those // threads is stuck waiting for a response from another thread. To do it // right, we'd need some way to interrupt the threads. // // Instead, we process events on the current thread while waiting for // threads to shutdown. This means that we have to preserve a mostly // functioning world until such time as the threads exit.
// As we're going to be waiting for all asynchronous shutdowns below, we // can begin asynchronously shutting down all XPCOM threads here, rather // than shutting each thread down one-at-a-time. for (constauto& thread : threadsToShutdown) {
thread->AsyncShutdown();
}
}
// NB: It's possible that there are events in the queue that want to *start* // an asynchronous shutdown. But we have already started async shutdown of // the threads above, so there's no need to worry about them. We only have to // wait for all in-flight asynchronous thread shutdowns to complete.
mMainThread->WaitForAllAsynchronousShutdowns();
// There are no more background threads at this point.
}
void nsThreadManager::ShutdownMainThread() { #ifdef DEBUG
{
OffTheBooksMutexAutoLock lock(mMutex);
MOZ_ASSERT(mState == State::eShutdown, "Must have called BeginShutdown");
} #endif
// Do NS_ProcessPendingEvents but with special handling to set // mEventsAreDoomed atomically with the removal of the last event. This means // that PutEvent cannot succeed if the event would be left in the main thread // queue after our final call to NS_ProcessPendingEvents. // See comments in `nsThread::ThreadFunc` for a more detailed explanation. while (true) { if (mMainThread->mEvents->ShutdownIfNoPendingEvents()) { break;
}
NS_ProcessPendingEvents(mMainThread);
}
// Normally thread shutdown clears the observer for the thread, but since the // main thread is special we do it manually here after we're sure all events // have been processed.
mMainThread->SetObserver(nullptr);
aThread.AddRef(); // for TLS entry
PR_SetThreadPrivate(mCurThreadIndex, &aThread);
#ifdef DEBUG
{
OffTheBooksMutexAutoLock lock(mMutex);
MOZ_ASSERT(aThread.isInList(), "Thread was not added to the thread list before registering!");
} #endif
}
PR_SetThreadPrivate(mCurThreadIndex, nullptr); // Ref-count balanced via ReleaseThread
}
// Not to be used for MainThread!
nsThread* nsThreadManager::CreateCurrentThread(SynchronizedEventQueue* aQueue) { // Make sure we don't have an nsThread yet.
MOZ_ASSERT(!PR_GetThreadPrivate(mCurThreadIndex));
if (!AllowNewXPCOMThreads()) { return nullptr;
}
RefPtr<nsThread> thread = new nsThread(
WrapNotNull(aQueue), nsThread::NOT_MAIN_THREAD, {.stackSize = 0}); if (NS_FAILED(thread->InitCurrentThread())) { return nullptr;
}
nsThread* nsThreadManager::GetCurrentThread() { // read thread local storage void* data = PR_GetThreadPrivate(mCurThreadIndex); if (data) { returnstatic_cast<nsThread*>(data);
}
// Keep this function working early during startup or late during shutdown on // the main thread. if (!AllowNewXPCOMThreads() || NS_IsMainThread()) { return nullptr;
}
// OK, that's fine. We'll dynamically create one :-) // // We assume that if we're implicitly creating a thread here that it doesn't // want an event queue. Any thread which wants an event queue should // explicitly create its nsThread wrapper. // // nsThread::InitCurrentThread() will check AllowNewXPCOMThreads, and return // an error if we're too late in shutdown to create new XPCOM threads.
RefPtr<nsThread> thread = new nsThread(); if (NS_FAILED(thread->InitCurrentThread())) { return nullptr;
}
NS_IMETHODIMP
nsThreadManager::NewNamedThread( const nsACString& aName, nsIThreadManager::ThreadCreationOptions aOptions,
nsIThread** aResult) { // Note: can be called from arbitrary threads
RefPtr<ThreadEventQueue> queue = new ThreadEventQueue(MakeUnique<EventQueue>());
RefPtr<nsThread> thr = new nsThread(WrapNotNull(queue), nsThread::NOT_MAIN_THREAD, aOptions);
// Note: nsThread::Init() will check AllowNewXPCOMThreads, and return an // error if we're too late in shutdown to create new XPCOM threads. If we // aren't, the thread will be synchronously added to mThreadList.
nsresult rv = thr->Init(aName); if (NS_FAILED(rv)) { return rv;
}
NS_IMETHODIMP
nsThreadManager::GetMainThread(nsIThread** aResult) { // Keep this functioning during Shutdown if (!mMainThread) { if (!NS_IsMainThread()) {
NS_WARNING( "Called GetMainThread but there isn't a main thread and " "we're not the main thread.");
} return NS_ERROR_NOT_INITIALIZED;
}
NS_ADDREF(*aResult = mMainThread); return NS_OK;
}
NS_IMETHODIMP
nsThreadManager::GetCurrentThread(nsIThread** aResult) { // Keep this functioning during Shutdown if (!mMainThread) { return NS_ERROR_NOT_INITIALIZED;
}
*aResult = GetCurrentThread(); if (!*aResult) { return NS_ERROR_OUT_OF_MEMORY;
}
NS_ADDREF(*aResult); return NS_OK;
}
nsresult nsThreadManager::SpinEventLoopUntilInternal( const nsACString& aVeryGoodReasonToDoThis,
nsINestedEventLoopCondition* aCondition,
ShutdownPhase aShutdownPhaseToCheck) { // XXX: We would want to AssertIsOnMainThread(); but that breaks some GTest.
nsCOMPtr<nsINestedEventLoopCondition> condition(aCondition);
nsresult rv = NS_OK;
if (!mozilla::SpinEventLoopUntil(aVeryGoodReasonToDoThis, [&]() -> bool { // Check if an ongoing shutdown reached our limits. if (aShutdownPhaseToCheck > ShutdownPhase::NotInShutdown &&
AppShutdown::GetCurrentShutdownPhase() >= aShutdownPhaseToCheck) { returntrue;
}
bool isDone = false;
rv = condition->IsDone(&isDone); // JS failure should be unusual, but we need to stop and propagate // the error back to the caller. if (NS_FAILED(rv)) { returntrue;
}
return isDone;
})) { // We stopped early for some reason, which is unexpected. return NS_ERROR_UNEXPECTED;
}
// If we exited when the condition told us to, we need to return whether // the condition encountered failure when executing. return rv;
}
NS_IMETHODIMP
nsThreadManager::DispatchToMainThread(nsIRunnable* aEvent, uint32_t aPriority,
uint8_t aArgc) { // Note: C++ callers should instead use NS_DispatchToMainThread.
MOZ_ASSERT(NS_IsMainThread());
// Keep this functioning during Shutdown if (NS_WARN_IF(!mMainThread)) { return NS_ERROR_NOT_INITIALIZED;
} // If aPriority wasn't explicitly passed, that means it should be treated as // PRIORITY_NORMAL. if (aArgc > 0 && aPriority != nsIRunnablePriority::PRIORITY_NORMAL) {
nsCOMPtr<nsIRunnable> event(aEvent); return mMainThread->DispatchFromScript( new PrioritizableRunnable(event.forget(), aPriority), 0);
} return mMainThread->DispatchFromScript(aEvent, 0);
}
class AutoMicroTaskWrapperRunnable final : public Runnable { public: explicit AutoMicroTaskWrapperRunnable(nsIRunnable* aEvent)
: Runnable("AutoMicroTaskWrapperRunnable"), mEvent(aEvent) {
MOZ_ASSERT(aEvent);
}
NS_IMETHODIMP
nsThreadManager::IdleDispatchToMainThread(nsIRunnable* aEvent,
uint32_t aTimeout) { // Note: C++ callers should instead use NS_DispatchToThreadQueue or // NS_DispatchToCurrentThreadQueue.
MOZ_ASSERT(NS_IsMainThread());
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
