src/sim/simIo.c

Go to the documentation of this file.

#include "simInt.h"

static char rcsid[] UNUSED = "$Id: simIo.c,v 1.5 2005/05/10 15:50:43 hhkim Exp $";

/*---------------------------------------------------------------------------*/
/* Constant declarations                                                     */
/*---------------------------------------------------------------------------*/

/*
 * Maximum permissible length of a line in the simulation file.
 */
#define MAX_LINE_LENGTH 500000


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

static array_t * SimObtainInputsArray(Sim_Sim_t * sim);
static void FreeArrays(array_t *array1, array_t *array2, array_t *array3, array_t *array4);
static array_t * BufferBuildInputsNodeArray(char * buffer, Ntk_Network_t * network);
static array_t * BufferBuildLatchesNodeArray(char * buffer, Ntk_Network_t * network);
static array_t * BufferBuildOutputsNodeArray(char * buffer, Ntk_Network_t * network);
static array_t * BufferBuildValuesArray(char * buffer, array_t * nodesArray);
static void SimAddVector(Sim_Sim_t * sim, array_t * vector);
static void BufferSkipWhiteSpace(char * buffer, int * position);
static char * BufferObtainStringAtPosition(char * buffer, int * position);
static void PrintValue(array_t *nodesArray, array_t *vector, int vectorIndex, int strSize, FILE *file);

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

void
Sim_SimPrint(
  Sim_Sim_t       * sim,
  FILE            * of,
  boolean         printMode,
  int             printInputsFlag,
  int             printOutputsFlag,
  int             printPseudoInputsFlag,
  int             printStatesFlag
  )

