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

Commit 4e316e5a authored by Noelle Scobie's avatar Noelle Scobie
Browse files

Convert benchmark registration to be programmatic & add other RE backends 

This makes it easier to add more benchmark cases, while ensuring they
run across all of RenderEngine's backends (GaneshGL, GaneshVk,
GraphiteVk), or across other parameters.

Also remove the obsolete flag guard that was disabling
BM_homescreen_edgeExtension

Bug: b/425760461
Test: atest librenderengine_bench
Flag: EXEMPT b/c test only, but GraphiteVk is guarded by compile flags
Change-Id: I576e017999910a95f332930bd934df42f24da7cf
parent d450a7f2

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::KawaseDualFilter);

#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