1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this->file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "bundle_priority_info.h"
17 #include "memmgr_log.h"
18 #include "kernel_interface.h"
19
20 namespace OHOS {
21 namespace Memory {
22 namespace {
23 const std::string TAG = "BundlePriorityInfo";
24 } // namespace
25
BundlePriorityInfo(const std::string & name,int bundleUid)26 BundlePriorityInfo::BundlePriorityInfo(const std::string &name, int bundleUid):name_(name), uid_(bundleUid)
27 {
28 this->priority_ = RECLAIM_PRIORITY_UNKNOWN;
29 this->accountId_ = bundleUid / USER_ID_SHIFT;
30 this->state_ = BundleState::STATE_DEFAULT;
31 this->createTime_ = KernelInterface::GetInstance().GetSystemCurTime();
32 }
33
BundlePriorityInfo(const std::string & name,int bundleUid,int priority)34 BundlePriorityInfo::BundlePriorityInfo(const std::string &name, int bundleUid, int priority):name_(name),
35 uid_(bundleUid), priority_(priority)
36 {
37 this->accountId_ = bundleUid / USER_ID_SHIFT;
38 this->state_ = BundleState::STATE_DEFAULT;
39 this->createTime_ = KernelInterface::GetInstance().GetSystemCurTime();
40 }
41
BundlePriorityInfo(const std::string & name,int bundleUid,int priority,int accountId,BundleState state)42 BundlePriorityInfo::BundlePriorityInfo(const std::string &name, int bundleUid, int priority, int accountId,
43 BundleState state) : name_(name), uid_(bundleUid), priority_(priority), accountId_(accountId), state_(state)
44 {
45 this->createTime_ = KernelInterface::GetInstance().GetSystemCurTime();
46 }
47
BundlePriorityInfo(const BundlePriorityInfo & copyBundle)48 BundlePriorityInfo::BundlePriorityInfo(const BundlePriorityInfo ©Bundle) : name_(copyBundle.name_),
49 uid_(copyBundle.uid_), priority_(copyBundle.priority_), accountId_(copyBundle.accountId_),
50 state_(copyBundle.state_), createTime_(copyBundle.createTime_)
51 {
52 for (auto itrProcess = copyBundle.procs_.begin(); itrProcess != copyBundle.procs_.end(); itrProcess++) {
53 ProcessPriorityInfo processInfo = itrProcess->second;
54 ProcessPriorityInfo tmpProcess(processInfo);
55
56 this->procs_.insert(std::make_pair(tmpProcess.pid_, tmpProcess));
57 }
58 }
59
HasProc(pid_t pid)60 bool BundlePriorityInfo::HasProc(pid_t pid)
61 {
62 if (procs_.count(pid) == 0) {
63 return false;
64 }
65 return true;
66 }
67
AddProc(ProcessPriorityInfo & newProcess)68 void BundlePriorityInfo::AddProc(ProcessPriorityInfo &newProcess)
69 {
70 procs_.insert(std::make_pair(newProcess.pid_, newProcess));
71 }
72
RemoveProcByPid(pid_t pid)73 void BundlePriorityInfo::RemoveProcByPid(pid_t pid)
74 {
75 procs_.erase(pid);
76 }
77
GetProcsCount()78 int BundlePriorityInfo::GetProcsCount()
79 {
80 return procs_.size();
81 }
82
FindProcByPid(pid_t pid)83 ProcessPriorityInfo& BundlePriorityInfo::FindProcByPid(pid_t pid)
84 {
85 return procs_.at(pid);
86 }
87
GetMinProcPriority()88 int BundlePriorityInfo::GetMinProcPriority()
89 {
90 int min_priority = RECLAIM_PRIORITY_UNKNOWN;
91 for (auto i = procs_.begin(); i != procs_.end(); ++i) {
92 if (i->second.isRender_) {
93 continue;
94 }
95 if (i->second.priority_ < min_priority) {
96 min_priority = i->second.priority_;
97 }
98 }
99 return min_priority;
100 }
101
SetPriority(int targetPriority)102 void BundlePriorityInfo::SetPriority(int targetPriority)
103 {
104 priority_ = targetPriority;
105 }
106
UpdatePriority()107 void BundlePriorityInfo::UpdatePriority()
108 {
109 int targetPriority = GetMinProcPriority();
110 if (targetPriority >= RECLAIM_PRIORITY_MAX) {
111 targetPriority = RECLAIM_PRIORITY_MAX;
112 } else if (targetPriority <= RECLAIM_PRIORITY_MIN) {
113 targetPriority = RECLAIM_PRIORITY_MIN;
114 }
115 SetPriority(targetPriority);
116 HILOGI("bundleName=%{public}s, priority=%{public}d", name_.c_str(), priority_);
117 }
118
GetState()119 BundleState BundlePriorityInfo::GetState()
120 {
121 return state_;
122 }
123
SetState(BundleState state)124 void BundlePriorityInfo::SetState(BundleState state)
125 {
126 state_ = state;
127 }
128
GetCreateTime() const129 int64_t BundlePriorityInfo::GetCreateTime() const
130 {
131 return createTime_;
132 }
133
SetCreateTime(const int64_t createTime)134 void BundlePriorityInfo::SetCreateTime(const int64_t createTime)
135 {
136 createTime_ = createTime;
137 }
138
IncreaseProcsPriority(int delta)139 void BundlePriorityInfo::IncreaseProcsPriority(int delta)
140 {
141 for (auto i = procs_.begin(); i != procs_.end(); ++i) {
142 int oldPriority = i->second.priority_;
143 i->second.SetPriority(oldPriority + delta);
144 int newPriority = i->second.priority_;
145 HILOGI("pid = %{public}d, oldPriority = %{public}d, newPriority = %{public}d",
146 i->second.pid_, oldPriority, newPriority);
147 }
148 }
149 } // namespace Memory
150 } // namespace OHOS
151