RegisterSet.hpp

// <RegisterSet> -*- C++ -*-
 
#pragma once
 
#include <cstdint>
#include <iostream>
#include <ios>
#include <unordered_map>
#include <functional>
#include <memory>
#include <string>
#include <utility>
#include <vector>
 
#include "sparta/functional/Register.hpp"
#include "sparta/functional/RegisterBankTable.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/StringUtils.hpp"
#include "sparta/functional/ArchData.hpp"
#include "sparta/utils/StringManager.hpp"
 
namespace sparta {
 
class RegisterSet;
 
class RegisterProxyBase
{
public:
    struct Definition
    {
        const Register::ident_type id;
 
        const char *name;
 
        const Register::group_num_type group_num;
 
        const char *group;
 
        const Register::group_idx_type group_idx;
 
        const char *desc;
 
    }; // Definition
 
    static const Definition DEFINITION_END;
};
 
inline bool operator==(const RegisterProxyBase::Definition &a,
                       const RegisterProxyBase::Definition &b)
{
    if (a.id != b.id) {
        return false;
    }
    if (!utils::strcmp_with_null(a.name, b.name)) {
        return false;
    }
    if (a.group_num != b.group_num) {
        return false;
    }
    if (!utils::strcmp_with_null(a.group, b.group)) {
        return false;
    }
    if (a.group_idx != b.group_idx) {
        return false;
    }
    if (!utils::strcmp_with_null(a.desc, b.desc)) {
        return false;
    }
 
    return true;
}
 
inline bool operator!=(const RegisterProxyBase::Definition &a,
                       const RegisterProxyBase::Definition &b)
{
    return !(a == b);
}
 
class RegisterProxy : public RegisterProxyBase
{
public:
    RegisterProxy() = delete;
 
    RegisterProxy(RegisterProxy &&) = delete;
 
    RegisterProxy(const RegisterProxy &) = delete;
 
    RegisterProxy &operator=(const RegisterProxy &) = delete;
 
    RegisterProxy(RegisterBase &reg)
    : rs_(*reg.getParentAs<RegisterSet>())
    , reg_inv_(&reg)
    , group_num_(Register::GROUP_NUM_NONE)
    , group_idx_(Register::GROUP_IDX_NONE)
    , reg_name_(reg.getNamePtr())
    {
        sparta_assert(
            reg_inv_ != nullptr,
            "reg argument of RegisterProxy constructor must not be nullptr")
    }
 
    RegisterProxy(RegisterSet &rs,
                  Register::group_num_type group_num,
                  Register::group_idx_type group_idx,
                  const std::string *managed_name)
    : rs_(rs)
    , reg_inv_(nullptr)
    , group_num_(group_num)
    , group_idx_(group_idx)
    , reg_name_(managed_name)
    {
        sparta_assert(group_num_ != Register::GROUP_NUM_NONE,
                    "group_num argument of RegisterProxy constructor must not "
                    "be GROUP_NUM_NONE");
        sparta_assert(group_idx_ != Register::GROUP_IDX_NONE,
                    "group_idx argument of RegisterProxy constructor must not "
                    "be GROUP_IDX_NONE");
        sparta_assert(reg_name_ != nullptr, "managed_name argument of "
                                          "RegisterProxy constructor must not "
                                          "be nullptr");
        sparta_assert(StringManager::getStringManager().isInterned(managed_name),
                    "managed_name argument of RegisterProxy constructor must "
                    "be a string managed by the StringManager singleton");
    }
 
    ~RegisterProxy()
    {
    }
 
    std::string stringize() const;
 
    RegisterBase *getCurrentRegister() const;
 
    RegisterBase *tryGetCurrentRegister() const;
 
    RegisterSet &getContainingRegisterSet() const;
 
private:
    RegisterSet &rs_;
 
    RegisterBase *reg_inv_;
 
    typename RegisterBase::group_num_type group_num_;
 
    typename RegisterBase::group_idx_type group_idx_;
 
    const std::string *reg_name_;
}; // class RegisterProxy
 
class RegisterSet : public TreeNode
{
public:
 
    static const ArchData::offset_type ARCH_DATA_LINE_SIZE = 512;
 
    using RegisterVector = typename RegisterBankTable<RegisterBase>::RegisterVector;
 
    using GroupVector = typename RegisterBankTable<RegisterBase>::RegisterVector;
 
    typedef std::unordered_map<std::string, std::unique_ptr<RegisterProxy>> RegisterProxyMap;
 
    typedef std::function<
        Register::bank_idx_type(RegisterBase::group_num_type,
                                RegisterBase::group_idx_type,
                                const std::string *name_ptr)>
        CurrentBankFunction;
 
    template <typename RegisterT>
    class RegisterTypeTag
    {
    };
 
