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 "UrmSettings.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<ResConfInfo*> mResourceTable;
    std::unordered_map<int32_t, int32_t> mFlatClusterMap;
    std::unordered_map<int32_t, int32_t> mFlatCGroupMap;
 
    std::shared_ptr<ResourceRegistry> mResourceRegistry;
 
    std::vector<std::vector<DLManager*>> mCocoTable;
 
    std::vector<int32_t> mCurrentlyAppliedPriority;
 
    CocoTable();
 
    void timerExpired(Request* req);
    void applyAction(ResIterable* currNode, int32_t index, int8_t priority);
    void removeAction(int32_t index, Resource* resource);
 
    int32_t getCocoTablePrimaryIndex(uint32_t resCode);
    int32_t getCocoTableSecondaryIndex(Resource* resource, int8_t priority);
 
    void deleteNode(ResIterable* node,
                    int32_t primaryIndex,
                    int32_t secondaryIndex);
 
    int8_t insertInCocoTable(ResIterable* currNode, int8_t priority);
 
    void fastPathApply(Resource* resource);
    void fastPathReset(Resource* resource);
    int8_t needAllocation(Resource* res);
 
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