1 /*
2 * Copyright 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 //#define LOG_NDEBUG 0
18 #define LOG_TAG "ResourceManagerService_test"
19
20 #include <utils/Log.h>
21
22 #include "ResourceManagerServiceTestUtils.h"
23 #include "ResourceManagerService.h"
24
25 namespace android {
26
27 class ResourceManagerServiceTest : public ResourceManagerServiceTestBase {
28 private:
createSecureVideoCodecResource(int amount=1)29 static MediaResource createSecureVideoCodecResource(int amount = 1) {
30 return MediaResource(MediaResource::Type::kSecureCodec,
31 MediaResource::SubType::kHwVideoCodec, amount);
32 }
33
createNonSecureVideoCodecResource(int amount=1)34 static MediaResource createNonSecureVideoCodecResource(int amount = 1) {
35 return MediaResource(MediaResource::Type::kNonSecureCodec,
36 MediaResource::SubType::kHwVideoCodec, amount);
37 }
38
createSecureAudioCodecResource(int amount=1)39 static MediaResource createSecureAudioCodecResource(int amount = 1) {
40 return MediaResource(MediaResource::Type::kSecureCodec,
41 MediaResource::SubType::kHwAudioCodec, amount);
42 }
43
createNonSecureAudioCodecResource(int amount=1)44 static MediaResource createNonSecureAudioCodecResource(int amount = 1) {
45 return MediaResource(MediaResource::Type::kNonSecureCodec,
46 MediaResource::SubType::kHwAudioCodec, amount);
47 }
48
createSecureImageCodecResource(int amount=1)49 static MediaResource createSecureImageCodecResource(int amount = 1) {
50 return MediaResource(MediaResource::Type::kSecureCodec,
51 MediaResource::SubType::kHwImageCodec, amount);
52 }
53
createNonSecureImageCodecResource(int amount=1)54 static MediaResource createNonSecureImageCodecResource(int amount = 1) {
55 return MediaResource(MediaResource::Type::kNonSecureCodec,
56 MediaResource::SubType::kHwImageCodec, amount);
57 }
58
createGraphicMemoryResource(int amount=1)59 static MediaResource createGraphicMemoryResource(int amount = 1) {
60 return MediaResource(MediaResource::Type::kGraphicMemory,
61 MediaResource::SubType::kUnspecifiedSubType, amount);
62 }
63
createDrmSessionResource(int amount=1)64 static MediaResource createDrmSessionResource(int amount = 1) {
65 return MediaResource(MediaResource::Type::kDrmSession,
66 MediaResource::SubType::kUnspecifiedSubType, amount);
67 }
68
createBatteryResource()69 static MediaResource createBatteryResource() {
70 return MediaResource(MediaResource::Type::kBattery,
71 MediaResource::SubType::kUnspecifiedSubType, 1);
72 }
73
createCpuBoostResource()74 static MediaResource createCpuBoostResource() {
75 return MediaResource(MediaResource::Type::kCpuBoost,
76 MediaResource::SubType::kUnspecifiedSubType, 1);
77 }
78
79 public:
ResourceManagerServiceTest(bool newRM=false)80 ResourceManagerServiceTest(bool newRM = false) : ResourceManagerServiceTestBase(newRM) {}
81
updateConfig(bool bSupportsMultipleSecureCodecs,bool bSupportsSecureWithNonSecureCodec)82 void updateConfig(bool bSupportsMultipleSecureCodecs, bool bSupportsSecureWithNonSecureCodec) {
83 std::vector<MediaResourcePolicyParcel> policies;
84 policies.push_back(
85 MediaResourcePolicy(
86 IResourceManagerService::kPolicySupportsMultipleSecureCodecs,
87 bSupportsMultipleSecureCodecs ? "true" : "false"));
88 policies.push_back(
89 MediaResourcePolicy(
90 IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec,
91 bSupportsSecureWithNonSecureCodec ? "true" : "false"));
92 mService->config(policies);
93 }
94
95 // test set up
96 // ---------------------------------------------------------------------------------
97 // pid priority client type number
98 // ---------------------------------------------------------------------------------
99 // kTestPid1(30) 30 mTestClient1 secure codec 1
100 // graphic memory 200
101 // graphic memory 200
102 // ---------------------------------------------------------------------------------
103 // kTestPid2(20) 20 mTestClient2 non-secure codec 1
104 // graphic memory 300
105 // -------------------------------------------
106 // mTestClient3 secure codec 1
107 // graphic memory 100
108 // ---------------------------------------------------------------------------------
addResource()109 void addResource() {
110 // kTestPid1 mTestClient1
111 std::vector<MediaResourceParcel> resources1;
112 resources1.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
113 ClientInfoParcel client1Info{.pid = static_cast<int32_t>(kTestPid1),
114 .uid = static_cast<int32_t>(kTestUid1),
115 .id = getId(mTestClient1),
116 .name = "none"};
117 mService->addResource(client1Info, mTestClient1, resources1);
118 resources1.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 200));
119 std::vector<MediaResourceParcel> resources11;
120 resources11.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 200));
121 mService->addResource(client1Info, mTestClient1, resources11);
122
123 // kTestPid2 mTestClient2
124 std::vector<MediaResourceParcel> resources2;
125 resources2.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 1));
126 resources2.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 300));
127 ClientInfoParcel client2Info{.pid = static_cast<int32_t>(kTestPid2),
128 .uid = static_cast<int32_t>(kTestUid2),
129 .id = getId(mTestClient2),
130 .name = "none"};
131 mService->addResource(client2Info, mTestClient2, resources2);
132
133 // kTestPid2 mTestClient3
134 std::vector<MediaResourceParcel> resources3;
135 ClientInfoParcel client3Info{.pid = static_cast<int32_t>(kTestPid2),
136 .uid = static_cast<int32_t>(kTestUid2),
137 .id = getId(mTestClient3),
138 .name = "none"};
139 mService->addResource(client3Info, mTestClient3, resources3);
140 resources3.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
141 resources3.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 100));
142 mService->addResource(client3Info, mTestClient3, resources3);
143
144 const PidResourceInfosMap &map = mService->getResourceMap();
145 EXPECT_EQ(2u, map.size());
146 const auto& mapIndex1 = map.find(kTestPid1);
147 EXPECT_TRUE(mapIndex1 != map.end());
148 const ResourceInfos &infos1 = mapIndex1->second;
149 EXPECT_EQ(1u, infos1.size());
150 expectEqResourceInfo(infos1.at(getId(mTestClient1)), kTestUid1, mTestClient1, resources1);
151
152 const auto& mapIndex2 = map.find(kTestPid2);
153 EXPECT_TRUE(mapIndex2 != map.end());
154 const ResourceInfos &infos2 = mapIndex2->second;
155 EXPECT_EQ(2u, infos2.size());
156 expectEqResourceInfo(infos2.at(getId(mTestClient2)), kTestUid2, mTestClient2, resources2);
157 expectEqResourceInfo(infos2.at(getId(mTestClient3)), kTestUid2, mTestClient3, resources3);
158 }
159
testCombineResourceWithNegativeValues()160 void testCombineResourceWithNegativeValues() {
161 // kTestPid1 mTestClient1
162 std::vector<MediaResourceParcel> resources1;
163 resources1.push_back(MediaResource(MediaResource::Type::kDrmSession, -100));
164 resources1.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, -100));
165 ClientInfoParcel client1Info{.pid = static_cast<int32_t>(kTestPid1),
166 .uid = static_cast<int32_t>(kTestUid1),
167 .id = getId(mTestClient1),
168 .name = "none"};
169 mService->addResource(client1Info, mTestClient1, resources1);
170
171 // Expected result:
172 // 1) the client should have been added;
173 // 2) both resource entries should have been rejected, resource list should be empty.
174 const PidResourceInfosMap &map = mService->getResourceMap();
175 EXPECT_EQ(1u, map.size());
176 const auto& mapIndex1 = map.find(kTestPid1);
177 EXPECT_TRUE(mapIndex1 != map.end());
178 const ResourceInfos &infos1 = mapIndex1->second;
179 EXPECT_EQ(1u, infos1.size());
180 std::vector<MediaResourceParcel> expected;
181 expectEqResourceInfo(infos1.at(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
182
183 resources1.clear();
184 resources1.push_back(MediaResource(MediaResource::Type::kDrmSession, INT64_MAX));
185 resources1.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, INT64_MAX));
186 mService->addResource(client1Info, mTestClient1, resources1);
187 resources1.clear();
188 resources1.push_back(MediaResource(MediaResource::Type::kDrmSession, 10));
189 resources1.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 10));
190 mService->addResource(client1Info, mTestClient1, resources1);
191
192 // Expected result:
193 // Both values should saturate to INT64_MAX
194 expected.push_back(MediaResource(MediaResource::Type::kDrmSession, INT64_MAX));
195 expected.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, INT64_MAX));
196 expectEqResourceInfo(infos1.at(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
197
198 resources1.clear();
199 resources1.push_back(MediaResource(MediaResource::Type::kDrmSession, -10));
200 resources1.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, -10));
201 mService->addResource(client1Info, mTestClient1, resources1);
202
203 // Expected result:
204 // 1) DrmSession resource should allow negative value addition, and value should drop accordingly
205 // 2) Non-drm session resource should ignore negative value addition.
206 expected.push_back(MediaResource(MediaResource::Type::kDrmSession, INT64_MAX - 10));
207 expected.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, INT64_MAX));
208 expectEqResourceInfo(infos1.at(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
209
210 resources1.clear();
211 resources1.push_back(MediaResource(MediaResource::Type::kDrmSession, INT64_MIN));
212 mService->addResource(client1Info, mTestClient1, resources1);
213
214 // Expected result:
215 // 1) DrmSession resource value should drop to 0, but the entry shouldn't be removed.
216 // 2) Non-drm session resource should ignore negative value addition.
217 expected.clear();
218 expected.push_back(MediaResource(MediaResource::Type::kDrmSession, 0));
219 expected.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, INT64_MAX));
220 expectEqResourceInfo(infos1.at(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
221 }
222
testConfig()223 void testConfig() {
224 EXPECT_TRUE(mService->mSupportsMultipleSecureCodecs);
225 EXPECT_TRUE(mService->mSupportsSecureWithNonSecureCodec);
226
227 updateConfig(true, false);
228 EXPECT_TRUE(mService->mSupportsMultipleSecureCodecs);
229 EXPECT_FALSE(mService->mSupportsSecureWithNonSecureCodec);
230
231 updateConfig(false, true);
232 EXPECT_FALSE(mService->mSupportsMultipleSecureCodecs);
233 EXPECT_TRUE(mService->mSupportsSecureWithNonSecureCodec);
234 }
235
testCombineResource()236 void testCombineResource() {
237 // kTestPid1 mTestClient1
238 std::vector<MediaResourceParcel> resources1;
239 resources1.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
240 ClientInfoParcel client1Info{.pid = static_cast<int32_t>(kTestPid1),
241 .uid = static_cast<int32_t>(kTestUid1),
242 .id = getId(mTestClient1),
243 .name = "none"};
244 mService->addResource(client1Info, mTestClient1, resources1);
245
246 std::vector<MediaResourceParcel> resources11;
247 resources11.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 200));
248 mService->addResource(client1Info, mTestClient1, resources11);
249
250 const PidResourceInfosMap &map = mService->getResourceMap();
251 EXPECT_EQ(1u, map.size());
252 const auto& mapIndex1 = map.find(kTestPid1);
253 EXPECT_TRUE(mapIndex1 != map.end());
254 const ResourceInfos &infos1 = mapIndex1->second;
255 EXPECT_EQ(1u, infos1.size());
256
257 // test adding existing types to combine values
258 resources1.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 100));
259 mService->addResource(client1Info, mTestClient1, resources1);
260
261 std::vector<MediaResourceParcel> expected;
262 expected.push_back(MediaResource(MediaResource::Type::kSecureCodec, 2));
263 expected.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 300));
264 expectEqResourceInfo(infos1.at(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
265
266 // test adding new types (including types that differs only in subType)
267 resources11.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 1));
268 resources11.push_back(MediaResource(MediaResource::Type::kSecureCodec,
269 MediaResource::SubType::kHwVideoCodec, 1));
270 mService->addResource(client1Info, mTestClient1, resources11);
271
272 expected.clear();
273 expected.push_back(MediaResource(MediaResource::Type::kSecureCodec, 2));
274 expected.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 1));
275 expected.push_back(MediaResource(MediaResource::Type::kSecureCodec,
276 MediaResource::SubType::kHwVideoCodec, 1));
277 expected.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 500));
278 expectEqResourceInfo(infos1.at(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
279 }
280
testRemoveResource()281 void testRemoveResource() {
282 // kTestPid1 mTestClient1
283 std::vector<MediaResourceParcel> resources1;
284 resources1.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
285 ClientInfoParcel client1Info{.pid = static_cast<int32_t>(kTestPid1),
286 .uid = static_cast<int32_t>(kTestUid1),
287 .id = getId(mTestClient1),
288 .name = "none"};
289 mService->addResource(client1Info, mTestClient1, resources1);
290
291 std::vector<MediaResourceParcel> resources11;
292 resources11.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 200));
293 mService->addResource(client1Info, mTestClient1, resources11);
294
295 const PidResourceInfosMap &map = mService->getResourceMap();
296 EXPECT_EQ(1u, map.size());
297 const auto& mapIndex1 = map.find(kTestPid1);
298 EXPECT_TRUE(mapIndex1 != map.end());
299 const ResourceInfos &infos1 = mapIndex1->second;
300 EXPECT_EQ(1u, infos1.size());
301
302 // test partial removal
303 resources11[0].value = 100;
304 mService->removeResource(client1Info, resources11);
305
306 std::vector<MediaResourceParcel> expected;
307 expected.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
308 expected.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 100));
309 expectEqResourceInfo(infos1.at(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
310
311 // test removal request with negative value, should be ignored
312 resources11[0].value = -10000;
313 mService->removeResource(client1Info, resources11);
314
315 expectEqResourceInfo(infos1.at(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
316
317 // test complete removal with overshoot value
318 resources11[0].value = 1000;
319 mService->removeResource(client1Info, resources11);
320
321 expected.clear();
322 expected.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
323 expectEqResourceInfo(infos1.at(getId(mTestClient1)), kTestUid1, mTestClient1, expected);
324 }
325
testOverridePid()326 void testOverridePid() {
327
328 std::vector<MediaResourceParcel> resources;
329 resources.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
330 resources.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 150));
331
332 // ### secure codec can't coexist and secure codec can coexist with non-secure codec ###
333 {
334 addResource();
335 updateConfig(false, true);
336
337 // priority too low to reclaim resource
338 ClientInfoParcel clientInfo{.pid = static_cast<int32_t>(kLowPriorityPid),
339 .uid = static_cast<int32_t>(kTestUid1),
340 .id = kLowPriorityClientId,
341 .name = "none"};
342 CHECK_STATUS_FALSE(mService->reclaimResource(clientInfo, resources, &result));
343
344 // override Low Priority Pid with High Priority Pid
345 mService->overridePid(kLowPriorityPid, kHighPriorityPid);
346 CHECK_STATUS_TRUE(mService->reclaimResource(clientInfo, resources, &result));
347
348 // restore Low Priority Pid
349 mService->overridePid(kLowPriorityPid, -1);
350 CHECK_STATUS_FALSE(mService->reclaimResource(clientInfo, resources, &result));
351 }
352 }
353
testMarkClientForPendingRemoval()354 void testMarkClientForPendingRemoval() {
355 ClientInfoParcel client1Info{.pid = static_cast<int32_t>(kTestPid1),
356 .uid = static_cast<int32_t>(kTestUid1),
357 .id = getId(mTestClient1),
358 .name = "none"};
359 ClientInfoParcel client2Info{.pid = static_cast<int32_t>(kTestPid2),
360 .uid = static_cast<int32_t>(kTestUid2),
361 .id = getId(mTestClient2),
362 .name = "none"};
363 ClientInfoParcel client3Info{.pid = static_cast<int32_t>(kTestPid2),
364 .uid = static_cast<int32_t>(kTestUid2),
365 .id = getId(mTestClient3),
366 .name = "none"};
367 {
368 addResource();
369 updateConfig(true, true);
370
371 std::vector<MediaResourceParcel> resources;
372 resources.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 1));
373
374 // Remove low priority clients
375 mService->removeClient(client1Info);
376
377 // no lower priority client
378 CHECK_STATUS_FALSE(mService->reclaimResource(client2Info, resources, &result));
379 EXPECT_EQ(false, toTestClient(mTestClient1)->checkIfReclaimedAndReset());
380 EXPECT_EQ(false, toTestClient(mTestClient2)->checkIfReclaimedAndReset());
381 EXPECT_EQ(false, toTestClient(mTestClient3)->checkIfReclaimedAndReset());
382
383 mService->markClientForPendingRemoval(client2Info);
384
385 // client marked for pending removal from the same process got reclaimed
386 CHECK_STATUS_TRUE(mService->reclaimResource(client2Info, resources, &result));
387 EXPECT_EQ(false, toTestClient(mTestClient1)->checkIfReclaimedAndReset());
388 EXPECT_EQ(true, toTestClient(mTestClient2)->checkIfReclaimedAndReset());
389 EXPECT_EQ(false, toTestClient(mTestClient3)->checkIfReclaimedAndReset());
390
391 // clean up client 3 which still left
392 mService->removeClient(client3Info);
393 }
394
395 {
396 addResource();
397 updateConfig(true, true);
398
399 std::vector<MediaResourceParcel> resources;
400 resources.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 1));
401
402 mService->markClientForPendingRemoval(client2Info);
403
404 // client marked for pending removal from the same process got reclaimed
405 // first, even though there are lower priority process
406 CHECK_STATUS_TRUE(mService->reclaimResource(client2Info, resources, &result));
407 EXPECT_EQ(false, toTestClient(mTestClient1)->checkIfReclaimedAndReset());
408 EXPECT_EQ(true, toTestClient(mTestClient2)->checkIfReclaimedAndReset());
409 EXPECT_EQ(false, toTestClient(mTestClient3)->checkIfReclaimedAndReset());
410
411 // lower priority client got reclaimed
412 CHECK_STATUS_TRUE(mService->reclaimResource(client2Info, resources, &result));
413 EXPECT_EQ(true, toTestClient(mTestClient1)->checkIfReclaimedAndReset());
414 EXPECT_EQ(false, toTestClient(mTestClient2)->checkIfReclaimedAndReset());
415 EXPECT_EQ(false, toTestClient(mTestClient3)->checkIfReclaimedAndReset());
416
417 // clean up client 3 which still left
418 mService->removeClient(client3Info);
419 }
420
421 {
422 addResource();
423 updateConfig(true, true);
424
425 mService->markClientForPendingRemoval(client2Info);
426
427 // client marked for pending removal got reclaimed
428 EXPECT_TRUE(mService->reclaimResourcesFromClientsPendingRemoval(kTestPid2).isOk());
429 EXPECT_EQ(false, toTestClient(mTestClient1)->checkIfReclaimedAndReset());
430 EXPECT_EQ(true, toTestClient(mTestClient2)->checkIfReclaimedAndReset());
431 EXPECT_EQ(false, toTestClient(mTestClient3)->checkIfReclaimedAndReset());
432
433 // No more clients marked for removal
434 EXPECT_TRUE(mService->reclaimResourcesFromClientsPendingRemoval(kTestPid2).isOk());
435 EXPECT_EQ(false, toTestClient(mTestClient1)->checkIfReclaimedAndReset());
436 EXPECT_EQ(false, toTestClient(mTestClient2)->checkIfReclaimedAndReset());
437 EXPECT_EQ(false, toTestClient(mTestClient3)->checkIfReclaimedAndReset());
438
439 mService->markClientForPendingRemoval(client3Info);
440
441 // client marked for pending removal got reclaimed
442 EXPECT_TRUE(mService->reclaimResourcesFromClientsPendingRemoval(kTestPid2).isOk());
443 EXPECT_EQ(false, toTestClient(mTestClient1)->checkIfReclaimedAndReset());
444 EXPECT_EQ(false, toTestClient(mTestClient2)->checkIfReclaimedAndReset());
445 EXPECT_EQ(true, toTestClient(mTestClient3)->checkIfReclaimedAndReset());
446
447 // clean up client 1 which still left
448 mService->removeClient(client1Info);
449 }
450 }
451
testRemoveClient()452 void testRemoveClient() {
453 addResource();
454
455 ClientInfoParcel client2Info{.pid = static_cast<int32_t>(kTestPid2),
456 .uid = static_cast<int32_t>(kTestUid2),
457 .id = getId(mTestClient2),
458 .name = "none"};
459 mService->removeClient(client2Info);
460
461 const PidResourceInfosMap &map = mService->getResourceMap();
462 EXPECT_EQ(2u, map.size());
463 const ResourceInfos &infos1 = map.at(kTestPid1);
464 const ResourceInfos &infos2 = map.at(kTestPid2);
465 EXPECT_EQ(1u, infos1.size());
466 EXPECT_EQ(1u, infos2.size());
467 // mTestClient2 has been removed.
468 EXPECT_EQ(mTestClient3, infos2.at(getId(mTestClient3)).client);
469 }
470
testGetAllClients()471 void testGetAllClients() {
472 addResource();
473
474 std::vector<ClientInfo> targetClients;
475 MediaResource resource(MediaResource::Type::kSecureCodec,
476 MediaResource::SubType::kUnspecifiedSubType,
477 1);
478 ResourceRequestInfo requestInfoHigh { kHighPriorityPid, kHighPriorityClientId, &resource};
479 ResourceRequestInfo requestInfoMid { kMidPriorityPid, kMidPriorityClientId, &resource};
480 ResourceRequestInfo requestInfoLow { kLowPriorityPid, kLowPriorityClientId, &resource};
481
482 EXPECT_FALSE(mService->getAllClients_l(requestInfoLow, targetClients));
483 // some higher priority process (e.g. kTestPid2) owns the resource, so getAllClients_l
484 // will fail.
485 EXPECT_FALSE(mService->getAllClients_l(requestInfoMid, targetClients));
486 EXPECT_TRUE(mService->getAllClients_l(requestInfoHigh, targetClients));
487
488 EXPECT_EQ(2u, targetClients.size());
489 // (OK to require ordering in clients[], as the pid map is sorted)
490 EXPECT_EQ(getId(mTestClient3), targetClients[0].mClientId);
491 EXPECT_EQ(getId(mTestClient1), targetClients[1].mClientId);
492 }
493
494 // test set up
495 // ---------------------------------------------------------------------------
496 // pid/priority client/clientId type number
497 // ---------------------------------------------------------------------------
498 // kTestPid1(30) mTestClient1 secure codec 1
499 // graphic memory 200
500 // graphic memory 200
501 // ---------------------------------------------------------------------------
502 // kTestPid2(20) mTestClient2 non-secure codec 1
503 // graphic memory 300
504 // ---------------------------------------------------
505 // mTestClient3 secure codec 1
506 // graphic memory 100
507 // ---------------------------------------------------------------------------
508 // kHighPriorityPid(10) kHighPriorityClient secure codec 1
509 // ---------------------------------------------------------------------------
510 // The kHighPriorityClient tries to reclaim request (after adding self)
511 // This should pass (and shouldn't be considered as a new client trying to
512 // reclaim from an existing client from same/higher priority process).
testSelfReclaimResourceSecure()513 void testSelfReclaimResourceSecure() {
514 std::vector<MediaResourceParcel> resources;
515 resources.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
516 resources.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 150));
517
518 ClientInfoParcel lowPriorityClient{.pid = static_cast<int32_t>(kLowPriorityPid),
519 .uid = static_cast<int32_t>(kTestUid2),
520 .id = kLowPriorityClientId,
521 .name = "none"};
522 ClientInfoParcel midPriorityClient{.pid = static_cast<int32_t>(kMidPriorityPid),
523 .uid = static_cast<int32_t>(kTestUid2),
524 .id = kMidPriorityClientId,
525 .name = "none"};
526 // HighPriority process with client id kHighPriorityClientId.
527 ClientInfoParcel highPriorityClient1{.pid = static_cast<int32_t>(kHighPriorityPid),
528 .uid = static_cast<int32_t>(kTestUid2),
529 .id = kHighPriorityClientId,
530 .name = "none"};
531 // HighPriority process with client id 0xABCD.
532 ClientInfoParcel highPriorityClient2{.pid = static_cast<int32_t>(kHighPriorityPid),
533 .uid = static_cast<int32_t>(kTestUid2),
534 .id = 0xABCD,
535 .name = "none"};
536
537 addResource();
538
539 // Add a secure codec resource for the highPriorityClient1.
540 std::shared_ptr<IResourceManagerClient> testClient4 =
541 createTestClient(kHighPriorityPid, kTestUid2);
542 std::vector<MediaResourceParcel> resources1;
543 resources1.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
544 mService->addResource(highPriorityClient1, testClient4, resources1);
545
546 // secure codecs can't coexist and secure codec can't coexist with non-secure codec.
547 updateConfig(false, false);
548
549 // priority too low
550 CHECK_STATUS_FALSE(mService->reclaimResource(lowPriorityClient, resources, &result));
551 CHECK_STATUS_FALSE(mService->reclaimResource(midPriorityClient, resources, &result));
552
553 // highPriorityClient2 tries to reclaim SecureCodec with Graphic memory.
554 // This should fail as this process already has an instance of secure
555 // codec through testClient4.
556 CHECK_STATUS_FALSE(mService->reclaimResource(highPriorityClient2, resources, &result));
557
558 // highPriorityClient1 tries to reclaim SecureCodec with Graphic memory.
559 // This should reclaim all secure and non-secure codecs.
560 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient1, resources, &result));
561 EXPECT_TRUE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
562 EXPECT_TRUE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
563 EXPECT_TRUE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
564
565 // Make sure there is nothing left.
566 CHECK_STATUS_FALSE(mService->reclaimResource(highPriorityClient1, resources, &result));
567 }
568
testReclaimResourceSecure()569 void testReclaimResourceSecure() {
570 std::vector<MediaResourceParcel> resources;
571 resources.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
572 resources.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 150));
573
574 ClientInfoParcel lowPriorityClient{.pid = static_cast<int32_t>(kLowPriorityPid),
575 .uid = static_cast<int32_t>(kTestUid2),
576 .id = kLowPriorityClientId,
577 .name = "none"};
578 ClientInfoParcel midPriorityClient{.pid = static_cast<int32_t>(kMidPriorityPid),
579 .uid = static_cast<int32_t>(kTestUid2),
580 .id = kMidPriorityClientId,
581 .name = "none"};
582 ClientInfoParcel highPriorityClient{.pid = static_cast<int32_t>(kHighPriorityPid),
583 .uid = static_cast<int32_t>(kTestUid2),
584 .id = kHighPriorityClientId,
585 .name = "none"};
586
587 // ### secure codec can't coexist and secure codec can coexist with non-secure codec ###
588 {
589 addResource();
590 updateConfig(false, true);
591
592 // priority too low
593 CHECK_STATUS_FALSE(mService->reclaimResource(lowPriorityClient, resources, &result));
594 CHECK_STATUS_FALSE(mService->reclaimResource(midPriorityClient, resources, &result));
595
596 // reclaim all secure codecs
597 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
598 EXPECT_TRUE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
599 EXPECT_FALSE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
600 EXPECT_TRUE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
601
602 // call again should reclaim one largest graphic memory from lowest process
603 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
604 EXPECT_FALSE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
605 EXPECT_TRUE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
606 EXPECT_FALSE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
607
608 // nothing left
609 CHECK_STATUS_FALSE(mService->reclaimResource(highPriorityClient, resources, &result));
610 }
611
612 // ### secure codecs can't coexist and secure codec can't coexist with non-secure codec ###
613 {
614 addResource();
615 updateConfig(false, false);
616
617 // priority too low
618 CHECK_STATUS_FALSE(mService->reclaimResource(lowPriorityClient, resources, &result));
619 CHECK_STATUS_FALSE(mService->reclaimResource(midPriorityClient, resources, &result));
620
621 // reclaim all secure and non-secure codecs
622 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
623 EXPECT_TRUE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
624 EXPECT_TRUE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
625 EXPECT_TRUE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
626
627 // nothing left
628 CHECK_STATUS_FALSE(mService->reclaimResource(highPriorityClient, resources, &result));
629 }
630
631 // ### secure codecs can coexist but secure codec can't coexist with non-secure codec ###
632 {
633 addResource();
634 updateConfig(true, false);
635
636 // priority too low
637 CHECK_STATUS_FALSE(mService->reclaimResource(lowPriorityClient, resources, &result));
638 CHECK_STATUS_FALSE(mService->reclaimResource(midPriorityClient, resources, &result));
639
640 // reclaim all non-secure codecs
641 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
642 EXPECT_FALSE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
643 EXPECT_TRUE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
644 EXPECT_FALSE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
645
646 // call again should reclaim one largest graphic memory from lowest process
647 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
648 EXPECT_TRUE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
649 EXPECT_FALSE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
650 EXPECT_FALSE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
651
652 // call again should reclaim another largest graphic memory from lowest process
653 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
654 EXPECT_FALSE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
655 EXPECT_FALSE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
656 EXPECT_TRUE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
657
658 // nothing left
659 CHECK_STATUS_FALSE(mService->reclaimResource(highPriorityClient, resources, &result));
660 }
661
662 // ### secure codecs can coexist and secure codec can coexist with non-secure codec ###
663 {
664 addResource();
665 updateConfig(true, true);
666
667 // priority too low
668 CHECK_STATUS_FALSE(mService->reclaimResource(lowPriorityClient, resources, &result));
669
670 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
671 // one largest graphic memory from lowest process got reclaimed
672 EXPECT_TRUE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
673 EXPECT_FALSE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
674 EXPECT_FALSE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
675
676 // call again should reclaim another graphic memory from lowest process
677 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
678 EXPECT_FALSE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
679 EXPECT_TRUE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
680 EXPECT_FALSE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
681
682 // call again should reclaim another graphic memory from lowest process
683 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
684 EXPECT_FALSE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
685 EXPECT_FALSE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
686 EXPECT_TRUE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
687
688 // nothing left
689 CHECK_STATUS_FALSE(mService->reclaimResource(highPriorityClient, resources, &result));
690 }
691
692 // ### secure codecs can coexist and secure codec can coexist with non-secure codec ###
693 {
694 addResource();
695 updateConfig(true, true);
696
697 std::vector<MediaResourceParcel> resources;
698 resources.push_back(MediaResource(MediaResource::Type::kSecureCodec, 1));
699
700 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
701 // secure codec from lowest process got reclaimed
702 EXPECT_TRUE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
703 EXPECT_FALSE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
704 EXPECT_FALSE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
705
706 // call again should reclaim another secure codec from lowest process
707 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
708 EXPECT_FALSE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
709 EXPECT_FALSE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
710 EXPECT_TRUE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
711
712 // no more secure codec, non-secure codec will be reclaimed.
713 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
714 EXPECT_FALSE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
715 EXPECT_TRUE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
716 EXPECT_FALSE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
717 }
718 }
719
testReclaimResourceNonSecure()720 void testReclaimResourceNonSecure() {
721 std::vector<MediaResourceParcel> resources;
722 resources.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 1));
723 resources.push_back(MediaResource(MediaResource::Type::kGraphicMemory, 150));
724
725 ClientInfoParcel lowPriorityClient{.pid = static_cast<int32_t>(kLowPriorityPid),
726 .uid = static_cast<int32_t>(kTestUid2),
727 .id = kLowPriorityClientId,
728 .name = "none"};
729 ClientInfoParcel midPriorityClient{.pid = static_cast<int32_t>(kMidPriorityPid),
730 .uid = static_cast<int32_t>(kTestUid2),
731 .id = kMidPriorityClientId,
732 .name = "none"};
733 ClientInfoParcel highPriorityClient{.pid = static_cast<int32_t>(kHighPriorityPid),
734 .uid = static_cast<int32_t>(kTestUid2),
735 .id = kHighPriorityClientId,
736 .name = "none"};
737
738 // ### secure codec can't coexist with non-secure codec ###
739 {
740 addResource();
741 updateConfig(true, false);
742
743 // priority too low
744 CHECK_STATUS_FALSE(mService->reclaimResource(lowPriorityClient, resources, &result));
745 CHECK_STATUS_FALSE(mService->reclaimResource(midPriorityClient, resources, &result));
746
747 // reclaim all secure codecs
748 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
749 EXPECT_TRUE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
750 EXPECT_FALSE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
751 EXPECT_TRUE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
752
753 // call again should reclaim one graphic memory from lowest process
754 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
755 EXPECT_FALSE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
756 EXPECT_TRUE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
757 EXPECT_FALSE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
758
759 // nothing left
760 CHECK_STATUS_FALSE(mService->reclaimResource(highPriorityClient, resources, &result));
761 }
762
763
764 // ### secure codec can coexist with non-secure codec ###
765 {
766 addResource();
767 updateConfig(true, true);
768
769 // priority too low
770 CHECK_STATUS_FALSE(mService->reclaimResource(lowPriorityClient, resources, &result));
771
772 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
773 // one largest graphic memory from lowest process got reclaimed
774 EXPECT_TRUE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
775 EXPECT_FALSE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
776 EXPECT_FALSE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
777
778 // call again should reclaim another graphic memory from lowest process
779 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
780 EXPECT_FALSE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
781 EXPECT_TRUE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
782 EXPECT_FALSE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
783
784 // call again should reclaim another graphic memory from lowest process
785 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
786 EXPECT_FALSE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
787 EXPECT_FALSE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
788 EXPECT_TRUE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
789
790 // nothing left
791 CHECK_STATUS_FALSE(mService->reclaimResource(highPriorityClient, resources, &result));
792 }
793
794 // ### secure codec can coexist with non-secure codec ###
795 {
796 addResource();
797 updateConfig(true, true);
798
799 std::vector<MediaResourceParcel> resources;
800 resources.push_back(MediaResource(MediaResource::Type::kNonSecureCodec, 1));
801
802 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
803 // one non secure codec from lowest process got reclaimed
804 EXPECT_FALSE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
805 EXPECT_TRUE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
806 EXPECT_FALSE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
807
808 // no more non-secure codec, secure codec from lowest priority process will be reclaimed
809 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, resources, &result));
810 EXPECT_TRUE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
811 EXPECT_FALSE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
812 EXPECT_FALSE(toTestClient(mTestClient3)->checkIfReclaimedAndReset());
813
814 // clean up client 3 which still left
815 ClientInfoParcel clientInfo{.pid = static_cast<int32_t>(kTestPid2),
816 .uid = static_cast<int32_t>(kTestUid2),
817 .id = getId(mTestClient3),
818 .name = "none"};
819 mService->removeClient(clientInfo);
820 }
821 }
822
testGetLowestPriorityBiggestClient()823 void testGetLowestPriorityBiggestClient() {
824 ClientInfo clientInfo;
825 MediaResource resource(MediaResource::Type::kGraphicMemory,
826 MediaResource::SubType::kUnspecifiedSubType,
827 1);
828 ResourceRequestInfo requestInfoHigh { kHighPriorityPid, kHighPriorityClientId, &resource};
829 ResourceRequestInfo requestInfoLow { kLowPriorityPid, kLowPriorityClientId, &resource};
830 EXPECT_FALSE(mService->getLowestPriorityBiggestClient_l(requestInfoHigh, clientInfo));
831
832 addResource();
833
834 EXPECT_FALSE(mService->getLowestPriorityBiggestClient_l(requestInfoLow, clientInfo));
835 EXPECT_TRUE(mService->getLowestPriorityBiggestClient_l(requestInfoHigh, clientInfo));
836
837 // kTestPid1 is the lowest priority process with MediaResource::Type::kGraphicMemory.
838 // mTestClient1 has the largest MediaResource::Type::kGraphicMemory within kTestPid1.
839 EXPECT_EQ(getId(mTestClient1), clientInfo.mClientId);
840 }
841
testGetLowestPriorityPid()842 void testGetLowestPriorityPid() {
843 int pid;
844 int priority;
845 TestProcessInfo processInfo;
846
847 MediaResource::Type type = MediaResource::Type::kGraphicMemory;
848 MediaResource::SubType subType = MediaResource::SubType::kUnspecifiedSubType;
849 EXPECT_FALSE(mService->getLowestPriorityPid_l(type, subType, &pid, &priority));
850
851 addResource();
852
853 EXPECT_TRUE(mService->getLowestPriorityPid_l(type, subType, &pid, &priority));
854 EXPECT_EQ(kTestPid1, pid);
855 int priority1;
856 processInfo.getPriority(kTestPid1, &priority1);
857 EXPECT_EQ(priority1, priority);
858
859 type = MediaResource::Type::kNonSecureCodec;
860 EXPECT_TRUE(mService->getLowestPriorityPid_l(type, subType, &pid, &priority));
861 EXPECT_EQ(kTestPid2, pid);
862 int priority2;
863 processInfo.getPriority(kTestPid2, &priority2);
864 EXPECT_EQ(priority2, priority);
865 }
866
testIsCallingPriorityHigher()867 void testIsCallingPriorityHigher() {
868 EXPECT_FALSE(mService->isCallingPriorityHigher_l(101, 100));
869 EXPECT_FALSE(mService->isCallingPriorityHigher_l(100, 100));
870 EXPECT_TRUE(mService->isCallingPriorityHigher_l(99, 100));
871 }
872
testBatteryStats()873 void testBatteryStats() {
874 // reset should always be called when ResourceManagerService is created (restarted)
875 EXPECT_EQ(1u, mSystemCB->eventCount());
876 EXPECT_EQ(EventType::VIDEO_RESET, mSystemCB->lastEventType());
877
878 // new client request should cause VIDEO_ON
879 std::vector<MediaResourceParcel> resources1;
880 resources1.push_back(MediaResource(MediaResource::Type::kBattery,
881 MediaResource::SubType::kHwVideoCodec, 1));
882 ClientInfoParcel client1Info{.pid = static_cast<int32_t>(kTestPid1),
883 .uid = static_cast<int32_t>(kTestUid1),
884 .id = getId(mTestClient1),
885 .name = "none"};
886 mService->addResource(client1Info, mTestClient1, resources1);
887 EXPECT_EQ(2u, mSystemCB->eventCount());
888 EXPECT_EQ(EventEntry({EventType::VIDEO_ON, kTestUid1}), mSystemCB->lastEvent());
889
890 // each client should only cause 1 VIDEO_ON
891 mService->addResource(client1Info, mTestClient1, resources1);
892 EXPECT_EQ(2u, mSystemCB->eventCount());
893
894 // new client request should cause VIDEO_ON
895 std::vector<MediaResourceParcel> resources2;
896 resources2.push_back(MediaResource(MediaResource::Type::kBattery,
897 MediaResource::SubType::kHwVideoCodec, 2));
898 ClientInfoParcel client2Info{.pid = static_cast<int32_t>(kTestPid2),
899 .uid = static_cast<int32_t>(kTestUid2),
900 .id = getId(mTestClient2),
901 .name = "none"};
902 mService->addResource(client2Info, mTestClient2, resources2);
903 EXPECT_EQ(3u, mSystemCB->eventCount());
904 EXPECT_EQ(EventEntry({EventType::VIDEO_ON, kTestUid2}), mSystemCB->lastEvent());
905
906 // partially remove mTestClient1's request, shouldn't be any VIDEO_OFF
907 mService->removeResource(client1Info, resources1);
908 EXPECT_EQ(3u, mSystemCB->eventCount());
909
910 // remove mTestClient1's request, should be VIDEO_OFF for kTestUid1
911 // (use resource2 to test removing more instances than previously requested)
912 mService->removeResource(client1Info, resources2);
913 EXPECT_EQ(4u, mSystemCB->eventCount());
914 EXPECT_EQ(EventEntry({EventType::VIDEO_OFF, kTestUid1}), mSystemCB->lastEvent());
915
916 // remove mTestClient2, should be VIDEO_OFF for kTestUid2
917 mService->removeClient(client2Info);
918 EXPECT_EQ(5u, mSystemCB->eventCount());
919 EXPECT_EQ(EventEntry({EventType::VIDEO_OFF, kTestUid2}), mSystemCB->lastEvent());
920 }
921
testCpusetBoost()922 void testCpusetBoost() {
923 // reset should always be called when ResourceManagerService is created (restarted)
924 EXPECT_EQ(1u, mSystemCB->eventCount());
925 EXPECT_EQ(EventType::VIDEO_RESET, mSystemCB->lastEventType());
926
927 // new client request should cause CPUSET_ENABLE
928 std::vector<MediaResourceParcel> resources1;
929 resources1.push_back(MediaResource(MediaResource::Type::kCpuBoost, 1));
930 ClientInfoParcel client1Info{.pid = static_cast<int32_t>(kTestPid1),
931 .uid = static_cast<int32_t>(kTestUid1),
932 .id = getId(mTestClient1),
933 .name = "none"};
934 mService->addResource(client1Info, mTestClient1, resources1);
935 EXPECT_EQ(2u, mSystemCB->eventCount());
936 EXPECT_EQ(EventType::CPUSET_ENABLE, mSystemCB->lastEventType());
937
938 // each client should only cause 1 CPUSET_ENABLE
939 mService->addResource(client1Info, mTestClient1, resources1);
940 EXPECT_EQ(2u, mSystemCB->eventCount());
941
942 // new client request should cause CPUSET_ENABLE
943 std::vector<MediaResourceParcel> resources2;
944 resources2.push_back(MediaResource(MediaResource::Type::kCpuBoost, 2));
945 ClientInfoParcel client2Info{.pid = static_cast<int32_t>(kTestPid2),
946 .uid = static_cast<int32_t>(kTestUid2),
947 .id = getId(mTestClient2),
948 .name = "none"};
949 mService->addResource(client2Info, mTestClient2, resources2);
950 EXPECT_EQ(3u, mSystemCB->eventCount());
951 EXPECT_EQ(EventType::CPUSET_ENABLE, mSystemCB->lastEventType());
952
953 // remove mTestClient2 should not cause CPUSET_DISABLE, mTestClient1 still active
954 mService->removeClient(client2Info);
955 EXPECT_EQ(3u, mSystemCB->eventCount());
956
957 // remove 1 cpuboost from mTestClient1, should not be CPUSET_DISABLE (still 1 left)
958 mService->removeResource(client1Info, resources1);
959 EXPECT_EQ(3u, mSystemCB->eventCount());
960
961 // remove 2 cpuboost from mTestClient1, should be CPUSET_DISABLE
962 // (use resource2 to test removing more than previously requested)
963 mService->removeResource(client1Info, resources2);
964 EXPECT_EQ(4u, mSystemCB->eventCount());
965 EXPECT_EQ(EventType::CPUSET_DISABLE, mSystemCB->lastEventType());
966 }
967
testReclaimResources_withVideoCodec_reclaimsOnlyVideoCodec()968 void testReclaimResources_withVideoCodec_reclaimsOnlyVideoCodec() {
969 const std::shared_ptr<IResourceManagerClient>& audioImageTestClient = mTestClient1;
970 const std::shared_ptr<IResourceManagerClient>& videoTestClient = mTestClient2;
971
972 // Create an audio and image codec resource
973 std::vector<MediaResourceParcel> audioImageResources;
974 audioImageResources.push_back(createNonSecureAudioCodecResource());
975 audioImageResources.push_back(createNonSecureImageCodecResource());
976 ClientInfoParcel client1Info{.pid = static_cast<int32_t>(kLowPriorityPid),
977 .uid = static_cast<int32_t>(kTestUid1),
978 .id = getId(audioImageTestClient),
979 .name = "none"};
980 mService->addResource(client1Info, audioImageTestClient, audioImageResources);
981
982 // Fail to reclaim a video codec resource
983 std::vector<MediaResourceParcel> reclaimResources;
984 reclaimResources.push_back(createNonSecureVideoCodecResource());
985 ClientInfoParcel highPriorityClient{.pid = static_cast<int32_t>(kHighPriorityPid),
986 .uid = static_cast<int32_t>(kTestUid2),
987 .id = kHighPriorityClientId,
988 .name = "none"};
989 CHECK_STATUS_FALSE(mService->reclaimResource(highPriorityClient, reclaimResources, &result));
990
991 // Now add a video codec resource
992 std::vector<MediaResourceParcel> videoResources;
993 videoResources.push_back(createNonSecureVideoCodecResource());
994 ClientInfoParcel client2Info{.pid = static_cast<int32_t>(kLowPriorityPid),
995 .uid = static_cast<int32_t>(kTestUid1),
996 .id = getId(videoTestClient),
997 .name = "none"};
998 mService->addResource(client2Info, videoTestClient, videoResources);
999
1000 // Verify that the newly-created video codec resource can be reclaimed
1001 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, reclaimResources, &result));
1002
1003 // Verify that the audio and image resources are untouched
1004 EXPECT_FALSE(toTestClient(audioImageTestClient)->checkIfReclaimedAndReset());
1005 // But the video resource was reclaimed
1006 EXPECT_TRUE(toTestClient(videoTestClient)->checkIfReclaimedAndReset());
1007 }
1008
testReclaimResources_withAudioCodec_reclaimsOnlyAudioCodec()1009 void testReclaimResources_withAudioCodec_reclaimsOnlyAudioCodec() {
1010 const auto & videoImageTestClient = mTestClient1;
1011 const auto & audioTestClient = mTestClient2;
1012
1013 // Create a video and audio codec resource
1014 std::vector<MediaResourceParcel> videoImageResources;
1015 videoImageResources.push_back(createNonSecureVideoCodecResource());
1016 videoImageResources.push_back(createNonSecureImageCodecResource());
1017 ClientInfoParcel client1Info{.pid = static_cast<int32_t>(kLowPriorityPid),
1018 .uid = static_cast<int32_t>(kTestUid1),
1019 .id = getId(videoImageTestClient),
1020 .name = "none"};
1021 mService->addResource(client1Info, videoImageTestClient, videoImageResources);
1022
1023 // Fail to reclaim an audio codec resource
1024 std::vector<MediaResourceParcel> reclaimResources;
1025 reclaimResources.push_back(createNonSecureAudioCodecResource());
1026 ClientInfoParcel highPriorityClient{.pid = static_cast<int32_t>(kHighPriorityPid),
1027 .uid = static_cast<int32_t>(kTestUid2),
1028 .id = kHighPriorityClientId,
1029 .name = "none"};
1030 CHECK_STATUS_FALSE(mService->reclaimResource(highPriorityClient, reclaimResources, &result));
1031
1032 // Now add an audio codec resource
1033 std::vector<MediaResourceParcel> audioResources;
1034 audioResources.push_back(createNonSecureAudioCodecResource());
1035 ClientInfoParcel client2Info{.pid = static_cast<int32_t>(kLowPriorityPid),
1036 .uid = static_cast<int32_t>(kTestUid2),
1037 .id = getId(audioTestClient),
1038 .name = "none"};
1039 mService->addResource(client2Info, audioTestClient, audioResources);
1040
1041 // Verify that the newly-created audio codec resource can be reclaimed
1042 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, reclaimResources, &result));
1043
1044 // Verify that the video and image resources are untouched
1045 EXPECT_FALSE(toTestClient(videoImageTestClient)->checkIfReclaimedAndReset());
1046 // But the audio resource was reclaimed
1047 EXPECT_TRUE(toTestClient(audioTestClient)->checkIfReclaimedAndReset());
1048 }
1049
testReclaimResources_withImageCodec_reclaimsOnlyImageCodec()1050 void testReclaimResources_withImageCodec_reclaimsOnlyImageCodec() {
1051 const auto & videoAudioTestClient = mTestClient1;
1052 const auto & imageTestClient = mTestClient2;
1053
1054 // Create a video and audio codec resource
1055 std::vector<MediaResourceParcel> videoAudioResources;
1056 videoAudioResources.push_back(createNonSecureVideoCodecResource());
1057 videoAudioResources.push_back(createNonSecureAudioCodecResource());
1058 ClientInfoParcel client1Info{.pid = static_cast<int32_t>(kLowPriorityPid),
1059 .uid = static_cast<int32_t>(kTestUid1),
1060 .id = getId(videoAudioTestClient),
1061 .name = "none"};
1062 mService->addResource(client1Info, videoAudioTestClient, videoAudioResources);
1063
1064 // Fail to reclaim an image codec resource
1065 std::vector<MediaResourceParcel> reclaimResources;
1066 reclaimResources.push_back(createNonSecureImageCodecResource());
1067 ClientInfoParcel highPriorityClient{.pid = static_cast<int32_t>(kHighPriorityPid),
1068 .uid = static_cast<int32_t>(kTestUid2),
1069 .id = kHighPriorityClientId,
1070 .name = "none"};
1071 CHECK_STATUS_FALSE(mService->reclaimResource(highPriorityClient, reclaimResources, &result));
1072
1073 // Now add an image codec resource
1074 std::vector<MediaResourceParcel> imageResources;
1075 imageResources.push_back(createNonSecureImageCodecResource());
1076 ClientInfoParcel client2Info{.pid = static_cast<int32_t>(kLowPriorityPid),
1077 .uid = static_cast<int32_t>(kTestUid2),
1078 .id = getId(imageTestClient),
1079 .name = "none"};
1080 mService->addResource(client2Info, imageTestClient, imageResources);
1081
1082 // Verify that the newly-created image codec resource can be reclaimed
1083 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, reclaimResources, &result));
1084
1085 // Verify that the video and audio resources are untouched
1086 EXPECT_FALSE(toTestClient(mTestClient1)->checkIfReclaimedAndReset());
1087 // But the image resource was reclaimed
1088 EXPECT_TRUE(toTestClient(mTestClient2)->checkIfReclaimedAndReset());
1089 }
1090
testReclaimResources_whenPartialResourceMatch_reclaims()1091 void testReclaimResources_whenPartialResourceMatch_reclaims() {
1092 const int onlyUid = kTestUid1;
1093 const auto onlyClient = createTestClient(kLowPriorityPid, onlyUid);
1094
1095 std::vector<MediaResourceParcel> ownedResources;
1096 ownedResources.push_back(createNonSecureVideoCodecResource());
1097 ownedResources.push_back(createGraphicMemoryResource(100));
1098 ClientInfoParcel onlyClientInfo{.pid = static_cast<int32_t>(kLowPriorityPid),
1099 .uid = static_cast<int32_t>(onlyUid),
1100 .id = getId(onlyClient),
1101 .name = "none"};
1102 mService->addResource(onlyClientInfo, onlyClient, ownedResources);
1103
1104 // Reclaim an image codec instead of the video codec that is owned, but also reclaim
1105 // graphics memory, which will trigger the reclaim.
1106 std::vector<MediaResourceParcel> reclaimResources;
1107 reclaimResources.push_back(createNonSecureImageCodecResource());
1108 reclaimResources.push_back(createGraphicMemoryResource(100));
1109 ClientInfoParcel highPriorityClient{.pid = static_cast<int32_t>(kHighPriorityPid),
1110 .uid = static_cast<int32_t>(kTestUid2),
1111 .id = kHighPriorityClientId,
1112 .name = "none"};
1113 CHECK_STATUS_TRUE(mService->reclaimResource(highPriorityClient, reclaimResources, &result));
1114
1115 // Verify that the video codec resources (including the needed graphic memory) is reclaimed
1116 EXPECT_TRUE(toTestClient(onlyClient)->checkIfReclaimedAndReset());
1117 }
1118
testReclaimResourcesFromMarkedClients_removesBiggestMarkedClientForSomeResources()1119 void testReclaimResourcesFromMarkedClients_removesBiggestMarkedClientForSomeResources() {
1120 // this test only uses one pid and one uid
1121 const int onlyPid = kTestPid1;
1122 const int onlyUid = kTestUid1;
1123
1124 // secure video codec
1125 const auto smallSecureVideoMarkedClient = createTestClient(onlyPid, onlyUid);
1126 const auto largeSecureVideoMarkedClient = createTestClient(onlyPid, onlyUid);
1127 const auto largestSecureVideoActiveClient = createTestClient(onlyPid, onlyUid);
1128 ClientInfoParcel clientA{.pid = static_cast<int32_t>(onlyPid),
1129 .uid = static_cast<int32_t>(onlyUid),
1130 .id = getId(smallSecureVideoMarkedClient),
1131 .name = "none"};
1132 ClientInfoParcel clientB{.pid = static_cast<int32_t>(onlyPid),
1133 .uid = static_cast<int32_t>(onlyUid),
1134 .id = getId(largeSecureVideoMarkedClient),
1135 .name = "none"};
1136 ClientInfoParcel clientC{.pid = static_cast<int32_t>(onlyPid),
1137 .uid = static_cast<int32_t>(onlyUid),
1138 .id = getId(largestSecureVideoActiveClient),
1139 .name = "none"};
1140 {
1141 std::vector<MediaResourceParcel> resources;
1142 resources.push_back(createSecureVideoCodecResource(1));
1143 mService->addResource(clientA, smallSecureVideoMarkedClient, resources);
1144 resources.clear();
1145 resources.push_back(createSecureVideoCodecResource(2));
1146 mService->addResource(clientB, largeSecureVideoMarkedClient, resources);
1147 resources.clear();
1148 resources.push_back(createSecureVideoCodecResource(3));
1149 mService->addResource(clientC, largestSecureVideoActiveClient, resources);
1150 }
1151 mService->markClientForPendingRemoval(clientA);
1152 mService->markClientForPendingRemoval(clientB);
1153 // don't mark the largest client
1154
1155 // non-secure video codec
1156 const auto smallNonSecureVideoMarkedClient = createTestClient(onlyPid, onlyUid);
1157 const auto largeNonSecureVideoMarkedClient = createTestClient(onlyPid, onlyUid);
1158 const auto largestNonSecureVideoActiveClient = createTestClient(onlyPid, onlyUid);
1159 ClientInfoParcel clientD{.pid = static_cast<int32_t>(onlyPid),
1160 .uid = static_cast<int32_t>(onlyUid),
1161 .id = getId(smallNonSecureVideoMarkedClient),
1162 .name = "none"};
1163 ClientInfoParcel clientE{.pid = static_cast<int32_t>(onlyPid),
1164 .uid = static_cast<int32_t>(onlyUid),
1165 .id = getId(largeNonSecureVideoMarkedClient),
1166 .name = "none"};
1167 ClientInfoParcel clientF{.pid = static_cast<int32_t>(onlyPid),
1168 .uid = static_cast<int32_t>(onlyUid),
1169 .id = getId(largestNonSecureVideoActiveClient),
1170 .name = "none"};
1171 {
1172 std::vector<MediaResourceParcel> resources;
1173 resources.push_back(createNonSecureVideoCodecResource(1));
1174 mService->addResource(clientD, smallNonSecureVideoMarkedClient, resources);
1175 resources.clear();
1176 resources.push_back(createNonSecureVideoCodecResource(2));
1177 mService->addResource(clientE, largeNonSecureVideoMarkedClient, resources);
1178 resources.clear();
1179 resources.push_back(createNonSecureVideoCodecResource(3));
1180 mService->addResource(clientF, largestNonSecureVideoActiveClient, resources);
1181 }
1182 mService->markClientForPendingRemoval(clientD);
1183 mService->markClientForPendingRemoval(clientE);
1184 // don't mark the largest client
1185
1186 // secure audio codec
1187 const auto smallSecureAudioMarkedClient = createTestClient(onlyPid, onlyUid);
1188 const auto largeSecureAudioMarkedClient = createTestClient(onlyPid, onlyUid);
1189 const auto largestSecureAudioActiveClient = createTestClient(onlyPid, onlyUid);
1190 ClientInfoParcel clientG{.pid = static_cast<int32_t>(onlyPid),
1191 .uid = static_cast<int32_t>(onlyUid),
1192 .id = getId(smallSecureAudioMarkedClient),
1193 .name = "none"};
1194 ClientInfoParcel clientH{.pid = static_cast<int32_t>(onlyPid),
1195 .uid = static_cast<int32_t>(onlyUid),
1196 .id = getId(largeSecureAudioMarkedClient),
1197 .name = "none"};
1198 ClientInfoParcel clientI{.pid = static_cast<int32_t>(onlyPid),
1199 .uid = static_cast<int32_t>(onlyUid),
1200 .id = getId(largestSecureVideoActiveClient),
1201 .name = "none"};
1202 {
1203 std::vector<MediaResourceParcel> resources;
1204 resources.push_back(createSecureAudioCodecResource(1));
1205 mService->addResource(clientG, smallSecureAudioMarkedClient, resources);
1206 resources.clear();
1207 resources.push_back(createSecureAudioCodecResource(2));
1208 mService->addResource(clientH, largeSecureAudioMarkedClient, resources);
1209 resources.clear();
1210 resources.push_back(createSecureAudioCodecResource(3));
1211 mService->addResource(clientI, largestSecureVideoActiveClient, resources);
1212 }
1213 mService->markClientForPendingRemoval(clientG);
1214 mService->markClientForPendingRemoval(clientH);
1215 // don't mark the largest client
1216
1217 // non-secure audio codec
1218 const auto smallNonSecureAudioMarkedClient = createTestClient(onlyPid, onlyUid);
1219 const auto largeNonSecureAudioMarkedClient = createTestClient(onlyPid, onlyUid);
1220 const auto largestNonSecureAudioActiveClient = createTestClient(onlyPid, onlyUid);
1221 ClientInfoParcel clientJ{.pid = static_cast<int32_t>(onlyPid),
1222 .uid = static_cast<int32_t>(onlyUid),
1223 .id = getId(smallNonSecureAudioMarkedClient),
1224 .name = "none"};
1225 ClientInfoParcel clientK{.pid = static_cast<int32_t>(onlyPid),
1226 .uid = static_cast<int32_t>(onlyUid),
1227 .id = getId(largeNonSecureAudioMarkedClient),
1228 .name = "none"};
1229 ClientInfoParcel clientL{.pid = static_cast<int32_t>(onlyPid),
1230 .uid = static_cast<int32_t>(onlyUid),
1231 .id = getId(largestNonSecureAudioActiveClient),
1232 .name = "none"};
1233 {
1234 std::vector<MediaResourceParcel> resources;
1235 resources.push_back(createNonSecureAudioCodecResource(1));
1236 mService->addResource(clientJ, smallNonSecureAudioMarkedClient, resources);
1237 resources.clear();
1238 resources.push_back(createNonSecureAudioCodecResource(2));
1239 mService->addResource(clientK, largeNonSecureAudioMarkedClient, resources);
1240 resources.clear();
1241 resources.push_back(createNonSecureAudioCodecResource(3));
1242 mService->addResource(clientL, largestNonSecureAudioActiveClient, resources);
1243 }
1244 mService->markClientForPendingRemoval(clientJ);
1245 mService->markClientForPendingRemoval(clientK);
1246 // don't mark the largest client
1247
1248 // secure image codec
1249 const auto smallSecureImageMarkedClient = createTestClient(onlyPid, onlyUid);
1250 const auto largeSecureImageMarkedClient = createTestClient(onlyPid, onlyUid);
1251 const auto largestSecureImageActiveClient = createTestClient(onlyPid, onlyUid);
1252 ClientInfoParcel clientM{.pid = static_cast<int32_t>(onlyPid),
1253 .uid = static_cast<int32_t>(onlyUid),
1254 .id = getId(smallSecureImageMarkedClient),
1255 .name = "none"};
1256 ClientInfoParcel clientN{.pid = static_cast<int32_t>(onlyPid),
1257 .uid = static_cast<int32_t>(onlyUid),
1258 .id = getId(largeSecureImageMarkedClient),
1259 .name = "none"};
1260 ClientInfoParcel clientO{.pid = static_cast<int32_t>(onlyPid),
1261 .uid = static_cast<int32_t>(onlyUid),
1262 .id = getId(largestSecureImageActiveClient),
1263 .name = "none"};
1264 {
1265 std::vector<MediaResourceParcel> resources;
1266 resources.push_back(createSecureImageCodecResource(1));
1267 mService->addResource(clientM, smallSecureImageMarkedClient, resources);
1268 resources.clear();
1269 resources.push_back(createSecureImageCodecResource(2));
1270 mService->addResource(clientN, largeSecureImageMarkedClient, resources);
1271 resources.clear();
1272 resources.push_back(createSecureImageCodecResource(3));
1273 mService->addResource(clientO, largestSecureImageActiveClient, resources);
1274 }
1275 mService->markClientForPendingRemoval(clientM);
1276 mService->markClientForPendingRemoval(clientN);
1277 // don't mark the largest client
1278
1279 // non-secure image codec
1280 const auto smallNonSecureImageMarkedClient = createTestClient(onlyPid, onlyUid);
1281 const auto largeNonSecureImageMarkedClient = createTestClient(onlyPid, onlyUid);
1282 const auto largestNonSecureImageActiveClient = createTestClient(onlyPid, onlyUid);
1283 ClientInfoParcel clientP{.pid = static_cast<int32_t>(onlyPid),
1284 .uid = static_cast<int32_t>(onlyUid),
1285 .id = getId(smallNonSecureImageMarkedClient),
1286 .name = "none"};
1287 ClientInfoParcel clientQ{.pid = static_cast<int32_t>(onlyPid),
1288 .uid = static_cast<int32_t>(onlyUid),
1289 .id = getId(largeNonSecureImageMarkedClient),
1290 .name = "none"};
1291 ClientInfoParcel clientR{.pid = static_cast<int32_t>(onlyPid),
1292 .uid = static_cast<int32_t>(onlyUid),
1293 .id = getId(largestNonSecureImageActiveClient),
1294 .name = "none"};
1295 {
1296 std::vector<MediaResourceParcel> resources;
1297 resources.push_back(createNonSecureImageCodecResource(1));
1298 mService->addResource(clientP, smallNonSecureImageMarkedClient, resources);
1299 resources.clear();
1300 resources.push_back(createNonSecureImageCodecResource(2));
1301 mService->addResource(clientQ, largeNonSecureImageMarkedClient, resources);
1302 resources.clear();
1303 resources.push_back(createNonSecureImageCodecResource(3));
1304 mService->addResource(clientR, largestNonSecureImageActiveClient, resources);
1305 }
1306 mService->markClientForPendingRemoval(clientP);
1307 mService->markClientForPendingRemoval(clientQ);
1308 // don't mark the largest client
1309
1310 // graphic memory
1311 const auto smallGraphicMemoryMarkedClient = createTestClient(onlyPid, onlyUid);
1312 const auto largeGraphicMemoryMarkedClient = createTestClient(onlyPid, onlyUid);
1313 const auto largestGraphicMemoryActiveClient = createTestClient(onlyPid, onlyUid);
1314 ClientInfoParcel clientS{.pid = static_cast<int32_t>(onlyPid),
1315 .uid = static_cast<int32_t>(onlyUid),
1316 .id = getId(smallGraphicMemoryMarkedClient),
1317 .name = "none"};
1318 ClientInfoParcel clientT{.pid = static_cast<int32_t>(onlyPid),
1319 .uid = static_cast<int32_t>(onlyUid),
1320 .id = getId(largeGraphicMemoryMarkedClient),
1321 .name = "none"};
1322 ClientInfoParcel clientU{.pid = static_cast<int32_t>(onlyPid),
1323 .uid = static_cast<int32_t>(onlyUid),
1324 .id = getId(largestGraphicMemoryActiveClient),
1325 .name = "none"};
1326 {
1327 std::vector<MediaResourceParcel> resources;
1328 resources.push_back(createGraphicMemoryResource(100));
1329 mService->addResource(clientS, smallGraphicMemoryMarkedClient, resources);
1330 resources.clear();
1331 resources.push_back(createGraphicMemoryResource(200));
1332 mService->addResource(clientT, largeGraphicMemoryMarkedClient, resources);
1333 resources.clear();
1334 resources.push_back(createGraphicMemoryResource(300));
1335 mService->addResource(clientU, largestGraphicMemoryActiveClient, resources);
1336 }
1337 mService->markClientForPendingRemoval(clientS);
1338 mService->markClientForPendingRemoval(clientT);
1339 // don't mark the largest client
1340
1341 // DRM session
1342 const auto smallDrmSessionMarkedClient = createTestClient(onlyPid, onlyUid);
1343 const auto largeDrmSessionMarkedClient = createTestClient(onlyPid, onlyUid);
1344 const auto largestDrmSessionActiveClient = createTestClient(onlyPid, onlyUid);
1345 ClientInfoParcel clientV{.pid = static_cast<int32_t>(onlyPid),
1346 .uid = static_cast<int32_t>(onlyUid),
1347 .id = getId(smallDrmSessionMarkedClient),
1348 .name = "none"};
1349 ClientInfoParcel clientW{.pid = static_cast<int32_t>(onlyPid),
1350 .uid = static_cast<int32_t>(onlyUid),
1351 .id = getId(largeDrmSessionMarkedClient),
1352 .name = "none"};
1353 ClientInfoParcel clientX{.pid = static_cast<int32_t>(onlyPid),
1354 .uid = static_cast<int32_t>(onlyUid),
1355 .id = getId(largestDrmSessionActiveClient),
1356 .name = "none"};
1357 {
1358 std::vector<MediaResourceParcel> resources;
1359 resources.push_back(createDrmSessionResource(1));
1360 mService->addResource(clientV, smallDrmSessionMarkedClient, resources);
1361 resources.clear();
1362 resources.push_back(createDrmSessionResource(2));
1363 mService->addResource(clientW, largeDrmSessionMarkedClient, resources);
1364 resources.clear();
1365 resources.push_back(createDrmSessionResource(3));
1366 mService->addResource(clientX, largestDrmSessionActiveClient, resources);
1367 }
1368 mService->markClientForPendingRemoval(clientV);
1369 mService->markClientForPendingRemoval(clientW);
1370 // don't mark the largest client
1371
1372 // battery
1373 const auto batteryMarkedClient = createTestClient(onlyPid, onlyUid);
1374 ClientInfoParcel clientY{.pid = static_cast<int32_t>(onlyPid),
1375 .uid = static_cast<int32_t>(onlyUid),
1376 .id = getId(batteryMarkedClient),
1377 .name = "none"};
1378 {
1379 std::vector<MediaResourceParcel> resources;
1380 resources.push_back(createBatteryResource());
1381 mService->addResource(clientY, batteryMarkedClient, resources);
1382 }
1383 mService->markClientForPendingRemoval(clientY);
1384
1385 // CPU boost
1386 const auto cpuBoostMarkedClient = createTestClient(onlyPid, onlyUid);
1387 ClientInfoParcel clientZ{.pid = static_cast<int32_t>(onlyPid),
1388 .uid = static_cast<int32_t>(onlyUid),
1389 .id = getId(cpuBoostMarkedClient),
1390 .name = "none"};
1391 {
1392 std::vector<MediaResourceParcel> resources;
1393 resources.push_back(createCpuBoostResource());
1394 mService->addResource(clientZ, cpuBoostMarkedClient, resources);
1395 }
1396 mService->markClientForPendingRemoval(clientZ);
1397
1398 // now we expect that we only reclaim resources from the biggest marked client
1399 EXPECT_TRUE(mService->reclaimResourcesFromClientsPendingRemoval(onlyPid).isOk());
1400 // secure video codec
1401 EXPECT_FALSE(toTestClient(smallSecureVideoMarkedClient)->checkIfReclaimedAndReset());
1402 EXPECT_TRUE(toTestClient(largeSecureVideoMarkedClient)->checkIfReclaimedAndReset());
1403 EXPECT_FALSE(toTestClient(largestSecureVideoActiveClient)->checkIfReclaimedAndReset());
1404 // non-secure video codec
1405 EXPECT_FALSE(toTestClient(smallNonSecureVideoMarkedClient)->checkIfReclaimedAndReset());
1406 EXPECT_TRUE(toTestClient(largeNonSecureVideoMarkedClient)->checkIfReclaimedAndReset());
1407 EXPECT_FALSE(toTestClient(largestNonSecureVideoActiveClient)->checkIfReclaimedAndReset());
1408 // secure audio codec
1409 EXPECT_FALSE(toTestClient(smallSecureAudioMarkedClient)->checkIfReclaimedAndReset());
1410 EXPECT_TRUE(toTestClient(largeSecureAudioMarkedClient)->checkIfReclaimedAndReset());
1411 EXPECT_FALSE(toTestClient(largestSecureAudioActiveClient)->checkIfReclaimedAndReset());
1412 // non-secure audio codec
1413 EXPECT_FALSE(toTestClient(smallNonSecureAudioMarkedClient)->checkIfReclaimedAndReset());
1414 EXPECT_TRUE(toTestClient(largeNonSecureAudioMarkedClient)->checkIfReclaimedAndReset());
1415 EXPECT_FALSE(toTestClient(largestNonSecureAudioActiveClient)->checkIfReclaimedAndReset());
1416 // secure image codec
1417 EXPECT_FALSE(toTestClient(smallSecureImageMarkedClient)->checkIfReclaimedAndReset());
1418 EXPECT_TRUE(toTestClient(largeSecureImageMarkedClient)->checkIfReclaimedAndReset());
1419 EXPECT_FALSE(toTestClient(largestSecureImageActiveClient)->checkIfReclaimedAndReset());
1420 // non-secure image codec
1421 EXPECT_FALSE(toTestClient(smallNonSecureImageMarkedClient)->checkIfReclaimedAndReset());
1422 EXPECT_TRUE(toTestClient(largeNonSecureImageMarkedClient)->checkIfReclaimedAndReset());
1423 EXPECT_FALSE(toTestClient(largestNonSecureImageActiveClient)->checkIfReclaimedAndReset());
1424 // graphic memory
1425 EXPECT_FALSE(toTestClient(smallGraphicMemoryMarkedClient)->checkIfReclaimedAndReset());
1426 EXPECT_TRUE(toTestClient(largeGraphicMemoryMarkedClient)->checkIfReclaimedAndReset());
1427 EXPECT_FALSE(toTestClient(largestGraphicMemoryActiveClient)->checkIfReclaimedAndReset());
1428 // DRM session
1429 EXPECT_FALSE(toTestClient(smallDrmSessionMarkedClient)->checkIfReclaimedAndReset());
1430 EXPECT_TRUE(toTestClient(largeDrmSessionMarkedClient)->checkIfReclaimedAndReset());
1431 EXPECT_FALSE(toTestClient(largestDrmSessionActiveClient)->checkIfReclaimedAndReset());
1432 // battery is not expected to be reclaimed when marked as pending removal
1433 EXPECT_FALSE(toTestClient(batteryMarkedClient)->checkIfReclaimedAndReset());
1434 // CPU boost is not expected to be reclaimed when marked as pending removal
1435 EXPECT_FALSE(toTestClient(cpuBoostMarkedClient)->checkIfReclaimedAndReset());
1436 }
1437
initClientConfigParcel(bool encoder,bool hw,int32_t width,int32_t height,int64_t id,const ClientInfoParcel & clientInfo,ClientConfigParcel & clientConfig)1438 inline void initClientConfigParcel(bool encoder, bool hw,
1439 int32_t width, int32_t height,
1440 int64_t id,
1441 const ClientInfoParcel& clientInfo,
1442 ClientConfigParcel& clientConfig) {
1443 clientConfig.codecType = hw? MediaResource::SubType::kHwVideoCodec :
1444 MediaResource::SubType::kSwVideoCodec;
1445 clientConfig.isEncoder = encoder;
1446 clientConfig.width = width;
1447 clientConfig.height = height;
1448 clientConfig.timeStamp = systemTime(SYSTEM_TIME_MONOTONIC) / 1000LL;
1449 clientConfig.id = id;
1450 clientConfig.clientInfo = clientInfo;
1451 }
1452
testConcurrentCodecs()1453 void testConcurrentCodecs() {
1454 std::shared_ptr<IResourceManagerClient> testClient4 =
1455 createTestClient(kTestPid1, kTestUid1);
1456 ClientInfoParcel client1Info{.pid = static_cast<int32_t>(kTestPid1),
1457 .uid = static_cast<int32_t>(kTestUid1),
1458 .id = getId(mTestClient1),
1459 .name = "none"};
1460 ClientInfoParcel client2Info{.pid = static_cast<int32_t>(kTestPid2),
1461 .uid = static_cast<int32_t>(kTestUid2),
1462 .id = getId(mTestClient2),
1463 .name = "none"};
1464 ClientInfoParcel client3Info{.pid = static_cast<int32_t>(kTestPid2),
1465 .uid = static_cast<int32_t>(kTestUid2),
1466 .id = getId(mTestClient3),
1467 .name = "none"};
1468 ClientInfoParcel client4Info{.pid = static_cast<int32_t>(kTestPid1),
1469 .uid = static_cast<int32_t>(kTestUid1),
1470 .id = getId(testClient4),
1471 .name = "none"};
1472 ClientConfigParcel client1Config;
1473 ClientConfigParcel client2Config;
1474 ClientConfigParcel client3Config;
1475 ClientConfigParcel client4Config;
1476
1477 // HW Video Encoder @ 1080P.
1478 initClientConfigParcel(true, true, 1920, 1080, 11111111,
1479 client1Info, client1Config);
1480 // HW Video Decoder @ 4K.
1481 initClientConfigParcel(true, true, 2160, 3840, 22222222,
1482 client2Info, client2Config);
1483 // SW Video Encoder @ 1080P.
1484 initClientConfigParcel(true, true, 1920, 1080, 33333333,
1485 client3Info, client3Config);
1486 // SW Video Decoder @ 4K.
1487 initClientConfigParcel(true, true, 2160, 3840, 44444444,
1488 client4Info, client4Config);
1489
1490 // Start client1 at 1080P.
1491 mService->notifyClientStarted(client1Config);
1492 long peakPixelCountP1 = mService->getPeakConcurrentPixelCount(kTestPid1);
1493 long currentPixelCountP1 = mService->getCurrentConcurrentPixelCount(kTestPid1);
1494 EXPECT_TRUE(peakPixelCountP1 = client1Config.width * client1Config.height);
1495 EXPECT_TRUE(currentPixelCountP1 = client1Config.width * client1Config.height);
1496
1497 // Stop client1.
1498 mService->notifyClientStopped(client1Config);
1499 peakPixelCountP1 = mService->getPeakConcurrentPixelCount(kTestPid1);
1500 currentPixelCountP1 = mService->getCurrentConcurrentPixelCount(kTestPid1);
1501 EXPECT_TRUE(peakPixelCountP1 == client1Config.width * client1Config.height);
1502 EXPECT_TRUE(currentPixelCountP1 == 0);
1503
1504 // Start client1 at 1080P.
1505 mService->notifyClientStarted(client1Config);
1506 // Start client2 at 4K.
1507 mService->notifyClientStarted(client2Config);
1508
1509 // Verify the Peak and Current Concurrent pixel count for both the process
1510 // (kTestPid1, kTestPid2)
1511 peakPixelCountP1 = mService->getPeakConcurrentPixelCount(kTestPid1);
1512 currentPixelCountP1 = mService->getCurrentConcurrentPixelCount(kTestPid1);
1513 long peakPixelCountP2 = mService->getPeakConcurrentPixelCount(kTestPid2);
1514 long currentPixelCountP2 = mService->getCurrentConcurrentPixelCount(kTestPid2);
1515 EXPECT_TRUE(peakPixelCountP1 == client1Config.width * client1Config.height);
1516 EXPECT_TRUE(currentPixelCountP1 == client1Config.width * client1Config.height);
1517 EXPECT_TRUE(peakPixelCountP2 == client2Config.width * client2Config.height);
1518 EXPECT_TRUE(currentPixelCountP2 == client2Config.width * client2Config.height);
1519
1520 // Start client3 at 1080P.
1521 mService->notifyClientStarted(client3Config);
1522 // Start client4 at 4K.
1523 mService->notifyClientStarted(client4Config);
1524
1525 // Verify the Peak and Current Concurrent pixel count for both the process
1526 // (kTestPid1, kTestPid2)
1527 peakPixelCountP1 = mService->getPeakConcurrentPixelCount(kTestPid1);
1528 currentPixelCountP1 = mService->getCurrentConcurrentPixelCount(kTestPid1);
1529 peakPixelCountP2 = mService->getPeakConcurrentPixelCount(kTestPid2);
1530 currentPixelCountP2 = mService->getCurrentConcurrentPixelCount(kTestPid2);
1531 EXPECT_TRUE(peakPixelCountP1 ==
1532 (client1Config.width * client1Config.height +
1533 client4Config.width * client4Config.height));
1534 EXPECT_TRUE(currentPixelCountP1 ==
1535 (client1Config.width * client1Config.height +
1536 client4Config.width * client4Config.height));
1537 EXPECT_TRUE(peakPixelCountP2 ==
1538 (client2Config.width * client2Config.height +
1539 client3Config.width * client3Config.height));
1540 EXPECT_TRUE(currentPixelCountP2 ==
1541 (client2Config.width * client2Config.height +
1542 client3Config.width * client3Config.height));
1543
1544 // Stop client4
1545 mService->notifyClientStopped(client4Config);
1546 currentPixelCountP1 = mService->getCurrentConcurrentPixelCount(kTestPid1);
1547 EXPECT_TRUE(currentPixelCountP1 == client1Config.width * client1Config.height);
1548
1549 // Stop client1
1550 mService->notifyClientStopped(client1Config);
1551
1552 // Stop client2
1553 mService->notifyClientStopped(client2Config);
1554 currentPixelCountP2 = mService->getCurrentConcurrentPixelCount(kTestPid2);
1555 EXPECT_TRUE(currentPixelCountP2 == client3Config.width * client3Config.height);
1556 // Stop client3
1557 mService->notifyClientStopped(client3Config);
1558
1559 // Verify the Peak and Current Concurrent pixel count for both the process
1560 // (kTestPid1, kTestPid2)
1561 peakPixelCountP1 = mService->getPeakConcurrentPixelCount(kTestPid1);
1562 currentPixelCountP1 = mService->getCurrentConcurrentPixelCount(kTestPid1);
1563 peakPixelCountP2 = mService->getPeakConcurrentPixelCount(kTestPid2);
1564 currentPixelCountP2 = mService->getCurrentConcurrentPixelCount(kTestPid2);
1565 EXPECT_TRUE(peakPixelCountP1 ==
1566 (client1Config.width * client1Config.height +
1567 client4Config.width * client4Config.height));
1568 EXPECT_TRUE(currentPixelCountP1 == 0);
1569 EXPECT_TRUE(peakPixelCountP2 ==
1570 (client2Config.width * client2Config.height +
1571 client3Config.width * client3Config.height));
1572 EXPECT_TRUE(currentPixelCountP2 == 0);
1573 }
1574
addNonSecureVideoCodecResource(std::shared_ptr<IResourceManagerClient> & client,std::vector<ClientInfoParcel> & infos)1575 void addNonSecureVideoCodecResource(std::shared_ptr<IResourceManagerClient>& client,
1576 std::vector<ClientInfoParcel>& infos) {
1577 std::vector<MediaResourceParcel> resources;
1578 resources.push_back(createNonSecureVideoCodecResource(1));
1579
1580 TestClient* testClient = toTestClient(client);
1581 ClientInfoParcel clientInfo {.pid = static_cast<int32_t>(testClient->pid()),
1582 .uid = static_cast<int32_t>(testClient->uid()),
1583 .id = getId(client),
1584 .name = "none",
1585 .importance = testClient->clientImportance()};
1586 mService->addResource(clientInfo, client, resources);
1587 infos.push_back(clientInfo);
1588 }
1589
doReclaimResource(const ClientInfoParcel & clientInfo)1590 bool doReclaimResource(const ClientInfoParcel& clientInfo) {
1591 bool result = false;
1592 std::vector<MediaResourceParcel> reclaimResources;
1593 reclaimResources.push_back(createNonSecureVideoCodecResource(1));
1594 bool success = mService->reclaimResource(clientInfo, reclaimResources, &result).isOk();
1595 return success && result;
1596 }
1597
1598 // Verifies the resource reclaim policies
1599 // - this verifies the reclaim policies based on:
1600 // - process priority (oom score)
1601 // - client priority
testReclaimPolicies()1602 void testReclaimPolicies() {
1603 // Create 3 clients with codec importance high, mid and low for a low
1604 // priority pid.
1605 std::vector<std::shared_ptr<IResourceManagerClient>> lowPriPidClients;
1606 lowPriPidClients.push_back(
1607 createTestClient(kLowPriorityPid, kTestUid1, kHighestCodecImportance));
1608 lowPriPidClients.push_back(
1609 createTestClient(kLowPriorityPid, kTestUid1, kMidCodecImportance));
1610 lowPriPidClients.push_back(
1611 createTestClient(kLowPriorityPid, kTestUid1, kLowestCodecImportance));
1612
1613 // Create 3 clients with codec importance high, mid and low for a high
1614 // priority pid.
1615 std::vector<std::shared_ptr<IResourceManagerClient>> highPriPidClients;
1616 highPriPidClients.push_back(
1617 createTestClient(kHighPriorityPid, kTestUid2, kHighestCodecImportance));
1618 highPriPidClients.push_back(
1619 createTestClient(kHighPriorityPid, kTestUid2, kMidCodecImportance));
1620 highPriPidClients.push_back(
1621 createTestClient(kHighPriorityPid, kTestUid2, kLowestCodecImportance));
1622
1623 // Add non secure video codec resources for all the 3 clients of low priority pid.
1624 std::vector<ClientInfoParcel> lowPriPidClientInfos;
1625 for (auto& client : lowPriPidClients) {
1626 addNonSecureVideoCodecResource(client, lowPriPidClientInfos);
1627 }
1628 // Add non secure video codec resources for all the 3 clients of high priority pid.
1629 std::vector<ClientInfoParcel> highPriPidClientInfos;
1630 for (auto& client : highPriPidClients) {
1631 addNonSecureVideoCodecResource(client, highPriPidClientInfos);
1632 }
1633
1634 // 1. Set reclaim policy as "Process Priority".
1635 // - A process should be reclaiming from:
1636 // - a lower priority process if there is any
1637 // - else fail.
1638 mService->setReclaimPolicy(true /*process priority*/, false /*codec importance*/);
1639
1640 // 1.A:
1641 // - high priority process should be able to reclaim successfully.
1642 // - A process should be reclaiming from the low priority process.
1643 EXPECT_TRUE(doReclaimResource(highPriPidClientInfos[0]));
1644 // Verify that the high priority pid's clients are untouched.
1645 bool success = true;
1646 for (auto& client : highPriPidClients) {
1647 if (toTestClient(client)->checkIfReclaimedAndReset()) {
1648 success = false;
1649 break;
1650 }
1651 }
1652 EXPECT_TRUE(success);
1653 // Verify that the one of the client from the low priority pid has been reclaimed.
1654 success = false;
1655 for (auto& client : lowPriPidClients) {
1656 if (toTestClient(client)->checkIfReclaimedAndReset()) {
1657 success = true;
1658 break;
1659 }
1660 }
1661 EXPECT_TRUE(success);
1662
1663 // 1.B:
1664 // - low priority process should fail to reclaim.
1665 EXPECT_FALSE(doReclaimResource(lowPriPidClientInfos[0]));
1666
1667 // 2. Set reclaim policy as "Client Importance".
1668 // - A process should be reclaiming from:
1669 // - a lower priority client from the same process if any
1670 // - else fail.
1671 mService->setReclaimPolicy(false /*process priority*/, true /*codec importance*/);
1672
1673 // 2.A:
1674 // - high priority process should be able to reclaim successfully.
1675 // - Process should be reclaiming from a lower priority client from the
1676 // same process.
1677 EXPECT_TRUE(doReclaimResource(highPriPidClientInfos[0]));
1678 // Verify that the low priority pid's clients are untouched.
1679 success = true;
1680 for (auto& client : lowPriPidClients) {
1681 if (toTestClient(client)->checkIfReclaimedAndReset()) {
1682 success = false;
1683 break;
1684 }
1685 }
1686 EXPECT_TRUE(success);
1687 // Verify that the one of the low priority client from the high priority
1688 // pid has been reclaimed.
1689 success = false;
1690 for (auto& client : highPriPidClients) {
1691 if (toTestClient(client)->checkIfReclaimedAndReset()) {
1692 success = true;
1693 break;
1694 }
1695 }
1696 EXPECT_TRUE(success);
1697
1698 // 2.B:
1699 // - high priority process should be able to reclaim successfully.
1700 // - Process should be reclaiming from a lower priority client from the
1701 // same process.
1702 EXPECT_TRUE(doReclaimResource(lowPriPidClientInfos[0]));
1703 // Verify that the high priority pid's clients are untouched.
1704 success = true;
1705 for (auto& client : highPriPidClients) {
1706 if (toTestClient(client)->checkIfReclaimedAndReset()) {
1707 success = false;
1708 break;
1709 }
1710 }
1711 EXPECT_TRUE(success);
1712 // Verify that the one of the low priority client from the low priority
1713 // pid has been reclaimed.
1714 success = false;
1715 for (auto& client : lowPriPidClients) {
1716 if (toTestClient(client)->checkIfReclaimedAndReset()) {
1717 success = true;
1718 break;
1719 }
1720 }
1721 EXPECT_TRUE(success);
1722
1723 // 2.C:
1724 // - lowest priority client from high priority process should fail to reclaim.
1725 EXPECT_FALSE(doReclaimResource(highPriPidClientInfos[2]));
1726
1727 // 2.D:
1728 // - lowest priority client from low priority process should fail to reclaim.
1729 EXPECT_FALSE(doReclaimResource(lowPriPidClientInfos[2]));
1730
1731 // 3. Set reclaim policy as "Process Priority and Client Importance".
1732 // - A process should be reclaiming from:
1733 // - a lower priority process if there is any
1734 // - else a lower priority client from the same process if any
1735 // - else fail.
1736 mService->setReclaimPolicy(true /*process priority*/, true /*codec importance*/);
1737
1738 // Remove all clients from the low priority process so that we have
1739 // only one process (with high priority) with all the resources.
1740 for (const auto& clientInfo : lowPriPidClientInfos) {
1741 mService->removeClient(clientInfo);
1742 }
1743 lowPriPidClientInfos.clear();
1744 lowPriPidClients.clear();
1745 // 3.A:
1746 // - high priority process should be able to reclaim successfully.
1747 EXPECT_TRUE(doReclaimResource(highPriPidClientInfos[0]));
1748 // Verify that the one of the client from the high priority pid has been reclaimed.
1749 success = false;
1750 for (auto& client : highPriPidClients) {
1751 if (toTestClient(client)->checkIfReclaimedAndReset()) {
1752 success = true;
1753 break;
1754 }
1755 }
1756 EXPECT_TRUE(success);
1757
1758 // 3.B, set the policy back to ReclaimPolicyProcessPriority
1759 mService->setReclaimPolicy(true /*process priority*/, false /*codec importance*/);
1760
1761 // Since there is only one process, the reclaim should fail.
1762 EXPECT_FALSE(doReclaimResource(highPriPidClientInfos[0]));
1763
1764 // 4. Set reclaim policy as "Process Priority and Client Importance".
1765 // - A process should be reclaiming from:
1766 // - from a lower priority process if there are any
1767 // - else from a lower priority client from the same process if there are any
1768 // - else fail.
1769 mService->setReclaimPolicy(true /*process priority*/, true /*codec importance*/);
1770
1771 // Remove all clients from the high priority process so that we can
1772 // start a new/fresh resource allocation.
1773 for (const auto& clientInfo : highPriPidClientInfos) {
1774 mService->removeClient(clientInfo);
1775 }
1776 highPriPidClientInfos.clear();
1777 highPriPidClients.clear();
1778
1779 // Create 3 clients with codec importance high for a low priority pid.
1780 lowPriPidClients.push_back(
1781 createTestClient(kLowPriorityPid, kTestUid1, kHighestCodecImportance));
1782 lowPriPidClients.push_back(
1783 createTestClient(kLowPriorityPid, kTestUid1, kHighestCodecImportance));
1784 lowPriPidClients.push_back(
1785 createTestClient(kLowPriorityPid, kTestUid1, kHighestCodecImportance));
1786
1787 // Create 3 clients with codec importance low for a high priority pid.
1788 highPriPidClients.push_back(
1789 createTestClient(kHighPriorityPid, kTestUid2, kLowestCodecImportance));
1790 highPriPidClients.push_back(
1791 createTestClient(kHighPriorityPid, kTestUid2, kLowestCodecImportance));
1792 highPriPidClients.push_back(
1793 createTestClient(kHighPriorityPid, kTestUid2, kLowestCodecImportance));
1794
1795 // Add non secure video codec resources for all the 3 clients of low priority pid.
1796 for (auto& client : lowPriPidClients) {
1797 addNonSecureVideoCodecResource(client, lowPriPidClientInfos);
1798 }
1799 // Add non secure video codec resources for all the 3 clients of high priority pid.
1800 for (auto& client : highPriPidClients) {
1801 addNonSecureVideoCodecResource(client, highPriPidClientInfos);
1802 }
1803
1804 // 4.A:
1805 // - high priority process should be able to reclaim successfully.
1806 EXPECT_TRUE(doReclaimResource(highPriPidClientInfos[0]));
1807 // Since all clients are of same priority with in high priority process,
1808 // none of the clients should be reclaimed.
1809 success = true;
1810 for (auto& client : highPriPidClients) {
1811 if (toTestClient(client)->checkIfReclaimedAndReset()) {
1812 success = false;
1813 break;
1814 }
1815 }
1816 EXPECT_TRUE(success);
1817 // Verify that the one of the client from the low priority pid has been reclaimed.
1818 success = false;
1819 for (auto& client : lowPriPidClients) {
1820 if (toTestClient(client)->checkIfReclaimedAndReset()) {
1821 success = true;
1822 break;
1823 }
1824 }
1825 EXPECT_TRUE(success);
1826
1827 // 4.B, set the policy back to ReclaimPolicyProcessPriority
1828 // If low priority process tries to reclaim, it should fail as there
1829 // aren't any lower priority clients or lower priority processes.
1830 EXPECT_FALSE(doReclaimResource(lowPriPidClientInfos[0]));
1831 }
1832 };
1833
1834 class ResourceManagerServiceNewTest : public ResourceManagerServiceTest {
1835 public:
ResourceManagerServiceNewTest(bool newRM=true)1836 ResourceManagerServiceNewTest(bool newRM = true) : ResourceManagerServiceTest(newRM) {}
1837 };
1838
TEST_F(ResourceManagerServiceTest,config)1839 TEST_F(ResourceManagerServiceTest, config) {
1840 testConfig();
1841 }
1842
TEST_F(ResourceManagerServiceTest,addResource)1843 TEST_F(ResourceManagerServiceTest, addResource) {
1844 addResource();
1845 }
1846
TEST_F(ResourceManagerServiceTest,combineResource)1847 TEST_F(ResourceManagerServiceTest, combineResource) {
1848 testCombineResource();
1849 }
1850
TEST_F(ResourceManagerServiceTest,combineResourceNegative)1851 TEST_F(ResourceManagerServiceTest, combineResourceNegative) {
1852 testCombineResourceWithNegativeValues();
1853 }
1854
TEST_F(ResourceManagerServiceTest,removeResource)1855 TEST_F(ResourceManagerServiceTest, removeResource) {
1856 testRemoveResource();
1857 }
1858
TEST_F(ResourceManagerServiceTest,removeClient)1859 TEST_F(ResourceManagerServiceTest, removeClient) {
1860 testRemoveClient();
1861 }
1862
TEST_F(ResourceManagerServiceTest,selfReclaimResource)1863 TEST_F(ResourceManagerServiceTest, selfReclaimResource) {
1864 testSelfReclaimResourceSecure();
1865 }
1866
TEST_F(ResourceManagerServiceTest,reclaimResource)1867 TEST_F(ResourceManagerServiceTest, reclaimResource) {
1868 testReclaimResourceSecure();
1869 testReclaimResourceNonSecure();
1870 }
1871
TEST_F(ResourceManagerServiceTest,getAllClients_l)1872 TEST_F(ResourceManagerServiceTest, getAllClients_l) {
1873 testGetAllClients();
1874 }
1875
TEST_F(ResourceManagerServiceTest,getLowestPriorityBiggestClient_l)1876 TEST_F(ResourceManagerServiceTest, getLowestPriorityBiggestClient_l) {
1877 testGetLowestPriorityBiggestClient();
1878 }
1879
TEST_F(ResourceManagerServiceTest,getLowestPriorityPid_l)1880 TEST_F(ResourceManagerServiceTest, getLowestPriorityPid_l) {
1881 testGetLowestPriorityPid();
1882 }
1883
TEST_F(ResourceManagerServiceTest,isCallingPriorityHigher_l)1884 TEST_F(ResourceManagerServiceTest, isCallingPriorityHigher_l) {
1885 testIsCallingPriorityHigher();
1886 }
1887
TEST_F(ResourceManagerServiceTest,batteryStats)1888 TEST_F(ResourceManagerServiceTest, batteryStats) {
1889 testBatteryStats();
1890 }
1891
TEST_F(ResourceManagerServiceTest,cpusetBoost)1892 TEST_F(ResourceManagerServiceTest, cpusetBoost) {
1893 testCpusetBoost();
1894 }
1895
TEST_F(ResourceManagerServiceTest,overridePid)1896 TEST_F(ResourceManagerServiceTest, overridePid) {
1897 testOverridePid();
1898 }
1899
TEST_F(ResourceManagerServiceTest,markClientForPendingRemoval)1900 TEST_F(ResourceManagerServiceTest, markClientForPendingRemoval) {
1901 testMarkClientForPendingRemoval();
1902 }
1903
TEST_F(ResourceManagerServiceTest,reclaimResources_withVideoCodec_reclaimsOnlyVideoCodec)1904 TEST_F(ResourceManagerServiceTest, reclaimResources_withVideoCodec_reclaimsOnlyVideoCodec) {
1905 testReclaimResources_withVideoCodec_reclaimsOnlyVideoCodec();
1906 }
1907
TEST_F(ResourceManagerServiceTest,reclaimResources_withAudioCodec_reclaimsOnlyAudioCodec)1908 TEST_F(ResourceManagerServiceTest, reclaimResources_withAudioCodec_reclaimsOnlyAudioCodec) {
1909 testReclaimResources_withAudioCodec_reclaimsOnlyAudioCodec();
1910 }
1911
TEST_F(ResourceManagerServiceTest,reclaimResources_withImageCodec_reclaimsOnlyImageCodec)1912 TEST_F(ResourceManagerServiceTest, reclaimResources_withImageCodec_reclaimsOnlyImageCodec) {
1913 testReclaimResources_withImageCodec_reclaimsOnlyImageCodec();
1914 }
1915
TEST_F(ResourceManagerServiceTest,reclaimResources_whenPartialResourceMatch_reclaims)1916 TEST_F(ResourceManagerServiceTest, reclaimResources_whenPartialResourceMatch_reclaims) {
1917 testReclaimResources_whenPartialResourceMatch_reclaims();
1918 }
1919
TEST_F(ResourceManagerServiceTest,reclaimResourcesFromMarkedClients_removesBiggestMarkedClientForSomeResources)1920 TEST_F(ResourceManagerServiceTest,
1921 reclaimResourcesFromMarkedClients_removesBiggestMarkedClientForSomeResources) {
1922 testReclaimResourcesFromMarkedClients_removesBiggestMarkedClientForSomeResources();
1923 }
1924
TEST_F(ResourceManagerServiceTest,concurrentCodecs)1925 TEST_F(ResourceManagerServiceTest, concurrentCodecs) {
1926 testConcurrentCodecs();
1927 }
1928
1929 /////// test cases for ResourceManagerServiceNew ////
TEST_F(ResourceManagerServiceNewTest,config)1930 TEST_F(ResourceManagerServiceNewTest, config) {
1931 testConfig();
1932 }
1933
TEST_F(ResourceManagerServiceNewTest,addResource)1934 TEST_F(ResourceManagerServiceNewTest, addResource) {
1935 addResource();
1936 }
1937
TEST_F(ResourceManagerServiceNewTest,combineResource)1938 TEST_F(ResourceManagerServiceNewTest, combineResource) {
1939 testCombineResource();
1940 }
1941
TEST_F(ResourceManagerServiceNewTest,combineResourceNegative)1942 TEST_F(ResourceManagerServiceNewTest, combineResourceNegative) {
1943 testCombineResourceWithNegativeValues();
1944 }
1945
TEST_F(ResourceManagerServiceNewTest,removeResource)1946 TEST_F(ResourceManagerServiceNewTest, removeResource) {
1947 testRemoveResource();
1948 }
1949
TEST_F(ResourceManagerServiceNewTest,removeClient)1950 TEST_F(ResourceManagerServiceNewTest, removeClient) {
1951 testRemoveClient();
1952 }
1953
TEST_F(ResourceManagerServiceNewTest,selfReclaimResource)1954 TEST_F(ResourceManagerServiceNewTest, selfReclaimResource) {
1955 testSelfReclaimResourceSecure();
1956 }
1957
TEST_F(ResourceManagerServiceNewTest,reclaimResource)1958 TEST_F(ResourceManagerServiceNewTest, reclaimResource) {
1959 testReclaimResourceSecure();
1960 testReclaimResourceNonSecure();
1961 }
1962
TEST_F(ResourceManagerServiceNewTest,getAllClients_l)1963 TEST_F(ResourceManagerServiceNewTest, getAllClients_l) {
1964 testGetAllClients();
1965 }
1966
TEST_F(ResourceManagerServiceNewTest,getLowestPriorityBiggestClient_l)1967 TEST_F(ResourceManagerServiceNewTest, getLowestPriorityBiggestClient_l) {
1968 testGetLowestPriorityBiggestClient();
1969 }
1970
TEST_F(ResourceManagerServiceNewTest,getLowestPriorityPid_l)1971 TEST_F(ResourceManagerServiceNewTest, getLowestPriorityPid_l) {
1972 testGetLowestPriorityPid();
1973 }
1974
TEST_F(ResourceManagerServiceNewTest,isCallingPriorityHigher_l)1975 TEST_F(ResourceManagerServiceNewTest, isCallingPriorityHigher_l) {
1976 testIsCallingPriorityHigher();
1977 }
1978
TEST_F(ResourceManagerServiceNewTest,batteryStats)1979 TEST_F(ResourceManagerServiceNewTest, batteryStats) {
1980 testBatteryStats();
1981 }
1982
TEST_F(ResourceManagerServiceNewTest,cpusetBoost)1983 TEST_F(ResourceManagerServiceNewTest, cpusetBoost) {
1984 testCpusetBoost();
1985 }
1986
TEST_F(ResourceManagerServiceNewTest,overridePid)1987 TEST_F(ResourceManagerServiceNewTest, overridePid) {
1988 testOverridePid();
1989 }
1990
TEST_F(ResourceManagerServiceNewTest,markClientForPendingRemoval)1991 TEST_F(ResourceManagerServiceNewTest, markClientForPendingRemoval) {
1992 testMarkClientForPendingRemoval();
1993 }
1994
TEST_F(ResourceManagerServiceNewTest,reclaimResources_withVideoCodec_reclaimsOnlyVideoCodec)1995 TEST_F(ResourceManagerServiceNewTest, reclaimResources_withVideoCodec_reclaimsOnlyVideoCodec) {
1996 testReclaimResources_withVideoCodec_reclaimsOnlyVideoCodec();
1997 }
1998
TEST_F(ResourceManagerServiceNewTest,reclaimResources_withAudioCodec_reclaimsOnlyAudioCodec)1999 TEST_F(ResourceManagerServiceNewTest, reclaimResources_withAudioCodec_reclaimsOnlyAudioCodec) {
2000 testReclaimResources_withAudioCodec_reclaimsOnlyAudioCodec();
2001 }
2002
TEST_F(ResourceManagerServiceNewTest,reclaimResources_withImageCodec_reclaimsOnlyImageCodec)2003 TEST_F(ResourceManagerServiceNewTest, reclaimResources_withImageCodec_reclaimsOnlyImageCodec) {
2004 testReclaimResources_withImageCodec_reclaimsOnlyImageCodec();
2005 }
2006
TEST_F(ResourceManagerServiceNewTest,reclaimResources_whenPartialResourceMatch_reclaims)2007 TEST_F(ResourceManagerServiceNewTest, reclaimResources_whenPartialResourceMatch_reclaims) {
2008 testReclaimResources_whenPartialResourceMatch_reclaims();
2009 }
2010
TEST_F(ResourceManagerServiceNewTest,reclaimResourcesFromMarkedClients_removesBiggestMarkedClientForSomeResources)2011 TEST_F(ResourceManagerServiceNewTest,
2012 reclaimResourcesFromMarkedClients_removesBiggestMarkedClientForSomeResources) {
2013 testReclaimResourcesFromMarkedClients_removesBiggestMarkedClientForSomeResources();
2014 }
2015
TEST_F(ResourceManagerServiceNewTest,concurrentCodecs)2016 TEST_F(ResourceManagerServiceNewTest, concurrentCodecs) {
2017 testConcurrentCodecs();
2018 }
2019
TEST_F(ResourceManagerServiceNewTest,reclaimPolicies)2020 TEST_F(ResourceManagerServiceNewTest, reclaimPolicies) {
2021 testReclaimPolicies();
2022 }
2023
2024 } // namespace android
2025