src/sim/simUtil.c

Go to the documentation of this file.

#include "simInt.h"
#include <sys/time.h>

static char rcsid[] UNUSED = "$Id: simUtil.c,v 1.8 2005/04/26 19:10:09 jinh Exp $";

/*---------------------------------------------------------------------------*/
/* Static function prototypes                                                */
/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/
/* Definition of exported functions                                          */
/*---------------------------------------------------------------------------*/

st_table *
Sim_NetworkBuildNodeToMvfTable(
  Ntk_Network_t *network,
  array_t       *nodesArray,
  int            internalPartitionHead,
  int            nextStateHead)
{
  array_t   *rootsName;
  array_t   *leavesMddId;
  array_t   *mvfArray;
  st_table  *nodeToMvfTable;

  SimNodesArrayBuildRootsAndLeaves(network, nodesArray, internalPartitionHead, nextStateHead, &rootsName, &leavesMddId);
  mvfArray = Part_PartitionBuildFunctions(Part_NetworkReadPartition(network),
                                          rootsName, leavesMddId, NIL(mdd_t));

  array_free(leavesMddId);
  array_free(rootsName);
  nodeToMvfTable = SimNodesArrayBuildNodeToMvfTable(nodesArray, internalPartitionHead, mvfArray);
  array_free(mvfArray);
  return(nodeToMvfTable);
}

/*---------------------------------------------------------------------------*/
/* Definition of internal functions                                          */
/*---------------------------------------------------------------------------*/
  
int
SimNodeReadValueCode(
  Ntk_Node_t * node,
  char       * value)
{
  int             index;
  Var_Variable_t *var = Ntk_NodeReadVariable(node);

  if (Var_VariableTestIsSymbolic(var)) {
    return(Var_VariableReadIndexFromSymbolicValue(var, value));
  }

  /* Enumerative or binary variable */
  else {
    index = atoi(value);
    if (index >= Var_VariableReadNumValues(var) || index < 0) {
      return(-1);
    }
    else {
      return(index);
    }
  }
}

boolean
SimTestPartInTermsOfCI(
  Sim_Sim_t *sim
  )
{
  int j, k, value, mddId;
  Ntk_Node_t *node, *supportNode;
  Mvf_Function_t *mvFunction;
  array_t *mddIdArray;
  
  /* if there are no internal nodes, return FALSE. This allows
     simulation to proceed when partition method inout is used.
     */
  if(sim->internalPartitionHead == sim->nextStateHead){
    return FALSE;
  }
  
  for (j = sim->nextStateHead; j < array_n(sim->nodesArray); j++) {
    node =  array_fetch(Ntk_Node_t *, sim->nodesArray, j);
    (void) st_lookup(sim->nodeToMvfTable, (char *) node, &mvFunction); 
    mddIdArray = Mvf_FunctionComputeSupport(mvFunction,
                            Ntk_NetworkReadMddManager(sim->network), &value);
    if(mddIdArray != NIL(array_t)){
      for(k = 0; k < array_n(mddIdArray); k++){
        mddId = array_fetch(int, mddIdArray, k);
        supportNode = Ntk_NetworkFindNodeByMddId(sim->network, mddId);
        if(!Ntk_NodeTestIsCombInput(supportNode)){
          array_free(mddIdArray);
          return FALSE;
        }
      }
      array_free(mddIdArray);
    }/* if array not nil */
  }/* for all nodes */
  
  return TRUE;
}

char *
SimInteger2ASCII(
  int  number)
{
  char * str = ALLOC(char, 21);

  (void) sprintf(str, "%d", number);
  return(str);
}
  

void
SimStringPrint(
  FILE * fp,
  char * string,
  int  len)
{
  int i;
  
  fprintf(fp, "%s", string);
  for(i = strlen(string); i < len; i++) {
    fprintf(fp, " ");
  }
  fprintf(fp, " ");
}
  
