CPUTopology.hpp

// <CPUTopology.h> -*- C++ -*-
 
 
#pragma once
 
#include <memory>
 
#include "CPU.hpp"
#include "CPUFactories.hpp"
#include "sparta/simulation/ResourceFactory.hpp"
#include "sparta/simulation/RootTreeNode.hpp"
#include "sparta/simulation/ResourceTreeNode.hpp"
 
namespace core_example{
 
class CPUTopology{
public:
 
    struct UnitInfo{
 
        std::string name;
 
        std::string parent_name;
 
        std::string human_name;
 
        std::string group_name;
 
        uint32_t group_id;
 
        sparta::ResourceFactoryBase* factory;
 
        bool is_private_subtree;
 
        UnitInfo(const std::string& name,
                 const std::string& parent_name,
                 const std::string& human_name,
                 const std::string&  group_name,
                 const uint32_t group_id,
                 sparta::ResourceFactoryBase* factory,
                 bool is_private_subtree = false) :
            name{name},
            parent_name{parent_name},
            human_name{human_name},
            group_name{group_name},
            group_id{group_id},
            factory{factory},
            is_private_subtree{is_private_subtree}{}
    };
 
    struct PortConnectionInfo{
 
        std::string output_port_name;
 
        std::string input_port_name;
 
        PortConnectionInfo(const std::string& output_port_name,
                           const std::string& input_port_name) :
            output_port_name{output_port_name},
            input_port_name{input_port_name}{}
    };
 
    CPUTopology() : factories{new CPUFactories()}{}
 
    auto setName(const std::string& topology) -> void{
        topology_name = topology;
    }
 
    auto setNumCores(const uint32_t num_of_cores) -> void{
        num_cores = num_of_cores;
    }
 
    static auto allocateTopology(const std::string& topology) -> CPUTopology*;
 
    uint32_t num_cores;
    std::unique_ptr<CPUFactories> factories;
    std::string topology_name;
    std::vector<UnitInfo> units;
    std::vector<PortConnectionInfo> port_connections;
}; // class CPUTopology
 
class CoreTopology_1 : public CPUTopology{
public:
 
    CoreTopology_1();
}; // class CoreTopology_1
}  // namespace core_example