From 81dfc5bec267e0fc51bf100a5b17489ba99ec5e1 Mon Sep 17 00:00:00 2001 From: liuyuxiu Date: Wed, 7 Aug 2024 11:22:36 +0800 Subject: [PATCH 01/10] qos_manager Signed-off-by: liuyuxiu --- .../include/concurrent_task_type.h | 2 + .../src/concurrent_task_service_proxy.cpp | 2 +- services/include/concurrent_task_controller.h | 21 +- services/include/qos_interface.h | 1 + .../src/.concurrent_task_controller.cpp.swp | Bin 0 -> 28672 bytes services/src/: | 1153 +++++++++++++++++ services/src/concurrent_task_controller.cpp | 191 +-- services/src/concurrent_task_service_stub.cpp | 2 +- .../phone/concurrent_task_controller_test.cpp | 4 +- 9 files changed, 1280 insertions(+), 96 deletions(-) create mode 100644 services/src/.concurrent_task_controller.cpp.swp create mode 100644 services/src/: diff --git a/frameworks/concurrent_task_client/include/concurrent_task_type.h b/frameworks/concurrent_task_client/include/concurrent_task_type.h index a83277f..94cb126 100644 --- a/frameworks/concurrent_task_client/include/concurrent_task_type.h +++ b/frameworks/concurrent_task_client/include/concurrent_task_type.h @@ -53,6 +53,8 @@ enum QueryIntervalItem { QUERY_EXECUTOR_START = 5, QUERY_RENDER_SERVICE_MAIN = 6, QUERY_RENDER_SERVICE_RENDER = 7, + QUERY_SELF_RENDER_REMOVE_THREAD = 8, + QUERY_SELF_RENDER_ADD_THREAD = 9, QURRY_TYPE_MAX, }; diff --git a/frameworks/concurrent_task_client/src/concurrent_task_service_proxy.cpp b/frameworks/concurrent_task_client/src/concurrent_task_service_proxy.cpp index 8e0e4a8..6ba5a9b 100644 --- a/frameworks/concurrent_task_client/src/concurrent_task_service_proxy.cpp +++ b/frameworks/concurrent_task_client/src/concurrent_task_service_proxy.cpp @@ -53,7 +53,7 @@ void ConcurrentTaskServiceProxy::QueryInterval(int queryItem, IntervalReply& que CONCUR_LOGE("Write interface token failed in QueryInterval Proxy"); return; } - if (!data.WriteInt32(queryItem) || !data.WriteInt32(queryRs.tid)) { + if (!data.WriteInt32(queryItem) || !data.WriteInt32(queryRs.tid) || !data.WriteInt32(queryRs.paramA)) { CONCUR_LOGE("Write info failed in QueryInterval Proxy"); return; } diff --git a/services/include/concurrent_task_controller.h b/services/include/concurrent_task_controller.h index 5dadc7a..27dca04 100644 --- a/services/include/concurrent_task_controller.h +++ b/services/include/concurrent_task_controller.h @@ -31,6 +31,11 @@ namespace OHOS { namespace ConcurrentTask { class ForegroundAppRecord; +struct TaskConfig { + int pid; + unsigned int value; +}; + class TaskController { public: static TaskController& GetInstance(); @@ -59,6 +64,8 @@ private: void QueryRenderServiceRender(pid_t uid, pid_t pid, IntervalReply& queryRs); void QueryHardware(pid_t uid, pid_t pid, IntervalReply& queryRs); void QueryExecutorStart(pid_t uid, pid_t pid, IntervalReply& queryRs); + void QuerySelfRenderRemoveThread(pid_t uid, pid_t pid, IntervalReply& queryRs); + void QuerySelfRenderAddThread(pid_t uid, pid_t pid, IntervalReply& queryRs); void QueryHwc(pid_t uid, IntervalReply& queryRs); int GetRequestType(std::string strRequstType); void DealSystemRequest(int requestType, const Json::Value& payload); @@ -77,6 +84,7 @@ private: bool ConfigReaderInit(); bool ModifySystemRate(const Json::Value& payload); void SetAppRate(const Json::Value& payload); + void UpdateAllAppRate(int appRate); int FindRateFromInfo(int uiTid, const Json::Value& payload); void SetRenderServiceRate(const Json::Value& payload); void SetAppAndRenderServiceRate(int appRate, int rsRate); @@ -128,7 +136,7 @@ private: class ForegroundAppRecord { public: - explicit ForegroundAppRecord(int pid, int uiTid, bool createGrp = true); + explicit ForegroundAppRecord(int pid, int uiTid, int appRate = 120, bool createGrp = true); ~ForegroundAppRecord(); void AddKeyThread(int tid, int prio = PRIO_NORMAL); @@ -143,13 +151,24 @@ public: void SetGrpId(int grpId); bool IsValid(); void PrintKeyThreads(); + int AddSelfRenderTid(IntervalReply& queryRs); + int RemoveSelfRenderTid(IntervalReply& queryRs); + void UpdateRate(int appRate); private: int pid_ = 0; int grpId_ = 0; int rate_ = 0; int uiTid_ = 0; + bool isForeground_ = false; + bool selfRenderStop_ = false; + int selfRenderGrpId_ = -1; + std::unordered_set selfRenderTids_; + std::map selfRenderTidCheckQos_; std::unordered_set keyThreads_; + + void TryCreateSelfRenderGrp(); + int SetTaskSmt(int tid, unsigned int smt_type); }; } // namespace ConcurrentTask } // namespace OHOS diff --git a/services/include/qos_interface.h b/services/include/qos_interface.h index 42d8987..533c7ec 100644 --- a/services/include/qos_interface.h +++ b/services/include/qos_interface.h @@ -30,6 +30,7 @@ constexpr unsigned int SET_RTG_ENABLE = 1; constexpr unsigned int QOS_CTRL_IPC_MAGIC = 0xCC; constexpr unsigned int AUTH_CTRL_IPC_MAGIC = 0xCD; constexpr unsigned int RTG_SCHED_IPC_MAGIC = 0xAB; +constexpr char PERF_CTRL_MAGIC = 'x'; constexpr unsigned int AF_QOS_ALL = 0x0003; constexpr unsigned int AF_QOS_DELEGATED = 0x0001; diff --git a/services/src/.concurrent_task_controller.cpp.swp b/services/src/.concurrent_task_controller.cpp.swp new file mode 100644 index 0000000000000000000000000000000000000000..1468ae6c6f7bcca61c8a16079ba27854f378dc10 GIT binary patch literal 28672 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 I_jB6+0JSy-pa1{> literal 0 HcmV?d00001 diff --git a/services/src/: b/services/src/: new file mode 100644 index 0000000..c7cd9e2 --- /dev/null +++ b/services/src/: @@ -0,0 +1,1153 @@ +/* + * 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 +#include +#include +#include +#include +#include +#include +#include "accesstoken_kit.h" +#include "concurrent_task_log.h" +#include "rtg_interface.h" +#include "ipc_skeleton.h" +#include "parameters.h" +#include "concurrent_task_controller.h" + +using namespace OHOS::RME; +using namespace OHOS::Security::AccessToken; + +namespace OHOS { +namespace ConcurrentTask { +namespace { + const std::string INTERVAL_DDL = "persist.ffrt.interval.renderthread"; + const std::string INTERVAL_APP_RATE = "persist.ffrt.interval.appRate"; + const std::string INTERVAL_RS_RATE = "persist.ffrt.interval.rsRate"; + const std::string CONFIG_FILE_NAME = "etc/qos_manager/qos_manager_config.xml"; + constexpr int CURRENT_RATE = 120; + constexpr int PARAM_TYPE = 1; + constexpr int UNI_APP_RATE_ID = -1; + const char RTG_SCHED_IPC_MAGIC = 0xAB; + constexpr int RTG_TYPE_MAX = 3; + constexpr int RS_UID = 1003; + constexpr int EXECUTOR_LIMIT_NUM = 3; + constexpr int APP_TYPE_VIDEO = 10067; + constexpr int APP_TYPE_VIDEO_CLIP = 10026; + constexpr int APP_TYPE_INVALID = -1; +} + +#define SMT_EXPELLEE 0U +#define SMT_EXPELLER 2U +#define SET_TASK_NO_SMT 41 +#define CMD_ID_SET_RTG \ + _IOWR(RTG_SCHED_IPC_MAGIC, SET_RTG, struct rtg_str_data)\ +#define PERF_CTRL_SET_TASK_NO_SMT \ + _IOWR(PERF_CTRL_MAGIC, SET_TASK_NO_SMT, struct TaskConfig) + +TaskController& TaskController::GetInstance() +{ + static TaskController instance; + return instance; +} + +void TaskController::RequestAuth(const Json::Value& payload) +{ + { + std::lock_guard autolock(configReaderMutex_); + if (!configEnable_ && !ConfigReaderInit()) { + return; + } + } + pid_t uid = IPCSkeleton::GetInstance().GetCallingUid(); + auto bundleName = GetProcessNameByToken(); + if (configReader_->IsBundleNameAuth(bundleName) || configReader_->IsUidAuth(uid)) { + pid_t pid = IPCSkeleton::GetInstance().GetCallingPid(); + AuthSystemProcess(pid); + return; + } + CONCUR_LOGE("Invalid uid %{public}d, can't call RequestAuth", uid); +} + +void TaskController::ReportData(uint32_t resType, int64_t value, const Json::Value& payload) +{ + pid_t uid = IPCSkeleton::GetInstance().GetCallingUid(); + if (GetProcessNameByToken() != RESOURCE_SCHEDULE_PROCESS_NAME) { + CONCUR_LOGE("Invalid uid %{public}d, only RSS can call ReportData", uid); + return; + } + if (!CheckJsonValid(payload)) { + return; + } + std::string strRequstType = ""; + try { + strRequstType = payload["type"].asString(); + } catch (...) { + CONCUR_LOGE("Unexpected type format"); + return; + } + if (strRequstType.length() == 0) { + CONCUR_LOGE("Get payload type err"); + return; + } + int requstType = GetRequestType(strRequstType); + DealSystemRequest(requstType, payload); + PrintInfo(); +} + +void TaskController::QueryInterval(int queryItem, IntervalReply& queryRs) +{ + pid_t uid = IPCSkeleton::GetInstance().GetCallingUid(); + pid_t pid = IPCSkeleton::GetInstance().GetCallingPid(); + switch (queryItem) { + case QUERY_UI: + QueryUi(uid, queryRs); + break; + case QUERY_RENDER: + QueryRender(uid, queryRs); + break; + case QUERY_RENDER_SERVICE: + QueryRenderService(uid, queryRs); + break; + case QUERY_RENDER_SERVICE_MAIN: + QueryRenderServiceMain(uid, pid, queryRs); + break; + case QUERY_RENDER_SERVICE_RENDER: + QueryRenderServiceRender(uid, pid, queryRs); + break; + case QUERY_COMPOSER: + QueryHwc(uid, queryRs); + break; + case QUERY_HARDWARE: + QueryHardware(uid, pid, queryRs); + break; + case QUERY_EXECUTOR_START: + QueryExecutorStart(uid, pid, queryRs); + break; + case QUERY_SELF_RENDER_REMOVE_THREAD: + QuerySelfRenderRemoveThread(uid, pid, queryRs); + break; + case QUERY_SELF_RENDER_ADD_THREAD: + QuerySelfRenderAddThread(uid, pid, queryRs); + break; + default: + break; + } +} + +std::string TaskController::GetProcessNameByToken() +{ + AccessTokenID tokenID = IPCSkeleton::GetInstance().GetCallingTokenID(); + NativeTokenInfo tokenInfo; + if (AccessTokenKit::GetNativeTokenInfo(tokenID, tokenInfo) != AccessTokenKitRet::RET_SUCCESS) { + return ""; + } + return tokenInfo.processName; +} + +void TaskController::QueryUi(int uid, IntervalReply& queryRs) +{ + pid_t pid = IPCSkeleton::GetInstance().GetCallingPid(); + auto iter = GetRecordOfPid(pid); + if (iter == foregroundApp_.end()) { + CONCUR_LOGD("Query ui with pid %{public}d failed", pid); + return; + } + int grpId = iter->GetGrpId(); + if (grpId <= 0) { + CONCUR_LOGI("%{public}d Query ui with none grpid", pid); + queryRs.rtgId = -1; + } else { + queryRs.rtgId = grpId; + } + queryRs.bundleName = appBundleName[pid]; +} + +void TaskController::QueryRender(int uid, IntervalReply& queryRs) +{ + pid_t pid = IPCSkeleton::GetInstance().GetCallingPid(); + auto iter = GetRecordOfPid(pid); + if (iter == foregroundApp_.end()) { + CONCUR_LOGD("Query render with pid %{public}d failed", pid); + return; + } + int grpId = iter->GetGrpId(); + if (grpId <= 0) { + CONCUR_LOGI("%{public}d Query render with none grpid", pid); + queryRs.rtgId = -1; + } else { + queryRs.rtgId = grpId; + } +} + +void TaskController::QueryRenderService(int uid, IntervalReply& queryRs) +{ + if (uid != RS_UID) { + return; + } + int queryTid = queryRs.tid; + if (renderServiceMainGrpId_ <= 0) { + TryCreateRSMainGrp(); + CONCUR_LOGI("uid %{public}d query rs group failed and create %{public}d.", uid, renderServiceMainGrpId_); + if (renderServiceMainGrpId_ <= 0) { + CONCUR_LOGE("uid %{public}d create rs group failed", uid); + return; + } + } + + queryRs.rtgId = renderServiceMainGrpId_; + if (queryTid <= 0) { + return; + } + list::iterator iter = find(rsThreads_.begin(), rsThreads_.end(), queryTid); + if (iter != rsThreads_.end()) { + return; + } + queryRs.rtgId = renderServiceMainGrpId_; + int ret = AddThreadToRtg(queryTid, renderServiceMainGrpId_, PRIO_RT); + if (ret < 0) { + CONCUR_LOGE("uid %{public}d tid %{public}d join rs group failed", uid, queryTid); + return; + } + CONCUR_LOGI("uid %{public}d tid %{public}d join rs group success in Query", uid, queryTid); + SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); +} + +void TaskController::QueryRenderServiceMain(int uid, int pid, IntervalReply& queryRs) +{ + if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { + return; + } + if (!rsAuthed_) { + if (AuthSystemProcess(pid) != 0) { + return; + SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); +} + +void TaskController::QueryRenderServiceMain(int uid, int pid, IntervalReply& queryRs) +{ + if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { + return; + } + if (!rsAuthed_) { + if (AuthSystemProcess(pid) != 0) { + return; + SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); +} + +void TaskController::QueryRenderServiceMain(int uid, int pid, IntervalReply& queryRs) +{ + if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { + return; + } + if (!rsAuthed_) { + if (AuthSystemProcess(pid) != 0) { + return; + } + rsAuthed_ = true; + } + if (renderServiceMainGrpId_ <= 0) { + TryCreateRSMainGrp(); + CONCUR_LOGI("uid %{public}d query rs group failed and create %{public}d.", uid, renderServiceMainGrpId_); + if (renderServiceMainGrpId_ <= 0) { + CONCUR_LOGE("uid %{public}d create rs group failed", uid); + return; + } + } + queryRs.rtgId = renderServiceMainGrpId_; + if (renderServiceMainTid_ <= 0) { + renderServiceMainTid_ = queryRs.tid; + int ret = AddThreadToRtg(renderServiceMainTid_, renderServiceMainGrpId_, PRIO_RT); + if (ret < 0) { + CONCUR_LOGE("uid %{public}d tid %{public}d join rs group failed.", uid, renderServiceMainTid_); + } + } + SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); +} + +void TaskController::QueryRenderServiceRender(int uid, int pid, IntervalReply& queryRs) +{ + if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { + return; + } + if (renderServiceRenderGrpId_ <= 0) { + TryCreateRSRenderGrp(); + if (renderServiceRenderGrpId_ <= 0) { + CONCUR_LOGE("uid %{public}d create rs group failed", uid); + return; + } + } + queryRs.rtgId = renderServiceRenderGrpId_; + if (renderServiceRenderTid_ <= 0 || renderServiceRenderTid_ != queryRs.tid) { + renderServiceRenderTid_ = queryRs.tid; + int ret = AddThreadToRtg(renderServiceRenderTid_, renderServiceRenderGrpId_, PRIO_RT); + if (ret < 0) { + CONCUR_LOGE("uid %{public}d tid %{public}d join rs group failed.", uid, renderServiceMainGrpId_); + } + } + SetFrameRateAndPrioType(renderServiceRenderGrpId_, CURRENT_RATE, PARAM_TYPE); +} + +void TaskController::QueryHardware(int uid, int pid, IntervalReply& queryRs) +{ + if (uid != RS_UID) { + return; + } + if (hardwareGrpId_ < 0) { + return; + } + hardwareTid_ = queryRs.tid; + TryCreateRSMainGrp(); + int ret = AddThreadToRtg(hardwareTid_, renderServiceMainGrpId_, PRIO_RT); + if (ret < 0) { + CONCUR_LOGE("uid %{public}d tid %{public}d join hardware group failed.", uid, hardwareTid_); + return; + } + queryRs.rtgId = hardwareGrpId_; +} + +void TaskController::QueryExecutorStart(int uid, int pid, IntervalReply& queryRs) +{ + if (uid != RS_UID) { + return; + } + if (renderServiceMainGrpId_ < 0) { + return; + } + std::lock_guard lock(executorStartLock_); + if (executorNum_ >= EXECUTOR_LIMIT_NUM) { + return; + } + if (queryRs.tid <= 0) { + return; + } + int ret = AddThreadToRtg(queryRs.tid, renderServiceMainGrpId_, PRIO_RT); + if (ret < 0) { + CONCUR_LOGE("uid %{public}d tid %{public}d join executor group failed.", uid, renderServiceMainTid_); + return; + } + executorNum_++; + queryRs.rtgId = renderServiceMainGrpId_; +} + +void TaskController::QuerySelfRenderRemoveThread(int uid, int pid, IntervalReply& queryRs) +{ + auto iter = GetRecordOfPid(pid); + if (iter != foregroundApp_.end()) { + queryRs.paramA = iter->RemoveSelfRenderTid(queryRs); + if (queryRs.paramA != 0) { + CONCUR_LOGE("uid %{public}d pid %{public}d Query Self Render Remove Thread %{public}d failed: %{public}d", + uid, pid, queryRs.tid, queryRs.paramA); + } + } +} + +void TaskController::QuerySelfRenderAddThread(int uid, int pid, IntervalReply& queryRs) +{ + auto iter = GetRecordOfPid(pid); + if (iter != foregroundApp_.end()) { + queryRs.paramA = iter->AddSelfRenderTid(queryRs); + if (queryRs.paramA != 0) { + CONCUR_LOGE("uid %{public}d pid %{public}d Query Self Render Add Thread %{public}d failed: %{public}d", + uid, pid, queryRs.tid, queryRs.paramA); + } + } +} + +void TaskController::QueryHwc(int uid, IntervalReply& queryRs) +{ + pid_t pid = IPCSkeleton::GetInstance().GetCallingPid(); + auto iter = GetRecordOfPid(pid); + if (iter == foregroundApp_.end()) { + CONCUR_LOGD("Query ipc thread with pid %{public}d failed", pid); + return; + } + int grpId = iter->GetGrpId(); + if (grpId <= 0) { + CONCUR_LOGI("%{public}d Query ipc thread with none grpid", pid); + queryRs.rtgId = -1; + } else { + queryRs.rtgId = grpId; + } +} + +void TaskController::Init() +{ + TypeMapInit(); + qosPolicy_.Init(); + TryCreateRsGroup(); + + std::lock_guard autolock(configReaderMutex_); + if (!configEnable_) { + ConfigReaderInit(); + } +} + +bool TaskController::ConfigReaderInit() +{ + configReader_ = make_unique(); + if (!configReader_) { + CONCUR_LOGE("configReader_ initialize error!"); + return configEnable_; + } + + std::string realPath; + configReader_->GetRealConfigPath(CONFIG_FILE_NAME.c_str(), realPath); + if (realPath.empty() || !configReader_->LoadFromConfigFile(realPath)) { + CONCUR_LOGE("config load failed!"); + return configEnable_; + } + configEnable_ = true; + ddlSceneSchedSwitch_ = configReader_->GetPowerModeSchedSwitch(); + CONCUR_LOGI("deadline scene sched switch = %{public}d", ddlSceneSchedSwitch_); + return configEnable_; +} + +void TaskController::Release() +{ + msgType_.clear(); + appTypeCache_.clear(); + if (renderServiceMainGrpId_ > 0) { + DestroyRtgGrp(renderServiceMainGrpId_); + renderServiceMainGrpId_ = -1; + } + if (renderServiceRenderGrpId_ > 0) { + DestroyRtgGrp(renderServiceRenderGrpId_); + renderServiceRenderGrpId_ = -1; + } + ddlSceneSchedSwitch_ = false; + + std::lock_guard autolock(configReaderMutex_); + configReader_ = nullptr; +} + +void TaskController::TypeMapInit() +{ + msgType_.clear(); + msgType_.insert(pair("foreground", MSG_FOREGROUND)); + msgType_.insert(pair("background", MSG_BACKGROUND)); + msgType_.insert(pair("appStart", MSG_APP_START)); + msgType_.insert(pair("appKilled", MSG_APP_KILLED)); + msgType_.insert(pair("continuousStart", MSG_CONTINUOUS_TASK_START)); + msgType_.insert(pair("continuousEnd", MSG_CONTINUOUS_TASK_END)); + msgType_.insert(pair("getFocus", MSG_GET_FOCUS)); + msgType_.insert(pair("loseFocus", MSG_LOSE_FOCUS)); + msgType_.insert(pair("enterInteractionScene", MSG_ENTER_INTERACTION_SCENE)); + msgType_.insert(pair("exitInteractionScene", MSG_EXIT_INTERACTION_SCENE)); +} + +void TaskController::TryCreateRSMainGrp() +{ + if (renderServiceMainGrpId_ == -1) { + renderServiceMainGrpId_ = TryCreateSystemGroup(); + hardwareGrpId_ = renderServiceMainGrpId_; + } +} + +void TaskController::TryCreateRSRenderGrp() +{ + if (renderServiceRenderGrpId_ == -1) { + renderServiceRenderGrpId_ = TryCreateSystemGroup(); + } +} + +void TaskController::TryCreateRsGroup() +{ + TryCreateRSMainGrp(); + TryCreateRSRenderGrp(); +} + +int TaskController::TryCreateSystemGroup() +{ + if (!rtgEnabled_) { + rtgEnabled_ = EnableRtg(true) < 0 ? false : true; + if (!rtgEnabled_) { + CONCUR_LOGE("Rtg enable failed"); + return -1; + } + CONCUR_LOGI("Enable Rtg"); + } + int grpId = CreateNewRtgGrp(PRIO_RT, MAX_KEY_THREADS); + if (grpId <= 0) { + CONCUR_LOGI("CreateRsRtgGroup with RT failed, try change to normal type."); + grpId = CreateNewRtgGrp(PRIO_NORMAL, MAX_KEY_THREADS); + } + if (grpId <= 0) { + CONCUR_LOGI("CreateRsRtgGroup failed! rtGrp:%{public}d", grpId); + return -1; + } + return grpId; +} + +int TaskController::GetRequestType(std::string strRequstType) +{ + auto iter = msgType_.find(strRequstType); + if (iter == msgType_.end()) { + return MSG_TYPE_MAX; + } + return msgType_[strRequstType]; +} + +bool TaskController::ParsePayload(const Json::Value& payload, int& uid, int& pid, std::string& bundleName) +{ + try { + uid = stoi(payload["uid"].asString()); + pid = stoi(payload["pid"].asString()); + bundleName = payload["bundleName"].asString(); + } catch(...) { + CONCUR_LOGE("Unexpected uid or pid format"); + return false; + } + if (uid > 0 && pid > 0) { + return true; + } + return false; +} + +void TaskController::DealSystemRequest(int requestType, const Json::Value& payload) +{ + int uid = -1; + int pid = -1; + std::string bundleName = ""; + if (!ParsePayload(payload, uid, pid, bundleName)) { + return; + } + switch (requestType) { + case MSG_FOREGROUND: + NewForeground(uid, pid); + break; + case MSG_BACKGROUND: + NewBackground(uid, pid); + break; + case MSG_APP_START: + NewAppStart(uid, pid, bundleName, ParseAppType(payload)); + break; + case MSG_APP_KILLED: + AppKilled(uid, pid); + break; + case MSG_CONTINUOUS_TASK_START: + case MSG_CONTINUOUS_TASK_END: + ContinuousTaskProcess(uid, pid, requestType); + break; + case MSG_GET_FOCUS: + case MSG_LOSE_FOCUS: + FocusStatusProcess(uid, pid, requestType); + break; + case MSG_ENTER_INTERACTION_SCENE: + case MSG_EXIT_INTERACTION_SCENE: + InteractionSceneProcess(requestType); + break; + default: + CONCUR_LOGE("Unknown system request"); + break; + } +} + +std::list::iterator TaskController::GetRecordOfPid(int pid) +{ + std::lock_guard lock(appInfoLock_); + for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { + if (iter->GetPid() == pid) { + return iter; + } + } + return foregroundApp_.end(); +} + +void TaskController::NewForeground(int uid, int pid) +{ + int uiTid = pid; + auto it = find(authApps_.begin(), authApps_.end(), pid); + if (it == authApps_.end()) { + CONCUR_LOGI("un-authed pid %{public}d", pid); + return; + } + int ret = AuthGet(pid); + if (ret != static_cast(AuthStatus::AUTH_STATUS_FOCUS)) { + unsigned int pidParam = static_cast(pid); + unsigned int uaFlag = AF_RTG_ALL; + unsigned int status = static_cast(AuthStatus::AUTH_STATUS_FOREGROUND); + int ret = AuthEnable(pidParam, uaFlag, status); + if (ret == 0) { + CONCUR_LOGI("auth_enable %{public}d success", pid); + } else { + CONCUR_LOGE("auth_enable %{public}d fail with ret %{public}d", pid, ret); + } + CONCUR_LOGI("pid %{public}d change to foreground.", pid); + } else { + CONCUR_LOGI("pid %{public}d is already focus", pid); + } + bool found = false; + bool ddlEnabled = OHOS::system::GetBoolParameter(INTERVAL_DDL, false); + std::lock_guard lock(appInfoLock_); + for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { + if (iter->GetPid() == pid) { + found = true; + if (ddlEnabled && pid != curGamePid_) { + iter->AddKeyThread(uiTid, PRIO_RT); + } + iter->BeginScene(); + } + } + if (!found) { + NewForegroundAppRecord(pid, uiTid, ddlEnabled); + } +} + +void TaskController::NewForegroundAppRecord(int pid, int uiTid, bool ddlEnabled) +{ + ForegroundAppRecord& appRecord = foregroundApp_.emplace_back(pid, uiTid, uniAppRate_, pid != curGamePid_); + if (foregroundApp_.size() <= 0 || appRecord.GetPid() != pid) { + CONCUR_LOGE("pid %{public}d create app record failed", pid); + return; + } + if (appRecord.IsValid()) { + if (ddlEnabled && pid != curGamePid_) { + appRecord.AddKeyThread(uiTid, PRIO_RT); + } + appRecord.BeginScene(); + } +} + +void TaskController::NewBackground(int uid, int pid) +{ + auto it = find(authApps_.begin(), authApps_.end(), pid); + if (it == authApps_.end()) { + CONCUR_LOGI("un-authed pid %{public}d", pid); + return; + } + CONCUR_LOGI("pid %{public}d change to background.", pid); + unsigned int pidParam = static_cast(pid); + + int ret = AuthPause(pidParam); + if (ret == 0) { + CONCUR_LOGI("auth_pause %{public}d success", pid); + } else { + CONCUR_LOGI("auth_pause %{public}d fail with %{public}d", pid, ret); + } + std::lock_guard lock(appInfoLock_); + for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { + if (iter->GetPid() == pid) { + iter->EndScene(); + return; + } + } +} + +void TaskController::NewAppStart(int uid, int pid, const std::string& bundleName, int appType) +{ + CONCUR_LOGI("pid %{public}d start.", pid); + unsigned int pidParam = static_cast(pid); + unsigned int uaFlag = AF_RTG_ALL; + unsigned int status = static_cast(AuthStatus::AUTH_STATUS_DEFAULT); + + int ret = AuthEnable(pidParam, uaFlag, status); + if (ret == 0) { + CONCUR_LOGI("auth_enable %{public}d success", pid); + } else { + CONCUR_LOGE("auth_enable %{public}d fail with ret %{public}d", pid, ret); + return; + } + std::lock_guard lock(appInfoLock_); + authApps_.push_back(pid); + appBundleName[pid] = bundleName; + if (ddlSceneSchedSwitch_ && appType != APP_TYPE_INVALID) { + appTypeCache_[pid] = appType; + } +} + +void TaskController::AppKilled(int uid, int pid) +{ + CONCUR_LOGI("pid %{public}d killed.", pid); + unsigned int pidParam = static_cast(pid); + int ret = AuthDelete(pidParam); + if (ret == 0) { + CONCUR_LOGI("auth_delete %{public}d success", pid); + } else { + CONCUR_LOGE("auth_delete %{public}d fail with %{public}d", pid, ret); + } + std::lock_guard lock(appInfoLock_); + for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { + if (iter->GetPid() == pid) { + foregroundApp_.erase(iter++); + break; + } + } + for (auto iter = authApps_.begin(); iter != authApps_.end(); iter++) { + if (*iter == pid) { + authApps_.erase(iter); + break; + } + } + appBundleName.erase(pid); + if (ddlSceneSchedSwitch_) { + appTypeCache_.erase(pid); + } +} + +int TaskController::AuthSystemProcess(int pid) +{ + unsigned int uaFlag = AF_RTG_ALL; + unsigned int status = static_cast(AuthStatus::AUTH_STATUS_SYSTEM_SERVER); + int ret = AuthEnable(pid, uaFlag, status); + if (ret == 0) { + CONCUR_LOGI("auth process %{public}d success", pid); + } else { + CONCUR_LOGI("auth process %{public}d failed, ret %{public}d", pid, ret); + } + return ret; +} + +void TaskController::ContinuousTaskProcess(int uid, int pid, int status) +{ + int ret = -1; + if (status == static_cast(MSG_CONTINUOUS_TASK_START)) { + ret = AuthEnhance(pid, true); + CONCUR_LOGI("auth_enhance pid %{public}d start, ret %{public}d", pid, ret); + } else if (status == static_cast(MSG_CONTINUOUS_TASK_END)) { + ret = AuthEnhance(pid, false); + CONCUR_LOGI("auth_enhance pid %{public}d end, ret %{public}d", pid, ret); + } else { + CONCUR_LOGE("Invalid auth_enhance status %{public}d", status); + } +} + +void TaskController::FocusStatusProcess(int uid, int pid, int status) +{ + int ret = -1; + unsigned int rtgFlag = AF_RTG_ALL; + unsigned int qosFlag = AF_QOS_DELEGATED; + if (status == static_cast(MSG_GET_FOCUS)) { + ret = AuthSwitch(pid, rtgFlag, qosFlag, static_cast(AuthStatus::AUTH_STATUS_FOCUS)); + CONCUR_LOGI("pid %{public}d get focus. ret %{public}d", pid, ret); + if (ddlSceneSchedSwitch_) { + if (IsVideoApp(pid)) { + isVideoApp_ = true; + CONCUR_LOGD("video app bundleName %{public}s get focus", appBundleName[pid].c_str()); + } else { + isVideoApp_ = false; + } + } + } else if (status == static_cast(MSG_LOSE_FOCUS)) { + ret = AuthSwitch(pid, rtgFlag, qosFlag, static_cast(AuthStatus::AUTH_STATUS_FOREGROUND)); + CONCUR_LOGI("pid %{public}d lose focus. ret %{public}d", pid, ret); + isVideoApp_ = false; + } else { + CONCUR_LOGE("Invalid focus status %{public}d", status); + } +} + +void TaskController::InteractionSceneProcess(int status) +{ + std::lock_guard lock(ddlPowerModeLock_); + if (ddlSceneSchedSwitch_) { + if (status == MSG_ENTER_INTERACTION_SCENE) { + DeadlinePerfMode(); + } else if (status == MSG_EXIT_INTERACTION_SCENE) { + if (isVideoApp_) { + return; + } + DeadlinePowerMode(); + } + } +} + +void TaskController::DeadlinePerfMode() +{ + if (ddlPowerModeEnable_) { + StartTrace(HITRACE_TAG_ACE, "Deadline perf mode"); + SetAppAndRenderServiceRate(uniAppRate_, systemRate_); + ddlPowerModeEnable_ = false; + CONCUR_LOGI("Deadline switch to perf mode"); + FinishTrace(HITRACE_TAG_ACE); + } +} + +void TaskController::DeadlinePowerMode() +{ + if (!ddlPowerModeEnable_) { + StartTrace(HITRACE_TAG_ACE, "Deadline power mode"); + int appRate = uniAppRate_; + int rsRate = systemRate_; + if (configReader_) { + appRate = configReader_->GetDegratationFps(appRate); + rsRate = configReader_->GetDegratationFps(rsRate); + } + SetAppAndRenderServiceRate(appRate, rsRate); + ddlPowerModeEnable_ = true; + CONCUR_LOGI("Deadline switch to power mode"); + FinishTrace(HITRACE_TAG_ACE); + } +} +void TaskController::QueryDeadline(int queryItem, DeadlineReply& ddlReply, const Json::Value& payload) +{ + pid_t uid = IPCSkeleton::GetInstance().GetCallingUid(); + std::string processName = GetProcessNameByToken(); + if (processName != RENDER_SERVICE_PROCESS_NAME && processName != GAME_ACCELERATE_SCHED_PROCESS_NAME) { + CONCUR_LOGE("Invalid uid %{public}d, only RS or RSS can call QueryDeadline", uid); + return; + } + switch (queryItem) { + case DDL_RATE: { + ModifySystemRate(payload); + break; + } + case MSG_GAME: { + ModifyGameState(payload); + break; + } + default: { + break; + } + } +} + +void TaskController::ModifyGameState(const Json::Value& payload) +{ + if (!CheckJsonValid(payload)) { + CONCUR_LOGE("[MSG_GAME]receive json invalid"); + return; + } + if (payload["gameMsg"].isNull()) { + CONCUR_LOGE("[MSG_GAME]message is null"); + return; + } + std::string gameMsg = payload["gameMsg"].asString(); + int oldGamePid = curGamePid_; + int newGamePid = GetGamePid(gameMsg); + curGamePid_ = newGamePid; + CONCUR_LOGI("[MSG_GAME]current game pid is %{public}d, old game pid is %{public}d", + newGamePid, oldGamePid); + if (curGamePid_ == -1) { + return; + } + std::lock_guard lock(appInfoLock_); + for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { + if (iter->GetPid() == curGamePid_ && iter->GetGrpId() >= 0) { + CONCUR_LOGI("[MSG_GAME]destroy rtg grp, pid is %{public}d grpId is %{public}d", + iter->GetPid(), iter->GetGrpId()); + DestroyRtgGrp(iter->GetGrpId()); + iter->SetGrpId(-1); + break; + } + } + return; +} + +int TaskController::GetGamePid(const std::string &gameMsg) const +{ + GameStatus status = GetGameScene(gameMsg); + CONCUR_LOGI("[MSG_GAME]gamescene status %{public}d", status); + int gamePid = -1; + if (status == GAME_ENTRY_MSG) { + size_t pos = gameMsg.find(","); + if (pos == string::npos) { + return -1; + } + int ret = sscanf_s(gameMsg.substr(0, pos).c_str(), "{\"gamePid\":\"%d\"", &gamePid); + if (ret == -1) { + CONCUR_LOGE("[MSG_GAME]message parsing failed, ret is %{public}d", ret); + } else { + CONCUR_LOGI("[MSG_GAME]message parsing success"); + } + } + return gamePid; +} + +GameStatus TaskController::GetGameScene(const std::string &gameMsg) const +{ + if (gameMsg.find("gameScene\":\"1") != std::string::npos) { + return GAME_ENTRY_MSG; + } + if (gameMsg.find("gameScene\":\"0") != std::string::npos) { + return GAME_EXIT_MSG; + } + if (gameMsg.find("cameraScene\":\"1") != std::string::npos) { + return CAMERA_ENTRY_MSG; + } + if (gameMsg.find("cameraScene\":\"0") != std::string::npos) { + return CAMERA_EXIT_MSG; + } + if (gameMsg.find("GTXGamePid\":") != std::string::npos) { + return GAME_GTX_MSG; + } + return STATUS_MSG_MAX; +} + +bool TaskController::ModifySystemRate(const Json::Value& payload) +{ + if (!CheckJsonValid(payload)) { + CONCUR_LOGI("service receive json invalid"); + return false; + } + SetAppRate(payload); + SetRenderServiceRate(payload); + return true; +} + +void TaskController::UpdateAllAppRate(int appRate) +{ + std::lock_guard lock(appInfoLock_); + for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { + iter->UpdateRate(appRate); + } +} + +void TaskController::SetAppRate(const Json::Value& payload) +{ + int rtgId = 0; + int uiTid = 0; + int appRate = FindRateFromInfo(UNI_APP_RATE_ID, payload); + if (appRate > 0 && appRate != uniAppRate_) { + CONCUR_LOGD("set unified app rate %{public}d", appRate); + uniAppRate_ = appRate; + if (ddlSceneSchedSwitch_ && ddlPowerModeEnable_ && configReader_) { + appRate = configReader_->GetDegratationFps(appRate); + } + bool ret = OHOS::system::SetParameter(INTERVAL_APP_RATE, std::to_string(appRate)); + if (ret == false) { + CONCUR_LOGI("set app rate param failed"); + } + UpdateAllAppRate(appRate); + StartTrace(HITRACE_TAG_ACE, + "SetAppRate:" + std::to_string(appRate) + " ret:" + std::to_string(ret)); + FinishTrace(HITRACE_TAG_ACE); + return; + } +} + +int TaskController::FindRateFromInfo(int uiTid, const Json::Value& payload) +{ + int appRate = 0; + if (payload[std::to_string(uiTid)].isNull()) { + CONCUR_LOGI("FindRateFromInfo tid %{public}d is null", uiTid); + return appRate; + } + try { + appRate = stoi(payload[std::to_string(uiTid)].asString()); + } catch (...) { + CONCUR_LOGI("application %{public}d is not in rtg_group", uiTid); + } + return appRate; +} + +void TaskController::SetRenderServiceRate(const Json::Value& payload) +{ + int rsRate = FindRateFromInfo(renderServiceMainTid_, payload); + std::lock_guard lock(rateInfoLock_); + if (renderServiceMainGrpId_ > 0 && rsRate > 0 && rsRate != systemRate_) { + CONCUR_LOGD("set rs rate %{public}d rtgId is %{public}d, old rate is %{public}d", + rsRate, renderServiceMainGrpId_, systemRate_); + SetFrameRate(renderServiceMainGrpId_, rsRate); + systemRate_ = rsRate; + if (ddlSceneSchedSwitch_ && ddlPowerModeEnable_ && configReader_) { + rsRate = configReader_->GetDegratationFps(rsRate); + } + bool ret = OHOS::system::SetParameter(INTERVAL_RS_RATE, std::to_string(rsRate)); + if (ret == false) { + CONCUR_LOGI("set rs rate param failed"); + } + StartTrace(HITRACE_TAG_ACE, + "SetRSRate:" + std::to_string(rsRate) + " ret:" + std::to_string(ret)); + FinishTrace(HITRACE_TAG_ACE); + } +} + +void TaskController::SetAppAndRenderServiceRate(int appRate, int rsRate) +{ + bool ret = OHOS::system::SetParameter(INTERVAL_APP_RATE, std::to_string(appRate)); + if (ret == false) { + CONCUR_LOGI("set app rate param failed"); + } + UpdateAllAppRate(appRate); + StartTrace(HITRACE_TAG_ACE, + "SetAppRate:" + std::to_string(appRate) + " ret:" + std::to_string(ret)); + FinishTrace(HITRACE_TAG_ACE); + + ret = OHOS::system::SetParameter(INTERVAL_RS_RATE, std::to_string(rsRate)); + if (ret == false) { + CONCUR_LOGI("set rs rate param failed"); + } + StartTrace(HITRACE_TAG_ACE, + "SetRSRate:" + std::to_string(rsRate) + " ret:" + std::to_string(ret)); + FinishTrace(HITRACE_TAG_ACE); +} + +bool TaskController::CheckJsonValid(const Json::Value& payload) +{ + Json::ValueType type = payload.type(); + if (type != Json::objectValue) { + CONCUR_LOGE("error payload"); + return false; + } + if (payload.empty()) { + CONCUR_LOGI("payload empty"); + return false; + } + return true; +} + +void TaskController::SetFrameRate(int rtgId, int rate) +{ + if (rtgId > 0) { + SetFrameRateAndPrioType(rtgId, rate, PARAM_TYPE); + } +} + +void TaskController::PrintInfo() +{ + std::lock_guard lock(appInfoLock_); + for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { + iter->PrintKeyThreads(); + } +} + +int TaskController::CreateNewRtgGrp(int prioType, int rtNum) +{ + struct rtg_grp_data grp_data; + int ret; + char fileName[] = "/proc/self/sched_rtg_ctrl"; + int fd = open(fileName, O_RDWR); + if (fd < 0) { + CONCUR_LOGE("Open file /proc/self/sched_rth_ctrl, errno = %{public}d", errno); + return fd; + } + (void)memset_s(&grp_data, sizeof(struct rtg_grp_data), 0, sizeof(struct rtg_grp_data)); + if ((prioType > 0) && (prioType < RTG_TYPE_MAX)) { + grp_data.prio_type = prioType; + } + if (rtNum > 0) { + grp_data.rt_cnt = rtNum; + } + grp_data.rtg_cmd = CMD_CREATE_RTG_GRP; + ret = ioctl(fd, CMD_ID_SET_RTG, &grp_data); + if (ret < 0) { + CONCUR_LOGE("create rtg grp failed, errno = %{public}d (%{public}s)", errno, strerror(errno)); + } else { + CONCUR_LOGI("create rtg grp success, get rtg id %{public}d.", ret); + } + close(fd); + return ret; +} + +int TaskController::ParseAppType(const Json::Value& payload) +{ + int appType = APP_TYPE_INVALID; + if (payload.isMember("appType") && payload["appType"].isString()) { + try { + appType = stoi(payload["appType"].asString()); + } catch (...) { + CONCUR_LOGE("Unexpected apptype format"); + return APP_TYPE_INVALID; + } + } + return appType; +} + +bool TaskController::IsVideoApp(int pid) +{ + if (!ddlSceneSchedSwitch_) { + return false; + } + if (appTypeCache_.find(pid) != appTypeCache_.end()) { + return appTypeCache_[pid] == APP_TYPE_VIDEO || + appTypeCache_[pid]== APP_TYPE_VIDEO_CLIP; + } + return false; +} + +ForegroundAppRecord::ForegroundAppRecord(int pid, int uiTid, int appRate, bool createGrp) +{ + pid_ = pid; + uiTid_ = uiTid; + rate_ = appRate; + if (OHOS::system::GetBoolParameter(INTERVAL_DDL, false) && createGrp) { + grpId_ = TaskController::GetInstance().CreateNewRtgGrp(PRIO_RT, MAX_KEY_THREADS); + } else { + grpId_ = -1; + } +} + +ForegroundAppRecord::~ForegroundAppRecord() +{ + if (grpId_ > 0) { + DestroyRtgGrp(grpId_); + } + if (selfRenderGrpId_ > 0) { + DestroyRtgGrp(selfRenderGrpId_); + } +} + +void ForegroundAppRecord::AddKeyThread(int tid, int prio) +{ + int rtgPrio = (prio >= PRIO_NORMAL) ? PRIO_NORMAL : PRIO_RT; + if (keyThreads_.find(tid) != keyThreads_.end()) { + return; + } + if (grpId_ <= 0) { + CONCUR_LOGI("Add key thread fail: Grp id not been created success, tid is %{public}d", tid); + return; + } + if (keyThreads_.size() >= MAX_KEY_THREADS) { + CONCUR_LOGI("Add key thread fail: Key threads num limit."); + return; + } + if (prio == RPIO_IN) { + setpriority(PRIO_PROCESS, tid, -13); // -13 represent spcial nice in qos + } else { + int ret = AddThreadToRtg(tid, grpId_, rtgPrio); + if (ret != 0) { + CONCUR_LOGI("Add key thread fail: Kernel err report. ret is %{public}d", ret); + } else { + CONCUR_LOGI("Add key thread %{public}d", tid); + } + keyThreads_.insert(tid); + } +} + +void ForegroundAppRecord::TryCreateSelfRenderGrp() +{ + if (selfRenderGrpId_ > 0) { + CONCUR_LOGI("self render group %{public}d already create", selfRenderGrpId_); + return; + } + int ret = 0; + ret = TaskController::GetInstance().CreateNewRtgGrp(PRIO_RT, MAX_KEY_THREADS); + if (ret < 0) { + CONCUR_LOGE("TryCreateSelfRenderGrp create group failed: %{public}d", ret); + return; + } + selfRenderGrpId_ = ret; + SetFrameRateAndPrioType(selfRenderGrpId_, rate_, PARAM_TYPE); +} + +int ForegroundAppRecord::SetTaskSmt(int tid, unsigned int smt_type) +{ + struct TaskConfig task_config; + int ret = 0; + int fd = open("/dev/hisi_perf_ctrl", O_RDWR); + if (fd < 0) { + CONCUR_LOGE("Open file /dev/hisi_perf_ctrl, errno = %{public}d", errno); + return fd; + } + (void)memset_s(&task_config, sizeof(struct TaskConfig), 0, sizeof(struct TaskConfig)); + task_config.pid = tid; + task_config.value = smt_type; + ret = ioctl(fd, PERF_CTRL_SET_TASK_NO_SMT, &task_config); + if (ret < 0) { + CONCUR_LOGE("set task %{public}d smt %{public}u failed, errno = %{public}d (%{public}s)", + tid, smt_type, errno, strerror(errno)); + } else { + CONCUR_LOGI("set task %{public}d smt %{public}u success", tid, smt_type); diff --git a/services/src/concurrent_task_controller.cpp b/services/src/concurrent_task_controller.cpp index d1cb67a..c7cd9e2 100644 --- a/services/src/concurrent_task_controller.cpp +++ b/services/src/concurrent_task_controller.cpp @@ -49,8 +49,13 @@ namespace { constexpr int APP_TYPE_INVALID = -1; } +#define SMT_EXPELLEE 0U +#define SMT_EXPELLER 2U +#define SET_TASK_NO_SMT 41 #define CMD_ID_SET_RTG \ - _IOWR(RTG_SCHED_IPC_MAGIC, SET_RTG, struct rtg_str_data) + _IOWR(RTG_SCHED_IPC_MAGIC, SET_RTG, struct rtg_str_data)\ +#define PERF_CTRL_SET_TASK_NO_SMT \ + _IOWR(PERF_CTRL_MAGIC, SET_TASK_NO_SMT, struct TaskConfig) TaskController& TaskController::GetInstance() { @@ -131,6 +136,12 @@ void TaskController::QueryInterval(int queryItem, IntervalReply& queryRs) case QUERY_EXECUTOR_START: QueryExecutorStart(uid, pid, queryRs); break; + case QUERY_SELF_RENDER_REMOVE_THREAD: + QuerySelfRenderRemoveThread(uid, pid, queryRs); + break; + case QUERY_SELF_RENDER_ADD_THREAD: + QuerySelfRenderAddThread(uid, pid, queryRs); + break; default: break; } @@ -214,6 +225,28 @@ void TaskController::QueryRenderService(int uid, IntervalReply& queryRs) SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); } +void TaskController::QueryRenderServiceMain(int uid, int pid, IntervalReply& queryRs) +{ + if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { + return; + } + if (!rsAuthed_) { + if (AuthSystemProcess(pid) != 0) { + return; + SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); +} + +void TaskController::QueryRenderServiceMain(int uid, int pid, IntervalReply& queryRs) +{ + if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { + return; + } + if (!rsAuthed_) { + if (AuthSystemProcess(pid) != 0) { + return; + SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); +} + void TaskController::QueryRenderServiceMain(int uid, int pid, IntervalReply& queryRs) { if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { @@ -309,6 +342,30 @@ void TaskController::QueryExecutorStart(int uid, int pid, IntervalReply& queryRs queryRs.rtgId = renderServiceMainGrpId_; } +void TaskController::QuerySelfRenderRemoveThread(int uid, int pid, IntervalReply& queryRs) +{ + auto iter = GetRecordOfPid(pid); + if (iter != foregroundApp_.end()) { + queryRs.paramA = iter->RemoveSelfRenderTid(queryRs); + if (queryRs.paramA != 0) { + CONCUR_LOGE("uid %{public}d pid %{public}d Query Self Render Remove Thread %{public}d failed: %{public}d", + uid, pid, queryRs.tid, queryRs.paramA); + } + } +} + +void TaskController::QuerySelfRenderAddThread(int uid, int pid, IntervalReply& queryRs) +{ + auto iter = GetRecordOfPid(pid); + if (iter != foregroundApp_.end()) { + queryRs.paramA = iter->AddSelfRenderTid(queryRs); + if (queryRs.paramA != 0) { + CONCUR_LOGE("uid %{public}d pid %{public}d Query Self Render Add Thread %{public}d failed: %{public}d", + uid, pid, queryRs.tid, queryRs.paramA); + } + } +} + void TaskController::QueryHwc(int uid, IntervalReply& queryRs) { pid_t pid = IPCSkeleton::GetInstance().GetCallingPid(); @@ -551,7 +608,7 @@ void TaskController::NewForeground(int uid, int pid) void TaskController::NewForegroundAppRecord(int pid, int uiTid, bool ddlEnabled) { - ForegroundAppRecord& appRecord = foregroundApp_.emplace_back(pid, uiTid, pid != curGamePid_); + ForegroundAppRecord& appRecord = foregroundApp_.emplace_back(pid, uiTid, uniAppRate_, pid != curGamePid_); if (foregroundApp_.size() <= 0 || appRecord.GetPid() != pid) { CONCUR_LOGE("pid %{public}d create app record failed", pid); return; @@ -840,6 +897,14 @@ bool TaskController::ModifySystemRate(const Json::Value& payload) return true; } +void TaskController::UpdateAllAppRate(int appRate) +{ + std::lock_guard lock(appInfoLock_); + for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { + iter->UpdateRate(appRate); + } +} + void TaskController::SetAppRate(const Json::Value& payload) { int rtgId = 0; @@ -855,27 +920,12 @@ void TaskController::SetAppRate(const Json::Value& payload) if (ret == false) { CONCUR_LOGI("set app rate param failed"); } + UpdateAllAppRate(appRate); StartTrace(HITRACE_TAG_ACE, "SetAppRate:" + std::to_string(appRate) + " ret:" + std::to_string(ret)); FinishTrace(HITRACE_TAG_ACE); return; } - std::lock_guard lock(appInfoLock_); - for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { - uiTid = iter->GetUiTid(); - rtgId = iter->GetGrpId(); - if (uiTid <= 0 || rtgId <= 0) { - continue; - } - appRate = FindRateFromInfo(uiTid, payload); - if (appRate > 0 && appRate != iter->GetRate()) { - CONCUR_LOGI("set app rate %{public}d rtgId is %{public}d, old rate is %{public}d", - appRate, rtgId, iter->GetRate()); - SetFrameRate(rtgId, appRate); - iter->SetRate(appRate); - } - } - return; } int TaskController::FindRateFromInfo(int uiTid, const Json::Value& payload) @@ -921,6 +971,7 @@ void TaskController::SetAppAndRenderServiceRate(int appRate, int rsRate) if (ret == false) { CONCUR_LOGI("set app rate param failed"); } + UpdateAllAppRate(appRate); StartTrace(HITRACE_TAG_ACE, "SetAppRate:" + std::to_string(appRate) + " ret:" + std::to_string(ret)); FinishTrace(HITRACE_TAG_ACE); @@ -1017,10 +1068,11 @@ bool TaskController::IsVideoApp(int pid) return false; } -ForegroundAppRecord::ForegroundAppRecord(int pid, int uiTid, bool createGrp) +ForegroundAppRecord::ForegroundAppRecord(int pid, int uiTid, int appRate, bool createGrp) { pid_ = pid; uiTid_ = uiTid; + rate_ = appRate; if (OHOS::system::GetBoolParameter(INTERVAL_DDL, false) && createGrp) { grpId_ = TaskController::GetInstance().CreateNewRtgGrp(PRIO_RT, MAX_KEY_THREADS); } else { @@ -1033,6 +1085,9 @@ ForegroundAppRecord::~ForegroundAppRecord() if (grpId_ > 0) { DestroyRtgGrp(grpId_); } + if (selfRenderGrpId_ > 0) { + DestroyRtgGrp(selfRenderGrpId_); + } } void ForegroundAppRecord::AddKeyThread(int tid, int prio) @@ -1062,81 +1117,37 @@ void ForegroundAppRecord::AddKeyThread(int tid, int prio) } } -bool ForegroundAppRecord::BeginScene() +void ForegroundAppRecord::TryCreateSelfRenderGrp() { - if (grpId_ <= 0) { - CONCUR_LOGI("Error begin scene in pid %{public}d", pid_); - return false; + if (selfRenderGrpId_ > 0) { + CONCUR_LOGI("self render group %{public}d already create", selfRenderGrpId_); + return; } - OHOS::RME::BeginFrameFreq(0); - OHOS::RME::EndFrameFreq(0); - return true; -} - -bool ForegroundAppRecord::EndScene() -{ - if (grpId_ <= 0) { - CONCUR_LOGI("Error end scene loss grpId_ in pid %{public}d", pid_); - return false; + int ret = 0; + ret = TaskController::GetInstance().CreateNewRtgGrp(PRIO_RT, MAX_KEY_THREADS); + if (ret < 0) { + CONCUR_LOGE("TryCreateSelfRenderGrp create group failed: %{public}d", ret); + return; } - OHOS::RME::EndScene(grpId_); - return true; + selfRenderGrpId_ = ret; + SetFrameRateAndPrioType(selfRenderGrpId_, rate_, PARAM_TYPE); } -int ForegroundAppRecord::GetPid() const +int ForegroundAppRecord::SetTaskSmt(int tid, unsigned int smt_type) { - return pid_; -} - -int ForegroundAppRecord::GetGrpId() const -{ - return grpId_; -} - -void ForegroundAppRecord::SetGrpId(int grpId) -{ - grpId_ = grpId; -} - -void ForegroundAppRecord::SetRate(int appRate) -{ - rate_ = appRate; -} - -int ForegroundAppRecord::GetRate() const -{ - return rate_; -} - -void ForegroundAppRecord::SetUiTid(int uiTid) -{ - uiTid_ = uiTid; -} - -int ForegroundAppRecord::GetUiTid() const -{ - return uiTid_; -} - -bool ForegroundAppRecord::IsValid() -{ - if (pid_ > 0) { - return true; + struct TaskConfig task_config; + int ret = 0; + int fd = open("/dev/hisi_perf_ctrl", O_RDWR); + if (fd < 0) { + CONCUR_LOGE("Open file /dev/hisi_perf_ctrl, errno = %{public}d", errno); + return fd; } - return false; -} - -void ForegroundAppRecord::PrintKeyThreads() -{ - std::string strLog = "pid "; - strLog.append(std::to_string(pid_)); - strLog.append(" has key threads: "); - for (auto iter = keyThreads_.begin(); iter != keyThreads_.end(); iter++) { - std::string temp = std::to_string(*iter); - strLog.append(temp); - strLog.append(", "); - } - CONCUR_LOGD("%{public}s", strLog.c_str()); -} -} // namespace ConcurrentTask -} // namespace OHOS + (void)memset_s(&task_config, sizeof(struct TaskConfig), 0, sizeof(struct TaskConfig)); + task_config.pid = tid; + task_config.value = smt_type; + ret = ioctl(fd, PERF_CTRL_SET_TASK_NO_SMT, &task_config); + if (ret < 0) { + CONCUR_LOGE("set task %{public}d smt %{public}u failed, errno = %{public}d (%{public}s)", + tid, smt_type, errno, strerror(errno)); + } else { + CONCUR_LOGI("set task %{public}d smt %{public}u success", tid, smt_type); diff --git a/services/src/concurrent_task_service_stub.cpp b/services/src/concurrent_task_service_stub.cpp index c33ec9b..6bcf9bd 100644 --- a/services/src/concurrent_task_service_stub.cpp +++ b/services/src/concurrent_task_service_stub.cpp @@ -71,7 +71,7 @@ int32_t ConcurrentTaskServiceStub::QueryIntervalInner(MessageParcel& data, [[may queryRs.tid = -1; queryRs.paramA = -1; queryRs.paramB = -1; - if (!data.ReadInt32(item) || !data.ReadInt32(queryRs.tid)) { + if (!data.ReadInt32(item) || !data.ReadInt32(queryRs.tid) || !data.ReadInt32(queryRs.paramA)) { CONCUR_LOGE("Read info failed in QueryInterval Stub"); return IPC_STUB_ERR; } diff --git a/test/unittest/phone/concurrent_task_controller_test.cpp b/test/unittest/phone/concurrent_task_controller_test.cpp index 19cc245..9f738ed 100644 --- a/test/unittest/phone/concurrent_task_controller_test.cpp +++ b/test/unittest/phone/concurrent_task_controller_test.cpp @@ -412,12 +412,10 @@ HWTEST_F(ConcurrentTaskControllerTest, SetAppRateTest, TestSize.Level1) foreApp1.SetRate(60); TaskController::GetInstance().foregroundApp_.push_back(foreApp1); TaskController::GetInstance().foregroundApp_.begin()->grpId_ = 1; - payload["758"] = "120"; + payload["-1"] = "120"; TaskController::GetInstance().SetAppRate(payload); int curAppRate = TaskController::GetInstance().foregroundApp_.begin()->GetRate(); EXPECT_EQ(curAppRate, 120); - payload["-1"] = "120"; - TaskController::GetInstance().SetAppRate(payload); EXPECT_EQ(OHOS::system::GetIntParameter("persist.ffrt.interval.appRate", 0), 120); } -- Gitee From 9df49fb63acd5633b814da4b77a57b8773aceea7 Mon Sep 17 00:00:00 2001 From: liuyuxiu Date: Wed, 7 Aug 2024 11:25:11 +0800 Subject: [PATCH 02/10] qos_manager Signed-off-by: liuyuxiu --- .../src/.concurrent_task_controller.cpp.swp | Bin 28672 -> 0 bytes services/src/: | 1153 ----------------- 2 files changed, 1153 deletions(-) delete mode 100644 services/src/.concurrent_task_controller.cpp.swp delete mode 100644 services/src/: diff --git a/services/src/.concurrent_task_controller.cpp.swp b/services/src/.concurrent_task_controller.cpp.swp deleted file mode 100644 index 1468ae6c6f7bcca61c8a16079ba27854f378dc10..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 28672 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 I_jB6+0JSy-pa1{> diff --git a/services/src/: b/services/src/: deleted file mode 100644 index c7cd9e2..0000000 --- a/services/src/: +++ /dev/null @@ -1,1153 +0,0 @@ -/* - * 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 -#include -#include -#include -#include -#include -#include -#include "accesstoken_kit.h" -#include "concurrent_task_log.h" -#include "rtg_interface.h" -#include "ipc_skeleton.h" -#include "parameters.h" -#include "concurrent_task_controller.h" - -using namespace OHOS::RME; -using namespace OHOS::Security::AccessToken; - -namespace OHOS { -namespace ConcurrentTask { -namespace { - const std::string INTERVAL_DDL = "persist.ffrt.interval.renderthread"; - const std::string INTERVAL_APP_RATE = "persist.ffrt.interval.appRate"; - const std::string INTERVAL_RS_RATE = "persist.ffrt.interval.rsRate"; - const std::string CONFIG_FILE_NAME = "etc/qos_manager/qos_manager_config.xml"; - constexpr int CURRENT_RATE = 120; - constexpr int PARAM_TYPE = 1; - constexpr int UNI_APP_RATE_ID = -1; - const char RTG_SCHED_IPC_MAGIC = 0xAB; - constexpr int RTG_TYPE_MAX = 3; - constexpr int RS_UID = 1003; - constexpr int EXECUTOR_LIMIT_NUM = 3; - constexpr int APP_TYPE_VIDEO = 10067; - constexpr int APP_TYPE_VIDEO_CLIP = 10026; - constexpr int APP_TYPE_INVALID = -1; -} - -#define SMT_EXPELLEE 0U -#define SMT_EXPELLER 2U -#define SET_TASK_NO_SMT 41 -#define CMD_ID_SET_RTG \ - _IOWR(RTG_SCHED_IPC_MAGIC, SET_RTG, struct rtg_str_data)\ -#define PERF_CTRL_SET_TASK_NO_SMT \ - _IOWR(PERF_CTRL_MAGIC, SET_TASK_NO_SMT, struct TaskConfig) - -TaskController& TaskController::GetInstance() -{ - static TaskController instance; - return instance; -} - -void TaskController::RequestAuth(const Json::Value& payload) -{ - { - std::lock_guard autolock(configReaderMutex_); - if (!configEnable_ && !ConfigReaderInit()) { - return; - } - } - pid_t uid = IPCSkeleton::GetInstance().GetCallingUid(); - auto bundleName = GetProcessNameByToken(); - if (configReader_->IsBundleNameAuth(bundleName) || configReader_->IsUidAuth(uid)) { - pid_t pid = IPCSkeleton::GetInstance().GetCallingPid(); - AuthSystemProcess(pid); - return; - } - CONCUR_LOGE("Invalid uid %{public}d, can't call RequestAuth", uid); -} - -void TaskController::ReportData(uint32_t resType, int64_t value, const Json::Value& payload) -{ - pid_t uid = IPCSkeleton::GetInstance().GetCallingUid(); - if (GetProcessNameByToken() != RESOURCE_SCHEDULE_PROCESS_NAME) { - CONCUR_LOGE("Invalid uid %{public}d, only RSS can call ReportData", uid); - return; - } - if (!CheckJsonValid(payload)) { - return; - } - std::string strRequstType = ""; - try { - strRequstType = payload["type"].asString(); - } catch (...) { - CONCUR_LOGE("Unexpected type format"); - return; - } - if (strRequstType.length() == 0) { - CONCUR_LOGE("Get payload type err"); - return; - } - int requstType = GetRequestType(strRequstType); - DealSystemRequest(requstType, payload); - PrintInfo(); -} - -void TaskController::QueryInterval(int queryItem, IntervalReply& queryRs) -{ - pid_t uid = IPCSkeleton::GetInstance().GetCallingUid(); - pid_t pid = IPCSkeleton::GetInstance().GetCallingPid(); - switch (queryItem) { - case QUERY_UI: - QueryUi(uid, queryRs); - break; - case QUERY_RENDER: - QueryRender(uid, queryRs); - break; - case QUERY_RENDER_SERVICE: - QueryRenderService(uid, queryRs); - break; - case QUERY_RENDER_SERVICE_MAIN: - QueryRenderServiceMain(uid, pid, queryRs); - break; - case QUERY_RENDER_SERVICE_RENDER: - QueryRenderServiceRender(uid, pid, queryRs); - break; - case QUERY_COMPOSER: - QueryHwc(uid, queryRs); - break; - case QUERY_HARDWARE: - QueryHardware(uid, pid, queryRs); - break; - case QUERY_EXECUTOR_START: - QueryExecutorStart(uid, pid, queryRs); - break; - case QUERY_SELF_RENDER_REMOVE_THREAD: - QuerySelfRenderRemoveThread(uid, pid, queryRs); - break; - case QUERY_SELF_RENDER_ADD_THREAD: - QuerySelfRenderAddThread(uid, pid, queryRs); - break; - default: - break; - } -} - -std::string TaskController::GetProcessNameByToken() -{ - AccessTokenID tokenID = IPCSkeleton::GetInstance().GetCallingTokenID(); - NativeTokenInfo tokenInfo; - if (AccessTokenKit::GetNativeTokenInfo(tokenID, tokenInfo) != AccessTokenKitRet::RET_SUCCESS) { - return ""; - } - return tokenInfo.processName; -} - -void TaskController::QueryUi(int uid, IntervalReply& queryRs) -{ - pid_t pid = IPCSkeleton::GetInstance().GetCallingPid(); - auto iter = GetRecordOfPid(pid); - if (iter == foregroundApp_.end()) { - CONCUR_LOGD("Query ui with pid %{public}d failed", pid); - return; - } - int grpId = iter->GetGrpId(); - if (grpId <= 0) { - CONCUR_LOGI("%{public}d Query ui with none grpid", pid); - queryRs.rtgId = -1; - } else { - queryRs.rtgId = grpId; - } - queryRs.bundleName = appBundleName[pid]; -} - -void TaskController::QueryRender(int uid, IntervalReply& queryRs) -{ - pid_t pid = IPCSkeleton::GetInstance().GetCallingPid(); - auto iter = GetRecordOfPid(pid); - if (iter == foregroundApp_.end()) { - CONCUR_LOGD("Query render with pid %{public}d failed", pid); - return; - } - int grpId = iter->GetGrpId(); - if (grpId <= 0) { - CONCUR_LOGI("%{public}d Query render with none grpid", pid); - queryRs.rtgId = -1; - } else { - queryRs.rtgId = grpId; - } -} - -void TaskController::QueryRenderService(int uid, IntervalReply& queryRs) -{ - if (uid != RS_UID) { - return; - } - int queryTid = queryRs.tid; - if (renderServiceMainGrpId_ <= 0) { - TryCreateRSMainGrp(); - CONCUR_LOGI("uid %{public}d query rs group failed and create %{public}d.", uid, renderServiceMainGrpId_); - if (renderServiceMainGrpId_ <= 0) { - CONCUR_LOGE("uid %{public}d create rs group failed", uid); - return; - } - } - - queryRs.rtgId = renderServiceMainGrpId_; - if (queryTid <= 0) { - return; - } - list::iterator iter = find(rsThreads_.begin(), rsThreads_.end(), queryTid); - if (iter != rsThreads_.end()) { - return; - } - queryRs.rtgId = renderServiceMainGrpId_; - int ret = AddThreadToRtg(queryTid, renderServiceMainGrpId_, PRIO_RT); - if (ret < 0) { - CONCUR_LOGE("uid %{public}d tid %{public}d join rs group failed", uid, queryTid); - return; - } - CONCUR_LOGI("uid %{public}d tid %{public}d join rs group success in Query", uid, queryTid); - SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); -} - -void TaskController::QueryRenderServiceMain(int uid, int pid, IntervalReply& queryRs) -{ - if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { - return; - } - if (!rsAuthed_) { - if (AuthSystemProcess(pid) != 0) { - return; - SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); -} - -void TaskController::QueryRenderServiceMain(int uid, int pid, IntervalReply& queryRs) -{ - if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { - return; - } - if (!rsAuthed_) { - if (AuthSystemProcess(pid) != 0) { - return; - SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); -} - -void TaskController::QueryRenderServiceMain(int uid, int pid, IntervalReply& queryRs) -{ - if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { - return; - } - if (!rsAuthed_) { - if (AuthSystemProcess(pid) != 0) { - return; - } - rsAuthed_ = true; - } - if (renderServiceMainGrpId_ <= 0) { - TryCreateRSMainGrp(); - CONCUR_LOGI("uid %{public}d query rs group failed and create %{public}d.", uid, renderServiceMainGrpId_); - if (renderServiceMainGrpId_ <= 0) { - CONCUR_LOGE("uid %{public}d create rs group failed", uid); - return; - } - } - queryRs.rtgId = renderServiceMainGrpId_; - if (renderServiceMainTid_ <= 0) { - renderServiceMainTid_ = queryRs.tid; - int ret = AddThreadToRtg(renderServiceMainTid_, renderServiceMainGrpId_, PRIO_RT); - if (ret < 0) { - CONCUR_LOGE("uid %{public}d tid %{public}d join rs group failed.", uid, renderServiceMainTid_); - } - } - SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); -} - -void TaskController::QueryRenderServiceRender(int uid, int pid, IntervalReply& queryRs) -{ - if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { - return; - } - if (renderServiceRenderGrpId_ <= 0) { - TryCreateRSRenderGrp(); - if (renderServiceRenderGrpId_ <= 0) { - CONCUR_LOGE("uid %{public}d create rs group failed", uid); - return; - } - } - queryRs.rtgId = renderServiceRenderGrpId_; - if (renderServiceRenderTid_ <= 0 || renderServiceRenderTid_ != queryRs.tid) { - renderServiceRenderTid_ = queryRs.tid; - int ret = AddThreadToRtg(renderServiceRenderTid_, renderServiceRenderGrpId_, PRIO_RT); - if (ret < 0) { - CONCUR_LOGE("uid %{public}d tid %{public}d join rs group failed.", uid, renderServiceMainGrpId_); - } - } - SetFrameRateAndPrioType(renderServiceRenderGrpId_, CURRENT_RATE, PARAM_TYPE); -} - -void TaskController::QueryHardware(int uid, int pid, IntervalReply& queryRs) -{ - if (uid != RS_UID) { - return; - } - if (hardwareGrpId_ < 0) { - return; - } - hardwareTid_ = queryRs.tid; - TryCreateRSMainGrp(); - int ret = AddThreadToRtg(hardwareTid_, renderServiceMainGrpId_, PRIO_RT); - if (ret < 0) { - CONCUR_LOGE("uid %{public}d tid %{public}d join hardware group failed.", uid, hardwareTid_); - return; - } - queryRs.rtgId = hardwareGrpId_; -} - -void TaskController::QueryExecutorStart(int uid, int pid, IntervalReply& queryRs) -{ - if (uid != RS_UID) { - return; - } - if (renderServiceMainGrpId_ < 0) { - return; - } - std::lock_guard lock(executorStartLock_); - if (executorNum_ >= EXECUTOR_LIMIT_NUM) { - return; - } - if (queryRs.tid <= 0) { - return; - } - int ret = AddThreadToRtg(queryRs.tid, renderServiceMainGrpId_, PRIO_RT); - if (ret < 0) { - CONCUR_LOGE("uid %{public}d tid %{public}d join executor group failed.", uid, renderServiceMainTid_); - return; - } - executorNum_++; - queryRs.rtgId = renderServiceMainGrpId_; -} - -void TaskController::QuerySelfRenderRemoveThread(int uid, int pid, IntervalReply& queryRs) -{ - auto iter = GetRecordOfPid(pid); - if (iter != foregroundApp_.end()) { - queryRs.paramA = iter->RemoveSelfRenderTid(queryRs); - if (queryRs.paramA != 0) { - CONCUR_LOGE("uid %{public}d pid %{public}d Query Self Render Remove Thread %{public}d failed: %{public}d", - uid, pid, queryRs.tid, queryRs.paramA); - } - } -} - -void TaskController::QuerySelfRenderAddThread(int uid, int pid, IntervalReply& queryRs) -{ - auto iter = GetRecordOfPid(pid); - if (iter != foregroundApp_.end()) { - queryRs.paramA = iter->AddSelfRenderTid(queryRs); - if (queryRs.paramA != 0) { - CONCUR_LOGE("uid %{public}d pid %{public}d Query Self Render Add Thread %{public}d failed: %{public}d", - uid, pid, queryRs.tid, queryRs.paramA); - } - } -} - -void TaskController::QueryHwc(int uid, IntervalReply& queryRs) -{ - pid_t pid = IPCSkeleton::GetInstance().GetCallingPid(); - auto iter = GetRecordOfPid(pid); - if (iter == foregroundApp_.end()) { - CONCUR_LOGD("Query ipc thread with pid %{public}d failed", pid); - return; - } - int grpId = iter->GetGrpId(); - if (grpId <= 0) { - CONCUR_LOGI("%{public}d Query ipc thread with none grpid", pid); - queryRs.rtgId = -1; - } else { - queryRs.rtgId = grpId; - } -} - -void TaskController::Init() -{ - TypeMapInit(); - qosPolicy_.Init(); - TryCreateRsGroup(); - - std::lock_guard autolock(configReaderMutex_); - if (!configEnable_) { - ConfigReaderInit(); - } -} - -bool TaskController::ConfigReaderInit() -{ - configReader_ = make_unique(); - if (!configReader_) { - CONCUR_LOGE("configReader_ initialize error!"); - return configEnable_; - } - - std::string realPath; - configReader_->GetRealConfigPath(CONFIG_FILE_NAME.c_str(), realPath); - if (realPath.empty() || !configReader_->LoadFromConfigFile(realPath)) { - CONCUR_LOGE("config load failed!"); - return configEnable_; - } - configEnable_ = true; - ddlSceneSchedSwitch_ = configReader_->GetPowerModeSchedSwitch(); - CONCUR_LOGI("deadline scene sched switch = %{public}d", ddlSceneSchedSwitch_); - return configEnable_; -} - -void TaskController::Release() -{ - msgType_.clear(); - appTypeCache_.clear(); - if (renderServiceMainGrpId_ > 0) { - DestroyRtgGrp(renderServiceMainGrpId_); - renderServiceMainGrpId_ = -1; - } - if (renderServiceRenderGrpId_ > 0) { - DestroyRtgGrp(renderServiceRenderGrpId_); - renderServiceRenderGrpId_ = -1; - } - ddlSceneSchedSwitch_ = false; - - std::lock_guard autolock(configReaderMutex_); - configReader_ = nullptr; -} - -void TaskController::TypeMapInit() -{ - msgType_.clear(); - msgType_.insert(pair("foreground", MSG_FOREGROUND)); - msgType_.insert(pair("background", MSG_BACKGROUND)); - msgType_.insert(pair("appStart", MSG_APP_START)); - msgType_.insert(pair("appKilled", MSG_APP_KILLED)); - msgType_.insert(pair("continuousStart", MSG_CONTINUOUS_TASK_START)); - msgType_.insert(pair("continuousEnd", MSG_CONTINUOUS_TASK_END)); - msgType_.insert(pair("getFocus", MSG_GET_FOCUS)); - msgType_.insert(pair("loseFocus", MSG_LOSE_FOCUS)); - msgType_.insert(pair("enterInteractionScene", MSG_ENTER_INTERACTION_SCENE)); - msgType_.insert(pair("exitInteractionScene", MSG_EXIT_INTERACTION_SCENE)); -} - -void TaskController::TryCreateRSMainGrp() -{ - if (renderServiceMainGrpId_ == -1) { - renderServiceMainGrpId_ = TryCreateSystemGroup(); - hardwareGrpId_ = renderServiceMainGrpId_; - } -} - -void TaskController::TryCreateRSRenderGrp() -{ - if (renderServiceRenderGrpId_ == -1) { - renderServiceRenderGrpId_ = TryCreateSystemGroup(); - } -} - -void TaskController::TryCreateRsGroup() -{ - TryCreateRSMainGrp(); - TryCreateRSRenderGrp(); -} - -int TaskController::TryCreateSystemGroup() -{ - if (!rtgEnabled_) { - rtgEnabled_ = EnableRtg(true) < 0 ? false : true; - if (!rtgEnabled_) { - CONCUR_LOGE("Rtg enable failed"); - return -1; - } - CONCUR_LOGI("Enable Rtg"); - } - int grpId = CreateNewRtgGrp(PRIO_RT, MAX_KEY_THREADS); - if (grpId <= 0) { - CONCUR_LOGI("CreateRsRtgGroup with RT failed, try change to normal type."); - grpId = CreateNewRtgGrp(PRIO_NORMAL, MAX_KEY_THREADS); - } - if (grpId <= 0) { - CONCUR_LOGI("CreateRsRtgGroup failed! rtGrp:%{public}d", grpId); - return -1; - } - return grpId; -} - -int TaskController::GetRequestType(std::string strRequstType) -{ - auto iter = msgType_.find(strRequstType); - if (iter == msgType_.end()) { - return MSG_TYPE_MAX; - } - return msgType_[strRequstType]; -} - -bool TaskController::ParsePayload(const Json::Value& payload, int& uid, int& pid, std::string& bundleName) -{ - try { - uid = stoi(payload["uid"].asString()); - pid = stoi(payload["pid"].asString()); - bundleName = payload["bundleName"].asString(); - } catch(...) { - CONCUR_LOGE("Unexpected uid or pid format"); - return false; - } - if (uid > 0 && pid > 0) { - return true; - } - return false; -} - -void TaskController::DealSystemRequest(int requestType, const Json::Value& payload) -{ - int uid = -1; - int pid = -1; - std::string bundleName = ""; - if (!ParsePayload(payload, uid, pid, bundleName)) { - return; - } - switch (requestType) { - case MSG_FOREGROUND: - NewForeground(uid, pid); - break; - case MSG_BACKGROUND: - NewBackground(uid, pid); - break; - case MSG_APP_START: - NewAppStart(uid, pid, bundleName, ParseAppType(payload)); - break; - case MSG_APP_KILLED: - AppKilled(uid, pid); - break; - case MSG_CONTINUOUS_TASK_START: - case MSG_CONTINUOUS_TASK_END: - ContinuousTaskProcess(uid, pid, requestType); - break; - case MSG_GET_FOCUS: - case MSG_LOSE_FOCUS: - FocusStatusProcess(uid, pid, requestType); - break; - case MSG_ENTER_INTERACTION_SCENE: - case MSG_EXIT_INTERACTION_SCENE: - InteractionSceneProcess(requestType); - break; - default: - CONCUR_LOGE("Unknown system request"); - break; - } -} - -std::list::iterator TaskController::GetRecordOfPid(int pid) -{ - std::lock_guard lock(appInfoLock_); - for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { - if (iter->GetPid() == pid) { - return iter; - } - } - return foregroundApp_.end(); -} - -void TaskController::NewForeground(int uid, int pid) -{ - int uiTid = pid; - auto it = find(authApps_.begin(), authApps_.end(), pid); - if (it == authApps_.end()) { - CONCUR_LOGI("un-authed pid %{public}d", pid); - return; - } - int ret = AuthGet(pid); - if (ret != static_cast(AuthStatus::AUTH_STATUS_FOCUS)) { - unsigned int pidParam = static_cast(pid); - unsigned int uaFlag = AF_RTG_ALL; - unsigned int status = static_cast(AuthStatus::AUTH_STATUS_FOREGROUND); - int ret = AuthEnable(pidParam, uaFlag, status); - if (ret == 0) { - CONCUR_LOGI("auth_enable %{public}d success", pid); - } else { - CONCUR_LOGE("auth_enable %{public}d fail with ret %{public}d", pid, ret); - } - CONCUR_LOGI("pid %{public}d change to foreground.", pid); - } else { - CONCUR_LOGI("pid %{public}d is already focus", pid); - } - bool found = false; - bool ddlEnabled = OHOS::system::GetBoolParameter(INTERVAL_DDL, false); - std::lock_guard lock(appInfoLock_); - for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { - if (iter->GetPid() == pid) { - found = true; - if (ddlEnabled && pid != curGamePid_) { - iter->AddKeyThread(uiTid, PRIO_RT); - } - iter->BeginScene(); - } - } - if (!found) { - NewForegroundAppRecord(pid, uiTid, ddlEnabled); - } -} - -void TaskController::NewForegroundAppRecord(int pid, int uiTid, bool ddlEnabled) -{ - ForegroundAppRecord& appRecord = foregroundApp_.emplace_back(pid, uiTid, uniAppRate_, pid != curGamePid_); - if (foregroundApp_.size() <= 0 || appRecord.GetPid() != pid) { - CONCUR_LOGE("pid %{public}d create app record failed", pid); - return; - } - if (appRecord.IsValid()) { - if (ddlEnabled && pid != curGamePid_) { - appRecord.AddKeyThread(uiTid, PRIO_RT); - } - appRecord.BeginScene(); - } -} - -void TaskController::NewBackground(int uid, int pid) -{ - auto it = find(authApps_.begin(), authApps_.end(), pid); - if (it == authApps_.end()) { - CONCUR_LOGI("un-authed pid %{public}d", pid); - return; - } - CONCUR_LOGI("pid %{public}d change to background.", pid); - unsigned int pidParam = static_cast(pid); - - int ret = AuthPause(pidParam); - if (ret == 0) { - CONCUR_LOGI("auth_pause %{public}d success", pid); - } else { - CONCUR_LOGI("auth_pause %{public}d fail with %{public}d", pid, ret); - } - std::lock_guard lock(appInfoLock_); - for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { - if (iter->GetPid() == pid) { - iter->EndScene(); - return; - } - } -} - -void TaskController::NewAppStart(int uid, int pid, const std::string& bundleName, int appType) -{ - CONCUR_LOGI("pid %{public}d start.", pid); - unsigned int pidParam = static_cast(pid); - unsigned int uaFlag = AF_RTG_ALL; - unsigned int status = static_cast(AuthStatus::AUTH_STATUS_DEFAULT); - - int ret = AuthEnable(pidParam, uaFlag, status); - if (ret == 0) { - CONCUR_LOGI("auth_enable %{public}d success", pid); - } else { - CONCUR_LOGE("auth_enable %{public}d fail with ret %{public}d", pid, ret); - return; - } - std::lock_guard lock(appInfoLock_); - authApps_.push_back(pid); - appBundleName[pid] = bundleName; - if (ddlSceneSchedSwitch_ && appType != APP_TYPE_INVALID) { - appTypeCache_[pid] = appType; - } -} - -void TaskController::AppKilled(int uid, int pid) -{ - CONCUR_LOGI("pid %{public}d killed.", pid); - unsigned int pidParam = static_cast(pid); - int ret = AuthDelete(pidParam); - if (ret == 0) { - CONCUR_LOGI("auth_delete %{public}d success", pid); - } else { - CONCUR_LOGE("auth_delete %{public}d fail with %{public}d", pid, ret); - } - std::lock_guard lock(appInfoLock_); - for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { - if (iter->GetPid() == pid) { - foregroundApp_.erase(iter++); - break; - } - } - for (auto iter = authApps_.begin(); iter != authApps_.end(); iter++) { - if (*iter == pid) { - authApps_.erase(iter); - break; - } - } - appBundleName.erase(pid); - if (ddlSceneSchedSwitch_) { - appTypeCache_.erase(pid); - } -} - -int TaskController::AuthSystemProcess(int pid) -{ - unsigned int uaFlag = AF_RTG_ALL; - unsigned int status = static_cast(AuthStatus::AUTH_STATUS_SYSTEM_SERVER); - int ret = AuthEnable(pid, uaFlag, status); - if (ret == 0) { - CONCUR_LOGI("auth process %{public}d success", pid); - } else { - CONCUR_LOGI("auth process %{public}d failed, ret %{public}d", pid, ret); - } - return ret; -} - -void TaskController::ContinuousTaskProcess(int uid, int pid, int status) -{ - int ret = -1; - if (status == static_cast(MSG_CONTINUOUS_TASK_START)) { - ret = AuthEnhance(pid, true); - CONCUR_LOGI("auth_enhance pid %{public}d start, ret %{public}d", pid, ret); - } else if (status == static_cast(MSG_CONTINUOUS_TASK_END)) { - ret = AuthEnhance(pid, false); - CONCUR_LOGI("auth_enhance pid %{public}d end, ret %{public}d", pid, ret); - } else { - CONCUR_LOGE("Invalid auth_enhance status %{public}d", status); - } -} - -void TaskController::FocusStatusProcess(int uid, int pid, int status) -{ - int ret = -1; - unsigned int rtgFlag = AF_RTG_ALL; - unsigned int qosFlag = AF_QOS_DELEGATED; - if (status == static_cast(MSG_GET_FOCUS)) { - ret = AuthSwitch(pid, rtgFlag, qosFlag, static_cast(AuthStatus::AUTH_STATUS_FOCUS)); - CONCUR_LOGI("pid %{public}d get focus. ret %{public}d", pid, ret); - if (ddlSceneSchedSwitch_) { - if (IsVideoApp(pid)) { - isVideoApp_ = true; - CONCUR_LOGD("video app bundleName %{public}s get focus", appBundleName[pid].c_str()); - } else { - isVideoApp_ = false; - } - } - } else if (status == static_cast(MSG_LOSE_FOCUS)) { - ret = AuthSwitch(pid, rtgFlag, qosFlag, static_cast(AuthStatus::AUTH_STATUS_FOREGROUND)); - CONCUR_LOGI("pid %{public}d lose focus. ret %{public}d", pid, ret); - isVideoApp_ = false; - } else { - CONCUR_LOGE("Invalid focus status %{public}d", status); - } -} - -void TaskController::InteractionSceneProcess(int status) -{ - std::lock_guard lock(ddlPowerModeLock_); - if (ddlSceneSchedSwitch_) { - if (status == MSG_ENTER_INTERACTION_SCENE) { - DeadlinePerfMode(); - } else if (status == MSG_EXIT_INTERACTION_SCENE) { - if (isVideoApp_) { - return; - } - DeadlinePowerMode(); - } - } -} - -void TaskController::DeadlinePerfMode() -{ - if (ddlPowerModeEnable_) { - StartTrace(HITRACE_TAG_ACE, "Deadline perf mode"); - SetAppAndRenderServiceRate(uniAppRate_, systemRate_); - ddlPowerModeEnable_ = false; - CONCUR_LOGI("Deadline switch to perf mode"); - FinishTrace(HITRACE_TAG_ACE); - } -} - -void TaskController::DeadlinePowerMode() -{ - if (!ddlPowerModeEnable_) { - StartTrace(HITRACE_TAG_ACE, "Deadline power mode"); - int appRate = uniAppRate_; - int rsRate = systemRate_; - if (configReader_) { - appRate = configReader_->GetDegratationFps(appRate); - rsRate = configReader_->GetDegratationFps(rsRate); - } - SetAppAndRenderServiceRate(appRate, rsRate); - ddlPowerModeEnable_ = true; - CONCUR_LOGI("Deadline switch to power mode"); - FinishTrace(HITRACE_TAG_ACE); - } -} -void TaskController::QueryDeadline(int queryItem, DeadlineReply& ddlReply, const Json::Value& payload) -{ - pid_t uid = IPCSkeleton::GetInstance().GetCallingUid(); - std::string processName = GetProcessNameByToken(); - if (processName != RENDER_SERVICE_PROCESS_NAME && processName != GAME_ACCELERATE_SCHED_PROCESS_NAME) { - CONCUR_LOGE("Invalid uid %{public}d, only RS or RSS can call QueryDeadline", uid); - return; - } - switch (queryItem) { - case DDL_RATE: { - ModifySystemRate(payload); - break; - } - case MSG_GAME: { - ModifyGameState(payload); - break; - } - default: { - break; - } - } -} - -void TaskController::ModifyGameState(const Json::Value& payload) -{ - if (!CheckJsonValid(payload)) { - CONCUR_LOGE("[MSG_GAME]receive json invalid"); - return; - } - if (payload["gameMsg"].isNull()) { - CONCUR_LOGE("[MSG_GAME]message is null"); - return; - } - std::string gameMsg = payload["gameMsg"].asString(); - int oldGamePid = curGamePid_; - int newGamePid = GetGamePid(gameMsg); - curGamePid_ = newGamePid; - CONCUR_LOGI("[MSG_GAME]current game pid is %{public}d, old game pid is %{public}d", - newGamePid, oldGamePid); - if (curGamePid_ == -1) { - return; - } - std::lock_guard lock(appInfoLock_); - for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { - if (iter->GetPid() == curGamePid_ && iter->GetGrpId() >= 0) { - CONCUR_LOGI("[MSG_GAME]destroy rtg grp, pid is %{public}d grpId is %{public}d", - iter->GetPid(), iter->GetGrpId()); - DestroyRtgGrp(iter->GetGrpId()); - iter->SetGrpId(-1); - break; - } - } - return; -} - -int TaskController::GetGamePid(const std::string &gameMsg) const -{ - GameStatus status = GetGameScene(gameMsg); - CONCUR_LOGI("[MSG_GAME]gamescene status %{public}d", status); - int gamePid = -1; - if (status == GAME_ENTRY_MSG) { - size_t pos = gameMsg.find(","); - if (pos == string::npos) { - return -1; - } - int ret = sscanf_s(gameMsg.substr(0, pos).c_str(), "{\"gamePid\":\"%d\"", &gamePid); - if (ret == -1) { - CONCUR_LOGE("[MSG_GAME]message parsing failed, ret is %{public}d", ret); - } else { - CONCUR_LOGI("[MSG_GAME]message parsing success"); - } - } - return gamePid; -} - -GameStatus TaskController::GetGameScene(const std::string &gameMsg) const -{ - if (gameMsg.find("gameScene\":\"1") != std::string::npos) { - return GAME_ENTRY_MSG; - } - if (gameMsg.find("gameScene\":\"0") != std::string::npos) { - return GAME_EXIT_MSG; - } - if (gameMsg.find("cameraScene\":\"1") != std::string::npos) { - return CAMERA_ENTRY_MSG; - } - if (gameMsg.find("cameraScene\":\"0") != std::string::npos) { - return CAMERA_EXIT_MSG; - } - if (gameMsg.find("GTXGamePid\":") != std::string::npos) { - return GAME_GTX_MSG; - } - return STATUS_MSG_MAX; -} - -bool TaskController::ModifySystemRate(const Json::Value& payload) -{ - if (!CheckJsonValid(payload)) { - CONCUR_LOGI("service receive json invalid"); - return false; - } - SetAppRate(payload); - SetRenderServiceRate(payload); - return true; -} - -void TaskController::UpdateAllAppRate(int appRate) -{ - std::lock_guard lock(appInfoLock_); - for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { - iter->UpdateRate(appRate); - } -} - -void TaskController::SetAppRate(const Json::Value& payload) -{ - int rtgId = 0; - int uiTid = 0; - int appRate = FindRateFromInfo(UNI_APP_RATE_ID, payload); - if (appRate > 0 && appRate != uniAppRate_) { - CONCUR_LOGD("set unified app rate %{public}d", appRate); - uniAppRate_ = appRate; - if (ddlSceneSchedSwitch_ && ddlPowerModeEnable_ && configReader_) { - appRate = configReader_->GetDegratationFps(appRate); - } - bool ret = OHOS::system::SetParameter(INTERVAL_APP_RATE, std::to_string(appRate)); - if (ret == false) { - CONCUR_LOGI("set app rate param failed"); - } - UpdateAllAppRate(appRate); - StartTrace(HITRACE_TAG_ACE, - "SetAppRate:" + std::to_string(appRate) + " ret:" + std::to_string(ret)); - FinishTrace(HITRACE_TAG_ACE); - return; - } -} - -int TaskController::FindRateFromInfo(int uiTid, const Json::Value& payload) -{ - int appRate = 0; - if (payload[std::to_string(uiTid)].isNull()) { - CONCUR_LOGI("FindRateFromInfo tid %{public}d is null", uiTid); - return appRate; - } - try { - appRate = stoi(payload[std::to_string(uiTid)].asString()); - } catch (...) { - CONCUR_LOGI("application %{public}d is not in rtg_group", uiTid); - } - return appRate; -} - -void TaskController::SetRenderServiceRate(const Json::Value& payload) -{ - int rsRate = FindRateFromInfo(renderServiceMainTid_, payload); - std::lock_guard lock(rateInfoLock_); - if (renderServiceMainGrpId_ > 0 && rsRate > 0 && rsRate != systemRate_) { - CONCUR_LOGD("set rs rate %{public}d rtgId is %{public}d, old rate is %{public}d", - rsRate, renderServiceMainGrpId_, systemRate_); - SetFrameRate(renderServiceMainGrpId_, rsRate); - systemRate_ = rsRate; - if (ddlSceneSchedSwitch_ && ddlPowerModeEnable_ && configReader_) { - rsRate = configReader_->GetDegratationFps(rsRate); - } - bool ret = OHOS::system::SetParameter(INTERVAL_RS_RATE, std::to_string(rsRate)); - if (ret == false) { - CONCUR_LOGI("set rs rate param failed"); - } - StartTrace(HITRACE_TAG_ACE, - "SetRSRate:" + std::to_string(rsRate) + " ret:" + std::to_string(ret)); - FinishTrace(HITRACE_TAG_ACE); - } -} - -void TaskController::SetAppAndRenderServiceRate(int appRate, int rsRate) -{ - bool ret = OHOS::system::SetParameter(INTERVAL_APP_RATE, std::to_string(appRate)); - if (ret == false) { - CONCUR_LOGI("set app rate param failed"); - } - UpdateAllAppRate(appRate); - StartTrace(HITRACE_TAG_ACE, - "SetAppRate:" + std::to_string(appRate) + " ret:" + std::to_string(ret)); - FinishTrace(HITRACE_TAG_ACE); - - ret = OHOS::system::SetParameter(INTERVAL_RS_RATE, std::to_string(rsRate)); - if (ret == false) { - CONCUR_LOGI("set rs rate param failed"); - } - StartTrace(HITRACE_TAG_ACE, - "SetRSRate:" + std::to_string(rsRate) + " ret:" + std::to_string(ret)); - FinishTrace(HITRACE_TAG_ACE); -} - -bool TaskController::CheckJsonValid(const Json::Value& payload) -{ - Json::ValueType type = payload.type(); - if (type != Json::objectValue) { - CONCUR_LOGE("error payload"); - return false; - } - if (payload.empty()) { - CONCUR_LOGI("payload empty"); - return false; - } - return true; -} - -void TaskController::SetFrameRate(int rtgId, int rate) -{ - if (rtgId > 0) { - SetFrameRateAndPrioType(rtgId, rate, PARAM_TYPE); - } -} - -void TaskController::PrintInfo() -{ - std::lock_guard lock(appInfoLock_); - for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { - iter->PrintKeyThreads(); - } -} - -int TaskController::CreateNewRtgGrp(int prioType, int rtNum) -{ - struct rtg_grp_data grp_data; - int ret; - char fileName[] = "/proc/self/sched_rtg_ctrl"; - int fd = open(fileName, O_RDWR); - if (fd < 0) { - CONCUR_LOGE("Open file /proc/self/sched_rth_ctrl, errno = %{public}d", errno); - return fd; - } - (void)memset_s(&grp_data, sizeof(struct rtg_grp_data), 0, sizeof(struct rtg_grp_data)); - if ((prioType > 0) && (prioType < RTG_TYPE_MAX)) { - grp_data.prio_type = prioType; - } - if (rtNum > 0) { - grp_data.rt_cnt = rtNum; - } - grp_data.rtg_cmd = CMD_CREATE_RTG_GRP; - ret = ioctl(fd, CMD_ID_SET_RTG, &grp_data); - if (ret < 0) { - CONCUR_LOGE("create rtg grp failed, errno = %{public}d (%{public}s)", errno, strerror(errno)); - } else { - CONCUR_LOGI("create rtg grp success, get rtg id %{public}d.", ret); - } - close(fd); - return ret; -} - -int TaskController::ParseAppType(const Json::Value& payload) -{ - int appType = APP_TYPE_INVALID; - if (payload.isMember("appType") && payload["appType"].isString()) { - try { - appType = stoi(payload["appType"].asString()); - } catch (...) { - CONCUR_LOGE("Unexpected apptype format"); - return APP_TYPE_INVALID; - } - } - return appType; -} - -bool TaskController::IsVideoApp(int pid) -{ - if (!ddlSceneSchedSwitch_) { - return false; - } - if (appTypeCache_.find(pid) != appTypeCache_.end()) { - return appTypeCache_[pid] == APP_TYPE_VIDEO || - appTypeCache_[pid]== APP_TYPE_VIDEO_CLIP; - } - return false; -} - -ForegroundAppRecord::ForegroundAppRecord(int pid, int uiTid, int appRate, bool createGrp) -{ - pid_ = pid; - uiTid_ = uiTid; - rate_ = appRate; - if (OHOS::system::GetBoolParameter(INTERVAL_DDL, false) && createGrp) { - grpId_ = TaskController::GetInstance().CreateNewRtgGrp(PRIO_RT, MAX_KEY_THREADS); - } else { - grpId_ = -1; - } -} - -ForegroundAppRecord::~ForegroundAppRecord() -{ - if (grpId_ > 0) { - DestroyRtgGrp(grpId_); - } - if (selfRenderGrpId_ > 0) { - DestroyRtgGrp(selfRenderGrpId_); - } -} - -void ForegroundAppRecord::AddKeyThread(int tid, int prio) -{ - int rtgPrio = (prio >= PRIO_NORMAL) ? PRIO_NORMAL : PRIO_RT; - if (keyThreads_.find(tid) != keyThreads_.end()) { - return; - } - if (grpId_ <= 0) { - CONCUR_LOGI("Add key thread fail: Grp id not been created success, tid is %{public}d", tid); - return; - } - if (keyThreads_.size() >= MAX_KEY_THREADS) { - CONCUR_LOGI("Add key thread fail: Key threads num limit."); - return; - } - if (prio == RPIO_IN) { - setpriority(PRIO_PROCESS, tid, -13); // -13 represent spcial nice in qos - } else { - int ret = AddThreadToRtg(tid, grpId_, rtgPrio); - if (ret != 0) { - CONCUR_LOGI("Add key thread fail: Kernel err report. ret is %{public}d", ret); - } else { - CONCUR_LOGI("Add key thread %{public}d", tid); - } - keyThreads_.insert(tid); - } -} - -void ForegroundAppRecord::TryCreateSelfRenderGrp() -{ - if (selfRenderGrpId_ > 0) { - CONCUR_LOGI("self render group %{public}d already create", selfRenderGrpId_); - return; - } - int ret = 0; - ret = TaskController::GetInstance().CreateNewRtgGrp(PRIO_RT, MAX_KEY_THREADS); - if (ret < 0) { - CONCUR_LOGE("TryCreateSelfRenderGrp create group failed: %{public}d", ret); - return; - } - selfRenderGrpId_ = ret; - SetFrameRateAndPrioType(selfRenderGrpId_, rate_, PARAM_TYPE); -} - -int ForegroundAppRecord::SetTaskSmt(int tid, unsigned int smt_type) -{ - struct TaskConfig task_config; - int ret = 0; - int fd = open("/dev/hisi_perf_ctrl", O_RDWR); - if (fd < 0) { - CONCUR_LOGE("Open file /dev/hisi_perf_ctrl, errno = %{public}d", errno); - return fd; - } - (void)memset_s(&task_config, sizeof(struct TaskConfig), 0, sizeof(struct TaskConfig)); - task_config.pid = tid; - task_config.value = smt_type; - ret = ioctl(fd, PERF_CTRL_SET_TASK_NO_SMT, &task_config); - if (ret < 0) { - CONCUR_LOGE("set task %{public}d smt %{public}u failed, errno = %{public}d (%{public}s)", - tid, smt_type, errno, strerror(errno)); - } else { - CONCUR_LOGI("set task %{public}d smt %{public}u success", tid, smt_type); -- Gitee From 211070defbce7275ed131d79c6b944bdf589bfa6 Mon Sep 17 00:00:00 2001 From: liuyuxiu Date: Wed, 7 Aug 2024 11:27:44 +0800 Subject: [PATCH 03/10] qos_manager Signed-off-by: liuyuxiu --- services/src/concurrent_task_controller.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/services/src/concurrent_task_controller.cpp b/services/src/concurrent_task_controller.cpp index c7cd9e2..bbd77a5 100644 --- a/services/src/concurrent_task_controller.cpp +++ b/services/src/concurrent_task_controller.cpp @@ -53,7 +53,7 @@ namespace { #define SMT_EXPELLER 2U #define SET_TASK_NO_SMT 41 #define CMD_ID_SET_RTG \ - _IOWR(RTG_SCHED_IPC_MAGIC, SET_RTG, struct rtg_str_data)\ + _IOWR(RTG_SCHED_IPC_MAGIC, SET_RTG, struct rtg_str_data) #define PERF_CTRL_SET_TASK_NO_SMT \ _IOWR(PERF_CTRL_MAGIC, SET_TASK_NO_SMT, struct TaskConfig) -- Gitee From 5cb8e95227562e8dbe679f2804a2a6e5a14fd700 Mon Sep 17 00:00:00 2001 From: liuyuxiu Date: Wed, 7 Aug 2024 11:45:06 +0800 Subject: [PATCH 04/10] qos_manager Signed-off-by: liuyuxiu --- services/src/concurrent_task_controller.cpp | 197 ++++++++++++++++++++ 1 file changed, 197 insertions(+) diff --git a/services/src/concurrent_task_controller.cpp b/services/src/concurrent_task_controller.cpp index bbd77a5..ad6fb21 100644 --- a/services/src/concurrent_task_controller.cpp +++ b/services/src/concurrent_task_controller.cpp @@ -1151,3 +1151,200 @@ int ForegroundAppRecord::SetTaskSmt(int tid, unsigned int smt_type) tid, smt_type, errno, strerror(errno)); } else { CONCUR_LOGI("set task %{public}d smt %{public}u success", tid, smt_type); + } + close(fd); + return ret; +} + +int ForegroundAppRecord::AddSelfRenderTid(IntervalReply& queryRs) +{ + int tid = queryRs.tid; + if (selfRenderGrpId_ <= 0) { + TryCreateSelfRenderGrp(); + CONCUR_LOGI("tid %{public}d add self render failed and create %{public}d", tid, selfRenderGrpId_); + if (selfRenderGrpId_ <= 0) { + CONCUR_LOGE("tid %{public}d create self render group failed", tid); + return -1; + } + } + queryRs.rtgId = selfRenderGrpId_; + if (selfRenderTids_.find(tid) != selfRenderTids_.end()) { + CONCUR_LOGI("tid %{public}d already in self render group", tid); + return 0; + } + int check_qos = queryRs.paramA; + int ret = AddThreadToRtg(tid, selfRenderGrpId_, PRIO_RT, check_qos); + if (ret != 0) { + CONCUR_LOGE("tid %{public}d check_qos %{public}d join self render group failed: %{public}d", + tid, check_qos, ret); + return ret; + } + ret = SetTaskSmt(tid, SMT_EXPELLER); + if (ret != 0) { + CONCUR_LOGE("tid %{public}d set smt %{public}u failed: %{public}d", tid, SMT_EXPELLER, ret); + } + selfRenderTids_.insert(tid); + selfRenderTidCheckQos_[tid] = check_qos; + return ret; +} + +int ForegroundAppRecord::RemoveSelfRenderTid(IntervalReply& queryRs) +{ + int tid = queryRs.tid; + if (selfRenderTids_.find(tid) == selfRenderTids_.end()) { + return 0; + } + if (selfRenderGrpId_ <= 0) { + CONCUR_LOGI("Remove self render tid fail: Grp id not been created success, tid is %{public}d", tid); + return -1; + } + int check_qos = queryRs.paramA; + int ret = SetTaskSmt(tid, SMT_EXPELLEE); + if (ret != 0) { + CONCUR_LOGE("tid %{public}d set smt %{public}u failed: %{public}d", tid, SMT_EXPELLEE, ret); + } + ret = RemoveRtgThread(tid, check_qos); + if (ret != 0) { + CONCUR_LOGE("tid %{public}d check_qos %{public}d exit self render group failed: %{public}d", + tid, check_qos, ret); + } + selfRenderTids_.erase(tid); + selfRenderTidCheckQos_.erase(tid); + return ret; +} + +bool ForegroundAppRecord::BeginScene() +{ + if (grpId_ <= 0) { + CONCUR_LOGI("Error begin scene in pid %{public}d", pid_); + return false; + } + OHOS::RME::BeginFrameFreq(0); + OHOS::RME::EndFrameFreq(0); + isForeground_ = true; + if (selfRenderGrpId_ < 0 && selfRenderStop_) { + int ret = 0; + ret = TaskController::GetInstance().CreateNewRtgGrp(PRIO_RT, MAX_KEY_THREADS); + if (ret < 0) { + CONCUR_LOGE("StartSelfRender create group failed."); + return false; + } + selfRenderGrpId_ = ret; + SetFrameRateAndPrioType(selfRenderGrpId_, rate_, PARAM_TYPE); + for (auto it = selfRenderTids_.begin(); it != selfRenderTids_.end(); it) { + ret = AddThreadToRtg(*it, selfRenderGrpId_, PRIO_RT, selfRenderTidCheckQos_[*it]); + if (ret != 0) { + CONCUR_LOGE("tid %{public}d join self render group failed.", *it); + return false; + } + ret = SetTaskSmt(*it, SMT_EXPELLER); + if (ret != 0) { + CONCUR_LOGE("tid %{public}d set smt %{public}u failed: %{public}d", *it, SMT_EXPELLER, ret); + } + } + selfRenderStop_ = false; + } + return true; +} + +bool ForegroundAppRecord::EndScene() +{ + if (grpId_ <= 0) { + CONCUR_LOGI("Error end scene loss grpId_ in pid %{public}d", pid_); + return false; + } + OHOS::RME::EndScene(grpId_); + isForeground_ = false; + if (selfRenderGrpId_ > 0) { + int ret = 0; + for (auto it = selfRenderTids_.begin(); it != selfRenderTids_.end(); it) { + ret = SetTaskSmt(*it, SMT_EXPELLEE); + if (ret != 0) { + CONCUR_LOGE("tid %{public}d set smt %{public}u failed: %{public}d", *it, SMT_EXPELLEE, ret); + } + } + OHOS::RME::DestroyRtgGrp(selfRenderGrpId_); + selfRenderGrpId_ = -1; + selfRenderStop_ = true; + } + return true; +} + +void ForegroundAppRecord::UpdateRate(int appRate) +{ + if (uiTid_ <= 0 || grpId_ <= 0) { + CONCUR_LOGI("set app rate failed: uiTid=%{public}d grpId=%{public}d", uiTid_, grpId_); + return; + } + if (appRate > 0 && appRate != rate_) { + int oldRate = rate_; + rate_ = appRate; + if (!isForeground_) { + CONCUR_LOGD("set app rate failed: uiTid=%{public}d grpId=%{public}d is not foreground", uiTid_, grpId_); + return; + } + if (selfRenderGrpId_ > 0) { + SetFrameRateAndPrioType(selfRenderGrpId_, appRate, PARAM_TYPE); + CONCUR_LOGI("set self render rate %{public}d rtgId is %{public}d, old rate is %{public}d", + appRate, selfRenderGrpId_, oldRate); + } + } +} + +int ForegroundAppRecord::GetPid() const +{ + return pid_; +} + +int ForegroundAppRecord::GetGrpId() const +{ + return grpId_; +} + +void ForegroundAppRecord::SetGrpId(int grpId) +{ + grpId_ = grpId; +} + +void ForegroundAppRecord::SetRate(int appRate) +{ + rate_ = appRate; +} + +int ForegroundAppRecord::GetRate() const +{ + return rate_; +} + +void ForegroundAppRecord::SetUiTid(int uiTid) +{ + uiTid_ = uiTid; +} + +int ForegroundAppRecord::GetUiTid() const +{ + return uiTid_; +} + +bool ForegroundAppRecord::IsValid() +{ + if (pid_ > 0) { + return true; + } + return false; +} + +void ForegroundAppRecord::PrintKeyThreads() +{ + std::string strLog = "pid "; + strLog.append(std::to_string(pid_)); + strLog.append(" has key threads: "); + for (auto iter = keyThreads_.begin(); iter != keyThreads_.end(); iter++) { + std::string temp = std::to_string(*iter); + strLog.append(temp); + strLog.append(", "); + } + CONCUR_LOGD("%{public}s", strLog.c_str()); +} +} // namespace ConcurrentTask +} // namespace OHOS \ No newline at end of file -- Gitee From bba51bee5d260ecdf5c04ffe1a1e6eae77456e56 Mon Sep 17 00:00:00 2001 From: liuyuxiu Date: Fri, 9 Aug 2024 16:29:02 +0800 Subject: [PATCH 05/10] qos_manager Signed-off-by: liuyuxiu --- services/src/concurrent_task_controller.cpp | 22 --------------------- 1 file changed, 22 deletions(-) diff --git a/services/src/concurrent_task_controller.cpp b/services/src/concurrent_task_controller.cpp index ad6fb21..6b8557f 100644 --- a/services/src/concurrent_task_controller.cpp +++ b/services/src/concurrent_task_controller.cpp @@ -225,28 +225,6 @@ void TaskController::QueryRenderService(int uid, IntervalReply& queryRs) SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); } -void TaskController::QueryRenderServiceMain(int uid, int pid, IntervalReply& queryRs) -{ - if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { - return; - } - if (!rsAuthed_) { - if (AuthSystemProcess(pid) != 0) { - return; - SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); -} - -void TaskController::QueryRenderServiceMain(int uid, int pid, IntervalReply& queryRs) -{ - if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { - return; - } - if (!rsAuthed_) { - if (AuthSystemProcess(pid) != 0) { - return; - SetFrameRateAndPrioType(renderServiceMainGrpId_, CURRENT_RATE, PARAM_TYPE); -} - void TaskController::QueryRenderServiceMain(int uid, int pid, IntervalReply& queryRs) { if (GetProcessNameByToken() != RENDER_SERVICE_PROCESS_NAME) { -- Gitee From 89f5be5eb0f406c66d698462e750163507afc338 Mon Sep 17 00:00:00 2001 From: liuyuxiu Date: Mon, 12 Aug 2024 11:09:22 +0800 Subject: [PATCH 06/10] qos_manager Signed-off-by: liuyuxiu --- common/include/config_reader.h | 1 + common/src/config_reader.cpp | 1 - services/src/concurrent_task_controller.cpp | 3 +-- 3 files changed, 2 insertions(+), 3 deletions(-) diff --git a/common/include/config_reader.h b/common/include/config_reader.h index fb78112..a2c73ca 100644 --- a/common/include/config_reader.h +++ b/common/include/config_reader.h @@ -23,6 +23,7 @@ namespace OHOS { namespace ConcurrentTask { +constexpr int FPS_OFFSET = 10000; class ConfigReader { public: bool LoadFromConfigFile(const std::string& configFile); diff --git a/common/src/config_reader.cpp b/common/src/config_reader.cpp index bdc3e8a..e8ddb3a 100644 --- a/common/src/config_reader.cpp +++ b/common/src/config_reader.cpp @@ -39,7 +39,6 @@ namespace { const std::string XML_TAG_FPS_HIGH = "120"; const std::string XML_TAG_FPS_MEDIUM = "90"; const std::string XML_TAG_FPS_STANDARD = "60"; - constexpr int FPS_OFFSET = 10000; } bool ConfigReader::IsValidNode(const xmlNode* currNode) diff --git a/services/src/concurrent_task_controller.cpp b/services/src/concurrent_task_controller.cpp index 6b8557f..e577fd5 100644 --- a/services/src/concurrent_task_controller.cpp +++ b/services/src/concurrent_task_controller.cpp @@ -877,6 +877,7 @@ bool TaskController::ModifySystemRate(const Json::Value& payload) void TaskController::UpdateAllAppRate(int appRate) { + appRate = appRate > FPS_OFFSET ? appRate - FPS_OFFSET : appRate; std::lock_guard lock(appInfoLock_); for (auto iter = foregroundApp_.begin(); iter != foregroundApp_.end(); iter++) { iter->UpdateRate(appRate); @@ -885,8 +886,6 @@ void TaskController::UpdateAllAppRate(int appRate) void TaskController::SetAppRate(const Json::Value& payload) { - int rtgId = 0; - int uiTid = 0; int appRate = FindRateFromInfo(UNI_APP_RATE_ID, payload); if (appRate > 0 && appRate != uniAppRate_) { CONCUR_LOGD("set unified app rate %{public}d", appRate); -- Gitee From 85ec602fca3d0feb8f87c9d8e410e2e2d350d66e Mon Sep 17 00:00:00 2001 From: liuyuxiu Date: Mon, 12 Aug 2024 14:36:49 +0800 Subject: [PATCH 07/10] qos_manager --- services/src/concurrent_task_controller.cpp | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/services/src/concurrent_task_controller.cpp b/services/src/concurrent_task_controller.cpp index e577fd5..4f7f03d 100644 --- a/services/src/concurrent_task_controller.cpp +++ b/services/src/concurrent_task_controller.cpp @@ -1150,7 +1150,7 @@ int ForegroundAppRecord::AddSelfRenderTid(IntervalReply& queryRs) return 0; } int check_qos = queryRs.paramA; - int ret = AddThreadToRtg(tid, selfRenderGrpId_, PRIO_RT, check_qos); + int ret = AddThreadToRtg(tid, selfRenderGrpId_, PRIO_RT); if (ret != 0) { CONCUR_LOGE("tid %{public}d check_qos %{public}d join self render group failed: %{public}d", tid, check_qos, ret); @@ -1180,7 +1180,7 @@ int ForegroundAppRecord::RemoveSelfRenderTid(IntervalReply& queryRs) if (ret != 0) { CONCUR_LOGE("tid %{public}d set smt %{public}u failed: %{public}d", tid, SMT_EXPELLEE, ret); } - ret = RemoveRtgThread(tid, check_qos); + ret = RemoveRtgThread(tid); if (ret != 0) { CONCUR_LOGE("tid %{public}d check_qos %{public}d exit self render group failed: %{public}d", tid, check_qos, ret); @@ -1208,8 +1208,8 @@ bool ForegroundAppRecord::BeginScene() } selfRenderGrpId_ = ret; SetFrameRateAndPrioType(selfRenderGrpId_, rate_, PARAM_TYPE); - for (auto it = selfRenderTids_.begin(); it != selfRenderTids_.end(); it) { - ret = AddThreadToRtg(*it, selfRenderGrpId_, PRIO_RT, selfRenderTidCheckQos_[*it]); + for (auto it = selfRenderTids_.begin(); it != selfRenderTids_.end(); it++) { + ret = AddThreadToRtg(*it, selfRenderGrpId_, PRIO_RT); if (ret != 0) { CONCUR_LOGE("tid %{public}d join self render group failed.", *it); return false; @@ -1234,7 +1234,7 @@ bool ForegroundAppRecord::EndScene() isForeground_ = false; if (selfRenderGrpId_ > 0) { int ret = 0; - for (auto it = selfRenderTids_.begin(); it != selfRenderTids_.end(); it) { + for (auto it = selfRenderTids_.begin(); it != selfRenderTids_.end(); it++) { ret = SetTaskSmt(*it, SMT_EXPELLEE); if (ret != 0) { CONCUR_LOGE("tid %{public}d set smt %{public}u failed: %{public}d", *it, SMT_EXPELLEE, ret); -- Gitee From 6678591712daf9d021eb0ec878a14efe4818c008 Mon Sep 17 00:00:00 2001 From: liuyuxiu Date: Mon, 12 Aug 2024 16:07:25 +0800 Subject: [PATCH 08/10] qos_manager Signed-off-by: liuyuxiu --- services/src/concurrent_task_controller.cpp | 26 ++++++++++----------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/services/src/concurrent_task_controller.cpp b/services/src/concurrent_task_controller.cpp index 4f7f03d..9af0514 100644 --- a/services/src/concurrent_task_controller.cpp +++ b/services/src/concurrent_task_controller.cpp @@ -136,12 +136,12 @@ void TaskController::QueryInterval(int queryItem, IntervalReply& queryRs) case QUERY_EXECUTOR_START: QueryExecutorStart(uid, pid, queryRs); break; - case QUERY_SELF_RENDER_REMOVE_THREAD: - QuerySelfRenderRemoveThread(uid, pid, queryRs); - break; - case QUERY_SELF_RENDER_ADD_THREAD: + case QUERY_SELF_RENDER_REMOVE_THREAD: + QuerySelfRenderRemoveThread(uid, pid, queryRs); + break; + case QUERY_SELF_RENDER_ADD_THREAD: QuerySelfRenderAddThread(uid, pid, queryRs); - break; + break; default: break; } @@ -327,8 +327,8 @@ void TaskController::QuerySelfRenderRemoveThread(int uid, int pid, IntervalReply queryRs.paramA = iter->RemoveSelfRenderTid(queryRs); if (queryRs.paramA != 0) { CONCUR_LOGE("uid %{public}d pid %{public}d Query Self Render Remove Thread %{public}d failed: %{public}d", - uid, pid, queryRs.tid, queryRs.paramA); - } + uid, pid, queryRs.tid, queryRs.paramA); + } } } @@ -339,7 +339,7 @@ void TaskController::QuerySelfRenderAddThread(int uid, int pid, IntervalReply& q queryRs.paramA = iter->AddSelfRenderTid(queryRs); if (queryRs.paramA != 0) { CONCUR_LOGE("uid %{public}d pid %{public}d Query Self Render Add Thread %{public}d failed: %{public}d", - uid, pid, queryRs.tid, queryRs.paramA); + uid, pid, queryRs.tid, queryRs.paramA); } } } @@ -897,7 +897,7 @@ void TaskController::SetAppRate(const Json::Value& payload) if (ret == false) { CONCUR_LOGI("set app rate param failed"); } - UpdateAllAppRate(appRate); + UpdateAllAppRate(appRate); StartTrace(HITRACE_TAG_ACE, "SetAppRate:" + std::to_string(appRate) + " ret:" + std::to_string(ret)); FinishTrace(HITRACE_TAG_ACE); @@ -1125,7 +1125,7 @@ int ForegroundAppRecord::SetTaskSmt(int tid, unsigned int smt_type) ret = ioctl(fd, PERF_CTRL_SET_TASK_NO_SMT, &task_config); if (ret < 0) { CONCUR_LOGE("set task %{public}d smt %{public}u failed, errno = %{public}d (%{public}s)", - tid, smt_type, errno, strerror(errno)); + tid, smt_type, errno, strerror(errno)); } else { CONCUR_LOGI("set task %{public}d smt %{public}u success", tid, smt_type); } @@ -1153,7 +1153,7 @@ int ForegroundAppRecord::AddSelfRenderTid(IntervalReply& queryRs) int ret = AddThreadToRtg(tid, selfRenderGrpId_, PRIO_RT); if (ret != 0) { CONCUR_LOGE("tid %{public}d check_qos %{public}d join self render group failed: %{public}d", - tid, check_qos, ret); + tid, check_qos, ret); return ret; } ret = SetTaskSmt(tid, SMT_EXPELLER); @@ -1183,7 +1183,7 @@ int ForegroundAppRecord::RemoveSelfRenderTid(IntervalReply& queryRs) ret = RemoveRtgThread(tid); if (ret != 0) { CONCUR_LOGE("tid %{public}d check_qos %{public}d exit self render group failed: %{public}d", - tid, check_qos, ret); + tid, check_qos, ret); } selfRenderTids_.erase(tid); selfRenderTidCheckQos_.erase(tid); @@ -1263,7 +1263,7 @@ void ForegroundAppRecord::UpdateRate(int appRate) if (selfRenderGrpId_ > 0) { SetFrameRateAndPrioType(selfRenderGrpId_, appRate, PARAM_TYPE); CONCUR_LOGI("set self render rate %{public}d rtgId is %{public}d, old rate is %{public}d", - appRate, selfRenderGrpId_, oldRate); + appRate, selfRenderGrpId_, oldRate); } } } -- Gitee From dac3a4246d300d17971770e82504703a354eebb7 Mon Sep 17 00:00:00 2001 From: liuyuxiu Date: Mon, 12 Aug 2024 16:07:25 +0800 Subject: [PATCH 09/10] qos_manager Signed-off-by: liuyuxiu --- services/src/concurrent_task_controller.cpp | 28 ++++++++++----------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/services/src/concurrent_task_controller.cpp b/services/src/concurrent_task_controller.cpp index 4f7f03d..7257382 100644 --- a/services/src/concurrent_task_controller.cpp +++ b/services/src/concurrent_task_controller.cpp @@ -136,12 +136,12 @@ void TaskController::QueryInterval(int queryItem, IntervalReply& queryRs) case QUERY_EXECUTOR_START: QueryExecutorStart(uid, pid, queryRs); break; - case QUERY_SELF_RENDER_REMOVE_THREAD: - QuerySelfRenderRemoveThread(uid, pid, queryRs); - break; - case QUERY_SELF_RENDER_ADD_THREAD: + case QUERY_SELF_RENDER_REMOVE_THREAD: + QuerySelfRenderRemoveThread(uid, pid, queryRs); + break; + case QUERY_SELF_RENDER_ADD_THREAD: QuerySelfRenderAddThread(uid, pid, queryRs); - break; + break; default: break; } @@ -327,9 +327,9 @@ void TaskController::QuerySelfRenderRemoveThread(int uid, int pid, IntervalReply queryRs.paramA = iter->RemoveSelfRenderTid(queryRs); if (queryRs.paramA != 0) { CONCUR_LOGE("uid %{public}d pid %{public}d Query Self Render Remove Thread %{public}d failed: %{public}d", - uid, pid, queryRs.tid, queryRs.paramA); - } - } + uid, pid, queryRs.tid, queryRs.paramA); + } + } } void TaskController::QuerySelfRenderAddThread(int uid, int pid, IntervalReply& queryRs) @@ -339,7 +339,7 @@ void TaskController::QuerySelfRenderAddThread(int uid, int pid, IntervalReply& q queryRs.paramA = iter->AddSelfRenderTid(queryRs); if (queryRs.paramA != 0) { CONCUR_LOGE("uid %{public}d pid %{public}d Query Self Render Add Thread %{public}d failed: %{public}d", - uid, pid, queryRs.tid, queryRs.paramA); + uid, pid, queryRs.tid, queryRs.paramA); } } } @@ -897,7 +897,7 @@ void TaskController::SetAppRate(const Json::Value& payload) if (ret == false) { CONCUR_LOGI("set app rate param failed"); } - UpdateAllAppRate(appRate); + UpdateAllAppRate(appRate); StartTrace(HITRACE_TAG_ACE, "SetAppRate:" + std::to_string(appRate) + " ret:" + std::to_string(ret)); FinishTrace(HITRACE_TAG_ACE); @@ -1125,7 +1125,7 @@ int ForegroundAppRecord::SetTaskSmt(int tid, unsigned int smt_type) ret = ioctl(fd, PERF_CTRL_SET_TASK_NO_SMT, &task_config); if (ret < 0) { CONCUR_LOGE("set task %{public}d smt %{public}u failed, errno = %{public}d (%{public}s)", - tid, smt_type, errno, strerror(errno)); + tid, smt_type, errno, strerror(errno)); } else { CONCUR_LOGI("set task %{public}d smt %{public}u success", tid, smt_type); } @@ -1153,7 +1153,7 @@ int ForegroundAppRecord::AddSelfRenderTid(IntervalReply& queryRs) int ret = AddThreadToRtg(tid, selfRenderGrpId_, PRIO_RT); if (ret != 0) { CONCUR_LOGE("tid %{public}d check_qos %{public}d join self render group failed: %{public}d", - tid, check_qos, ret); + tid, check_qos, ret); return ret; } ret = SetTaskSmt(tid, SMT_EXPELLER); @@ -1183,7 +1183,7 @@ int ForegroundAppRecord::RemoveSelfRenderTid(IntervalReply& queryRs) ret = RemoveRtgThread(tid); if (ret != 0) { CONCUR_LOGE("tid %{public}d check_qos %{public}d exit self render group failed: %{public}d", - tid, check_qos, ret); + tid, check_qos, ret); } selfRenderTids_.erase(tid); selfRenderTidCheckQos_.erase(tid); @@ -1263,7 +1263,7 @@ void ForegroundAppRecord::UpdateRate(int appRate) if (selfRenderGrpId_ > 0) { SetFrameRateAndPrioType(selfRenderGrpId_, appRate, PARAM_TYPE); CONCUR_LOGI("set self render rate %{public}d rtgId is %{public}d, old rate is %{public}d", - appRate, selfRenderGrpId_, oldRate); + appRate, selfRenderGrpId_, oldRate); } } } -- Gitee From 6c6b5a4ce9c9762f0e1fb5a26fc346a8b499d643 Mon Sep 17 00:00:00 2001 From: liuyuxiu Date: Mon, 12 Aug 2024 08:49:10 +0000 Subject: [PATCH 10/10] update services/src/concurrent_task_controller.cpp. Signed-off-by: liuyuxiu --- services/src/concurrent_task_controller.cpp | 4 ---- 1 file changed, 4 deletions(-) diff --git a/services/src/concurrent_task_controller.cpp b/services/src/concurrent_task_controller.cpp index 1ad6fcb..7257382 100644 --- a/services/src/concurrent_task_controller.cpp +++ b/services/src/concurrent_task_controller.cpp @@ -329,11 +329,7 @@ void TaskController::QuerySelfRenderRemoveThread(int uid, int pid, IntervalReply CONCUR_LOGE("uid %{public}d pid %{public}d Query Self Render Remove Thread %{public}d failed: %{public}d", uid, pid, queryRs.tid, queryRs.paramA); } -<<<<<<< HEAD } -======= - } ->>>>>>> 6678591712daf9d021eb0ec878a14efe4818c008 } void TaskController::QuerySelfRenderAddThread(int uid, int pid, IntervalReply& queryRs) -- Gitee