array_t *
SimSimInitDataFormat(
  Sim_Sim_t * sim)
{
  int           i, j;
  int           size;
  int           maxSize;
  int           numValue;
  boolean       symbolic;
  Ntk_Node_t   *node;
  Var_Variable_t *var;
  array_t      *formatArray = array_alloc(int, 0);
  
  for (j = 0; j < array_n(sim->nodesArray); j++) {
    node     = array_fetch(Ntk_Node_t *, sim->nodesArray, j);
    var      = Ntk_NodeReadVariable(node);
    symbolic = Var_VariableTestIsSymbolic(var);
    numValue = Var_VariableReadNumValues(var);
    maxSize = 0;
    if (symbolic) {
      for (i = 0; i < numValue; i++) {
        size = strlen(Var_VariableReadSymbolicValueFromIndex(var, i));
        if (size > maxSize) {
          maxSize = size;
        }
      }
    }
    else { /* Binary or enumertive type */
      while(numValue != 0) {
        maxSize++;
        numValue = numValue/10;
      }
    }
    array_insert_last(int, formatArray, maxSize);
  }
  return(formatArray);
}

void
SimSimVectorFillCurrentState(
  Sim_Sim_t * sim /* sim data-structure */,
  int  n /* index of nextState in the vectorArray */)
{
  int          i;
  array_t     *currentVector  = array_fetch(array_t *, sim->vectorArray, n-1);
  array_t     *nextVector     = array_fetch(array_t *, sim->vectorArray, n);
  
  for (i = sim->nextStateHead; i < sim->outputHead; i++) {
    /* We assume nextVector contains only the inputs : insert_last is convenient */
    int value = array_fetch(int, currentVector, i);
    array_insert_last(int, nextVector, value);
  }
}
 
int
SimNodeComputeRandomValue(
  Ntk_Node_t * node,
  Sim_PseudoSrc  pseudoInputSource)
{
  int value = 0; /* initialize so that lint doesn't complain */ 

  if (Ntk_NodeTestIsPseudoInput(node)) {
    Tbl_Entry_t *entry;
    int          rowNum;
    int          colNum;
    int          rowChoice;
    Tbl_Table_t *table     = Ntk_NodeReadTable(node);
    int          outIndex  = Ntk_NodeReadOutputIndex(node);

    /* Decide which row to take value from. */
    if (pseudoInputSource == Sim_First_c) {
      rowChoice = 0;
    }
    else {
      int numRows = Tbl_TableReadNumRows(table);
      rowChoice = ((int) util_random()) % numRows;
    }
    
    Tbl_TableForEachOutputEntry(table, rowNum, colNum, entry) {
      if ((colNum == outIndex) && (rowNum == rowChoice)) {
        Tbl_Range_t *range;
        lsGen        lsGen;
        int          tempValue;
        int          entryChoice;
        int          i = 0;

        /* We are now in rowChoice. Decide which value of entry to take. */
        if (pseudoInputSource == Sim_First_c) {
          entryChoice = 0;
        }
        else {
          int numValues = Tbl_EntryReadNumValues(entry);
          entryChoice = ((int) util_random()) % numValues;
        }
    
        Tbl_EntryForEachValue(entry, tempValue, lsGen, range) {
          if(entryChoice == i) {
            value = tempValue;
            /*
             * We could break out of the two FOR loops to avoid unnecessary
             * work. However, the inner loop has an lsGen that must be freed
             * if the loop is broken early, and I couldn't get lsFinish to be
             * called correctly.  Also, the table shouldn't be big to worry
             * about it.
             */
          }
          i++;
        }
      }
    }
  }
  else {
    Var_Variable_t *var = Ntk_NodeReadVariable(node);

    value = ((int) util_random()) % Var_VariableReadNumValues(var);
  }

  return value;
}


