From 1fc8858593a855961db475c36803b93bcaa5b576 Mon Sep 17 00:00:00 2001 From: ChenJie Date: Sat, 21 May 2022 16:42:18 +0800 Subject: [PATCH 1/3] feat: reclaim priority supports process ref by distribute device Signed-off-by: ChenJie --- README_zh.md | 9 +- interface/innerkits/include/i_mem_mgr.h | 3 + interface/innerkits/include/mem_mgr_client.h | 1 + interface/innerkits/include/mem_mgr_proxy.h | 1 + interface/innerkits/src/mem_mgr_client.cpp | 13 + interface/innerkits/src/mem_mgr_proxy.cpp | 29 ++ .../memmgrservice/include/mem_mgr_service.h | 1 + services/memmgrservice/include/mem_mgr_stub.h | 1 + .../process_priority_info.h | 3 + .../reclaim_priority_constants.h | 4 + .../reclaim_priority_manager.h | 4 + .../memmgrservice/src/mem_mgr_service.cpp | 9 + services/memmgrservice/src/mem_mgr_stub.cpp | 23 ++ .../bundle_priority_info.cpp | 8 +- .../process_priority_info.cpp | 15 + .../reclaim_priority_manager.cpp | 122 ++++++-- test/unittest/phone/innerkits_test.cpp | 6 + .../phone/reclaim_priority_manager_test.cpp | 279 ++++++++++++------ 18 files changed, 401 insertions(+), 130 deletions(-) diff --git a/README_zh.md b/README_zh.md index bd0781e..f8e3837 100644 --- a/README_zh.md +++ b/README_zh.md @@ -72,8 +72,9 @@ | 0 | 前台应用。 | | 100 | 正在进行后台短时任务的应用。 | | 200 | 后台可感知应用，如正在执行导航、播放音乐等长时任务的应用。 | -| 600 | 被冻结的应用。 | -| 800 | 挂起应用。 | +| 260 | 连接着分布式设备的后台应用。 | +| 400 | 普通后台应用。 | + ### 回收策略/查杀策略 @@ -93,8 +94,8 @@ | 查杀内存水线 | 进程回收优先级 | | ------------ | -------------- | - | 500 MB | 800 | - | 400 MB | 600 | + | 500 MB | 400 | + | 400 MB | 300 | | 300 MB | 200 | | 200 MB | 100 | | 100 MB | 0 | diff --git a/interface/innerkits/include/i_mem_mgr.h b/interface/innerkits/include/i_mem_mgr.h index 62d74de..e37a400 100644 --- a/interface/innerkits/include/i_mem_mgr.h +++ b/interface/innerkits/include/i_mem_mgr.h @@ -29,8 +29,11 @@ public: virtual int32_t GetBundlePriorityList(BundlePriorityList &bundlePrioList) = 0; + virtual int32_t NotifyDistDevStatus(int32_t pid, int32_t uid, const std::string &name, bool connected) = 0; + enum { MEM_MGR_GET_BUNDLE_PRIORITY_LIST = 1, + MEM_MGR_NOTIFY_DIST_DEV_STATUS = 2, }; }; } // namespace Memory diff --git a/interface/innerkits/include/mem_mgr_client.h b/interface/innerkits/include/mem_mgr_client.h index 49786d0..b45ee6f 100644 --- a/interface/innerkits/include/mem_mgr_client.h +++ b/interface/innerkits/include/mem_mgr_client.h @@ -26,6 +26,7 @@ class MemMgrClient { public: int32_t GetBundlePriorityList(BundlePriorityList &bundlePrioList); + int32_t NotifyDistDevStatus(int32_t pid, int32_t uid, const std::string &name, bool connected); private: sptr GetMemMgrService(); diff --git a/interface/innerkits/include/mem_mgr_proxy.h b/interface/innerkits/include/mem_mgr_proxy.h index 987ac66..e31b950 100644 --- a/interface/innerkits/include/mem_mgr_proxy.h +++ b/interface/innerkits/include/mem_mgr_proxy.h @@ -25,6 +25,7 @@ public: explicit MemMgrProxy(const sptr& impl) : IRemoteProxy(impl) {} ~MemMgrProxy() = default; int32_t GetBundlePriorityList(BundlePriorityList &bundlePrioList) override; + int32_t NotifyDistDevStatus(int32_t pid, int32_t uid, const std::string &name, bool connected) override; private: static inline BrokerDelegator delegator_; }; diff --git a/interface/innerkits/src/mem_mgr_client.cpp b/interface/innerkits/src/mem_mgr_client.cpp index f64c4f6..cd0af67 100644 --- a/interface/innerkits/src/mem_mgr_client.cpp +++ b/interface/innerkits/src/mem_mgr_client.cpp @@ -40,6 +40,19 @@ int32_t MemMgrClient::GetBundlePriorityList(BundlePriorityList &bundlePrioList) return dps->GetBundlePriorityList(bundlePrioList); } +int32_t MemMgrClient::NotifyDistDevStatus(int32_t pid, int32_t uid, const std::string &name, bool connected) +{ + HILOGI("called, pid=%{public}d, uid=%{public}d, name=%{public}s, connected=%{public}d", pid, uid, name.c_str(), + connected); + auto dps = GetMemMgrService(); + if (dps == nullptr) { + HILOGE("MemMgrService is null"); + return -1; + } + return dps->NotifyDistDevStatus(pid, uid, name, connected); +} + + sptr MemMgrClient::GetMemMgrService() { HILOGI("called"); diff --git a/interface/innerkits/src/mem_mgr_proxy.cpp b/interface/innerkits/src/mem_mgr_proxy.cpp index e79626d..157769a 100644 --- a/interface/innerkits/src/mem_mgr_proxy.cpp +++ b/interface/innerkits/src/mem_mgr_proxy.cpp @@ -50,5 +50,34 @@ int32_t MemMgrProxy::GetBundlePriorityList(BundlePriorityList &bundlePrioList) bundlePrioList = *list; return ERR_OK; } + +int32_t MemMgrProxy::NotifyDistDevStatus(int32_t pid, int32_t uid, const std::string &name, bool connected) +{ + HILOGI("called, pid=%{public}d, uid=%{public}d, name=%{public}s, connected=%{public}d", pid, uid, name.c_str(), + connected); + sptr remote = Remote(); + MessageParcel data; + if (!data.WriteInterfaceToken(IMemMgr::GetDescriptor())) { + HILOGE("write interface token failed"); + return ERR_FLATTEN_OBJECT; + } + if (!data.WriteInt32(pid) || !data.WriteInt32(uid) || !data.WriteString(name) || !data.WriteBool(connected)) { + HILOGE("write params failed"); + return ERR_INVALID_DATA; + } + MessageParcel reply; + MessageOption option; + int32_t error = remote->SendRequest(IMemMgr::MEM_MGR_NOTIFY_DIST_DEV_STATUS, data, reply, option); + if (error != ERR_NONE) { + HILOGE("transact failed, error: %{public}d", error); + return error; + } + int32_t ret; + if (!reply.ReadInt32(ret)) { + HILOGE("read result failed"); + return IPC_PROXY_ERR; + } + return ret; +} } // namespace Memory } // namespace OHOS diff --git a/services/memmgrservice/include/mem_mgr_service.h b/services/memmgrservice/include/mem_mgr_service.h index 1801199..7e22fe7 100644 --- a/services/memmgrservice/include/mem_mgr_service.h +++ b/services/memmgrservice/include/mem_mgr_service.h @@ -30,6 +30,7 @@ public: MemMgrService(); ~MemMgrService() = default; virtual int32_t GetBundlePriorityList(BundlePriorityList &bundlePrioList) override; + virtual int32_t NotifyDistDevStatus(int32_t pid, int32_t uid, const std::string &name, bool connected) override; protected: void OnStart() override; diff --git a/services/memmgrservice/include/mem_mgr_stub.h b/services/memmgrservice/include/mem_mgr_stub.h index 6c7bef5..45c7467 100644 --- a/services/memmgrservice/include/mem_mgr_stub.h +++ b/services/memmgrservice/include/mem_mgr_stub.h @@ -35,6 +35,7 @@ public: private: int32_t HandleGetBunldePriorityList(MessageParcel &data, MessageParcel &reply); + int32_t HandleNotifyDistDevStatus(MessageParcel &data, MessageParcel &reply); using MemMgrFunc = int32_t (MemMgrStub::*)(MessageParcel &data, MessageParcel &reply); std::map memberFuncMap_; diff --git a/services/memmgrservice/include/reclaim_priority_manager/process_priority_info.h b/services/memmgrservice/include/reclaim_priority_manager/process_priority_info.h index b61670e..f8e4784 100644 --- a/services/memmgrservice/include/reclaim_priority_manager/process_priority_info.h +++ b/services/memmgrservice/include/reclaim_priority_manager/process_priority_info.h @@ -25,13 +25,16 @@ namespace Memory { class ProcessPriorityInfo { public: explicit ProcessPriorityInfo(pid_t pid, int bundleUid, int priority); + ProcessPriorityInfo(const ProcessPriorityInfo ©Process); int uid_; pid_t pid_; int priority_; + bool isFreground; // true means freground, false means background bool isBackgroundRunning; bool isSuspendDelay; bool isEventStart; bool isDataAbilityStart; + bool isDistDeviceConnected; void SetPriority(int targetPriority); }; } // namespace Memory diff --git a/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_constants.h b/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_constants.h index 08c6c03..b9cf7cb 100644 --- a/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_constants.h +++ b/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_constants.h @@ -33,6 +33,8 @@ constexpr int RECLAIM_PRIORITY_VISIBLE = 1; constexpr int RECLAIM_PRIORITY_BG_SUSPEND_DELAY = 100; // perceived background process priority constexpr int RECLAIM_PRIORITY_BG_PERCEIVED = 200; +// background and connected by distribute device +constexpr int RECLAIM_PRIORITY_BG_DIST_DEVICE = 260; // background priority constexpr int RECLAIM_PRIORITY_BACKGROUND = 400; // frozen process priority @@ -71,6 +73,8 @@ enum class AppStateUpdateReason { APPLICATION_SUSPEND, PROCESS_TERMINATED, OS_ACCOUNT_CHANGED, + DIST_DEVICE_CONNECTED, + DIST_DEVICE_DISCONNECTED, }; enum class BundleState { diff --git a/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_manager.h b/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_manager.h index 2260e5e..c51d095 100644 --- a/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_manager.h +++ b/services/memmgrservice/include/reclaim_priority_manager/reclaim_priority_manager.h @@ -100,6 +100,7 @@ public: void SetBundleState(int accountId, int uid, BundleState state); + std::string& AppStateUpdateResonToString(AppStateUpdateReason reason); private: bool initialized_ = false; @@ -113,6 +114,8 @@ private: std::mutex totalBundlePrioSetLock_; std::shared_ptr handler_; + std::map updateReasonStrMapping_; + std::string unkown_reason = "UNKOWN_REASON"; ReclaimPriorityManager(); bool GetEventHandler(); bool UpdateReclaimPriorityInner(pid_t pid, int bundleUid, const std::string &bundleName, @@ -127,6 +130,7 @@ private: std::shared_ptr account); void HandleUpdateProcess(AppStateUpdateReason reason, std::shared_ptr bundle, ProcessPriorityInfo &proc, AppAction &action); + void UpdatePriorityByProcStatus(std::shared_ptr bundle, ProcessPriorityInfo &proc); bool HandleApplicationSuspend(std::shared_ptr bundle); std::shared_ptr FindOsAccountById(int accountId); void RemoveOsAccountById(int accountId); diff --git a/services/memmgrservice/src/mem_mgr_service.cpp b/services/memmgrservice/src/mem_mgr_service.cpp index 4194768..2f04511 100644 --- a/services/memmgrservice/src/mem_mgr_service.cpp +++ b/services/memmgrservice/src/mem_mgr_service.cpp @@ -96,5 +96,14 @@ int32_t MemMgrService::GetBundlePriorityList(BundlePriorityList &bundlePrioList) bundlePrioList.SetCount(bundlePrioList.Size()); return 0; } + +int32_t MemMgrService::NotifyDistDevStatus(int32_t pid, int32_t uid, const std::string &name, bool connected) +{ + HILOGI("called, pid=%{public}d, uid=%{public}d, name=%{public}s, connected=%{public}d", pid, uid, name.c_str(), + connected); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriority(pid, uid, name, + connected ? AppStateUpdateReason::DIST_DEVICE_CONNECTED : AppStateUpdateReason::DIST_DEVICE_DISCONNECTED); + return 0; +} } // namespace Memory } // namespace OHOS diff --git a/services/memmgrservice/src/mem_mgr_stub.cpp b/services/memmgrservice/src/mem_mgr_stub.cpp index 51c0b9d..cb33334 100644 --- a/services/memmgrservice/src/mem_mgr_stub.cpp +++ b/services/memmgrservice/src/mem_mgr_stub.cpp @@ -26,6 +26,8 @@ MemMgrStub::MemMgrStub() { memberFuncMap_[static_cast(IMemMgr::MEM_MGR_GET_BUNDLE_PRIORITY_LIST)] = &MemMgrStub::HandleGetBunldePriorityList; + memberFuncMap_[static_cast(IMemMgr::MEM_MGR_NOTIFY_DIST_DEV_STATUS)] = + &MemMgrStub::HandleNotifyDistDevStatus; } MemMgrStub::~MemMgrStub() @@ -67,5 +69,26 @@ int32_t MemMgrStub::HandleGetBunldePriorityList(MessageParcel &data, MessageParc reply.WriteParcelable(list.get()); return ret; } + +int32_t MemMgrStub::HandleNotifyDistDevStatus(MessageParcel &data, MessageParcel &reply) +{ + HILOGI("called"); + int32_t pid = 0; + int32_t uid = 0; + std::string name; + bool connected; + if (!data.ReadInt32(pid) || !data.ReadInt32(uid) || !data.ReadString(name) || !data.ReadBool(connected)) { + HILOGE("read params failed"); + return IPC_STUB_ERR; + } + HILOGI("called, pid=%{public}d, uid=%{public}d, name=%{public}s, connected=%{public}d", pid, uid, name.c_str(), + connected); + + int32_t ret = NotifyDistDevStatus(pid, uid, name, connected); + if (!reply.WriteInt32(ret)) { + return IPC_STUB_ERR; + } + return ret; +} } // namespace Memory } // namespace OHOS diff --git a/services/memmgrservice/src/reclaim_priority_manager/bundle_priority_info.cpp b/services/memmgrservice/src/reclaim_priority_manager/bundle_priority_info.cpp index 2f0ba99..5464b62 100644 --- a/services/memmgrservice/src/reclaim_priority_manager/bundle_priority_info.cpp +++ b/services/memmgrservice/src/reclaim_priority_manager/bundle_priority_info.cpp @@ -46,11 +46,7 @@ BundlePriorityInfo::BundlePriorityInfo(const BundlePriorityInfo ©Bundle) : n { for (auto itrProcess = copyBundle.procs_.begin(); itrProcess != copyBundle.procs_.end(); itrProcess++) { ProcessPriorityInfo processInfo = itrProcess->second; - ProcessPriorityInfo tmpProcess(processInfo.pid_, processInfo.uid_, processInfo.priority_); - tmpProcess.isBackgroundRunning = processInfo.isBackgroundRunning; - tmpProcess.isSuspendDelay = processInfo.isSuspendDelay; - tmpProcess.isEventStart = processInfo.isEventStart; - tmpProcess.isDataAbilityStart = processInfo.isDataAbilityStart; + ProcessPriorityInfo tmpProcess(processInfo); this->procs_.insert(std::make_pair(tmpProcess.pid_, tmpProcess)); } @@ -97,7 +93,7 @@ int BundlePriorityInfo::GetMinProcPriority() void BundlePriorityInfo::SetPriority(int targetPriority) { - priority_ = targetPriority; + priority_ = targetPriority; } void BundlePriorityInfo::UpdatePriority() diff --git a/services/memmgrservice/src/reclaim_priority_manager/process_priority_info.cpp b/services/memmgrservice/src/reclaim_priority_manager/process_priority_info.cpp index ffafe8e..8931a85 100644 --- a/services/memmgrservice/src/reclaim_priority_manager/process_priority_info.cpp +++ b/services/memmgrservice/src/reclaim_priority_manager/process_priority_info.cpp @@ -27,10 +27,25 @@ ProcessPriorityInfo::ProcessPriorityInfo(pid_t pid, int bundleUid, int priority) this->uid_ = bundleUid; this->pid_ = pid; this->priority_ = priority; + this->isFreground = (priority == RECLAIM_PRIORITY_FOREGROUND) ? true : false; this->isBackgroundRunning = false; this->isSuspendDelay = false; this->isEventStart = false; this->isDataAbilityStart = false; + this->isDistDeviceConnected = false; +} + +ProcessPriorityInfo::ProcessPriorityInfo(const ProcessPriorityInfo ©Process) +{ + this->uid_ = copyProcess.uid_; + this->pid_ = copyProcess.pid_; + this->priority_ = copyProcess.priority_; + this->isFreground = copyProcess.isFreground; + this->isBackgroundRunning = copyProcess.isBackgroundRunning; + this->isSuspendDelay = copyProcess.isSuspendDelay; + this->isEventStart = copyProcess.isEventStart; + this->isDataAbilityStart = copyProcess.isDataAbilityStart; + this->isDistDeviceConnected = copyProcess.isDistDeviceConnected; } void ProcessPriorityInfo::SetPriority(int targetPriority) diff --git a/services/memmgrservice/src/reclaim_priority_manager/reclaim_priority_manager.cpp b/services/memmgrservice/src/reclaim_priority_manager/reclaim_priority_manager.cpp index af241a1..b870b93 100644 --- a/services/memmgrservice/src/reclaim_priority_manager/reclaim_priority_manager.cpp +++ b/services/memmgrservice/src/reclaim_priority_manager/reclaim_priority_manager.cpp @@ -51,6 +51,37 @@ bool WriteOomScoreAdjToKernel(std::shared_ptr bundle) ReclaimPriorityManager::ReclaimPriorityManager() { + updateReasonStrMapping_[static_cast(AppStateUpdateReason::CREATE_PROCESS)] = "CREATE_PROCESS"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::PROCESS_READY)] = "PROCESS_READY"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::FOREGROUND)] = "FOREGROUND"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::BACKGROUND)] = "BACKGROUND"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::SUSPEND_DELAY_START)] = "SUSPEND_DELAY_START"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::SUSPEND_DELAY_END)] = "SUSPEND_DELAY_END"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::BACKGROUND_RUNNING_START)] = + "BACKGROUND_RUNNING_START"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::BACKGROUND_RUNNING_END)] = + "BACKGROUND_RUNNING_END"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::EVENT_START)] = "EVENT_START"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::EVENT_END)] = "EVENT_END"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::DATA_ABILITY_START)] = "DATA_ABILITY_START"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::DATA_ABILITY_END)] = "DATA_ABILITY_END"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::APPLICATION_SUSPEND)] = "APPLICATION_SUSPEND"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::PROCESS_TERMINATED)] = "PROCESS_TERMINATED"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::OS_ACCOUNT_CHANGED)] = "OS_ACCOUNT_CHANGED"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::DIST_DEVICE_CONNECTED)] = + "DIST_DEVICE_CONNECTED"; + updateReasonStrMapping_[static_cast(AppStateUpdateReason::DIST_DEVICE_DISCONNECTED)] = + "DIST_DEVICE_DISCONNECTED"; +} + +std::string& ReclaimPriorityManager::AppStateUpdateResonToString(AppStateUpdateReason reason) +{ + auto ptr = updateReasonStrMapping_.find(static_cast(reason)); + if (ptr != updateReasonStrMapping_.end()) { + return ptr->second; + } else { + return unkown_reason; + } } bool ReclaimPriorityManager::Init() @@ -93,11 +124,7 @@ void ReclaimPriorityManager::GetBundlePrioSet(BunldeCopySet &bundleSet) for (auto itrProcess = bundle->procs_.begin(); itrProcess != bundle->procs_.end(); itrProcess++) { ProcessPriorityInfo processInfo = itrProcess->second; - ProcessPriorityInfo tmpProcess(processInfo.pid_, processInfo.uid_, processInfo.priority_); - tmpProcess.isBackgroundRunning = processInfo.isBackgroundRunning; - tmpProcess.isSuspendDelay = processInfo.isSuspendDelay; - tmpProcess.isEventStart = processInfo.isEventStart; - tmpProcess.isDataAbilityStart = processInfo.isDataAbilityStart; + ProcessPriorityInfo tmpProcess(processInfo); tmpBundleInfo.procs_.insert(std::make_pair(tmpProcess.pid_, tmpProcess)); } @@ -339,7 +366,8 @@ bool ReclaimPriorityManager::HandleApplicationSuspend(std::shared_ptrpriority_ > RECLAIM_PRIORITY_BG_PERCEIVED) { - proc.SetPriority(RECLAIM_PRIORITY_BG_PERCEIVED); - UpdateBundlePriority(bundle); + ret = ApplyReclaimPriority(bundle, pid, action); + return ret; +} + +void ReclaimPriorityManager::UpdatePriorityByProcStatus(std::shared_ptr bundle, + ProcessPriorityInfo &proc) +{ + HILOGD("enter, bundle[uid_=%{public}d,name=%{public}s,priority=%{public}d], proc[pid_=%{public}d, uid=%{public}d," + "isFreground=%{public}d, isBackgroundRunning=%{public}d, isSuspendDelay=%{public}d, isEventStart=%{public}d," + "isDataAbilityStart=%{public}d, isDistDeviceConnected=%{public}d, priority=%{public}d]", + bundle->uid_, bundle->name_.c_str(), bundle->priority_, + proc.pid_, proc.uid_, proc.isFreground, proc.isBackgroundRunning, proc.isSuspendDelay, proc.isEventStart, + proc.isDataAbilityStart, proc.isDistDeviceConnected, proc.priority_); + + if (bundle->priority_ < RECLAIM_PRIORITY_FOREGROUND) { // is a system process + HILOGD("%{public}d is a system process, skiped!", proc.pid_); + return; + } + if (proc.isFreground) { // is a freground process + HILOGD("%{public}d is a freground process", proc.pid_); + if (proc.priority_ > RECLAIM_PRIORITY_FOREGROUND) { + proc.SetPriority(RECLAIM_PRIORITY_FOREGROUND); } - } else if (bundle->priority_ == RECLAIM_PRIORITY_BG_PERCEIVED) { + } else { // is a background process proc.SetPriority(RECLAIM_PRIORITY_BACKGROUND); - UpdateBundlePriority(bundle); + HILOGD("%{public}d is a background process, set process priority to %{public}d first", proc.pid_, + proc.priority_); + } + if (proc.isSuspendDelay) { // is a background process with transient task + HILOGD("%{public}d is a background process with transient task", proc.pid_); + if (proc.priority_ > RECLAIM_PRIORITY_BG_SUSPEND_DELAY) { + proc.SetPriority(RECLAIM_PRIORITY_BG_SUSPEND_DELAY); + HILOGD("set process[%{public}d] priority to %{public}d", proc.pid_, proc.priority_); + } + } else if (proc.isBackgroundRunning || proc.isEventStart || proc.isDataAbilityStart) { + // is a background perceived process + if (proc.priority_ > RECLAIM_PRIORITY_BG_PERCEIVED) { + proc.SetPriority(RECLAIM_PRIORITY_BG_PERCEIVED); + HILOGD("set process[%{public}d] priority to %{public}d", proc.pid_, proc.priority_); + } + } else if (proc.isDistDeviceConnected) { // is a background process connected by distribute device + if (proc.priority_ > RECLAIM_PRIORITY_BG_DIST_DEVICE) { + HILOGD("set process[%{public}d] priority to %{public}d", proc.pid_, proc.priority_); + proc.SetPriority(RECLAIM_PRIORITY_BG_DIST_DEVICE); + } + } else { + // is a plain background process } - ret = ApplyReclaimPriority(bundle, pid, action); - return ret; + UpdateBundlePriority(bundle); } void ReclaimPriorityManager::HandleUpdateProcess(AppStateUpdateReason reason, std::shared_ptr bundle, ProcessPriorityInfo &proc, AppAction &action) { + HILOGD("called, bundle[uid_=%{public}d,name=%{public}s,priority=%{public}d], proc[pid_=%{public}d, uid=%{public}d," + "isFreground=%{public}d, isBackgroundRunning=%{public}d, isSuspendDelay=%{public}d, isEventStart=%{public}d," + "isDataAbilityStart=%{public}d, isDistDeviceConnected=%{public}d, priority=%{public}d], case:%{public}s", + bundle->uid_, bundle->name_.c_str(), bundle->priority_, proc.pid_, proc.uid_, proc.isFreground, + proc.isBackgroundRunning, proc.isSuspendDelay, proc.isEventStart, proc.isDataAbilityStart, + proc.isDistDeviceConnected, proc.priority_, AppStateUpdateResonToString(reason).c_str()); switch (reason) { case AppStateUpdateReason::FOREGROUND: { - proc.SetPriority(RECLAIM_PRIORITY_FOREGROUND); - UpdateBundlePriority(bundle); + proc.isFreground = true; action = AppAction::APP_FOREGROUND; break; } case AppStateUpdateReason::BACKGROUND: { - proc.SetPriority(RECLAIM_PRIORITY_BACKGROUND); - UpdateBundlePriority(bundle); + proc.isFreground = false; action = AppAction::APP_BACKGROUND; break; } case AppStateUpdateReason::SUSPEND_DELAY_START: proc.isSuspendDelay = true; - if (bundle->priority_ > RECLAIM_PRIORITY_BG_SUSPEND_DELAY) { - proc.SetPriority(RECLAIM_PRIORITY_BG_SUSPEND_DELAY); - UpdateBundlePriority(bundle); - } break; case AppStateUpdateReason::SUSPEND_DELAY_END: proc.isSuspendDelay = false; - if (bundle->priority_ == RECLAIM_PRIORITY_BG_SUSPEND_DELAY) { - proc.SetPriority(RECLAIM_PRIORITY_BACKGROUND); - UpdateBundlePriority(bundle); - } break; case AppStateUpdateReason::BACKGROUND_RUNNING_START: proc.isBackgroundRunning = true; @@ -439,9 +500,16 @@ void ReclaimPriorityManager::HandleUpdateProcess(AppStateUpdateReason reason, case AppStateUpdateReason::DATA_ABILITY_END: proc.isDataAbilityStart = false; break; + case AppStateUpdateReason::DIST_DEVICE_CONNECTED: + proc.isDistDeviceConnected = true; + break; + case AppStateUpdateReason::DIST_DEVICE_DISCONNECTED: + proc.isDistDeviceConnected = false; + break; default: break; } + UpdatePriorityByProcStatus(bundle, proc); } bool ReclaimPriorityManager::ApplyReclaimPriority(std::shared_ptr bundle, diff --git a/test/unittest/phone/innerkits_test.cpp b/test/unittest/phone/innerkits_test.cpp index 6407c12..bd326ad 100644 --- a/test/unittest/phone/innerkits_test.cpp +++ b/test/unittest/phone/innerkits_test.cpp @@ -67,5 +67,11 @@ HWTEST_F(InnerkitsTest, GetPriorityDescTest, TestSize.Level1) auto ptr = ReclaimPriorityMapping.find(RECLAIM_PRIORITY_SYSTEM); EXPECT_EQ(ptr->second, "System"); } + +HWTEST_F(InnerkitsTest, NotifyDistDevStatus_Test, TestSize.Level1) +{ + int32_t ret = MemMgrClient::GetInstance().NotifyDistDevStatus(123, 456, "dist_dev_test", true); + EXPECT_EQ(ret, 0); +} } } diff --git a/test/unittest/phone/reclaim_priority_manager_test.cpp b/test/unittest/phone/reclaim_priority_manager_test.cpp index e6fa0a7..e03be9e 100644 --- a/test/unittest/phone/reclaim_priority_manager_test.cpp +++ b/test/unittest/phone/reclaim_priority_manager_test.cpp @@ -52,6 +52,24 @@ void ReclaimPriorityManagerTest::TearDown() { } +static void PrintReclaimPriorityList() +{ + ReclaimPriorityManager::BunldeCopySet bundleSet; + ReclaimPriorityManager::GetInstance().GetBundlePrioSet(bundleSet); + printf("begin print reclaim priority list. \n"); + printf(" uid name priority accountId\n"); + for (auto bi : bundleSet) { + printf("%3d\t%42s\t%5d\t%3d\n", bi.uid_, bi.name_.c_str(), bi.priority_, bi.accountId_); + for (auto piPair : bi.procs_) { + ProcessPriorityInfo &pi = piPair.second; + printf("\tuid_=%3d, pid_=%5d, priority_=%5d, isFg=%d, isBgTsk=%d, isSusDelay=%d, isDistDevConn=%d \n", + pi.uid_, pi.pid_, pi.priority_, pi.isFreground, pi.isBackgroundRunning, pi.isSuspendDelay, + pi.isDistDeviceConnected); + } + } + printf("-------------------------------------------------------------------------------\n"); +} + HWTEST_F(ReclaimPriorityManagerTest, AddOsAccountInfo, TestSize.Level1) { int account_id = 0; @@ -78,18 +96,17 @@ HWTEST_F(ReclaimPriorityManagerTest, RemoveOsAccountById, TestSize.Level1) HWTEST_F(ReclaimPriorityManagerTest, IsProcExist, TestSize.Level1) { - int pid = 1000; - int uid = 100; + int pid = 10001; + int uid = 20010001; int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid); - EXPECT_EQ(account_id, 0); + EXPECT_EQ(account_id, 100); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); bool isProcExist = ReclaimPriorityManager::GetInstance().IsProcExist(pid, uid, account_id); EXPECT_EQ(isProcExist, true); - pid = 1001; - isProcExist = ReclaimPriorityManager::GetInstance().IsProcExist(pid, uid, account_id); + isProcExist = ReclaimPriorityManager::GetInstance().IsProcExist(pid+1, uid, account_id); EXPECT_EQ(isProcExist, false); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, @@ -113,10 +130,10 @@ HWTEST_F(ReclaimPriorityManagerTest, IsSystemApp, TestSize.Level1) HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityProcessCreate, TestSize.Level1) { - int pid = 1002; - int uid = 104; + int pid = 10002; + int uid = 20010002; int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid); - EXPECT_EQ(account_id, 0); + EXPECT_EQ(account_id, 100); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); @@ -134,9 +151,9 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityProcessCreate, TestSiz HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityProcessTerminate, TestSize.Level1) { - int pid_1 = 1003; - int pid_2 = 1004; - int uid = 105; + int pid_1 = 10003; + int pid_2 = 10004; + int uid = 20010003; ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid_1, uid, "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid_2, uid, @@ -158,8 +175,8 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityProcessTerminate, Test HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPrioritySystemProcess, TestSize.Level1) { - int pid = 1005; - int uid = 106; + int pid = 10005; + int uid = 20010005; ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.systemui", AppStateUpdateReason::CREATE_PROCESS); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, @@ -180,8 +197,8 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPrioritySystemProcess, TestSiz HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBackground, TestSize.Level1) { - int pid = 1006; - int uid = 107; + int pid = 10006; + int uid = 20010006; ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, @@ -199,64 +216,74 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBackground, TestSize.L HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPrioritySuspendDelayStart, TestSize.Level1) { - int pid = 1007; - int uid = 108; - ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, - "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); + int pid = 10007; + int uid = 20010007; + printf("process created!"); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, - "com.ohos.reclaim_test", AppStateUpdateReason::SUSPEND_DELAY_START); + "com.ohos.reclaim_suspend_delay_start", AppStateUpdateReason::CREATE_PROCESS); + PrintReclaimPriorityList(); int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid); std::shared_ptr account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id); std::shared_ptr bundle = account->FindBundleById(uid); - int priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_FOREGROUND); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND); + printf("process suspend delay start!"); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, - "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND); + "com.ohos.reclaim_suspend_delay_start", AppStateUpdateReason::SUSPEND_DELAY_START); + PrintReclaimPriorityList(); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND); + + printf("process go to background!"); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, - "com.ohos.reclaim_test", AppStateUpdateReason::SUSPEND_DELAY_START); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BG_SUSPEND_DELAY); + "com.ohos.reclaim_suspend_delay_start", AppStateUpdateReason::BACKGROUND); + PrintReclaimPriorityList(); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_SUSPEND_DELAY); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, - "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED); + "com.ohos.reclaim_suspend_delay_start", AppStateUpdateReason::PROCESS_TERMINATED); } HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPrioritySuspendDelayEnd, TestSize.Level1) { - int pid = 1008; - int uid = 109; - int priority; - ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, - "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); - ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, - "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND); + int pid = 10008; + int uid = 20010008; + const std::string bundleName = "com.ohos.reclaim_suspend_delay_end"; + + printf("process created!\n"); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, bundleName, + AppStateUpdateReason::CREATE_PROCESS); + printf("process go to background!\n"); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, bundleName, + AppStateUpdateReason::BACKGROUND); + PrintReclaimPriorityList(); int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid); std::shared_ptr account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id); std::shared_ptr bundle = account->FindBundleById(uid); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BACKGROUND); - - ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, - "com.ohos.reclaim_test", AppStateUpdateReason::SUSPEND_DELAY_START); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BG_SUSPEND_DELAY); - - ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, - "com.ohos.reclaim_test", AppStateUpdateReason::SUSPEND_DELAY_END); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BACKGROUND); - - ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, - "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND); + + printf("process suspend delay start!\n"); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, bundleName, + AppStateUpdateReason::SUSPEND_DELAY_START); + PrintReclaimPriorityList(); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_SUSPEND_DELAY); + + printf("process suspend delay end!\n"); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, bundleName, + AppStateUpdateReason::SUSPEND_DELAY_END); + sleep(5); + PrintReclaimPriorityList(); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND); + + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, bundleName, + AppStateUpdateReason::PROCESS_TERMINATED); } HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBgRunningStart, TestSize.Level1) { - int pid = 1009; - int uid = 110; + int pid = 10009; + int uid = 20010009; ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, @@ -281,9 +308,9 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBgRunningStart, TestSi HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBgRunningEnd, TestSize.Level1) { - int pid = 1010; - int uid = 111; - int priority; + int pid = 10010; + int uid = 20010010; + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, @@ -292,19 +319,17 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBgRunningEnd, TestSize int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid); std::shared_ptr account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id); std::shared_ptr bundle = account->FindBundleById(uid); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BACKGROUND); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND_RUNNING_START); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BG_PERCEIVED); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_PERCEIVED); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND_RUNNING_END); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BACKGROUND); + sleep(5); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED); @@ -312,8 +337,8 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityBgRunningEnd, TestSize HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityEventStart, TestSize.Level1) { - int pid = 1011; - int uid = 112; + int pid = 10011; + int uid = 20010011; ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, @@ -322,15 +347,13 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityEventStart, TestSize.L int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid); std::shared_ptr account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id); std::shared_ptr bundle = account->FindBundleById(uid); - int priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_FOREGROUND); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::BACKGROUND); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::EVENT_START); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BG_PERCEIVED); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_PERCEIVED); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED); @@ -338,9 +361,8 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityEventStart, TestSize.L HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityEventEnd, TestSize.Level1) { - int pid = 1012; - int uid = 113; - int priority; + int pid = 10012; + int uid = 20010012; ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, @@ -349,18 +371,16 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityEventEnd, TestSize.Lev int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid); std::shared_ptr account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id); std::shared_ptr bundle = account->FindBundleById(uid); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BACKGROUND); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::EVENT_START); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BG_PERCEIVED); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_PERCEIVED); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::EVENT_END); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BACKGROUND); + sleep(5); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED); @@ -368,8 +388,8 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityEventEnd, TestSize.Lev HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityDataAbilityStart, TestSize.Level1) { - int pid = 1013; - int uid = 114; + int pid = 10013; + int uid = 20010013; ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, @@ -394,9 +414,8 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityDataAbilityStart, Test HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityDataAbilityEnd, TestSize.Level1) { - int pid = 1014; - int uid = 115; - int priority; + int pid = 10014; + int uid = 20010014; ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, @@ -405,19 +424,17 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityDataAbilityEnd, TestSi int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid); std::shared_ptr account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id); std::shared_ptr bundle = account->FindBundleById(uid); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BACKGROUND); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::DATA_ABILITY_START); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BG_PERCEIVED); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_PERCEIVED); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::DATA_ABILITY_END); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_BACKGROUND); + sleep(5); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::PROCESS_TERMINATED); @@ -425,21 +442,22 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityDataAbilityEnd, TestSi HWTEST_F(ReclaimPriorityManagerTest, GetBundlePrioSet, TestSize.Level1) { - int pid = 1015; - int uid = 116; + int pid = 10015; + int uid = 20010015; ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); ReclaimPriorityManager::BunldeCopySet bundleSet; ReclaimPriorityManager::GetInstance().GetBundlePrioSet(bundleSet); bool isEmpty = bundleSet.size() == 0; EXPECT_EQ(isEmpty, false); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", + AppStateUpdateReason::PROCESS_TERMINATED); } HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityApplicationSuspend, TestSize.Level1) { - int pid = 1016; - int uid = 117; - int priority; + int pid = 10016; + int uid = 20010016; ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", AppStateUpdateReason::CREATE_PROCESS); ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(IGNORE_PID, uid, @@ -448,8 +466,83 @@ HWTEST_F(ReclaimPriorityManagerTest, UpdateReclaimPriorityApplicationSuspend, Te int account_id = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(uid); std::shared_ptr account = ReclaimPriorityManager::GetInstance().FindOsAccountById(account_id); std::shared_ptr bundle = account->FindBundleById(uid); - priority = bundle->priority_; - EXPECT_EQ(priority, RECLAIM_PRIORITY_SUSPEND); + EXPECT_EQ(bundle->priority_, RECLAIM_PRIORITY_SUSPEND); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid, uid, "com.ohos.reclaim_test", + AppStateUpdateReason::PROCESS_TERMINATED); +} + +HWTEST_F(ReclaimPriorityManagerTest, DistDeviceCase, TestSize.Level1) +{ + // Preconditions: create one bundle with two freground processes + printf("Preconditions: create one bundle with two freground processes\n"); + int pid1 = 10017; + int pid2 = 10018; + int bundleUid = 20010017; + const std::string bundleName1 = "com.ohos.reclaim_dist_device_test.process1"; + const std::string bundleName2 = "com.ohos.reclaim_dist_device_test.process2"; + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid1, bundleUid, bundleName1, + AppStateUpdateReason::CREATE_PROCESS); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2, + AppStateUpdateReason::CREATE_PROCESS); + + int accountId = ReclaimPriorityManager::GetInstance().GetOsAccountLocalIdFromUid(bundleUid); + bool isProc1Exist = ReclaimPriorityManager::GetInstance().IsProcExist(pid1, bundleUid, accountId); + ASSERT_EQ(isProc1Exist, true); + bool isProc2Exist = ReclaimPriorityManager::GetInstance().IsProcExist(pid2, bundleUid, accountId); + ASSERT_EQ(isProc2Exist, true); + std::shared_ptr account = ReclaimPriorityManager::GetInstance().FindOsAccountById(accountId); + std::shared_ptr bundle = account->FindBundleById(bundleUid); + ProcessPriorityInfo &proc1 = bundle->FindProcByPid(pid1); + ProcessPriorityInfo &proc2 = bundle->FindProcByPid(pid2); + ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND); + ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_FOREGROUND); + ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND); + PrintReclaimPriorityList(); + + // process#1 keep freground, process#2 go to background + printf("process#1 keep freground, process#2 go to background\n"); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2, + AppStateUpdateReason::BACKGROUND); + ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND); + ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND); + ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND); + PrintReclaimPriorityList(); + + // process#2 is connected to a distribute device + printf("process#1 is connected to a distribute device\n"); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2, + AppStateUpdateReason::DIST_DEVICE_CONNECTED); + ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_FOREGROUND); + ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE); + ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_FOREGROUND); + PrintReclaimPriorityList(); + + // process#1 go to background + printf("process#1 go to background\n"); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid1, bundleUid, bundleName1, + AppStateUpdateReason::BACKGROUND); + ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND); + ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE); + ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BG_DIST_DEVICE); + PrintReclaimPriorityList(); + + // process#2 is disconnected to a distribute device + printf("process#2 is disconnected to a distribute device\n"); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2, + AppStateUpdateReason::DIST_DEVICE_DISCONNECTED); + sleep(5); + ASSERT_EQ(proc1.priority_, RECLAIM_PRIORITY_BACKGROUND); + ASSERT_EQ(proc2.priority_, RECLAIM_PRIORITY_BACKGROUND); + ASSERT_EQ(bundle->priority_, RECLAIM_PRIORITY_BACKGROUND); + PrintReclaimPriorityList(); + + // clean up the mess + printf("clean up the mess\n"); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid1, bundleUid, bundleName1, + AppStateUpdateReason::PROCESS_TERMINATED); + ReclaimPriorityManager::GetInstance().UpdateReclaimPriorityInner(pid2, bundleUid, bundleName2, + AppStateUpdateReason::PROCESS_TERMINATED); + PrintReclaimPriorityList(); } } } -- Gitee From b86e498fe8dc04dc59765623ddd0793a46e9bdb4 Mon Sep 17 00:00:00 2001 From: ChenJie Date: Sat, 21 May 2022 16:58:33 +0800 Subject: [PATCH 2/3] update Signed-off-by: ChenJie --- .../src/reclaim_priority_manager/reclaim_priority_manager.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/services/memmgrservice/src/reclaim_priority_manager/reclaim_priority_manager.cpp b/services/memmgrservice/src/reclaim_priority_manager/reclaim_priority_manager.cpp index b870b93..f84f560 100644 --- a/services/memmgrservice/src/reclaim_priority_manager/reclaim_priority_manager.cpp +++ b/services/memmgrservice/src/reclaim_priority_manager/reclaim_priority_manager.cpp @@ -467,12 +467,12 @@ void ReclaimPriorityManager::HandleUpdateProcess(AppStateUpdateReason reason, proc.isDistDeviceConnected, proc.priority_, AppStateUpdateResonToString(reason).c_str()); switch (reason) { case AppStateUpdateReason::FOREGROUND: { - proc.isFreground = true; + proc.isFreground = true; action = AppAction::APP_FOREGROUND; break; } case AppStateUpdateReason::BACKGROUND: { - proc.isFreground = false; + proc.isFreground = false; action = AppAction::APP_BACKGROUND; break; } -- Gitee From f4d68615b3848acf298a9e3792f2c6bb099b6840 Mon Sep 17 00:00:00 2001 From: ChenJie Date: Sat, 21 May 2022 17:55:17 +0800 Subject: [PATCH 3/3] update Signed-off-by: ChenJie --- .../src/kill_strategy_manager/low_memory_killer.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/services/memmgrservice/src/kill_strategy_manager/low_memory_killer.cpp b/services/memmgrservice/src/kill_strategy_manager/low_memory_killer.cpp index 3c11cd3..de2ffeb 100644 --- a/services/memmgrservice/src/kill_strategy_manager/low_memory_killer.cpp +++ b/services/memmgrservice/src/kill_strategy_manager/low_memory_killer.cpp @@ -106,14 +106,14 @@ int LowMemoryKiller::KillOneBundleByPrio(int minPrio) /* Low memory killer core function */ void LowMemoryKiller::PsiHandlerInner() { - HILOGD("[%{public}ld] called", ++calledCount); + HILOGI("[%{public}ld] called", ++calledCount); int triBuf, availBuf, thBuf, freedBuf; int totalBuf = 0; int minPrio = RECLAIM_PRIORITY_UNKNOWN + 1; int killCnt = 0; triBuf = KernelInterface::GetInstance().GetCurrentBuffer(); - HILOGD("[%{public}ld] current buffer = %{public}d KB", calledCount, triBuf); + HILOGE("[%{public}ld] current buffer = %{public}d KB", calledCount, triBuf); if (triBuf == MAX_BUFFER_KB) { HILOGE("[%{public}ld] get buffer failed, skiped!", calledCount); return; @@ -126,7 +126,7 @@ void LowMemoryKiller::PsiHandlerInner() break; } } - HILOGD("[%{public}ld] minPrio = %{public}d", calledCount, minPrio); + HILOGE("[%{public}ld] minPrio = %{public}d", calledCount, minPrio); if (minPrio == RECLAIM_PRIORITY_UNKNOWN + 1) { HILOGE("[%{public}ld] no minPrio, skiped!", calledCount); -- Gitee