Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit e9e62c53 authored by Girish Shetty's avatar Girish Shetty Committed by Gerrit Code Review
Browse files

Merge changes from topic "rm_refactor_last_batch" into main 

* changes:
  resourcemanager: define reclaim policy
  resourcemanager: define resource model
  resourcemanager: refactor resource map into an abstraction
  resourcemanager: new implementation of resourcemanager
parents c5f2ca78 6c16adb3

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_