ParameterSet.hpp

Go to the documentation of this file.

// <ParameterSet> -*- C++ -*-
 
#pragma once
 
#include <iostream>
#include <iomanip>
#include <string>
#include <ostream>
#include <vector>
#include <unordered_map>
 
#include "sparta/utils/Utils.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/simulation/Parameter.hpp"
 
namespace sparta
{
    class ParameterTree;
 
    class ParameterSet : public TreeNode
    {
        friend class ParameterBase; 
 
    public:
        ParameterSet* __this_ps;
 
        ParameterSet() = delete; 
        ParameterSet(const ParameterSet& rhp) = delete; 
        void operator=(const ParameterSet& rhp) = delete; 
 
        static constexpr char NODE_NAME[] = "params";
 
        static constexpr char PARAMETER_SET_NODE_TAG[] = "SPARTA_ParameterSet";
 
        typedef std::vector<sparta::ParameterBase*> ParameterVector;
 
        typedef std::unordered_map<std::string, ParameterBase*> ParameterPairs;
 
        ParameterSet(TreeNode* parent) :
            TreeNode(NODE_NAME,
                     TreeNode::GROUP_NAME_BUILTIN,
                     TreeNode::GROUP_IDX_NONE,
                     "Parameter set"),
            __this_ps(this)
        {
            addTag(PARAMETER_SET_NODE_TAG); // Tag for easier searching
 
            if(parent){
                // Do not inherit parent phase yet if finalizing
                const bool inherit_phase = parent->getPhase() < TREE_FINALIZING;
                parent->addChild(this, inherit_phase);
            }
        }
 
        virtual ~ParameterSet() = default;
 
        bool validateIndependently(std::string& err_names) const
        {
            bool success = true;
            for(const ParameterPairs::value_type& p : keys_){
                std::string temp;
                if(!p.second->validateIndependently(temp)){
                    err_names += p.second->stringize();
                    err_names += ": ";
                    err_names += temp;
                    err_names += '\n';
                    success = false;
                }
            }
            return success;
        }
 
        bool validateDependencies(const TreeNode* node, std::string& err_names) const
        {
            bool success = true;
            for(const ParameterPairs::value_type& p : keys_){
                std::string temp;
                if(!p.second->validateDependencies(node, temp)){
                    err_names += p.second->stringize();
                    err_names += ": ";
                    err_names += temp;
                    err_names += '\n';
                    success = false;
                }
            }
            return success;
        }
 
        void resetReadCounts() {
            for(ParameterPairs::value_type & pair : keys_) {
                pair.second->resetReadCount_();
            }
        }
 
        void resetWriteCounts() {
            for(ParameterPairs::value_type & pair : keys_) {
                pair.second->resetWriteCount_();
            }
        }
 
        void verifyAllRead() const {
            std::stringstream errors;
            bool err = false;
            for(const ParameterPairs::value_type& p : keys_){
                if(not p.second->isReadOrIgnored()){
                    if(err){
                        errors << ", ";
                    }
                    errors << p.second->getName();
                    err = true;
                }
            }
 
            if(err){
                throw ParameterException("Some parameters in ParameterSet \"")
                    << getLocation() << "\" have not been read: " << errors.str()
                    << " . A sparta::Resource must read all of its parameters or explicitly "
                    ".ignore() them";
            }
        }
 
        void ignoreAll() const {
            for(const ParameterPairs::value_type& p : keys_){
                p.second->ignore_();
            }
        }
 
