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

Commit 7234fa59 authored by Vishnu Nair's avatar Vishnu Nair
Browse files

SF: Predict HWC composition strategy 

Asynchronously run ValidateDisplay to determine client composition
strategy. If we can predict that the composition strategy will not
change from frame to frame (for example by looking at whether
the geometry of the layers is changing), the hwc call is run
asynchronously with the gpu composition. If the result of the call is
incorrectly predicted, the gpu composition is rerun.

ValidateDisplay can take multiple milliseconds to complete and by
making it non-blocking in cases where we can predict the strategy
chosen by the hardware, we can jump start the client composition
and shave valuable milliseconds from the frame time.

This feature is disabled by default.

Test: perfetto traces
Bug: 220031739

Change-Id: Ib4dcc0e055d5272c89cfff853211edac73aa449b
parent 80f319d7

services/surfaceflinger/CompositionEngine/Android.bp

+5 −0
Original line number Diff line number Diff line
@@ -41,6 +41,10 @@ cc_defaults { 
        "libtonemap",

        "libtrace_proto",

        "libaidlcommonsupport",

        "libprocessgroup",

        "libcgrouprc",

        "libjsoncpp",

        "libcgrouprc_format",

    ],

    header_libs: [

        "android.hardware.graphics.composer@2.1-command-buffer",
@@ -68,6 +72,7 @@ cc_library { 
        "src/DisplayColorProfile.cpp",

        "src/DisplaySurface.cpp",

        "src/DumpHelpers.cpp",

        "src/HwcAsyncWorker.cpp",

        "src/HwcBufferCache.cpp",

        "src/LayerFECompositionState.cpp",

        "src/Output.cpp",

services/surfaceflinger/CompositionEngine/include/compositionengine/DisplaySurface.h

+3 −0
Original line number Diff line number Diff line
@@ -72,6 +72,9 @@ public: 
    virtual void resizeBuffers(const ui::Size&) = 0;



    virtual const sp<Fence>& getClientTargetAcquireFence() const = 0;



    // Returns true if the render surface supports client composition prediction.

    virtual bool supportsCompositionStrategyPrediction() const;

};



} // namespace compositionengine

services/surfaceflinger/CompositionEngine/include/compositionengine/Output.h

+18 −3
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ 
#include <utils/Vector.h>



#include <ui/DisplayIdentification.h>

#include "DisplayHardware/HWComposer.h"



namespace android {
@@ -54,6 +55,7 @@ struct LayerFECompositionState; 


namespace impl {

struct OutputCompositionState;

struct GpuCompositionResult;

} // namespace impl



/**
@@ -262,6 +264,9 @@ public: 
    // Latches the front-end layer state for each output layer

    virtual void updateLayerStateFromFE(const CompositionRefreshArgs&) const = 0;



    // Enables predicting composition strategy to run client composition earlier

    virtual void setPredictCompositionStrategy(bool) = 0;



protected:

    virtual void setDisplayColorProfile(std::unique_ptr<DisplayColorProfile>) = 0;

    virtual void setRenderSurface(std::unique_ptr<RenderSurface>) = 0;
@@ -278,13 +283,22 @@ protected: 
    virtual void updateColorProfile(const CompositionRefreshArgs&) = 0;

    virtual void beginFrame() = 0;

    virtual void prepareFrame() = 0;



    using GpuCompositionResult = compositionengine::impl::GpuCompositionResult;

    // Runs prepare frame in another thread while running client composition using

    // the previous frame's composition strategy.

    virtual GpuCompositionResult prepareFrameAsync(const CompositionRefreshArgs&) = 0;

    virtual void devOptRepaintFlash(const CompositionRefreshArgs&) = 0;

    virtual void finishFrame(const CompositionRefreshArgs&) = 0;

    virtual void finishFrame(const CompositionRefreshArgs&, GpuCompositionResult&&) = 0;

    virtual std::optional<base::unique_fd> composeSurfaces(

            const Region&, const compositionengine::CompositionRefreshArgs& refreshArgs) = 0;

            const Region&, const compositionengine::CompositionRefreshArgs&,

            std::shared_ptr<renderengine::ExternalTexture>, base::unique_fd&) = 0;

    virtual void postFramebuffer() = 0;

    virtual void renderCachedSets(const CompositionRefreshArgs&) = 0;

    virtual void chooseCompositionStrategy() = 0;

    virtual std::optional<android::HWComposer::DeviceRequestedChanges>

    chooseCompositionStrategy() = 0;

    virtual void applyCompositionStrategy(

            const std::optional<android::HWComposer::DeviceRequestedChanges>& changes) = 0;

    virtual bool getSkipColorTransform() const = 0;

    virtual FrameFences presentAndGetFrameFences() = 0;

    virtual std::vector<LayerFE::LayerSettings> generateClientCompositionRequests(
@@ -295,6 +309,7 @@ protected: 
            std::vector<LayerFE::LayerSettings>& clientCompositionLayers) = 0;

    virtual void setExpensiveRenderingExpected(bool enabled) = 0;

    virtual void cacheClientCompositionRequests(uint32_t cacheSize) = 0;

    virtual bool canPredictCompositionStrategy(const CompositionRefreshArgs&) = 0;

};



} // namespace compositionengine

services/surfaceflinger/CompositionEngine/include/compositionengine/RenderSurface.h

+3 −0
Original line number Diff line number Diff line
@@ -100,6 +100,9 @@ public: 


    // Debugging - gets the page flip count for the RenderSurface

    virtual std::uint32_t getPageFlipCount() const = 0;



    // Returns true if the render surface supports client composition prediction.

    virtual bool supportsCompositionStrategyPrediction() const = 0;

};



} // namespace compositionengine

services/surfaceflinger/CompositionEngine/include/compositionengine/impl/Display.h

+6 −3
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include <compositionengine/DisplayColorProfile.h>

#include <compositionengine/DisplayCreationArgs.h>

#include <compositionengine/RenderSurface.h>

#include <compositionengine/impl/GpuCompositionResult.h>

#include <compositionengine/impl/Output.h>

#include <ui/PixelFormat.h>

#include <ui/Size.h>
@@ -51,11 +52,14 @@ public: 
    void setReleasedLayers(const CompositionRefreshArgs&) override;

    void setColorTransform(const CompositionRefreshArgs&) override;

    void setColorProfile(const ColorProfile&) override;

    void chooseCompositionStrategy() override;



    using DeviceRequestedChanges = android::HWComposer::DeviceRequestedChanges;

    std::optional<DeviceRequestedChanges> chooseCompositionStrategy() override;

    void applyCompositionStrategy(const std::optional<DeviceRequestedChanges>&) override;

    bool getSkipColorTransform() const override;

    compositionengine::Output::FrameFences presentAndGetFrameFences() override;

    void setExpensiveRenderingExpected(bool) override;

    void finishFrame(const CompositionRefreshArgs&) override;

    void finishFrame(const CompositionRefreshArgs&, GpuCompositionResult&&) override;



    // compositionengine::Display overrides

    DisplayId getId() const override;
@@ -73,7 +77,6 @@ public: 
    using DisplayRequests = android::HWComposer::DeviceRequestedChanges::DisplayRequests;

    using LayerRequests = android::HWComposer::DeviceRequestedChanges::LayerRequests;

    using ClientTargetProperty = android::HWComposer::DeviceRequestedChanges::ClientTargetProperty;

    virtual bool anyLayersRequireClientComposition() const;

    virtual bool allLayersRequireClientComposition() const;

    virtual void applyChangedTypesToLayers(const ChangedTypes&);

    virtual void applyDisplayRequests(const DisplayRequests&);