3f8b9fe50b
This feature is intended for use in headless test environments, where disabling drawing has minimal compatibility impact and can save significant resource usage when running UI tests. This feature is controlled via a new system property 'debug.hwui.drawing_enabled', and a HardwareRenderer API that can override the property value on a per-process basis. Bug: 201691826 Test: boot emulator Merged-In: I93c21e680382e03342f235dbf58bd7a5c8a6f767 Change-Id: I391c841e3a0cdcfcc6c7910a316a4dd5e970547d
945 lines
33 KiB
C++
945 lines
33 KiB
C++
/*
|
|
* Copyright (C) 2014 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include "CanvasContext.h"
|
|
|
|
#include <apex/window.h>
|
|
#include <fcntl.h>
|
|
#include <strings.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <algorithm>
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
#include <functional>
|
|
|
|
#include <gui/TraceUtils.h>
|
|
#include "../Properties.h"
|
|
#include "AnimationContext.h"
|
|
#include "Frame.h"
|
|
#include "LayerUpdateQueue.h"
|
|
#include "Properties.h"
|
|
#include "RenderThread.h"
|
|
#include "hwui/Canvas.h"
|
|
#include "pipeline/skia/SkiaOpenGLPipeline.h"
|
|
#include "pipeline/skia/SkiaPipeline.h"
|
|
#include "pipeline/skia/SkiaVulkanPipeline.h"
|
|
#include "thread/CommonPool.h"
|
|
#include "utils/GLUtils.h"
|
|
#include "utils/TimeUtils.h"
|
|
|
|
#define TRIM_MEMORY_COMPLETE 80
|
|
#define TRIM_MEMORY_UI_HIDDEN 20
|
|
|
|
#define LOG_FRAMETIME_MMA 0
|
|
|
|
#if LOG_FRAMETIME_MMA
|
|
static float sBenchMma = 0;
|
|
static int sFrameCount = 0;
|
|
static const float NANOS_PER_MILLIS_F = 1000000.0f;
|
|
#endif
|
|
|
|
namespace android {
|
|
namespace uirenderer {
|
|
namespace renderthread {
|
|
|
|
namespace {
|
|
class ScopedActiveContext {
|
|
public:
|
|
ScopedActiveContext(CanvasContext* context) { sActiveContext = context; }
|
|
|
|
~ScopedActiveContext() { sActiveContext = nullptr; }
|
|
|
|
static CanvasContext* getActiveContext() { return sActiveContext; }
|
|
|
|
private:
|
|
static CanvasContext* sActiveContext;
|
|
};
|
|
|
|
CanvasContext* ScopedActiveContext::sActiveContext = nullptr;
|
|
} /* namespace */
|
|
|
|
CanvasContext* CanvasContext::create(RenderThread& thread, bool translucent,
|
|
RenderNode* rootRenderNode, IContextFactory* contextFactory) {
|
|
auto renderType = Properties::getRenderPipelineType();
|
|
|
|
switch (renderType) {
|
|
case RenderPipelineType::SkiaGL:
|
|
return new CanvasContext(thread, translucent, rootRenderNode, contextFactory,
|
|
std::make_unique<skiapipeline::SkiaOpenGLPipeline>(thread));
|
|
case RenderPipelineType::SkiaVulkan:
|
|
return new CanvasContext(thread, translucent, rootRenderNode, contextFactory,
|
|
std::make_unique<skiapipeline::SkiaVulkanPipeline>(thread));
|
|
default:
|
|
LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
|
|
break;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void CanvasContext::invokeFunctor(const RenderThread& thread, Functor* functor) {
|
|
ATRACE_CALL();
|
|
auto renderType = Properties::getRenderPipelineType();
|
|
switch (renderType) {
|
|
case RenderPipelineType::SkiaGL:
|
|
skiapipeline::SkiaOpenGLPipeline::invokeFunctor(thread, functor);
|
|
break;
|
|
case RenderPipelineType::SkiaVulkan:
|
|
skiapipeline::SkiaVulkanPipeline::invokeFunctor(thread, functor);
|
|
break;
|
|
default:
|
|
LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void CanvasContext::prepareToDraw(const RenderThread& thread, Bitmap* bitmap) {
|
|
skiapipeline::SkiaPipeline::prepareToDraw(thread, bitmap);
|
|
}
|
|
|
|
CanvasContext::CanvasContext(RenderThread& thread, bool translucent, RenderNode* rootRenderNode,
|
|
IContextFactory* contextFactory,
|
|
std::unique_ptr<IRenderPipeline> renderPipeline)
|
|
: mRenderThread(thread)
|
|
, mGenerationID(0)
|
|
, mOpaque(!translucent)
|
|
, mAnimationContext(contextFactory->createAnimationContext(mRenderThread.timeLord()))
|
|
, mJankTracker(&thread.globalProfileData())
|
|
, mProfiler(mJankTracker.frames(), thread.timeLord().frameIntervalNanos())
|
|
, mContentDrawBounds(0, 0, 0, 0)
|
|
, mRenderPipeline(std::move(renderPipeline)) {
|
|
rootRenderNode->makeRoot();
|
|
mRenderNodes.emplace_back(rootRenderNode);
|
|
mProfiler.setDensity(DeviceInfo::getDensity());
|
|
}
|
|
|
|
CanvasContext::~CanvasContext() {
|
|
destroy();
|
|
for (auto& node : mRenderNodes) {
|
|
node->clearRoot();
|
|
}
|
|
mRenderNodes.clear();
|
|
}
|
|
|
|
void CanvasContext::addRenderNode(RenderNode* node, bool placeFront) {
|
|
int pos = placeFront ? 0 : static_cast<int>(mRenderNodes.size());
|
|
node->makeRoot();
|
|
mRenderNodes.emplace(mRenderNodes.begin() + pos, node);
|
|
}
|
|
|
|
void CanvasContext::removeRenderNode(RenderNode* node) {
|
|
node->clearRoot();
|
|
mRenderNodes.erase(std::remove(mRenderNodes.begin(), mRenderNodes.end(), node),
|
|
mRenderNodes.end());
|
|
}
|
|
|
|
void CanvasContext::destroy() {
|
|
stopDrawing();
|
|
setSurface(nullptr);
|
|
setSurfaceControl(nullptr);
|
|
freePrefetchedLayers();
|
|
destroyHardwareResources();
|
|
mAnimationContext->destroy();
|
|
}
|
|
|
|
static void setBufferCount(ANativeWindow* window) {
|
|
int query_value;
|
|
int err = window->query(window, NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &query_value);
|
|
if (err != 0 || query_value < 0) {
|
|
ALOGE("window->query failed: %s (%d) value=%d", strerror(-err), err, query_value);
|
|
return;
|
|
}
|
|
auto min_undequeued_buffers = static_cast<uint32_t>(query_value);
|
|
|
|
// We only need to set min_undequeued + 2 because the renderahead amount was already factored into the
|
|
// query for min_undequeued
|
|
int bufferCount = min_undequeued_buffers + 2;
|
|
native_window_set_buffer_count(window, bufferCount);
|
|
}
|
|
|
|
void CanvasContext::setSurface(ANativeWindow* window, bool enableTimeout) {
|
|
ATRACE_CALL();
|
|
|
|
if (window) {
|
|
mNativeSurface = std::make_unique<ReliableSurface>(window);
|
|
mNativeSurface->init();
|
|
if (enableTimeout) {
|
|
// TODO: Fix error handling & re-shorten timeout
|
|
ANativeWindow_setDequeueTimeout(window, 4000_ms);
|
|
}
|
|
} else {
|
|
mNativeSurface = nullptr;
|
|
}
|
|
setupPipelineSurface();
|
|
}
|
|
|
|
void CanvasContext::setSurfaceControl(ASurfaceControl* surfaceControl) {
|
|
if (surfaceControl == mSurfaceControl) return;
|
|
|
|
auto funcs = mRenderThread.getASurfaceControlFunctions();
|
|
|
|
if (surfaceControl == nullptr) {
|
|
setASurfaceTransactionCallback(nullptr);
|
|
setPrepareSurfaceControlForWebviewCallback(nullptr);
|
|
}
|
|
|
|
if (mSurfaceControl != nullptr) {
|
|
funcs.unregisterListenerFunc(this, &onSurfaceStatsAvailable);
|
|
funcs.releaseFunc(mSurfaceControl);
|
|
}
|
|
mSurfaceControl = surfaceControl;
|
|
mSurfaceControlGenerationId++;
|
|
mExpectSurfaceStats = surfaceControl != nullptr;
|
|
if (mSurfaceControl != nullptr) {
|
|
funcs.acquireFunc(mSurfaceControl);
|
|
funcs.registerListenerFunc(surfaceControl, this, &onSurfaceStatsAvailable);
|
|
}
|
|
}
|
|
|
|
void CanvasContext::setupPipelineSurface() {
|
|
bool hasSurface = mRenderPipeline->setSurface(
|
|
mNativeSurface ? mNativeSurface->getNativeWindow() : nullptr, mSwapBehavior);
|
|
|
|
if (mNativeSurface && !mNativeSurface->didSetExtraBuffers()) {
|
|
setBufferCount(mNativeSurface->getNativeWindow());
|
|
|
|
}
|
|
|
|
mFrameNumber = -1;
|
|
|
|
if (mNativeSurface != nullptr && hasSurface) {
|
|
mHaveNewSurface = true;
|
|
mSwapHistory.clear();
|
|
// Enable frame stats after the surface has been bound to the appropriate graphics API.
|
|
// Order is important when new and old surfaces are the same, because old surface has
|
|
// its frame stats disabled automatically.
|
|
native_window_enable_frame_timestamps(mNativeSurface->getNativeWindow(), true);
|
|
} else {
|
|
mRenderThread.removeFrameCallback(this);
|
|
mGenerationID++;
|
|
}
|
|
}
|
|
|
|
void CanvasContext::setSwapBehavior(SwapBehavior swapBehavior) {
|
|
mSwapBehavior = swapBehavior;
|
|
}
|
|
|
|
bool CanvasContext::pauseSurface() {
|
|
mGenerationID++;
|
|
return mRenderThread.removeFrameCallback(this);
|
|
}
|
|
|
|
void CanvasContext::setStopped(bool stopped) {
|
|
if (mStopped != stopped) {
|
|
mStopped = stopped;
|
|
if (mStopped) {
|
|
mGenerationID++;
|
|
mRenderThread.removeFrameCallback(this);
|
|
mRenderPipeline->onStop();
|
|
} else if (mIsDirty && hasSurface()) {
|
|
mRenderThread.postFrameCallback(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CanvasContext::allocateBuffers() {
|
|
if (mNativeSurface && Properties::isDrawingEnabled()) {
|
|
ANativeWindow_tryAllocateBuffers(mNativeSurface->getNativeWindow());
|
|
}
|
|
}
|
|
|
|
void CanvasContext::setLightAlpha(uint8_t ambientShadowAlpha, uint8_t spotShadowAlpha) {
|
|
mLightInfo.ambientShadowAlpha = ambientShadowAlpha;
|
|
mLightInfo.spotShadowAlpha = spotShadowAlpha;
|
|
}
|
|
|
|
void CanvasContext::setLightGeometry(const Vector3& lightCenter, float lightRadius) {
|
|
mLightGeometry.center = lightCenter;
|
|
mLightGeometry.radius = lightRadius;
|
|
}
|
|
|
|
void CanvasContext::setOpaque(bool opaque) {
|
|
mOpaque = opaque;
|
|
}
|
|
|
|
void CanvasContext::setColorMode(ColorMode mode) {
|
|
mRenderPipeline->setSurfaceColorProperties(mode);
|
|
setupPipelineSurface();
|
|
}
|
|
|
|
bool CanvasContext::makeCurrent() {
|
|
if (mStopped) return false;
|
|
|
|
auto result = mRenderPipeline->makeCurrent();
|
|
switch (result) {
|
|
case MakeCurrentResult::AlreadyCurrent:
|
|
return true;
|
|
case MakeCurrentResult::Failed:
|
|
mHaveNewSurface = true;
|
|
setSurface(nullptr);
|
|
return false;
|
|
case MakeCurrentResult::Succeeded:
|
|
mHaveNewSurface = true;
|
|
return true;
|
|
default:
|
|
LOG_ALWAYS_FATAL("unexpected result %d from IRenderPipeline::makeCurrent",
|
|
(int32_t)result);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
static bool wasSkipped(FrameInfo* info) {
|
|
return info && ((*info)[FrameInfoIndex::Flags] & FrameInfoFlags::SkippedFrame);
|
|
}
|
|
|
|
bool CanvasContext::isSwapChainStuffed() {
|
|
static const auto SLOW_THRESHOLD = 6_ms;
|
|
|
|
if (mSwapHistory.size() != mSwapHistory.capacity()) {
|
|
// We want at least 3 frames of history before attempting to
|
|
// guess if the queue is stuffed
|
|
return false;
|
|
}
|
|
nsecs_t frameInterval = mRenderThread.timeLord().frameIntervalNanos();
|
|
auto& swapA = mSwapHistory[0];
|
|
|
|
// Was there a happy queue & dequeue time? If so, don't
|
|
// consider it stuffed
|
|
if (swapA.dequeueDuration < SLOW_THRESHOLD && swapA.queueDuration < SLOW_THRESHOLD) {
|
|
return false;
|
|
}
|
|
|
|
for (size_t i = 1; i < mSwapHistory.size(); i++) {
|
|
auto& swapB = mSwapHistory[i];
|
|
|
|
// If there's a multi-frameInterval gap we effectively already dropped a frame,
|
|
// so consider the queue healthy.
|
|
if (std::abs(swapA.swapCompletedTime - swapB.swapCompletedTime) > frameInterval * 3) {
|
|
return false;
|
|
}
|
|
|
|
// Was there a happy queue & dequeue time? If so, don't
|
|
// consider it stuffed
|
|
if (swapB.dequeueDuration < SLOW_THRESHOLD && swapB.queueDuration < SLOW_THRESHOLD) {
|
|
return false;
|
|
}
|
|
|
|
swapA = swapB;
|
|
}
|
|
|
|
// All signs point to a stuffed swap chain
|
|
ATRACE_NAME("swap chain stuffed");
|
|
return true;
|
|
}
|
|
|
|
void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo, int64_t syncQueued,
|
|
RenderNode* target) {
|
|
mRenderThread.removeFrameCallback(this);
|
|
|
|
// If the previous frame was dropped we don't need to hold onto it, so
|
|
// just keep using the previous frame's structure instead
|
|
if (!wasSkipped(mCurrentFrameInfo)) {
|
|
mCurrentFrameInfo = mJankTracker.startFrame();
|
|
}
|
|
|
|
mCurrentFrameInfo->importUiThreadInfo(uiFrameInfo);
|
|
mCurrentFrameInfo->set(FrameInfoIndex::SyncQueued) = syncQueued;
|
|
mCurrentFrameInfo->markSyncStart();
|
|
|
|
info.damageAccumulator = &mDamageAccumulator;
|
|
info.layerUpdateQueue = &mLayerUpdateQueue;
|
|
info.damageGenerationId = mDamageId++;
|
|
info.out.canDrawThisFrame = true;
|
|
|
|
mAnimationContext->startFrame(info.mode);
|
|
for (const sp<RenderNode>& node : mRenderNodes) {
|
|
// Only the primary target node will be drawn full - all other nodes would get drawn in
|
|
// real time mode. In case of a window, the primary node is the window content and the other
|
|
// node(s) are non client / filler nodes.
|
|
info.mode = (node.get() == target ? TreeInfo::MODE_FULL : TreeInfo::MODE_RT_ONLY);
|
|
node->prepareTree(info);
|
|
GL_CHECKPOINT(MODERATE);
|
|
}
|
|
mAnimationContext->runRemainingAnimations(info);
|
|
GL_CHECKPOINT(MODERATE);
|
|
|
|
freePrefetchedLayers();
|
|
GL_CHECKPOINT(MODERATE);
|
|
|
|
mIsDirty = true;
|
|
|
|
if (CC_UNLIKELY(!hasSurface())) {
|
|
mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
|
|
info.out.canDrawThisFrame = false;
|
|
return;
|
|
}
|
|
|
|
if (CC_LIKELY(mSwapHistory.size() && !Properties::forceDrawFrame)) {
|
|
nsecs_t latestVsync = mRenderThread.timeLord().latestVsync();
|
|
SwapHistory& lastSwap = mSwapHistory.back();
|
|
nsecs_t vsyncDelta = std::abs(lastSwap.vsyncTime - latestVsync);
|
|
// The slight fudge-factor is to deal with cases where
|
|
// the vsync was estimated due to being slow handling the signal.
|
|
// See the logic in TimeLord#computeFrameTimeNanos or in
|
|
// Choreographer.java for details on when this happens
|
|
if (vsyncDelta < 2_ms) {
|
|
// Already drew for this vsync pulse, UI draw request missed
|
|
// the deadline for RT animations
|
|
info.out.canDrawThisFrame = false;
|
|
}
|
|
} else {
|
|
info.out.canDrawThisFrame = true;
|
|
}
|
|
|
|
// TODO: Do we need to abort out if the backdrop is added but not ready? Should that even
|
|
// be an allowable combination?
|
|
if (mRenderNodes.size() > 2 && !mRenderNodes[1]->isRenderable()) {
|
|
info.out.canDrawThisFrame = false;
|
|
}
|
|
|
|
if (info.out.canDrawThisFrame) {
|
|
int err = mNativeSurface->reserveNext();
|
|
if (err != OK) {
|
|
mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
|
|
info.out.canDrawThisFrame = false;
|
|
ALOGW("reserveNext failed, error = %d (%s)", err, strerror(-err));
|
|
if (err != TIMED_OUT) {
|
|
// A timed out surface can still recover, but assume others are permanently dead.
|
|
setSurface(nullptr);
|
|
return;
|
|
}
|
|
}
|
|
} else {
|
|
mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
|
|
}
|
|
|
|
bool postedFrameCallback = false;
|
|
if (info.out.hasAnimations || !info.out.canDrawThisFrame) {
|
|
if (CC_UNLIKELY(!Properties::enableRTAnimations)) {
|
|
info.out.requiresUiRedraw = true;
|
|
}
|
|
if (!info.out.requiresUiRedraw) {
|
|
// If animationsNeedsRedraw is set don't bother posting for an RT anim
|
|
// as we will just end up fighting the UI thread.
|
|
mRenderThread.postFrameCallback(this);
|
|
postedFrameCallback = true;
|
|
}
|
|
}
|
|
|
|
if (!postedFrameCallback &&
|
|
info.out.animatedImageDelay != TreeInfo::Out::kNoAnimatedImageDelay) {
|
|
// Subtract the time of one frame so it can be displayed on time.
|
|
const nsecs_t kFrameTime = mRenderThread.timeLord().frameIntervalNanos();
|
|
if (info.out.animatedImageDelay <= kFrameTime) {
|
|
mRenderThread.postFrameCallback(this);
|
|
} else {
|
|
const auto delay = info.out.animatedImageDelay - kFrameTime;
|
|
int genId = mGenerationID;
|
|
mRenderThread.queue().postDelayed(delay, [this, genId]() {
|
|
if (mGenerationID == genId) {
|
|
mRenderThread.postFrameCallback(this);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
void CanvasContext::stopDrawing() {
|
|
cleanupResources();
|
|
mRenderThread.removeFrameCallback(this);
|
|
mAnimationContext->pauseAnimators();
|
|
mGenerationID++;
|
|
}
|
|
|
|
void CanvasContext::notifyFramePending() {
|
|
ATRACE_CALL();
|
|
mRenderThread.pushBackFrameCallback(this);
|
|
}
|
|
|
|
nsecs_t CanvasContext::draw() {
|
|
if (auto grContext = getGrContext()) {
|
|
if (grContext->abandoned()) {
|
|
LOG_ALWAYS_FATAL("GrContext is abandoned/device lost at start of CanvasContext::draw");
|
|
return 0;
|
|
}
|
|
}
|
|
SkRect dirty;
|
|
mDamageAccumulator.finish(&dirty);
|
|
|
|
if (!Properties::isDrawingEnabled() ||
|
|
(dirty.isEmpty() && Properties::skipEmptyFrames && !surfaceRequiresRedraw())) {
|
|
mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
|
|
if (auto grContext = getGrContext()) {
|
|
// Submit to ensure that any texture uploads complete and Skia can
|
|
// free its staging buffers.
|
|
grContext->flushAndSubmit();
|
|
}
|
|
|
|
// Notify the callbacks, even if there's nothing to draw so they aren't waiting
|
|
// indefinitely
|
|
waitOnFences();
|
|
for (auto& func : mFrameCompleteCallbacks) {
|
|
std::invoke(func, mFrameNumber);
|
|
}
|
|
mFrameCompleteCallbacks.clear();
|
|
return 0;
|
|
}
|
|
|
|
ScopedActiveContext activeContext(this);
|
|
mCurrentFrameInfo->set(FrameInfoIndex::FrameInterval) =
|
|
mRenderThread.timeLord().frameIntervalNanos();
|
|
|
|
mCurrentFrameInfo->markIssueDrawCommandsStart();
|
|
|
|
Frame frame = mRenderPipeline->getFrame();
|
|
SkRect windowDirty = computeDirtyRect(frame, &dirty);
|
|
|
|
bool drew = mRenderPipeline->draw(frame, windowDirty, dirty, mLightGeometry, &mLayerUpdateQueue,
|
|
mContentDrawBounds, mOpaque, mLightInfo, mRenderNodes,
|
|
&(profiler()));
|
|
|
|
int64_t frameCompleteNr = getFrameNumber();
|
|
|
|
waitOnFences();
|
|
|
|
if (mNativeSurface) {
|
|
// TODO(b/165985262): measure performance impact
|
|
const auto vsyncId = mCurrentFrameInfo->get(FrameInfoIndex::FrameTimelineVsyncId);
|
|
if (vsyncId != UiFrameInfoBuilder::INVALID_VSYNC_ID) {
|
|
const auto inputEventId =
|
|
static_cast<int32_t>(mCurrentFrameInfo->get(FrameInfoIndex::InputEventId));
|
|
native_window_set_frame_timeline_info(mNativeSurface->getNativeWindow(), vsyncId,
|
|
inputEventId);
|
|
}
|
|
}
|
|
|
|
bool requireSwap = false;
|
|
int error = OK;
|
|
bool didSwap =
|
|
mRenderPipeline->swapBuffers(frame, drew, windowDirty, mCurrentFrameInfo, &requireSwap);
|
|
|
|
mIsDirty = false;
|
|
|
|
if (requireSwap) {
|
|
bool didDraw = true;
|
|
// Handle any swapchain errors
|
|
error = mNativeSurface->getAndClearError();
|
|
if (error == TIMED_OUT) {
|
|
// Try again
|
|
mRenderThread.postFrameCallback(this);
|
|
// But since this frame didn't happen, we need to mark full damage in the swap
|
|
// history
|
|
didDraw = false;
|
|
|
|
} else if (error != OK || !didSwap) {
|
|
// Unknown error, abandon the surface
|
|
setSurface(nullptr);
|
|
didDraw = false;
|
|
}
|
|
|
|
SwapHistory& swap = mSwapHistory.next();
|
|
if (didDraw) {
|
|
swap.damage = windowDirty;
|
|
} else {
|
|
float max = static_cast<float>(INT_MAX);
|
|
swap.damage = SkRect::MakeWH(max, max);
|
|
}
|
|
swap.swapCompletedTime = systemTime(SYSTEM_TIME_MONOTONIC);
|
|
swap.vsyncTime = mRenderThread.timeLord().latestVsync();
|
|
if (didDraw) {
|
|
nsecs_t dequeueStart =
|
|
ANativeWindow_getLastDequeueStartTime(mNativeSurface->getNativeWindow());
|
|
if (dequeueStart < mCurrentFrameInfo->get(FrameInfoIndex::SyncStart)) {
|
|
// Ignoring dequeue duration as it happened prior to frame render start
|
|
// and thus is not part of the frame.
|
|
swap.dequeueDuration = 0;
|
|
} else {
|
|
swap.dequeueDuration =
|
|
ANativeWindow_getLastDequeueDuration(mNativeSurface->getNativeWindow());
|
|
}
|
|
swap.queueDuration =
|
|
ANativeWindow_getLastQueueDuration(mNativeSurface->getNativeWindow());
|
|
} else {
|
|
swap.dequeueDuration = 0;
|
|
swap.queueDuration = 0;
|
|
}
|
|
mCurrentFrameInfo->set(FrameInfoIndex::DequeueBufferDuration) = swap.dequeueDuration;
|
|
mCurrentFrameInfo->set(FrameInfoIndex::QueueBufferDuration) = swap.queueDuration;
|
|
mHaveNewSurface = false;
|
|
mFrameNumber = -1;
|
|
} else {
|
|
mCurrentFrameInfo->set(FrameInfoIndex::DequeueBufferDuration) = 0;
|
|
mCurrentFrameInfo->set(FrameInfoIndex::QueueBufferDuration) = 0;
|
|
}
|
|
|
|
mCurrentFrameInfo->markSwapBuffersCompleted();
|
|
|
|
#if LOG_FRAMETIME_MMA
|
|
float thisFrame = mCurrentFrameInfo->duration(FrameInfoIndex::IssueDrawCommandsStart,
|
|
FrameInfoIndex::FrameCompleted) /
|
|
NANOS_PER_MILLIS_F;
|
|
if (sFrameCount) {
|
|
sBenchMma = ((9 * sBenchMma) + thisFrame) / 10;
|
|
} else {
|
|
sBenchMma = thisFrame;
|
|
}
|
|
if (++sFrameCount == 10) {
|
|
sFrameCount = 1;
|
|
ALOGD("Average frame time: %.4f", sBenchMma);
|
|
}
|
|
#endif
|
|
|
|
if (didSwap) {
|
|
for (auto& func : mFrameCompleteCallbacks) {
|
|
std::invoke(func, frameCompleteNr);
|
|
}
|
|
mFrameCompleteCallbacks.clear();
|
|
}
|
|
|
|
if (requireSwap) {
|
|
if (mExpectSurfaceStats) {
|
|
reportMetricsWithPresentTime();
|
|
std::lock_guard lock(mLast4FrameInfosMutex);
|
|
std::pair<FrameInfo*, int64_t>& next = mLast4FrameInfos.next();
|
|
next.first = mCurrentFrameInfo;
|
|
next.second = frameCompleteNr;
|
|
} else {
|
|
mCurrentFrameInfo->markFrameCompleted();
|
|
mCurrentFrameInfo->set(FrameInfoIndex::GpuCompleted)
|
|
= mCurrentFrameInfo->get(FrameInfoIndex::FrameCompleted);
|
|
std::scoped_lock lock(mFrameMetricsReporterMutex);
|
|
mJankTracker.finishFrame(*mCurrentFrameInfo, mFrameMetricsReporter);
|
|
}
|
|
}
|
|
|
|
cleanupResources();
|
|
mRenderThread.cacheManager().onFrameCompleted();
|
|
return mCurrentFrameInfo->get(FrameInfoIndex::DequeueBufferDuration);
|
|
}
|
|
|
|
void CanvasContext::cleanupResources() {
|
|
auto& tracker = mJankTracker.frames();
|
|
auto size = tracker.size();
|
|
auto capacity = tracker.capacity();
|
|
if (size == capacity) {
|
|
nsecs_t nowNanos = systemTime(SYSTEM_TIME_MONOTONIC);
|
|
nsecs_t frameCompleteNanos =
|
|
tracker[0].get(FrameInfoIndex::FrameCompleted);
|
|
nsecs_t frameDiffNanos = nowNanos - frameCompleteNanos;
|
|
nsecs_t cleanupMillis = ns2ms(std::max(frameDiffNanos, 10_s));
|
|
mRenderThread.cacheManager().performDeferredCleanup(cleanupMillis);
|
|
}
|
|
}
|
|
|
|
void CanvasContext::reportMetricsWithPresentTime() {
|
|
{ // acquire lock
|
|
std::scoped_lock lock(mFrameMetricsReporterMutex);
|
|
if (mFrameMetricsReporter == nullptr) {
|
|
return;
|
|
}
|
|
} // release lock
|
|
if (mNativeSurface == nullptr) {
|
|
return;
|
|
}
|
|
ATRACE_CALL();
|
|
FrameInfo* forthBehind;
|
|
int64_t frameNumber;
|
|
{ // acquire lock
|
|
std::scoped_lock lock(mLast4FrameInfosMutex);
|
|
if (mLast4FrameInfos.size() != mLast4FrameInfos.capacity()) {
|
|
// Not enough frames yet
|
|
return;
|
|
}
|
|
// Surface object keeps stats for the last 8 frames.
|
|
std::tie(forthBehind, frameNumber) = mLast4FrameInfos.front();
|
|
} // release lock
|
|
|
|
nsecs_t presentTime = 0;
|
|
native_window_get_frame_timestamps(
|
|
mNativeSurface->getNativeWindow(), frameNumber, nullptr /*outRequestedPresentTime*/,
|
|
nullptr /*outAcquireTime*/, nullptr /*outLatchTime*/,
|
|
nullptr /*outFirstRefreshStartTime*/, nullptr /*outLastRefreshStartTime*/,
|
|
nullptr /*outGpuCompositionDoneTime*/, &presentTime, nullptr /*outDequeueReadyTime*/,
|
|
nullptr /*outReleaseTime*/);
|
|
|
|
forthBehind->set(FrameInfoIndex::DisplayPresentTime) = presentTime;
|
|
{ // acquire lock
|
|
std::scoped_lock lock(mFrameMetricsReporterMutex);
|
|
if (mFrameMetricsReporter != nullptr) {
|
|
mFrameMetricsReporter->reportFrameMetrics(forthBehind->data(), true /*hasPresentTime*/);
|
|
}
|
|
} // release lock
|
|
}
|
|
|
|
FrameInfo* CanvasContext::getFrameInfoFromLast4(uint64_t frameNumber) {
|
|
std::scoped_lock lock(mLast4FrameInfosMutex);
|
|
for (size_t i = 0; i < mLast4FrameInfos.size(); i++) {
|
|
if (mLast4FrameInfos[i].second == frameNumber) {
|
|
return mLast4FrameInfos[i].first;
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void CanvasContext::onSurfaceStatsAvailable(void* context, ASurfaceControl* control,
|
|
ASurfaceControlStats* stats) {
|
|
|
|
CanvasContext* instance = static_cast<CanvasContext*>(context);
|
|
|
|
const ASurfaceControlFunctions& functions =
|
|
instance->mRenderThread.getASurfaceControlFunctions();
|
|
|
|
nsecs_t gpuCompleteTime = functions.getAcquireTimeFunc(stats);
|
|
uint64_t frameNumber = functions.getFrameNumberFunc(stats);
|
|
|
|
FrameInfo* frameInfo = instance->getFrameInfoFromLast4(frameNumber);
|
|
|
|
if (frameInfo != nullptr) {
|
|
frameInfo->set(FrameInfoIndex::FrameCompleted) = std::max(gpuCompleteTime,
|
|
frameInfo->get(FrameInfoIndex::SwapBuffersCompleted));
|
|
frameInfo->set(FrameInfoIndex::GpuCompleted) = gpuCompleteTime;
|
|
std::scoped_lock lock(instance->mFrameMetricsReporterMutex);
|
|
instance->mJankTracker.finishFrame(*frameInfo, instance->mFrameMetricsReporter);
|
|
}
|
|
}
|
|
|
|
// Called by choreographer to do an RT-driven animation
|
|
void CanvasContext::doFrame() {
|
|
if (!mRenderPipeline->isSurfaceReady()) return;
|
|
prepareAndDraw(nullptr);
|
|
}
|
|
|
|
SkISize CanvasContext::getNextFrameSize() const {
|
|
static constexpr SkISize defaultFrameSize = {INT32_MAX, INT32_MAX};
|
|
if (mNativeSurface == nullptr) {
|
|
return defaultFrameSize;
|
|
}
|
|
ANativeWindow* anw = mNativeSurface->getNativeWindow();
|
|
|
|
SkISize size;
|
|
size.fWidth = ANativeWindow_getWidth(anw);
|
|
size.fHeight = ANativeWindow_getHeight(anw);
|
|
return size;
|
|
}
|
|
|
|
void CanvasContext::prepareAndDraw(RenderNode* node) {
|
|
ATRACE_CALL();
|
|
|
|
nsecs_t vsync = mRenderThread.timeLord().computeFrameTimeNanos();
|
|
int64_t vsyncId = mRenderThread.timeLord().lastVsyncId();
|
|
int64_t frameDeadline = mRenderThread.timeLord().lastFrameDeadline();
|
|
int64_t frameInterval = mRenderThread.timeLord().frameIntervalNanos();
|
|
int64_t frameInfo[UI_THREAD_FRAME_INFO_SIZE];
|
|
UiFrameInfoBuilder(frameInfo)
|
|
.addFlag(FrameInfoFlags::RTAnimation)
|
|
.setVsync(vsync, vsync, vsyncId, frameDeadline, frameInterval);
|
|
|
|
TreeInfo info(TreeInfo::MODE_RT_ONLY, *this);
|
|
prepareTree(info, frameInfo, systemTime(SYSTEM_TIME_MONOTONIC), node);
|
|
if (info.out.canDrawThisFrame) {
|
|
draw();
|
|
} else {
|
|
// wait on fences so tasks don't overlap next frame
|
|
waitOnFences();
|
|
}
|
|
}
|
|
|
|
void CanvasContext::markLayerInUse(RenderNode* node) {
|
|
if (mPrefetchedLayers.erase(node)) {
|
|
node->decStrong(nullptr);
|
|
}
|
|
}
|
|
|
|
void CanvasContext::freePrefetchedLayers() {
|
|
if (mPrefetchedLayers.size()) {
|
|
for (auto& node : mPrefetchedLayers) {
|
|
ALOGW("Incorrectly called buildLayer on View: %s, destroying layer...",
|
|
node->getName());
|
|
node->destroyLayers();
|
|
node->decStrong(nullptr);
|
|
}
|
|
mPrefetchedLayers.clear();
|
|
}
|
|
}
|
|
|
|
void CanvasContext::buildLayer(RenderNode* node) {
|
|
ATRACE_CALL();
|
|
if (!mRenderPipeline->isContextReady()) return;
|
|
|
|
// buildLayer() will leave the tree in an unknown state, so we must stop drawing
|
|
stopDrawing();
|
|
|
|
TreeInfo info(TreeInfo::MODE_FULL, *this);
|
|
info.damageAccumulator = &mDamageAccumulator;
|
|
info.layerUpdateQueue = &mLayerUpdateQueue;
|
|
info.runAnimations = false;
|
|
node->prepareTree(info);
|
|
SkRect ignore;
|
|
mDamageAccumulator.finish(&ignore);
|
|
// Tickle the GENERIC property on node to mark it as dirty for damaging
|
|
// purposes when the frame is actually drawn
|
|
node->setPropertyFieldsDirty(RenderNode::GENERIC);
|
|
|
|
mRenderPipeline->renderLayers(mLightGeometry, &mLayerUpdateQueue, mOpaque, mLightInfo);
|
|
|
|
node->incStrong(nullptr);
|
|
mPrefetchedLayers.insert(node);
|
|
}
|
|
|
|
void CanvasContext::destroyHardwareResources() {
|
|
stopDrawing();
|
|
if (mRenderPipeline->isContextReady()) {
|
|
freePrefetchedLayers();
|
|
for (const sp<RenderNode>& node : mRenderNodes) {
|
|
node->destroyHardwareResources();
|
|
}
|
|
mRenderPipeline->onDestroyHardwareResources();
|
|
}
|
|
}
|
|
|
|
void CanvasContext::trimMemory(RenderThread& thread, int level) {
|
|
ATRACE_CALL();
|
|
if (!thread.getGrContext()) return;
|
|
ATRACE_CALL();
|
|
if (level >= TRIM_MEMORY_COMPLETE) {
|
|
thread.cacheManager().trimMemory(CacheManager::TrimMemoryMode::Complete);
|
|
thread.destroyRenderingContext();
|
|
} else if (level >= TRIM_MEMORY_UI_HIDDEN) {
|
|
thread.cacheManager().trimMemory(CacheManager::TrimMemoryMode::UiHidden);
|
|
}
|
|
}
|
|
|
|
DeferredLayerUpdater* CanvasContext::createTextureLayer() {
|
|
return mRenderPipeline->createTextureLayer();
|
|
}
|
|
|
|
void CanvasContext::dumpFrames(int fd) {
|
|
mJankTracker.dumpStats(fd);
|
|
mJankTracker.dumpFrames(fd);
|
|
}
|
|
|
|
void CanvasContext::resetFrameStats() {
|
|
mJankTracker.reset();
|
|
}
|
|
|
|
void CanvasContext::setName(const std::string&& name) {
|
|
mJankTracker.setDescription(JankTrackerType::Window, std::move(name));
|
|
}
|
|
|
|
void CanvasContext::waitOnFences() {
|
|
if (mFrameFences.size()) {
|
|
ATRACE_CALL();
|
|
for (auto& fence : mFrameFences) {
|
|
fence.get();
|
|
}
|
|
mFrameFences.clear();
|
|
}
|
|
}
|
|
|
|
void CanvasContext::enqueueFrameWork(std::function<void()>&& func) {
|
|
mFrameFences.push_back(CommonPool::async(std::move(func)));
|
|
}
|
|
|
|
int64_t CanvasContext::getFrameNumber() {
|
|
// mFrameNumber is reset to -1 when the surface changes or we swap buffers
|
|
if (mFrameNumber == -1 && mNativeSurface.get()) {
|
|
mFrameNumber = ANativeWindow_getNextFrameId(mNativeSurface->getNativeWindow());
|
|
}
|
|
return mFrameNumber;
|
|
}
|
|
|
|
bool CanvasContext::surfaceRequiresRedraw() {
|
|
if (!mNativeSurface) return false;
|
|
if (mHaveNewSurface) return true;
|
|
|
|
ANativeWindow* anw = mNativeSurface->getNativeWindow();
|
|
const int width = ANativeWindow_getWidth(anw);
|
|
const int height = ANativeWindow_getHeight(anw);
|
|
|
|
return width != mLastFrameWidth || height != mLastFrameHeight;
|
|
}
|
|
|
|
SkRect CanvasContext::computeDirtyRect(const Frame& frame, SkRect* dirty) {
|
|
if (frame.width() != mLastFrameWidth || frame.height() != mLastFrameHeight) {
|
|
// can't rely on prior content of window if viewport size changes
|
|
dirty->setEmpty();
|
|
mLastFrameWidth = frame.width();
|
|
mLastFrameHeight = frame.height();
|
|
} else if (mHaveNewSurface || frame.bufferAge() == 0) {
|
|
// New surface needs a full draw
|
|
dirty->setEmpty();
|
|
} else {
|
|
if (!dirty->isEmpty() && !dirty->intersect(SkRect::MakeIWH(frame.width(), frame.height()))) {
|
|
ALOGW("Dirty " RECT_STRING " doesn't intersect with 0 0 %d %d ?", SK_RECT_ARGS(*dirty),
|
|
frame.width(), frame.height());
|
|
dirty->setEmpty();
|
|
}
|
|
profiler().unionDirty(dirty);
|
|
}
|
|
|
|
if (dirty->isEmpty()) {
|
|
dirty->setIWH(frame.width(), frame.height());
|
|
}
|
|
|
|
// At this point dirty is the area of the window to update. However,
|
|
// the area of the frame we need to repaint is potentially different, so
|
|
// stash the screen area for later
|
|
SkRect windowDirty(*dirty);
|
|
|
|
// If the buffer age is 0 we do a full-screen repaint (handled above)
|
|
// If the buffer age is 1 the buffer contents are the same as they were
|
|
// last frame so there's nothing to union() against
|
|
// Therefore we only care about the > 1 case.
|
|
if (frame.bufferAge() > 1) {
|
|
if (frame.bufferAge() > (int)mSwapHistory.size()) {
|
|
// We don't have enough history to handle this old of a buffer
|
|
// Just do a full-draw
|
|
dirty->setIWH(frame.width(), frame.height());
|
|
} else {
|
|
// At this point we haven't yet added the latest frame
|
|
// to the damage history (happens below)
|
|
// So we need to damage
|
|
for (int i = mSwapHistory.size() - 1;
|
|
i > ((int)mSwapHistory.size()) - frame.bufferAge(); i--) {
|
|
dirty->join(mSwapHistory[i].damage);
|
|
}
|
|
}
|
|
}
|
|
|
|
return windowDirty;
|
|
}
|
|
|
|
CanvasContext* CanvasContext::getActiveContext() {
|
|
return ScopedActiveContext::getActiveContext();
|
|
}
|
|
|
|
bool CanvasContext::mergeTransaction(ASurfaceTransaction* transaction, ASurfaceControl* control) {
|
|
if (!mASurfaceTransactionCallback) return false;
|
|
return std::invoke(mASurfaceTransactionCallback, reinterpret_cast<int64_t>(transaction),
|
|
reinterpret_cast<int64_t>(control), getFrameNumber());
|
|
}
|
|
|
|
void CanvasContext::prepareSurfaceControlForWebview() {
|
|
if (mPrepareSurfaceControlForWebviewCallback) {
|
|
std::invoke(mPrepareSurfaceControlForWebviewCallback);
|
|
}
|
|
}
|
|
|
|
} /* namespace renderthread */
|
|
} /* namespace uirenderer */
|
|
} /* namespace android */
|