    template <typename RegisterT>
    RegisterSet(TreeNode *parent,
                const RegisterBase::Definition *defs,
                const RegisterProxyBase::Definition *proxy_defs,
                CurrentBankFunction cbfxn,
                RegisterTypeTag<RegisterT> tag)
    : TreeNode("regs",
               TreeNode::GROUP_NAME_BUILTIN,
               TreeNode::GROUP_IDX_NONE,
               "Register set")
    , adata_(this,
             ARCH_DATA_LINE_SIZE,
             ArchData::DEFAULT_INITIAL_FILL,
             ArchData::DEFAULT_INITIAL_FILL_SIZE,
             false) // Cannot delete lines
    , cur_bank_fxn_(cbfxn)
    {
        (void)tag;
 
        if(parent){
            setExpectedParent_(parent);
        }
 
        // Add all registers
        const auto *rdef = defs;
        if (rdef != nullptr) {
            while (rdef->name != nullptr) {
                addRegister_<RegisterT>(rdef);
                ++rdef;
            }
        }
 
        // Add all proxies
        const auto *pdef = proxy_defs;
        if (pdef != nullptr) {
            while (pdef->name != nullptr) {
                addProxy_(pdef);
                ++pdef;
            }
        }
 
        // Perform the layout. At this point, no further registers can be added.
        adata_.layout();
 
        if (parent) {
            parent->addChild(this);
        }
    }
 
    template <typename RegisterT>
    RegisterSet(TreeNode *parent,
                const RegisterBase::Definition *defs,
                RegisterTypeTag<RegisterT> tag)
    : RegisterSet(parent, defs, nullptr, nullptr, tag)
    {
        // Handled in delegated consturctor
    }
 
    template <typename RegisterT = Register>
    static std::unique_ptr<RegisterSet>
    create(TreeNode *parent,
           const RegisterBase::Definition *defs,
           const RegisterProxyBase::Definition *proxy_defs,
           CurrentBankFunction cbfxn)
    {
        return std::unique_ptr<RegisterSet>(new RegisterSet(
            parent, defs, proxy_defs, cbfxn, RegisterTypeTag<RegisterT>()));
    }
 
    template <typename RegisterT = Register>
    static std::unique_ptr<RegisterSet>
    create(TreeNode *parent, const RegisterBase::Definition *defs)
    {
        return std::unique_ptr<RegisterSet>(new RegisterSet(
            parent, defs, RegisterTypeTag<RegisterT>()));
    }
 
    ~RegisterSet()
    {
        for (auto r : owned_regs_) {
            delete r;
        }
    }
 
    void reset() {
        for (uint32_t i=0; i<regs_.size(); i++) {
            regs_[i]->reset();
        }
    }
 
    void setMinimumBankIndex(RegisterBase::bank_idx_type min_idx) {
        banks_.setMinimumBankIndex(min_idx);
    }
 
    uint32_t getNumRegisters() const { return regs_.size(); }
 
    RegisterBase::bank_idx_type getNumBanks() const
    {
        return banks_.getNumBanks();
    }
 
    RegisterBase::group_idx_type getNumGroups() const
    {
        return banks_.getNumGroups();
    }
 
    const RegisterVector& getRegisters() const { return regs_; }
 
    // Overload of TreeNode::stringize
    virtual std::string stringize(bool pretty=false) const override {
        (void) pretty;
        std::stringstream ss;
        ss << '<' << getLocation() << ' ' << regs_.size() << " regs>";
        return ss.str();
    }
 
    void dumpBanks(std::ostream& out) const {
        banks_.dump(out);
    }
 
    RegisterBase *getRegister(const std::string &name)
    {
        return getChildAs<RegisterBase>(name);
    }
 
    RegisterProxy &getRegisterProxy(const std::string &name)
    {
        auto rpi = reg_proxies_.find(name);
        if(rpi != reg_proxies_.end()){
            return *(rpi->second.get());
        }
        auto r = getChildAs<RegisterBase>(name, false);
        if(!r){
            throw SpartaException("Could not get register proxy from ") << getLocation()
                  << " named \"" << name << "\" because there was no existing proxy and no "
                  "register with this name.";
        }
        reg_proxies_[name] =
            typename RegisterProxyMap::mapped_type(new RegisterProxy(*r));
        return *reg_proxies_[name];
    }
 
    bool canLookupRegister(RegisterBase::group_num_type group_num,
                           RegisterBase::group_idx_type group_idx) const noexcept
    {
        return banks_.canLookupRegister(group_num, group_idx, RegisterBase::BANK_IDX_DEFAULT);
    }
 
    bool canLookupRegister(RegisterBase::group_num_type group_num,
                           RegisterBase::group_idx_type group_idx,
                           RegisterBase::bank_idx_type bank_idx) const noexcept
    {
        return banks_.canLookupRegister(group_num, group_idx, bank_idx);
    }
 
