Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e9023cf4 authored by Matt Buckley's avatar Matt Buckley
Browse files

Refactor HintSessionWrapper and move into CanvasContext 

 * Move HintSessionWrapper into its own file
 * Refactor HintSessionWrapper initialization and lifecycle
 * Move HintSessionWrapper instance into CanvasContext
 * Have HintSessionWrapper do its own validity checks
 * Have HintSessionWrapper implicitly initialize when called

Bug: b/260267128
Bug: b/260224719
Test: manual
Change-Id: I69f89bb5ef601d1b5d9fca1a5da62256f2556da8
parent 30adb922

libs/hwui/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -570,6 +570,7 @@ cc_defaults { 
                "renderthread/VulkanSurface.cpp",

                "renderthread/RenderProxy.cpp",

                "renderthread/RenderThread.cpp",

                "renderthread/HintSessionWrapper.cpp",

                "service/GraphicsStatsService.cpp",

                "thread/CommonPool.cpp",

                "utils/GLUtils.cpp",

libs/hwui/FrameInfo.h

+1 −0
Original line number Diff line number Diff line
@@ -104,6 +104,7 @@ public: 
        set(FrameInfoIndex::AnimationStart) = vsyncTime;

        set(FrameInfoIndex::PerformTraversalsStart) = vsyncTime;

        set(FrameInfoIndex::DrawStart) = vsyncTime;

        set(FrameInfoIndex::FrameStartTime) = vsyncTime;

        set(FrameInfoIndex::FrameDeadline) = frameDeadline;

        set(FrameInfoIndex::FrameInterval) = frameInterval;

        return *this;

libs/hwui/renderthread/CanvasContext.cpp

+47 −11
Original line number Diff line number Diff line
@@ -71,16 +71,19 @@ CanvasContext* ScopedActiveContext::sActiveContext = nullptr; 
} /* namespace */



CanvasContext* CanvasContext::create(RenderThread& thread, bool translucent,

                                     RenderNode* rootRenderNode, IContextFactory* contextFactory) {

                                     RenderNode* rootRenderNode, IContextFactory* contextFactory,

                                     int32_t uiThreadId, int32_t renderThreadId) {

    auto renderType = Properties::getRenderPipelineType();



    switch (renderType) {

        case RenderPipelineType::SkiaGL:

            return new CanvasContext(thread, translucent, rootRenderNode, contextFactory,

                                     std::make_unique<skiapipeline::SkiaOpenGLPipeline>(thread));

                                     std::make_unique<skiapipeline::SkiaOpenGLPipeline>(thread),

                                     uiThreadId, renderThreadId);

        case RenderPipelineType::SkiaVulkan:

            return new CanvasContext(thread, translucent, rootRenderNode, contextFactory,

                                     std::make_unique<skiapipeline::SkiaVulkanPipeline>(thread));

                                     std::make_unique<skiapipeline::SkiaVulkanPipeline>(thread),

                                     uiThreadId, renderThreadId);

        default:

            LOG_ALWAYS_FATAL("canvas context type %d not supported", (int32_t)renderType);

            break;
@@ -110,7 +113,8 @@ void CanvasContext::prepareToDraw(const RenderThread& thread, Bitmap* bitmap) { 


CanvasContext::CanvasContext(RenderThread& thread, bool translucent, RenderNode* rootRenderNode,

                             IContextFactory* contextFactory,

                             std::unique_ptr<IRenderPipeline> renderPipeline)

                             std::unique_ptr<IRenderPipeline> renderPipeline, pid_t uiThreadId,

                             pid_t renderThreadId)

        : mRenderThread(thread)

        , mGenerationID(0)

        , mOpaque(!translucent)
