CocoTable.h

Go to the documentation of this file.

// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// SPDX-License-Identifier: BSD-3-Clause-Clear
 
#ifndef COCOQ_H
#define COCOQ_H
 
#include <fstream>
#include <vector>
#include <unordered_map>
#include <mutex>
#include <cerrno>
#include <atomic>
#include <cstring>
#include <memory>
 
#include "ResourceRegistry.h"
#include "TargetRegistry.h"
#include "Request.h"
#include "RequestQueue.h"
#include "ResourceTunerSettings.h"
#include "MemoryPool.h"
#include "Logger.h"
#include "Utils.h"
 
class CocoTable {
private:
    static std::shared_ptr<CocoTable> mCocoTableInstance;
    static std::mutex instanceProtectionLock;
 
    std::vector<ResourceConfigInfo*> mResourceTable;
    std::unordered_map<int32_t, int32_t> mFlatClusterMap;
 
    std::vector<std::vector<std::pair<CocoNode*, CocoNode*>>> mCocoTable;
 
    std::vector<int32_t> mCurrentlyAppliedPriority;
 
    CocoTable();
 
    void timerExpired(Request* req);
    void applyAction(CocoNode* currNode, int32_t index, int8_t priority);
    void removeAction(int32_t index, Resource* resource);
    void processResourceCleanupAt(Request* request, int32_t index);
 
    int32_t getCocoTablePrimaryIndex(uint32_t resCode);
    int32_t getCocoTableSecondaryIndex(Resource* resource, int8_t priority);
 
    void deleteNode(CocoNode* node,
                    int32_t primaryIndex,
                    int32_t secondaryIndex,
                    int8_t priority);
 
    int8_t insertInCocoTable(CocoNode* currNode,
                             Resource* resource,
                             int8_t priority);
 
    void insertInCocoTableHigherLower(CocoNode* newNode,
                                      int32_t primaryIndex,
                                      int32_t secondaryIndex,
                                      int32_t policy,
                                      int8_t priority);
 
    void insertInCocoTableLazyApply(CocoNode* newNode,
                                    int32_t primaryIndex,
                                    int32_t secondaryIndex,
                                    int8_t priority);
 
    void insertInCocoTableInstantApply(CocoNode* newNode,
                                       int32_t primaryIndex,
                                       int32_t secondaryIndex,
                                       int8_t priority);
 
public:
    ~CocoTable();
 
    int8_t insertRequest(Request* req);
 
    int8_t removeRequest(Request* req);
 
    int8_t updateRequest(Request* req, int64_t duration);
 
    static std::shared_ptr<CocoTable> getInstance() {
        if(mCocoTableInstance == nullptr) {
            instanceProtectionLock.lock();
            if(mCocoTableInstance == nullptr) {
                try {
                    mCocoTableInstance = std::shared_ptr<CocoTable> (new CocoTable());
                } catch(const std::bad_alloc& e) {
                    instanceProtectionLock.unlock();
                    return nullptr;
                }
            }
            instanceProtectionLock.unlock();
        }
        return mCocoTableInstance;
    }
};
 
#endif