Resource.hpp

Go to the documentation of this file.

// <Resource.hpp> -*- C++ -*-
 
#pragma once
 
#include <string>
#include <ostream>
#include <type_traits>
 
#include "sparta/simulation/ResourceContainer.hpp"
#include "sparta/simulation/Clock.hpp"
#include "sparta/utils/SpartaException.hpp"
#include "sparta/kernel/Scheduler.hpp"
#include "sparta/utils/SpartaAssert.hpp"
#include "sparta/simulation/TreeNode.hpp"
#include "sparta/utils/Utils.hpp"
#include "simdb/Errors.hpp"
 
namespace sparta {
 
    class TreeNode;
 
    class PostRunValidationInfo
    {
    public:
        // Empty for now
    };
 
 
    class Resource
    {
        friend class TreeNode;
 
    public:
 
        Resource(TreeNode* rc);
 
        Resource(TreeNode* rc,
                 const std::string& name);
 
        Resource(const std::string & name,
                 const Clock * clk);
 
        virtual ~Resource();
 
        const Clock * getClock() const;
 
        Scheduler * getScheduler(const bool must_exist = true) const;
 
        std::string getName() const;
 
        TreeNode* getContainer();
 
        const TreeNode* getContainer() const;
 
        ResourceContainer* getResourceContainer();
 
        const ResourceContainer* getResourceContainer() const;
 
        virtual void addLink(TreeNode *node, const std::string &label)
        {
            (void)node; (void)label;
            /* Resource that do not overload this method does not use the links */
        }
 
        virtual void activateLink(const std::string &label)
        {
            (void)label;
            /* Resource that do not overload this method does not use the links */
        }
 
        Resource(const Resource &) = delete;
        Resource &operator=(const Resource &) = delete;
 
    private:
 
        virtual void simulationTerminating_();
 
        virtual void validatePostRun_(const PostRunValidationInfo& info) const;
 
        virtual void dumpDebugContent_(std::ostream& output) const;
 
        virtual void onStartingTeardown_();
 
        virtual void onBindTreeEarly_() {;}
 
        virtual void onBindTreeLate_() {;}
 
        TreeNode* res_container_;
 
        std::string name_;
 
        const Clock * clk_;
    };
 
    GENERATE_HAS_ATTR(getClock)
 
    
    class AssertContext
    {
        void appendTickData_(std::ostream& ss, Scheduler * sched)
        {
            if(sched) {
                ss << "tick: " << sched->getCurrentTick();
            }
            else {
                ss << "(no scheduler associated)";
            }
        }
 
        void appendClockData_(std::ostream& ss, const Clock* clk)
        {
            Scheduler * sched = nullptr;
            if(clk){
                ss << "at cycle: " << clk->currentCycle() << " ";
                sched = clk->getScheduler();
            }else{
                ss << "(no clock associated) ";
            }
            // also always include the tick data along with the clock.
            appendTickData_(ss, sched);
        }
    public:
 
 
        template <class CTXT>
        std::string getContextDescription(CTXT* ctxt,
                                          typename std::enable_if<!std::is_base_of<Resource, CTXT>::value
                                                                  && !std::is_base_of<TreeNode, CTXT>::value
                                                                  && !has_attr_getClock<CTXT>::value>::type* dummy = nullptr) {
            (void) ctxt;
            (void) dummy;
            std::stringstream ss;
            ss << "(from non-sparta context at ";
            appendTickData_(ss, nullptr);
            ss << ")";
 
            return ss.str();
        }
 
        template <class CTXT>
        std::string getContextDescription(CTXT* ctxt,
                                          typename std::enable_if<!std::is_base_of<Resource, CTXT>::value
                                                                  && !std::is_base_of<TreeNode, CTXT>::value
                                                                  && has_attr_getClock<CTXT>::value>::type* dummy = 0) {
            (void) dummy;
            std::stringstream ss;
            static_assert(std::is_pointer<decltype(ctxt->getClock())>::value,
                          "Type of this pointer is a class having a getClock method, but this "
                          "method does not return a pointer to a sparta::Clock");
            static_assert(std::is_base_of<sparta::Clock,
                                          typename std::remove_pointer<typename std::remove_cv<decltype(ctxt->getClock())>::type>::type>::value != false,
                          "Type of this pointer is a class having a getClock method, but this "
                          "method doe not return a sparta::Clock");
            auto clock = ctxt->getClock();
            // write the clock and tick to the stream.
            appendClockData_(ss, clock);
 
            return ss.str();
        }
 
        template <class CTXT>
        std::string getContextDescription(const sparta::Resource* ctxt,
                                          typename std::enable_if<std::is_base_of<Resource, CTXT>::value>::type* dummy = 0) {
            (void) dummy;
            std::stringstream ss;
            const ResourceContainer* rc = ctxt->getResourceContainer();
            if(!rc){
                ss << "(within uncontained resource)";
            }else{
                ss << "within resource at: " << rc->getLocation() << " ";
                const sparta::Clock* clock = ctxt->getClock();
                // write the clock and tick to the stream.
                appendClockData_(ss, clock);
 
            }
            return ss.str();
        }
 
        template <class CTXT>
        std::string getContextDescription(const sparta::TreeNode* ctxt,
                                          typename std::enable_if<std::is_base_of<TreeNode, CTXT>::value>::type* dummy = 0) {
            (void) dummy;
            std::stringstream ss;
            if(!ctxt){
                ss << "(within null treenode)"; // This should not happen, but could
            }else{
                ss << "within TreeNode: " << ctxt->getLocation() << " ";
                const sparta::Clock* clock = ctxt->getClock();
                // write the clock and tick to the stream.
                appendClockData_(ss, clock);
            }
            return ss.str();
        }
    };
 
    #define ADD_CONTEXT_INFORMATION(ex, thisptr)  \
        sparta::AssertContext ac; \
        ex << " " << ac.getContextDescription<typename std::remove_pointer<decltype(thisptr)>::type>(thisptr);
 
    #define sparta_assert_context(e, insertions)  \
        if(__builtin_expect(!(e), 0)) { sparta::SpartaException ex(std::string(#e) + ": " );  \
                                        ex << insertions;                                 \
                                        ADD_FILE_INFORMATION(ex, __FILE__, __LINE__);     \
                                        ADD_CONTEXT_INFORMATION(ex, this);                \
                                        throw ex; }
 
 
} // namespace sparta