TatumInterface.h

Go to the documentation of this file.

/*******************************************************************************
 * The software programs comprising "CGRA-ME" and the documentation provided
 * with them are copyright by its authors and the University of Toronto. Only
 * non-commercial, not-for-profit use of this software is permitted without ex-
 * plicit permission. This software is provided "as is" with no warranties or
 * guarantees of support. See the LICENCE for more details. You should have re-
 * ceived a copy of the full licence along with this software. If not, see
 * <http://cgra-me.ece.utoronto.ca/license/>.
 ******************************************************************************/
 
#ifndef __TATUMINTERFACE__H__
#define __TATUMINTERFACE__H__
 
#include <algorithm>
#include <CGRA/Module.h>
#include <CGRA/ModuleComposites.h>
#include <CGRA/Mapping.h>
#include <CGRA/Util.h>
#include <CGRA/PerfEngine.h>
#include "tatum/TimingGraph.hpp"
#include "tatum/Time.hpp"
#include "tatum/TimingConstraints.hpp"
#include "tatum/delay_calc/FixedDelayCalculator.hpp"
#include "tatum/report/graphviz_dot_writer.hpp"
#include "tatum/timing_analyzers.hpp"
#include "tatum/graph_walkers.hpp"
#include "tatum/analyzer_factory.hpp"
#include "tatum/TimingReporter.hpp"
 
using tatum::TimingGraph;
using tatum::NodeId;
using tatum::NodeType;
using tatum::EdgeId;
using tatum::EdgeType;
using tatum::Time;
using tatum::FixedDelayCalculator;
using tatum::TimingConstraints;
using tatum::TimingReporter;
using tatum::DomainId;
 
using tatum::util::linear_map;
 
// Edges represented by pair of MRRGNodes, where the Key drives the Value
typedef std::multimap<MRRG::NodeDescriptor, MRRG::NodeDescriptor> EdgeList;
 
class MRRGNameResolver;
 
class PerfEngine;
 
typedef enum TGEntityType
{
    TG_REG,
    TG_COMB,
} TGEntityType;
 
typedef struct TGEntity
{
    TGEntityType type;
    MRRG::NodeDescriptor parent;
 
    unsigned width;
    unsigned used_input = 0;
    std::vector<std::vector<tatum::NodeId>> ipins; // FU ops tracks 2 lists
    std::vector<tatum::NodeId> opins;
 
    // combinational logic exclusive variable:
    std::vector<tatum::EdgeId> ipins2opins;
 
    // register exclusive variables:
    std::vector<tatum::NodeId> cpins;
    std::vector<tatum::NodeId> srcs;
    std::vector<tatum::NodeId> snks;
    std::vector<tatum::EdgeId> ipins2snks;
    std::vector<tatum::EdgeId> srcs2opins;
    std::vector<tatum::EdgeId> cpins2snks;
    std::vector<tatum::EdgeId> cpins2srcs;
} TGEntity;
 
class TatumInterface
{
    public:
        TatumInterface(std::map<std::string, double>&, PerfEngine*);
 
        TatumInterface(const TatumInterface&) = delete;
        TatumInterface(TatumInterface&&) = delete;
        TatumInterface& operator=(const TatumInterface&) = delete;
        TatumInterface& operator=(TatumInterface&&) = delete;
 
        void createTatumTimingGraph(EdgeList& m); // sets tg & nr
        void initializeTatumEngine(EdgeList& m); // sets dc, tc, analyzer, & tr
        void reportSetupAnalysis();
    private:
        std::map<std::string, double>& timingModels;
        tatum::NodeId clk;
        tatum::DomainId clkDid;
        std::shared_ptr<tatum::TimingGraph> tg;
        std::shared_ptr<MRRGNameResolver> nr;
        std::shared_ptr<tatum::FixedDelayCalculator> dc;
        std::shared_ptr<tatum::TimingConstraints> tc;
        std::shared_ptr<tatum::SetupHoldTimingAnalyzer> analyzer;
        std::shared_ptr<tatum::TimingReporter> tr;
        PerfEngine* parent;
        linear_map<tatum::EdgeId, tatum::Time> maxComb;
        linear_map<tatum::EdgeId, tatum::Time> minComb;
        linear_map<tatum::EdgeId, tatum::Time> setup;
        linear_map<tatum::EdgeId, tatum::Time> hold;
        std::vector<tatum::NodeId> memOut; // FIXME: currently constrained as constant generator
        std::map<MRRG::NodeDescriptor, std::shared_ptr<TGEntity>> mrrg2tg; // maps an MRRG node to its corresponding tg nodes
        std::map<tatum::NodeId, MRRG::NodeDescriptor> tg2mrrg; // maps a TG node to its corresponding parent MRRG node
        void removeWireNodes(EdgeList& orig, EdgeList& reduced);
        void createTGEntity(MRRG::NodeDescriptor n, bool reduce = true);
        void connectTGEntities(MRRG::NodeDescriptor from, MRRG::NodeDescriptor to, bool reduce = true);
        void connectTGClock(MRRG::NodeDescriptor n, bool reduce = true);
        double getFanoutBasedRCDelay(MRRG::NodeDescriptor src);
};
 
class MRRGNameResolver : public tatum::TimingGraphNameResolver
{
    public:
        MRRGNameResolver(const tatum::TimingGraph& tg): tg_(&tg) {}
 
        MRRGNameResolver(const MRRGNameResolver&) = delete;
        MRRGNameResolver(MRRGNameResolver&&) = delete;
        MRRGNameResolver& operator=(const MRRGNameResolver&) = delete;
        MRRGNameResolver& operator=(MRRGNameResolver&&) = delete;
 
        std::string node_name(tatum::NodeId node) const override {
            //return "Node(" + std::to_string(size_t(node)) + ")";
            return node2inst[node];
        }
 
        std::string node_type_name(tatum::NodeId node) const override {
            auto type = tg_->node_type(node);
            std::stringstream ss;
            ss << type;
            return ss.str();
        }
 
        void set_node_name(tatum::NodeId node, std::string name) {
            node2inst.insert(node, name);
        }
    private:
        const tatum::TimingGraph* tg_;
        linear_map<tatum::NodeId, std::string> node2inst = {};
};
 
#endif