DynamicResourceTreeNode.hpp

// <DynamicResourceTreeNode> -*- C++ -*-
 
#pragma once
 
#include <iostream>
#include <string>
 
#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"
#include "sparta/functional/ArchData.hpp"
 
namespace sparta
{
    template <typename ResourceT, typename ParamsT>
    class DynamicResourceTreeNode : public TreeNode
    {
    public:
 
        static const ArchData::offset_type ARCH_DATA_LINE_SIZE = 256;
 
        DynamicResourceTreeNode(TreeNode* parent,
                                const std::string & name,
                                const std::string & group,
                                group_idx_type group_idx,
                                const std::string & desc,
                                const ParamsT* params) :
            TreeNode(name, group, group_idx, desc),
            adata_(this, ARCH_DATA_LINE_SIZE),
            params_(params)
        {
            setExpectedParent_(parent);
 
            if(nullptr == parent){
                throw SpartaException("Cannot create a DynamicResourceTreeNode without a non-null parent. Error at: ")
                    << getLocation();
            }
 
            // Ensure that this node has a parent that is attached (because this node isn't actually attached yet)
            if(false == parent->isAttached()){
                throw SpartaException("Cannot create resource for TreeNode \"")
                    << getName() << "\"@" << (void*)this << " because it is not attached to a tree with a RootTreeNode";
            }
 
            if(nullptr == params){
                throw SpartaException("Params for DynamicResourceTreeNode \"")
                    << getLocation() << " cannot be null";
            }
 
            if(getClock() == nullptr && parent->getClock() == nullptr){
                throw SpartaException("No clock associated with TreeNode ")
                    << getLocation() << " and no ancestor has an associated clock. A DynamicResourceTreeNode "
                    << "must have at least one clock associated with a node in their ancestry";
            }
 
            // Layout the contained ArchData
            adata_.layout();
            if(parent != nullptr){
                parent->addChild(this);
            }
        }
 
        DynamicResourceTreeNode(TreeNode* parent,
                                const std::string & name,
                                const std::string & desc,
                                const ParamsT* params) :
            DynamicResourceTreeNode(parent,
                                    name,
                                    TreeNode::GROUP_NAME_NONE,
                                    TreeNode::GROUP_IDX_NONE,
                                    desc,
                                    params)
        { }
 
        virtual ~DynamicResourceTreeNode() {
        }
 
        void finalize() {
            if(getResource_() != nullptr){
                throw SpartaException("Cannot re-finalize this DynamicResourceTreeNode: ")
                    << getLocation() << " because it already has a resource";
            }
 
            createResource_();
        }
 
        virtual std::string stringize(bool pretty=false) const override {
            (void) pretty;
            std::stringstream ss;
            ss << "<" << getLocation() << " dynamic resource: \"" << demangle(typeid(ResourceT).name()) << "\">";
            return ss.str();
        }
 
    private:
 
        virtual void createResource_() override {
            sparta_assert(params_ != nullptr); // Constructor should prevent this
            sparta_assert(getParent() != nullptr); // Constructor should prevent this
 
            if(getResource_() != nullptr){
                // Already has a resource. Nothing left to do
                return;
            }
 
            if(getPhase() != TREE_FINALIZING){
                throw SpartaException("Tried to create resource through DynamicResourceTreeNode ")
                    << getLocation() << " but tree was not in TREE_FINALIZING phase";
            }
 
            if(getClock() == nullptr){
                throw SpartaException("No clock associated with DynamicResourceTreeNode ")
                    << getLocation() << " and no ancestor has an associated clock. All DynamicResourceTreeNodes "
                    << "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;
            }
 
            res_.reset(new ResourceT(this, params_));
            sparta_assert(res_ != nullptr); // Resource created must not be null
            if(getResource_() == nullptr){
                throw SpartaException("DynamicResourceTreeNode ") << getLocation()
                    << " created a resource of type " << demangle(typeid(ResourceT).name())
                    << " 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_() != res_.get()){
                throw SpartaException("DynamicResourceTreeNode ") << getLocation()
                    << " created a resource of type " << demangle(typeid(ResourceT).name())
                    << " but that resource was different than the resource registered with this "
                       "node.";
            }
            lockResource_();
        }
 
        // Prevent addition to the tree after the TREE_BUILDING phase
        virtual void onSettingParent_(const TreeNode* parent) const override {
            (void) parent;
            if(isBuilt()){
                throw SpartaException("Cannot add DynamicResourceTreeNode  \"")
                    << getName() << "\" as child of device tree node \""
                    << getLocation() << "\". This tree has exited the TREE_BUILDING "
                    << "phase and ResourceTreeNodes can no longer be added.";
            }
        }
 
        std::unique_ptr<ResourceT> res_; 
 
        ArchData adata_;
 
        const ParamsT* params_;
    };
 
 
} // namespace sparta