{
  int             i, j;
  char           *str;
  array_t        *vector = NIL(array_t);
  array_t        *formatArray;
  Ntk_Node_t     *node;
  Var_Variable_t *var;
  int             index;
  int             strSize     = 0;
  int             numNodes    = array_n(sim->nodesArray);  
  int             inputWidth  = sim->currentStateHead;

  if(sim->verbose) {
    (void) printf("Printing %d vectors...\n", array_n(sim->vectorArray));
  }
  
  formatArray = SimSimInitDataFormat(sim);
  
  if (printMode) {
    (void) fprintf(of, "# %s\n", Vm_VisReadVersion());
    (void) fprintf(of, "# Network: %s\n", Ntk_NetworkReadName(sim->network));

    if (sim->inputFile != NIL(char)) {
      (void) fprintf(of, "# Input Vectors File: %s\n", sim->inputFile);
    }
    else {
      (void) fprintf(of, "# Simulation vectors have been randomly generated\n");
    }
    (void) fprintf(of, "\n\n");
    (void) fprintf(of, ".inputs  ");
    for (i = 0; i < inputWidth; i++) {
      node = array_fetch(Ntk_Node_t *, sim->nodesArray, i);
      (void) fprintf(of, "%s ", Ntk_NodeReadName(node));
    }
    (void) fprintf(of, "\n");
    (void) fprintf(of, ".latches ");
    for (i = sim->currentStateHead; i < sim->internalPartitionHead; i++) {
      node = array_fetch(Ntk_Node_t *, sim->nodesArray, i);
      (void) fprintf(of, "%s ", Ntk_NodeReadName(node));
    }
    (void) fprintf(of, "\n");

    (void) fprintf(of, ".outputs ");
    for (i = sim->outputHead; i < numNodes; i++) {
      node = array_fetch(Ntk_Node_t *, sim->nodesArray, i);
      (void) fprintf(of, "%s ", Ntk_NodeReadName(node));
    }
    (void) fprintf(of, "\n");

    /* Reset State is the current state of the first vector */
    (void) fprintf(of, ".initial ");
    vector = array_fetch(array_t *, sim->vectorArray, 0);
    for (i = sim->currentStateHead; i < sim->internalPartitionHead; i++) {
      if(i >= array_n(vector)) {/* If currentState is not specified '*' is printed */
        (void) fprintf(of, "* ");
      }
      else {
        node = array_fetch(Ntk_Node_t *, sim->nodesArray, i);
        var = Ntk_NodeReadVariable(node);
        index = array_fetch(int, vector, i);
        if (Var_VariableTestIsSymbolic(var)) {
          (void) fprintf(of, "%s ", Var_VariableReadSymbolicValueFromIndex(var, index));
        }
        else { /* Binary or enumerative type */
          str = SimInteger2ASCII(index);
          (void) fprintf(of, "%s ", str);
          FREE(str);
        }
      }
    }
    
    (void) fprintf(of, "\n\n.start_vectors");

    (void) fprintf(of, "\n\n");

    /*
     * Print the order of variables for which values
     * are printed in the next lines.
     */
    
    (void) fprintf(of, "# ");
    /*
     * If either printInputsFlag or printPseudoInputsFlag is zero, we
     * cannot use the output as the input for simulation. Print a
     * warning message regarding that.
     */
    if ((printInputsFlag == 0) || (printPseudoInputsFlag == 0)){
      (void) fprintf(vis_stderr,"Warning - print flag of some inputs is set to zero.\n");
      (void) fprintf(vis_stderr,"Hence the output file you specified cannot be used as an input\n");
      (void) fprintf(vis_stderr,"file for a subsequent simulation run.\n");
    }
      
    if (printInputsFlag || printPseudoInputsFlag){
      for (i = 0; i < inputWidth; i++) {
        node = array_fetch(Ntk_Node_t *, sim->nodesArray, i);
        if (Ntk_NodeTestIsPrimaryInput(node)){
          if (printInputsFlag){
            (void) fprintf(of, "%s ", Ntk_NodeReadName(node));
          }
        }
        else{
          if (printPseudoInputsFlag){
            (void) fprintf(of, "%s ", Ntk_NodeReadName(node));
          }
        }
      }
      (void) fprintf(of, "; ");
    }
    
    if (printStatesFlag) {
      for (i = sim->currentStateHead; i < sim->internalPartitionHead; i++) {
        node = array_fetch(Ntk_Node_t *, sim->nodesArray, i);
        (void) fprintf(of, "%s ", Ntk_NodeReadName(node));
      }
      (void) fprintf(of, "; ");      
    }
    if (printOutputsFlag){
      for (i = sim->outputHead; i < numNodes; i++) {
        node = array_fetch(Ntk_Node_t *, sim->nodesArray, i);
        (void) fprintf(of, "%s ", Ntk_NodeReadName(node));
      }
      (void) fprintf(of, "\n\n");
    }
  }
  
  for (i = 0; i < array_n(sim->vectorArray); i++) {
    vector = array_fetch(array_t *, sim->vectorArray, i);
    if ((printInputsFlag) || (printPseudoInputsFlag)){
      for (j = 0; j < sim->currentStateHead; j++) {
        strSize = array_fetch(int, formatArray, j);
        node = array_fetch(Ntk_Node_t *, sim->nodesArray, j);
        if (Ntk_NodeTestIsPrimaryInput(node)){
          if(printInputsFlag){
            PrintValue(sim->nodesArray, vector, j, strSize, of);
          }
        }
        else {
          if (printPseudoInputsFlag){
            PrintValue(sim->nodesArray, vector, j, strSize, of);
          }
        }
      }
    }
    if (printStatesFlag){
      (void) fprintf(of,"; ");
      for (j = sim->currentStateHead; j < sim->internalPartitionHead; j++){
        strSize = array_fetch(int, formatArray, j);
        node = array_fetch(Ntk_Node_t *, sim->nodesArray, j);
        PrintValue(sim->nodesArray, vector, j, strSize, of);
      }
    }
    if (printOutputsFlag){
      (void) fprintf(of,"; ");
      for (j = sim->outputHead; j < numNodes; j++){
        strSize = array_fetch(int, formatArray, j);
        node = array_fetch(Ntk_Node_t *, sim->nodesArray, j);
        PrintValue(sim->nodesArray, vector, j, strSize, of);
      }
    }
    (void) fprintf(of, "\n");
  }
  if (printStatesFlag){
    /*
     * Need to print the final state on a separate line.
     */
    (void) fprintf(of,"# Final State : ");
    for (j = sim->currentStateHead; j < sim->internalPartitionHead; j++){
      strSize = array_fetch(int, formatArray, j);
      node = array_fetch(Ntk_Node_t *, sim->nodesArray, j);
      PrintValue(sim->nodesArray, vector, j, strSize, of);
    }
    (void) fprintf(of, "\n");
  }
  array_free(formatArray);
}



