RootTreeNode.hpp

Go to the documentation of this file.

// <RootTreeNode> -*- C++ -*-
 
#pragma once
 
#include <memory>
#include <ostream>
#include <string>
#include <vector>
 
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/simulation/TreeNodeExtensions.hpp"
#include "sparta/simulation/GlobalTreeNode.hpp"
#include "sparta/app/ConfigApplicators.hpp"
#include "sparta/log/NotificationSource.hpp"
#include "sparta/simulation/TreeNodePrivateAttorney.hpp"
#include "sparta/simulation/ParameterTree.hpp"
#include "sparta/simulation/ParameterSet.hpp"
#include "sparta/kernel/PhasedObject.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/utils/SpartaException.hpp"
 
namespace sparta
{
    class ArchData;
    class Clock;
 
    namespace app {
        class Simulation;
    }
 
    namespace python {
        class PythonInterpreter;
    }
 
    class RootTreeNode : public TreeNode
    {
    public:
 
        typedef NotificationSource<TreeNode> NewDescendantNotiSrc;
 
        RootTreeNode(const std::string & name,
                     const std::string & desc,
                     app::Simulation* sim,
                     GlobalTreeNode* search_scope) :
            TreeNode(name, GROUP_NAME_NONE, GROUP_IDX_NONE, desc),
            sim_(sim),
            new_node_noti_(this,
                           "descendant_attached",
                           "Notification immediately after a node becomes a descendant of this "
                           "root at any distance. This new node may have children already attached "
                           "which will not receive their own descendant_attached notification",
                           "descendant_attached")
        {
            if(search_scope != nullptr){
                search_node_ = search_scope;
            }else{
                search_node_ = new GlobalTreeNode();
                alloc_search_node_.reset(search_node_);
            }
            search_node_->addChild(this);
 
            /* Define the default scope that all tree nodes will be in. This is
             * to ensure that getScopeRoot() never returns nullptr event when no
             * scope is explicitly defined. */
            setScopeRoot();
        }
 
        RootTreeNode(const std::string & name,
                     const std::string & desc,
                     GlobalTreeNode* search_scope) :
            RootTreeNode(name, desc, nullptr, search_scope)
        {
            // Delegated construction
        }
 
        RootTreeNode(const std::string & name) :
            RootTreeNode(name, "Top of device tree", nullptr, nullptr)
        {
            // Delegated construction
        }
 
        RootTreeNode(const std::string & name,
                     const std::string & desc,
                     app::Simulation* sim) :
            RootTreeNode(name, desc, sim, nullptr)
        {
            // Delegated construction
        }
 
        RootTreeNode(const std::string & name,
                     const std::string & desc) :
            RootTreeNode(name, desc, nullptr, nullptr)
        {
            // Delegated construction
        }
 
        RootTreeNode(app::Simulation* sim) :
            RootTreeNode("top", "Top of device tree", sim, nullptr)
        {
            // Delegated construction
        }
 
        RootTreeNode(GlobalTreeNode* search_scope) :
            RootTreeNode("top", "Top of device tree", nullptr, search_scope)
        {
            // Delegated construction
        }
 
        RootTreeNode(app::Simulation* sim, GlobalTreeNode* search_scope) :
            RootTreeNode("top", "Top of device tree", sim, search_scope)
        {
            // Delegated construction
        }
 
        RootTreeNode() :
            RootTreeNode("top", "Top of device tree", nullptr, nullptr)
        {
            // Delegated construction
        }
 
        virtual ~RootTreeNode() {
            // Inform Search Scope node since it will not be notified by
            // ~TreeNode, which does not recognize the search scope as a parent
            if(search_node_){
                removeFromParentForTeardown_(search_node_);
            }
 
            // No need to alert children, because ~TreeNode will do this next
        }
 
        // Returns true. Tree root is always considered "attached"
        virtual bool isAttached() const override final {
            return true;
        }
 
        // Returns 0. Tree root will never have a parent
        virtual TreeNode* getParent() override final { return nullptr; }
 
        // Returns 0. Tree root will never have a parent
        virtual const TreeNode* getParent() const override final { return nullptr; }
 
        // Override TreeNode::setClock() so we can pass that clock to the search scope
        virtual void setClock(const Clock * clk) override final {
            if (search_node_) {
                search_node_->setClock(clk);
            }
            TreeNode::setClock(clk);
        }
 
        app::Simulation* getSimulator() const {
            return sim_;
        }
 
        GlobalTreeNode* getSearchScope(){
            sparta_assert(search_node_);
            return search_node_;
        }
 
        void enterConfiguring(){
            if(getPhase() != TREE_BUILDING){
                throw SpartaException("Device tree with root \"")
                    << getLocation()<< "\" not currently in the TREE_BUILDING phase, so it cannot "
                                       "enter TREE_CONFIGURING";
            }
 
            enterConfig_(); // Enter the next phase (cannot throw)
        }
 
        void enterFinalized(sparta::python::PythonInterpreter* pyshell = nullptr);
 
        void bindTreeEarly() {
            if(getPhase() != TREE_FINALIZED){
                throw SpartaException("Device tree with root \"")
                    << getLocation()
                    << "\" not in the TREE_FINALIZED phase, so it cannot be bound (bindTreeEarly)";
            }
 
            bindTreeEarly_();
        }
 
        void bindTreeLate() {
            if(getPhase() != TREE_FINALIZED){
                throw SpartaException("Device tree with root \"")
                    << getLocation()
                    << "\" not in the TREE_FINALIZED phase, so it cannot be bound (bindTreeLate)";
            }
 
            bindTreeLate_();
        }
 
        void simulationTerminating() {
            simulationTerminating_();
        }
 
