RequestManager.h

// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// SPDX-License-Identifier: BSD-3-Clause-Clear
 
#ifndef REQUEST_MANAGER_H
#define REQUEST_MANAGER_H
 
#include <unordered_set>
#include <unordered_map>
#include <memory>
 
#include "Request.h"
#include "CocoTable.h"
#include "ClientDataManager.h"
 
typedef std::pair<Request*, int8_t> RequestInfo;
 
enum RequestListType {
    ACTIVE_TUNE = 0,
    PENDING_TUNE,
};
 
enum RequestProcessingStatus : int8_t {
    REQ_UNCHANGED = 0x01,
    REQ_CANCELLED = 0x02,
    REQ_COMPLETED = 0x04,
    REQ_NOT_FOUND = 0x08,
};
 
class RequestManager {
private:
    static std::shared_ptr<RequestManager> mReqeustManagerInstance;
    static std::mutex instanceProtectionLock;
 
    int64_t mTotalRequestServed;
    std::unordered_set<Request*> mRequestsList[2];
    std::unordered_map<int64_t, RequestInfo> mActiveRequests;
    MinLRUCache mUntuneCache;
    std::shared_timed_mutex mRequestMapMutex;
 
    RequestManager();
 
    int8_t checkOwnership(Request* request, Request* targetRequest);
    int8_t isSane(Request* request);
    int8_t requestMatch(Request* request);
 
public:
    ~RequestManager();
 
    int8_t verifyHandle(int64_t handle);
 
    int8_t shouldRequestBeAdded(Request* request);
 
    int8_t addRequest(Request* request);
 
    void removeRequest(Request* request);
 
    RequestInfo getRequestFromMap(int64_t handle);
 
    int64_t getActiveReqeustsCount();
 
    int8_t disableRequestProcessing(int64_t handle);
 
    void markRequestAsComplete(int64_t handle);
 
    int8_t getRequestProcessingStatus(int64_t handle);
 
    std::vector<Request*> getPendingList();
 
    void moveToPendingList();
 
    void clearPending();
 
    static std::shared_ptr<RequestManager> getInstance() {
        if(mReqeustManagerInstance == nullptr) {
            instanceProtectionLock.lock();
            if(mReqeustManagerInstance == nullptr) {
                try {
                    mReqeustManagerInstance = std::shared_ptr<RequestManager> (new RequestManager());
                } catch(const std::bad_alloc& e) {
                    instanceProtectionLock.unlock();
                    return nullptr;
                }
            }
            instanceProtectionLock.unlock();
        }
        return mReqeustManagerInstance;
    }
};
 
#endif