        virtual std::string dumpList() const {
            std::stringstream ss;
            ss << "Parameters for " << getLocation() << ":\n";
 
            // Determine column sizes
            uint32_t col_sizes[] = {0, 0, 0, 0, 0};
            for(const ParameterPairs::value_type& p : keys_){
                col_sizes[0] = std::max<uint32_t>(p.second->getTypeName().size(), col_sizes[0]);
                col_sizes[1] = std::max<uint32_t>(p.second->getName().size(), col_sizes[1]);
                col_sizes[2] = std::max<uint32_t>(p.second->getValueAsString().size(), col_sizes[2]);
                col_sizes[3] = std::max<uint32_t>(p.second->getDefaultAsString().size(), col_sizes[3]);
                col_sizes[4] = std::max<uint32_t>(numDecDigits(p.second->getReadCount()), col_sizes[4]);
            }
 
            // Render table with constant column size (type, key, value, default, read: num_reads)
            for(const ParameterPairs::value_type& p : keys_){
                const ParameterBase* pb = p.second;
                if(!pb->isVisibilityAllowed()){
                    continue;
                }
                ss << "  ";
                ss << '('
                   << std::setiosflags(std::ios::left) << std::setw(col_sizes[0]) << pb->getTypeName() << " "
                   << std::setiosflags(std::ios::left) << std::setw(col_sizes[1]) << pb->getName() << " : "
                   << std::setiosflags(std::ios::left) << std::setw(col_sizes[2]) << pb->getValueAsString() << ", def="
                   << std::setiosflags(std::ios::left) << std::setw(col_sizes[3]) << pb->getDefaultAsString()
                   << " read: " << std::setiosflags(std::ios::left) << std::setw(col_sizes[4]) << pb->getReadCount()
                   << ')';
 
                ss << '\n';
            }
 
            return ss.str();
        }
 
        // Overload of TreeNode::stringize
        virtual std::string stringize(bool pretty=false) const override {
            (void) pretty;
            std::stringstream ss;
            ss << '<' << getLocation() << ' ' << keys_.size() << " params>";
            return ss.str();
        }
 
        template <class T>
        const T getParameterValueAs(const std::string& name) const {
            ParameterPairs::const_iterator itr = keys_.find(name);
            if(keys_.end() == itr){
                throw ParameterException("Could not get parameter by name \"")
                    << name << "\". No parameter by that name exists.";
            }
            ParameterBase* pb = itr->second;
            sparta_assert(pb != nullptr);
            return pb->getValueAs<T>();
        }
 
        template <class ContentT>
        const Parameter<ContentT>& getParameterAs(const std::string& name) const {
            const ParameterBase* pb = getParameter(name, true);
            Parameter<ContentT>* p = dynamic_cast<const Parameter<ContentT>*>(pb);
            if(!p){
                throw SpartaException("Found parameter \"") << name << "\" in ParameterSet "
                    << getLocation() << " but Parameter was not of requested type \""
                    << demangle(typeid(ContentT).name()) << "\". Was instead \""
                    << pb->getTypeName() << "\". ";
            }
            return *p;
        }
 
        // Overload of getParameterAs for non-const access with a pointer ContentT type
        template <class ContentT>
        Parameter<ContentT>& getParameterAs(const std::string& name) {
            ParameterBase* pb = getParameter(name, true);
            Parameter<ContentT>* p = dynamic_cast<Parameter<ContentT>*>(pb);
            if(!p){
                throw SpartaException("Found parameter \"") << name << "\" in ParameterSet "
                    << getLocation() << " but Parameter was not of requested type \""
                    << demangle(typeid(ContentT).name()) << "\". Was instead \""
                    << pb->getTypeName() << "\". ";
            }
            return *p;
        }
 
        ParameterBase* getParameter(const std::string& name, bool must_exist=true) {
            return getChildAs<ParameterBase>(name, must_exist);
        }
 
        const ParameterBase* getParameter(const std::string& name, bool must_exist=true) const {
            return getChildAs<ParameterBase>(name, must_exist);
        }
 
        uint32_t findParameters(const std::string& name,
                                std::vector<ParameterBase*>& results) {
            std::vector<TreeNode*> nodes;
            TreeNode::findChildren(name, nodes);
            uint32_t num_found = 0;
            for(TreeNode* node : nodes){
                ParameterBase* p = dynamic_cast<ParameterBase*>(node);
                if(p != nullptr){
                    results.push_back(p);
                    ++num_found;
                }else{
                    std::cerr << "Could not cast node " << node->getLocation() << " to ParameterBase*" << std::endl;
                }
            }
            return num_found;
        }
 
        bool hasParameter(const std::string& name) const {
            ParameterPairs::const_iterator itr = keys_.find(name);
            return itr != keys_.end();
        }
 
