diff --git a/common/include/frame_trace.h b/common/include/frame_trace.h new file mode 100644 index 0000000000000000000000000000000000000000..091eddbfcd9c119ac38038434a9ea17bab31cee1 --- /dev/null +++ b/common/include/frame_trace.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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. + */ + +#ifndef FRAME_TRACE_H +#define FRAME_TRACE_H + +#include "bytrace.h" + +#include +#include + +#define RME_SCOPED_TRACE(fmt, ...) RmeScopedTrace rmeScopedTrace(fmt, ##__VA_ARGS__) +#ifdef RME_DEBUG +#define RME_DEBUG_SCOPED_TRACE(fmt, ...) RmeScopedTrace rmeScopedTrace(fmt, ##__VA_ARGS__) +#else +#define RME_DEBUG_SCOPED_TRACE(fmt, ...) +#endif + +#define RME_FUNCTION_TRACE() RME_SCOPED_TRACE(__func__) +#define RME_SCOPED_TRACE_BEGIN(fmt, ...) RmeTraceBeginWithArgs(fmt, ##__VA_ARGS__) +#define RME_SCOPED_TRACE_END() RmeTraceEnd() + +namespace OHOS { +namespace RME { +bool RmeTraceEnable(); +void RmeTraceBegin(const char* name); +bool RmeTraceBeginWithArgs(const char* format, ...) __attribute__((__format__(printf, 1, 2))); +bool RmeTraceGeginWithArgvs(const char* format, va_list args); +void RmeTraceEnd(); + +class RmeScopedTrace final { +public: + explicit RmeScopedTrace(const char* format, ...) __attribute__((__format__(printf, 2, 3))); + ~RmeScopedTrace(); + +private: + bool traceEnabled_ { false }; +}; +} // namespace RME +} // namespace OHOS + + +#endif diff --git a/common/include/rtg_interface.h b/common/include/rtg_interface.h index 2a38b352e91e0582d239694ac0684e5559f0cde4..f409dc793eba752d6d798d1ebf80e0ecc0d42df8 100644 --- a/common/include/rtg_interface.h +++ b/common/include/rtg_interface.h @@ -89,8 +89,8 @@ extern "C"{ int EnableRtg(bool flag); //-----for frame rtg-----// int CreateNewRtgGrp(int prioType = 0, int rtNum = 0); // Return GrpId if success - int AddThreadToRtg(int tid, int grpId); - int AddThreadsToRtg(vector tids, int grpId); + int AddThreadToRtg(int tid, int grpId, int prioType = 0); + int AddThreadsToRtg(vector tids, int grpId, int prioType = 0); int RemoveRtgThread(int tid); int ClearRtgGrp(int grpId); int DestroyRtgGrp(int grpId); diff --git a/common/src/frame_trace.cpp b/common/src/frame_trace.cpp new file mode 100644 index 0000000000000000000000000000000000000000..69b3ed8851e1c58c12c602da9b248469f23a3463 --- /dev/null +++ b/common/src/frame_trace.cpp @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2022 Huawei Device Co., Ltd. + * 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 "frame_trace.h" + +#include +#include + +namespace OHOS { +namespace RME { +namespace { +const size_t MAX_STRING_SIZE = 128; +} + +bool RmeTraceEnable() +{ + return true; +} + +void RmeTraceBegin(const char* name) +{ + if (name == nullptr) { + return; + } + std::string nameStr(name); + StartTrace(BYTRACE_TAG_ACE, nameStr); +} + +void RmeTraceEnd() +{ + if (RmeTraceEnable()) { + FinishTrace(BYTRACE_TAG_ACE); + } +} + +bool RmeTraceBeginWithArgv(const char* format, va_list args) +{ + char name[MAX_STRING_SIZE] = { 0 }; + if (vsnprintf_s(name, sizeof(name), sizeof(name) - 1, format, args) < 0) { + return false; + } + RmeTraceBegin(name); + return true; +} + +bool RmeTraceBeginWithArgs(const char* format, ...) +{ + if (RmeTraceEnable()) { + va_list args; + va_start(args, format); + bool retVal = RmeTraceBeginWithArgv(format, args); + va_end(args); + return retVal; + } + return false; +} + +RmeScopedTrace::RmeScopedTrace(const char* format, ...) : traceEnabled_(RmeTraceEnable()) +{ + if (traceEnabled_) { + va_list args; + va_start(args, format); + traceEnabled_ = RmeTraceBeginWithArgv(format, args); + va_end(args); + } +} + +RmeScopedTrace::~RmeScopedTrace() +{ + if (traceEnabled_) { + RmeTraceEnd(); + } +} + +} // namespace RME +} // namespace OHOS diff --git a/frameworks/core/frame_aware_collector/include/rme_core_sched.h b/frameworks/core/frame_aware_collector/include/rme_core_sched.h index 5324cdbeca5a13d87ea89ecc05007e5766e59f26..66d678b12858f022f14db1c60b3a81942f3aa24b 100644 --- a/frameworks/core/frame_aware_collector/include/rme_core_sched.h +++ b/frameworks/core/frame_aware_collector/include/rme_core_sched.h @@ -18,6 +18,7 @@ #include #include "rme_log_domain.h" +#include "frame_trace.h" namespace OHOS { namespace RME { @@ -49,6 +50,8 @@ public: private: int m_currentPid = -1; int m_currentRtg = -1; + int m_renderTid = -1; + int m_uiTid = -1; }; } // namespace RME } // namespace OHOS diff --git a/frameworks/core/frame_aware_collector/include/rme_scene_sched.h b/frameworks/core/frame_aware_collector/include/rme_scene_sched.h index 2fccfbe885524c97561e749a86241a494da412b1..d94660dc1753c291a6552a205aa22480da6d16c7 100644 --- a/frameworks/core/frame_aware_collector/include/rme_scene_sched.h +++ b/frameworks/core/frame_aware_collector/include/rme_scene_sched.h @@ -19,7 +19,6 @@ #include "frame_scene_sched.h" #include "frame_window_mgr.h" #include "rme_core_sched.h" -#include "rme_log_domain.h" namespace OHOS { namespace RME { diff --git a/frameworks/core/frame_aware_collector/src/rme_core_sched.cpp b/frameworks/core/frame_aware_collector/src/rme_core_sched.cpp index 5e179fc757aeca263a5bd29ff13644b0148a9f45..dd78872996877a6dca705ae900e5c844a425b72d 100644 --- a/frameworks/core/frame_aware_collector/src/rme_core_sched.cpp +++ b/frameworks/core/frame_aware_collector/src/rme_core_sched.cpp @@ -34,23 +34,24 @@ RmeCoreSched::~RmeCoreSched() bool RmeCoreSched::Init() { + RmeTraceBegin("FrameS-Init"); int ret = GetRtgEnable(); if (ret > 0) { RME_LOGE("[Init]: rtgEnabled! scheme Open!ret: %{public}d", ret); } else { RME_LOGE("[Init]: do not enabled!ret: %{public}d", ret); } + RmeTraceEnd(); return ret; } void RmeCoreSched::BeginFlushAnimation() { m_currentPid = getpid(); - int tid = gettid(); if (m_currentRtg == -1) { m_currentRtg = SearchRtgForTid(m_currentPid); if (m_currentRtg <= 0) { - RME_LOGE("[BeginFlushAnimation]:Search rtg failed!pid %{public}d,Rtg: %{public}d", + RME_LOGE("[BeginFlushAnimation]:Search rtg empty!pid %{public}d,Rtg: %{public}d", m_currentPid, m_currentRtg); return; } else { @@ -58,8 +59,10 @@ void RmeCoreSched::BeginFlushAnimation() } } int ret = BeginFrameFreq(m_currentRtg, 0); - RME_LOGI("[BeginFlushAnimation]:BeginFrameFreq,Rtg:%{public}d,Pid:%{public}d,tid:%{public}d, ret:%{public}d!", - m_currentRtg, m_currentPid, tid, ret); + RmeTraceBegin(("FrameS-Begin&AddThread-rtg:" + to_string(m_currentRtg) + " ret:" + to_string(ret)).c_str()); + m_uiTid = gettid(); + AddThreadToRtg(m_uiTid, m_currentRtg); + RmeTraceEnd(); return; } @@ -67,7 +70,9 @@ void RmeCoreSched::EndFlushAnimation() {} void RmeCoreSched::BeginFlushBuild() { + RmeTraceBegin(("FrameS-SetMargin-rtg:" + to_string(m_currentRtg) + " margin:" + to_string(CPU_MARGIN_THREE)).c_str()); SetMargin(m_currentRtg, CPU_MARGIN_THREE); + RmeTraceEnd(); } void RmeCoreSched::EndFlushBuild() {} @@ -78,14 +83,18 @@ void RmeCoreSched::EndFlushLayout() {} void RmeCoreSched::BeginFlushRender() { + RmeTraceBegin(("FrameS-SetMargin-rtg:" + to_string(m_currentRtg) + " margin:" + to_string(CPU_MARGIN_FIVE)).c_str()); SetMargin(m_currentRtg, CPU_MARGIN_FIVE); + RmeTraceEnd(); } void RmeCoreSched::EndFlushRender() {} void RmeCoreSched::BeginFlushRenderFinish() { + RmeTraceBegin(("FrameS-SetMargin-rtg:" + to_string(m_currentRtg) + " margin:" + to_string(CPU_MARGIN_SEVEN)).c_str()); SetMargin(m_currentRtg, CPU_MARGIN_SEVEN); + RmeTraceEnd(); } void RmeCoreSched::EndFlushRenderFinish() {} @@ -97,35 +106,33 @@ void RmeCoreSched::ProcessCommandsStart() {} void RmeCoreSched::AnimateStart() { if (m_currentRtg <= 0) { - RME_LOGE("[AnimateStart]: search rtg error! Rtg:%{public}d, Pid:%{public}d", m_currentRtg, m_currentPid); + RME_LOGE("[AnimateStart]: search rtg empty! Rtg:%{public}d, Pid:%{public}d", m_currentRtg, m_currentPid); return; } - int rendertid = gettid(); - int ret = AddThreadToRtg(rendertid, m_currentRtg); - if (ret) { // 1 means false. - RME_LOGE("[AnimateStart]:add rtg failed! rtGrp: %{public}d, rendertid: %{public}d, m_currentPid:%{public}d", - m_currentRtg, rendertid, m_currentPid); - } else { - RME_LOGI("[AnimateStart]:add rtg SUCESS! rendertid:%{public}d, rtGrp:%{public}d", rendertid, m_currentRtg); - } + m_renderTid = gettid(); + int ret = AddThreadToRtg(m_renderTid, m_currentRtg); + RmeTraceBegin(("FrameS-Add rtg:" + to_string(m_currentRtg) + " ret:" + to_string(ret)).c_str()); + RmeTraceEnd(); } void RmeCoreSched::RenderStart() { + RmeTraceBegin(("FrameS-SetMargin:" + to_string(m_currentRtg) + " margin:" + to_string(CPU_MARGIN_THREE)).c_str()); SetMargin(m_currentRtg, CPU_MARGIN_THREE); + RmeTraceEnd(); } void RmeCoreSched::SendCommandsStart() { int pid = getpid(); if (m_currentRtg <= 0) { - RME_LOGE("[SendCommandStart]: m_currentRtg error! rtGrp:%{public}d, m_currentPid:%{public}d, pid:%{public}d!", + RME_LOGW("[SendCommandStart]: search rtg empty! rtGrp:%{public}d, m_currentPid:%{public}d, pid:%{public}d!", m_currentRtg, m_currentPid, pid); return; } int ret = EndFrameFreq(m_currentRtg); - RME_LOGI("[SendCommandsStart]: set EndFrameFreq, ret: %{public}d, m_currentPid:%{publid}d, pid:%{public}d!", - ret, m_currentPid, pid); + RmeTraceBegin(("FrameS-EndFrameFreq-rtg:" + to_string(m_currentRtg)+" ret:" + to_string(ret)).c_str()); + RmeTraceEnd(); } } // namespace RME } // OHOS diff --git a/frameworks/core/frame_aware_collector/src/rme_scene_sched.cpp b/frameworks/core/frame_aware_collector/src/rme_scene_sched.cpp index cd3188d6f8cf133e1449741f3b52491c600acf64..0051b451528bc781dc5a51c1646088a011254b1f 100644 --- a/frameworks/core/frame_aware_collector/src/rme_scene_sched.cpp +++ b/frameworks/core/frame_aware_collector/src/rme_scene_sched.cpp @@ -17,7 +17,6 @@ namespace OHOS { namespace RME { -DEFINE_RMELOG_INTELLISENSE("ueaClient-RmeSceneSched"); RmeSceneSched::RmeSceneSched() :curWorkingStatus(0), rmeCoreSched(nullptr) @@ -51,7 +50,6 @@ void RmeSceneSched::BeginFlushAnimation() } if (curWorkingStatus == 1) { rmeCoreSched->BeginFlushAnimation(); - RME_LOGI("[BeginFlushAnimation]:RmeSceneSched send msg success!"); } } @@ -150,7 +148,6 @@ void RmeSceneSched::SendCommandsStart() { if (curWorkingStatus == 1) { rmeCoreSched->SendCommandsStart(); - RME_LOGI("[SendCommandsStart]:RmeSceneSched send msg success!"); } } } // namespace RME diff --git a/frameworks/core/frame_aware_policy/src/intellisense_server.cpp b/frameworks/core/frame_aware_policy/src/intellisense_server.cpp index 846b933c9f7d82860db6e77da1af40f9fa24ed5d..fb855851d7239be909ef696099c70346b7096998 100644 --- a/frameworks/core/frame_aware_policy/src/intellisense_server.cpp +++ b/frameworks/core/frame_aware_policy/src/intellisense_server.cpp @@ -21,6 +21,7 @@ #include "rtg_msg_mgr.h" #include "rme_log_domain.h" #include "app_info_mgr.h" +#include "frame_trace.h" namespace OHOS { namespace RME { @@ -61,6 +62,7 @@ bool IntelliSenseServer::ReadXml() void IntelliSenseServer::ReportMessage(std::string appName, std::string processName, int pid, AppStateUpdateReason reason) { + RME_FUNCTION_TRACE(); int rtGrp = AppInfoMgr::GetInstance().GetAppRtgrp(pid); switch (reason) { case AppStateUpdateReason::APP_FOREGROUND: @@ -93,6 +95,7 @@ void IntelliSenseServer::ReportMessage(std::string appName, std::string processN void IntelliSenseServer::ReportWindowFocus(const int pid, int isFocus) { + RME_FUNCTION_TRACE(); int rtGrp = AppInfoMgr::GetInstance().GetAppRtgrp(pid); switch (isFocus) { case static_cast(WindowState::FOCUS_YES): // isFocus: 0 @@ -119,6 +122,7 @@ void IntelliSenseServer::ReportWindowFocus(const int pid, int isFocus) void IntelliSenseServer::ReportProcessInfo(const int pid, const int tid, ThreadState state) { + RME_FUNCTION_TRACE(); switch (state) { case ThreadState::DIED: { diff --git a/frameworks/core/frame_aware_policy/src/rtg_msg_mgr.cpp b/frameworks/core/frame_aware_policy/src/rtg_msg_mgr.cpp index 212889ab752459a5d4801994b4c0b869ebabf875..0d60ab67b5015a95d376c6f2c3ad5c4b4b6cf451 100644 --- a/frameworks/core/frame_aware_policy/src/rtg_msg_mgr.cpp +++ b/frameworks/core/frame_aware_policy/src/rtg_msg_mgr.cpp @@ -14,12 +14,14 @@ */ #include "rtg_msg_mgr.h" +#include "frame_trace.h" namespace OHOS { namespace RME { namespace { constexpr int PRIO_TYPE = 0; constexpr int RT_NUM = 0; + constexpr int PID_PRIO_TYPE = 2; } DEFINE_RMELOG_INTELLISENSE("ueaServer-RtgMsgMgr"); IMPLEMENT_SINGLE_INSTANCE(RtgMsgMgr); @@ -35,25 +37,31 @@ void RtgMsgMgr::Init() int RtgMsgMgr::OnForeground(const std::string appName, const int pid) { // for multiwindow + RmeTraceBegin(("FrameC-createRtgGrp-pid"+ to_string(pid)).c_str()); int rtGrp = CreateNewRtgGrp(PRIO_TYPE, RT_NUM); if (rtGrp <= 0) { RME_LOGE("[OnForeground]: createNewRtgGroup failed! rtGrp:%{public}d, pid: %{public}d", rtGrp, pid); return rtGrp; } - int ret = AddThreadToRtg(pid, rtGrp); // add ui thread + RmeTraceEnd(); + RmeTraceBegin(("FrameC-addThread-pid:" + to_string(pid), +" rtgrp:" + to_string(rtGrp)).c_str()); + int ret = AddThreadToRtg(pid, rtGrp, PID_PRIO_TYPE); // add ui thread if (ret != 0) { RME_LOGE("[OnFore]:add thread fail! pid:%{public}d,rtg:%{public}d!ret:%{publid}d", pid, rtGrp, ret); } + RmeTraceEnd(); return rtGrp; } void RtgMsgMgr::OnBackground(const std::string appName, const int pid, const int grpId) { + RmeTraceBegin(("FrameC-destroyRtgGrp-grpId" + to_string(grpId)).c_str()); if (grpId <= 0) { RME_LOGE("[OnBackground]:do not find grpid, pid:%{public}d, grpId:%{public}d", pid, grpId); return; } DestroyRtgGrp(grpId); + RmeTraceEnd(); } void RtgMsgMgr::ProcessStart(const int tid, const int grpId) diff --git a/interfaces/innerkits/frameintf/BUILD.gn b/interfaces/innerkits/frameintf/BUILD.gn index ef12a2ea0595a13b1192e6985f2b5cad9aa87783..54b5154b81f03dfc68e2401b8f566dab68a2f5bf 100644 --- a/interfaces/innerkits/frameintf/BUILD.gn +++ b/interfaces/innerkits/frameintf/BUILD.gn @@ -35,6 +35,7 @@ ohos_shared_library("frame_ui_intf") { "${framework_path}/frame_aware_collector/src/frame_window_mgr.cpp", "${framework_path}/frame_aware_collector/src/rme_core_sched.cpp", "${framework_path}/frame_aware_collector/src/rme_scene_sched.cpp", + "${frame_aware_path}/common/src/frame_trace.cpp", "frame_ui_intf.cpp", ] @@ -79,6 +80,7 @@ ohos_shared_library("frame_msg_intf") { "${framework_path}/frame_aware_policy/src/intellisense_server.cpp", "${framework_path}/frame_aware_policy/src/para_config.cpp", "${framework_path}/frame_aware_policy/src/rtg_msg_mgr.cpp", + "${frame_aware_path}/common/src/frame_trace.cpp", "frame_msg_intf.cpp", ] diff --git a/interfaces/innerkits/frameintf/rtg_interface.cpp b/interfaces/innerkits/frameintf/rtg_interface.cpp index 90ce4083fb5c616d2464270ff8ea75e8e4826175..80a59b34b4021adfeae298edcac1e91e34bda9fd 100644 --- a/interfaces/innerkits/frameintf/rtg_interface.cpp +++ b/interfaces/innerkits/frameintf/rtg_interface.cpp @@ -122,7 +122,7 @@ int CreateNewRtgGrp(int prioType, int rtNum) return ret; } -int AddThreadToRtg(int tid, int grpId) +int AddThreadToRtg(int tid, int grpId, int prioType) { struct rtg_grp_data grp_data; int ret; @@ -136,17 +136,13 @@ int AddThreadToRtg(int tid, int grpId) grp_data.tids[0] = tid; grp_data.grp_id = grpId; grp_data.rtg_cmd = CMD_ADD_RTG_THREAD; + grp_data.prio_type = prioType; ret = ioctl(fd, CMD_ID_SET_RTG, &grp_data); - if (ret == 0) { - RME_LOGI("add rtg grp success"); - } else { - RME_LOGE("add tid %d to grp %d fail with ret %d", tid, grpId, ret); - } close(fd); return ret; } -int AddThreadsToRtg(vector tids, int grpId) +int AddThreadsToRtg(vector tids, int grpId, int prioType) { struct rtg_grp_data grp_data; int ret; @@ -162,6 +158,7 @@ int AddThreadsToRtg(vector tids, int grpId) grp_data.tid_num = num; grp_data.grp_id = grpId; grp_data.rtg_cmd = CMD_ADD_RTG_THREAD; + grp_data.prio_type = prioType; for (int i = 0; i < num; i++) { if (tids[i] < 0) { return -1; @@ -237,9 +234,9 @@ int DestroyRtgGrp(int GrpId) grp_data.grp_id = GrpId; ret = ioctl(fd, CMD_ID_SET_RTG, &grp_data); if ( ret < 0) { - RME_LOGE("create rtg grp failed, errno = %{public}d (%{public}s)", errno, strerror(errno)); + RME_LOGE("destroy rtg grp failed, errno = %{public}d (%{public}s)", errno, strerror(errno)); } else { - RME_LOGI("create rtg grp success, get rtg id %{public}d.", ret); + RME_LOGI("destroy rtg grp success, get rtg id:%{public}d, ret:%{public}d.", GrpId, ret); } close(fd); return ret; @@ -304,11 +301,6 @@ int BeginFrameFreq(int grpId, int stateParam) return fd; } ret = ioctl(fd, CMD_ID_BEGIN_FRAME_FREQ, &state_data); - if ( ret < 0) { - RME_LOGE("set BeginFrameFreq failed, errno = %{public}d (%{public}s)", errno, strerror(errno)); - } else { - RME_LOGI("set BeginFrameFreq success, get ret %{public}d.", ret); - } close(fd); return ret; } @@ -325,13 +317,7 @@ int EndFrameFreq(int grpId) return fd; } ret = ioctl(fd, CMD_ID_END_FRAME_FREQ, &state_data); - if ( ret < 0) { - RME_LOGE("set EndFrameFreq failed, errno = %{public}d (%{public}s)", errno, strerror(errno)); - } else { - RME_LOGI("set EndFrameFreq success, get ret %{public}d.", ret); - } close(fd); - return ret; } @@ -390,13 +376,7 @@ int SetMargin(int grpId, int stateParam) return fd; } ret = ioctl(fd, CMD_ID_SET_MARGIN, &state_data); - if ( ret < 0) { - RME_LOGE("set margin failed, errno = %{public}d (%{public}s)", errno, strerror(errno)); - } else { - RME_LOGI("set margin success, get ret %{public}d.", ret); - } close(fd); - return ret; }