oagFpgaOccGraph.h

Go to the documentation of this file.

#if !defined(oagFpgaOccGraph_P)
#define oagFpgaOccGraph_P

#include <stdlib.h>

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

using namespace std;

namespace oagFpga {

// *****************************************************************************
// OccGraph
//
// *****************************************************************************

class OccGraph {

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

    typedef set<OccRef> Cut;
    typedef list<Cut>   CutSet;


    static OccRef           getNull(oa::oaOccurrence *occurrence) {
        return OccRef(RtlGraph::getNull(), occurrence);
    }
    static inline bool      isNull(OccRef x) {
        return x.occurrence == NULL || RtlGraph::isNull(x.ref);
    }
    static inline OccRef    constantOne(oa::oaOccurrence *occurrence) {
        return OccRef(getGraph(occurrence)->constantOne(), occurrence);
    }
    static inline OccRef    constantZero(oa::oaOccurrence *occurrence) {
        return OccRef(getGraph(occurrence)->constantZero(), occurrence);
    }
    /*
    static inline OccRef notOf(OccRef x) {
        return OccRef(oagAi::Graph::notOf(x.ref), x.occurrence);
    }
    static inline bool       isInverted(OccRef x) {
        return oagAi::Graph::isInverted(x.ref);
    }
    static inline OccRef     getNonInverted(OccRef x) {
        return OccRef(oagAi::Graph::getNonInverted(x.ref), x.occurrence);
    }
    */
    

    static inline RtlNode::Type     getNodeType(OccRef x) {
        return getGraph(x)->getNodeType(x.ref);
    }

    //    on terminal nodes...
    static OccRef     getTerminalDriver(OccRef terminal, 
                                        bool searchThroughHierarchy = false);
    static inline bool       isTerminal(OccRef terminal) {
        return getGraph(terminal)->isTerminal(terminal.ref);
    }
    //    on sequential nodes...
    static inline OccRef     getNextState(OccRef sequential) {
        assert(isSequential(sequential));
        return OccRef(getGraph(sequential)->getNextState(sequential.ref), sequential.occurrence);
    }
    static inline bool       isSequential(OccRef sequential) {
        return getGraph(sequential)->isSequential(sequential.ref);
    }
    /*
    static oagAi::Node::SequentialData *getSequentialData(OccRef sequential) {
        return getGraph(sequential)->getSequentialData(sequential.ref);    
    }
    //    on and nodes...
    static inline OccRef     getAndLeft(OccRef x) {
        return OccRef(getGraph(x)->getAndLeft(x.ref), x.occurrence);
    }
    static inline OccRef     getAndRight(OccRef x) {
        return OccRef(getGraph(x)->getAndRight(x.ref), x.occurrence);
    }
    */
    
    static void              getFanout(OccRef x, list<OccRef> &result);
    static inline bool       hasFanout(OccRef x) {
        return getGraph(x)->hasFanout(x.ref);
    }


    // Net-to-BBRef connections
    static oa::oaOccBitNet *   getNetToBBConnection(OccRef ref);
    static OccRef              getNetToBBConnection(oa::oaOccBitNet *net);
    
    static void                getNetToBBAllEquivConnections(OccRef ref, 
                                            list<oa::oaOccBitNet *> &result);
    

    static void         getOutputs(oa::oaOccurrence *top, list<OccRef> &result);
    static void         getOutputs(oa::oaOccurrence *top, list<oa::oaOccBitNet*> &result);
    static void         getInputs(oa::oaOccurrence *top, list<OccRef> &result);
    static void         getInputs(oa::oaOccurrence *top, list<oa::oaOccBitNet*> &result);
    static void         getStates(oa::oaOccurrence *top, list<OccRef> &result);
    static void         getLocalStates(oa::oaOccurrence *top, list<OccRef> &result);
    static void         getConstants(oa::oaOccurrence *top, list<OccRef> &zeros, 
                                                                list<OccRef> &ones);

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

    /*
    static void         enumerateKfeasibleCuts(OccRef x, unsigned int maxCutSize, CutSet &result);
    static void         clearKfeasibleCuts(oa::oaOccurrence *occurrence);
    */

    static void         getTransitiveFanin(OccRef x, list<OccRef> &transitiveFanin);
    static void         getTransitiveFanout(OccRef x, list<OccRef> &transitiveFanout);
    /*
    static void         getFaninRoots(OccRef x, list<OccRef> &faninRoots);
    static void         getFanoutRoots(OccRef x, list<OccRef> &fanoutRoots);


    static bool         testEquivalence(OccRef x, OccRef y);
    static void         getEquivalents(OccRef x, list<OccRef> &result);

    static void         getFanoutOfEquivalentNodes(OccRef x, list<OccRef> &result);

    */

  private:
                       
    static inline RtlGraph *   getGraph(oa::oaOccurrence *occurrence) {
        return &(Manager::get(occurrence->getModule()->getDesign())->bbg);
    }
    static inline RtlGraph *   getGraph(const OccRef &x) {
        return &(Manager::get(x.occurrence->getModule()->getDesign())->bbg);
    }
    
    static void             convertRefListToOccRefList(const list<BBRef> &source,
                                                       oa::oaOccurrence *occurrence,
                                                       list<OccRef> &result);
};

}

#endif

---