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

Commit 27ab3ac6 authored by Yiwei Zhang's avatar Yiwei Zhang
Browse files

GpuStats: move GpuStats related structs and enums away from GraphicsEnv 

Bug: 135210726
Test: build, flash and boot
Test: adb shell dumpsys gpu
Change-Id: I48c5c432aca916f923ab5674f8ec533d4f5aac0f
parent 466748f4

libs/graphicsenv/GraphicsEnv.cpp

+19 −19
Original line number Diff line number Diff line
@@ -170,11 +170,11 @@ void GraphicsEnv::hintActivityLaunch() { 
        std::lock_guard<std::mutex> lock(mStatsLock);

        if (mGpuStats.glDriverToSend) {

            mGpuStats.glDriverToSend = false;

            sendGpuStatsLocked(GraphicsEnv::Api::API_GL, true, mGpuStats.glDriverLoadingTime);

            sendGpuStatsLocked(GpuStatsInfo::Api::API_GL, true, mGpuStats.glDriverLoadingTime);

        }

        if (mGpuStats.vkDriverToSend) {

            mGpuStats.vkDriverToSend = false;

            sendGpuStatsLocked(GraphicsEnv::Api::API_VK, true, mGpuStats.vkDriverLoadingTime);

            sendGpuStatsLocked(GpuStatsInfo::Api::API_VK, true, mGpuStats.vkDriverLoadingTime);

        }

    });

    trySendGpuStatsThread.detach();
@@ -205,32 +205,32 @@ void GraphicsEnv::setGpuStats(const std::string& driverPackageName, 
    mGpuStats.vulkanVersion = vulkanVersion;

}