Sim_Sim_t *
Sim_FileParseDeclaration(
  Ntk_Network_t * network,
  FILE          * fp,
  char          * inputFile,
  boolean         verbose)
{
  int            i;
  Ntk_Node_t    *node;
  char           buffer[MAX_LINE_LENGTH];
  char          *buffer2;
  int            currentStateHead;
  int            internalPartitionHead;
  int            nextStateHead;
  int            outputHead;
  st_table      *nodeToMvfTable;
  array_t       *nodesArray;
  int            lineNumber              = 0;
  array_t       *inputsArray             = NIL(array_t);
  array_t       *latchesArray            = NIL(array_t);
  array_t       *internalPartitionArray  = NIL(array_t);
  array_t       *outputsArray            = NIL(array_t);
  array_t       *initState               = NIL(array_t);
  Sim_Sim_t     *sim                     = NIL(Sim_Sim_t);
  graph_t       *partition;
  vertex_t      *vertex;
  array_t       *dfsarray;

  internalPartitionArray = array_alloc(Ntk_Node_t *, 0);

  /* Add internal partition nodes */
  partition = Part_NetworkReadPartition(network);
  dfsarray = g_dfs(partition);
  for(i=0; i< array_n(dfsarray); i++){
    vertex = array_fetch(vertex_t *, dfsarray, i);
    node = Ntk_NetworkFindNodeByName(network, Part_VertexReadName(vertex));
    if(!(Ntk_NodeTestIsCombInput(node) || Ntk_NodeTestIsCombOutput(node))){
      array_insert_last(Ntk_Node_t *, internalPartitionArray, node);
    }
  }
  array_free(dfsarray);

  while (fgets(buffer, MAX_LINE_LENGTH -1, fp) != NULL) {
    int position = 0;
    lineNumber++;

    /* Every line must end by '\n' */
    if (buffer[strlen(buffer) -1] != '\n') {
      SimAppendErrorMsg("Simulate: Line ",
                       SimInteger2ASCII(lineNumber), "istoolong!\n");
      FreeArrays(inputsArray, latchesArray, outputsArray, internalPartitionArray);
      return(sim);
    }
    
  
    /* Eliminate spaces */
    BufferSkipWhiteSpace(buffer, &position);
    /* buffer2 will contain buffer without space in the begining */
    buffer2 = buffer + position;
    /* Avoid comment and empty lines */
    if (buffer[position] != '#' && buffer[position] != '\n') {
      if (!strncmp(buffer2, ".inputs", 7)) {
        inputsArray = BufferBuildInputsNodeArray(buffer2 + 7, network);
        if (inputsArray == NIL(array_t)) {
          SimAppendErrorMsg("Simulate: Error line ",
                           SimInteger2ASCII(lineNumber), ".\n");
          FreeArrays(inputsArray, latchesArray, outputsArray, internalPartitionArray);
          return(sim);
        }
      }
      else if (!strncmp(buffer2, ".latches", 8)) {
        latchesArray = BufferBuildLatchesNodeArray(buffer2 + 8, network);
        if (latchesArray == NIL(array_t)) {
          SimAppendErrorMsg("Simulate: Error line ",
                           SimInteger2ASCII(lineNumber), ".\n");
          FreeArrays(inputsArray, latchesArray, outputsArray, internalPartitionArray);
          return(sim);
        }
      }
      else if (!strncmp(buffer2, ".outputs", 8)) {
        outputsArray = BufferBuildOutputsNodeArray(buffer2 + 8, network);
        if (outputsArray == NIL(array_t)) {
          SimAppendErrorMsg("Simulate: Error line ", SimInteger2ASCII(lineNumber),
                           ".\n");
          FreeArrays(inputsArray, latchesArray, outputsArray, internalPartitionArray);
          return(sim);
        }
      }
      else if (!strncmp(buffer2, ".initial", 8)) {
        /* Error if latches are not  already read before initial-state */
        if (latchesArray == NIL(array_t)) {
          error_append("Simulate: Latches must be declared before initial state declaration.\n");
          FreeArrays(inputsArray, latchesArray, outputsArray, internalPartitionArray);
          return(sim);
        }
        initState = BufferBuildValuesArray(buffer2 + 8, latchesArray);
        if (initState == NIL(array_t)) {
          SimAppendErrorMsg("Simulate: Error line ",
                           SimInteger2ASCII(lineNumber), ".\n");
          FreeArrays(inputsArray, latchesArray, outputsArray, internalPartitionArray);
          return(sim);
        }
      }
      else if (!strncmp(buffer2, ".start_vectors", 14)) {
        /* Verification of the declarations */
        if (inputsArray == NIL(array_t)) {
          error_append("Simulate: Input file is missing inputs declaration.\n");
          FreeArrays(inputsArray, latchesArray, outputsArray, internalPartitionArray);
          return(sim);
        }
          
        currentStateHead = array_n(inputsArray);
          
        nodesArray = array_dup(inputsArray);
        array_free(inputsArray);
        inputsArray = NIL(array_t);
        if(latchesArray == NIL(array_t)) {
          /* Verify if actually there is no latch in the network */
          if (Ntk_NetworkReadNumLatches(network) > 0) {
            error_append("Simulate: Input file is missing latches declaration.\n");
            FreeArrays(inputsArray, latchesArray, outputsArray, internalPartitionArray);
            return(0);
          }
          else {
            internalPartitionHead = currentStateHead;
            nextStateHead = internalPartitionHead + array_n(internalPartitionArray);
            outputHead = nextStateHead;
          }
        }
        else {
          internalPartitionHead = currentStateHead + array_n(latchesArray);
          nextStateHead = internalPartitionHead + array_n(internalPartitionArray);
          outputHead = nextStateHead + array_n(latchesArray);
          /* Add current states node */
          array_append(nodesArray, latchesArray);
          array_append(nodesArray, internalPartitionArray);
          array_free(internalPartitionArray);
          /* Add next state node as data-input of current-state node */
          for(i = 0; i < array_n(latchesArray); i++) {
            node = array_fetch(Ntk_Node_t *, latchesArray, i);
            node = Ntk_LatchReadDataInput(node);
            array_insert_last(Ntk_Node_t *, nodesArray, node);
          }
          array_free(latchesArray);
        }
        if (outputsArray != NIL(array_t)) {
          array_append(nodesArray, outputsArray);
          array_free(outputsArray);
        }
        /* Building nodeToMvfTable */
        nodeToMvfTable = Sim_NetworkBuildNodeToMvfTable(network, nodesArray,
                                                       internalPartitionHead,
                                                       nextStateHead);
        sim = Sim_SimCreate(network, nodeToMvfTable, inputFile, lineNumber,
                            nodesArray, currentStateHead, internalPartitionHead, 
                            nextStateHead, outputHead, initState, NULL, verbose);

        return(sim); /* Normal end */
      }
      
      /* Unknown string in the declaration part */
      else {
        SimAppendErrorMsg("Simulate: Syntax error in the declaration line: ",
                         SimInteger2ASCII(lineNumber),
                         " or missing .start_vectors statement.\n") ;
        FreeArrays(inputsArray, latchesArray, outputsArray, internalPartitionArray);
        return(sim);
      }
    }
  }
  array_free(internalPartitionArray);
  return(sim);  
}

