ResourceTreeNode.hpp

// <ResourceTreeNode> -*- C++ -*-
 
#pragma once
 
#include <iostream>
#include <string>
 
#include "sparta/functional/ArchData.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/log/MessageSource.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/simulation/ParameterSet.hpp"
#include "sparta/simulation/ResourceFactory.hpp"
 
namespace sparta
{
 
    class ResourceTreeNode : public TreeNode
    {
    public:
 
        static const ArchData::offset_type ARCH_DATA_LINE_SIZE = 256;
 
        ResourceTreeNode(TreeNode* parent,
                         const std::string & name,
                         const std::string & group,
                         group_idx_type group_idx,
                         const std::string & desc,
                         ResourceFactoryBase* res_fact) :
            TreeNode(name, group, group_idx, desc),
            created_resource_(false),
            res_fact_(res_fact),
            params_(0),
            adata_(this, ARCH_DATA_LINE_SIZE)
        {
            setExpectedParent_(parent);
 
            if(nullptr == res_fact_){
                throw SpartaException("Resource factory for node \"")
                    << getLocation() << " cannot be null";
            }
 
            if(parent != nullptr){
                parent->addChild(this); // Do not inherit parent state
            }
 
            initConfigurables_();
        }
 
        ResourceTreeNode(const std::string & name,
                         const std::string & group,
                         group_idx_type group_idx,
                         const std::string & desc,
                         ResourceFactoryBase* res_fact) :
            ResourceTreeNode(nullptr, name, group, group_idx, desc, res_fact)
        {
            // Initialization delegated to other constructor
        }
 
        ResourceTreeNode(TreeNode* parent,
                         const std::string & name,
                         const std::string & desc,
                         ResourceFactoryBase* res_fact) :
            ResourceTreeNode(parent,
                             name,
                             TreeNode::GROUP_NAME_NONE,
                             TreeNode::GROUP_IDX_NONE,
                             desc,
                             res_fact)
        {
            // Initialization delegated to other constructor
        }
 
        ResourceTreeNode(const std::string & name,
                         const std::string & desc,
                         ResourceFactoryBase* res_fact) :
            ResourceTreeNode(name,
                             TreeNode::GROUP_NAME_NONE,
                             TreeNode::GROUP_IDX_NONE,
                             desc,
                             res_fact)
        {
            // Initialization delegated to other constructor
        }
 
        virtual ~ResourceTreeNode() {
            if(res_fact_ != nullptr){
                if(params_ != nullptr){
                    res_fact_->deleteParameters(params_);
                    params_ = 0;
                }
 
                if(getResource_() != nullptr){
                    res_fact_->deleteResource(getResource_());
                }
 
                res_fact_->deleteSubtree(this);
            }
        }
 
        ParameterSet* getParameterSet() {
            sparta_assert(params_ != 0);
            return params_;
        }
 
        const ParameterSet* getParameterSet() const {
            sparta_assert(params_ != 0);
            return params_;
        }
 
        virtual std::string getResourceType() const override {
            return res_fact_->getResourceType();
        }
 
        virtual std::string getResourceTypeRaw() const override {
            return res_fact_->getResourceTypeRaw();
        }
 
        virtual std::string stringize(bool pretty=false) const override {
            (void) pretty;
            std::stringstream ss;
            ss << "<" << getLocation() << " resource: \""
               << res_fact_->getResourceType() << "\">";
            return ss.str();
        }
 
        void finalize() {
            if(getResource_() != nullptr){
                throw SpartaException("Cannot re-finalize this ResourceTreeNode: ")
                    << getLocation() << " because it already has a resource. ";
            }
 
            createResource_();
        }
 
 
        Resource* getResourceNow() noexcept {
            return getResource_();
        }
 
    protected:
 