@@ -118,7 +122,8 @@ CanvasContext::CanvasContext(RenderThread& thread, bool translucent, RenderNode* 
        , mJankTracker(&thread.globalProfileData())

        , mProfiler(mJankTracker.frames(), thread.timeLord().frameIntervalNanos())

        , mContentDrawBounds(0, 0, 0, 0)

        , mRenderPipeline(std::move(renderPipeline)) {

        , mRenderPipeline(std::move(renderPipeline))

        , mHintSessionWrapper(uiThreadId, renderThreadId) {

    mRenderThread.cacheManager().registerCanvasContext(this);

    rootRenderNode->makeRoot();

    mRenderNodes.emplace_back(rootRenderNode);
@@ -472,16 +477,22 @@ void CanvasContext::notifyFramePending() { 
    mRenderThread.pushBackFrameCallback(this);

}



std::optional<nsecs_t> CanvasContext::draw() {

void CanvasContext::draw() {

    if (auto grContext = getGrContext()) {

        if (grContext->abandoned()) {

            LOG_ALWAYS_FATAL("GrContext is abandoned/device lost at start of CanvasContext::draw");

            return std::nullopt;

            return;

        }

    }

    SkRect dirty;

    mDamageAccumulator.finish(&dirty);



    // reset syncDelayDuration each time we draw

    nsecs_t syncDelayDuration = mSyncDelayDuration;

    nsecs_t idleDuration = mIdleDuration;

    mSyncDelayDuration = 0;

    mIdleDuration = 0;



    if (!Properties::isDrawingEnabled() ||

        (dirty.isEmpty() && Properties::skipEmptyFrames && !surfaceRequiresRedraw())) {

        mCurrentFrameInfo->addFlag(FrameInfoFlags::SkippedFrame);
@@ -498,7 +509,7 @@ std::optional<nsecs_t> CanvasContext::draw() { 
            std::invoke(func, false /* didProduceBuffer */);

        }

        mFrameCommitCallbacks.clear();

        return std::nullopt;

        return;

    }



    ScopedActiveContext activeContext(this);
@@ -650,10 +661,25 @@ std::optional<nsecs_t> CanvasContext::draw() { 
        }

    }



    int64_t intendedVsync = mCurrentFrameInfo->get(FrameInfoIndex::IntendedVsync);

    int64_t frameDeadline = mCurrentFrameInfo->get(FrameInfoIndex::FrameDeadline);

    int64_t dequeueBufferDuration = mCurrentFrameInfo->get(FrameInfoIndex::DequeueBufferDuration);



    mHintSessionWrapper.updateTargetWorkDuration(frameDeadline - intendedVsync);



    if (didDraw) {

        int64_t frameStartTime = mCurrentFrameInfo->get(FrameInfoIndex::FrameStartTime);

        int64_t frameDuration = systemTime(SYSTEM_TIME_MONOTONIC) - frameStartTime;

        int64_t actualDuration = frameDuration -

                                 (std::min(syncDelayDuration, mLastDequeueBufferDuration)) -

                                 dequeueBufferDuration - idleDuration;

        mHintSessionWrapper.reportActualWorkDuration(actualDuration);

    }



    mLastDequeueBufferDuration = dequeueBufferDuration;



    mRenderThread.cacheManager().onFrameCompleted();

    return didDraw ? std::make_optional(

                             mCurrentFrameInfo->get(FrameInfoIndex::DequeueBufferDuration))

                   : std::nullopt;

    return;

}



void CanvasContext::reportMetricsWithPresentTime() {
@@ -766,6 +792,8 @@ void CanvasContext::onSurfaceStatsAvailable(void* context, int32_t surfaceContro 
// Called by choreographer to do an RT-driven animation

void CanvasContext::doFrame() {

    if (!mRenderPipeline->isSurfaceReady()) return;

    mIdleDuration =

            systemTime(SYSTEM_TIME_MONOTONIC) - mRenderThread.timeLord().computeFrameTimeNanos();

    prepareAndDraw(nullptr);

}
@@ -974,6 +1002,14 @@ void CanvasContext::prepareSurfaceControlForWebview() { 
    }

}



void CanvasContext::sendLoadResetHint() {

    mHintSessionWrapper.sendLoadResetHint();

}



void CanvasContext::setSyncDelayDuration(nsecs_t duration) {

    mSyncDelayDuration = duration;

}



} /* namespace renderthread */

} /* namespace uirenderer */

} /* namespace android */

libs/hwui/renderthread/CanvasContext.h

+30 −18
Original line number Diff line number Diff line
@@ -16,10 +16,26 @@ 


#pragma once



#include <SkBitmap.h>

#include <SkRect.h>

#include <SkSize.h>

#include <cutils/compiler.h>

#include <utils/Functor.h>

#include <utils/Mutex.h>



#include <functional>

#include <future>

#include <set>

#include <string>

#include <utility>

#include <vector>



#include "ColorMode.h"

#include "DamageAccumulator.h"

#include "FrameInfo.h"

#include "FrameInfoVisualizer.h"

#include "FrameMetricsReporter.h"

#include "HintSessionWrapper.h"

#include "IContextFactory.h"

#include "IRenderPipeline.h"

#include "JankTracker.h"
@@ -30,21 +46,6 @@ 
#include "renderthread/RenderTask.h"

#include "renderthread/RenderThread.h"

#include "utils/RingBuffer.h"

#include "ColorMode.h"



#include <SkBitmap.h>

#include <SkRect.h>

#include <SkSize.h>

#include <cutils/compiler.h>

#include <utils/Functor.h>

#include <utils/Mutex.h>



#include <functional>

#include <future>

#include <set>

#include <string>

#include <utility>

#include <vector>



namespace android {

namespace uirenderer {
@@ -66,7 +67,8 @@ class Frame; 
class CanvasContext : public IFrameCallback {

public:

    static CanvasContext* create(RenderThread& thread, bool translucent, RenderNode* rootRenderNode,

                                 IContextFactory* contextFactory);

                                 IContextFactory* contextFactory, pid_t uiThreadId,

                                 pid_t renderThreadId);

    virtual ~CanvasContext();



    /**
@@ -138,7 +140,7 @@ public: 
    bool makeCurrent();

    void prepareTree(TreeInfo& info, int64_t* uiFrameInfo, int64_t syncQueued, RenderNode* target);

    // Returns the DequeueBufferDuration.

    std::optional<nsecs_t> draw();

    void draw();

    void destroy();



    // IFrameCallback, Choreographer-driven frame callback entry point
@@ -214,9 +216,14 @@ public: 


    static CanvasContext* getActiveContext();



    void sendLoadResetHint();



    void setSyncDelayDuration(nsecs_t duration);



private:

    CanvasContext(RenderThread& thread, bool translucent, RenderNode* rootRenderNode,

                  IContextFactory* contextFactory, std::unique_ptr<IRenderPipeline> renderPipeline);

                  IContextFactory* contextFactory, std::unique_ptr<IRenderPipeline> renderPipeline,

                  pid_t uiThreadId, pid_t renderThreadId);



    friend class RegisterFrameCallbackTask;

    // TODO: Replace with something better for layer & other GL object
@@ -330,6 +337,11 @@ private: 


    std::function<bool(int64_t, int64_t, int64_t)> mASurfaceTransactionCallback;

    std::function<void()> mPrepareSurfaceControlForWebviewCallback;



    HintSessionWrapper mHintSessionWrapper;

    nsecs_t mLastDequeueBufferDuration = 0;

    nsecs_t mSyncDelayDuration = 0;

    nsecs_t mIdleDuration = 0;

};



} /* namespace renderthread */

libs/hwui/renderthread/DrawFrameTask.cpp

+6 −153
Original line number Diff line number Diff line
@@ -16,7 +16,6 @@ 


#include "DrawFrameTask.h"



#include <dlfcn.h>

#include <gui/TraceUtils.h>

#include <utils/Log.h>
@@ -28,70 +27,11 @@ 
#include "../RenderNode.h"

#include "CanvasContext.h"

#include "RenderThread.h"

#include "thread/CommonPool.h"

#include "utils/TimeUtils.h"



namespace android {

namespace uirenderer {

namespace renderthread {



namespace {



typedef APerformanceHintManager* (*APH_getManager)();

typedef APerformanceHintSession* (*APH_createSession)(APerformanceHintManager*, const int32_t*,

                                                      size_t, int64_t);

typedef void (*APH_updateTargetWorkDuration)(APerformanceHintSession*, int64_t);

typedef void (*APH_reportActualWorkDuration)(APerformanceHintSession*, int64_t);

typedef void (*APH_sendHint)(APerformanceHintSession* session, int32_t);

typedef void (*APH_closeSession)(APerformanceHintSession* session);



bool gAPerformanceHintBindingInitialized = false;

APH_getManager gAPH_getManagerFn = nullptr;

APH_createSession gAPH_createSessionFn = nullptr;

APH_updateTargetWorkDuration gAPH_updateTargetWorkDurationFn = nullptr;

APH_reportActualWorkDuration gAPH_reportActualWorkDurationFn = nullptr;

APH_sendHint gAPH_sendHintFn = nullptr;

APH_closeSession gAPH_closeSessionFn = nullptr;



void ensureAPerformanceHintBindingInitialized() {

    if (gAPerformanceHintBindingInitialized) return;



    void* handle_ = dlopen("libandroid.so", RTLD_NOW | RTLD_NODELETE);

    LOG_ALWAYS_FATAL_IF(handle_ == nullptr, "Failed to dlopen libandroid.so!");



    gAPH_getManagerFn = (APH_getManager)dlsym(handle_, "APerformanceHint_getManager");

    LOG_ALWAYS_FATAL_IF(gAPH_getManagerFn == nullptr,

                        "Failed to find required symbol APerformanceHint_getManager!");



    gAPH_createSessionFn = (APH_createSession)dlsym(handle_, "APerformanceHint_createSession");

    LOG_ALWAYS_FATAL_IF(gAPH_createSessionFn == nullptr,

                        "Failed to find required symbol APerformanceHint_createSession!");



    gAPH_updateTargetWorkDurationFn = (APH_updateTargetWorkDuration)dlsym(

            handle_, "APerformanceHint_updateTargetWorkDuration");

    LOG_ALWAYS_FATAL_IF(

            gAPH_updateTargetWorkDurationFn == nullptr,

            "Failed to find required symbol APerformanceHint_updateTargetWorkDuration!");



    gAPH_reportActualWorkDurationFn = (APH_reportActualWorkDuration)dlsym(

            handle_, "APerformanceHint_reportActualWorkDuration");

    LOG_ALWAYS_FATAL_IF(

            gAPH_reportActualWorkDurationFn == nullptr,

            "Failed to find required symbol APerformanceHint_reportActualWorkDuration!");



    gAPH_sendHintFn = (APH_sendHint)dlsym(handle_, "APerformanceHint_sendHint");

    LOG_ALWAYS_FATAL_IF(gAPH_sendHintFn == nullptr,

                        "Failed to find required symbol APerformanceHint_sendHint!");



    gAPH_closeSessionFn = (APH_closeSession)dlsym(handle_, "APerformanceHint_closeSession");

    LOG_ALWAYS_FATAL_IF(gAPH_closeSessionFn == nullptr,

                        "Failed to find required symbol APerformanceHint_closeSession!");



    gAPerformanceHintBindingInitialized = true;

}



}  // namespace



DrawFrameTask::DrawFrameTask()

        : mRenderThread(nullptr)

        , mContext(nullptr)
@@ -100,13 +40,11 @@ DrawFrameTask::DrawFrameTask() 


DrawFrameTask::~DrawFrameTask() {}



void DrawFrameTask::setContext(RenderThread* thread, CanvasContext* context, RenderNode* targetNode,

                               int32_t uiThreadId, int32_t renderThreadId) {

void DrawFrameTask::setContext(RenderThread* thread, CanvasContext* context,

                               RenderNode* targetNode) {

    mRenderThread = thread;

    mContext = context;

    mTargetNode = targetNode;

    mUiThreadId = uiThreadId;

    mRenderThreadId = renderThreadId;

}



void DrawFrameTask::pushLayerUpdate(DeferredLayerUpdater* layer) {
@@ -150,11 +88,11 @@ void DrawFrameTask::postAndWait() { 
void DrawFrameTask::run() {

    const int64_t vsyncId = mFrameInfo[static_cast<int>(FrameInfoIndex::FrameTimelineVsyncId)];

    ATRACE_FORMAT("DrawFrames %" PRId64, vsyncId);

    nsecs_t syncDelayDuration = systemTime(SYSTEM_TIME_MONOTONIC) - mSyncQueued;



    mContext->setSyncDelayDuration(systemTime(SYSTEM_TIME_MONOTONIC) - mSyncQueued);



    bool canUnblockUiThread;

    bool canDrawThisFrame;

    bool didDraw = false;

    {

        TreeInfo info(TreeInfo::MODE_FULL, *mContext);

        info.forceDrawFrame = mForceDrawFrame;
@@ -175,9 +113,6 @@ void DrawFrameTask::run() { 
    std::function<void()> frameCompleteCallback = std::move(mFrameCompleteCallback);

    mFrameCallback = nullptr;

    mFrameCompleteCallback = nullptr;

    int64_t intendedVsync = mFrameInfo[static_cast<int>(FrameInfoIndex::IntendedVsync)];

    int64_t frameDeadline = mFrameInfo[static_cast<int>(FrameInfoIndex::FrameDeadline)];

    int64_t frameStartTime = mFrameInfo[static_cast<int>(FrameInfoIndex::FrameStartTime)];



    // From this point on anything in "this" is *UNSAFE TO ACCESS*

    if (canUnblockUiThread) {
@@ -188,18 +123,15 @@ void DrawFrameTask::run() { 
    if (CC_UNLIKELY(frameCallback)) {

        context->enqueueFrameWork([frameCallback, context, syncResult = mSyncResult,

                                   frameNr = context->getFrameNumber()]() {

            auto frameCommitCallback = std::move(frameCallback(syncResult, frameNr));

            auto frameCommitCallback = frameCallback(syncResult, frameNr);

            if (frameCommitCallback) {

                context->addFrameCommitListener(std::move(frameCommitCallback));

            }

        });

    }



    nsecs_t dequeueBufferDuration = 0;

    if (CC_LIKELY(canDrawThisFrame)) {

        std::optional<nsecs_t> drawResult = context->draw();

        didDraw = drawResult.has_value();

        dequeueBufferDuration = drawResult.value_or(0);

        context->draw();

    } else {

        // Do a flush in case syncFrameState performed any texture uploads. Since we skipped

        // the draw() call, those uploads (or deletes) will end up sitting in the queue.
@@ -218,41 +150,6 @@ void DrawFrameTask::run() { 
    if (!canUnblockUiThread) {

        unblockUiThread();

    }



    if (!mHintSessionWrapper) mHintSessionWrapper.emplace(mUiThreadId, mRenderThreadId);



    constexpr int64_t kSanityCheckLowerBound = 100_us;

    constexpr int64_t kSanityCheckUpperBound = 10_s;

    int64_t targetWorkDuration = frameDeadline - intendedVsync;

    targetWorkDuration = targetWorkDuration * Properties::targetCpuTimePercentage / 100;

    if (targetWorkDuration > kSanityCheckLowerBound &&

        targetWorkDuration < kSanityCheckUpperBound &&

        targetWorkDuration != mLastTargetWorkDuration) {

        mLastTargetWorkDuration = targetWorkDuration;

        mHintSessionWrapper->updateTargetWorkDuration(targetWorkDuration);

    }



    if (didDraw) {

        int64_t frameDuration = systemTime(SYSTEM_TIME_MONOTONIC) - frameStartTime;

        int64_t actualDuration = frameDuration -

                                 (std::min(syncDelayDuration, mLastDequeueBufferDuration)) -

                                 dequeueBufferDuration;

        if (actualDuration > kSanityCheckLowerBound && actualDuration < kSanityCheckUpperBound) {

            mHintSessionWrapper->reportActualWorkDuration(actualDuration);

        }

    }



    mLastDequeueBufferDuration = dequeueBufferDuration;

}



void DrawFrameTask::sendLoadResetHint() {

    if (!(Properties::useHintManager && Properties::isDrawingEnabled())) return;

    if (!mHintSessionWrapper) mHintSessionWrapper.emplace(mUiThreadId, mRenderThreadId);

    nsecs_t now = systemTime();

    if (now - mLastFrameNotification > kResetHintTimeout) {

        mHintSessionWrapper->sendHint(SessionHint::CPU_LOAD_RESET);

    }

    mLastFrameNotification = now;

}



bool DrawFrameTask::syncFrameState(TreeInfo& info) {
@@ -305,50 +202,6 @@ void DrawFrameTask::unblockUiThread() { 
    mSignal.signal();

}



DrawFrameTask::HintSessionWrapper::HintSessionWrapper(int32_t uiThreadId, int32_t renderThreadId) {

    if (!Properties::useHintManager) return;

    if (uiThreadId < 0 || renderThreadId < 0) return;



    ensureAPerformanceHintBindingInitialized();



    APerformanceHintManager* manager = gAPH_getManagerFn();

    if (!manager) return;



    std::vector<int32_t> tids = CommonPool::getThreadIds();

    tids.push_back(uiThreadId);

    tids.push_back(renderThreadId);



    // DrawFrameTask code will always set a target duration before reporting actual durations.

    // So this is just a placeholder value that's never used.

    int64_t dummyTargetDurationNanos = 16666667;

    mHintSession =

            gAPH_createSessionFn(manager, tids.data(), tids.size(), dummyTargetDurationNanos);

}



DrawFrameTask::HintSessionWrapper::~HintSessionWrapper() {

    if (mHintSession) {

        gAPH_closeSessionFn(mHintSession);

    }

}



void DrawFrameTask::HintSessionWrapper::updateTargetWorkDuration(long targetDurationNanos) {

    if (mHintSession) {

        gAPH_updateTargetWorkDurationFn(mHintSession, targetDurationNanos);

    }

}



void DrawFrameTask::HintSessionWrapper::reportActualWorkDuration(long actualDurationNanos) {

    if (mHintSession) {

        gAPH_reportActualWorkDurationFn(mHintSession, actualDurationNanos);

    }

}



void DrawFrameTask::HintSessionWrapper::sendHint(SessionHint hint) {

    if (mHintSession && Properties::isDrawingEnabled()) {

        gAPH_sendHintFn(mHintSession, static_cast<int>(hint));

    }

}



} /* namespace renderthread */

} /* namespace uirenderer */

} /* namespace android */