TargetRegistry.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 TARGET_REGISTRY_H
#define TARGET_REGISTRY_H
 
#include <regex>
#include <memory>
#include <vector>
#include <cstring>
#include <sstream>
#include <fstream>
#include <cstdlib>
#include <dirent.h>
#include <algorithm>
#include <sys/stat.h>
#include <unordered_map>
 
#include "Logger.h"
#include "ErrCodes.h"
#include "AuxRoutines.h"
 
#define POLICY_DIR_PATH "/sys/devices/system/cpu/cpufreq/"
#define ONLINE_CPU_FILE_PATH "/sys/devices/system/cpu/online"
#define CPU_CAPACITY_FILE_PATH "/sys/devices/system/cpu/cpu%d/cpu_capacity"
 
enum TargetQueries {
    GET_MASK = 801,
    GET_CLUSTER_COUNT,
    GET_CORE_COUNT,
    GET_PHYSICAL_CLUSTER_ID,
    GET_PHYSICAL_CORE_ID,
    GET_MAX_CLUSTER,
};
 
typedef struct {
    std::string mCgroupName; 
    int32_t mCgroupID;  
    int8_t mCreationNeeded; 
    int8_t mIsThreaded; 
} CGroupConfigInfo;
 
typedef struct {
    int32_t mPhysicalID; 
    int32_t mCapacity; 
    int32_t mStartCpu; 
    int32_t mNumCpus; 
} ClusterInfo;
 
typedef struct {
    int32_t mMpamGroupInfoID; 
    std::string mMpamGroupName; 
    int32_t mPriority; 
} MpamGroupConfigInfo;
 
typedef struct {
    std::string mCacheType; 
    int32_t mNumCacheBlocks; 
    int8_t mPriorityAware; 
} CacheInfo;
 
class TargetRegistry {
private:
    static std::shared_ptr<TargetRegistry> targetRegistryInstance;
 
    std::unordered_map<int32_t, int32_t> mLogicalToPhysicalClusterMapping;
    std::unordered_map<int32_t, ClusterInfo*> mPhysicalClusters;
    std::unordered_map<int32_t, CGroupConfigInfo*> mCGroupMapping;
    std::unordered_map<int32_t, MpamGroupConfigInfo*> mMpamGroupMapping;
    std::unordered_map<std::string, CacheInfo*> mCacheInfoMapping;
 
    TargetRegistry();
 
    void generatePolicyBasedMapping(std::vector<std::string>& policyDirs);
    void getClusterIdBasedMapping();
 
public:
    ~TargetRegistry();
 
    // Methods for adding Target Info via TargetConfig.yaml
    void addClusterSpreadInfo(const std::string& physicalID, const std::string& coreCount);
    void addClusterMapping(const std::string& logicalID, const std::string& physicalID);
 
    // Method for adding CGroup configs from InitConfig.yaml
    void addCGroupMapping(CGroupConfigInfo* cGroupConfigInfo);
 
    // Method for adding Mpam Group configs from InitConfig.yaml
    void addMpamGroupMapping(MpamGroupConfigInfo* mpamGroupConfigInfo);
 
    void addCacheInfoMapping(CacheInfo* cacheInfo);
 
    void getClusterIDs(std::vector<int32_t>& clusterIDs);
 
    int32_t getPhysicalCoreId(int32_t logicalClusterId, int32_t logicalCoreId);
 
    int32_t getPhysicalClusterId(int32_t logicalClusterId);
 
    ClusterInfo* getClusterInfo(int32_t physicalClusterID);
 
    void readTargetInfo();
 
    CGroupConfigInfo* getCGroupConfig(int32_t cGroupID);
    void getCGroupNames(std::vector<std::string>& cGroupNames);
    void getCGroupConfigs(std::vector<CGroupConfigInfo*>& cGroupConfigs);
    int32_t getCreatedCGroupsCount();
 
    MpamGroupConfigInfo* getMpamGroupConfig(int32_t mpamGroupID);
    void getMpamGroupNames(std::vector<std::string>& cGroupNames);
    int32_t getCreatedMpamGroupsCount();
 
    void displayTargetInfo();
 
    ErrCode addIrqAffine(std::vector<std::string>& values,
                         int8_t areClusterValues = false);
    ErrCode addLogLimit(std::vector<std::string>& values);
 
    static std::shared_ptr<TargetRegistry> getInstance() {
        if(targetRegistryInstance == nullptr) {
            targetRegistryInstance = std::shared_ptr<TargetRegistry>(new TargetRegistry());
        }
        return targetRegistryInstance;
    }
};
 
class CGroupConfigInfoBuilder {
private:
    CGroupConfigInfo* mCGroupConfigInfo;
 
public:
    CGroupConfigInfoBuilder();
 
    ErrCode setCGroupName(const std::string& cGroupName);
    ErrCode setCGroupID(const std::string& cGroupIdentifier);
    ErrCode setCreationNeeded(const std::string& creationNeeded);
    ErrCode setThreaded(const std::string& isThreaded);
 
    CGroupConfigInfo* build();
};
 
class MpamGroupConfigInfoBuilder {
private:
    MpamGroupConfigInfo* mMpamGroupInfo;
 
public:
    MpamGroupConfigInfoBuilder();
 
    ErrCode setName(const std::string& name);
    ErrCode setLgcID(const std::string& logicalID);
    ErrCode setPriority(const std::string& priority);
 
    MpamGroupConfigInfo* build();
};
 
class CacheInfoBuilder {
private:
    CacheInfo* mCacheInfo;
 
public:
    CacheInfoBuilder();
 
    ErrCode setType(const std::string& type);
    ErrCode setNumBlocks(const std::string& numBlocks);
    ErrCode setPriorityAware(const std::string& isPriorityAware);
 
    CacheInfo* build();
};
 
// Utility to fetch target-specific information
uint64_t GET_TARGET_INFO(int32_t option,
                         int32_t numArgs,
                         int32_t* args);
 
#endif