        void validatePreRun() {
            if(getPhase() != TREE_FINALIZED){
                throw SpartaException("Device tree with root \"")
                    << getLocation()
                    << "\" not in the TREE_FINALIZED phase, so it cannot be pre-run validated";
            }
 
            validateTree_(); // Validate all nodes, which may throw
        }
 
 
        void validatePostRun();
 
        void dumpDebugContent(std::ostream& out) noexcept {
            dumpDebugContent_(out);
        }
 
        void enterTeardown() {
            enterTeardown_(); // Enter the next phase
        }
 
        virtual std::string stringize(bool pretty=false) const override {
            (void) pretty;
            std::stringstream ss;
            ss << "<" << getLocation() << " (root)>";
            return ss.str();
        }
 
 
        NewDescendantNotiSrc& getNodeAttachedNotification() {
            return new_node_noti_;
        }
 
 
 
        void getArchDataAssociations(std::vector<const ArchData*>& ad_this_tree,
                                     std::vector<const ArchData*>& ad_no_assoc,
                                     std::vector<const ArchData*>& ad_not_attached,
                                     std::vector<const ArchData*>& ad_other_tree) const noexcept;
 
        void validateArchDataAssociations() const;
 
        void dumpArchDataAssociations(std::ostream& o) const noexcept;
 
        void dumpTypeMix(std::ostream& o) const;
 
        template <typename ExtensionT>
        static void registerExtensionClass() {
            static_assert(std::is_base_of<ExtensionsBase, ExtensionT>::value);
            extensionFactories_()[ExtensionT::NAME] = []() { return new ExtensionT; };
        }
 
        static void registerExtensionFactory(const std::string & extension_name,
                                             std::function<ExtensionsBase*()> factory)
        {
            extensionFactories_()[extension_name] = factory;
        }
 
        static std::function<ExtensionsBase*()> & getExtensionFactory(const std::string & extension_name)
        {
            auto it = extensionFactories_().find(extension_name);
            if (it != extensionFactories_().end()) {
                return it->second;
            }
 
            static std::function<ExtensionsBase*()> none;
            return none;
        }
 
        ParameterTree& getExtensionsUnboundParameterTree() {
            return extensions_ptree_;
        }
 
        const ParameterTree& getExtensionsUnboundParameterTree() const {
            return extensions_ptree_;
        }
 
        void addExtensions(const std::string & yaml_file,
                           const std::vector<std::string> & config_search_paths = {},
                           const bool verbose_cfg = false)
        {
            app::NodeConfigFileApplicator applicator("", yaml_file, config_search_paths);
 
            ParameterTree ptree;
            applicator.applyUnbound(ptree, verbose_cfg);
 
            // Store the extensions in the std::any map owned by the ParameterTree::Node's
            extensions_ptree_.merge(ptree);
            if (verbose_cfg) {
                std::cout << "After merging extension file '" << yaml_file << "', parameter tree contains:\n";
                constexpr bool print_user_data = false; // Already printed from "extension" nodes
                extensions_ptree_.recursePrint(std::cout, print_user_data);
            }
        }
 
 
    private:
 
        static std::map<std::string, std::function<ExtensionsBase*()>> & extensionFactories_() {
            static std::map<std::string, std::function<ExtensionsBase*()>> factories;
            return factories;
        }
 
        ParameterTree extensions_ptree_;
 
        // No effect on root
        virtual void createResource_() override {};
 
        virtual void onSettingParent_(const TreeNode* parent) const override final {
            if(parent != search_node_){
                throw SpartaException("This RootTreeNode \"")
                    << "\" cannot be a child of any other node except its constructed "
                       "GlobalTreeNode";
            }
        }
 
        virtual void setParent_(TreeNode* parent, bool) override final {
            if(parent != search_node_){
                throw SpartaCriticalError("This RootTreeNode \"")
                    << "\" cannot be a child of any other node except its constructed "
                       "GlobalTreeNode";
            }
 
            // NOTE: Do not store parent because the root should act as if there is no parent
        }
 
        virtual void onDescendentSubtreeAdded_(TreeNode* des) noexcept override final {
            // Broadcast notification for self coming into existence
            try{
                new_node_noti_.postNotification(*des);
 
                // Iterate subtree headed by des and notify observers of these
                for(TreeNode* child : TreeNodePrivateAttorney::getAllChildren(des)){
                    onDescendentSubtreeAdded_(child);
                }
            }catch(SpartaException& ex){
                std::stringstream msg;
                msg << ex.what() <<
                    "\nThis exception within onDescendentSubtreeAdded_, which is not exception-"
                    "safe. The integrity of this sparta tree (" << getRoot() << ") is compromised. "
                    "Aborting. ";
                sparta_abort(false,msg.str());
            }
        }
 
        std::unique_ptr<GlobalTreeNode> alloc_search_node_;
 
        GlobalTreeNode* search_node_;
 
        app::Simulation* sim_;
 
        NewDescendantNotiSrc new_node_noti_;
    };
 
    template <typename ExtensionT>
    class ExtensionRegistration
    {
    public:
        ExtensionRegistration()
        {
            sparta::RootTreeNode::registerExtensionClass<ExtensionT>();
        }
    };
 
} // namespace sparta
 
#define SPARTA_CONCATENATE_DETAIL(x, y) x##y
#define SPARTA_CONCATENATE(x, y) SPARTA_CONCATENATE_DETAIL(x, y)
 
#define REGISTER_TREE_NODE_EXTENSION(ExtensionClass) \
    sparta::ExtensionRegistration<ExtensionClass> SPARTA_CONCATENATE(__extension_registration_, __COUNTER__)