void GraphicsEnv::setDriverToLoad(GraphicsEnv::Driver driver) {

void GraphicsEnv::setDriverToLoad(GpuStatsInfo::Driver driver) {

    ATRACE_CALL();



    std::lock_guard<std::mutex> lock(mStatsLock);

    switch (driver) {

        case GraphicsEnv::Driver::GL:

        case GraphicsEnv::Driver::GL_UPDATED:

        case GraphicsEnv::Driver::ANGLE: {

            if (mGpuStats.glDriverToLoad == GraphicsEnv::Driver::NONE) {

        case GpuStatsInfo::Driver::GL:

        case GpuStatsInfo::Driver::GL_UPDATED:

        case GpuStatsInfo::Driver::ANGLE: {

            if (mGpuStats.glDriverToLoad == GpuStatsInfo::Driver::NONE) {

                mGpuStats.glDriverToLoad = driver;

                break;

            }



            if (mGpuStats.glDriverFallback == GraphicsEnv::Driver::NONE) {

            if (mGpuStats.glDriverFallback == GpuStatsInfo::Driver::NONE) {

                mGpuStats.glDriverFallback = driver;

            }

            break;

        }

        case Driver::VULKAN:

        case Driver::VULKAN_UPDATED: {

            if (mGpuStats.vkDriverToLoad == GraphicsEnv::Driver::NONE) {

        case GpuStatsInfo::Driver::VULKAN:

        case GpuStatsInfo::Driver::VULKAN_UPDATED: {

            if (mGpuStats.vkDriverToLoad == GpuStatsInfo::Driver::NONE) {

                mGpuStats.vkDriverToLoad = driver;

                break;

            }



            if (mGpuStats.vkDriverFallback == GraphicsEnv::Driver::NONE) {

            if (mGpuStats.vkDriverFallback == GpuStatsInfo::Driver::NONE) {

                mGpuStats.vkDriverFallback = driver;

            }

            break;
@@ -240,13 +240,13 @@ void GraphicsEnv::setDriverToLoad(GraphicsEnv::Driver driver) { 
    }

}



void GraphicsEnv::setDriverLoaded(GraphicsEnv::Api api, bool isDriverLoaded,

void GraphicsEnv::setDriverLoaded(GpuStatsInfo::Api api, bool isDriverLoaded,

                                  int64_t driverLoadingTime) {

    ATRACE_CALL();



    std::lock_guard<std::mutex> lock(mStatsLock);

    const bool doNotSend = mGpuStats.appPackageName.empty();

    if (api == GraphicsEnv::Api::API_GL) {

    if (api == GpuStatsInfo::Api::API_GL) {

        if (doNotSend) mGpuStats.glDriverToSend = true;

        mGpuStats.glDriverLoadingTime = driverLoadingTime;

    } else {
@@ -278,7 +278,7 @@ void GraphicsEnv::setCpuVulkanInUse() { 
    }

}



void GraphicsEnv::sendGpuStatsLocked(GraphicsEnv::Api api, bool isDriverLoaded,

void GraphicsEnv::sendGpuStatsLocked(GpuStatsInfo::Api api, bool isDriverLoaded,

                                     int64_t driverLoadingTime) {

    ATRACE_CALL();
@@ -299,16 +299,16 @@ void GraphicsEnv::sendGpuStatsLocked(GraphicsEnv::Api api, bool isDriverLoaded, 
          mGpuStats.driverVersionCode, mGpuStats.driverBuildTime, mGpuStats.appPackageName.c_str(),

          mGpuStats.vulkanVersion, static_cast<int32_t>(api), isDriverLoaded, driverLoadingTime);



    GraphicsEnv::Driver driver = GraphicsEnv::Driver::NONE;

    GpuStatsInfo::Driver driver = GpuStatsInfo::Driver::NONE;

    bool isIntendedDriverLoaded = false;

    if (api == GraphicsEnv::Api::API_GL) {

    if (api == GpuStatsInfo::Api::API_GL) {

        driver = mGpuStats.glDriverToLoad;

        isIntendedDriverLoaded =

                isDriverLoaded && (mGpuStats.glDriverFallback == GraphicsEnv::Driver::NONE);

                isDriverLoaded && (mGpuStats.glDriverFallback == GpuStatsInfo::Driver::NONE);

    } else {

        driver = mGpuStats.vkDriverToLoad;

        isIntendedDriverLoaded =

                isDriverLoaded && (mGpuStats.vkDriverFallback == GraphicsEnv::Driver::NONE);

                isDriverLoaded && (mGpuStats.vkDriverFallback == GpuStatsInfo::Driver::NONE);

    }



    const sp<IGpuService> gpuService = getGpuService();

libs/graphicsenv/IGpuService.cpp

+2 −2
Original line number Diff line number Diff line
@@ -30,7 +30,7 @@ public: 
    virtual void setGpuStats(const std::string& driverPackageName,

                             const std::string& driverVersionName, uint64_t driverVersionCode,

                             int64_t driverBuildTime, const std::string& appPackageName,

                             const int32_t vulkanVersion, GraphicsEnv::Driver driver,

                             const int32_t vulkanVersion, GpuStatsInfo::Driver driver,

                             bool isDriverLoaded, int64_t driverLoadingTime) {

        Parcel data, reply;

        data.writeInterfaceToken(IGpuService::getInterfaceDescriptor());
@@ -143,7 +143,7 @@ status_t BnGpuService::onTransact(uint32_t code, const Parcel& data, Parcel* rep 
            if ((status = data.readInt64(&driverLoadingTime)) != OK) return status;



            setGpuStats(driverPackageName, driverVersionName, driverVersionCode, driverBuildTime,

                        appPackageName, vulkanVersion, static_cast<GraphicsEnv::Driver>(driver),

                        appPackageName, vulkanVersion, static_cast<GpuStatsInfo::Driver>(driver),

                        isDriverLoaded, driverLoadingTime);



            return OK;

libs/graphicsenv/include/graphicsenv/GpuStatsInfo.h

+39 −0
Original line number Diff line number Diff line
@@ -72,4 +72,43 @@ public: 
    bool cpuVulkanInUse = false;

};



/*

 * class for holding the gpu stats in GraphicsEnv before sending to GpuService.

 */

class GpuStatsInfo {

public:

    enum Api {

        API_GL = 0,

        API_VK = 1,

    };



    enum Driver {

        NONE = 0,

        GL = 1,

        GL_UPDATED = 2,

        VULKAN = 3,

        VULKAN_UPDATED = 4,

        ANGLE = 5,

    };



    GpuStatsInfo() = default;

    GpuStatsInfo(const GpuStatsInfo&) = default;

    virtual ~GpuStatsInfo() = default;



    std::string driverPackageName = "";

    std::string driverVersionName = "";

    uint64_t driverVersionCode = 0;

    int64_t driverBuildTime = 0;

    std::string appPackageName = "";

    int32_t vulkanVersion = 0;

    Driver glDriverToLoad = Driver::NONE;

    Driver glDriverFallback = Driver::NONE;

    Driver vkDriverToLoad = Driver::NONE;

    Driver vkDriverFallback = Driver::NONE;

    bool glDriverToSend = false;

    bool vkDriverToSend = false;

    int64_t glDriverLoadingTime = 0;

    int64_t vkDriverLoadingTime = 0;

};



} // namespace android

libs/graphicsenv/include/graphicsenv/GraphicsEnv.h

+6 −53
Original line number Diff line number Diff line
@@ -17,6 +17,8 @@ 
#ifndef ANDROID_UI_GRAPHICS_ENV_H

#define ANDROID_UI_GRAPHICS_ENV_H 1



#include <graphicsenv/GpuStatsInfo.h>



#include <mutex>

#include <string>

#include <vector>
@@ -28,55 +30,6 @@ namespace android { 
struct NativeLoaderNamespace;



class GraphicsEnv {

public:

    enum Api {

        API_GL = 0,

        API_VK = 1,

    };



    enum Driver {

        NONE = 0,

        GL = 1,

        GL_UPDATED = 2,

        VULKAN = 3,

        VULKAN_UPDATED = 4,

        ANGLE = 5,

    };



private:

    struct GpuStats {

        std::string driverPackageName;

        std::string driverVersionName;

        uint64_t driverVersionCode;

        int64_t driverBuildTime;

        std::string appPackageName;

        int32_t vulkanVersion;

        Driver glDriverToLoad;

        Driver glDriverFallback;

        Driver vkDriverToLoad;

        Driver vkDriverFallback;

        bool glDriverToSend;

        bool vkDriverToSend;

        int64_t glDriverLoadingTime;

        int64_t vkDriverLoadingTime;



        GpuStats()

              : driverPackageName(""),

                driverVersionName(""),

                driverVersionCode(0),

                driverBuildTime(0),

                appPackageName(""),

                vulkanVersion(0),

                glDriverToLoad(Driver::NONE),

                glDriverFallback(Driver::NONE),

                vkDriverToLoad(Driver::NONE),

                vkDriverFallback(Driver::NONE),

                glDriverToSend(false),

                vkDriverToSend(false),

                glDriverLoadingTime(0),

                vkDriverLoadingTime(0) {}

    };



public:

    static GraphicsEnv& getInstance();
@@ -97,9 +50,9 @@ public: 
                     uint64_t versionCode, int64_t driverBuildTime,

                     const std::string& appPackageName, const int32_t vulkanVersion);

    void setCpuVulkanInUse();

    void setDriverToLoad(Driver driver);

    void setDriverLoaded(Api api, bool isDriverLoaded, int64_t driverLoadingTime);

    void sendGpuStatsLocked(Api api, bool isDriverLoaded, int64_t driverLoadingTime);

    void setDriverToLoad(GpuStatsInfo::Driver driver);

    void setDriverLoaded(GpuStatsInfo::Api api, bool isDriverLoaded, int64_t driverLoadingTime);

    void sendGpuStatsLocked(GpuStatsInfo::Api api, bool isDriverLoaded, int64_t driverLoadingTime);



    bool shouldUseAngle(std::string appName);

    bool shouldUseAngle();
@@ -135,7 +88,7 @@ private: 
    std::string mDriverPath;

    std::string mSphalLibraries;

    std::mutex mStatsLock;

    GpuStats mGpuStats;

    GpuStatsInfo mGpuStats;

    std::string mAnglePath;

    std::string mAngleAppName;

    std::string mAngleDeveloperOptIn;

libs/graphicsenv/include/graphicsenv/IGpuService.h

+1 −1
Original line number Diff line number Diff line
@@ -37,7 +37,7 @@ public: 
    virtual void setGpuStats(const std::string& driverPackageName,

                             const std::string& driverVersionName, uint64_t driverVersionCode,

                             int64_t driverBuildTime, const std::string& appPackageName,

                             const int32_t vulkanVersion, GraphicsEnv::Driver driver,

                             const int32_t vulkanVersion, GpuStatsInfo::Driver driver,

                             bool isDriverLoaded, int64_t driverLoadingTime) = 0;



    // set CPU Vulkan in use signal from GraphicsEnvironment.