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 #include <utils/Log.h>
20
21 #include <gtest/gtest.h>
22
23 #include "ResourceManagerService.h"
24 #include <media/IResourceManagerService.h>
25 #include <media/MediaResource.h>
26 #include <media/MediaResourcePolicy.h>
27 #include <media/stagefright/foundation/ADebug.h>
28 #include <media/stagefright/ProcessInfoInterface.h>
29
30 namespace android {
31
getId(const sp<IResourceManagerClient> & client)32 static int64_t getId(const sp<IResourceManagerClient>& client) {
33 return (int64_t) client.get();
34 }
35
36 struct TestProcessInfo : public ProcessInfoInterface {
TestProcessInfoandroid::TestProcessInfo37 TestProcessInfo() {}
~TestProcessInfoandroid::TestProcessInfo38 virtual ~TestProcessInfo() {}
39
getPriorityandroid::TestProcessInfo40 virtual bool getPriority(int pid, int *priority) {
41 // For testing, use pid as priority.
42 // Lower the value higher the priority.
43 *priority = pid;
44 return true;
45 }
46
isValidPidandroid::TestProcessInfo47 virtual bool isValidPid(int /* pid */) {
48 return true;
49 }
50
51 private:
52 DISALLOW_EVIL_CONSTRUCTORS(TestProcessInfo);
53 };
54
55 struct TestClient : public BnResourceManagerClient {
TestClientandroid::TestClient56 TestClient(int pid, sp<ResourceManagerService> service)
57 : mReclaimed(false), mPid(pid), mService(service) {}
58
reclaimResourceandroid::TestClient59 virtual bool reclaimResource() {
60 sp<IResourceManagerClient> client(this);
61 mService->removeResource(mPid, (int64_t) client.get());
62 mReclaimed = true;
63 return true;
64 }
65
getNameandroid::TestClient66 virtual String8 getName() {
67 return String8("test_client");
68 }
69
reclaimedandroid::TestClient70 bool reclaimed() const {
71 return mReclaimed;
72 }
73
resetandroid::TestClient74 void reset() {
75 mReclaimed = false;
76 }
77
78 protected:
~TestClientandroid::TestClient79 virtual ~TestClient() {}
80
81 private:
82 bool mReclaimed;
83 int mPid;
84 sp<ResourceManagerService> mService;
85 DISALLOW_EVIL_CONSTRUCTORS(TestClient);
86 };
87
88 static const int kTestPid1 = 30;
89 static const int kTestPid2 = 20;
90
91 static const int kLowPriorityPid = 40;
92 static const int kMidPriorityPid = 25;
93 static const int kHighPriorityPid = 10;
94
95 class ResourceManagerServiceTest : public ::testing::Test {
96 public:
ResourceManagerServiceTest()97 ResourceManagerServiceTest()
98 : mService(new ResourceManagerService(new TestProcessInfo)),
99 mTestClient1(new TestClient(kTestPid1, mService)),
100 mTestClient2(new TestClient(kTestPid2, mService)),
101 mTestClient3(new TestClient(kTestPid2, mService)) {
102 }
103
104 protected:
isEqualResources(const Vector<MediaResource> & resources1,const Vector<MediaResource> & resources2)105 static bool isEqualResources(const Vector<MediaResource> &resources1,
106 const Vector<MediaResource> &resources2) {
107 if (resources1.size() != resources2.size()) {
108 return false;
109 }
110 for (size_t i = 0; i < resources1.size(); ++i) {
111 if (resources1[i] != resources2[i]) {
112 return false;
113 }
114 }
115 return true;
116 }
117
expectEqResourceInfo(const ResourceInfo & info,sp<IResourceManagerClient> client,const Vector<MediaResource> & resources)118 static void expectEqResourceInfo(const ResourceInfo &info, sp<IResourceManagerClient> client,
119 const Vector<MediaResource> &resources) {
120 EXPECT_EQ(client, info.client);
121 EXPECT_TRUE(isEqualResources(resources, info.resources));
122 }
123
verifyClients(bool c1,bool c2,bool c3)124 void verifyClients(bool c1, bool c2, bool c3) {
125 TestClient *client1 = static_cast<TestClient*>(mTestClient1.get());
126 TestClient *client2 = static_cast<TestClient*>(mTestClient2.get());
127 TestClient *client3 = static_cast<TestClient*>(mTestClient3.get());
128
129 EXPECT_EQ(c1, client1->reclaimed());
130 EXPECT_EQ(c2, client2->reclaimed());
131 EXPECT_EQ(c3, client3->reclaimed());
132
133 client1->reset();
134 client2->reset();
135 client3->reset();
136 }
137
138 // test set up
139 // ---------------------------------------------------------------------------------
140 // pid priority client type number
141 // ---------------------------------------------------------------------------------
142 // kTestPid1(30) 30 mTestClient1 secure codec 1
143 // graphic memory 200
144 // graphic memory 200
145 // ---------------------------------------------------------------------------------
146 // kTestPid2(20) 20 mTestClient2 non-secure codec 1
147 // graphic memory 300
148 // -------------------------------------------
149 // mTestClient3 secure codec 1
150 // graphic memory 100
151 // ---------------------------------------------------------------------------------
addResource()152 void addResource() {
153 // kTestPid1 mTestClient1
154 Vector<MediaResource> resources1;
155 resources1.push_back(MediaResource(MediaResource::kSecureCodec, 1));
156 mService->addResource(kTestPid1, getId(mTestClient1), mTestClient1, resources1);
157 resources1.push_back(MediaResource(MediaResource::kGraphicMemory, 200));
158 Vector<MediaResource> resources11;
159 resources11.push_back(MediaResource(MediaResource::kGraphicMemory, 200));
160 mService->addResource(kTestPid1, getId(mTestClient1), mTestClient1, resources11);
161
162 // kTestPid2 mTestClient2
163 Vector<MediaResource> resources2;
164 resources2.push_back(MediaResource(MediaResource::kNonSecureCodec, 1));
165 resources2.push_back(MediaResource(MediaResource::kGraphicMemory, 300));
166 mService->addResource(kTestPid2, getId(mTestClient2), mTestClient2, resources2);
167
168 // kTestPid2 mTestClient3
169 Vector<MediaResource> resources3;
170 mService->addResource(kTestPid2, getId(mTestClient3), mTestClient3, resources3);
171 resources3.push_back(MediaResource(MediaResource::kSecureCodec, 1));
172 resources3.push_back(MediaResource(MediaResource::kGraphicMemory, 100));
173 mService->addResource(kTestPid2, getId(mTestClient3), mTestClient3, resources3);
174
175 const PidResourceInfosMap &map = mService->mMap;
176 EXPECT_EQ(2u, map.size());
177 ssize_t index1 = map.indexOfKey(kTestPid1);
178 ASSERT_GE(index1, 0);
179 const ResourceInfos &infos1 = map[index1];
180 EXPECT_EQ(1u, infos1.size());
181 expectEqResourceInfo(infos1[0], mTestClient1, resources1);
182
183 ssize_t index2 = map.indexOfKey(kTestPid2);
184 ASSERT_GE(index2, 0);
185 const ResourceInfos &infos2 = map[index2];
186 EXPECT_EQ(2u, infos2.size());
187 expectEqResourceInfo(infos2[0], mTestClient2, resources2);
188 expectEqResourceInfo(infos2[1], mTestClient3, resources3);
189 }
190
testConfig()191 void testConfig() {
192 EXPECT_TRUE(mService->mSupportsMultipleSecureCodecs);
193 EXPECT_TRUE(mService->mSupportsSecureWithNonSecureCodec);
194
195 Vector<MediaResourcePolicy> policies1;
196 policies1.push_back(
197 MediaResourcePolicy(
198 String8(kPolicySupportsMultipleSecureCodecs),
199 String8("true")));
200 policies1.push_back(
201 MediaResourcePolicy(
202 String8(kPolicySupportsSecureWithNonSecureCodec),
203 String8("false")));
204 mService->config(policies1);
205 EXPECT_TRUE(mService->mSupportsMultipleSecureCodecs);
206 EXPECT_FALSE(mService->mSupportsSecureWithNonSecureCodec);
207
208 Vector<MediaResourcePolicy> policies2;
209 policies2.push_back(
210 MediaResourcePolicy(
211 String8(kPolicySupportsMultipleSecureCodecs),
212 String8("false")));
213 policies2.push_back(
214 MediaResourcePolicy(
215 String8(kPolicySupportsSecureWithNonSecureCodec),
216 String8("true")));
217 mService->config(policies2);
218 EXPECT_FALSE(mService->mSupportsMultipleSecureCodecs);
219 EXPECT_TRUE(mService->mSupportsSecureWithNonSecureCodec);
220 }
221
testRemoveResource()222 void testRemoveResource() {
223 addResource();
224
225 mService->removeResource(kTestPid2, getId(mTestClient2));
226
227 const PidResourceInfosMap &map = mService->mMap;
228 EXPECT_EQ(2u, map.size());
229 const ResourceInfos &infos1 = map.valueFor(kTestPid1);
230 const ResourceInfos &infos2 = map.valueFor(kTestPid2);
231 EXPECT_EQ(1u, infos1.size());
232 EXPECT_EQ(1u, infos2.size());
233 // mTestClient2 has been removed.
234 EXPECT_EQ(mTestClient3, infos2[0].client);
235 }
236
testGetAllClients()237 void testGetAllClients() {
238 addResource();
239
240 MediaResource::Type type = MediaResource::kSecureCodec;
241 Vector<sp<IResourceManagerClient> > clients;
242 EXPECT_FALSE(mService->getAllClients_l(kLowPriorityPid, type, &clients));
243 // some higher priority process (e.g. kTestPid2) owns the resource, so getAllClients_l
244 // will fail.
245 EXPECT_FALSE(mService->getAllClients_l(kMidPriorityPid, type, &clients));
246 EXPECT_TRUE(mService->getAllClients_l(kHighPriorityPid, type, &clients));
247
248 EXPECT_EQ(2u, clients.size());
249 EXPECT_EQ(mTestClient3, clients[0]);
250 EXPECT_EQ(mTestClient1, clients[1]);
251 }
252
testReclaimResourceSecure()253 void testReclaimResourceSecure() {
254 Vector<MediaResource> resources;
255 resources.push_back(MediaResource(MediaResource::kSecureCodec, 1));
256 resources.push_back(MediaResource(MediaResource::kGraphicMemory, 150));
257
258 // ### secure codec can't coexist and secure codec can coexist with non-secure codec ###
259 {
260 addResource();
261 mService->mSupportsMultipleSecureCodecs = false;
262 mService->mSupportsSecureWithNonSecureCodec = true;
263
264 // priority too low
265 EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources));
266 EXPECT_FALSE(mService->reclaimResource(kMidPriorityPid, resources));
267
268 // reclaim all secure codecs
269 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
270 verifyClients(true /* c1 */, false /* c2 */, true /* c3 */);
271
272 // call again should reclaim one largest graphic memory from lowest process
273 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
274 verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
275
276 // nothing left
277 EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources));
278 }
279
280 // ### secure codecs can't coexist and secure codec can't coexist with non-secure codec ###
281 {
282 addResource();
283 mService->mSupportsMultipleSecureCodecs = false;
284 mService->mSupportsSecureWithNonSecureCodec = false;
285
286 // priority too low
287 EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources));
288 EXPECT_FALSE(mService->reclaimResource(kMidPriorityPid, resources));
289
290 // reclaim all secure and non-secure codecs
291 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
292 verifyClients(true /* c1 */, true /* c2 */, true /* c3 */);
293
294 // nothing left
295 EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources));
296 }
297
298
299 // ### secure codecs can coexist but secure codec can't coexist with non-secure codec ###
300 {
301 addResource();
302 mService->mSupportsMultipleSecureCodecs = true;
303 mService->mSupportsSecureWithNonSecureCodec = false;
304
305 // priority too low
306 EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources));
307 EXPECT_FALSE(mService->reclaimResource(kMidPriorityPid, resources));
308
309 // reclaim all non-secure codecs
310 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
311 verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
312
313 // call again should reclaim one largest graphic memory from lowest process
314 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
315 verifyClients(true /* c1 */, false /* c2 */, false /* c3 */);
316
317 // call again should reclaim another largest graphic memory from lowest process
318 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
319 verifyClients(false /* c1 */, false /* c2 */, true /* c3 */);
320
321 // nothing left
322 EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources));
323 }
324
325 // ### secure codecs can coexist and secure codec can coexist with non-secure codec ###
326 {
327 addResource();
328 mService->mSupportsMultipleSecureCodecs = true;
329 mService->mSupportsSecureWithNonSecureCodec = true;
330
331 // priority too low
332 EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources));
333
334 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
335 // one largest graphic memory from lowest process got reclaimed
336 verifyClients(true /* c1 */, false /* c2 */, false /* c3 */);
337
338 // call again should reclaim another graphic memory from lowest process
339 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
340 verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
341
342 // call again should reclaim another graphic memory from lowest process
343 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
344 verifyClients(false /* c1 */, false /* c2 */, true /* c3 */);
345
346 // nothing left
347 EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources));
348 }
349
350 // ### secure codecs can coexist and secure codec can coexist with non-secure codec ###
351 {
352 addResource();
353 mService->mSupportsMultipleSecureCodecs = true;
354 mService->mSupportsSecureWithNonSecureCodec = true;
355
356 Vector<MediaResource> resources;
357 resources.push_back(MediaResource(MediaResource::kSecureCodec, 1));
358
359 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
360 // secure codec from lowest process got reclaimed
361 verifyClients(true /* c1 */, false /* c2 */, false /* c3 */);
362
363 // call again should reclaim another secure codec from lowest process
364 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
365 verifyClients(false /* c1 */, false /* c2 */, true /* c3 */);
366
367 // no more secure codec, non-secure codec will be reclaimed.
368 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
369 verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
370 }
371 }
372
testReclaimResourceNonSecure()373 void testReclaimResourceNonSecure() {
374 Vector<MediaResource> resources;
375 resources.push_back(MediaResource(MediaResource::kNonSecureCodec, 1));
376 resources.push_back(MediaResource(MediaResource::kGraphicMemory, 150));
377
378 // ### secure codec can't coexist with non-secure codec ###
379 {
380 addResource();
381 mService->mSupportsSecureWithNonSecureCodec = false;
382
383 // priority too low
384 EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources));
385 EXPECT_FALSE(mService->reclaimResource(kMidPriorityPid, resources));
386
387 // reclaim all secure codecs
388 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
389 verifyClients(true /* c1 */, false /* c2 */, true /* c3 */);
390
391 // call again should reclaim one graphic memory from lowest process
392 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
393 verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
394
395 // nothing left
396 EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources));
397 }
398
399
400 // ### secure codec can coexist with non-secure codec ###
401 {
402 addResource();
403 mService->mSupportsSecureWithNonSecureCodec = true;
404
405 // priority too low
406 EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources));
407
408 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
409 // one largest graphic memory from lowest process got reclaimed
410 verifyClients(true /* c1 */, false /* c2 */, false /* c3 */);
411
412 // call again should reclaim another graphic memory from lowest process
413 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
414 verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
415
416 // call again should reclaim another graphic memory from lowest process
417 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
418 verifyClients(false /* c1 */, false /* c2 */, true /* c3 */);
419
420 // nothing left
421 EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources));
422 }
423
424 // ### secure codec can coexist with non-secure codec ###
425 {
426 addResource();
427 mService->mSupportsSecureWithNonSecureCodec = true;
428
429 Vector<MediaResource> resources;
430 resources.push_back(MediaResource(MediaResource::kNonSecureCodec, 1));
431
432 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
433 // one non secure codec from lowest process got reclaimed
434 verifyClients(false /* c1 */, true /* c2 */, false /* c3 */);
435
436 // no more non-secure codec, secure codec from lowest priority process will be reclaimed
437 EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources));
438 verifyClients(true /* c1 */, false /* c2 */, false /* c3 */);
439
440 // clean up client 3 which still left
441 mService->removeResource(kTestPid2, getId(mTestClient3));
442 }
443 }
444
testGetLowestPriorityBiggestClient()445 void testGetLowestPriorityBiggestClient() {
446 MediaResource::Type type = MediaResource::kGraphicMemory;
447 sp<IResourceManagerClient> client;
448 EXPECT_FALSE(mService->getLowestPriorityBiggestClient_l(kHighPriorityPid, type, &client));
449
450 addResource();
451
452 EXPECT_FALSE(mService->getLowestPriorityBiggestClient_l(kLowPriorityPid, type, &client));
453 EXPECT_TRUE(mService->getLowestPriorityBiggestClient_l(kHighPriorityPid, type, &client));
454
455 // kTestPid1 is the lowest priority process with MediaResource::kGraphicMemory.
456 // mTestClient1 has the largest MediaResource::kGraphicMemory within kTestPid1.
457 EXPECT_EQ(mTestClient1, client);
458 }
459
testGetLowestPriorityPid()460 void testGetLowestPriorityPid() {
461 int pid;
462 int priority;
463 TestProcessInfo processInfo;
464
465 MediaResource::Type type = MediaResource::kGraphicMemory;
466 EXPECT_FALSE(mService->getLowestPriorityPid_l(type, &pid, &priority));
467
468 addResource();
469
470 EXPECT_TRUE(mService->getLowestPriorityPid_l(type, &pid, &priority));
471 EXPECT_EQ(kTestPid1, pid);
472 int priority1;
473 processInfo.getPriority(kTestPid1, &priority1);
474 EXPECT_EQ(priority1, priority);
475
476 type = MediaResource::kNonSecureCodec;
477 EXPECT_TRUE(mService->getLowestPriorityPid_l(type, &pid, &priority));
478 EXPECT_EQ(kTestPid2, pid);
479 int priority2;
480 processInfo.getPriority(kTestPid2, &priority2);
481 EXPECT_EQ(priority2, priority);
482 }
483
testGetBiggestClient()484 void testGetBiggestClient() {
485 MediaResource::Type type = MediaResource::kGraphicMemory;
486 sp<IResourceManagerClient> client;
487 EXPECT_FALSE(mService->getBiggestClient_l(kTestPid2, type, &client));
488
489 addResource();
490
491 EXPECT_TRUE(mService->getBiggestClient_l(kTestPid2, type, &client));
492 EXPECT_EQ(mTestClient2, client);
493 }
494
testIsCallingPriorityHigher()495 void testIsCallingPriorityHigher() {
496 EXPECT_FALSE(mService->isCallingPriorityHigher_l(101, 100));
497 EXPECT_FALSE(mService->isCallingPriorityHigher_l(100, 100));
498 EXPECT_TRUE(mService->isCallingPriorityHigher_l(99, 100));
499 }
500
501 sp<ResourceManagerService> mService;
502 sp<IResourceManagerClient> mTestClient1;
503 sp<IResourceManagerClient> mTestClient2;
504 sp<IResourceManagerClient> mTestClient3;
505 };
506
TEST_F(ResourceManagerServiceTest,config)507 TEST_F(ResourceManagerServiceTest, config) {
508 testConfig();
509 }
510
TEST_F(ResourceManagerServiceTest,addResource)511 TEST_F(ResourceManagerServiceTest, addResource) {
512 addResource();
513 }
514
TEST_F(ResourceManagerServiceTest,removeResource)515 TEST_F(ResourceManagerServiceTest, removeResource) {
516 testRemoveResource();
517 }
518
TEST_F(ResourceManagerServiceTest,reclaimResource)519 TEST_F(ResourceManagerServiceTest, reclaimResource) {
520 testReclaimResourceSecure();
521 testReclaimResourceNonSecure();
522 }
523
TEST_F(ResourceManagerServiceTest,getAllClients_l)524 TEST_F(ResourceManagerServiceTest, getAllClients_l) {
525 testGetAllClients();
526 }
527
TEST_F(ResourceManagerServiceTest,getLowestPriorityBiggestClient_l)528 TEST_F(ResourceManagerServiceTest, getLowestPriorityBiggestClient_l) {
529 testGetLowestPriorityBiggestClient();
530 }
531
TEST_F(ResourceManagerServiceTest,getLowestPriorityPid_l)532 TEST_F(ResourceManagerServiceTest, getLowestPriorityPid_l) {
533 testGetLowestPriorityPid();
534 }
535
TEST_F(ResourceManagerServiceTest,getBiggestClient_l)536 TEST_F(ResourceManagerServiceTest, getBiggestClient_l) {
537 testGetBiggestClient();
538 }
539
TEST_F(ResourceManagerServiceTest,isCallingPriorityHigher_l)540 TEST_F(ResourceManagerServiceTest, isCallingPriorityHigher_l) {
541 testIsCallingPriorityHigher();
542 }
543
544 } // namespace android
545