Merge changes from topic "rm_refactor_last_batch" into main am: e9e62c53d8 am:... (69e06179) · Commits · e / os / android_frameworks_av

services/mediaresourcemanager/Android.bp

+5 −0

Original line number	Diff line number	Diff line
		@@ -74,10 +74,14 @@ cc_library {
		name: "libresourcemanagerservice",

		srcs: [
		"DefaultResourceModel.cpp",
		"ProcessPriorityReclaimPolicy.cpp",
		"ResourceManagerMetrics.cpp",
		"ResourceManagerService.cpp",
		"ResourceManagerServiceNew.cpp",
		"ResourceObserverService.cpp",
		"ResourceManagerServiceUtils.cpp",
		"ResourceTracker.cpp",
		"ServiceLog.cpp",
		"UidObserver.cpp",

		@@ -97,6 +101,7 @@ cc_library {
		"libstatssocket",
		"libprotobuf-cpp-lite",
		"libactivitymanager_aidl",
		"aconfig_mediacodec_flags_c_lib",
		],

		static_libs: [

services/mediaresourcemanager/DefaultResourceModel.cpp

0 → 100644

+145 −0

Original line number	Diff line number	Diff line
		/*
		**
		** Copyright 2023, 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 "DefaultResourceModel"
		#include <utils/Log.h>

		#include "ResourceManagerServiceUtils.h"
		#include "DefaultResourceModel.h"
		#include "ResourceTracker.h"

		namespace android {

		DefaultResourceModel::DefaultResourceModel(
		const std::shared_ptr<ResourceTracker>& resourceTracker,
		bool supportsMultipleSecureCodecs,
		bool supportsSecureWithNonSecureCodec)
		: mSupportsMultipleSecureCodecs(supportsMultipleSecureCodecs),
		mSupportsSecureWithNonSecureCodec(supportsSecureWithNonSecureCodec),
		mResourceTracker(resourceTracker) {
		}

		DefaultResourceModel::~DefaultResourceModel() {
		}

		bool DefaultResourceModel::getAllClients(
		const ReclaimRequestInfo& reclimRequestInfo,
		std::vector<ClientInfo>& clients) {

		clients.clear();
		MediaResourceParcel mediaResource{.type = reclimRequestInfo.mResources[0].type,
		.subType = reclimRequestInfo.mResources[0].subType};
		ResourceRequestInfo resourceRequestInfo{reclimRequestInfo.mCallingPid, &mediaResource};

		// Resolve the secure-unsecure codec conflicts if there is any.
		switch (reclimRequestInfo.mResources[0].type) {
		case MediaResource::Type::kSecureCodec:
		// Looking to start a secure codec.
		// #1. Make sure if multiple secure codecs can coexist
		if (!mSupportsMultipleSecureCodecs) {
		if (!mResourceTracker->getNonConflictingClients(resourceRequestInfo, clients)) {
		// A higher priority process owns an instance of a secure codec.
		// So this request can't be fulfilled.
		return false;
		}
		}
		// #2. Make sure a secure codec can coexist if there is an instance
		// of non-secure codec running already.
		if (!mSupportsSecureWithNonSecureCodec) {
		mediaResource.type = MediaResource::Type::kNonSecureCodec;
		if (!mResourceTracker->getNonConflictingClients(resourceRequestInfo, clients)) {
		// A higher priority process owns an instance of a non-secure codec.
		// So this request can't be fulfilled.
		return false;
		}
		}
		break;
		case MediaResource::Type::kNonSecureCodec:
		// Looking to start a non-secure codec.
		// Make sure a non-secure codec can coexist if there is an instance
		// of secure codec running already.
		if (!mSupportsSecureWithNonSecureCodec) {
		mediaResource.type = MediaResource::Type::kSecureCodec;
		if (!mResourceTracker->getNonConflictingClients(resourceRequestInfo, clients)) {
		// A higher priority process owns an instance of a secure codec.
		// So this request can't be fulfilled.
		return false;
		}
		}
		break;
		default:
		break;
		}

		if (!clients.empty()) {
		// There is secure/unsecure codec co-existence conflict
		// and we have only found processes with lower priority holding the
		// resources. So, all of these need to be reclaimed.
		return false;
		}

		// No more resource conflicts.
		switch (reclimRequestInfo.mResources[0].type) {
		case MediaResource::Type::kSecureCodec:
		case MediaResource::Type::kNonSecureCodec:
		// Handling Codec resource reclaim
		return getCodecClients(reclimRequestInfo, clients);
		case MediaResource::Type::kGraphicMemory:
		case MediaResource::Type::kDrmSession:
		// Handling DRM and GraphicMemory resource reclaim
		mediaResource.id = reclimRequestInfo.mResources[0].id;
		mediaResource.value = reclimRequestInfo.mResources[0].value;
		return mResourceTracker->getAllClients(resourceRequestInfo, clients);
		default:
		break;
		}

		return !clients.empty();
		}

		bool DefaultResourceModel::getCodecClients(
		const ReclaimRequestInfo& reclimRequestInfo,
		std::vector<ClientInfo>& clients) {
		MediaResourceParcel mediaResource;
		ResourceRequestInfo resourceRequestInfo{reclimRequestInfo.mCallingPid, &mediaResource};

		// 1. Look to find the client(s) with the other resources, for the given
		// primary type.
		MediaResource::SubType primarySubType = reclimRequestInfo.mResources[0].subType;
		for (size_t index = 1; index < reclimRequestInfo.mResources.size(); index++) {
		mediaResource.type = reclimRequestInfo.mResources[index].type;
		mediaResource.subType = reclimRequestInfo.mResources[index].subType;
		mResourceTracker->getAllClients(resourceRequestInfo, clients, primarySubType);
		}

		// 2. Get all clients of the same type.
		mediaResource.type = reclimRequestInfo.mResources[0].type;
		mediaResource.subType = reclimRequestInfo.mResources[0].subType;
		mResourceTracker->getAllClients(resourceRequestInfo, clients);

		// 3. Get all cliends of the different type.
		MediaResourceType otherType =
		(reclimRequestInfo.mResources[0].type == MediaResource::Type::kSecureCodec) ?
		MediaResource::Type::kNonSecureCodec : MediaResource::Type::kSecureCodec;
		mediaResource.type = otherType;
		mResourceTracker->getAllClients(resourceRequestInfo, clients);

		return !clients.empty();
		}

		} // namespace android

services/mediaresourcemanager/DefaultResourceModel.h

0 → 100644

+73 −0

Original line number	Diff line number	Diff line
		/*
		**
		** Copyright 2023, 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.
		*/

		#ifndef ANDROID_MEDIA_DEFAULTRESOURCEMODEL_H_
		#define ANDROID_MEDIA_DEFAULTRESOURCEMODEL_H_

		#include "IResourceModel.h"

		namespace android {

		class ResourceTracker;

		/*
		* Implements the Default Resource Model that handles:
		* - coexistence of secure codec with another secure/non-secure codecs
		* - sharing resources among other codecs
		*/
		class DefaultResourceModel : public IResourceModel {
		public:
		DefaultResourceModel(const std::shared_ptr<ResourceTracker>& resourceTracker,
		bool supportsMultipleSecureCodecs = true,
		bool supportsSecureWithNonSecureCodec = true);
		virtual ~DefaultResourceModel();

		/*
		* Set the codec co-existence properties
		*/
		void config(bool supportsMultipleSecureCodecs, bool supportsSecureWithNonSecureCodec) {
		mSupportsMultipleSecureCodecs = supportsMultipleSecureCodecs;
		mSupportsSecureWithNonSecureCodec = supportsSecureWithNonSecureCodec;
		}

		/*
		* Get a list of all clients that holds the resources requested.
		* This implementation uses the ResourceModel to select the clients.
		*
		* @param[in] reclaimRequestInfo Information about the Reclaim request
		* @param[out] cliens The list of clients that hold the resources in question.
		*
		* @return true if there aren't any resource conflicts and false otherwise.
		*/
		bool getAllClients(const ReclaimRequestInfo& reclaimRequestInfo,
		std::vector<ClientInfo>& clients) override;

		protected:
		bool getCodecClients(const ReclaimRequestInfo& reclaimRequestInfo,
		std::vector<ClientInfo>& clients);

		protected:
		// Keeping these protected to allow extending this implementation
		// by other resource models.
		bool mSupportsMultipleSecureCodecs;
		bool mSupportsSecureWithNonSecureCodec;
		std::shared_ptr<ResourceTracker> mResourceTracker;
		};

		} // namespace android

		#endif // ANDROID_MEDIA_DEFAULTRESOURCEMODEL_H_

services/mediaresourcemanager/IReclaimPolicy.h

0 → 100644

+58 −0

Original line number	Diff line number	Diff line
		/*
		**
		** Copyright 2023, 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.
		*/

		#ifndef ANDROID_MEDIA_IRECLAIMPOLICY_H_
		#define ANDROID_MEDIA_IRECLAIMPOLICY_H_

		#include <memory>
		#include <aidl/android/media/IResourceManagerClient.h>

		namespace android {

		struct ClientInfo;
		struct ReclaimRequestInfo;

		/*
		* Interface that defines Reclaim Policy.
		*
		* This provides an interface to select/identify a client based on a specific
		* Reclaim policy.
		*/
		class IReclaimPolicy {
		public:
		IReclaimPolicy() {}

		virtual ~IReclaimPolicy() {}

		/*
		* Based on the Reclaim policy, identify and return a client from the list
		* of given clients that satisfy the resource requested.
		*
		* @param[in] reclaimRequestInfo Information about the resource request
		* @param[in] client List of clients to select from.
		* @param[out] targetClients Upon success, this will have the list of identified client(s).
		*
		* @return true on success, false otherwise
		*/
		virtual bool getClients(const ReclaimRequestInfo& reclaimRequestInfo,
		const std::vector<ClientInfo>& clients,
		std::vector<ClientInfo>& targetClients) = 0;
		};

		} // namespace android

		#endif // ANDROID_MEDIA_IRECLAIMPOLICY_H_

services/mediaresourcemanager/IResourceModel.h

0 → 100644

+67 −0

Original line number	Diff line number	Diff line
		/*
		**
		** Copyright 2023, 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.
		*/

		#ifndef ANDROID_MEDIA_IRESOURCEMODEL_H_
		#define ANDROID_MEDIA_IRESOURCEMODEL_H_

		#include <memory>
		#include <vector>

		#include <aidl/android/media/IResourceManagerClient.h>
		#include <aidl/android/media/MediaResourceParcel.h>

		namespace android {

		struct ClientInfo;
		struct ReclaimRequestInfo;

		/*
		* Interface that defines Resource Model.
		*
		* This provides an interface that manages the resource model.
		* The primary functionality of the implementation of this resource model is to:
		* 1. Define a resource model for a device (or family of devices)
		* For example (and not limited to):
		* - Can a secure codec coexist with another secure or unsecured codec?
		* - How many codecs can coexist?
		* - Can one type of codecs (for example avc) coexist with another type of codec
		* (for example hevc) independently? OR are they sharing the common
		* resource pool?
		* 2. Provide a list of clients that hold requesting resources.
		*/
		class IResourceModel {
		public:
		IResourceModel() {}

		virtual ~IResourceModel() {}

		/*
		* Get a list of all clients that holds the resources requested.
		* This implementation uses the ResourceModel to select the clients.
		*
		* @param[in] reclaimRequestInfo Information about the Reclaim request
		* @param[out] clients The list of clients that hold the resources in question.
		*
		* @return true if there aren't any resource conflicts and false otherwise.
		*/
		virtual bool getAllClients(const ReclaimRequestInfo& reclaimRequestInfo,
		std::vector<ClientInfo>& clients) = 0;
		};

		} // namespace android

		#endif // ANDROID_MEDIA_IRESOURCEMODEL_H_