int
Sim_FileParseVectors(
  FILE      * fp,
  Sim_Sim_t  * sim,
  int         num)
{
  char           buffer[MAX_LINE_LENGTH];
  char          *buffer2;
  array_t       *vectorArray;
  int            numberVector            = 0;
  array_t       *inputsArray             = SimObtainInputsArray(sim);

  sim->vectorArray = array_alloc(array_t *, 0);
  
  while (fgets(buffer, MAX_LINE_LENGTH -1, fp) != NULL) {
    int position = 0;
    (sim->lineNumber)++;

    /* Every line must end by '\n' */
    if (buffer[strlen(buffer) -1] != '\n') {
      SimAppendErrorMsg("Simulate: Line ", SimInteger2ASCII(sim->lineNumber),
                       " is too long!\n");
      array_free(inputsArray);
      return(0);
    }
    
    /* Eliminate spaces */
    BufferSkipWhiteSpace(buffer, &position);
    /* buffer2 will contain buffer without space in the begining */
    buffer2 = buffer + position;
    /* Avoid comment and empty lines */
    if (buffer[position] != '#' && buffer[position] != '\n') {
      /* Read only "num" vectors */
      if (numberVector >= num && num != 0) {
        array_free(inputsArray);
        return(1); /* Normal end before EOF */
      }
      vectorArray = BufferBuildValuesArray(buffer2, inputsArray);
      if (vectorArray == NIL(array_t)) {
        SimAppendErrorMsg("Simulate: Error line ",
                         SimInteger2ASCII(sim->lineNumber), ".\n");
        array_free(inputsArray);
        return(0);
      }
      numberVector++;
      SimAddVector(sim, vectorArray);
    }
  }
  array_free(inputsArray);
  return(2); /* End of file */
}