        static inline uint32_t getNumBoundTypes() {
            return (uint32_t)KeyValue::GBL_type_name_map.size();
        }
 
        bool hasModificationPermission(const ParameterBase * modifying_param,
                                       std::vector<const ParameterBase *> params) const
        {
            for(const auto & param : params)
            {
                sparta_assert(param != modifying_param);
 
                bool hit_modifier = false;
                for(const auto & it : params_) {
                    if(it == param) {
                        sparta_assert(hit_modifier == true, "Parameter: '"
                                          << it->getName() << "' cannot modifiy '" << param->getName()
                                          << "' because '" << it->getName()
                                          << "' does not come before '" << param->getName()
                                          << "' in the parameter set");
                        return (hit_modifier == true);
                    }
                    if(it == modifying_param) {
                        hit_modifier = true;
                    }
                }
            }
            return true;
        }
 
        bool canParameterBeModifiedByLockingParam(const ParameterBase * modify_e) {
            if(locking_params_stack_.empty()) {
                return true;
            }
            sparta_assert(locking_params_stack_.back() != modify_e,
                              "Parameter '" << locking_params_stack_.back()->getName()
                              << "' cannot modify itself in it's own callback!");
            return hasModificationPermission(locking_params_stack_.back(), {modify_e});
        }
 
        void lock(const ParameterBase * lock_param);
 
        bool isLocked() const {
            return (locking_params_stack_.empty() == false);
        }
 
        void unlock(const ParameterBase * unlock_param);
 
        template<typename T>
        class ParameterSetIterator
        {
        public:
            ParameterSetIterator() :
                keys_(0), key_iter_(ParameterPairs::iterator())
            {
            }
 
            ParameterSetIterator(ParameterPairs const * keys, T const & itr) :
                keys_(keys), key_iter_(itr)
            {
                sparta_assert(keys != 0); // Cannot create without a valid keys map
            }
 
            ParameterSetIterator(const ParameterSetIterator& rhp) :
                keys_(rhp.keys_), key_iter_(rhp.key_iter_)
            {}
 
            const ParameterSetIterator& operator=(const ParameterSetIterator& rhp)
            {
                keys_ = rhp.keys_;
                key_iter_ = rhp.key_iter_;
                return *this;
            }
 
            // Prefix
            const ParameterSetIterator& operator++()
            {
                // There is a bug in boost that prevents gcc from compiling this
                // with -Werror=sequence-point on.
                ++key_iter_;
                return *this;
            }
 
            // Postfix
            const ParameterSetIterator operator++(int i)
            {
                (void) i;
                ParameterSetIterator current = *this;
                ++(*this);
                return current;
            }
 
            ParameterBase* operator*(){
                if(keys_ == 0){
                    throw ParameterException("Iterator has not been initialized");
                }
                if(key_iter_ == keys_->end()){
                    throw ParameterException("Iterator has reached end and is invalid");
                }
                return key_iter_->second;
            }
 
            const ParameterBase * operator*() const {
                if(keys_ == 0){
                    throw ParameterException("Iterator has not been initialized");
                }
                if(key_iter_ == keys_->end()){
                    throw ParameterException("Iterator has reached end and is invalid");
                }
                return key_iter_->second;
            }
 
            bool operator==(const ParameterSetIterator& rhp) const {
                return key_iter_ == rhp.key_iter_;
            }
 
            bool operator!=(const ParameterSetIterator& rhp) const {
                return key_iter_ != rhp.key_iter_;
            }
 
        private:
            ParameterPairs const * keys_;
            T key_iter_;
 
        };
 
        typedef ParameterSetIterator<ParameterPairs::iterator> iterator;
 
        typedef ParameterSetIterator<ParameterPairs::const_iterator> const_iterator;
 
        // Returns a vector of names
        std::vector<std::string> getNames() const {
            std::vector<std::string> result;
            for(ParameterPairs::value_type const & pair : keys_){
                result.push_back(pair.first);
            }
            return result;
        }
 
        iterator begin() {
            ParameterPairs::iterator itr = keys_.begin();
            return iterator((const ParameterPairs*)&keys_, itr);
        }
 
