gecko-dev/gfx/layers/PaintThread.cpp

243 строки
7.0 KiB
C++

/* -*- 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 "PaintThread.h"
#include <algorithm>
#include "base/task.h"
#include "gfxPlatform.h"
#include "gfxPrefs.h"
#include "GeckoProfiler.h"
#include "mozilla/layers/CompositorBridgeChild.h"
#include "mozilla/layers/ShadowLayers.h"
#include "mozilla/layers/SyncObject.h"
#include "mozilla/gfx/2D.h"
#include "mozilla/Preferences.h"
#include "mozilla/SharedThreadPool.h"
#include "mozilla/SyncRunnable.h"
#include "nsIPropertyBag2.h"
#include "nsServiceManagerUtils.h"
#include "prsystem.h"
// Uncomment the following line to dispatch sync runnables when
// painting so that rasterization happens synchronously from
// the perspective of the main thread
// #define OMTP_FORCE_SYNC
namespace mozilla {
namespace layers {
using namespace gfx;
void PaintTask::DropTextureClients() { mClients.Clear(); }
StaticAutoPtr<PaintThread> PaintThread::sSingleton;
StaticRefPtr<nsIThread> PaintThread::sThread;
PlatformThreadId PaintThread::sThreadId;
PaintThread::PaintThread() {}
void PaintThread::Release() {}
void PaintThread::AddRef() {}
/* static */ int32_t PaintThread::CalculatePaintWorkerCount() {
int32_t cpuCores = PR_GetNumberOfProcessors();
int32_t workerCount = gfxPrefs::LayersOMTPPaintWorkers();
// If not manually specified, default to (cpuCores * 3) / 4, and clamp
// between 1 and 4. If a user wants more, they can manually specify it
if (workerCount < 1) {
workerCount = std::min(std::max((cpuCores * 3) / 4, 1), 4);
}
return workerCount;
}
/* static */ void PaintThread::Start() {
PaintThread::sSingleton = new PaintThread();
if (!PaintThread::sSingleton->Init()) {
gfxCriticalNote << "Unable to start paint thread";
PaintThread::sSingleton = nullptr;
}
}
bool PaintThread::Init() {
MOZ_ASSERT(NS_IsMainThread());
RefPtr<nsIThread> thread;
nsresult rv = NS_NewNamedThread("PaintThread", getter_AddRefs(thread));
if (NS_FAILED(rv)) {
return false;
}
sThread = thread;
// Only create paint workers for tiling if we are using tiling or could
// expect to dynamically switch to tiling in the future
if (gfxPlatform::GetPlatform()->UsesTiling()) {
InitPaintWorkers();
}
nsCOMPtr<nsIRunnable> paintInitTask = NewRunnableMethod(
"PaintThread::InitOnPaintThread", this, &PaintThread::InitOnPaintThread);
SyncRunnable::DispatchToThread(sThread, paintInitTask);
return true;
}
void PaintThread::InitOnPaintThread() {
MOZ_ASSERT(!NS_IsMainThread());
sThreadId = PlatformThread::CurrentId();
}
void PaintThread::InitPaintWorkers() {
MOZ_ASSERT(NS_IsMainThread());
int32_t count = PaintThread::CalculatePaintWorkerCount();
if (count != 1) {
mPaintWorkers =
SharedThreadPool::Get(NS_LITERAL_CSTRING("PaintWorker"), count);
}
}
void DestroyPaintThread(UniquePtr<PaintThread>&& pt) {
MOZ_ASSERT(PaintThread::IsOnPaintThread());
pt->ShutdownOnPaintThread();
}
/* static */ void PaintThread::Shutdown() {
MOZ_ASSERT(NS_IsMainThread());
UniquePtr<PaintThread> pt(sSingleton.forget());
if (!pt) {
return;
}
sThread->Dispatch(NewRunnableFunction("DestroyPaintThreadRunnable",
DestroyPaintThread, std::move(pt)));
sThread->Shutdown();
sThread = nullptr;
}
void PaintThread::ShutdownOnPaintThread() { MOZ_ASSERT(IsOnPaintThread()); }
/* static */ PaintThread* PaintThread::Get() {
return PaintThread::sSingleton.get();
}
/* static */ bool PaintThread::IsOnPaintThread() {
return sThreadId == PlatformThread::CurrentId();
}
bool PaintThread::IsOnPaintWorkerThread() {
return (mPaintWorkers && mPaintWorkers->IsOnCurrentThread()) ||
(sThreadId == PlatformThread::CurrentId());
}
void PaintThread::Dispatch(RefPtr<Runnable>& aRunnable) {
#ifndef OMTP_FORCE_SYNC
sThread->Dispatch(aRunnable.forget());
#else
SyncRunnable::DispatchToThread(sThread, aRunnable);
#endif
}
void PaintThread::UpdateRenderMode() {
if (!!mPaintWorkers != gfxPlatform::GetPlatform()->UsesTiling()) {
if (mPaintWorkers) {
mPaintWorkers = nullptr;
} else {
InitPaintWorkers();
}
}
}
void PaintThread::QueuePaintTask(UniquePtr<PaintTask>&& aTask) {
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aTask);
if (gfxPrefs::LayersOMTPDumpCapture() && aTask->mCapture) {
aTask->mCapture->Dump();
}
MOZ_RELEASE_ASSERT(aTask->mCapture->hasOneRef());
RefPtr<CompositorBridgeChild> cbc(CompositorBridgeChild::Get());
cbc->NotifyBeginAsyncPaint(aTask.get());
RefPtr<PaintThread> self = this;
RefPtr<Runnable> task =
NS_NewRunnableFunction("PaintThread::AsyncPaintTask",
[self, cbc, task = std::move(aTask)]() -> void {
self->AsyncPaintTask(cbc, task.get());
});
nsIEventTarget* paintThread =
mPaintWorkers ? static_cast<nsIEventTarget*>(mPaintWorkers.get())
: static_cast<nsIEventTarget*>(sThread.get());
#ifndef OMTP_FORCE_SYNC
paintThread->Dispatch(task.forget());
#else
SyncRunnable::DispatchToThread(paintThread, task);
#endif
}
void PaintThread::AsyncPaintTask(CompositorBridgeChild* aBridge,
PaintTask* aTask) {
AUTO_PROFILER_LABEL("PaintThread::AsyncPaintTask", GRAPHICS);
MOZ_ASSERT(IsOnPaintWorkerThread());
MOZ_ASSERT(aTask);
gfx::DrawTargetCapture* capture = aTask->mCapture;
gfx::DrawTarget* target = aTask->mTarget;
target->DrawCapturedDT(capture, Matrix());
target->Flush();
if (gfxPrefs::LayersOMTPReleaseCaptureOnMainThread()) {
// This should ensure the capture drawtarget, which may hold on to
// UnscaledFont objects, gets destroyed on the main thread (See bug
// 1404742). This assumes (unflushed) target DrawTargets do not themselves
// hold on to UnscaledFonts.
NS_ReleaseOnMainThreadSystemGroup("PaintTask::DrawTargetCapture",
aTask->mCapture.forget());
}
if (aBridge->NotifyFinishedAsyncWorkerPaint(aTask)) {
AsyncEndLayerTransaction(aBridge);
}
}
void PaintThread::QueueEndLayerTransaction(SyncObjectClient* aSyncObject) {
MOZ_ASSERT(NS_IsMainThread());
RefPtr<CompositorBridgeChild> cbc(CompositorBridgeChild::Get());
if (cbc->NotifyBeginAsyncEndLayerTransaction(aSyncObject)) {
RefPtr<PaintThread> self = this;
RefPtr<Runnable> task = NS_NewRunnableFunction(
"PaintThread::AsyncEndLayerTransaction",
[self, cbc]() -> void { self->AsyncEndLayerTransaction(cbc); });
#ifndef OMTP_FORCE_SYNC
sThread->Dispatch(task.forget());
#else
SyncRunnable::DispatchToThread(sThread, task);
#endif
}
}
void PaintThread::AsyncEndLayerTransaction(CompositorBridgeChild* aBridge) {
MOZ_ASSERT(IsOnPaintWorkerThread());
aBridge->NotifyFinishedAsyncEndLayerTransaction();
}
} // namespace layers
} // namespace mozilla