oagFpgaAiModGraph.cpp

Go to the documentation of this file.

#include "oagFpga.h"
#include "oagFpgaAiModGraph.h"
#include <set>

#include "oagFpgaDebug.h"

namespace oagFpga {


// *****************************************************************************
// failIfInDifferentModules()
//
//
// *****************************************************************************
inline void
AiModGraph::failIfInDifferentModules(oa::oaModule *x, oa::oaModule *y) {
    if (x != y) {
        cerr << "ERROR: Expected AiModRefs that refer to nodes in the same module" << endl;    
        QUIT_ON_ERROR;
    }
}     


// *****************************************************************************
// convertRefListToAiModRefList()
//
//
// *****************************************************************************
void
AiModGraph::convertRefListToAiModRefList(const list<oagAi::Ref> & source,
                                     oa::oaModule *module,
                                     list<AiModRef> & result) {
    for(list<oagAi::Ref>::const_iterator it = source.begin(); it != source.end(); ++it) {
        result.push_back(AiModRef(*it, module));
    }
}


// *****************************************************************************
// convertAiModRefListToRefList()
//
//
// *****************************************************************************
oa::oaModule*
AiModGraph::convertAiModRefListToRefList(const list<AiModRef> & source,
                                     list<oagAi::Ref> & result) {
    if (source.empty()) return NULL;
    oa::oaModule *module = source.front().module;
    for(list<AiModRef>::const_iterator it = source.begin(); it != source.end(); ++it) {
      assert(it->module == module);
      result.push_back(it->ref);
    }
    return module;
}


// *****************************************************************************
// convertRefVectorToAiModRefVector()
//
//
// *****************************************************************************
void
AiModGraph::convertRefVectorToAiModRefVector(const vector<oagAi::Ref> & source,
                                         oa::oaModule *module,
                                         vector<AiModRef> & result) {
  result.reserve(source.size());
  for(vector<oagAi::Ref>::const_iterator it = source.begin(); it != source.end(); ++it) {
    result.push_back(AiModRef(*it, module));
  }
}


// *****************************************************************************
// newAnd()
//
//
// *****************************************************************************
AiModRef
AiModGraph::newAnd(AiModRef x, AiModRef y) {
    failIfInDifferentModules(x,y);
    
    return AiModRef(getGraph(x)->newAnd(x.ref, y.ref), x.module);
}


// *****************************************************************************
// andOf()
//
// *****************************************************************************
AiModRef
AiModGraph::andOf(AiModRef x, AiModRef y) {
    failIfInDifferentModules(x,y);
    
    return AiModRef(getGraph(x)->andOf(x.ref, y.ref), x.module);
}
    

// *****************************************************************************
// setTerminalDriver()
//
// *****************************************************************************
void
AiModGraph::setTerminalDriver(AiModRef terminal, AiModRef driver) {
    failIfInDifferentModules(terminal, driver);

    getGraph(terminal)->setTerminalDriver(terminal.ref, driver.ref);
}


// *****************************************************************************
// setAndLeft()
//
//
// *****************************************************************************
void
AiModGraph::setAndLeft(AiModRef x, AiModRef left) {
    failIfInDifferentModules(x,left);

    getGraph(x)->setAndLeft(x.ref, left.ref);
}


// *****************************************************************************
// setAndRight()
//
//
// *****************************************************************************
void
AiModGraph::setAndRight(AiModRef x, AiModRef right) {
    failIfInDifferentModules(x,right);

    getGraph(x)->setAndRight(x.ref, right.ref);
}


// *****************************************************************************
// setNextState()
//
//
// *****************************************************************************
void
AiModGraph::setNextState(AiModRef sequential, AiModRef nextState) {
    failIfInDifferentModules(sequential, nextState);

    getGraph(sequential)->setNextState(sequential.ref, nextState.ref);
}


// *****************************************************************************
// resubsitute()
//
//
// *****************************************************************************
void
AiModGraph::resubstitute(AiModRef original, AiModRef replacement) {
    failIfInDifferentModules(original, replacement);

    getGraph(original)->resubstitute(original.ref, replacement.ref);
}


// *****************************************************************************
// resubsitute()
//
//
// *****************************************************************************
void
AiModGraph::resubstitute(AiModRef original, AiModRef replacement, AiModRef target) {
    failIfInDifferentModules(original, replacement);
    failIfInDifferentModules(original, target);
    
    getGraph(original)->resubstitute(original.ref, replacement.ref, target.ref);
}


// *****************************************************************************
// detach()
//
//
// *****************************************************************************
void
AiModGraph::detach(AiModRef x) {

    getGraph(x)->detach(x.ref);
}


// *****************************************************************************
//  hasCombinationalCycle()
//
// *****************************************************************************
bool
AiModGraph::hasCombinationalCycle(oa::oaModule *module) {
    return getGraph(module)->hasCombinationalCycle();
}


// *****************************************************************************
// enumerateKfeasibleCuts()
//
// *****************************************************************************
AiModGraph::CutSet
AiModGraph::enumerateKfeasibleCuts(AiModRef x, unsigned int maxCutSize, 
                                 int maxCutCount, int maxCutDepth,
                                 bool includeConstantNode) {
  oagAi::Graph::CutSet *source = getGraph(x)->enumerateKfeasibleCuts(x.ref, 
                                                                     maxCutSize, maxCutCount, maxCutDepth,
                                                                     includeConstantNode);

    // convert cuts in Refs to cuts in AiModRefs
    CutSet result;
    for(oagAi::Graph::CutSet::iterator setIter = source->begin(); setIter != source->end(); ++setIter) {
        Cut    resultCut;
        for(oagAi::Graph::Cut::iterator cutIter = setIter->begin(); cutIter != setIter->end(); ++cutIter) {
            resultCut.insert(AiModRef(*cutIter, x.module));
        }
        result.push_back(resultCut);
    }
    return result;
}


// *****************************************************************************
// clearKfeasibleCuts()
//
//
// *****************************************************************************
void
AiModGraph::clearKfeasibleCuts(oa::oaModule *module) {
    getGraph(module)->clearKfeasibleCuts();
}


// *****************************************************************************
// getFanout()
//
//
// *****************************************************************************
list<AiModRef>
AiModGraph::getFanout(AiModRef x) {
    list<AiModRef> result;
    convertRefListToAiModRefList(getGraph(x)->getFanout(x.ref), x.module, result);
    return result;
}
    
    
// *****************************************************************************
// getFanout()
//
//
// *****************************************************************************
void
AiModGraph::getFanout(AiModRef x, list<AiModRef> &result) {
    convertRefListToAiModRefList(getGraph(x)->getFanout(x.ref), x.module, result);
}


// *****************************************************************************
// getTransitiveFanin()
//
//
// *****************************************************************************
void
AiModGraph::getTransitiveFanin(AiModRef x, list<AiModRef> &transitiveFanin, 
                             bool includeRoots, bool crossSequential) {
    list<oagAi::Ref> flatResult;
    getGraph(x)->getTransitiveFanin(x.ref, flatResult, 
                                    includeRoots, crossSequential);
    convertRefListToAiModRefList(flatResult, x.module, transitiveFanin);
}


// *****************************************************************************
// getTransitiveFanout()
//
//
// *****************************************************************************
void
AiModGraph::getTransitiveFanout(AiModRef x, list<AiModRef> &transitiveFanout,
                              bool includeRoots, bool crossSequential) {
    list<oagAi::Ref> flatResult;
    getGraph(x)->getTransitiveFanout(x.ref, flatResult, 
                                     includeRoots, crossSequential);
    convertRefListToAiModRefList(flatResult, x.module, transitiveFanout);
}


// *****************************************************************************
// getTransitiveFanin()
//
//
// *****************************************************************************
void
AiModGraph::getTransitiveFanin(AiModRef x, vector<AiModRef> &transitiveFanin,
                             bool includeRoots, bool crossSequential) {
    vector<oagAi::Ref> flatResult;
    getGraph(x)->getTransitiveFanin(x.ref, flatResult, 
                                    includeRoots, crossSequential);
    convertRefVectorToAiModRefVector(flatResult, x.module, transitiveFanin);
}


// *****************************************************************************
// getTransitiveFanout()
//
//
// *****************************************************************************
void
AiModGraph::getTransitiveFanout(AiModRef x, vector<AiModRef> &transitiveFanout,
                              bool includeRoots, bool crossSequential) {
    vector<oagAi::Ref> flatResult;
    getGraph(x)->getTransitiveFanout(x.ref, flatResult, 
                                     includeRoots, crossSequential);
    convertRefVectorToAiModRefVector(flatResult, x.module, transitiveFanout);
}


// *****************************************************************************
// getTransitiveFanin()
//
//
// *****************************************************************************
void
AiModGraph::getTransitiveFanin(list<AiModRef> x, list<AiModRef> &transitiveFanin, 
                             bool includeRoots, bool crossSequential) {
    if (x.empty()) return;
    list<oagAi::Ref> flatInput;
    oa::oaModule *module = convertAiModRefListToRefList(x, flatInput);
    list<oagAi::Ref> flatResult;
    getGraph(module)->getTransitiveFanin(flatInput, flatResult, 
                                         includeRoots, crossSequential);
    convertRefListToAiModRefList(flatResult, module, transitiveFanin);
}


// *****************************************************************************
// getTransitiveFanout()
//
//
// *****************************************************************************
void
AiModGraph::getTransitiveFanout(list<AiModRef> x, list<AiModRef> &transitiveFanout,
                              bool includeRoots, bool crossSequential) {
    if (x.empty()) return;
    list<oagAi::Ref> flatInput;
    oa::oaModule *module = convertAiModRefListToRefList(x, flatInput);
    list<oagAi::Ref> flatResult;
    getGraph(module)->getTransitiveFanout(flatInput, flatResult, 
                                          includeRoots, crossSequential);
    convertRefListToAiModRefList(flatResult, module, transitiveFanout);
}


// *****************************************************************************
// getTransitiveFanin()
//
//
// *****************************************************************************
void
AiModGraph::getTransitiveFanin(list<AiModRef> x, vector<AiModRef> &transitiveFanin,
                             bool includeRoots, bool crossSequential) {
    if (x.empty()) return;
    list<oagAi::Ref> flatInput;
    oa::oaModule *module = convertAiModRefListToRefList(x, flatInput);
    vector<oagAi::Ref> flatResult;
    getGraph(module)->getTransitiveFanin(flatInput, flatResult, 
                                         includeRoots, crossSequential);
    convertRefVectorToAiModRefVector(flatResult, module, transitiveFanin);
}


// *****************************************************************************
// getTransitiveFanout()
//
//
// *****************************************************************************
void
AiModGraph::getTransitiveFanout(list<AiModRef> x, vector<AiModRef> &transitiveFanout,
                              bool includeRoots, bool crossSequential) {
    if (x.empty()) return;
    list<oagAi::Ref> flatInput;
    oa::oaModule *module = convertAiModRefListToRefList(x, flatInput);
    vector<oagAi::Ref> flatResult;
    getGraph(module)->getTransitiveFanout(flatInput, flatResult, 
                                          includeRoots, crossSequential);
    convertRefVectorToAiModRefVector(flatResult, module, transitiveFanout);
}


// *****************************************************************************
// getFaninRoots()
//
//
// *****************************************************************************
void
AiModGraph::getFaninRoots(AiModRef x, list<AiModRef> &faninRoots) {
    list<oagAi::Ref> flatResult;
    getGraph(x)->getFaninRoots(x.ref, flatResult);
    
    convertRefListToAiModRefList(flatResult, x.module, faninRoots);
}


// *****************************************************************************
// getFanoutRoots()
//
//
// *****************************************************************************
void
AiModGraph::getFanoutRoots(AiModRef x, list<AiModRef> &fanoutRoots) {
    list<oagAi::Ref> flatResult;
    getGraph(x)->getFanoutRoots(x.ref, flatResult);
    
    convertRefListToAiModRefList(flatResult, x.module, fanoutRoots);
}


// *****************************************************************************
// testEquivalence()
//
//
// *****************************************************************************
bool
AiModGraph::testEquivalence(AiModRef x, AiModRef y) {
    failIfInDifferentModules(x,y);

    return getGraph(x)->testEquivalence(x.ref, y.ref);
}


// *****************************************************************************
// setEquivalent()
//
//
// *****************************************************************************
void
AiModGraph::setEquivalent(AiModRef x, AiModRef y) {
    failIfInDifferentModules(x,y);

    getGraph(x)->setEquivalent(x.ref, y.ref);
}


// *****************************************************************************
// getEquivalents()
//
//
// *****************************************************************************
void
AiModGraph::getEquivalents(AiModRef x, list<AiModRef> & result) {
    list<oagAi::Ref> flatResult;
    getGraph(x)->getEquivalents(x.ref, flatResult);
    
    convertRefListToAiModRefList(flatResult, x.module, result);
}


// *****************************************************************************
// getFanoutOfEquivalentNodes()
//
//
// *****************************************************************************
void
AiModGraph::getFanoutOfEquivalentNodes(AiModRef x, list<AiModRef> &result) {
    list<oagAi::Ref> flatResult;
    getGraph(x)->getFanoutOfEquivalentNodes(x.ref, flatResult);
    
    convertRefListToAiModRefList(flatResult, x.module, result);
}


// *****************************************************************************
// prepareNetToAiConnection()
//
//
// *****************************************************************************
AiModRef   
AiModGraph::prepareNetToAiConnection(oa::oaModBitNet *net) {
    Manager *manager = Manager::get(net->getDesign());
    return AiModRef(manager->prepareNetToAiConnection(net), net->getModule());
}


// *****************************************************************************
// getNetToAiConnection()
//
//
// *****************************************************************************
oa::oaModBitNet *   
AiModGraph::getNetToAiConnection(AiModRef x) {
    Manager *manager = Manager::get(x.module->getDesign());
    return manager->getNetToAiConnection(x.ref);
}


// *****************************************************************************
// getNetToAiConnection()
//
//
// *****************************************************************************
AiModRef
AiModGraph::getNetToAiConnection(oa::oaModBitNet *net) {
    Manager *manager = Manager::get(net->getDesign());
    return AiModRef(manager->getNetToAiConnection(net), net->getModule());
}


// *****************************************************************************
// setNetToAiConnection()
//
//
// *****************************************************************************
void
AiModGraph::setNetToAiConnection(oa::oaModBitNet *net, AiModRef x) {
    failIfInDifferentModules(net->getModule(), x.module);

    Manager *manager = Manager::get(x.module->getDesign());
    manager->setNetToAiConnection(net, x.ref);
}


// *****************************************************************************
// removeNetToAiConnection()
//
//
// *****************************************************************************
void
AiModGraph::removeNetToAiConnection(oa::oaModBitNet *net) {
    Manager *manager = Manager::get(net->getDesign());
    manager->removeNetToAiConnection(net);
}


// *****************************************************************************
// getOutputs()
//
//
// *****************************************************************************
void         
AiModGraph::getOutputs(oa::oaModule *module, list<AiModRef> &result) {
    assert(module);
    oa::oaModTerm *term;
    oa::oaIter<oa::oaModTerm> termIter(module->getTerms(oacTermIterSingleBit));
    while((term = termIter.getNext())) {
        if(term->getTermType() == oa::oacOutputTermType) {
            result.push_back(prepareNetToAiConnection(toBitNet(term->getNet())));
        }
    }
}


// *****************************************************************************
// getInputs()
//
//
// *****************************************************************************
void         
AiModGraph::getInputs(oa::oaModule *module, list<AiModRef> &result) {
    assert(module);
    oa::oaModTerm *term;
    oa::oaIter<oa::oaModTerm> termIter(module->getTerms(oacTermIterSingleBit));
    while((term = termIter.getNext())) {
        if(term->getTermType() == oa::oacInputTermType) {
            result.push_back(prepareNetToAiConnection(toBitNet(term->getNet())));
        }
    }
}


// *****************************************************************************
// getAllNodes()
//
//
// *****************************************************************************
void         
AiModGraph::getAllNodes(oa::oaModule *module, list<AiModRef> &result) {
    assert(module);

    // add the state bits inside this object
    list<oagAi::Ref> flatResult;
    getGraph(module)->getAll(flatResult);
    convertRefListToAiModRefList(flatResult, module, result);

}


// *****************************************************************************
// getLocalStates()
//
//
// *****************************************************************************
void         
AiModGraph::getLocalStates(oa::oaModule *module, list<AiModRef> &result) {
    assert(module);

    // add the state bits inside this object
    list<oagAi::Ref> flatResult;
    getGraph(module)->getAllSequential(flatResult);
    convertRefListToAiModRefList(flatResult, module, result);
}


// *****************************************************************************
// getAllConnections()
//
//
// *****************************************************************************
void
AiModGraph::getAllConnections(oa::oaModBitNet *net, 
                            set<oa::oaModBitNet*> &connectedNets,
                            set<AiModRef> &connectedRefs,
                            bool searchForwardThroughGraph,
                            bool searchBackwardThroughGraph,
                            bool searchThroughEquivNets,
                            bool searchThroughEquivRefs,
                            bool includeSelf) {
    assert(net);
    
    // has this net been visited?
    if (connectedNets.find(net) == connectedNets.end()) {
        connectedNets.insert(net);
    } else {
        return;
    }

    // --- directly connected refs
    getAllConnections(getNetToAiConnection(net), connectedNets, connectedRefs,
                searchForwardThroughGraph, searchBackwardThroughGraph,
                searchThroughEquivNets, searchThroughEquivRefs, true);
    
    // --- equivalent nets (if searchThroughEquivNets)
    if (searchThroughEquivNets) {
        oa::oaModBitNet *equivNet;
        oa::oaIter<oa::oaModBitNet> equivIter(net->getEquivalentNets());
        while((equivNet = equivIter.getNext())) {
            getAllConnections(equivNet, connectedNets, connectedRefs,
                searchForwardThroughGraph, searchBackwardThroughGraph,
                searchThroughEquivNets, searchThroughEquivRefs, true);
        }
    }
    
    // -- exclude self
    if (!includeSelf) {
        connectedNets.erase(net);
    }
}


// *****************************************************************************
// getAllConnections()
//

//
// *****************************************************************************    
void 
AiModGraph::getAllConnections(AiModRef x, 
                            set<oa::oaModBitNet*> &connectedNets,
                            set<AiModRef> &connectedRefs,
                            bool searchForwardThroughGraph,
                            bool searchBackwardThroughGraph,
                            bool searchThroughEquivNets,
                            bool searchThroughEquivRefs,
                            bool includeSelf) {
    if (isNull(x)) {
        return;
    }

    // has this ref been visited?
    if (connectedRefs.find(x) == connectedRefs.end()) {
        connectedRefs.insert(x);
    } else {
        return;
    }
    
    // --- directly connected nets
    if (isTerminal(x) && !isInverted(x)) {
        oa::oaModBitNet *net;
        if ((net = getNetToAiConnection(x))) {
            getAllConnections(net, connectedNets, connectedRefs,
                searchForwardThroughGraph, searchBackwardThroughGraph,
                searchThroughEquivNets, searchThroughEquivRefs, true);
        }
    }

    // --- connected backward through graph (if searchBackwardThroughGraph)
    if (searchBackwardThroughGraph) {
        // terminal drivers
        if (isTerminal(x)) {
            AiModRef driver = getTerminalDriver(x);
            driver = isInverted(x) ? notOf(driver) : driver;
            getAllConnections(driver, connectedNets, connectedRefs,
                searchForwardThroughGraph, searchBackwardThroughGraph,
                searchThroughEquivNets, searchThroughEquivRefs, true);
        }
    }

    // --- connected forward through graph (if searchForwardThroughGraph)
    if (searchForwardThroughGraph) {
        // terminals in fanout
        list<AiModRef> fanoutList;
        getFanout(x, fanoutList);
        while(!fanoutList.empty()) {
            AiModRef fanout(fanoutList.front());
            fanoutList.pop_front();
            if(isTerminal(fanout)) {
                fanout = isInverted(x) ? notOf(fanout) : fanout;
                fanout = isInverted(getTerminalDriver(fanout)) ? notOf(fanout) : fanout;
                getAllConnections(fanout, connectedNets, connectedRefs,
                    searchForwardThroughGraph, searchBackwardThroughGraph,
                    searchThroughEquivNets, searchThroughEquivRefs, true);
            }
        }
    }

    // --- equivalent nodes (if searchThroughEquivRefs)
    if (searchThroughEquivRefs) {
        list<AiModRef> equivList;
        getEquivalents(x, equivList);
        while(!equivList.empty()) {
            AiModRef equiv(equivList.front());
            equivList.pop_front();
            getAllConnections(equiv, connectedNets, connectedRefs,
                searchForwardThroughGraph, searchBackwardThroughGraph,
                searchThroughEquivNets, searchThroughEquivRefs, true);
        }
    }
    
    // -- exclude self
    if (!includeSelf) {
        connectedRefs.erase(x);
    }
}


// *****************************************************************************
// findDriverOfEquivalentNets()
//
//
// *****************************************************************************
oa::oaModBitNet *
AiModGraph::findDriverOfEquivalentNets(oa::oaModBitNet *net) {
    assert(net);

    // ignore if there are no equivalent nets
    if (net->getEquivalentNets().isEmpty()) {
      return NULL;
    }

    // ignore if there is already a driver in the graph
    AiModRef termRef = getNetToAiConnection(net);
    if (!isNull(termRef) && !isNull(getTerminalDriver(termRef))) {    
      return NULL;
    }

    // iterate over equivalent nets to find driver
    oa::oaModBitNet *equivNet;
    oa::oaIter<oa::oaModBitNet> equivNetIter(net->getEquivalentNets());

    DEBUG_PRINT("Equivalent set : ");
    while ((equivNet = equivNetIter.getNext())) {
      assert(equivNet);
      
      oa::oaString netString;
      equivNet->getName(oa::oaVerilogNS(), netString);
      DEBUG_PRINTMORE(netString << " ");

      // is this driven in the graph?
      AiModRef termRef = getNetToAiConnection(equivNet);
      if (!isNull(termRef) && !isNull(getTerminalDriver(termRef))) {
        // avoid combinational cycles
        AiModRef driverRef = termRef;
        while(true) {
          oa::oaModBitNet *net2 = getNetToAiConnection(driverRef);
          if (net2 && net2 == net) {
            // net can't be in a cycle with itself
            return NULL;
          }
          driverRef = getTerminalDriver(driverRef);
          if (isNull(driverRef) || !isTerminal(driverRef)) {
            break;
          }
        }
        return equivNet;
      }
      
      // is an input terminal attached?
      oa::oaModTerm *term;
      oa::oaIter<oa::oaModTerm> termIter(equivNet->getTerms(oacTermIterSingleBit));
      while((term = termIter.getNext())) {
        assert(term);
        if(term->getTermType() == oa::oacInputTermType) {
          return equivNet;
        }
      }
    }
    DEBUG_PRINTMORE("\n");
    
    // is there a preferred equivalent?
    /*
    // NOTE: This appears to be broken.  A preferred net is sometimes
    // returned when none has been set.  Reason unknown.

    if (net->getPreferredEquivalent() != net) {
      return net->getPreferredEquivalent();
    }
    */

    return NULL;
}


// *****************************************************************************
// connectEquivalentNetsInGraph()
//
// *****************************************************************************
void
AiModGraph::connectEquivalentNetsInGraph(oa::oaModule *module) {
  assert(module);

  oa::oaModNet *net;
  oa::oaIter<oa::oaModNet> netIter(module->getNets(oacNetIterSingleBit));
  while((net = netIter.getNext())) {
    oa::oaModBitNet *bitNet = toBitNet(net);
    assert(bitNet);
    AiModRef termNode = getNetToAiConnection(bitNet);
    assert(!isNull(termNode));
    if (!isNull(getTerminalDriver(termNode))) {
      continue;
    }

    oa::oaModBitNet *driverNet = findDriverOfEquivalentNets(bitNet);

    if (driverNet) {      
      AiModRef driver = getNetToAiConnection(driverNet);
#if defined(DEBUG)
      cout << "Moving equivalent nets to graph : node ";
      termNode.printName(false);
      cout << " was ";
      getTerminalDriver(termNode).printName();
      cout << " is now driven by ";
      driver.printName(true);
      cout << endl;
#endif
      setTerminalDriver(termNode, driver);
    }
  }
}


// *****************************************************************************
// print()
//
//
// *****************************************************************************
void                
AiModGraph::print(oa::oaModule *module) {
  assert(module);

  list<AiModRef> all;
  getAllNodes(module, all);
  for(list<AiModRef>::iterator it = all.begin(); it!=all.end(); it++) {
    it->print();
  }
}


// *****************************************************************************
// print()
//
//
// *****************************************************************************
void                
AiModRef::print(bool lineFeed) {
    const int TYPE_COL_WIDTH = 4;
    const int MODULE_COL_WIDTH = 20;
    const int REF_COL_WIDTH = 5;

    oa::oaString modString;
    if (!module) {
        modString = "(null)";
    } else {
        module->getName(oa::oaVerilogNS(), modString);
    }

    if (AiModGraph::getNodeType(*this) == oagAi::Node::AND) {
        cout.width(TYPE_COL_WIDTH);
        cout << "AND ";
        cout.width(MODULE_COL_WIDTH);
        cout << modString << ".";
        cout.width(REF_COL_WIDTH);
        cout << ref << " :\t";
        cout << AiModGraph::getAndLeft(*this).ref << ", " << AiModGraph::getAndRight(*this).ref;
    } else if (AiModGraph::getNodeType(*this) == oagAi::Node::SEQUENTIAL) {
        cout.width(TYPE_COL_WIDTH);
        cout << "SEQ ";
        cout.width(MODULE_COL_WIDTH);
        cout << modString << ".";
        cout.width(REF_COL_WIDTH);
        cout << ref << " :\t";
        cout << AiModGraph::getNextState(*this).ref;
    } else if (AiModGraph::getNodeType(*this) == oagAi::Node::CONSTANT0) {
        cout.width(TYPE_COL_WIDTH);
        cout << "ZRO ";
        cout.width(MODULE_COL_WIDTH);
        cout << modString << ".";
        cout.width(REF_COL_WIDTH);
        cout << ref << " :\t";
    } else if (AiModGraph::getNodeType(*this) == oagAi::Node::TERMINAL) {
        cout.width(TYPE_COL_WIDTH);
        cout << "TRM ";
        cout.width(MODULE_COL_WIDTH);
        cout << modString << ".";
        cout.width(REF_COL_WIDTH);
        cout << ref << " :\t";
        cout << AiModGraph::getTerminalDriver(*this).ref;
        cout << " net= ";
        oa::oaModBitNet *net = AiModGraph::getNetToAiConnection(*this);
        if (net) {
          oa::oaString netString;
          net->getName(oa::oaVerilogNS(), netString);
          cout << netString;
        } else {
          cout << "*none*";
        }
    } else if (AiModGraph::getNodeType(*this) == oagAi::Node::NONE) {
        cout.width(TYPE_COL_WIDTH);
        cout << "NUL ";
        cout.width(MODULE_COL_WIDTH);
        cout << modString << ".";
        cout.width(REF_COL_WIDTH);
        cout << ref << " :\t";
    }

    if (AiModGraph::isInverted(*this)) {
        cout << " (inverted)";
    }
    
    if (lineFeed) {
        cout << endl;
    }
}


// *****************************************************************************
// printName()
//
//
// *****************************************************************************
void                
AiModRef::printName(bool lineFeed) {

    oa::oaString modString;
    if (!module) {
        modString = "(null)";
    } else {
        module->getName(oa::oaVerilogNS(), modString);
    }

    cout << modString << "." << ref;
    
    if (lineFeed) {
        cout << endl;
    }
}


// *****************************************************************************
// getFaninCone()
//
//
// *****************************************************************************
void
AiModGraph::getFaninCone(AiModRef x, const list<AiModRef> &coneRoots, 
                       list<AiModRef> &transitiveFanin, bool includeRoots) {

  list<oagAi::Ref> flatCut;
  oa::oaModule *module = convertAiModRefListToRefList(coneRoots, flatCut);
  assert(coneRoots.empty() || module == x.module);
  list<oagAi::Ref> flatResult;
  getGraph(x.module)->getFaninCone(x.ref, flatCut, flatResult, includeRoots);
  convertRefListToAiModRefList(flatResult, x.module, transitiveFanin);
}


// *****************************************************************************
// getFanoutCone()
//
//
// *****************************************************************************
void
AiModGraph::getFanoutCone(AiModRef x, const list<AiModRef> &coneRoots, 
                        list<AiModRef> &transitiveFanout, bool includeRoots) {
  
  list<oagAi::Ref> flatCut;
  oa::oaModule *module = convertAiModRefListToRefList(coneRoots, flatCut);
  assert(module == x.module);
  list<oagAi::Ref> flatResult;
  getGraph(x.module)->getFanoutCone(x.ref, flatCut, flatResult, includeRoots);
  convertRefListToAiModRefList(flatResult, x.module, transitiveFanout);
}

}

---