oagFpgaModGraph.h

Go to the documentation of this file.

#if !defined(oagFpgaModGraph_P)
#define oagFpgaModGraph_P

#include <stdlib.h>

#include "oaDesignDB.h"
#include "oagFpgaModRef.h"
#include "oagFpgaManager.h"
#include "oagFpgaRtlGraph.h"
#include <list>
#include <set>

using namespace std;

namespace oagFpga {

// *****************************************************************************
// ModGraph
//
//
// *****************************************************************************

class ModGraph {
//  friend class SimMod;

  private:
        
                                   ModGraph();   // this is a purely static
                                                 // class and can not be
                                                 // instantiated
  public:

/*
    typedef set<ModRef> Cut;
    typedef list<Cut>   CutSet;
*/
    

    static ModRef           getNull(oa::oaModule *module) {
        return ModRef(RtlGraph::getNull(), module);
    }
    static inline bool      isNull(ModRef x) {
        return RtlGraph::isNull(x.ref);
    }
    static inline ModRef    constantOne(oa::oaModule *module) {
        return ModRef(getGraph(module)->constantOne(), module);
    }
    static inline ModRef    constantZero(oa::oaModule *module) {
        return ModRef(getGraph(module)->constantZero(), module);
    }
    /*
    static inline ModRef notOf(ModRef x) {
        return ModRef(RtlGraph::notOf(x.ref), x.module);
    }
    static inline bool       isInverted(ModRef x) {
        return oagAi::Graph::isInverted(x.ref);
    }
    static inline ModRef     getNonInverted(ModRef x) {
        return ModRef(oagAi::Graph::getNonInverted(x.ref), x.module);
    }
    
    
    static inline unsigned int getUserData(ModRef x, unsigned int index) {
        return getGraph(x)->getUserData(x.ref, index);
    }
    static inline void         setUserData(ModRef x, unsigned int index, unsigned int data) {
        getGraph(x)->setUserData(x.ref, index, data);
    }
    */
    
    /*
    
    static ModRef           newSequential(ModRef nextState) {
        return ModRef(getGraph(nextState)->newSequential(nextState.ref), nextState.module);
    }
    static ModRef           newTerminal(ModRef terminal) {
        return ModRef(getGraph(terminal)->newTerminal(terminal.ref), terminal.module);    
    }
    static ModRef           newAnd(ModRef x, ModRef y);
    static ModRef           andOf(ModRef x, ModRef y);
    */
    static void             setTerminalDriver(ModRef terminal, ModRef driver);    
    /*
    static void             setNextState(ModRef sequential, ModRef nextState);
    static void             setAndLeft(ModRef x, ModRef left);
    static void             setAndRight(ModRef x, ModRef left);
    
    static void             resubstitute(ModRef original, ModRef replacement);
    static void             resubstitute(ModRef original, ModRef replacement, ModRef target);
    static void             detach(ModRef x);
    */
    
    
    static inline RtlNode::FuncType   getNodeType(ModRef x) {
        return getGraph(x)->getNodeType(x.ref);
    }    

    static inline RtlNode::OptType   getNodeOptType(ModRef x) {
        return getGraph(x)->getNodeOptType(x.ref);
    }    

    static inline RtlNode::SeqType   getNodeSeqType(ModRef x) {
        return getGraph(x)->getNodeSeqType(x.ref);
    }    
    static inline int               getNumOutputBits(ModRef x) {
        return getGraph(x)->getNumOutputBits(x.ref);
    }
    static inline BBRef             getPrimaryBBID(ModRef x) {
        return getGraph(x)->getPrimaryBBID(x.ref);
    }

    
    //    on terminal nodes...
    static ModRef         getTerminalDriver(ModRef terminal) {
        return ModRef(getGraph(terminal)->getTerminalDriver(terminal.ref), terminal.module);    
    }
    static bool           isTerminal(ModRef x) {
        return getGraph(x)->isTerminal(x.ref);    
    }
    static bool           isFunctional(ModRef x) {
        //         OPERATOR).
        return getGraph(x)->isFunctional(x.ref);    
    }
    //    on sequential nodes...
    static ModRef         getNextState(ModRef sequential) {
        return ModRef(getGraph(sequential)->getNextState(sequential.ref), sequential.module);    
    }
    static bool           isSequential(ModRef x) {
        return getGraph(x)->isSequential(x.ref);    
    }
    /*
    static oagAi::Node::SequentialData *getSequentialData(ModRef sequential) {
        return getGraph(sequential)->getSequentialData(sequential.ref);    
    }
    //    on and nodes...
    static bool           isAnd(ModRef x) {
        return getGraph(x)->isAnd(x.ref);    
    }
    static inline ModRef         getAndLeft(ModRef x) {
        return ModRef(getGraph(x)->getAndLeft(x.ref), x.module);
    }
    static inline ModRef         getAndRight(ModRef x) {
        return ModRef(getGraph(x)->getAndRight(x.ref), x.module);
    }
    */
    // on all nodes...
    static list<ModRef>      getFanin(ModRef x);
    static list<ModRef>      getFanout(ModRef x);
    static void              getFanout(ModRef x, list<ModRef> &result);
    static inline bool       hasFanout(ModRef x) {
        return getGraph(x)->hasFanout(x.ref);
    }

    
    static ModRef              prepareNetToBBConnection(oa::oaModBitNet *net);
    static oa::oaModBitNet *   getNetToBBConnection(ModRef ref);
    static ModRef              getNetToBBConnection(oa::oaModBitNet *net);
    static void                setNetToBBConnection(oa::oaModBitNet *net, ModRef ref);
    static void                removeNetToBBConnection(oa::oaModBitNet *net);