    RegisterBase *lookupRegister(RegisterBase::group_num_type group_num,
                                 RegisterBase::group_idx_type group_idx)
    {
        const auto &rm = banks_[RegisterBase::BANK_IDX_DEFAULT][group_num];
        const auto idx_count = rm.count(group_idx);
        if (idx_count==1) {
            sparta_assert(rm.at(group_idx) != nullptr);
        }
        return (idx_count==1 ? rm.at(group_idx) : nullptr);
    }
 
    RegisterBase *lookupRegister(RegisterBase::group_num_type group_num,
                                 RegisterBase::group_idx_type group_idx,
                                 RegisterBase::bank_idx_type bank_idx)
    {
        const auto &rm = banks_[bank_idx][group_num];
        const auto idx_count = rm.count(group_idx);
        if (idx_count==1) {
            sparta_assert(rm.at(group_idx) != nullptr);
        }
        return (idx_count==1 ? rm.at(group_idx) : nullptr);
    }
 
    RegisterBase *getRegister(RegisterBase::group_num_type group_num,
                              RegisterBase::group_idx_type group_idx)
    {
        return banks_.getRegister(group_num, group_idx, RegisterBase::BANK_IDX_DEFAULT);
    }
 
    RegisterBase *getRegister(RegisterBase::group_num_type group_num,
                              RegisterBase::group_idx_type group_idx,
                              RegisterBase::bank_idx_type bank_idx)
    {
        return banks_.getRegister(group_num, group_idx, bank_idx);
    }
 
    uint32_t getGroupSize(RegisterBase::group_num_type group_num) noexcept
    {
        return banks_.getGroupSize(group_num, RegisterBase::BANK_IDX_DEFAULT);
    }
 
    uint32_t getGroupSize(RegisterBase::group_num_type group_num,
                          RegisterBase::bank_idx_type bank_num)
    {
        return banks_.getGroupSize(group_num, bank_num);
    }
 
    RegisterBase::bank_idx_type
    getCurrentBank(RegisterBase::group_num_type group_num,
                   RegisterBase::group_idx_type group_idx,
                   const std::string *name_ptr) const
    {
        if (cur_bank_fxn_ == nullptr) {
            return RegisterBase::BANK_IDX_DEFAULT;
        }
        return cur_bank_fxn_(group_num, group_idx, name_ptr);
    }
 
private:
    virtual void onAddingChild_(TreeNode *child) override
    {
        auto reg = dynamic_cast<RegisterBase *>(child);
        if (nullptr == reg) {
            throw SpartaException("Cannot add TreeNode child at ")
                << child << " which is not a Register to RegisterSet "
                << getLocation();
        }
 
        // Add register to regs_ list for tracking.
        regs_.push_back(reg);
    }
 