        iterator end() {
            ParameterPairs::iterator itr = keys_.end();
            return iterator((const ParameterPairs*)&keys_, itr);
        }
 
        const_iterator begin() const {
            ParameterPairs::const_iterator itr = keys_.begin();
            return const_iterator((const ParameterPairs*)&keys_, itr);
        }
 
        const_iterator end() const {
            ParameterPairs::const_iterator itr = keys_.end();
            return const_iterator((const ParameterPairs*)&keys_, itr);
        }
 
        size_t getNumParameters() const {
            return keys_.size();
        }
 
        uint32_t readVolatileParamValuesFromVirtualTree();
 
        uint32_t readAllParamValuesFromVirtualTree();
 
   protected:
 
        void addParameter_(sparta::ParameterBase* p);
 
        virtual void onAddingChild_(TreeNode* child) override;
 
        virtual void onAddedAsChild_() noexcept override;
 
        const ParameterTree* getSimParameterTree_();
 
        const ParameterTree* getSimArchParameterTree_();
 
        void readValuesFromVirtualTree_();
 
        bool readValueFromVirtualTree_(const ParameterTree* arch_pt,
                                       const ParameterTree* pt,
                                       sparta::ParameterBase* p);
 
        ParameterPairs keys_;
 
        ParameterVector params_;
 
    private:
 
        std::vector<const ParameterBase *> locking_params_stack_;
 
        OneWayBool<false> populated_from_virtual_;
 
    }; // class ParameterSet
 
} // namespace sparta
 
#define PARAMETER(type, name, def, doc)                                 \
    sparta::Parameter<type> name {#name, def, doc, __this_ps};
 
#define LOCKED_PARAMETER(type, name, def, doc)                          \
    sparta::Parameter<type> name {#name, def, doc, sparta::Parameter<type>::ParameterAttribute::LOCKED, __this_ps};
 
#define VOLATILE_LOCKED_PARAMETER(type, name, def, doc)                 \
    sparta::Parameter<type> name {#name, def, doc, sparta::Parameter<type>::ParameterAttribute::LOCKED, __this_ps, true};
 
#define HIDDEN_PARAMETER(type, name, def, doc)                          \
    sparta::Parameter<type> name {#name, def, doc, sparta::Parameter<type>::ParameterAttribute::HIDDEN,  __this_ps};
 
#define VOLATILE_HIDDEN_PARAMETER(type, name, def, doc)                 \
    sparta::Parameter<type> name {#name, def, doc, sparta::Parameter<type>::ParameterAttribute::HIDDEN, __this_ps, true};
 
#define VOLATILE_PARAMETER(type, name, def, doc)                        \
    sparta::Parameter<type> name {#name, def, doc, __this_ps, true};
 
#define PARAMETER_CTORDEFAULT(type, name, doc)                          \
    class _Parameter_##name : public sparta::Parameter<type>              \
    {                                                                   \
    public:                                                             \
        typedef type value_type;                                        \
                                                                        \
        /* construction with no default is disallowed */                \
        _Parameter_##name() = delete;                                   \
                                                                        \
        /* construction with new default value */                       \
        _Parameter_##name(ParameterSet* ps, type default_value) :       \
            sparta::Parameter<type>(#name, default_value, doc)            \
        {                                                               \
            sparta_assert(ps, "Must construct Parameter " #name " with valid ParameterSet"); \
            this->addToSet_(ps);                                        \
        }                                                               \
                                                                        \
        void operator=(const value_type& v) {                           \
            sparta::Parameter<value_type>::operator=(v);                  \
            /*return *this;*/                                           \
        }                                                               \
    };                                                                  \
    _Parameter_##name name; // No construction args suppled. Must be explicitly done by containing class
 
inline std::ostream& operator<< (std::ostream& out, sparta::ParameterSet const & ps){
    out << ps.stringize(true); // pretty
    return out;
}
 
inline std::ostream& operator<< (std::ostream& out, sparta::ParameterSet const * ps){
    out << ps->stringize(true); // pretty
    return out;
}