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

Commit b59a127b authored by Yiwei Zhang's avatar Yiwei Zhang
Browse files

GpuStats: migrate to new statsd native puller api (part 2) 

This change migrates the global atom puller over to the new api.

Bug: 148421389
Test: atest gpuservice_unittest
Test: statsd_testdrive 10054
Change-Id: If57199b266a3f4436a53712f8deec9ad75bfda41
parent 6ee546d8

services/gpuservice/gpustats/Android.bp

+7 −0
Original line number Diff line number Diff line
@@ -7,9 +7,16 @@ cc_library_shared { 
        "libcutils",

        "libgraphicsenv",

        "liblog",

        "libstatslog",

        "libstatspull",

        "libstatssocket",

        "libutils",

    ],

    export_include_dirs: ["include"],

    export_shared_lib_headers: [

        "libstatspull",

        "libstatssocket",

    ],

    cppflags: [

        "-Wall",

        "-Werror",

services/gpuservice/gpustats/GpuStats.cpp

+57 −0
Original line number Diff line number Diff line
@@ -21,12 +21,23 @@ 


#include <cutils/properties.h>

#include <log/log.h>

#include <stats_event.h>

#include <statslog.h>

#include <utils/Trace.h>



#include <unordered_set>



namespace android {



GpuStats::GpuStats() {

    AStatsManager_registerPullAtomCallback(android::util::GPU_STATS_GLOBAL_INFO,

                                           GpuStats::pullAtomCallback, nullptr, this);

}



GpuStats::~GpuStats() {

    AStatsManager_unregisterPullAtomCallback(android::util::GPU_STATS_GLOBAL_INFO);

}



static void addLoadingCount(GpuStatsInfo::Driver driver, bool isDriverLoaded,

                            GpuStatsGlobalInfo* const outGlobalInfo) {

    switch (driver) {
@@ -233,4 +244,50 @@ void GpuStats::dumpAppLocked(std::string* result) { 
    }

}



AStatsManager_PullAtomCallbackReturn GpuStats::pullGlobalInfoAtom(AStatsEventList* data) {

    ATRACE_CALL();



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

    // flush cpuVulkanVersion and glesVersion to builtin driver stats

    interceptSystemDriverStatsLocked();



    if (data) {

        for (const auto& ele : mGlobalStats) {

            AStatsEvent* event = AStatsEventList_addStatsEvent(data);

            AStatsEvent_setAtomId(event, android::util::GPU_STATS_GLOBAL_INFO);

            AStatsEvent_writeString(event, ele.second.driverPackageName.c_str());

            AStatsEvent_writeString(event, ele.second.driverVersionName.c_str());

            AStatsEvent_writeInt64(event, ele.second.driverVersionCode);

            AStatsEvent_writeInt64(event, ele.second.driverBuildTime);

            AStatsEvent_writeInt64(event, ele.second.glLoadingCount);

            AStatsEvent_writeInt64(event, ele.second.glLoadingFailureCount);

            AStatsEvent_writeInt64(event, ele.second.vkLoadingCount);

            AStatsEvent_writeInt64(event, ele.second.vkLoadingFailureCount);

            AStatsEvent_writeInt32(event, ele.second.vulkanVersion);

            AStatsEvent_writeInt32(event, ele.second.cpuVulkanVersion);

            AStatsEvent_writeInt32(event, ele.second.glesVersion);

            AStatsEvent_writeInt64(event, ele.second.angleLoadingCount);

            AStatsEvent_writeInt64(event, ele.second.angleLoadingFailureCount);

            AStatsEvent_build(event);

        }

    }



    mGlobalStats.clear();



    return AStatsManager_PULL_SUCCESS;

}



AStatsManager_PullAtomCallbackReturn GpuStats::pullAtomCallback(int32_t atomTag,

                                                                AStatsEventList* data,

                                                                void* cookie) {

    ATRACE_CALL();



    GpuStats* pGpuStats = reinterpret_cast<GpuStats*>(cookie);

    if (atomTag == android::util::GPU_STATS_GLOBAL_INFO) {

        return pGpuStats->pullGlobalInfoAtom(data);

    }



    return AStatsManager_PULL_SKIP;

}



} // namespace android

services/gpuservice/gpustats/include/gpustats/GpuStats.h

+12 −2
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ 


#include <graphicsenv/GpuStatsInfo.h>

#include <graphicsenv/GraphicsEnv.h>

#include <stats_pull_atom_callback.h>

#include <utils/String16.h>

#include <utils/Vector.h>
@@ -29,8 +30,8 @@ namespace android { 


class GpuStats {

public:

    GpuStats() = default;

    ~GpuStats() = default;

    GpuStats();

    ~GpuStats();



    // Insert new gpu driver stats into global stats and app stats.

    void insertDriverStats(const std::string& driverPackageName,
@@ -48,6 +49,15 @@ public: 
    static const size_t MAX_NUM_LOADING_TIMES = 50;



private:

    // Friend class for testing.

    friend class TestableGpuStats;



    // Native atom puller callback registered in statsd.

    static AStatsManager_PullAtomCallbackReturn pullAtomCallback(int32_t atomTag,

                                                                 AStatsEventList* data,

                                                                 void* cookie);

    // Pull global into into global atom.

    AStatsManager_PullAtomCallbackReturn pullGlobalInfoAtom(AStatsEventList* data);

    // Dump global stats

    void dumpGlobalLocked(std::string* result);

    // Dump app stats

services/gpuservice/tests/unittests/Android.bp

+2 −0
Original line number Diff line number Diff line
@@ -26,6 +26,8 @@ cc_test { 
        "libgfxstats",

        "libgraphicsenv",

        "liblog",

        "libstatslog",

        "libstatspull",

        "libutils",

    ],

    static_libs: [

services/gpuservice/tests/unittests/GpuStatsTest.cpp

+37 −0
Original line number Diff line number Diff line
@@ -21,9 +21,13 @@ 
#include <gmock/gmock.h>

#include <gpustats/GpuStats.h>

#include <gtest/gtest.h>

#include <stats_pull_atom_callback.h>

#include <statslog.h>

#include <utils/String16.h>

#include <utils/Vector.h>



#include "TestableGpuStats.h"



namespace android {

namespace {
@@ -249,5 +253,38 @@ TEST_F(GpuStatsTest, canDumpAppBeforeClearApp) { 
    EXPECT_FALSE(inputCommand(InputCommand::DUMP_GLOBAL).empty());

}



TEST_F(GpuStatsTest, skipPullInvalidAtom) {

    TestableGpuStats testableGpuStats(mGpuStats.get());

    mGpuStats->insertDriverStats(BUILTIN_DRIVER_PKG_NAME, BUILTIN_DRIVER_VER_NAME,

                                 BUILTIN_DRIVER_VER_CODE, BUILTIN_DRIVER_BUILD_TIME, APP_PKG_NAME_1,

                                 VULKAN_VERSION, GpuStatsInfo::Driver::GL, true,

                                 DRIVER_LOADING_TIME_1);



    EXPECT_FALSE(inputCommand(InputCommand::DUMP_GLOBAL).empty());

    EXPECT_FALSE(inputCommand(InputCommand::DUMP_APP).empty());



    EXPECT_TRUE(testableGpuStats.makePullAtomCallback(-1) == AStatsManager_PULL_SKIP);



    EXPECT_FALSE(inputCommand(InputCommand::DUMP_GLOBAL).empty());

    EXPECT_FALSE(inputCommand(InputCommand::DUMP_APP).empty());

}



TEST_F(GpuStatsTest, canPullGlobalAtom) {

    TestableGpuStats testableGpuStats(mGpuStats.get());

    mGpuStats->insertDriverStats(BUILTIN_DRIVER_PKG_NAME, BUILTIN_DRIVER_VER_NAME,

                                 BUILTIN_DRIVER_VER_CODE, BUILTIN_DRIVER_BUILD_TIME, APP_PKG_NAME_1,

                                 VULKAN_VERSION, GpuStatsInfo::Driver::GL, true,

                                 DRIVER_LOADING_TIME_1);



    EXPECT_FALSE(inputCommand(InputCommand::DUMP_GLOBAL).empty());

    EXPECT_FALSE(inputCommand(InputCommand::DUMP_APP).empty());



    EXPECT_TRUE(testableGpuStats.makePullAtomCallback(android::util::GPU_STATS_GLOBAL_INFO) ==

                AStatsManager_PULL_SUCCESS);



    EXPECT_TRUE(inputCommand(InputCommand::DUMP_GLOBAL).empty());

    EXPECT_FALSE(inputCommand(InputCommand::DUMP_APP).empty());

}



} // namespace

} // namespace android