1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "animator_monitor.h"
17 #include "jank_frame_monitor.h"
18 #include "perf_reporter.h"
19 #include "perf_trace.h"
20 #include "perf_utils.h"
21 #include "scene_monitor.h"
22 #include "xperf_event_builder.h"
23 #include "xperf_event_reporter.h"
24
25 #include "hisysevent.h"
26 #include "render_service_client/core/transaction/rs_interfaces.h"
27 #include "hiview_logger.h"
28
29 #ifdef RESOURCE_SCHEDULE_SERVICE_ENABLE
30 #include "res_sched_client.h"
31 #include "res_type.h"
32 #endif // RESOURCE_SCHEDULE_SERVICE_ENABLE
33
34 namespace OHOS {
35 namespace HiviewDFX {
36
37 DEFINE_LOG_LABEL(0xD002D66, "Hiview-PerfMonitor");
38
39 namespace {
40 constexpr char EVENT_KEY_PROCESS_NAME[] = "PROCESS_NAME";
41 constexpr char EVENT_KEY_ABILITY_NAME[] = "ABILITY_NAME";
42 constexpr char EVENT_KEY_PAGE_URL[] = "PAGE_URL";
43 constexpr char EVENT_KEY_PAGE_NAME[] = "PAGE_NAME";
44 constexpr char EVENT_KEY_VERSION_CODE[] = "VERSION_CODE";
45 constexpr char EVENT_KEY_VERSION_NAME[] = "VERSION_NAME";
46 constexpr char EVENT_KEY_BUNDLE_NAME[] = "BUNDLE_NAME";
47 constexpr char EVENT_KEY_JANK_STATS[] = "JANK_STATS";
48 constexpr char EVENT_KEY_JANK_STATS_VER[] = "JANK_STATS_VER";
49 constexpr char EVENT_KEY_APP_PID[] = "APP_PID";
50 constexpr char EVENT_KEY_SCENE_ID[] = "SCENE_ID";
51 constexpr char EVENT_KEY_INPUT_TIME[] = "INPUT_TIME";
52 constexpr char EVENT_KEY_ANIMATION_START_LATENCY[] = "ANIMATION_START_LATENCY";
53 constexpr char EVENT_KEY_ANIMATION_END_LATENCY[] = "ANIMATION_END_LATENCY";
54 constexpr char EVENT_KEY_E2E_LATENCY[] = "E2E_LATENCY";
55 constexpr char EVENT_KEY_UNIQUE_ID[] = "UNIQUE_ID";
56 constexpr char EVENT_KEY_MODULE_NAME[] = "MODULE_NAME";
57 constexpr char EVENT_KEY_DURITION[] = "DURITION";
58 constexpr char EVENT_KEY_TOTAL_FRAMES[] = "TOTAL_FRAMES";
59 constexpr char EVENT_KEY_TOTAL_MISSED_FRAMES[] = "TOTAL_MISSED_FRAMES";
60 constexpr char EVENT_KEY_MAX_FRAMETIME[] = "MAX_FRAMETIME";
61 constexpr char EVENT_KEY_MAX_FRAMETIME_SINCE_START[] = "MAX_FRAMETIME_SINCE_START";
62 constexpr char EVENT_KEY_MAX_HITCH_TIME[] = "MAX_HITCH_TIME";
63 constexpr char EVENT_KEY_MAX_HITCH_TIME_SINCE_START[] = "MAX_HITCH_TIME_SINCE_START";
64 constexpr char EVENT_KEY_MAX_SEQ_MISSED_FRAMES[] = "MAX_SEQ_MISSED_FRAMES";
65 constexpr char EVENT_KEY_SOURCE_TYPE[] = "SOURCE_TYPE";
66 constexpr char EVENT_KEY_NOTE[] = "NOTE";
67 constexpr char EVENT_KEY_DISPLAY_ANIMATOR[] = "DISPLAY_ANIMATOR";
68 constexpr char EVENT_KEY_SKIPPED_FRAME_TIME[] = "SKIPPED_FRAME_TIME";
69 constexpr char EVENT_KEY_REAL_SKIPPED_FRAME_TIME[] = "REAL_SKIPPED_FRAME_TIME";
70 constexpr char EVENT_KEY_FILTER_TYPE[] = "FILTER_TYPE";
71 constexpr char EVENT_KEY_STARTTIME[] = "STARTTIME";
72 constexpr char EVENT_KEY_SUBHEALTH_INFO[] = "SUB_HEALTH_INFO";
73 constexpr char EVENT_KEY_SUBHEALTH_REASON[] = "SUB_HEALTH_REASON";
74 constexpr char EVENT_KEY_SUBHEALTH_TIME[] = "SUB_HEALTH_TIME";
75 constexpr char EVENT_KEY_VSYNC_TIME[] = "VSYNC_TIME";
76 constexpr char STATISTIC_DURATION[] = "DURATION";
77 constexpr char KEY_SCROLL_START_TIME[] = "SCROLL_START_TIME";
78 constexpr char KEY_SCROLL_END_TIME[] = "SCROLL_END_TIME";
79 constexpr char KEY_TOTAL_NUM[] = "TOTAL_NUM";
80 constexpr char KEY_FAILED_NUM[] = "FAILED_NUM";
81 constexpr char KEY_TOTAL_SIZE[] = "TOTAL_SIZE";
82 constexpr char KEY_FAILED_SIZE[] = "FAILED_SIZE";
83 constexpr char KEY_TYPE_DETAILS[] = "TYPE_DETAILS";
84 constexpr char KEY_PID[] = "PID";
85 constexpr char KEY_SURFACE_NAME[] = "SURFACE_NAME";
86 constexpr char KEY_COMPONENT_NAME[] = "COMPONENT_NAME";
87
88 #ifdef RESOURCE_SCHEDULE_SERVICE_ENABLE
89 constexpr int32_t MAX_JANK_FRAME_TIME = 32;
90 #endif // RESOURCE_SCHEDULE_SERVICE_ENABLE
91
92 } // namespace
93
GetInstance()94 PerfReporter& PerfReporter::GetInstance()
95 {
96 static PerfReporter instance;
97 return instance;
98 }
99
ReportJankFrameApp(double jank,int32_t jankThreshold)100 void PerfReporter::ReportJankFrameApp(double jank, int32_t jankThreshold)
101 {
102 if (jank >= static_cast<double>(jankThreshold)) {
103 JankInfo jankInfo;
104 jankInfo.skippedFrameTime = static_cast<int64_t>(jank * SINGLE_FRAME_TIME);
105 jankInfo.baseInfo = SceneMonitor::GetInstance().GetBaseInfo();
106 EventReporter::ReportJankFrameApp(jankInfo);
107 }
108 }
109
ReportPageShowMsg(const std::string & pageUrl,const std::string & bundleName,const std::string & pageName)110 void PerfReporter::ReportPageShowMsg(const std::string& pageUrl, const std::string& bundleName,
111 const std::string& pageName)
112 {
113 EventReporter::ReportPageShowMsg(pageUrl, bundleName, pageName);
114 }
115
ReportAnimatorEvent(PerfEventType type,DataBase & data)116 void PerfReporter::ReportAnimatorEvent(PerfEventType type, DataBase& data)
117 {
118 switch (type) {
119 case EVENT_RESPONSE:
120 data.eventType = EVENT_RESPONSE;
121 break;
122 case EVENT_COMPLETE:
123 data.eventType = EVENT_COMPLETE;
124 break;
125 case EVENT_JANK_FRAME:
126 data.eventType = EVENT_JANK_FRAME;
127 break;
128 default :
129 break;
130 }
131 ReportPerfEventToUI(data);
132 ReportPerfEventToRS(data);
133 }
134
ReportPerfEventToRS(DataBase & data)135 void PerfReporter::ReportPerfEventToRS(DataBase& data)
136 {
137 OHOS::Rosen::DataBaseRs dataRs;
138 ConvertToRsData(dataRs, data);
139 switch (dataRs.eventType) {
140 case EVENT_RESPONSE:
141 {
142 XPERF_TRACE_SCOPED("EVENT_REPORT_RESPONSE_RS sceneId = %s, uniqueId = %lld",
143 dataRs.sceneId.c_str(), static_cast<long long> (dataRs.uniqueId));
144 Rosen::RSInterfaces::GetInstance().ReportEventResponse(dataRs);
145 break;
146 }
147 case EVENT_COMPLETE:
148 {
149 if (data.needReportRs) {
150 XPERF_TRACE_SCOPED("EVENT_REPORT_COMPLETE_RS sceneId = %s, uniqueId = %lld",
151 dataRs.sceneId.c_str(), static_cast<long long> (dataRs.uniqueId));
152 Rosen::RSInterfaces::GetInstance().ReportEventComplete(dataRs);
153 }
154 break;
155 }
156 case EVENT_JANK_FRAME:
157 {
158 XPERF_TRACE_SCOPED("EVENT_REPORT_JANK_RS sceneId = %s, uniqueId = %lld",
159 dataRs.sceneId.c_str(), static_cast<long long> (dataRs.uniqueId));
160 Rosen::RSInterfaces::GetInstance().ReportEventJankFrame(dataRs);
161 break;
162 }
163 default :
164 break;
165 }
166 }
167
ReportPerfEventToUI(DataBase data)168 void PerfReporter::ReportPerfEventToUI(DataBase data)
169 {
170 switch (data.eventType) {
171 case EVENT_COMPLETE:
172 if (!data.needReportRs) {
173 EventReporter::ReportEventComplete(data);
174 }
175 break;
176 case EVENT_JANK_FRAME:
177 if (data.totalFrames > 0) {
178 EventReporter::ReportEventJankFrame(data);
179 }
180 break;
181 default :
182 break;
183 }
184 }
185
ConvertToRsData(OHOS::Rosen::DataBaseRs & dataRs,DataBase & data)186 void PerfReporter::ConvertToRsData(OHOS::Rosen::DataBaseRs &dataRs, DataBase& data)
187 {
188 dataRs.eventType = static_cast<int32_t>(data.eventType);
189 dataRs.sceneId = data.sceneId;
190 dataRs.appPid = data.baseInfo.pid;
191 dataRs.uniqueId = data.beginVsyncTime / NS_TO_MS;
192 dataRs.inputTime = data.inputTime;
193 dataRs.beginVsyncTime = data.beginVsyncTime;
194 dataRs.endVsyncTime = data.endVsyncTime;
195 dataRs.versionCode = data.baseInfo.versionCode;
196 dataRs.versionName = data.baseInfo.versionName;
197 dataRs.bundleName = data.baseInfo.bundleName;
198 dataRs.processName = data.baseInfo.processName;
199 dataRs.abilityName = data.baseInfo.abilityName;
200 dataRs.pageUrl = data.baseInfo.pageUrl;
201 dataRs.sourceType = GetSourceTypeName(data.sourceType);
202 dataRs.note = data.baseInfo.note;
203 dataRs.isDisplayAnimator = data.isDisplayAnimator;
204 }
205
ReportSingleJankFrame(JankInfo & jankInfo)206 void PerfReporter::ReportSingleJankFrame(JankInfo& jankInfo)
207 {
208 EventReporter::ReportJankFrameUnFiltered(jankInfo);
209 if (!jankInfo.sceneTag) {
210 EventReporter::ReportJankFrameFiltered(jankInfo);
211 }
212 }
213
ReportStatsJankFrame(int64_t jankFrameRecordBeginTime,int64_t duration,const std::vector<uint16_t> & jankFrameRecord,int32_t jankFrameTotalCount,const BaseInfo & baseInfo)214 void PerfReporter::ReportStatsJankFrame(int64_t jankFrameRecordBeginTime, int64_t duration,
215 const std::vector<uint16_t>& jankFrameRecord, int32_t jankFrameTotalCount, const BaseInfo& baseInfo)
216 {
217 XPERF_TRACE_SCOPED("ReportJankStatsApp count=%" PRId32 ";duration=%" PRId64 ";beginTime=%" PRId64 ";",
218 jankFrameTotalCount, duration, jankFrameRecordBeginTime);
219 if (duration > DEFAULT_VSYNC && jankFrameTotalCount > 0 && jankFrameRecordBeginTime > 0) {
220 EventReporter::ReportStatsJankFrame(jankFrameRecordBeginTime, duration, jankFrameRecord,
221 baseInfo, JANK_STATS_VERSION);
222 }
223 }
224
ReportWhiteBlockStat(uint64_t scrollStartTime,uint64_t scrollEndTime,const std::map<int64_t,ImageLoadInfo * > & mRecords)225 void PerfReporter::ReportWhiteBlockStat(uint64_t scrollStartTime, uint64_t scrollEndTime,
226 const std::map<int64_t, ImageLoadInfo*>& mRecords)
227 {
228 if (mRecords.size() == 0) {
229 HIVIEW_LOGD("no data to report");
230 return;
231 }
232 std::string imageLoadStat;
233 int totalNum = 0; //总个数
234 int failedNum = 0; //失败个数
235 int64_t totalSize = 0; //总大小
236 int64_t failedSize = 0; //失败总大小
237 std::map<std::string, std::pair<int, int>> typeDetails;
238 int64_t size = 0;
239 for (const auto& pair : mRecords) {
240 ImageLoadInfo* record = pair.second;
241 if (record == nullptr) {
242 continue;
243 }
244 if (record->loadEndTime == 0) {
245 continue;
246 }
247 size = (record->width * record->height);
248 totalNum++;
249 totalSize += size;
250 if (record->loadState == 0) {
251 failedNum ++;
252 failedSize += size;
253 }
254
255 auto it = typeDetails.find(record->imageType);
256 if (it != typeDetails.end()) {
257 (it->second).first++;
258 if (record->loadState == 0) {
259 (it->second).second++;
260 }
261 } else {
262 typeDetails.emplace(record->imageType, std::make_pair(1, ((record->loadState == 0) ? 1 : 0)));
263 }
264 }
265 for (const auto& typeDetail : typeDetails) {
266 std::string str = ("type=" + typeDetail.first + ",total=" + std::to_string(typeDetail.second.first) +
267 ",failed=" + std::to_string(typeDetail.second.second) + ";");
268 imageLoadStat += str;
269 }
270
271 ImageLoadStat stat = {scrollStartTime, scrollEndTime, totalNum, failedNum, totalSize, failedSize, imageLoadStat};
272 EventReporter::ReportImageLoadStat(stat);
273 }
274
ReportSurface(const int64_t & uniqueId,const std::string & surfaceName,const std::string & componentName,const std::string & bundleName,const int32_t & pid)275 void PerfReporter::ReportSurface(const int64_t& uniqueId, const std::string& surfaceName,
276 const std::string& componentName, const std::string& bundleName, const int32_t& pid)
277 {
278 SurfaceInfo surfaceInfo = {uniqueId, surfaceName, componentName, bundleName, pid};
279 EventReporter::ReportSurfaceInfo(surfaceInfo);
280 }
281
ReportJankFrameApp(JankInfo & info)282 void EventReporter::ReportJankFrameApp(JankInfo& info)
283 {
284 std::string eventName = "JANK_FRAME_APP";
285 const auto& bundleName = info.baseInfo.bundleName;
286 const auto& processName = info.baseInfo.processName;
287 const auto& abilityName = info.baseInfo.abilityName;
288 const auto& pageUrl = info.baseInfo.pageUrl;
289 const auto& versionCode = info.baseInfo.versionCode;
290 const auto& versionName = info.baseInfo.versionName;
291 const auto& pageName = info.baseInfo.pageName;
292 const auto& skippedFrameTime = info.skippedFrameTime;
293 XperfEventBuilder builder;
294 XperfEvent event = builder.EventName(eventName)
295 .EventType(HISYSEVENT_FAULT)
296 .Param(EVENT_KEY_PROCESS_NAME, processName)
297 .Param(EVENT_KEY_MODULE_NAME, bundleName)
298 .Param(EVENT_KEY_ABILITY_NAME, abilityName)
299 .Param(EVENT_KEY_PAGE_URL, pageUrl)
300 .Param(EVENT_KEY_VERSION_CODE, versionCode)
301 .Param(EVENT_KEY_VERSION_NAME, versionName)
302 .Param(EVENT_KEY_PAGE_NAME, pageName)
303 .Param(EVENT_KEY_SKIPPED_FRAME_TIME, static_cast<uint64_t>(skippedFrameTime))
304 .Build();
305 XperfEventReporter reporter;
306 reporter.Report(ACE_DOMAIN, event);
307 XPERF_TRACE_SCOPED("JANK_FRAME_APP: skipppedFrameTime=%lld(ms)",
308 static_cast<long long>(skippedFrameTime / NS_TO_MS));
309 #ifdef RESOURCE_SCHEDULE_SERVICE_ENABLE
310 ReportAppFrameDropToRss(false, bundleName);
311 #endif // RESOURCE_SCHEDULE_SERVICE_ENABLE
312 }
313
ReportPageShowMsg(const std::string & pageUrl,const std::string & bundleName,const std::string & pageName)314 void EventReporter::ReportPageShowMsg(const std::string& pageUrl, const std::string& bundleName,
315 const std::string& pageName)
316 {
317 XperfEventBuilder builder;
318 XperfEvent event = builder.EventName("APP_PAGE_INFO_UPDATE")
319 .EventType(HISYSEVENT_BEHAVIOR)
320 .Param(EVENT_KEY_PAGE_URL, pageUrl)
321 .Param(EVENT_KEY_BUNDLE_NAME, bundleName)
322 .Param(EVENT_KEY_PAGE_NAME, pageName)
323 .Build();
324 XperfEventReporter reporter;
325 reporter.Report(ACE_DOMAIN, event);
326 }
327
ReportEventComplete(DataBase & data)328 void EventReporter::ReportEventComplete(DataBase& data)
329 {
330 std::string eventName = "INTERACTION_COMPLETED_LATENCY";
331 const auto& appPid = data.baseInfo.pid;
332 const auto& bundleName = data.baseInfo.bundleName;
333 const auto& processName = data.baseInfo.processName;
334 const auto& abilityName = data.baseInfo.abilityName;
335 const auto& pageUrl = data.baseInfo.pageUrl;
336 const auto& versionCode = data.baseInfo.versionCode;
337 const auto& versionName = data.baseInfo.versionName;
338 const auto& pageName = data.baseInfo.pageName;
339 const auto& sceneId = data.sceneId;
340 const auto& sourceType = GetSourceTypeName(data.sourceType);
341 auto inputTime = data.inputTime;
342 ConvertRealtimeToSystime(data.inputTime, inputTime);
343 const auto& animationStartLantency = (data.beginVsyncTime - data.inputTime) / NS_TO_MS;
344 const auto& animationEndLantency = (data.endVsyncTime - data.beginVsyncTime) / NS_TO_MS;
345 const auto& e2eLatency = animationStartLantency + animationEndLantency;
346 const auto& note = data.baseInfo.note;
347 const auto& extend = data.baseInfo.subHealthInfo.info;
348 const auto& reason = data.baseInfo.subHealthInfo.subHealthReason;
349 const auto& subHealthTime = data.baseInfo.subHealthInfo.subHealthTime;
350 XperfEventBuilder builder;
351 XperfEvent event = builder.EventName(eventName)
352 .EventType(HISYSEVENT_BEHAVIOR)
353 .Param(EVENT_KEY_APP_PID, appPid)
354 .Param(EVENT_KEY_BUNDLE_NAME, bundleName)
355 .Param(EVENT_KEY_PROCESS_NAME, processName)
356 .Param(EVENT_KEY_ABILITY_NAME, abilityName)
357 .Param(EVENT_KEY_PAGE_URL, pageUrl)
358 .Param(EVENT_KEY_VERSION_CODE, versionCode)
359 .Param(EVENT_KEY_VERSION_NAME, versionName)
360 .Param(EVENT_KEY_PAGE_NAME, pageName)
361 .Param(EVENT_KEY_SCENE_ID, sceneId)
362 .Param(EVENT_KEY_SOURCE_TYPE, sourceType)
363 .Param(EVENT_KEY_INPUT_TIME, static_cast<uint64_t>(inputTime))
364 .Param(EVENT_KEY_ANIMATION_START_LATENCY, static_cast<uint64_t>(animationStartLantency))
365 .Param(EVENT_KEY_ANIMATION_END_LATENCY, static_cast<uint64_t>(animationEndLantency))
366 .Param(EVENT_KEY_E2E_LATENCY, static_cast<uint64_t>(e2eLatency))
367 .Param(EVENT_KEY_NOTE, note)
368 .Param(EVENT_KEY_SUBHEALTH_INFO, extend)
369 .Param(EVENT_KEY_SUBHEALTH_REASON, reason)
370 .Param(EVENT_KEY_SUBHEALTH_TIME, static_cast<int32_t>(subHealthTime))
371 .Build();
372 XperfEventReporter reporter;
373 reporter.Report(ACE_DOMAIN, event);
374 XPERF_TRACE_SCOPED("INTERACTION_COMPLETED_LATENCY: sceneId =%s, inputTime=%lld(ms),"
375 "e2eLatency=%lld(ms)", sceneId.c_str(),
376 static_cast<long long>(inputTime), static_cast<long long>(e2eLatency));
377 }
378
ReportEventJankFrame(DataBase & data)379 void EventReporter::ReportEventJankFrame(DataBase& data)
380 {
381 std::string eventName = "INTERACTION_APP_JANK";
382 const auto& uniqueId = data.beginVsyncTime / NS_TO_MS;
383 auto startTime = data.beginVsyncTime;
384 ConvertRealtimeToSystime(data.beginVsyncTime, startTime);
385 const auto& durition = (data.endVsyncTime - data.beginVsyncTime) / NS_TO_MS;
386 const auto& maxFrameTime = data.maxFrameTime / NS_TO_MS;
387 XperfEventBuilder builder;
388 XperfEvent event = builder.EventName(eventName)
389 .EventType(HISYSEVENT_BEHAVIOR)
390 .Param(EVENT_KEY_UNIQUE_ID, static_cast<int32_t>(uniqueId)).Param(EVENT_KEY_SCENE_ID, data.sceneId)
391 .Param(EVENT_KEY_PROCESS_NAME, data.baseInfo.processName)
392 .Param(EVENT_KEY_MODULE_NAME, data.baseInfo.bundleName)
393 .Param(EVENT_KEY_ABILITY_NAME, data.baseInfo.abilityName).Param(EVENT_KEY_PAGE_URL, data.baseInfo.pageUrl)
394 .Param(EVENT_KEY_VERSION_CODE, data.baseInfo.versionCode)
395 .Param(EVENT_KEY_VERSION_NAME, data.baseInfo.versionName)
396 .Param(EVENT_KEY_PAGE_NAME, data.baseInfo.pageName)
397 .Param(EVENT_KEY_STARTTIME, static_cast<uint64_t>(startTime))
398 .Param(EVENT_KEY_DURITION, static_cast<uint64_t>(durition))
399 .Param(EVENT_KEY_TOTAL_FRAMES, data.totalFrames).Param(EVENT_KEY_TOTAL_MISSED_FRAMES, data.totalMissed)
400 .Param(EVENT_KEY_MAX_FRAMETIME, static_cast<uint64_t>(maxFrameTime))
401 .Param(EVENT_KEY_MAX_FRAMETIME_SINCE_START, static_cast<uint64_t>(data.maxFrameTimeSinceStart))
402 .Param(EVENT_KEY_MAX_HITCH_TIME, static_cast<uint64_t>(data.maxHitchTime))
403 .Param(EVENT_KEY_MAX_HITCH_TIME_SINCE_START, static_cast<uint64_t>(data.maxHitchTimeSinceStart))
404 .Param(EVENT_KEY_MAX_SEQ_MISSED_FRAMES, data.maxSuccessiveFrames)
405 .Param(EVENT_KEY_NOTE, data.baseInfo.note).Param(EVENT_KEY_DISPLAY_ANIMATOR, data.isDisplayAnimator)
406 .Param(EVENT_KEY_SUBHEALTH_INFO, data.baseInfo.subHealthInfo.info)
407 .Param(EVENT_KEY_SUBHEALTH_REASON, data.baseInfo.subHealthInfo.subHealthReason)
408 .Param(EVENT_KEY_SUBHEALTH_TIME, static_cast<int32_t>(data.baseInfo.subHealthInfo.subHealthTime))
409 .Build();
410 XperfEventReporter reporter;
411 reporter.Report(ACE_DOMAIN, event);
412 XPERF_TRACE_SCOPED("INTERACTION_APP_JANK: sceneId =%s, startTime=%lld(ms),"
413 "maxFrameTime=%lld(ms), pageName=%s", data.sceneId.c_str(), static_cast<long long>(startTime),
414 static_cast<long long>(maxFrameTime), data.baseInfo.pageName.c_str());
415 #ifdef RESOURCE_SCHEDULE_SERVICE_ENABLE
416 if (data.isDisplayAnimator && maxFrameTime > MAX_JANK_FRAME_TIME) {
417 ReportAppFrameDropToRss(true, data.baseInfo.bundleName, maxFrameTime);
418 }
419 #endif // RESOURCE_SCHEDULE_SERVICE_ENABLE
420 }
421
ReportStatsJankFrame(int64_t startTime,int64_t duration,const std::vector<uint16_t> & jank,const BaseInfo & baseInfo,uint32_t jankStatusVersion)422 void EventReporter::ReportStatsJankFrame(int64_t startTime, int64_t duration, const std::vector<uint16_t>& jank,
423 const BaseInfo& baseInfo, uint32_t jankStatusVersion)
424 {
425 std::string eventName = "JANK_STATS_APP";
426 auto app_version_code = baseInfo.versionCode;
427 auto app_version_name = baseInfo.versionName;
428 auto packageName = baseInfo.bundleName;
429 auto abilityName = baseInfo.abilityName;
430 auto pageUrl = baseInfo.pageUrl;
431 XperfEventBuilder builder;
432 XperfEvent event = builder.EventName(eventName)
433 .EventType(HISYSEVENT_STATISTIC)
434 .Param(EVENT_KEY_STARTTIME, startTime)
435 .Param(STATISTIC_DURATION, duration)
436 .Param(EVENT_KEY_VERSION_CODE, app_version_code)
437 .Param(EVENT_KEY_VERSION_NAME, app_version_name)
438 .Param(EVENT_KEY_BUNDLE_NAME, packageName)
439 .Param(EVENT_KEY_ABILITY_NAME, abilityName)
440 .Param(EVENT_KEY_PAGE_URL, pageUrl)
441 .Param(EVENT_KEY_JANK_STATS, jank)
442 .Param(EVENT_KEY_JANK_STATS_VER, jankStatusVersion)
443 .Build();
444 XperfEventReporter reporter;
445 reporter.Report(ACE_DOMAIN, event);
446 }
447
ReportJankFrameFiltered(JankInfo & info)448 void EventReporter::ReportJankFrameFiltered(JankInfo& info)
449 {
450 std::string eventName = "JANK_FRAME_FILTERED";
451 const auto& bundleName = info.baseInfo.bundleName;
452 const auto& processName = info.baseInfo.processName;
453 const auto& abilityName = info.baseInfo.abilityName;
454 const auto& pageUrl = info.baseInfo.pageUrl;
455 const auto& versionCode = info.baseInfo.versionCode;
456 const auto& versionName = info.baseInfo.versionName;
457 const auto& pageName = info.baseInfo.pageName;
458 const auto& skippedFrameTime = info.skippedFrameTime;
459 const auto& windowName = info.windowName;
460 XperfEventBuilder builder;
461 XperfEvent event = builder.EventName(eventName)
462 .EventType(HISYSEVENT_BEHAVIOR)
463 .Param(EVENT_KEY_PROCESS_NAME, processName)
464 .Param(EVENT_KEY_MODULE_NAME, bundleName)
465 .Param(EVENT_KEY_ABILITY_NAME, abilityName)
466 .Param(EVENT_KEY_PAGE_URL, pageUrl)
467 .Param(EVENT_KEY_VERSION_CODE, versionCode)
468 .Param(EVENT_KEY_VERSION_NAME, versionName)
469 .Param(EVENT_KEY_PAGE_NAME, pageName)
470 .Param(EVENT_KEY_SKIPPED_FRAME_TIME, static_cast<uint64_t>(skippedFrameTime))
471 .Build();
472 XperfEventReporter reporter;
473 reporter.Report(ACE_DOMAIN, event);
474 XPERF_TRACE_SCOPED("JANK_FRAME_FILTERED: skipppedFrameTime=%lld(ms), windowName=%s",
475 static_cast<long long>(skippedFrameTime / NS_TO_MS), windowName.c_str());
476 }
477
ReportJankFrameUnFiltered(JankInfo & info)478 void EventReporter::ReportJankFrameUnFiltered(JankInfo& info)
479 {
480 std::string eventName = "JANK_FRAME_UNFILTERED";
481 const auto& bundleName = info.baseInfo.bundleName;
482 const auto& processName = info.baseInfo.processName;
483 const auto& abilityName = info.baseInfo.abilityName;
484 const auto& pageUrl = info.baseInfo.pageUrl;
485 const auto& versionCode = info.baseInfo.versionCode;
486 const auto& versionName = info.baseInfo.versionName;
487 const auto& pageName = info.baseInfo.pageName;
488 const auto& skippedFrameTime = info.skippedFrameTime;
489 const auto& realSkippedFrameTime = info.realSkippedFrameTime;
490 const auto& windowName = info.windowName;
491 const auto& sceneId = info.sceneId;
492 const auto& extend = info.baseInfo.subHealthInfo.info;
493 const auto& reason = info.baseInfo.subHealthInfo.subHealthReason;
494 const auto& subHealthTime = info.baseInfo.subHealthInfo.subHealthTime;
495 const auto& sceneTag = info.sceneTag;
496 const auto& vsyncTime = info.vsyncTime;
497 XperfEventBuilder builder;
498 XperfEvent event = builder.EventName(eventName)
499 .EventType(HISYSEVENT_BEHAVIOR)
500 .Param(EVENT_KEY_PROCESS_NAME, processName)
501 .Param(EVENT_KEY_MODULE_NAME, bundleName)
502 .Param(EVENT_KEY_ABILITY_NAME, abilityName)
503 .Param(EVENT_KEY_PAGE_URL, pageUrl)
504 .Param(EVENT_KEY_VERSION_CODE, versionCode)
505 .Param(EVENT_KEY_VERSION_NAME, versionName)
506 .Param(EVENT_KEY_PAGE_NAME, pageName)
507 .Param(EVENT_KEY_FILTER_TYPE, sceneTag)
508 .Param(EVENT_KEY_SCENE_ID, sceneId)
509 .Param(EVENT_KEY_REAL_SKIPPED_FRAME_TIME, static_cast<uint64_t>(realSkippedFrameTime))
510 .Param(EVENT_KEY_SKIPPED_FRAME_TIME, static_cast<uint64_t>(skippedFrameTime))
511 .Param(EVENT_KEY_SUBHEALTH_INFO, extend)
512 .Param(EVENT_KEY_SUBHEALTH_REASON, reason)
513 .Param(EVENT_KEY_SUBHEALTH_TIME, static_cast<int32_t>(subHealthTime))
514 .Param(EVENT_KEY_VSYNC_TIME, static_cast<uint64_t>(vsyncTime))
515 .Build();
516 XperfEventReporter reporter;
517 reporter.Report(ACE_DOMAIN, event);
518 XPERF_TRACE_SCOPED("JANK_FRAME_UNFILTERED: skipppedFrameTime=%lld(ms), windowName=%s, filterType=%" PRIu64
519 ",vsyncTime=%lld(ns)", static_cast<long long>(skippedFrameTime / NS_TO_MS), windowName.c_str(),
520 sceneTag, static_cast<long long>(vsyncTime));
521 }
522
523 #ifdef RESOURCE_SCHEDULE_SERVICE_ENABLE
ReportAppFrameDropToRss(const bool isInteractionJank,const std::string & bundleName,const int64_t maxFrameTime)524 void EventReporter::ReportAppFrameDropToRss(const bool isInteractionJank, const std::string &bundleName,
525 const int64_t maxFrameTime)
526 {
527 uint32_t eventType = ResourceSchedule::ResType::RES_TYPE_APP_FRAME_DROP;
528 int32_t subType = isInteractionJank ? ResourceSchedule::ResType::AppFrameDropType::INTERACTION_APP_JANK
529 : ResourceSchedule::ResType::AppFrameDropType::JANK_FRAME_APP;
530 std::unordered_map<std::string, std::string> payload = {
531 { "bundleName", bundleName },
532 { "maxFrameTime", std::to_string(maxFrameTime) },
533 };
534 ResourceSchedule::ResSchedClient::GetInstance().ReportData(eventType, subType, payload);
535 }
536 #endif // RESOURCE_SCHEDULE_SERVICE_ENABLE
537
ReportImageLoadStat(const ImageLoadStat & stat)538 void EventReporter::ReportImageLoadStat(const ImageLoadStat& stat)
539 {
540 XperfEventBuilder builder;
541 XperfEvent event = builder.EventName("SCROLL_IMAGE_STAT")
542 .EventType(HISYSEVENT_STATISTIC)
543 .Param(KEY_SCROLL_START_TIME, stat.startTime)
544 .Param(KEY_SCROLL_END_TIME, stat.endTime)
545 .Param(KEY_TOTAL_NUM, stat.totalNum)
546 .Param(KEY_FAILED_NUM, stat.failedNum)
547 .Param(KEY_TOTAL_SIZE, stat.totalSize)
548 .Param(KEY_FAILED_SIZE, stat.failedSize)
549 .Param(KEY_TYPE_DETAILS, stat.typeDetails)
550 .Build();
551 XperfEventReporter reporter;
552 reporter.Report(PERFORMANCE_DOMAIN, event);
553 }
554
ReportSurfaceInfo(const SurfaceInfo & surface)555 void EventReporter::ReportSurfaceInfo(const SurfaceInfo& surface)
556 {
557 XperfEventBuilder builder;
558 XperfEvent event = builder.EventName("SURFACE_ATTACH")
559 .EventType(HISYSEVENT_BEHAVIOR)
560 .Param(KEY_PID, surface.pid)
561 .Param(EVENT_KEY_BUNDLE_NAME, surface.bundleName)
562 .Param(EVENT_KEY_UNIQUE_ID, surface.uniqueId)
563 .Param(KEY_SURFACE_NAME, surface.surfaceName)
564 .Param(KEY_COMPONENT_NAME, surface.componentName)
565 .Build();
566 XperfEventReporter reporter;
567 reporter.Report(ACE_DOMAIN, event);
568 }
569 }
570 }