summaryrefslogtreecommitdiffstats
path: root/gfx/layers/ipc/CompositorThread.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'gfx/layers/ipc/CompositorThread.cpp')
-rw-r--r--gfx/layers/ipc/CompositorThread.cpp195
1 files changed, 195 insertions, 0 deletions
diff --git a/gfx/layers/ipc/CompositorThread.cpp b/gfx/layers/ipc/CompositorThread.cpp
new file mode 100644
index 0000000000..65fbdc66f1
--- /dev/null
+++ b/gfx/layers/ipc/CompositorThread.cpp
@@ -0,0 +1,195 @@
+/* -*- 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/. */
+#include "CompositorThread.h"
+
+#include "CompositorBridgeParent.h"
+#include "gfxGradientCache.h"
+#include "MainThreadUtils.h"
+#include "VRManagerParent.h"
+#include "mozilla/BackgroundHangMonitor.h"
+#include "mozilla/SpinEventLoopUntil.h"
+#include "mozilla/gfx/gfxVars.h"
+#include "mozilla/layers/CompositorManagerParent.h"
+#include "mozilla/layers/ImageBridgeParent.h"
+#include "mozilla/layers/VideoBridgeParent.h"
+#include "mozilla/media/MediaSystemResourceService.h"
+#include "nsThread.h"
+#include "nsThreadUtils.h"
+
+namespace mozilla {
+namespace layers {
+
+static StaticRefPtr<CompositorThreadHolder> sCompositorThreadHolder;
+static Atomic<bool> sFinishedCompositorShutDown(false);
+static mozilla::BackgroundHangMonitor* sBackgroundHangMonitor;
+static ProfilerThreadId sProfilerThreadId;
+
+nsIThread* CompositorThread() {
+ return sCompositorThreadHolder
+ ? sCompositorThreadHolder->GetCompositorThread()
+ : nullptr;
+}
+
+CompositorThreadHolder* CompositorThreadHolder::GetSingleton() {
+ return sCompositorThreadHolder;
+}
+
+CompositorThreadHolder::CompositorThreadHolder()
+ : mCompositorThread(CreateCompositorThread()) {
+ MOZ_ASSERT(NS_IsMainThread());
+}
+
+CompositorThreadHolder::~CompositorThreadHolder() {
+ sFinishedCompositorShutDown = true;
+}
+
+/* static */ already_AddRefed<nsIThread>
+CompositorThreadHolder::CreateCompositorThread() {
+ MOZ_ASSERT(NS_IsMainThread());
+
+ MOZ_ASSERT(!sCompositorThreadHolder,
+ "The compositor thread has already been started!");
+
+ // When the CanvasRenderer thread is disabled, WebGL may be handled on this
+ // thread, requiring a bigger stack size. See: CanvasManagerParent::Init
+ //
+ // This is 4M, which is higher than the default 256K.
+ // Increased with bug 1753349 to accommodate the `chromium/5359` branch of
+ // ANGLE, which has large peak stack usage for some pathological shader
+ // compilations.
+ //
+ // Previously increased to 512K to accommodate Mesa in bug 1753340.
+ //
+ // Previously increased to 320K to avoid a stack overflow in the
+ // Intel Vulkan driver initialization in bug 1716120.
+ //
+ // Note: we only override it if it's limited already.
+ uint32_t stackSize = nsIThreadManager::DEFAULT_STACK_SIZE;
+ if (stackSize) {
+ stackSize =
+ std::max(stackSize, gfx::gfxVars::SupportsThreadsafeGL() &&
+ !gfx::gfxVars::UseCanvasRenderThread()
+ ? 4096U << 10
+ : 512U << 10);
+ }
+
+ nsCOMPtr<nsIThread> compositorThread;
+ nsresult rv = NS_NewNamedThread(
+ "Compositor", getter_AddRefs(compositorThread),
+ NS_NewRunnableFunction(
+ "CompositorThreadHolder::CompositorThreadHolderSetup",
+ []() {
+ sProfilerThreadId = profiler_current_thread_id();
+ sBackgroundHangMonitor = new mozilla::BackgroundHangMonitor(
+ "Compositor",
+ /* Timeout values are powers-of-two to enable us get better
+ data. 128ms is chosen for transient hangs because 8Hz should
+ be the minimally acceptable goal for Compositor
+ responsiveness (normal goal is 60Hz). */
+ 128,
+ /* 2048ms is chosen for permanent hangs because it's longer than
+ * most Compositor hangs seen in the wild, but is short enough
+ * to not miss getting native hang stacks. */
+ 2048);
+ nsCOMPtr<nsIThread> thread = NS_GetCurrentThread();
+ static_cast<nsThread*>(thread.get())->SetUseHangMonitor(true);
+ }),
+ {.stackSize = stackSize});
+
+ if (NS_FAILED(rv)) {
+ return nullptr;
+ }
+
+ CompositorBridgeParent::Setup();
+ ImageBridgeParent::Setup();
+
+ return compositorThread.forget();
+}
+
+void CompositorThreadHolder::Start() {
+ MOZ_ASSERT(NS_IsMainThread(), "Should be on the main Thread!");
+ MOZ_ASSERT(!sCompositorThreadHolder,
+ "The compositor thread has already been started!");
+
+ // We unset the holder instead of asserting because failing to start the
+ // compositor thread may not be a fatal error. As long as this succeeds in
+ // either the GPU process or the UI process, the user will have a usable
+ // browser. If we get neither, it will crash as soon as we try to post to the
+ // compositor thread for the first time.
+ sProfilerThreadId = ProfilerThreadId();
+ sCompositorThreadHolder = new CompositorThreadHolder();
+ if (!sCompositorThreadHolder->GetCompositorThread()) {
+ gfxCriticalNote << "Compositor thread not started ("
+ << XRE_IsParentProcess() << ")";
+ sCompositorThreadHolder = nullptr;
+ }
+}
+
+void CompositorThreadHolder::Shutdown() {
+ MOZ_ASSERT(NS_IsMainThread(), "Should be on the main Thread!");
+ if (!sCompositorThreadHolder) {
+ // We've already shutdown or never started.
+ return;
+ }
+
+ ImageBridgeParent::Shutdown();
+ gfx::VRManagerParent::Shutdown();
+ MediaSystemResourceService::Shutdown();
+ CompositorManagerParent::Shutdown();
+ gfx::gfxGradientCache::Shutdown();
+
+ // Ensure there are no pending tasks that would cause an access to the
+ // thread's HangMonitor. APZ and Canvas can keep a reference to the compositor
+ // thread and may continue to dispatch tasks on it as the system shuts down.
+ CompositorThread()->Dispatch(NS_NewRunnableFunction(
+ "CompositorThreadHolder::Shutdown",
+ [compositorThreadHolder =
+ RefPtr<CompositorThreadHolder>(sCompositorThreadHolder),
+ backgroundHangMonitor = UniquePtr<mozilla::BackgroundHangMonitor>(
+ sBackgroundHangMonitor)]() {
+ VideoBridgeParent::UnregisterExternalImages();
+ nsCOMPtr<nsIThread> thread = NS_GetCurrentThread();
+ static_cast<nsThread*>(thread.get())->SetUseHangMonitor(false);
+ }));
+
+ sCompositorThreadHolder = nullptr;
+ sBackgroundHangMonitor = nullptr;
+
+ SpinEventLoopUntil("CompositorThreadHolder::Shutdown"_ns, [&]() {
+ bool finished = sFinishedCompositorShutDown;
+ return finished;
+ });
+
+ // At this point, the CompositorThreadHolder instance will have been
+ // destroyed, but the compositor thread itself may still be running due to
+ // APZ/Canvas code holding a reference to the underlying
+ // nsIThread/nsISerialEventTarget. Any tasks scheduled to run on the
+ // compositor thread earlier in this function will have been run to
+ // completion.
+ CompositorBridgeParent::FinishShutdown();
+}
+
+/* static */
+bool CompositorThreadHolder::IsInCompositorThread() {
+ if (!CompositorThread()) {
+ return false;
+ }
+ bool in = false;
+ MOZ_ALWAYS_SUCCEEDS(CompositorThread()->IsOnCurrentThread(&in));
+ return in;
+}
+
+/* static */
+ProfilerThreadId CompositorThreadHolder::GetThreadId() {
+ return sCompositorThreadHolder ? sProfilerThreadId : ProfilerThreadId();
+}
+
+} // namespace layers
+} // namespace mozilla
+
+bool NS_IsInCompositorThread() {
+ return mozilla::layers::CompositorThreadHolder::IsInCompositorThread();
+}