oagFpgaSimMod.cpp

Go to the documentation of this file.

#include "oagFpgaSimMod.h"
#include <iostream>

#include "oagFpgaDebug.h"

using namespace std;

namespace oagFpga {

// *****************************************************************************
// SimMod()
//
//
// *****************************************************************************
SimMod::SimMod(oa::oaDesign *design) { 
    assert(design);
    assert(design->getTopModule());
    this->design = design;
    clear();
    // determine BITS_PER_RAND
    BITS_PER_RAND = 0;
    for(unsigned int i=1; i<sizeof(int)*8; i++) {
      if (RAND_MAX >= (1<<i)) {
        BITS_PER_RAND++;
      }
    }
}


// *****************************************************************************
// clear()
//
//
// *****************************************************************************   
void
SimMod::clear() {
    toBeSimulated.clear();
    /*
    // refresh constant node
    AiModRef constant;
    constant = AiModGraph::constantZero(design->getTopModule());
    AiModGraph::setUserData(constant, SIM_USER_DATA_INDEX, 0);
    toBeSimulated.push_back(constant);
    */
}


// *****************************************************************************
// generateRandomStateVectors()
//
//
// *****************************************************************************
void
SimMod::generateRandomStateVectors() {
    list<AiModRef> states;
    AiModGraph::getLocalStates(design->getTopModule(), states);
    for(list<AiModRef>::iterator it=states.begin(); it!=states.end(); ++it) {
        setVector(*it, randomVector());
    }
}


// *****************************************************************************
// generateRandomInputVectors()
//
//
// *****************************************************************************
void
SimMod::generateRandomInputVectors() {
    list<AiModRef> inputs;
    AiModGraph::getInputs(design->getTopModule(), inputs);
    for(list<AiModRef>::iterator it=inputs.begin(); it!=inputs.end(); ++it) {
        setVector(*it, randomVector());
    }
}


// *****************************************************************************
// randomVector()
//
//
//
// *****************************************************************************
SimMod::SimVec
SimMod::randomVector() {
    const int RAND_MASK = (1 << BITS_PER_RAND) - 1;

    SimVec result = 0;
    int bits = sizeof(int)*8;
    while(bits>0) {
      result = (result << BITS_PER_RAND) | (rand() & RAND_MASK);
      bits -= BITS_PER_RAND;
    }
    return result;
}

    
// *****************************************************************************
// runOne()
//
//
// *****************************************************************************
void
SimMod::runOne(const AiModRef & ref) {
    assert(!AiModGraph::isInverted(ref));
    assert(ref.module);
    
#ifdef DEBUG_SIM
    oa::oaString nameString;
    ref.module->getName(nameString);
    DEBUG_PRINT("- ai " << nameString << "." << ref.ref << "\t");
#endif

    switch(AiModGraph::getNodeType(ref)) {
    case oagAi::Node::AND: {
      DEBUG_PRINTMORE("and");
      
      AiModRef left = AiModGraph::getAndLeft(ref);
      AiModRef nonInvLeft = AiModGraph::getNonInverted(left);
      AiModRef right = AiModGraph::getAndRight(ref);
      AiModRef nonInvRight = AiModGraph::getNonInverted(right);
      
      SimVec leftVec = 0;
      if(AiModGraph::getNodeType(nonInvLeft) == oagAi::Node::CONSTANT0) {
        leftVec = 0;
      } else {
        leftVec = AiModGraph::getUserData(nonInvLeft, SIM_USER_DATA_INDEX);
      }
      leftVec = AiModGraph::isInverted(left) ? ~leftVec : leftVec;
            
      SimVec rightVec = 0;
      if(AiModGraph::getNodeType(nonInvRight) == oagAi::Node::CONSTANT0) {
        rightVec = 0;
      } else {
        rightVec = AiModGraph::getUserData(nonInvRight, SIM_USER_DATA_INDEX);
      }
      rightVec = AiModGraph::isInverted(right) ? ~rightVec : rightVec;
            
      AiModGraph::setUserData(ref, SIM_USER_DATA_INDEX, leftVec & rightVec);
            
      break;
    }

    case oagAi::Node::SEQUENTIAL: {
      DEBUG_PRINTMORE("seq")
      break;
    }
            
    case oagAi::Node::TERMINAL: {
      DEBUG_PRINTMORE("terminal")

      AiModRef driver = AiModGraph::getTerminalDriver(ref);
      AiModRef nonInvDriver = AiModGraph::getNonInverted(driver);
      SimVec driverVec = 0;
      if(AiModGraph::getNodeType(nonInvDriver) == oagAi::Node::CONSTANT0) {
        driverVec = 0;
      } else {
        driverVec = AiModGraph::getUserData(nonInvDriver, SIM_USER_DATA_INDEX);
      }
      driverVec = AiModGraph::isInverted(driver) ? ~driverVec : driverVec;

      AiModGraph::setUserData(ref, SIM_USER_DATA_INDEX, driverVec);

      break;
    }
            
    default:
      QUIT_ON_INTERNAL_ERROR;
      break;
    }
    
    DEBUG_PRINTMORE(" vector=" << AiModGraph::getUserData(ref, SIM_USER_DATA_INDEX));
}


// *****************************************************************************
// runFull()
//
//
// *****************************************************************************
void
SimMod::runFull() {

    toBeSimulated.clear();

    // seed all the start points
    AiModGraph::getInputs(design->getTopModule(), toBeSimulated);
    AiModGraph::getLocalStates(design->getTopModule(), toBeSimulated);
    
    runIncremental();
}


// *****************************************************************************
// nextCycle()
//
//
// *****************************************************************************
void    
SimMod::nextCycle() {
    list<AiModRef> stateList;
    AiModGraph::getLocalStates(design->getTopModule(), stateList);
    for(list<AiModRef>::iterator it = stateList.begin();
        it != stateList.end(); ++it) {
        assert(!AiModGraph::isInverted(*it));
        AiModRef nextState = AiModGraph::getNextState(*it);
        AiModRef nonInvNextState = AiModGraph::getNonInverted(nextState);
        if (AiModGraph::isNull(nextState)) {
            // no next state input.  do nothing
        } else if (AiModGraph::isInverted(nextState)) {
          AiModGraph::setUserData(*it, SIM_USER_DATA_INDEX,
                                ~AiModGraph::getUserData(nonInvNextState, 
                                                       SIM_USER_DATA_INDEX));
        } else {
          AiModGraph::setUserData(*it, SIM_USER_DATA_INDEX,
                                AiModGraph::getUserData(nonInvNextState, 
                                                      SIM_USER_DATA_INDEX));
        }
        toBeSimulated.push_back(*it);
    }    
}


// *****************************************************************************
// runIncremental()
//
//
// *****************************************************************************
void
SimMod::runIncremental() {
  if (toBeSimulated.empty()) return;

  vector<AiModRef> topoOrder;
  AiModGraph::getTransitiveFanout(toBeSimulated, topoOrder, true);

  // simulate in forward topological order
  for(vector<AiModRef>::iterator it = topoOrder.begin();
      it != topoOrder.end(); it++) {
    // compute vector at node
    runOne(*it);
  }

  toBeSimulated.clear();
}

}

---