mdd_t *
SimSimVectorBuildMdd(
  Sim_Sim_t * sim,
  array_t * vector,
  array_t * partitionVector)
{
  int            i;
  int            value;
  mdd_t         *mddMinterm;
  Ntk_Node_t    *node;
  mdd_t         *literalMdd;
  mdd_t         *tmpMdd;
  Ntk_Network_t *network = sim->network;
  mdd_manager   *mddManager = Ntk_NetworkReadMddManager(network);

  mddMinterm = mdd_one(mddManager);
  for(i = 0; i < sim->internalPartitionHead; i++) { /* For every combinational input */

    node     = array_fetch(Ntk_Node_t *, sim->nodesArray, i);
    value    = array_fetch(int, vector, i);

    /* LiteralMdd will represent the mdd of  "Node-variable = value" */
    literalMdd = mdd_eq_c(mddManager, Ntk_NodeReadMddId(node), value);
    tmpMdd = mdd_and(literalMdd, mddMinterm, 1, 1);
    mdd_free(mddMinterm);
    mdd_free(literalMdd);
    mddMinterm = tmpMdd;
  }

  for(i = 0; i < array_n(partitionVector); i++) { /* For every internal Partition node */

    node     = array_fetch(Ntk_Node_t *, sim->nodesArray, i + sim->internalPartitionHead);
    value    = array_fetch(int, partitionVector, i);

    /* LiteralMdd will represent the mdd of  "Node-variable = value" */
    literalMdd = mdd_eq_c(mddManager, Ntk_NodeReadMddId(node), value);
    tmpMdd = mdd_and(literalMdd, mddMinterm, 1, 1);
    mdd_free(mddMinterm);
    mdd_free(literalMdd);
    mddMinterm = tmpMdd;
  }

  return(mddMinterm);
}

void
SimAppendErrorMsg(
  char * str1,
  char * str2,
  char * str3)
{
  error_append(str1);
  error_append(str2);
  error_append(str3);
}

int
SimComputeRandomInteger(void)
{
  struct timeval tp;
  struct timezone tzp;

  if ((int) gettimeofday(&tp,&tzp) == -1) {
    fprintf (vis_stderr, "sim : Error while calling gettimeofday.\n");
    exit(-1);
  }
  return((int) (tp.tv_sec));
}

void
SimNodesArrayBuildRootsAndLeaves(
  Ntk_Network_t *network,                                
  array_t *  nodesArray,
  int        internalPartitionHead,
  int        nextStateHead,
  array_t ** roots,
  array_t ** leaves)
{
  int         i;
  Ntk_Node_t *node;

  *roots  = array_alloc(char *, 0);
  *leaves = array_alloc(int, 0);

  for(i = 0; i < nextStateHead; i++) {
    node = array_fetch(Ntk_Node_t *, nodesArray, i);
    array_insert_last(int, *leaves, Ntk_NodeReadMddId(node));
  }

  for(i = internalPartitionHead; i < array_n(nodesArray); i++) {
    node = array_fetch(Ntk_Node_t *, nodesArray, i);
    array_insert_last(char *, *roots, Ntk_NodeReadName(node));
  }

}

st_table *
SimNodesArrayBuildNodeToMvfTable(
  array_t  * nodesArray,
  int        internalPartitionHead,
  array_t  * mvfArray)
{
  int         i;
  Ntk_Node_t *node;
  array_t    *mvf;
  st_table   *nodeToMvfTable = st_init_table(st_ptrcmp, st_ptrhash);
  
  for(i = internalPartitionHead; i < array_n(nodesArray); i++) {
    node = array_fetch(Ntk_Node_t *, nodesArray, i);
    mvf  = array_fetch(Mvf_Function_t *, mvfArray, i - internalPartitionHead);
    st_insert(nodeToMvfTable, (char *) node, (char *) mvf);
  }
  return(nodeToMvfTable);
}

/*---------------------------------------------------------------------------*/
/* Definition of static functions                                            */
/*---------------------------------------------------------------------------*/