blob: f06a0457d3fba06e4135b08e67f912ae07a6fee2 [file] [log] [blame]
Yiwei Zhang2d4c1882019-02-24 22:28:08 -08001/*
2 * Copyright 2019 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16#undef LOG_TAG
17#define LOG_TAG "GpuStats"
18#define ATRACE_TAG ATRACE_TAG_GRAPHICS
19
Yiwei Zhang29f85932020-02-04 17:14:54 -080020#include "gpustats/GpuStats.h"
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080021
Yiwei Zhang29f85932020-02-04 17:14:54 -080022#include <android/util/ProtoOutputStream.h>
Yiwei Zhang174a2a02019-05-06 19:08:31 -070023#include <cutils/properties.h>
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080024#include <log/log.h>
Yiwei Zhangb59a1272020-02-04 14:58:01 -080025#include <stats_event.h>
26#include <statslog.h>
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080027#include <utils/Trace.h>
28
Yiwei Zhang174a2a02019-05-06 19:08:31 -070029#include <unordered_set>
30
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080031namespace android {
32
Yiwei Zhangb59a1272020-02-04 14:58:01 -080033GpuStats::~GpuStats() {
Alec Mouri822b10a2020-03-17 17:51:27 -070034 if (mStatsdRegistered) {
Tej Singh38a4b212020-03-13 19:04:51 -070035 AStatsManager_clearPullAtomCallback(android::util::GPU_STATS_GLOBAL_INFO);
36 AStatsManager_clearPullAtomCallback(android::util::GPU_STATS_APP_INFO);
Alec Mouri822b10a2020-03-17 17:51:27 -070037 }
Yiwei Zhangb59a1272020-02-04 14:58:01 -080038}
39
Yiwei Zhang27ab3ac2019-07-02 18:10:55 -070040static void addLoadingCount(GpuStatsInfo::Driver driver, bool isDriverLoaded,
Yiwei Zhangf40fb102019-02-27 21:05:06 -080041 GpuStatsGlobalInfo* const outGlobalInfo) {
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080042 switch (driver) {
Yiwei Zhang27ab3ac2019-07-02 18:10:55 -070043 case GpuStatsInfo::Driver::GL:
44 case GpuStatsInfo::Driver::GL_UPDATED:
Yiwei Zhangf40fb102019-02-27 21:05:06 -080045 outGlobalInfo->glLoadingCount++;
46 if (!isDriverLoaded) outGlobalInfo->glLoadingFailureCount++;
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080047 break;
Yiwei Zhang27ab3ac2019-07-02 18:10:55 -070048 case GpuStatsInfo::Driver::VULKAN:
49 case GpuStatsInfo::Driver::VULKAN_UPDATED:
Yiwei Zhangf40fb102019-02-27 21:05:06 -080050 outGlobalInfo->vkLoadingCount++;
51 if (!isDriverLoaded) outGlobalInfo->vkLoadingFailureCount++;
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080052 break;
Yiwei Zhang27ab3ac2019-07-02 18:10:55 -070053 case GpuStatsInfo::Driver::ANGLE:
Yiwei Zhang8e7c4b62019-05-08 15:57:59 -070054 outGlobalInfo->angleLoadingCount++;
55 if (!isDriverLoaded) outGlobalInfo->angleLoadingFailureCount++;
56 break;
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080057 default:
Yiwei Zhang8e7c4b62019-05-08 15:57:59 -070058 break;
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080059 }
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080060}
61
Yiwei Zhang27ab3ac2019-07-02 18:10:55 -070062static void addLoadingTime(GpuStatsInfo::Driver driver, int64_t driverLoadingTime,
Yiwei Zhangf40fb102019-02-27 21:05:06 -080063 GpuStatsAppInfo* const outAppInfo) {
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080064 switch (driver) {
Yiwei Zhang27ab3ac2019-07-02 18:10:55 -070065 case GpuStatsInfo::Driver::GL:
66 case GpuStatsInfo::Driver::GL_UPDATED:
Yiwei Zhang8e7c4b62019-05-08 15:57:59 -070067 if (outAppInfo->glDriverLoadingTime.size() < GpuStats::MAX_NUM_LOADING_TIMES) {
68 outAppInfo->glDriverLoadingTime.emplace_back(driverLoadingTime);
69 }
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080070 break;
Yiwei Zhang27ab3ac2019-07-02 18:10:55 -070071 case GpuStatsInfo::Driver::VULKAN:
72 case GpuStatsInfo::Driver::VULKAN_UPDATED:
Yiwei Zhang8e7c4b62019-05-08 15:57:59 -070073 if (outAppInfo->vkDriverLoadingTime.size() < GpuStats::MAX_NUM_LOADING_TIMES) {
74 outAppInfo->vkDriverLoadingTime.emplace_back(driverLoadingTime);
75 }
76 break;
Yiwei Zhang27ab3ac2019-07-02 18:10:55 -070077 case GpuStatsInfo::Driver::ANGLE:
Yiwei Zhang8e7c4b62019-05-08 15:57:59 -070078 if (outAppInfo->angleDriverLoadingTime.size() < GpuStats::MAX_NUM_LOADING_TIMES) {
79 outAppInfo->angleDriverLoadingTime.emplace_back(driverLoadingTime);
80 }
Yiwei Zhang2d4c1882019-02-24 22:28:08 -080081 break;
82 default:
83 break;
84 }
85}
86
Tim Van Pattena9ad69b2021-11-24 19:29:38 -070087void GpuStats::purgeOldDriverStats() {
88 ALOG_ASSERT(mAppStats.size() == MAX_NUM_APP_RECORDS);
89
90 struct GpuStatsApp {
91 // Key is <app package name>+<driver version code>.
92 const std::string *appStatsKey = nullptr;
93 const std::chrono::time_point<std::chrono::system_clock> *lastAccessTime = nullptr;
94 };
95 std::vector<GpuStatsApp> gpuStatsApps(MAX_NUM_APP_RECORDS);
96
97 // Create a list of pointers to package names and their last access times.
98 int index = 0;
99 for (const auto & [appStatsKey, gpuStatsAppInfo] : mAppStats) {
100 GpuStatsApp &gpuStatsApp = gpuStatsApps[index];
101 gpuStatsApp.appStatsKey = &appStatsKey;
102 gpuStatsApp.lastAccessTime = &gpuStatsAppInfo.lastAccessTime;
103 ++index;
104 }
105
106 // Sort the list with the oldest access times at the front.
107 std::sort(gpuStatsApps.begin(), gpuStatsApps.end(), [](GpuStatsApp a, GpuStatsApp b) -> bool {
108 return *a.lastAccessTime < *b.lastAccessTime;
109 });
110
111 // Remove the oldest packages from mAppStats to make room for new apps.
112 for (int i = 0; i < APP_RECORD_HEADROOM; ++i) {
113 mAppStats.erase(*gpuStatsApps[i].appStatsKey);
114 gpuStatsApps[i].appStatsKey = nullptr;
115 gpuStatsApps[i].lastAccessTime = nullptr;
116 }
117}
118
Yiwei Zhangfdd7e782020-01-31 15:59:34 -0800119void GpuStats::insertDriverStats(const std::string& driverPackageName,
120 const std::string& driverVersionName, uint64_t driverVersionCode,
121 int64_t driverBuildTime, const std::string& appPackageName,
122 const int32_t vulkanVersion, GpuStatsInfo::Driver driver,
123 bool isDriverLoaded, int64_t driverLoadingTime) {
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800124 ATRACE_CALL();
125
126 std::lock_guard<std::mutex> lock(mLock);
Alec Mouri822b10a2020-03-17 17:51:27 -0700127 registerStatsdCallbacksIfNeeded();
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800128 ALOGV("Received:\n"
129 "\tdriverPackageName[%s]\n"
130 "\tdriverVersionName[%s]\n"
131 "\tdriverVersionCode[%" PRIu64 "]\n"
132 "\tdriverBuildTime[%" PRId64 "]\n"
133 "\tappPackageName[%s]\n"
Yiwei Zhang794d2952019-05-06 17:43:59 -0700134 "\tvulkanVersion[%d]\n"
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800135 "\tdriver[%d]\n"
136 "\tisDriverLoaded[%d]\n"
137 "\tdriverLoadingTime[%" PRId64 "]",
138 driverPackageName.c_str(), driverVersionName.c_str(), driverVersionCode, driverBuildTime,
Yiwei Zhang794d2952019-05-06 17:43:59 -0700139 appPackageName.c_str(), vulkanVersion, static_cast<int32_t>(driver), isDriverLoaded,
140 driverLoadingTime);
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800141
142 if (!mGlobalStats.count(driverVersionCode)) {
Yiwei Zhangf40fb102019-02-27 21:05:06 -0800143 GpuStatsGlobalInfo globalInfo;
Yiwei Zhang8e7c4b62019-05-08 15:57:59 -0700144 addLoadingCount(driver, isDriverLoaded, &globalInfo);
Yiwei Zhangf40fb102019-02-27 21:05:06 -0800145 globalInfo.driverPackageName = driverPackageName;
146 globalInfo.driverVersionName = driverVersionName;
147 globalInfo.driverVersionCode = driverVersionCode;
148 globalInfo.driverBuildTime = driverBuildTime;
Yiwei Zhang794d2952019-05-06 17:43:59 -0700149 globalInfo.vulkanVersion = vulkanVersion;
Yiwei Zhangf40fb102019-02-27 21:05:06 -0800150 mGlobalStats.insert({driverVersionCode, globalInfo});
Yiwei Zhang8e7c4b62019-05-08 15:57:59 -0700151 } else {
152 addLoadingCount(driver, isDriverLoaded, &mGlobalStats[driverVersionCode]);
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800153 }
154
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800155 const std::string appStatsKey = appPackageName + std::to_string(driverVersionCode);
156 if (!mAppStats.count(appStatsKey)) {
Yiwei Zhang8c5e3bd2019-05-09 14:34:19 -0700157 if (mAppStats.size() >= MAX_NUM_APP_RECORDS) {
Tim Van Pattena9ad69b2021-11-24 19:29:38 -0700158 ALOGV("GpuStatsAppInfo has reached maximum size. Removing old stats to make room.");
159 purgeOldDriverStats();
Yiwei Zhang8c5e3bd2019-05-09 14:34:19 -0700160 }
161
Yiwei Zhangf40fb102019-02-27 21:05:06 -0800162 GpuStatsAppInfo appInfo;
163 addLoadingTime(driver, driverLoadingTime, &appInfo);
164 appInfo.appPackageName = appPackageName;
165 appInfo.driverVersionCode = driverVersionCode;
Tim Van Pattena9ad69b2021-11-24 19:29:38 -0700166 appInfo.angleInUse = driverPackageName == "angle";
167 appInfo.lastAccessTime = std::chrono::system_clock::now();
Yiwei Zhangf40fb102019-02-27 21:05:06 -0800168 mAppStats.insert({appStatsKey, appInfo});
Tim Van Pattena9ad69b2021-11-24 19:29:38 -0700169 } else {
170 mAppStats[appStatsKey].angleInUse = driverPackageName == "angle";
171 addLoadingTime(driver, driverLoadingTime, &mAppStats[appStatsKey]);
172 mAppStats[appStatsKey].lastAccessTime = std::chrono::system_clock::now();
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800173 }
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800174}
175
Yiwei Zhangbcba4112019-07-03 13:39:32 -0700176void GpuStats::insertTargetStats(const std::string& appPackageName,
177 const uint64_t driverVersionCode, const GpuStatsInfo::Stats stats,
Serdar Kocdemirb2901c92022-11-17 00:39:05 +0000178 const uint64_t value) {
179 return insertTargetStatsArray(appPackageName, driverVersionCode, stats, &value, 1);
180}
181
182void GpuStats::insertTargetStatsArray(const std::string& appPackageName,
183 const uint64_t driverVersionCode, const GpuStatsInfo::Stats stats,
184 const uint64_t* values, const uint32_t valueCount) {
Yiwei Zhangbcba4112019-07-03 13:39:32 -0700185 ATRACE_CALL();
186
Yiwei Zhang8c5e3bd2019-05-09 14:34:19 -0700187 const std::string appStatsKey = appPackageName + std::to_string(driverVersionCode);
Yiwei Zhangbcba4112019-07-03 13:39:32 -0700188
189 std::lock_guard<std::mutex> lock(mLock);
Alec Mouri822b10a2020-03-17 17:51:27 -0700190 registerStatsdCallbacksIfNeeded();
Serdar Kocdemirb2901c92022-11-17 00:39:05 +0000191
192 const auto foundApp = mAppStats.find(appStatsKey);
193 if (foundApp == mAppStats.end()) {
Yiwei Zhang8c5e3bd2019-05-09 14:34:19 -0700194 return;
195 }
196
Serdar Kocdemirb2901c92022-11-17 00:39:05 +0000197 GpuStatsAppInfo& targetAppStats = foundApp->second;
198
199 if (stats == GpuStatsInfo::Stats::VULKAN_INSTANCE_EXTENSION
200 || stats == GpuStatsInfo::Stats::VULKAN_DEVICE_EXTENSION) {
201 // Handle extension arrays separately as we need to store a unique set of them
202 // in the stats vector. Storing in std::set<> is not efficient for serialization tasks.
203 std::vector<int32_t>& targetVec =
204 (stats == GpuStatsInfo::Stats::VULKAN_INSTANCE_EXTENSION) ?
205 targetAppStats.vulkanInstanceExtensions :
206 targetAppStats.vulkanDeviceExtensions;
207 const bool addAll = (targetVec.size() == 0);
208 targetVec.reserve(valueCount);
209
210 // Add new extensions into the set
211 for(uint32_t i = 0;
212 (i < valueCount) && (targetVec.size() < GpuStatsAppInfo::MAX_NUM_EXTENSIONS);
213 i++) {
214 const int32_t extVal = int32_t(values[i] & 0xFFFFFFFF);
215 if (addAll
216 || std::find(targetVec.cbegin(), targetVec.cend(), extVal) == targetVec.cend()) {
217 targetVec.push_back(extVal);
218 }
219 }
220 }
221 else {
222 // Handle other type of stats info events
223 for(uint32_t i = 0; i < valueCount; i++) {
224 const uint64_t value = values[i];
225 switch (stats) {
226 case GpuStatsInfo::Stats::CPU_VULKAN_IN_USE:
227 targetAppStats.cpuVulkanInUse = true;
228 break;
229 case GpuStatsInfo::Stats::FALSE_PREROTATION:
230 targetAppStats.falsePrerotation = true;
231 break;
232 case GpuStatsInfo::Stats::GLES_1_IN_USE:
233 targetAppStats.gles1InUse = true;
234 break;
235 case GpuStatsInfo::Stats::CREATED_GLES_CONTEXT:
236 targetAppStats.createdGlesContext = true;
237 break;
238 case GpuStatsInfo::Stats::CREATED_VULKAN_DEVICE:
239 targetAppStats.createdVulkanDevice = true;
240 break;
241 case GpuStatsInfo::Stats::CREATED_VULKAN_API_VERSION:
242 targetAppStats.vulkanApiVersion = uint32_t(value & 0xffffffff);
243 break;
244 case GpuStatsInfo::Stats::CREATED_VULKAN_SWAPCHAIN:
245 targetAppStats.createdVulkanSwapchain = true;
246 break;
247 case GpuStatsInfo::Stats::VULKAN_DEVICE_FEATURES_ENABLED:
248 // Merge all requested feature bits together for this app
249 targetAppStats.vulkanDeviceFeaturesEnabled |= value;
250 break;
251 default:
252 break;
253 }
254 }
Yiwei Zhangbcba4112019-07-03 13:39:32 -0700255 }
Yiwei Zhang8c5e3bd2019-05-09 14:34:19 -0700256}
257
Yiwei Zhang174a2a02019-05-06 19:08:31 -0700258void GpuStats::interceptSystemDriverStatsLocked() {
259 // Append cpuVulkanVersion and glesVersion to system driver stats
260 if (!mGlobalStats.count(0) || mGlobalStats[0].glesVersion) {
261 return;
262 }
263
264 mGlobalStats[0].cpuVulkanVersion = property_get_int32("ro.cpuvulkan.version", 0);
265 mGlobalStats[0].glesVersion = property_get_int32("ro.opengles.version", 0);
266}
267
Alec Mouri822b10a2020-03-17 17:51:27 -0700268void GpuStats::registerStatsdCallbacksIfNeeded() {
269 if (!mStatsdRegistered) {
Tej Singh38a4b212020-03-13 19:04:51 -0700270 AStatsManager_setPullAtomCallback(android::util::GPU_STATS_GLOBAL_INFO, nullptr,
271 GpuStats::pullAtomCallback, this);
272 AStatsManager_setPullAtomCallback(android::util::GPU_STATS_APP_INFO, nullptr,
273 GpuStats::pullAtomCallback, this);
Alec Mouri822b10a2020-03-17 17:51:27 -0700274 mStatsdRegistered = true;
275 }
276}
277
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800278void GpuStats::dump(const Vector<String16>& args, std::string* result) {
279 ATRACE_CALL();
280
281 if (!result) {
282 ALOGE("Dump result shouldn't be nullptr.");
283 return;
284 }
285
286 std::lock_guard<std::mutex> lock(mLock);
287 bool dumpAll = true;
288
289 std::unordered_set<std::string> argsSet;
290 for (size_t i = 0; i < args.size(); i++) {
291 argsSet.insert(String8(args[i]).c_str());
292 }
293
294 const bool dumpGlobal = argsSet.count("--global") != 0;
295 if (dumpGlobal) {
296 dumpGlobalLocked(result);
297 dumpAll = false;
298 }
299
300 const bool dumpApp = argsSet.count("--app") != 0;
301 if (dumpApp) {
302 dumpAppLocked(result);
303 dumpAll = false;
304 }
305
Yiwei Zhangfdd7e782020-01-31 15:59:34 -0800306 if (dumpAll) {
307 dumpGlobalLocked(result);
308 dumpAppLocked(result);
309 }
310
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800311 if (argsSet.count("--clear")) {
312 bool clearAll = true;
313
314 if (dumpGlobal) {
315 mGlobalStats.clear();
316 clearAll = false;
317 }
318
319 if (dumpApp) {
320 mAppStats.clear();
321 clearAll = false;
322 }
323
324 if (clearAll) {
325 mGlobalStats.clear();
326 mAppStats.clear();
327 }
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800328 }
329}
330
331void GpuStats::dumpGlobalLocked(std::string* result) {
Yiwei Zhang174a2a02019-05-06 19:08:31 -0700332 interceptSystemDriverStatsLocked();
333
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800334 for (const auto& ele : mGlobalStats) {
Yiwei Zhangf40fb102019-02-27 21:05:06 -0800335 result->append(ele.second.toString());
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800336 result->append("\n");
337 }
338}
339
340void GpuStats::dumpAppLocked(std::string* result) {
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800341 for (const auto& ele : mAppStats) {
Yiwei Zhangf40fb102019-02-27 21:05:06 -0800342 result->append(ele.second.toString());
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800343 result->append("\n");
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800344 }
345}
346
Yiwei Zhang29f85932020-02-04 17:14:54 -0800347static std::string protoOutputStreamToByteString(android::util::ProtoOutputStream& proto) {
348 if (!proto.size()) return "";
349
350 std::string byteString;
351 sp<android::util::ProtoReader> reader = proto.data();
352 while (reader->readBuffer() != nullptr) {
353 const size_t toRead = reader->currentToRead();
354 byteString.append((char*)reader->readBuffer(), toRead);
355 reader->move(toRead);
356 }
357
358 if (byteString.size() != proto.size()) return "";
359
360 return byteString;
361}
362
363static std::string int64VectorToProtoByteString(const std::vector<int64_t>& value) {
364 if (value.empty()) return "";
365
366 android::util::ProtoOutputStream proto;
367 for (const auto& ele : value) {
368 proto.write(android::util::FIELD_TYPE_INT64 | android::util::FIELD_COUNT_REPEATED |
369 1 /* field id */,
370 (long long)ele);
371 }
372
373 return protoOutputStreamToByteString(proto);
374}
375
376AStatsManager_PullAtomCallbackReturn GpuStats::pullAppInfoAtom(AStatsEventList* data) {
377 ATRACE_CALL();
378
379 std::lock_guard<std::mutex> lock(mLock);
380
381 if (data) {
382 for (const auto& ele : mAppStats) {
Salud Lemus30108fa2020-07-11 00:02:19 +0000383 std::string glDriverBytes = int64VectorToProtoByteString(
384 ele.second.glDriverLoadingTime);
385 std::string vkDriverBytes = int64VectorToProtoByteString(
386 ele.second.vkDriverLoadingTime);
387 std::string angleDriverBytes = int64VectorToProtoByteString(
388 ele.second.angleDriverLoadingTime);
Yiwei Zhang29f85932020-02-04 17:14:54 -0800389
Salud Lemus30108fa2020-07-11 00:02:19 +0000390 android::util::addAStatsEvent(
391 data,
392 android::util::GPU_STATS_APP_INFO,
393 ele.second.appPackageName.c_str(),
394 ele.second.driverVersionCode,
395 android::util::BytesField(glDriverBytes.c_str(),
396 glDriverBytes.length()),
397 android::util::BytesField(vkDriverBytes.c_str(),
398 vkDriverBytes.length()),
399 android::util::BytesField(angleDriverBytes.c_str(),
400 angleDriverBytes.length()),
401 ele.second.cpuVulkanInUse,
402 ele.second.falsePrerotation,
Tim Van Pattena9ad69b2021-11-24 19:29:38 -0700403 ele.second.gles1InUse,
Serdar Kocdemirb2901c92022-11-17 00:39:05 +0000404 ele.second.angleInUse,
405 ele.second.createdGlesContext,
406 ele.second.createdVulkanDevice,
407 ele.second.createdVulkanSwapchain,
408 ele.second.vulkanApiVersion,
409 ele.second.vulkanDeviceFeaturesEnabled,
410 ele.second.vulkanInstanceExtensions,
411 ele.second.vulkanDeviceExtensions);
Yiwei Zhang29f85932020-02-04 17:14:54 -0800412 }
413 }
414
415 mAppStats.clear();
416
417 return AStatsManager_PULL_SUCCESS;
418}
419
Yiwei Zhangb59a1272020-02-04 14:58:01 -0800420AStatsManager_PullAtomCallbackReturn GpuStats::pullGlobalInfoAtom(AStatsEventList* data) {
421 ATRACE_CALL();
422
423 std::lock_guard<std::mutex> lock(mLock);
424 // flush cpuVulkanVersion and glesVersion to builtin driver stats
425 interceptSystemDriverStatsLocked();
426
427 if (data) {
428 for (const auto& ele : mGlobalStats) {
Salud Lemus30108fa2020-07-11 00:02:19 +0000429 android::util::addAStatsEvent(
430 data,
431 android::util::GPU_STATS_GLOBAL_INFO,
432 ele.second.driverPackageName.c_str(),
433 ele.second.driverVersionName.c_str(),
434 ele.second.driverVersionCode,
435 ele.second.driverBuildTime,
436 ele.second.glLoadingCount,
437 ele.second.glLoadingFailureCount,
438 ele.second.vkLoadingCount,
439 ele.second.vkLoadingFailureCount,
440 ele.second.vulkanVersion,
441 ele.second.cpuVulkanVersion,
442 ele.second.glesVersion,
443 ele.second.angleLoadingCount,
444 ele.second.angleLoadingFailureCount);
Yiwei Zhangb59a1272020-02-04 14:58:01 -0800445 }
446 }
447
448 mGlobalStats.clear();
449
450 return AStatsManager_PULL_SUCCESS;
451}
452
453AStatsManager_PullAtomCallbackReturn GpuStats::pullAtomCallback(int32_t atomTag,
454 AStatsEventList* data,
455 void* cookie) {
456 ATRACE_CALL();
457
458 GpuStats* pGpuStats = reinterpret_cast<GpuStats*>(cookie);
459 if (atomTag == android::util::GPU_STATS_GLOBAL_INFO) {
460 return pGpuStats->pullGlobalInfoAtom(data);
Yiwei Zhang29f85932020-02-04 17:14:54 -0800461 } else if (atomTag == android::util::GPU_STATS_APP_INFO) {
462 return pGpuStats->pullAppInfoAtom(data);
Yiwei Zhangb59a1272020-02-04 14:58:01 -0800463 }
464
465 return AStatsManager_PULL_SKIP;
466}
467
Yiwei Zhang2d4c1882019-02-24 22:28:08 -0800468} // namespace android