/*---------------------------------------------------------------------------*/
/* Definition of internal functions                                          */
/*---------------------------------------------------------------------------*/

/*---------------------------------------------------------------------------*/
/* Definition of static functions                                            */
/*---------------------------------------------------------------------------*/
static array_t *
SimObtainInputsArray(
  Sim_Sim_t * sim)
{
  int          i;
  Ntk_Node_t * node;
  array_t    * inputsArray = array_alloc(Ntk_Node_t *, 0);

  for (i = 0; i < sim->currentStateHead; i++) {
    node = array_fetch(Ntk_Node_t *, sim->nodesArray, i);
    array_insert_last(Ntk_Node_t *, inputsArray, node);
  }
  return(inputsArray);
}

static void
FreeArrays(
  array_t *array1,
  array_t *array2,
  array_t *array3,
  array_t *array4)
{
  if (array1 != NIL(array_t)) {
    array_free(array1);
  }
  if (array2 != NIL(array_t)) {
    array_free(array2);
  }
  if (array3 != NIL(array_t)) {
    array_free(array3);
  }
  if (array4 != NIL(array_t)) {
    array_free(array4);
  }
}
  

static array_t *
BufferBuildInputsNodeArray(
  char * buffer,
  Ntk_Network_t * network)
{
  char       *str;
  Ntk_Node_t *node;
  int         position = 0;
  array_t    *array    = array_alloc(Ntk_Node_t *, 0);
    
  while((str = BufferObtainStringAtPosition(buffer, &position)) != NULL) {
    node = Ntk_NetworkFindNodeByActualName(network, str);
    if (node == NIL(Ntk_Node_t) || !Ntk_NodeTestIsInput(node)) {
      SimAppendErrorMsg("Simulate: ", str, " is not a valid input name.\n");
      array_free(array);
      FREE(str);
      return(NIL(array_t));
    }
    FREE(str);
    array_insert_last(Ntk_Node_t *, array, node);
  }
  /* Verification of number of values */
  if (array_n(array) != Ntk_NetworkReadNumInputs(network)) {
    error_append("Simulate: All inputs and pseudo-inputs must be specified.\n");
    array_free(array);
    return(NIL(array_t));
  }
  return(array);
}


static array_t *
BufferBuildLatchesNodeArray(
  char * buffer,
  Ntk_Network_t * network)
{
  char       *str;
  Ntk_Node_t *node;
  int         position = 0;
  array_t    *array    = array_alloc(Ntk_Node_t *, 0);
    
  while ((str = BufferObtainStringAtPosition(buffer, &position)) != NULL) {
    node = Ntk_NetworkFindNodeByActualName(network, str);
    if (node == NIL(Ntk_Node_t) || !Ntk_NodeTestIsLatch(node)) {
      SimAppendErrorMsg("Simulate: ", str, " is not a valid latch name\n");
      array_free(array);
      FREE(str);
      return(NIL(array_t));
    }
    FREE(str);
    array_insert_last(Ntk_Node_t *, array, node);
  }
  /* Verification of number of items */
  if (array_n(array) != Ntk_NetworkReadNumLatches(network)) {
    error_append("Simulate: All latches must be specified.\n");
    array_free(array);
    return(NIL(array_t));
  }
  return(array);
}