    template <typename RegisterT>
    void addRegister_(const RegisterBase::Definition *rdef)
    {
        sparta_assert(false == adata_.isLaidOut());// Cannot addRegister_ after the ArchData has been layed out
        sparta_assert(reg_proxies_.size() == 0); // Cannot addRegister_ once a proxy has been added
        auto r = new RegisterT(nullptr, *rdef, &adata_);
 
        // Attempt to insert the register into the bank table
        banks_.addRegister(r); // Throws if unable to add
 
        // Finally add register as child after it is validated
        this->addChild(r);
        owned_regs_.push_back(r);
    }
 
 
    void addProxy_(const RegisterProxyBase::Definition *pdef)
    {
        sparta_assert(pdef,
                          "Attempted to add a RegisterProxy to RegisterSet " << getLocation()
                          << " with a null proxy definition");
 
        // Check fields of the definition
        sparta_assert(pdef->name,
                          "Attempted to add a RegisterProxy to RegisterSet " << getLocation()
                          << " with a null proxy name");
        sparta_assert(pdef->desc,
                          "Attempted to add a RegisterProxy to RegisterSet " << getLocation()
                           << " named \"" << pdef->name << "\" with a null proxy description");
        sparta_assert(pdef->group_num != Register::GROUP_NUM_NONE,
                          "Attempted to add a RegisterProxy to RegisterSet " << getLocation()
                          << " named \"" << pdef->name << "\" with a group number of "
                          "GROUP_NUM_NONE. RegisterProxy definitions must have a valid group number");
        sparta_assert(pdef->group_idx != Register::GROUP_IDX_NONE,
                          "Attempted to add a RegisterProxy to RegisterSet " << getLocation()
                          << " named \"" << pdef->name << "\" with a group number of "
                          "GROUP_NUM_NONE. RegisterProxy definitions must have a valid group number");
 
        // Check ID conflicts with other proxies and registers
        for(auto& reg : regs_){
            sparta_assert(reg->getID() != pdef->id,
                              "Attempted to add a RegisterProxy to RegisterSet " << getLocation()
                              << " named \"" << pdef->name << "\" with an ID of " << pdef->id
                              << " which is already usd by Register " << reg);
        }
 
        // Check for a register with the same name
        auto reg_samename = getChildAs<RegisterBase>(pdef->name, false);
        sparta_assert(reg_samename == nullptr,
                          "Attempted to add a RegisterProxy to RegisterSet " << getLocation()
                           << " named \"" << pdef->name << "\" but there is already a normal "
                           "Register with the same name: " << reg_samename->getLocation());
 
        // Check for an existing proxy
        auto rpi = reg_proxies_.find(pdef->name);
        if(rpi != reg_proxies_.end()){
            throw SpartaException("A RegisterProxy in ") << getLocation()
                  << " named \"" << pdef->name << "\" already exists";
        }
 
 
        uint32_t matches = 0;
        for(uint32_t b = 0; b < banks_.getNumBanks(); b++){
            if(banks_.canLookupRegister(pdef->group_num, pdef->group_idx, b)){
                auto r = banks_.lookupRegister(pdef->group_num, pdef->group_idx, b);
 
                // Sanity check lookup
                sparta_assert(r);
                sparta_assert(r->getGroupNum() == pdef->group_num);
                sparta_assert(r->getGroupIdx() == pdef->group_idx);
 
                // Ensure that the group name matches
                sparta_assert(r->getGroupName() == pdef->group,
                                  "Attempted to add a RegisterProxy to RegisterSet "
                                  << getLocation() << " named \"" << pdef->name << "\" which matched "
                                  "the group number and group index with " << *r << " but the "
                                  "proxy had an incorrect group name \"" << pdef->group << "\"");
 
                matches++;
            }
        }
 
        // Ensure that one register matches
        sparta_assert(matches > 0,
                          "Attempted to add a RegisterProxy to RegisterSet "
                          << getLocation() << " named \"" << pdef->name << "\" with group num "
                          << pdef->group_num << " and group idx " << pdef->group_idx << " which did "
                          "not match any known registers");
 
        // Finally add the proxy
        auto rp = new RegisterProxy(*this,
                                    pdef->group_num,
                                    pdef->group_idx,
                                    StringManager::getStringManager().internString(pdef->name));
        reg_proxies_[pdef->name] = typename RegisterProxyMap::mapped_type(rp); // Takes ownership of memory
    }
 
    ArchData adata_;
 
    RegisterVector owned_regs_;
 
    RegisterVector regs_;
 
    RegisterBankTable<RegisterBase> banks_;
 
    RegisterProxyMap reg_proxies_;
 
    CurrentBankFunction cur_bank_fxn_;
 
}; // class RegisterSet
 
inline std::string RegisterProxy::stringize() const
{
    std::stringstream ss;
    ss << "<RegisterProxy to ";
    if (reg_inv_) {
        ss << reg_inv_;
    } else {
        ss << "name: \"" << reg_name_ << "\" group: " << group_num_
           << " idx: " << group_idx_;
    }
    ss << " within " << rs_.getLocation() << ">";
    return ss.str();
}
 
inline RegisterBase *RegisterProxy::getCurrentRegister() const
{
    if (reg_inv_ != nullptr) {
        return reg_inv_;
    }
 
    auto bank_idx = rs_.getCurrentBank(group_num_, group_idx_, reg_name_);
    return rs_.getRegister(group_num_, group_idx_, bank_idx);
}
 
inline RegisterBase *RegisterProxy::tryGetCurrentRegister() const
{
    if (reg_inv_ != nullptr) {
        return reg_inv_;
    }
 
    auto bank_idx = rs_.getCurrentBank(group_num_, group_idx_, reg_name_);
    if (!rs_.canLookupRegister(group_num_, group_idx_, bank_idx)) {
        return nullptr;
    }
    return rs_.lookupRegister(group_num_, group_idx_, bank_idx);
}
 
inline RegisterSet &RegisterProxy::getContainingRegisterSet() const
{
    return rs_;
}
 
} // namespace sparta
 
inline std::ostream &operator<<(std::ostream &o, const sparta::RegisterProxy &rp)
{
    o << rp.stringize();
    return o;
}
 
inline std::ostream &operator<<(std::ostream &o, const sparta::RegisterProxy *rp)
{
    if (nullptr == rp) {
        o << "null";
    } else {
        o << rp->stringize();
    }
    return o;
}
 
inline std::ostream& operator<<(std::ostream& o, const sparta::RegisterSet &rs)
{
    o << rs.stringize();
    return o;
}
 
inline std::ostream &operator<<(std::ostream &o, const sparta::RegisterSet *rs)
{
    if(nullptr == rs){
        o << "null";
    }else{
        o << rs->stringize();
    }
    return o;
}