    static oa::oaModBitNet *   findDriverOfEquivalentNets(oa::oaModBitNet *net);

    static void                connectEquivalentNetsInGraph(oa::oaModule *module);

    
    static bool   hasCombinationalCycle(oa::oaModule *module);

    /*
                              
    static CutSet enumerateKfeasibleCuts(ModRef x, unsigned int maxCutSize,
                                         int maxCutCout = -1, int maxCutDepth = -1,
                                         bool includeConstantNode = true);
    static void   clearKfeasibleCuts(oa::oaModule *module);
    */

    static void   getTransitiveFanin(ModRef x, list<ModRef> &transitiveFanin, 
                                     bool includeRoots = true, bool crossSequential = false);
    static void   getTransitiveFanin(ModRef x, vector<ModRef> &transitiveFanin, 
                                     bool includeRoots = true, bool crossSequential = false);
    static void   getTransitiveFanin(list<ModRef> x, list<ModRef> &transitiveFanin, 
                                     bool includeRoots = true, bool crossSequential = false);
    static void   getTransitiveFanin(list<ModRef> x, vector<ModRef> &transitiveFanin, 
                                     bool includeRoots = true, bool crossSequential = false);

    static void   getTransitiveFanout(ModRef x, list<ModRef> &transitiveFanout, 
                                      bool includeRoots = true, bool crossSequential = false);
    static void   getTransitiveFanout(ModRef x, vector<ModRef> &transitiveFanout, 
                                      bool includeRoots = true, bool crossSequential = false);
    static void   getTransitiveFanout(list<ModRef> x, list<ModRef> &transitiveFanout, 
                                      bool includeRoots = true, bool crossSequential = false);
    static void   getTransitiveFanout(list<ModRef> x, vector<ModRef> &transitiveFanout, 
                                      bool includeRoots = true, bool crossSequential = false);

    /*
    static void   getFaninCone(ModRef x, const list<ModRef> &coneRoots, 
                               list<ModRef> &transitiveFanin, bool includeRoots = true);
    static void   getFanoutCone(ModRef x, const list<ModRef> &coneRoots, 
                                list<ModRef> &transitiveFanout, bool includeRoots = true);
    
    static void   getFaninRoots(ModRef x, list<ModRef> &faninRoots);
    static void   getFanoutRoots(ModRef x, list<ModRef> &fanoutRoots);

    
    static bool         testEquivalence(ModRef x, ModRef y);
    static void         setEquivalent(ModRef x, ModRef y);
    static void         getEquivalents(ModRef x, list<ModRef> & result);
    static void         removeEquivalences(ModRef x) {
        getGraph(x)->removeEquivalences(x.ref);
    }
    static void         chooseEquivalent(ModRef x) {
        getGraph(x)->chooseEquivalent(x.ref);
    }

    static void         getFanoutOfEquivalentNodes(ModRef x, list<ModRef> & result);
    */


    /*
    static void         print(oa::oaModule *module);
    
    static void         getAllNodes(oa::oaModule *module, list<ModRef> &result);
    static void         getInputs(oa::oaModule *module, list<ModRef> &result);
    */
    static void         getOutputs(oa::oaModule *module, list<ModRef> &result);
    /*
    static void         getLocalStates(oa::oaModule *module, list<ModRef> &result);    

    static void                getAllConnections(oa::oaModBitNet *net,
                                    set<oa::oaModBitNet*> &connectedNets,
                                    set<ModRef> &connectedRefs,
                                    bool searchForwardThroughGraph = true,
                                    bool searchBackwardThroughGraph = true,
                                    bool searchThroughEquivNets = true,
                                    bool searchThroughEquivRefs = false,
                                    bool includeSelf = true);
    static void                getAllConnections(ModRef x, 
                                    set<oa::oaModBitNet*> &connectedNets,
                                    set<ModRef> &connectedRefs,
                                    bool searchForwardThroughGraph = true,
                                    bool searchBackwardThroughGraph = true,
                                    bool searchThroughEquivNets = true,
                                    bool searchThroughEquivRefs = false,
                                    bool includeSelf = true);

    
    static void         incrementExternalReferences(ModRef x) {
        getGraph(x)->incrementExternalReferences(x.ref);
    }
    static void         decrementExternalReferences(ModRef x) {
        getGraph(x)->decrementExternalReferences(x.ref);
    }
    static void         clearExternalReferences(ModRef x) {
        getGraph(x)->clearExternalReferences(x.ref);
    }
    */


    public:
  
    static inline RtlGraph *   getGraph(oa::oaDesign *design) {
        return &(Manager::get(design)->bbg);
    }
    static inline RtlGraph *   getGraph(oa::oaModule *module) {
        return &(Manager::get(module->getDesign())->bbg);
    }
    static inline RtlGraph *   getGraph(const ModRef &x) {
        return &(Manager::get(x.module->getDesign())->bbg);
    }

    static void             failIfInDifferentModules(oa::oaModule *x, oa::oaModule *y);
    static void             failIfInDifferentModules(ModRef x, ModRef y) {
        failIfInDifferentModules(x.module, y.module);
    }
    
    static oa::oaModule*    convertModRefListToRefList(const list<ModRef> & source,
                                                       list<BBRef> & result);
    static void             convertRefListToModRefList(const list<BBRef> & source,
                                                       oa::oaModule *module,
                                                       list<ModRef> & result);
    static void             convertRefVectorToModRefVector(const vector<BBRef> & source,
                                                           oa::oaModule *module,
                                                           vector<ModRef> & result);
};

}

#endif

---