static array_t *
BufferBuildOutputsNodeArray(
  char * buffer,
  Ntk_Network_t * network)
{
  char       *str;
  Ntk_Node_t *node;
  int         position = 0;
  array_t    *array    = array_alloc(Ntk_Node_t *, 0);
    
  while((str = BufferObtainStringAtPosition(buffer, &position)) != NULL) {
    node = Ntk_NetworkFindNodeByActualName(network, str);
    if (node == NIL(Ntk_Node_t) || !Ntk_NodeTestIsPrimaryOutput(node)) {
      SimAppendErrorMsg("Simulate: ", str, " is not a valid output name\n");
      FREE(str);
      array_free(array);
      return(NIL(array_t));
    }
    FREE(str);
    array_insert_last(Ntk_Node_t *, array, node);
  }
  return(array);
}

static array_t *
BufferBuildValuesArray(
  char * buffer,
  array_t * nodesArray)
{
  char       *str;
  Ntk_Node_t *node;
  int         index;
  int         i         = 0;
  int         arraySize = array_n(nodesArray);
  int         position  = 0;
  array_t    *array     = array_alloc(int, 0);
    
  while((str = BufferObtainStringAtPosition(buffer, &position)) != NULL) {
    if (i >= arraySize) {
      SimAppendErrorMsg("Simulate: Too many values(", str, " invalid value).\n");
      array_free(array);
      FREE(str);
      return(NIL(array_t));
    }  
    node = array_fetch(Ntk_Node_t *, nodesArray, i);
    i++;
    index = SimNodeReadValueCode(node, str);
    if (index == -1) {
      SimAppendErrorMsg("Simulate: ", str, ": invalid value.\n");
      array_free(array);
      FREE(str);
      return(NIL(array_t));
    }

    FREE(str);
    array_insert_last(int, array, index);
  }
  
  /* Verification of number of items */
  if (array_n(array) != array_n(nodesArray)) {
    error_append("Simulate: incomplete number of values.\n");
    array_free(array);
    return(NIL(array_t));
  }
  return(array);
}


static void
SimAddVector(
  Sim_Sim_t * sim,
  array_t * vector)
{
  array_insert_last(array_t *, sim->vectorArray, vector);
}

static void
BufferSkipWhiteSpace(
  char * buffer,
  int * position)
{
  for (; buffer[*position] == ' ' || buffer[*position] == '\t'; (*position)++);
}

static char *
BufferObtainStringAtPosition(
  char * buffer,
  int * position)
{
  char *str;
  int   strPosition;
  int   len;
  
  /* Traverse Space */
  BufferSkipWhiteSpace(buffer, position);

  strPosition = *position;
  for (;buffer[*position] != ' ' && buffer[*position] != '\t' &&
            buffer[*position] != ';'  && buffer[*position] != '\n'; (*position)++);

  if (strPosition == *position) {
    return(NIL(char));
  }
  len = *position - strPosition + 1;
  str = ALLOC(char, len);
  strncpy(str, buffer + strPosition, len - 1);
  str[len-1] = '\0';
  return(str);
}

static void
PrintValue(array_t *nodesArray, array_t *vector, int vectorIndex,
           int strSize, FILE *file)
{
  int index;
  Var_Variable_t *var;
  char *str;
  Ntk_Node_t *node;
  
  if (array_n(vector) > vectorIndex) {
    node = array_fetch(Ntk_Node_t *, nodesArray, vectorIndex);
    var = Ntk_NodeReadVariable(node);
    index = array_fetch(int, vector, vectorIndex);
    if (Var_VariableTestIsSymbolic(var)) {
      SimStringPrint(file, Var_VariableReadSymbolicValueFromIndex(var, index),
                     strSize);
    }
    else { /* Binary or enumerative type */
      str = SimInteger2ASCII(index);
      SimStringPrint(file, str, strSize);
      FREE(str);
    }
  }
  else {
    error_append("Warning: Value is missing in vector.\n");
    SimStringPrint(file, "*", strSize);
  }
}