| /* |
| * Copyright 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| //#define LOG_NDEBUG 0 |
| #define LOG_TAG "ResourceManagerService_test" |
| #include <utils/Log.h> |
| |
| #include <gtest/gtest.h> |
| |
| #include "ResourceManagerService.h" |
| #include <media/IResourceManagerService.h> |
| #include <media/MediaResource.h> |
| #include <media/MediaResourcePolicy.h> |
| #include <media/stagefright/foundation/ADebug.h> |
| #include <media/stagefright/ProcessInfoInterface.h> |
| |
| namespace android { |
| |
| static int64_t getId(const sp<IResourceManagerClient>& client) { |
| return (int64_t) client.get(); |
| } |
| |
| struct TestProcessInfo : public ProcessInfoInterface { |
| TestProcessInfo() {} |
| virtual ~TestProcessInfo() {} |
| |
| virtual bool getPriority(int pid, int *priority) { |
| // For testing, use pid as priority. |
| // Lower the value higher the priority. |
| *priority = pid; |
| return true; |
| } |
| |
| virtual bool isValidPid(int /* pid */) { |
| return true; |
| } |
| |
| private: |
| DISALLOW_EVIL_CONSTRUCTORS(TestProcessInfo); |
| }; |
| |
| struct TestClient : public BnResourceManagerClient { |
| TestClient(int pid, sp<ResourceManagerService> service) |
| : mReclaimed(false), mPid(pid), mService(service) {} |
| |
| virtual bool reclaimResource() { |
| sp<IResourceManagerClient> client(this); |
| mService->removeResource(mPid, (int64_t) client.get()); |
| mReclaimed = true; |
| return true; |
| } |
| |
| virtual String8 getName() { |
| return String8("test_client"); |
| } |
| |
| bool reclaimed() const { |
| return mReclaimed; |
| } |
| |
| void reset() { |
| mReclaimed = false; |
| } |
| |
| protected: |
| virtual ~TestClient() {} |
| |
| private: |
| bool mReclaimed; |
| int mPid; |
| sp<ResourceManagerService> mService; |
| DISALLOW_EVIL_CONSTRUCTORS(TestClient); |
| }; |
| |
| static const int kTestPid1 = 30; |
| static const int kTestPid2 = 20; |
| |
| static const int kLowPriorityPid = 40; |
| static const int kMidPriorityPid = 25; |
| static const int kHighPriorityPid = 10; |
| |
| class ResourceManagerServiceTest : public ::testing::Test { |
| public: |
| ResourceManagerServiceTest() |
| : mService(new ResourceManagerService(new TestProcessInfo)), |
| mTestClient1(new TestClient(kTestPid1, mService)), |
| mTestClient2(new TestClient(kTestPid2, mService)), |
| mTestClient3(new TestClient(kTestPid2, mService)) { |
| } |
| |
| protected: |
| static bool isEqualResources(const Vector<MediaResource> &resources1, |
| const Vector<MediaResource> &resources2) { |
| if (resources1.size() != resources2.size()) { |
| return false; |
| } |
| for (size_t i = 0; i < resources1.size(); ++i) { |
| if (resources1[i] != resources2[i]) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| static void expectEqResourceInfo(const ResourceInfo &info, sp<IResourceManagerClient> client, |
| const Vector<MediaResource> &resources) { |
| EXPECT_EQ(client, info.client); |
| EXPECT_TRUE(isEqualResources(resources, info.resources)); |
| } |
| |
| void verifyClients(bool c1, bool c2, bool c3) { |
| TestClient *client1 = static_cast<TestClient*>(mTestClient1.get()); |
| TestClient *client2 = static_cast<TestClient*>(mTestClient2.get()); |
| TestClient *client3 = static_cast<TestClient*>(mTestClient3.get()); |
| |
| EXPECT_EQ(c1, client1->reclaimed()); |
| EXPECT_EQ(c2, client2->reclaimed()); |
| EXPECT_EQ(c3, client3->reclaimed()); |
| |
| client1->reset(); |
| client2->reset(); |
| client3->reset(); |
| } |
| |
| // test set up |
| // --------------------------------------------------------------------------------- |
| // pid priority client type number |
| // --------------------------------------------------------------------------------- |
| // kTestPid1(30) 30 mTestClient1 secure codec 1 |
| // graphic memory 200 |
| // graphic memory 200 |
| // --------------------------------------------------------------------------------- |
| // kTestPid2(20) 20 mTestClient2 non-secure codec 1 |
| // graphic memory 300 |
| // ------------------------------------------- |
| // mTestClient3 secure codec 1 |
| // graphic memory 100 |
| // --------------------------------------------------------------------------------- |
| void addResource() { |
| // kTestPid1 mTestClient1 |
| Vector<MediaResource> resources1; |
| resources1.push_back(MediaResource(MediaResource::kSecureCodec, 1)); |
| mService->addResource(kTestPid1, getId(mTestClient1), mTestClient1, resources1); |
| resources1.push_back(MediaResource(MediaResource::kGraphicMemory, 200)); |
| Vector<MediaResource> resources11; |
| resources11.push_back(MediaResource(MediaResource::kGraphicMemory, 200)); |
| mService->addResource(kTestPid1, getId(mTestClient1), mTestClient1, resources11); |
| |
| // kTestPid2 mTestClient2 |
| Vector<MediaResource> resources2; |
| resources2.push_back(MediaResource(MediaResource::kNonSecureCodec, 1)); |
| resources2.push_back(MediaResource(MediaResource::kGraphicMemory, 300)); |
| mService->addResource(kTestPid2, getId(mTestClient2), mTestClient2, resources2); |
| |
| // kTestPid2 mTestClient3 |
| Vector<MediaResource> resources3; |
| mService->addResource(kTestPid2, getId(mTestClient3), mTestClient3, resources3); |
| resources3.push_back(MediaResource(MediaResource::kSecureCodec, 1)); |
| resources3.push_back(MediaResource(MediaResource::kGraphicMemory, 100)); |
| mService->addResource(kTestPid2, getId(mTestClient3), mTestClient3, resources3); |
| |
| const PidResourceInfosMap &map = mService->mMap; |
| EXPECT_EQ(2u, map.size()); |
| ssize_t index1 = map.indexOfKey(kTestPid1); |
| ASSERT_GE(index1, 0); |
| const ResourceInfos &infos1 = map[index1]; |
| EXPECT_EQ(1u, infos1.size()); |
| expectEqResourceInfo(infos1[0], mTestClient1, resources1); |
| |
| ssize_t index2 = map.indexOfKey(kTestPid2); |
| ASSERT_GE(index2, 0); |
| const ResourceInfos &infos2 = map[index2]; |
| EXPECT_EQ(2u, infos2.size()); |
| expectEqResourceInfo(infos2[0], mTestClient2, resources2); |
| expectEqResourceInfo(infos2[1], mTestClient3, resources3); |
| } |
| |
| void testConfig() { |
| EXPECT_TRUE(mService->mSupportsMultipleSecureCodecs); |
| EXPECT_TRUE(mService->mSupportsSecureWithNonSecureCodec); |
| |
| Vector<MediaResourcePolicy> policies1; |
| policies1.push_back( |
| MediaResourcePolicy( |
| String8(kPolicySupportsMultipleSecureCodecs), |
| String8("true"))); |
| policies1.push_back( |
| MediaResourcePolicy( |
| String8(kPolicySupportsSecureWithNonSecureCodec), |
| String8("false"))); |
| mService->config(policies1); |
| EXPECT_TRUE(mService->mSupportsMultipleSecureCodecs); |
| EXPECT_FALSE(mService->mSupportsSecureWithNonSecureCodec); |
| |
| Vector<MediaResourcePolicy> policies2; |
| policies2.push_back( |
| MediaResourcePolicy( |
| String8(kPolicySupportsMultipleSecureCodecs), |
| String8("false"))); |
| policies2.push_back( |
| MediaResourcePolicy( |
| String8(kPolicySupportsSecureWithNonSecureCodec), |
| String8("true"))); |
| mService->config(policies2); |
| EXPECT_FALSE(mService->mSupportsMultipleSecureCodecs); |
| EXPECT_TRUE(mService->mSupportsSecureWithNonSecureCodec); |
| } |
| |
| void testRemoveResource() { |
| addResource(); |
| |
| mService->removeResource(kTestPid2, getId(mTestClient2)); |
| |
| const PidResourceInfosMap &map = mService->mMap; |
| EXPECT_EQ(2u, map.size()); |
| const ResourceInfos &infos1 = map.valueFor(kTestPid1); |
| const ResourceInfos &infos2 = map.valueFor(kTestPid2); |
| EXPECT_EQ(1u, infos1.size()); |
| EXPECT_EQ(1u, infos2.size()); |
| // mTestClient2 has been removed. |
| EXPECT_EQ(mTestClient3, infos2[0].client); |
| } |
| |
| void testGetAllClients() { |
| addResource(); |
| |
| MediaResource::Type type = MediaResource::kSecureCodec; |
| Vector<sp<IResourceManagerClient> > clients; |
| EXPECT_FALSE(mService->getAllClients_l(kLowPriorityPid, type, &clients)); |
| // some higher priority process (e.g. kTestPid2) owns the resource, so getAllClients_l |
| // will fail. |
| EXPECT_FALSE(mService->getAllClients_l(kMidPriorityPid, type, &clients)); |
| EXPECT_TRUE(mService->getAllClients_l(kHighPriorityPid, type, &clients)); |
| |
| EXPECT_EQ(2u, clients.size()); |
| EXPECT_EQ(mTestClient3, clients[0]); |
| EXPECT_EQ(mTestClient1, clients[1]); |
| } |
| |
| void testReclaimResourceSecure() { |
| Vector<MediaResource> resources; |
| resources.push_back(MediaResource(MediaResource::kSecureCodec, 1)); |
| resources.push_back(MediaResource(MediaResource::kGraphicMemory, 150)); |
| |
| // ### secure codec can't coexist and secure codec can coexist with non-secure codec ### |
| { |
| addResource(); |
| mService->mSupportsMultipleSecureCodecs = false; |
| mService->mSupportsSecureWithNonSecureCodec = true; |
| |
| // priority too low |
| EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources)); |
| EXPECT_FALSE(mService->reclaimResource(kMidPriorityPid, resources)); |
| |
| // reclaim all secure codecs |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(true /* c1 */, false /* c2 */, true /* c3 */); |
| |
| // call again should reclaim one largest graphic memory from lowest process |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(false /* c1 */, true /* c2 */, false /* c3 */); |
| |
| // nothing left |
| EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources)); |
| } |
| |
| // ### secure codecs can't coexist and secure codec can't coexist with non-secure codec ### |
| { |
| addResource(); |
| mService->mSupportsMultipleSecureCodecs = false; |
| mService->mSupportsSecureWithNonSecureCodec = false; |
| |
| // priority too low |
| EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources)); |
| EXPECT_FALSE(mService->reclaimResource(kMidPriorityPid, resources)); |
| |
| // reclaim all secure and non-secure codecs |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(true /* c1 */, true /* c2 */, true /* c3 */); |
| |
| // nothing left |
| EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources)); |
| } |
| |
| |
| // ### secure codecs can coexist but secure codec can't coexist with non-secure codec ### |
| { |
| addResource(); |
| mService->mSupportsMultipleSecureCodecs = true; |
| mService->mSupportsSecureWithNonSecureCodec = false; |
| |
| // priority too low |
| EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources)); |
| EXPECT_FALSE(mService->reclaimResource(kMidPriorityPid, resources)); |
| |
| // reclaim all non-secure codecs |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(false /* c1 */, true /* c2 */, false /* c3 */); |
| |
| // call again should reclaim one largest graphic memory from lowest process |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(true /* c1 */, false /* c2 */, false /* c3 */); |
| |
| // call again should reclaim another largest graphic memory from lowest process |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(false /* c1 */, false /* c2 */, true /* c3 */); |
| |
| // nothing left |
| EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources)); |
| } |
| |
| // ### secure codecs can coexist and secure codec can coexist with non-secure codec ### |
| { |
| addResource(); |
| mService->mSupportsMultipleSecureCodecs = true; |
| mService->mSupportsSecureWithNonSecureCodec = true; |
| |
| // priority too low |
| EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources)); |
| |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| // one largest graphic memory from lowest process got reclaimed |
| verifyClients(true /* c1 */, false /* c2 */, false /* c3 */); |
| |
| // call again should reclaim another graphic memory from lowest process |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(false /* c1 */, true /* c2 */, false /* c3 */); |
| |
| // call again should reclaim another graphic memory from lowest process |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(false /* c1 */, false /* c2 */, true /* c3 */); |
| |
| // nothing left |
| EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources)); |
| } |
| |
| // ### secure codecs can coexist and secure codec can coexist with non-secure codec ### |
| { |
| addResource(); |
| mService->mSupportsMultipleSecureCodecs = true; |
| mService->mSupportsSecureWithNonSecureCodec = true; |
| |
| Vector<MediaResource> resources; |
| resources.push_back(MediaResource(MediaResource::kSecureCodec, 1)); |
| |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| // secure codec from lowest process got reclaimed |
| verifyClients(true /* c1 */, false /* c2 */, false /* c3 */); |
| |
| // call again should reclaim another secure codec from lowest process |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(false /* c1 */, false /* c2 */, true /* c3 */); |
| |
| // no more secure codec, non-secure codec will be reclaimed. |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(false /* c1 */, true /* c2 */, false /* c3 */); |
| } |
| } |
| |
| void testReclaimResourceNonSecure() { |
| Vector<MediaResource> resources; |
| resources.push_back(MediaResource(MediaResource::kNonSecureCodec, 1)); |
| resources.push_back(MediaResource(MediaResource::kGraphicMemory, 150)); |
| |
| // ### secure codec can't coexist with non-secure codec ### |
| { |
| addResource(); |
| mService->mSupportsSecureWithNonSecureCodec = false; |
| |
| // priority too low |
| EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources)); |
| EXPECT_FALSE(mService->reclaimResource(kMidPriorityPid, resources)); |
| |
| // reclaim all secure codecs |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(true /* c1 */, false /* c2 */, true /* c3 */); |
| |
| // call again should reclaim one graphic memory from lowest process |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(false /* c1 */, true /* c2 */, false /* c3 */); |
| |
| // nothing left |
| EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources)); |
| } |
| |
| |
| // ### secure codec can coexist with non-secure codec ### |
| { |
| addResource(); |
| mService->mSupportsSecureWithNonSecureCodec = true; |
| |
| // priority too low |
| EXPECT_FALSE(mService->reclaimResource(kLowPriorityPid, resources)); |
| |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| // one largest graphic memory from lowest process got reclaimed |
| verifyClients(true /* c1 */, false /* c2 */, false /* c3 */); |
| |
| // call again should reclaim another graphic memory from lowest process |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(false /* c1 */, true /* c2 */, false /* c3 */); |
| |
| // call again should reclaim another graphic memory from lowest process |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(false /* c1 */, false /* c2 */, true /* c3 */); |
| |
| // nothing left |
| EXPECT_FALSE(mService->reclaimResource(kHighPriorityPid, resources)); |
| } |
| |
| // ### secure codec can coexist with non-secure codec ### |
| { |
| addResource(); |
| mService->mSupportsSecureWithNonSecureCodec = true; |
| |
| Vector<MediaResource> resources; |
| resources.push_back(MediaResource(MediaResource::kNonSecureCodec, 1)); |
| |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| // one non secure codec from lowest process got reclaimed |
| verifyClients(false /* c1 */, true /* c2 */, false /* c3 */); |
| |
| // no more non-secure codec, secure codec from lowest priority process will be reclaimed |
| EXPECT_TRUE(mService->reclaimResource(kHighPriorityPid, resources)); |
| verifyClients(true /* c1 */, false /* c2 */, false /* c3 */); |
| |
| // clean up client 3 which still left |
| mService->removeResource(kTestPid2, getId(mTestClient3)); |
| } |
| } |
| |
| void testGetLowestPriorityBiggestClient() { |
| MediaResource::Type type = MediaResource::kGraphicMemory; |
| sp<IResourceManagerClient> client; |
| EXPECT_FALSE(mService->getLowestPriorityBiggestClient_l(kHighPriorityPid, type, &client)); |
| |
| addResource(); |
| |
| EXPECT_FALSE(mService->getLowestPriorityBiggestClient_l(kLowPriorityPid, type, &client)); |
| EXPECT_TRUE(mService->getLowestPriorityBiggestClient_l(kHighPriorityPid, type, &client)); |
| |
| // kTestPid1 is the lowest priority process with MediaResource::kGraphicMemory. |
| // mTestClient1 has the largest MediaResource::kGraphicMemory within kTestPid1. |
| EXPECT_EQ(mTestClient1, client); |
| } |
| |
| void testGetLowestPriorityPid() { |
| int pid; |
| int priority; |
| TestProcessInfo processInfo; |
| |
| MediaResource::Type type = MediaResource::kGraphicMemory; |
| EXPECT_FALSE(mService->getLowestPriorityPid_l(type, &pid, &priority)); |
| |
| addResource(); |
| |
| EXPECT_TRUE(mService->getLowestPriorityPid_l(type, &pid, &priority)); |
| EXPECT_EQ(kTestPid1, pid); |
| int priority1; |
| processInfo.getPriority(kTestPid1, &priority1); |
| EXPECT_EQ(priority1, priority); |
| |
| type = MediaResource::kNonSecureCodec; |
| EXPECT_TRUE(mService->getLowestPriorityPid_l(type, &pid, &priority)); |
| EXPECT_EQ(kTestPid2, pid); |
| int priority2; |
| processInfo.getPriority(kTestPid2, &priority2); |
| EXPECT_EQ(priority2, priority); |
| } |
| |
| void testGetBiggestClient() { |
| MediaResource::Type type = MediaResource::kGraphicMemory; |
| sp<IResourceManagerClient> client; |
| EXPECT_FALSE(mService->getBiggestClient_l(kTestPid2, type, &client)); |
| |
| addResource(); |
| |
| EXPECT_TRUE(mService->getBiggestClient_l(kTestPid2, type, &client)); |
| EXPECT_EQ(mTestClient2, client); |
| } |
| |
| void testIsCallingPriorityHigher() { |
| EXPECT_FALSE(mService->isCallingPriorityHigher_l(101, 100)); |
| EXPECT_FALSE(mService->isCallingPriorityHigher_l(100, 100)); |
| EXPECT_TRUE(mService->isCallingPriorityHigher_l(99, 100)); |
| } |
| |
| sp<ResourceManagerService> mService; |
| sp<IResourceManagerClient> mTestClient1; |
| sp<IResourceManagerClient> mTestClient2; |
| sp<IResourceManagerClient> mTestClient3; |
| }; |
| |
| TEST_F(ResourceManagerServiceTest, config) { |
| testConfig(); |
| } |
| |
| TEST_F(ResourceManagerServiceTest, addResource) { |
| addResource(); |
| } |
| |
| TEST_F(ResourceManagerServiceTest, removeResource) { |
| testRemoveResource(); |
| } |
| |
| TEST_F(ResourceManagerServiceTest, reclaimResource) { |
| testReclaimResourceSecure(); |
| testReclaimResourceNonSecure(); |
| } |
| |
| TEST_F(ResourceManagerServiceTest, getAllClients_l) { |
| testGetAllClients(); |
| } |
| |
| TEST_F(ResourceManagerServiceTest, getLowestPriorityBiggestClient_l) { |
| testGetLowestPriorityBiggestClient(); |
| } |
| |
| TEST_F(ResourceManagerServiceTest, getLowestPriorityPid_l) { |
| testGetLowestPriorityPid(); |
| } |
| |
| TEST_F(ResourceManagerServiceTest, getBiggestClient_l) { |
| testGetBiggestClient(); |
| } |
| |
| TEST_F(ResourceManagerServiceTest, isCallingPriorityHigher_l) { |
| testIsCallingPriorityHigher(); |
| } |
| |
| } // namespace android |