        virtual void createResource_() override
        {
            if(getPhase() != TREE_FINALIZING){
                throw SpartaException("Tried to create resource on ")
                    << getLocation() << " but tree was not in TREE_FINALIZING phase";
            }
 
            if(getResource_() != nullptr){
                // Already has a resource. Nothing left to do
                sparta_assert(created_resource_,
                            "Resource was set in ResourceTreeNode " << getLocation()
                            << " but not by the ResourceTreeNode itself");
                return;
            }
 
            // Ensure that this node has a parent OR children.
            // Note that this:
            //    A) prohibits 1-node device trees. A 'top' node should exist anyway
            //    B) Cannot check for orphaned trees (yet)
            if(!isAttached()){
                throw SpartaException("Cannot create resource for TreeNode \"")
                    << getName() << "\"@" << (void*)this << " because it is not attached to a tree with a RootTreeNode";
            }
 
            // Check for valid configured values
            if(getResource_() != 0){
                throw SpartaException("Resource already created for TreeNode \"")
                    << getLocation() << "\". Cannot create again";
            }
 
            if(getClock() == nullptr){
                throw SpartaException("No clock associated with TreeNode ")
                    << getLocation() << " and no ancestor has an associated clock. All ResourceTreeNodes "
                    << "must have at least one clock associated with a node in their ancestry";
            }
 
            std::string errs;
            if(!params_->validateIndependently(errs)){
                throw SpartaException("Parameter limits violated:")
                    << errs;
            }
 
            if(!params_->validateDependencies(this, errs)){
                throw SpartaException("Parameter validation callbacks indicated invalid parameters: ")
                    << errs;
            }
 
            // Note, parameters have been reset to 0 read-counts when the
            // parameter set was constructed
 
            Resource* r = res_fact_->createResource(this, params_);
            sparta_assert(r != nullptr); // Resource created must not be NULL
 
            if(getResource_() == nullptr){
                throw SpartaException("ResourceTreeNode ") << getLocation()
                    << " created a resource of type " << res_fact_->getResourceType()
                    << " but that resource did not register itself with this node. Ensure that "
                       "this resource class uses the proper sparta::Resource base-class constructor "
                       "which takes a ResourceContainer";
            }
            if(getResource_() != r){
                throw SpartaException("ResourceTreeNode ") << getLocation()
                    << " created a resource of type " << res_fact_->getResourceType()
                    << " but that resource was different than the resource registered with this "
                       "node.";
            }
 
            lockResource_(); // No changing resource until teardown
 
            created_resource_ = true; // Created by this ResourceTreeNode
 
            // Note, do not check all parameters right here because children may
            // be reading them. Instead, defer this to a tree-validation stage
            // Ensure each Parameter was read at least once by the consuming
            // component
 
            // Layout the contained ArchData
            adata_.layout();
        }
 
    private:
 
        // Prevent addition to the tree after the TREE_BUILDING phase
        void onSettingParent_(const TreeNode* parent) const override {
            (void) parent;
            if(isBuilt()){
                throw SpartaException("Cannot add ResourceTreeNode  \"")
                    << getName() << "\" as child of device tree node \""
                    << getLocation() << "\". This tree has exited the TREE_BUILDING "
                    << "phase and ResourceTreeNodes can no longer be added.";
            }
        }
 
        void onConfiguring_() override {
            // Hook to configure mode, even call create subtree
            res_fact_->onConfiguring(this);
        }
 
        void onBindTreeEarly_() override {
            // This doesn't work due to a bug in Port's auto
            // precedence registration in SPARTA.  If the resource
            // factory does the binding early and connects ports
            // together, then when a sparta::Unit's onBindTreeEarly_
            // function is called, the ports are already bound and an
            // assertion will fire.  The fix should be a separate
            // state that allows the Unit to register events on ports
            // before ANY binding occurs
            //
            //res_fact_->bindEarly(this);
        }
 
        void onBindTreeLate_() override {
            res_fact_->bindLate(this);
        }
 
        // Validate the tree
        void validateNode_() const override {
            params_->verifyAllRead(); // Throws if not all read at least once
        }
 
        void initConfigurables_() {
            // Create parameters first
            params_ = res_fact_->createParameters(this);
            sparta_assert(params_ != 0); // Params must not be NULL
            params_->resetReadCounts(); // Reset read-counts to 0
 
            //Hook for additional building is needed
            res_fact_->onBuilding(this);
 
            std::string res_type = res_fact_->getResourceType();
            if(res_type == ""){
                throw SpartaException("resource type for ResourceFactory associated with ")
                    << getLocation() << " must not be empty string";
            }
        }
 
        bool created_resource_; 
        ResourceFactoryBase* const res_fact_; 
        ParameterSet* params_; 
 
        ArchData adata_;
    };
 
 
} // namespace sparta