| /* |
| * 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. |
| */ |
| #undef LOG_TAG |
| #define LOG_TAG "GpuStats" |
| #define ATRACE_TAG ATRACE_TAG_GRAPHICS |
| |
| #include "gpustats/GpuStats.h" |
| |
| #include <android/util/ProtoOutputStream.h> |
| #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() { |
| if (mStatsdRegistered) { |
| AStatsManager_clearPullAtomCallback(android::util::GPU_STATS_GLOBAL_INFO); |
| AStatsManager_clearPullAtomCallback(android::util::GPU_STATS_APP_INFO); |
| } |
| } |
| |
| static void addLoadingCount(GpuStatsInfo::Driver driver, bool isDriverLoaded, |
| GpuStatsGlobalInfo* const outGlobalInfo) { |
| switch (driver) { |
| case GpuStatsInfo::Driver::GL: |
| case GpuStatsInfo::Driver::GL_UPDATED: |
| outGlobalInfo->glLoadingCount++; |
| if (!isDriverLoaded) outGlobalInfo->glLoadingFailureCount++; |
| break; |
| case GpuStatsInfo::Driver::VULKAN: |
| case GpuStatsInfo::Driver::VULKAN_UPDATED: |
| outGlobalInfo->vkLoadingCount++; |
| if (!isDriverLoaded) outGlobalInfo->vkLoadingFailureCount++; |
| break; |
| case GpuStatsInfo::Driver::ANGLE: |
| outGlobalInfo->angleLoadingCount++; |
| if (!isDriverLoaded) outGlobalInfo->angleLoadingFailureCount++; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void addLoadingTime(GpuStatsInfo::Driver driver, int64_t driverLoadingTime, |
| GpuStatsAppInfo* const outAppInfo) { |
| switch (driver) { |
| case GpuStatsInfo::Driver::GL: |
| case GpuStatsInfo::Driver::GL_UPDATED: |
| if (outAppInfo->glDriverLoadingTime.size() < GpuStats::MAX_NUM_LOADING_TIMES) { |
| outAppInfo->glDriverLoadingTime.emplace_back(driverLoadingTime); |
| } |
| break; |
| case GpuStatsInfo::Driver::VULKAN: |
| case GpuStatsInfo::Driver::VULKAN_UPDATED: |
| if (outAppInfo->vkDriverLoadingTime.size() < GpuStats::MAX_NUM_LOADING_TIMES) { |
| outAppInfo->vkDriverLoadingTime.emplace_back(driverLoadingTime); |
| } |
| break; |
| case GpuStatsInfo::Driver::ANGLE: |
| if (outAppInfo->angleDriverLoadingTime.size() < GpuStats::MAX_NUM_LOADING_TIMES) { |
| outAppInfo->angleDriverLoadingTime.emplace_back(driverLoadingTime); |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| |
| void GpuStats::insertDriverStats(const std::string& driverPackageName, |
| const std::string& driverVersionName, uint64_t driverVersionCode, |
| int64_t driverBuildTime, const std::string& appPackageName, |
| const int32_t vulkanVersion, GpuStatsInfo::Driver driver, |
| bool isDriverLoaded, int64_t driverLoadingTime) { |
| ATRACE_CALL(); |
| |
| std::lock_guard<std::mutex> lock(mLock); |
| registerStatsdCallbacksIfNeeded(); |
| ALOGV("Received:\n" |
| "\tdriverPackageName[%s]\n" |
| "\tdriverVersionName[%s]\n" |
| "\tdriverVersionCode[%" PRIu64 "]\n" |
| "\tdriverBuildTime[%" PRId64 "]\n" |
| "\tappPackageName[%s]\n" |
| "\tvulkanVersion[%d]\n" |
| "\tdriver[%d]\n" |
| "\tisDriverLoaded[%d]\n" |
| "\tdriverLoadingTime[%" PRId64 "]", |
| driverPackageName.c_str(), driverVersionName.c_str(), driverVersionCode, driverBuildTime, |
| appPackageName.c_str(), vulkanVersion, static_cast<int32_t>(driver), isDriverLoaded, |
| driverLoadingTime); |
| |
| if (!mGlobalStats.count(driverVersionCode)) { |
| GpuStatsGlobalInfo globalInfo; |
| addLoadingCount(driver, isDriverLoaded, &globalInfo); |
| globalInfo.driverPackageName = driverPackageName; |
| globalInfo.driverVersionName = driverVersionName; |
| globalInfo.driverVersionCode = driverVersionCode; |
| globalInfo.driverBuildTime = driverBuildTime; |
| globalInfo.vulkanVersion = vulkanVersion; |
| mGlobalStats.insert({driverVersionCode, globalInfo}); |
| } else { |
| addLoadingCount(driver, isDriverLoaded, &mGlobalStats[driverVersionCode]); |
| } |
| |
| const std::string appStatsKey = appPackageName + std::to_string(driverVersionCode); |
| if (!mAppStats.count(appStatsKey)) { |
| if (mAppStats.size() >= MAX_NUM_APP_RECORDS) { |
| ALOGV("GpuStatsAppInfo has reached maximum size. Ignore new stats."); |
| return; |
| } |
| |
| GpuStatsAppInfo appInfo; |
| addLoadingTime(driver, driverLoadingTime, &appInfo); |
| appInfo.appPackageName = appPackageName; |
| appInfo.driverVersionCode = driverVersionCode; |
| mAppStats.insert({appStatsKey, appInfo}); |
| return; |
| } |
| |
| addLoadingTime(driver, driverLoadingTime, &mAppStats[appStatsKey]); |
| } |
| |
| void GpuStats::insertTargetStats(const std::string& appPackageName, |
| const uint64_t driverVersionCode, const GpuStatsInfo::Stats stats, |
| const uint64_t /*value*/) { |
| ATRACE_CALL(); |
| |
| const std::string appStatsKey = appPackageName + std::to_string(driverVersionCode); |
| |
| std::lock_guard<std::mutex> lock(mLock); |
| registerStatsdCallbacksIfNeeded(); |
| if (!mAppStats.count(appStatsKey)) { |
| return; |
| } |
| |
| switch (stats) { |
| case GpuStatsInfo::Stats::CPU_VULKAN_IN_USE: |
| mAppStats[appStatsKey].cpuVulkanInUse = true; |
| break; |
| case GpuStatsInfo::Stats::FALSE_PREROTATION: |
| mAppStats[appStatsKey].falsePrerotation = true; |
| break; |
| case GpuStatsInfo::Stats::GLES_1_IN_USE: |
| mAppStats[appStatsKey].gles1InUse = true; |
| break; |
| default: |
| break; |
| } |
| } |
| |
| void GpuStats::interceptSystemDriverStatsLocked() { |
| // Append cpuVulkanVersion and glesVersion to system driver stats |
| if (!mGlobalStats.count(0) || mGlobalStats[0].glesVersion) { |
| return; |
| } |
| |
| mGlobalStats[0].cpuVulkanVersion = property_get_int32("ro.cpuvulkan.version", 0); |
| mGlobalStats[0].glesVersion = property_get_int32("ro.opengles.version", 0); |
| } |
| |
| void GpuStats::registerStatsdCallbacksIfNeeded() { |
| if (!mStatsdRegistered) { |
| AStatsManager_setPullAtomCallback(android::util::GPU_STATS_GLOBAL_INFO, nullptr, |
| GpuStats::pullAtomCallback, this); |
| AStatsManager_setPullAtomCallback(android::util::GPU_STATS_APP_INFO, nullptr, |
| GpuStats::pullAtomCallback, this); |
| mStatsdRegistered = true; |
| } |
| } |
| |
| void GpuStats::dump(const Vector<String16>& args, std::string* result) { |
| ATRACE_CALL(); |
| |
| if (!result) { |
| ALOGE("Dump result shouldn't be nullptr."); |
| return; |
| } |
| |
| std::lock_guard<std::mutex> lock(mLock); |
| bool dumpAll = true; |
| |
| std::unordered_set<std::string> argsSet; |
| for (size_t i = 0; i < args.size(); i++) { |
| argsSet.insert(String8(args[i]).c_str()); |
| } |
| |
| const bool dumpGlobal = argsSet.count("--global") != 0; |
| if (dumpGlobal) { |
| dumpGlobalLocked(result); |
| dumpAll = false; |
| } |
| |
| const bool dumpApp = argsSet.count("--app") != 0; |
| if (dumpApp) { |
| dumpAppLocked(result); |
| dumpAll = false; |
| } |
| |
| if (dumpAll) { |
| dumpGlobalLocked(result); |
| dumpAppLocked(result); |
| } |
| |
| if (argsSet.count("--clear")) { |
| bool clearAll = true; |
| |
| if (dumpGlobal) { |
| mGlobalStats.clear(); |
| clearAll = false; |
| } |
| |
| if (dumpApp) { |
| mAppStats.clear(); |
| clearAll = false; |
| } |
| |
| if (clearAll) { |
| mGlobalStats.clear(); |
| mAppStats.clear(); |
| } |
| } |
| } |
| |
| void GpuStats::dumpGlobalLocked(std::string* result) { |
| interceptSystemDriverStatsLocked(); |
| |
| for (const auto& ele : mGlobalStats) { |
| result->append(ele.second.toString()); |
| result->append("\n"); |
| } |
| } |
| |
| void GpuStats::dumpAppLocked(std::string* result) { |
| for (const auto& ele : mAppStats) { |
| result->append(ele.second.toString()); |
| result->append("\n"); |
| } |
| } |
| |
| static std::string protoOutputStreamToByteString(android::util::ProtoOutputStream& proto) { |
| if (!proto.size()) return ""; |
| |
| std::string byteString; |
| sp<android::util::ProtoReader> reader = proto.data(); |
| while (reader->readBuffer() != nullptr) { |
| const size_t toRead = reader->currentToRead(); |
| byteString.append((char*)reader->readBuffer(), toRead); |
| reader->move(toRead); |
| } |
| |
| if (byteString.size() != proto.size()) return ""; |
| |
| return byteString; |
| } |
| |
| static std::string int64VectorToProtoByteString(const std::vector<int64_t>& value) { |
| if (value.empty()) return ""; |
| |
| android::util::ProtoOutputStream proto; |
| for (const auto& ele : value) { |
| proto.write(android::util::FIELD_TYPE_INT64 | android::util::FIELD_COUNT_REPEATED | |
| 1 /* field id */, |
| (long long)ele); |
| } |
| |
| return protoOutputStreamToByteString(proto); |
| } |
| |
| AStatsManager_PullAtomCallbackReturn GpuStats::pullAppInfoAtom(AStatsEventList* data) { |
| ATRACE_CALL(); |
| |
| std::lock_guard<std::mutex> lock(mLock); |
| |
| if (data) { |
| for (const auto& ele : mAppStats) { |
| std::string glDriverBytes = int64VectorToProtoByteString( |
| ele.second.glDriverLoadingTime); |
| std::string vkDriverBytes = int64VectorToProtoByteString( |
| ele.second.vkDriverLoadingTime); |
| std::string angleDriverBytes = int64VectorToProtoByteString( |
| ele.second.angleDriverLoadingTime); |
| |
| android::util::addAStatsEvent( |
| data, |
| android::util::GPU_STATS_APP_INFO, |
| ele.second.appPackageName.c_str(), |
| ele.second.driverVersionCode, |
| android::util::BytesField(glDriverBytes.c_str(), |
| glDriverBytes.length()), |
| android::util::BytesField(vkDriverBytes.c_str(), |
| vkDriverBytes.length()), |
| android::util::BytesField(angleDriverBytes.c_str(), |
| angleDriverBytes.length()), |
| ele.second.cpuVulkanInUse, |
| ele.second.falsePrerotation, |
| ele.second.gles1InUse); |
| } |
| } |
| |
| mAppStats.clear(); |
| |
| return AStatsManager_PULL_SUCCESS; |
| } |
| |
| 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) { |
| android::util::addAStatsEvent( |
| data, |
| android::util::GPU_STATS_GLOBAL_INFO, |
| ele.second.driverPackageName.c_str(), |
| ele.second.driverVersionName.c_str(), |
| ele.second.driverVersionCode, |
| ele.second.driverBuildTime, |
| ele.second.glLoadingCount, |
| ele.second.glLoadingFailureCount, |
| ele.second.vkLoadingCount, |
| ele.second.vkLoadingFailureCount, |
| ele.second.vulkanVersion, |
| ele.second.cpuVulkanVersion, |
| ele.second.glesVersion, |
| ele.second.angleLoadingCount, |
| ele.second.angleLoadingFailureCount); |
| } |
| } |
| |
| 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); |
| } else if (atomTag == android::util::GPU_STATS_APP_INFO) { |
| return pGpuStats->pullAppInfoAtom(data); |
| } |
| |
| return AStatsManager_PULL_SKIP; |
| } |
| |
| } // namespace android |