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

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

Game Driver Metrics: make gpu stats info parcelable 

This change also rename the GpuStats*Atom to GpuStats*Info because we'd
like to make GpuStats generic to all the authorized recipients, but atom
is too specific to statsd.

Bug: 126560138
Test: adb shell dumpsys gpu --gpustats
Change-Id: Ie071277ae849a32607979d07aca7682febaf4368
parent 70435e9b

libs/graphicsenv/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -16,6 +16,7 @@ cc_library_shared { 
    name: "libgraphicsenv",



    srcs: [

        "GpuStatsInfo.cpp",

        "GraphicsEnv.cpp",

        "IGpuService.cpp"

    ],

libs/graphicsenv/GpuStatsInfo.cpp

0 → 100644
+101 −0
Original line number Diff line number Diff line 
/*

 * Copyright 2019 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#include <inttypes.h>



#include <android-base/stringprintf.h>

#include <binder/Parcel.h>

#include <graphicsenv/GpuStatsInfo.h>



namespace android {



using base::StringAppendF;



status_t GpuStatsGlobalInfo::writeToParcel(Parcel* parcel) const {

    status_t status;

    if ((status = parcel->writeUtf8AsUtf16(driverPackageName)) != OK) return status;

    if ((status = parcel->writeUtf8AsUtf16(driverVersionName)) != OK) return status;

    if ((status = parcel->writeUint64(driverVersionCode)) != OK) return status;

    if ((status = parcel->writeInt64(driverBuildTime)) != OK) return status;

    if ((status = parcel->writeInt32(glLoadingCount)) != OK) return status;

    if ((status = parcel->writeInt32(glLoadingFailureCount)) != OK) return status;

    if ((status = parcel->writeInt32(vkLoadingCount)) != OK) return status;

    if ((status = parcel->writeInt32(vkLoadingFailureCount)) != OK) return status;

    return OK;

}



status_t GpuStatsGlobalInfo::readFromParcel(const Parcel* parcel) {

    status_t status;

    if ((status = parcel->readUtf8FromUtf16(&driverPackageName)) != OK) return status;

    if ((status = parcel->readUtf8FromUtf16(&driverVersionName)) != OK) return status;

    if ((status = parcel->readUint64(&driverVersionCode)) != OK) return status;

    if ((status = parcel->readInt64(&driverBuildTime)) != OK) return status;

    if ((status = parcel->readInt32(&glLoadingCount)) != OK) return status;

    if ((status = parcel->readInt32(&glLoadingFailureCount)) != OK) return status;

    if ((status = parcel->readInt32(&vkLoadingCount)) != OK) return status;

    if ((status = parcel->readInt32(&vkLoadingFailureCount)) != OK) return status;

    return OK;

}



std::string GpuStatsGlobalInfo::toString() const {

    std::string result;

    StringAppendF(&result, "driverPackageName = %s\n", driverPackageName.c_str());

    StringAppendF(&result, "driverVersionName = %s\n", driverVersionName.c_str());

    StringAppendF(&result, "driverVersionCode = %" PRIu64 "\n", driverVersionCode);

    StringAppendF(&result, "driverBuildTime = %" PRId64 "\n", driverBuildTime);

    StringAppendF(&result, "glLoadingCount = %d\n", glLoadingCount);

    StringAppendF(&result, "glLoadingFailureCount = %d\n", glLoadingFailureCount);

    StringAppendF(&result, "vkLoadingCount = %d\n", vkLoadingCount);

    StringAppendF(&result, "vkLoadingFailureCount = %d\n", vkLoadingFailureCount);

    return result;

}



status_t GpuStatsAppInfo::writeToParcel(Parcel* parcel) const {

    status_t status;

    if ((status = parcel->writeUtf8AsUtf16(appPackageName)) != OK) return status;

    if ((status = parcel->writeUint64(driverVersionCode)) != OK) return status;

    if ((status = parcel->writeInt64Vector(glDriverLoadingTime)) != OK) return status;

    if ((status = parcel->writeInt64Vector(vkDriverLoadingTime)) != OK) return status;

    return OK;

}



status_t GpuStatsAppInfo::readFromParcel(const Parcel* parcel) {

    status_t status;

    if ((status = parcel->readUtf8FromUtf16(&appPackageName)) != OK) return status;

    if ((status = parcel->readUint64(&driverVersionCode)) != OK) return status;

    if ((status = parcel->readInt64Vector(&glDriverLoadingTime)) != OK) return status;

    if ((status = parcel->readInt64Vector(&vkDriverLoadingTime)) != OK) return status;

    return OK;

}



std::string GpuStatsAppInfo::toString() const {

    std::string result;

    StringAppendF(&result, "appPackageName = %s\n", appPackageName.c_str());

    StringAppendF(&result, "driverVersionCode = %" PRIu64 "\n", driverVersionCode);

    result.append("glDriverLoadingTime:");

    for (int32_t loadingTime : glDriverLoadingTime) {

        StringAppendF(&result, " %d", loadingTime);

    }

    result.append("\n");

    result.append("vkDriverLoadingTime:");

    for (int32_t loadingTime : vkDriverLoadingTime) {

        StringAppendF(&result, " %d", loadingTime);

    }

    result.append("\n");

    return result;

}



} // namespace android

libs/graphicsenv/include/graphicsenv/GpuStatsAtoms.h→libs/graphicsenv/include/graphicsenv/GpuStatsInfo.h

+28 −2
Original line number Diff line number Diff line
@@ -19,9 +19,23 @@ 
#include <string>

#include <vector>



#include <binder/Parcelable.h>



namespace android {



struct GpuStatsGlobalAtom {

/*

 * class for transporting gpu global stats from GpuService to authorized

 * recipents. This class is intended to be a data container.

 */

class GpuStatsGlobalInfo : public Parcelable {

public:

    GpuStatsGlobalInfo() = default;

    GpuStatsGlobalInfo(const GpuStatsGlobalInfo&) = default;

    virtual ~GpuStatsGlobalInfo() = default;

    virtual status_t writeToParcel(Parcel* parcel) const;

    virtual status_t readFromParcel(const Parcel* parcel);

    std::string toString() const;



    std::string driverPackageName = "";

    std::string driverVersionName = "";

    uint64_t driverVersionCode = 0;
@@ -32,7 +46,19 @@ struct GpuStatsGlobalAtom { 
    int32_t vkLoadingFailureCount = 0;

};



struct GpuStatsAppAtom {

/*

 * class for transporting gpu app stats from GpuService to authorized recipents.

 * This class is intended to be a data container.

 */

class GpuStatsAppInfo : public Parcelable {

public:

    GpuStatsAppInfo() = default;

    GpuStatsAppInfo(const GpuStatsAppInfo&) = default;

    virtual ~GpuStatsAppInfo() = default;

    virtual status_t writeToParcel(Parcel* parcel) const;

    virtual status_t readFromParcel(const Parcel* parcel);

    std::string toString() const;



    std::string appPackageName = "";

    uint64_t driverVersionCode = 0;

    std::vector<int64_t> glDriverLoadingTime = {};

services/gpuservice/gpustats/GpuStats.cpp

+25 −51
Original line number Diff line number Diff line
@@ -19,28 +19,25 @@ 


#include "GpuStats.h"



#include <android-base/stringprintf.h>

#include <unordered_set>



#include <log/log.h>

#include <utils/Trace.h>



#include <unordered_set>



namespace android {



using base::StringAppendF;



static bool addLoadingCount(GraphicsEnv::Driver driver, bool isDriverLoaded,

                            GpuStatsGlobalAtom* const outGlobalAtom) {

                            GpuStatsGlobalInfo* const outGlobalInfo) {

    switch (driver) {

        case GraphicsEnv::Driver::GL:

        case GraphicsEnv::Driver::GL_UPDATED:

            outGlobalAtom->glLoadingCount++;

            if (!isDriverLoaded) outGlobalAtom->glLoadingFailureCount++;

            outGlobalInfo->glLoadingCount++;

            if (!isDriverLoaded) outGlobalInfo->glLoadingFailureCount++;

            break;

        case GraphicsEnv::Driver::VULKAN:

        case GraphicsEnv::Driver::VULKAN_UPDATED:

            outGlobalAtom->vkLoadingCount++;

            if (!isDriverLoaded) outGlobalAtom->vkLoadingFailureCount++;

            outGlobalInfo->vkLoadingCount++;

            if (!isDriverLoaded) outGlobalInfo->vkLoadingFailureCount++;

            break;

        default:

            // Currently we don't support GraphicsEnv::Driver::ANGLE because the
@@ -52,15 +49,15 @@ static bool addLoadingCount(GraphicsEnv::Driver driver, bool isDriverLoaded, 
}



static void addLoadingTime(GraphicsEnv::Driver driver, int64_t driverLoadingTime,

                           GpuStatsAppAtom* const outAppAtom) {

                           GpuStatsAppInfo* const outAppInfo) {

    switch (driver) {

        case GraphicsEnv::Driver::GL:

        case GraphicsEnv::Driver::GL_UPDATED:

            outAppAtom->glDriverLoadingTime.emplace_back(driverLoadingTime);

            outAppInfo->glDriverLoadingTime.emplace_back(driverLoadingTime);

            break;

        case GraphicsEnv::Driver::VULKAN:

        case GraphicsEnv::Driver::VULKAN_UPDATED:

            outAppAtom->vkDriverLoadingTime.emplace_back(driverLoadingTime);

            outAppInfo->vkDriverLoadingTime.emplace_back(driverLoadingTime);

            break;

        default:

            break;
@@ -87,31 +84,31 @@ void GpuStats::insert(const std::string& driverPackageName, const std::string& d 
          appPackageName.c_str(), static_cast<int32_t>(driver), isDriverLoaded, driverLoadingTime);



    if (!mGlobalStats.count(driverVersionCode)) {

        GpuStatsGlobalAtom globalAtom;

        if (!addLoadingCount(driver, isDriverLoaded, &globalAtom)) {

        GpuStatsGlobalInfo globalInfo;

        if (!addLoadingCount(driver, isDriverLoaded, &globalInfo)) {

            return;

        }

        globalAtom.driverPackageName = driverPackageName;

        globalAtom.driverVersionName = driverVersionName;

        globalAtom.driverVersionCode = driverVersionCode;

        globalAtom.driverBuildTime = driverBuildTime;

        mGlobalStats.insert({driverVersionCode, globalAtom});

        globalInfo.driverPackageName = driverPackageName;

        globalInfo.driverVersionName = driverVersionName;

        globalInfo.driverVersionCode = driverVersionCode;

        globalInfo.driverBuildTime = driverBuildTime;

        mGlobalStats.insert({driverVersionCode, globalInfo});

    } else if (!addLoadingCount(driver, isDriverLoaded, &mGlobalStats[driverVersionCode])) {

        return;

    }



    if (mAppStats.size() >= MAX_NUM_APP_RECORDS) {

        ALOGV("GpuStatsAppAtom has reached maximum size. Ignore new stats.");

        ALOGV("GpuStatsAppInfo has reached maximum size. Ignore new stats.");

        return;

    }



    const std::string appStatsKey = appPackageName + std::to_string(driverVersionCode);

    if (!mAppStats.count(appStatsKey)) {

        GpuStatsAppAtom appAtom;

        addLoadingTime(driver, driverLoadingTime, &appAtom);

        appAtom.appPackageName = appPackageName;

        appAtom.driverVersionCode = driverVersionCode;

        mAppStats.insert({appStatsKey, appAtom});

        GpuStatsAppInfo appInfo;

        addLoadingTime(driver, driverLoadingTime, &appInfo);

        appInfo.appPackageName = appPackageName;

        appInfo.driverVersionCode = driverVersionCode;

        mAppStats.insert({appStatsKey, appInfo});

        return;

    }
@@ -174,39 +171,16 @@ void GpuStats::dump(const Vector<String16>& args, std::string* result) { 
}



void GpuStats::dumpGlobalLocked(std::string* result) {

    result->append("GpuStats global:\n");



    for (const auto& ele : mGlobalStats) {

        StringAppendF(result, "  driverPackageName = %s\n", ele.second.driverPackageName.c_str());

        StringAppendF(result, "  driverVersionName = %s\n", ele.second.driverVersionName.c_str());

        StringAppendF(result, "  driverVersionCode = %" PRIu64 "\n", ele.second.driverVersionCode);

        StringAppendF(result, "  driverBuildTime = %" PRId64 "\n", ele.second.driverBuildTime);

        StringAppendF(result, "  glLoadingCount = %d\n", ele.second.glLoadingCount);

        StringAppendF(result, "  glLoadingFailureCount = %d\n", ele.second.glLoadingFailureCount);

        StringAppendF(result, "  vkLoadingCount = %d\n", ele.second.vkLoadingCount);

        StringAppendF(result, "  vkLoadingFailureCount = %d\n", ele.second.vkLoadingFailureCount);

        result->append(ele.second.toString());

        result->append("\n");

    }

}



void GpuStats::dumpAppLocked(std::string* result) {

    result->append("GpuStats app:\n");



    for (const auto& ele : mAppStats) {

        StringAppendF(result, "  appPackageName = %s\n", ele.second.appPackageName.c_str());

        StringAppendF(result, "  driverVersionCode = %" PRIu64 "\n", ele.second.driverVersionCode);



        result->append("  glDriverLoadingTime:");

        for (int32_t loadingTime : ele.second.glDriverLoadingTime) {

            StringAppendF(result, " %d", loadingTime);

        }

        result->append(ele.second.toString());

        result->append("\n");



        result->append("  vkDriverLoadingTime:");

        for (int32_t loadingTime : ele.second.vkDriverLoadingTime) {

            StringAppendF(result, " %d", loadingTime);

        }

        result->append("\n\n");

    }

}

services/gpuservice/gpustats/GpuStats.h

+3 −3
Original line number Diff line number Diff line
@@ -20,7 +20,7 @@ 
#include <unordered_map>

#include <vector>



#include <graphicsenv/GpuStatsAtoms.h>

#include <graphicsenv/GpuStatsInfo.h>

#include <graphicsenv/GraphicsEnv.h>

#include <utils/String16.h>

#include <utils/Vector.h>
@@ -52,9 +52,9 @@ private: 
    // GpuStats access should be guarded by mLock.

    std::mutex mLock;

    // Key is driver version code.

    std::unordered_map<uint64_t, GpuStatsGlobalAtom> mGlobalStats;

    std::unordered_map<uint64_t, GpuStatsGlobalInfo> mGlobalStats;

    // Key is <app package name>+<driver version code>.

    std::unordered_map<std::string, GpuStatsAppAtom> mAppStats;

    std::unordered_map<std::string, GpuStatsAppInfo> mAppStats;

};



} // namespace android