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

Commit 822e4ebe authored by Noelle Scobie's avatar Noelle Scobie Committed by Android (Google) Code Review
Browse files

Merge changes from topic "nscobie_renderengine-camelcase-enums" into main 

* changes:
  Convert benchmark registration to be programmatic & add other RE backends
  Add ftl support to RenderEngine enums
  Process pending tasks before shutting down RenderEngineThreaded
parents 11c088d4 4e316e5a

libs/renderengine/RenderEngine.cpp

+10 −9
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ 


#include <com_android_graphics_surfaceflinger_flags.h>

#include <cutils/properties.h>

#include <ftl/enum.h>

#include <log/log.h>



// TODO: b/341728634 - Clean up conditional compilation.
@@ -45,28 +46,28 @@ std::unique_ptr<RenderEngine> RenderEngine::create(const RenderEngineCreationArg 
#if COMPILE_GRAPHITE_RENDERENGINE

    const RenderEngine::SkiaBackend actualSkiaBackend = args.skiaBackend;

#else

    if (args.skiaBackend == RenderEngine::SkiaBackend::GRAPHITE) {

    if (args.skiaBackend == RenderEngine::SkiaBackend::Graphite) {

        ALOGE("RenderEngine with Graphite Skia backend was requested, but Graphite was not "

              "included in the build. Falling back to Ganesh (%s)",

              args.graphicsApi == RenderEngine::GraphicsApi::GL ? "GL" : "Vulkan");

              ftl::enum_string(args.graphicsApi).c_str());

    }

    const RenderEngine::SkiaBackend actualSkiaBackend = RenderEngine::SkiaBackend::GANESH;

    const RenderEngine::SkiaBackend actualSkiaBackend = RenderEngine::SkiaBackend::Ganesh;

#endif



    ALOGD("%sRenderEngine with %s Backend (%s)", args.threaded == Threaded::YES ? "Threaded " : "",

          args.graphicsApi == GraphicsApi::GL ? "SkiaGL" : "SkiaVK",

          actualSkiaBackend == SkiaBackend::GANESH ? "Ganesh" : "Graphite");

    ALOGD("%sRenderEngine with Skia%s Backend (%s)",

          args.threaded == Threaded::Yes ? "Threaded " : "",

          ftl::enum_string(args.graphicsApi).c_str(), ftl::enum_string(actualSkiaBackend).c_str());



// TODO: b/341728634 - Clean up conditional compilation.

#if COMPILE_GRAPHITE_RENDERENGINE

    if (actualSkiaBackend == SkiaBackend::GRAPHITE) {

    if (actualSkiaBackend == SkiaBackend::Graphite) {

        createInstanceFactory = [args]() {

            return android::renderengine::skia::GraphiteVkRenderEngine::create(args);

        };

    } else

#endif

    { // GANESH

        if (args.graphicsApi == GraphicsApi::VK) {

        if (args.graphicsApi == GraphicsApi::Vk) {

            createInstanceFactory = [args]() {

                return android::renderengine::skia::GaneshVkRenderEngine::create(args);

            };
@@ -77,7 +78,7 @@ std::unique_ptr<RenderEngine> RenderEngine::create(const RenderEngineCreationArg 
        }

    }



    if (args.threaded == Threaded::YES) {

    if (args.threaded == Threaded::Yes) {

        return renderengine::threaded::RenderEngineThreaded::create(createInstanceFactory);

    } else {

        return createInstanceFactory();

libs/renderengine/benchmark/RenderEngineBench.cpp

+96 −42
Original line number Diff line number Diff line
@@ -18,6 +18,8 @@ 
#include <android-base/file.h>

#include <benchmark/benchmark.h>

#include <com_android_graphics_libgui_flags.h>

#include <com_android_graphics_surfaceflinger_flags.h>

#include <ftl/enum.h>

#include <gui/SurfaceComposerClient.h>

#include <log/log.h>

#include <renderengine/ExternalTexture.h>
@@ -26,6 +28,15 @@ 
#include <renderengine/impl/ExternalTexture.h>



#include <mutex>

#include <sstream>



// TODO: b/341728634 - Clean up conditional compilation.

#if COM_ANDROID_GRAPHICS_SURFACEFLINGER_FLAGS(GRAPHITE_RENDERENGINE) || \

        COM_ANDROID_GRAPHICS_SURFACEFLINGER_FLAGS(FORCE_COMPILE_GRAPHITE_RENDERENGINE)

#define COMPILE_GRAPHITE_RENDERENGINE 1

#else

#define COMPILE_GRAPHITE_RENDERENGINE 0

#endif



using namespace android;

using namespace android::renderengine;
@@ -75,22 +86,6 @@ std::pair<uint32_t, uint32_t> getDisplaySize() { 
    return std::pair<uint32_t, uint32_t>(width, height);

}



static std::unique_ptr<RenderEngine> createRenderEngine(

        RenderEngine::Threaded threaded, RenderEngine::GraphicsApi graphicsApi,

        RenderEngine::BlurAlgorithm blurAlgorithm = RenderEngine::BlurAlgorithm::KAWASE) {

    auto args = RenderEngineCreationArgs::Builder()

                        .setPixelFormat(static_cast<int>(ui::PixelFormat::RGBA_8888))

                        .setImageCacheSize(1)

                        .setEnableProtectedContext(true)

                        .setPrecacheToneMapperShaderOnly(false)

                        .setBlurAlgorithm(blurAlgorithm)

                        .setContextPriority(RenderEngine::ContextPriority::REALTIME)

                        .setThreaded(threaded)

                        .setGraphicsApi(graphicsApi)

                        .build();

    return RenderEngine::create(args);

}



static std::shared_ptr<ExternalTexture> allocateBuffer(RenderEngine& re, uint32_t width,

                                                       uint32_t height,

                                                       uint64_t extraUsageFlags = 0,
@@ -209,11 +204,8 @@ constexpr char kHomescreenPath[] = "/resources/homescreen.png"; 
 * Draw a layer with texture and no additional shaders as a baseline to evaluate a shader's impact

 * on performance

 */

template <class... Args>

void BM_homescreen(benchmark::State& benchState, Args&&... args) {

    auto args_tuple = std::make_tuple(std::move(args)...);

    auto re = createRenderEngine(static_cast<RenderEngine::Threaded>(std::get<0>(args_tuple)),

                                 static_cast<RenderEngine::GraphicsApi>(std::get<1>(args_tuple)));

void BM_homescreen(benchmark::State& benchState, const RenderEngineCreationArgs& creationArgs) {

    auto re = RenderEngine::create(creationArgs);



    auto [width, height] = getDisplaySize();

    auto srcBuffer = createTexture(*re, kHomescreenPath);
@@ -237,11 +229,9 @@ void BM_homescreen(benchmark::State& benchState, Args&&... args) { 
    benchDrawLayers(*re, layers, benchState, "homescreen");

}



template <class... Args>

void BM_homescreen_blur(benchmark::State& benchState, Args&&... args) {

    auto args_tuple = std::make_tuple(std::move(args)...);

    auto re = createRenderEngine(static_cast<RenderEngine::Threaded>(std::get<0>(args_tuple)),

                                 static_cast<RenderEngine::GraphicsApi>(std::get<1>(args_tuple)));

void BM_homescreen_blur(benchmark::State& benchState,

                        const RenderEngineCreationArgs& creationArgs) {

    auto re = RenderEngine::create(creationArgs);



    auto [width, height] = getDisplaySize();

    auto srcBuffer = createTexture(*re, kHomescreenPath);
@@ -275,11 +265,9 @@ void BM_homescreen_blur(benchmark::State& benchState, Args&&... args) { 
    benchDrawLayers(*re, layers, benchState, "homescreen_blurred");

}



template <class... Args>

void BM_homescreen_edgeExtension(benchmark::State& benchState, Args&&... args) {

    auto args_tuple = std::make_tuple(std::move(args)...);

    auto re = createRenderEngine(static_cast<RenderEngine::Threaded>(std::get<0>(args_tuple)),

                                 static_cast<RenderEngine::GraphicsApi>(std::get<1>(args_tuple)));

void BM_homescreen_edgeExtension(benchmark::State& benchState,

                                 const RenderEngineCreationArgs& creationArgs) {

    auto re = RenderEngine::create(creationArgs);



    auto [width, height] = getDisplaySize();

    auto srcBuffer = createTexture(*re, kHomescreenPath);
@@ -310,19 +298,85 @@ void BM_homescreen_edgeExtension(benchmark::State& benchState, Args&&... args) { 
    benchDrawLayers(*re, layers, benchState, "homescreen_edge_extension");

}



BENCHMARK_CAPTURE(BM_homescreen_blur, gaussian, RenderEngine::Threaded::YES,

                  RenderEngine::GraphicsApi::GL, RenderEngine::BlurAlgorithm::GAUSSIAN);

std::string GenerateBenchmarkVariantName(const char* benchmarkName,

                                         const RenderEngineCreationArgs& args) {

    std::stringstream ss;

    ss << ftl::enum_string(args.skiaBackend);

    ss << ftl::enum_string(args.graphicsApi);



    if (args.blurAlgorithm != RenderEngine::BlurAlgorithm::None) {

        ss << "_";

        ss << ftl::enum_string(args.blurAlgorithm);

    }



    ss << "__" << benchmarkName;



    return ss.str();

}



template <class Lambda, class... Args>

void RegisterBenchmarkIfValid(Lambda&& benchmarkFn, const char* benchmarkName,

                              const RenderEngineCreationArgs& reCreationArgs,

                              Args&&... benchmarkArgs) {

    // Graphite only supports (native) Vulkan in RenderEngine.

    if (reCreationArgs.skiaBackend == RenderEngine::SkiaBackend::Graphite &&

        reCreationArgs.graphicsApi != RenderEngine::GraphicsApi::Vk) {

        return;

    }



    if (!RenderEngine::canSupport(reCreationArgs.graphicsApi)) {

        return;

    }



BENCHMARK_CAPTURE(BM_homescreen_blur, kawase, RenderEngine::Threaded::YES,

                  RenderEngine::GraphicsApi::GL, RenderEngine::BlurAlgorithm::KAWASE);

    benchmark::RegisterBenchmark(GenerateBenchmarkVariantName(benchmarkName, reCreationArgs),

                                 benchmarkFn, reCreationArgs, benchmarkArgs...);

}



BENCHMARK_CAPTURE(BM_homescreen_blur, kawase_dual_filter, RenderEngine::Threaded::YES,

                  RenderEngine::GraphicsApi::GL, RenderEngine::BlurAlgorithm::KAWASE_DUAL_FILTER);

#define REGISTER_BM_IF_VALID(benchmarkFn, reCreationArgs, ...) \

    RegisterBenchmarkIfValid(benchmarkFn, #benchmarkFn, reCreationArgs, ##__VA_ARGS__)



BENCHMARK_CAPTURE(BM_homescreen, SkiaGLThreaded, RenderEngine::Threaded::YES,

                  RenderEngine::GraphicsApi::GL);

namespace renderenginebench {



#if COM_ANDROID_GRAPHICS_LIBGUI_FLAGS_EDGE_EXTENSION_SHADER

BENCHMARK_CAPTURE(BM_homescreen_edgeExtension, SkiaGLThreaded, RenderEngine::Threaded::YES,

                  RenderEngine::GraphicsApi::GL);

void registerBenchmarks() {

    RenderEngineCreationArgs::Builder argBuilder =

            RenderEngineCreationArgs::Builder()

                    .setPixelFormat(static_cast<int>(ui::PixelFormat::RGBA_8888))

                    .setImageCacheSize(1)

                    .setEnableProtectedContext(true)

                    .setPrecacheToneMapperShaderOnly(false)

                    .setContextPriority(RenderEngine::ContextPriority::Realtime)

                    .setThreaded(RenderEngine::Threaded::Yes);



    for (RenderEngine::GraphicsApi graphicsApi :

         {RenderEngine::GraphicsApi::GL, RenderEngine::GraphicsApi::Vk}) {

        argBuilder.setGraphicsApi(graphicsApi);



// TODO: b/341728634 - Clean up conditional compilation.

#if COMPILE_GRAPHITE_RENDERENGINE

        const auto skiaBackends = {RenderEngine::SkiaBackend::Ganesh,

                                   RenderEngine::SkiaBackend::Graphite};

#else

        const auto skiaBackends = {RenderEngine::SkiaBackend::Ganesh};

#endif

        for (RenderEngine::SkiaBackend skiaBackend : skiaBackends) {

            argBuilder.setSkiaBackend(skiaBackend);



            // BM_homescreen_blur

            for (RenderEngine::BlurAlgorithm blurAlgorithm :

                 {RenderEngine::BlurAlgorithm::Gaussian, RenderEngine::BlurAlgorithm::Kawase,

                  RenderEngine::BlurAlgorithm::KawaseDualFilter}) {

                argBuilder.setBlurAlgorithm(blurAlgorithm);

                REGISTER_BM_IF_VALID(BM_homescreen_blur, argBuilder.build());

            }

            argBuilder.setBlurAlgorithm(RenderEngine::BlurAlgorithm::None);



            // BM_homescreen

            REGISTER_BM_IF_VALID(BM_homescreen, argBuilder.build());



            // BM_homescreen_edgeExtension

            REGISTER_BM_IF_VALID(BM_homescreen_edgeExtension, argBuilder.build());

        }

    }

}



} // namespace renderenginebench

libs/renderengine/benchmark/RenderEngineBench.h

+5 −0
Original line number Diff line number Diff line
@@ -35,6 +35,11 @@ void parseFlags(int argc, char** argv); 
 */

void parseFlagsForHelp(int argc, char** argv);



/**

 * Register generated benchmark combinations with the benchmark runner.

 */

void registerBenchmarks();



/**

 * Whether to save the drawing result to a file.

 *

libs/renderengine/benchmark/main.cpp

+1 −0
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ int main(int argc, char** argv) { 
    // Initialize will exit if it sees '--help', so check for it and print info

    // about our flags first.

    renderenginebench::parseFlagsForHelp(argc, argv);

    renderenginebench::registerBenchmarks();

    benchmark::Initialize(&argc, argv);



    // Calling this separately from parseFlagsForHelp prevents collisions with

libs/renderengine/include/renderengine/RenderEngine.h

+34 −21
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 
#define SF_RENDERENGINE_H_



#include <android-base/unique_fd.h>

#include <ftl/enum.h>

#include <ftl/future.h>

#include <math/mat4.h>

#include <renderengine/DisplaySettings.h>
@@ -92,8 +93,10 @@ class ExternalTexture; 
}



enum class Protection {

    UNPROTECTED = 1,

    PROTECTED = 2,

    Unprotected,

    Protected,



    ftl_last = Protected

};



// Toggles for skipping or enabling priming of particular shaders.
@@ -115,32 +118,42 @@ struct PrimeCacheConfig { 
class RenderEngine {

public:

    enum class ContextPriority {

        LOW = 1,

        MEDIUM = 2,

        HIGH = 3,

        REALTIME = 4,

        Low,

        Medium,

        High,

        Realtime,



        ftl_last = Realtime

    };



    enum class Threaded {

        NO,

        YES,

        No,

        Yes,



        ftl_last = Yes

    };



    enum class GraphicsApi {

        GL,

        VK,

        Vk,



        ftl_last = Vk

    };



    enum class SkiaBackend {

        GANESH,

        GRAPHITE,

        Ganesh,

        Graphite,



        ftl_last = Graphite

    };



    enum class BlurAlgorithm {

        NONE,

        GAUSSIAN,

        KAWASE,

        KAWASE_DUAL_FILTER,

        None,

        Gaussian,

        Kawase,

        KawaseDualFilter,



        ftl_last = KawaseDualFilter

    };



    static std::unique_ptr<RenderEngine> create(const RenderEngineCreationArgs& args);
@@ -253,7 +266,7 @@ public: 


    // TODO(b/180767535): This is only implemented to allow for backend-specific behavior, which

    // we should not allow in general, so remove this.

    bool isThreaded() const { return mThreaded == Threaded::YES; }

    bool isThreaded() const { return mThreaded == Threaded::Yes; }



    static void validateInputBufferUsage(const sp<GraphicBuffer>&);

    static void validateOutputBufferUsage(const sp<GraphicBuffer>&);
@@ -265,7 +278,7 @@ public: 
    virtual void setEnableTracing(bool /*tracingEnabled*/) {}



protected:

    RenderEngine() : RenderEngine(Threaded::NO) {}

    RenderEngine() : RenderEngine(Threaded::No) {}



    RenderEngine(Threaded threaded) : mThreaded(threaded) {}
@@ -408,11 +421,11 @@ private: 
    uint32_t imageCacheSize = 0;

    bool enableProtectedContext = false;

    bool precacheToneMapperShaderOnly = false;

    RenderEngine::BlurAlgorithm blurAlgorithm = RenderEngine::BlurAlgorithm::NONE;

    RenderEngine::ContextPriority contextPriority = RenderEngine::ContextPriority::MEDIUM;

    RenderEngine::Threaded threaded = RenderEngine::Threaded::YES;

    RenderEngine::BlurAlgorithm blurAlgorithm = RenderEngine::BlurAlgorithm::None;

    RenderEngine::ContextPriority contextPriority = RenderEngine::ContextPriority::Medium;

    RenderEngine::Threaded threaded = RenderEngine::Threaded::Yes;

    RenderEngine::GraphicsApi graphicsApi = RenderEngine::GraphicsApi::GL;

    RenderEngine::SkiaBackend skiaBackend = RenderEngine::SkiaBackend::GANESH;

    RenderEngine::SkiaBackend skiaBackend = RenderEngine::SkiaBackend::Ganesh;

};



} // namespace renderengine