Camera service: Update client eviction priorities
Use both oom score and process state for client eviction.
The score will have higher priority over the process state.
This should resolve the state ambiguity when PiP clients
try to connect to exclusive camera resources while
foreground clients are running.
BUG: 34701266
Test: Manual testing, complete CTS Camera package
Change-Id: Ic775b011a20e50f9c0c1c0a4bc1cf7ca75410740
diff --git a/services/camera/libcameraservice/utils/ClientManager.h b/services/camera/libcameraservice/utils/ClientManager.h
index 830c50b..d7135f1 100644
--- a/services/camera/libcameraservice/utils/ClientManager.h
+++ b/services/camera/libcameraservice/utils/ClientManager.h
@@ -31,6 +31,43 @@
namespace android {
namespace resource_policy {
+class ClientPriority {
+public:
+ ClientPriority(int32_t score, int32_t state) :
+ mScore(score), mState(state) {}
+
+ int32_t getScore() const { return mScore; }
+ int32_t getState() const { return mState; }
+
+ bool operator==(const ClientPriority& rhs) const {
+ return (this->mScore == rhs.mScore) && (this->mState == rhs.mState);
+ }
+
+ bool operator< (const ClientPriority& rhs) const {
+ if (this->mScore == rhs.mScore) {
+ return this->mState < rhs.mState;
+ } else {
+ return this->mScore < rhs.mScore;
+ }
+ }
+
+ bool operator> (const ClientPriority& rhs) const {
+ return rhs < *this;
+ }
+
+ bool operator<=(const ClientPriority& rhs) const {
+ return !(*this > rhs);
+ }
+
+ bool operator>=(const ClientPriority& rhs) const {
+ return !(*this < rhs);
+ }
+
+private:
+ int32_t mScore;
+ int32_t mState;
+};
+
// --------------------------------------------------------------------------------
/**
@@ -45,9 +82,9 @@
class ClientDescriptor final {
public:
ClientDescriptor(const KEY& key, const VALUE& value, int32_t cost,
- const std::set<KEY>& conflictingKeys, int32_t priority, int32_t ownerId);
+ const std::set<KEY>& conflictingKeys, int32_t score, int32_t ownerId, int32_t state);
ClientDescriptor(KEY&& key, VALUE&& value, int32_t cost, std::set<KEY>&& conflictingKeys,
- int32_t priority, int32_t ownerId);
+ int32_t score, int32_t ownerId, int32_t state);
~ClientDescriptor();
@@ -69,7 +106,7 @@
/**
* Return the priority for this descriptor.
*/
- int32_t getPriority() const;
+ const ClientPriority &getPriority() const;
/**
* Return the owner ID for this descriptor.
@@ -89,7 +126,7 @@
/**
* Set the proirity for this descriptor.
*/
- void setPriority(int32_t priority);
+ void setPriority(const ClientPriority& priority);
// This class is ordered by key
template<class K, class V>
@@ -100,7 +137,7 @@
VALUE mValue;
int32_t mCost;
std::set<KEY> mConflicting;
- int32_t mPriority;
+ ClientPriority mPriority;
int32_t mOwnerId;
}; // class ClientDescriptor
@@ -111,16 +148,17 @@
template<class KEY, class VALUE>
ClientDescriptor<KEY, VALUE>::ClientDescriptor(const KEY& key, const VALUE& value, int32_t cost,
- const std::set<KEY>& conflictingKeys, int32_t priority, int32_t ownerId) : mKey{key},
- mValue{value}, mCost{cost}, mConflicting{conflictingKeys}, mPriority{priority},
+ const std::set<KEY>& conflictingKeys, int32_t score, int32_t ownerId, int32_t state) :
+ mKey{key}, mValue{value}, mCost{cost}, mConflicting{conflictingKeys},
+ mPriority(score, state),
mOwnerId{ownerId} {}
template<class KEY, class VALUE>
ClientDescriptor<KEY, VALUE>::ClientDescriptor(KEY&& key, VALUE&& value, int32_t cost,
- std::set<KEY>&& conflictingKeys, int32_t priority, int32_t ownerId) :
+ std::set<KEY>&& conflictingKeys, int32_t score, int32_t ownerId, int32_t state) :
mKey{std::forward<KEY>(key)}, mValue{std::forward<VALUE>(value)}, mCost{cost},
- mConflicting{std::forward<std::set<KEY>>(conflictingKeys)}, mPriority{priority},
- mOwnerId{ownerId} {}
+ mConflicting{std::forward<std::set<KEY>>(conflictingKeys)},
+ mPriority(score, state), mOwnerId{ownerId} {}
template<class KEY, class VALUE>
ClientDescriptor<KEY, VALUE>::~ClientDescriptor() {}
@@ -141,7 +179,7 @@
}
template<class KEY, class VALUE>
-int32_t ClientDescriptor<KEY, VALUE>::getPriority() const {
+const ClientPriority& ClientDescriptor<KEY, VALUE>::getPriority() const {
return mPriority;
}
@@ -165,7 +203,7 @@
}
template<class KEY, class VALUE>
-void ClientDescriptor<KEY, VALUE>::setPriority(int32_t priority) {
+void ClientDescriptor<KEY, VALUE>::setPriority(const ClientPriority& priority) {
mPriority = priority;
}
@@ -231,7 +269,7 @@
* Given a map containing owner (pid) -> priority mappings, update the priority of each
* ClientDescriptor with an owner in this mapping.
*/
- void updatePriorities(const std::map<int32_t,int32_t>& ownerPriorityList);
+ void updatePriorities(const std::map<int32_t,ClientPriority>& ownerPriorityList);
/**
* Remove all ClientDescriptors.
@@ -383,17 +421,17 @@
const KEY& key = client->getKey();
int32_t cost = client->getCost();
- int32_t priority = client->getPriority();
+ ClientPriority priority = client->getPriority();
int32_t owner = client->getOwnerId();
int64_t totalCost = getCurrentCostLocked() + cost;
// Determine the MRU of the owners tied for having the highest priority
int32_t highestPriorityOwner = owner;
- int32_t highestPriority = priority;
+ ClientPriority highestPriority = priority;
for (const auto& i : mClients) {
- int32_t curPriority = i->getPriority();
- if (curPriority >= highestPriority) {
+ ClientPriority curPriority = i->getPriority();
+ if (curPriority <= highestPriority) {
highestPriority = curPriority;
highestPriorityOwner = i->getOwnerId();
}
@@ -408,7 +446,7 @@
for (const auto& i : mClients) {
const KEY& curKey = i->getKey();
int32_t curCost = i->getCost();
- int32_t curPriority = i->getPriority();
+ ClientPriority curPriority = i->getPriority();
int32_t curOwner = i->getOwnerId();
bool conflicting = (curKey == key || i->isConflicting(key) ||
@@ -417,13 +455,13 @@
if (!returnIncompatibleClients) {
// Find evicted clients
- if (conflicting && curPriority > priority) {
+ if (conflicting && curPriority < priority) {
// Pre-existing conflicting client with higher priority exists
evictList.clear();
evictList.push_back(client);
return evictList;
} else if (conflicting || ((totalCost > mMaxCost && curCost > 0) &&
- (curPriority <= priority) &&
+ (curPriority >= priority) &&
!(highestPriorityOwner == owner && owner == curOwner))) {
// Add a pre-existing client to the eviction list if:
// - We are adding a client with higher priority that conflicts with this one.
@@ -437,7 +475,7 @@
} else {
// Find clients preventing the incoming client from being added
- if (curPriority > priority && (conflicting || (totalCost > mMaxCost && curCost > 0))) {
+ if (curPriority < priority && (conflicting || (totalCost > mMaxCost && curCost > 0))) {
// Pre-existing conflicting client with higher priority exists
evictList.push_back(i);
}
@@ -524,7 +562,7 @@
template<class KEY, class VALUE, class LISTENER>
void ClientManager<KEY, VALUE, LISTENER>::updatePriorities(
- const std::map<int32_t,int32_t>& ownerPriorityList) {
+ const std::map<int32_t,ClientPriority>& ownerPriorityList) {
Mutex::Autolock lock(mLock);
for (auto& i : mClients) {
auto j = ownerPriorityList.find(i->getOwnerId());