1 /*
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
20 #include "gpustats/GpuStats.h"
21
22 #include <android/util/ProtoOutputStream.h>
23 #include <cutils/properties.h>
24 #include <log/log.h>
25 #include <stats_event.h>
26 #include <statslog.h>
27 #include <utils/Trace.h>
28
29 #include <unordered_set>
30
31 namespace android {
32
~GpuStats()33 GpuStats::~GpuStats() {
34 if (mStatsdRegistered) {
35 AStatsManager_clearPullAtomCallback(android::util::GPU_STATS_GLOBAL_INFO);
36 AStatsManager_clearPullAtomCallback(android::util::GPU_STATS_APP_INFO);
37 }
38 }
39
addLoadingCount(GpuStatsInfo::Driver driver,bool isDriverLoaded,GpuStatsGlobalInfo * const outGlobalInfo)40 static void addLoadingCount(GpuStatsInfo::Driver driver, bool isDriverLoaded,
41 GpuStatsGlobalInfo* const outGlobalInfo) {
42 switch (driver) {
43 case GpuStatsInfo::Driver::GL:
44 case GpuStatsInfo::Driver::GL_UPDATED:
45 outGlobalInfo->glLoadingCount++;
46 if (!isDriverLoaded) outGlobalInfo->glLoadingFailureCount++;
47 break;
48 case GpuStatsInfo::Driver::VULKAN:
49 case GpuStatsInfo::Driver::VULKAN_UPDATED:
50 outGlobalInfo->vkLoadingCount++;
51 if (!isDriverLoaded) outGlobalInfo->vkLoadingFailureCount++;
52 break;
53 case GpuStatsInfo::Driver::ANGLE:
54 outGlobalInfo->angleLoadingCount++;
55 if (!isDriverLoaded) outGlobalInfo->angleLoadingFailureCount++;
56 break;
57 default:
58 break;
59 }
60 }
61
addLoadingTime(GpuStatsInfo::Driver driver,int64_t driverLoadingTime,GpuStatsAppInfo * const outAppInfo)62 static void addLoadingTime(GpuStatsInfo::Driver driver, int64_t driverLoadingTime,
63 GpuStatsAppInfo* const outAppInfo) {
64 switch (driver) {
65 case GpuStatsInfo::Driver::GL:
66 case GpuStatsInfo::Driver::GL_UPDATED:
67 if (outAppInfo->glDriverLoadingTime.size() < GpuStats::MAX_NUM_LOADING_TIMES) {
68 outAppInfo->glDriverLoadingTime.emplace_back(driverLoadingTime);
69 }
70 break;
71 case GpuStatsInfo::Driver::VULKAN:
72 case GpuStatsInfo::Driver::VULKAN_UPDATED:
73 if (outAppInfo->vkDriverLoadingTime.size() < GpuStats::MAX_NUM_LOADING_TIMES) {
74 outAppInfo->vkDriverLoadingTime.emplace_back(driverLoadingTime);
75 }
76 break;
77 case GpuStatsInfo::Driver::ANGLE:
78 if (outAppInfo->angleDriverLoadingTime.size() < GpuStats::MAX_NUM_LOADING_TIMES) {
79 outAppInfo->angleDriverLoadingTime.emplace_back(driverLoadingTime);
80 }
81 break;
82 default:
83 break;
84 }
85 }
86
purgeOldDriverStats()87 void 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
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)119 void 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) {
124 ATRACE_CALL();
125
126 std::lock_guard<std::mutex> lock(mLock);
127 registerStatsdCallbacksIfNeeded();
128 ALOGV("Received:\n"
129 "\tdriverPackageName[%s]\n"
130 "\tdriverVersionName[%s]\n"
131 "\tdriverVersionCode[%" PRIu64 "]\n"
132 "\tdriverBuildTime[%" PRId64 "]\n"
133 "\tappPackageName[%s]\n"
134 "\tvulkanVersion[%d]\n"
135 "\tdriver[%d]\n"
136 "\tisDriverLoaded[%d]\n"
137 "\tdriverLoadingTime[%" PRId64 "]",
138 driverPackageName.c_str(), driverVersionName.c_str(), driverVersionCode, driverBuildTime,
139 appPackageName.c_str(), vulkanVersion, static_cast<int32_t>(driver), isDriverLoaded,
140 driverLoadingTime);
141
142 if (!mGlobalStats.count(driverVersionCode)) {
143 GpuStatsGlobalInfo globalInfo;
144 addLoadingCount(driver, isDriverLoaded, &globalInfo);
145 globalInfo.driverPackageName = driverPackageName;
146 globalInfo.driverVersionName = driverVersionName;
147 globalInfo.driverVersionCode = driverVersionCode;
148 globalInfo.driverBuildTime = driverBuildTime;
149 globalInfo.vulkanVersion = vulkanVersion;
150 mGlobalStats.insert({driverVersionCode, globalInfo});
151 } else {
152 addLoadingCount(driver, isDriverLoaded, &mGlobalStats[driverVersionCode]);
153 }
154
155 const std::string appStatsKey = appPackageName + std::to_string(driverVersionCode);
156 if (!mAppStats.count(appStatsKey)) {
157 if (mAppStats.size() >= MAX_NUM_APP_RECORDS) {
158 ALOGV("GpuStatsAppInfo has reached maximum size. Removing old stats to make room.");
159 purgeOldDriverStats();
160 }
161
162 GpuStatsAppInfo appInfo;
163 addLoadingTime(driver, driverLoadingTime, &appInfo);
164 appInfo.appPackageName = appPackageName;
165 appInfo.driverVersionCode = driverVersionCode;
166 appInfo.angleInUse = driverPackageName == "angle";
167 appInfo.lastAccessTime = std::chrono::system_clock::now();
168 mAppStats.insert({appStatsKey, appInfo});
169 } else {
170 mAppStats[appStatsKey].angleInUse = driverPackageName == "angle";
171 addLoadingTime(driver, driverLoadingTime, &mAppStats[appStatsKey]);
172 mAppStats[appStatsKey].lastAccessTime = std::chrono::system_clock::now();
173 }
174 }
175
insertTargetStats(const std::string & appPackageName,const uint64_t driverVersionCode,const GpuStatsInfo::Stats stats,const uint64_t value)176 void GpuStats::insertTargetStats(const std::string& appPackageName,
177 const uint64_t driverVersionCode, const GpuStatsInfo::Stats stats,
178 const uint64_t value) {
179 return insertTargetStatsArray(appPackageName, driverVersionCode, stats, &value, 1);
180 }
181
insertTargetStatsArray(const std::string & appPackageName,const uint64_t driverVersionCode,const GpuStatsInfo::Stats stats,const uint64_t * values,const uint32_t valueCount)182 void GpuStats::insertTargetStatsArray(const std::string& appPackageName,
183 const uint64_t driverVersionCode, const GpuStatsInfo::Stats stats,
184 const uint64_t* values, const uint32_t valueCount) {
185 ATRACE_CALL();
186
187 const std::string appStatsKey = appPackageName + std::to_string(driverVersionCode);
188
189 std::lock_guard<std::mutex> lock(mLock);
190 registerStatsdCallbacksIfNeeded();
191
192 const auto foundApp = mAppStats.find(appStatsKey);
193 if (foundApp == mAppStats.end()) {
194 return;
195 }
196
197 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 }
255 }
256 }
257
interceptSystemDriverStatsLocked()258 void 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
registerStatsdCallbacksIfNeeded()268 void GpuStats::registerStatsdCallbacksIfNeeded() {
269 if (!mStatsdRegistered) {
270 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);
274 mStatsdRegistered = true;
275 }
276 }
277
dump(const Vector<String16> & args,std::string * result)278 void 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
306 if (dumpAll) {
307 dumpGlobalLocked(result);
308 dumpAppLocked(result);
309 }
310
311 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 }
328 }
329 }
330
dumpGlobalLocked(std::string * result)331 void GpuStats::dumpGlobalLocked(std::string* result) {
332 interceptSystemDriverStatsLocked();
333
334 for (const auto& ele : mGlobalStats) {
335 result->append(ele.second.toString());
336 result->append("\n");
337 }
338 }
339
dumpAppLocked(std::string * result)340 void GpuStats::dumpAppLocked(std::string* result) {
341 for (const auto& ele : mAppStats) {
342 result->append(ele.second.toString());
343 result->append("\n");
344 }
345 }
346
protoOutputStreamToByteString(android::util::ProtoOutputStream & proto)347 static 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
int64VectorToProtoByteString(const std::vector<int64_t> & value)363 static 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
pullAppInfoAtom(AStatsEventList * data)376 AStatsManager_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) {
383 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);
389
390 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,
403 ele.second.gles1InUse,
404 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);
412 }
413 }
414
415 mAppStats.clear();
416
417 return AStatsManager_PULL_SUCCESS;
418 }
419
pullGlobalInfoAtom(AStatsEventList * data)420 AStatsManager_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) {
429 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);
445 }
446 }
447
448 mGlobalStats.clear();
449
450 return AStatsManager_PULL_SUCCESS;
451 }
452
pullAtomCallback(int32_t atomTag,AStatsEventList * data,void * cookie)453 AStatsManager_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);
461 } else if (atomTag == android::util::GPU_STATS_APP_INFO) {
462 return pGpuStats->pullAppInfoAtom(data);
463 }
464
465 return AStatsManager_PULL_SKIP;
466 }
467
468 } // namespace android
469