src/ntk/ntkNode.c

Go to the documentation of this file.

#include "ntkInt.h"
#include "baig.h"

static char rcsid[] UNUSED = "$Id: ntkNode.c,v 1.15 2009/04/11 01:56:10 fabio Exp $";

/*---------------------------------------------------------------------------*/
/* Constant declarations                                                     */
/*---------------------------------------------------------------------------*/
#define UNASSIGNED_OUTPUT_INDEX -1
#define LATCH_DATA    0 
#define LATCH_INITIAL 1



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

static void NetworkAddCombOutput(Ntk_Network_t *network, Ntk_Node_t *node);

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

char *
Ntk_NodeReadName(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->name);
}


Ntk_Network_t *
Ntk_NodeReadNetwork(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->network);
}


Var_Variable_t *
Ntk_NodeReadVariable(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->variable);
}


Tbl_Table_t *
Ntk_NodeReadTable(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  assert((node->type == NtkCombinational_c) || (node->type == NtkPseudoInput_c));
  return (node->table);
}

mAigEdge_t
Ntk_NodeReadMAigId(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->mAigId);
}


void
Ntk_NodeSetMAigId(
  Ntk_Node_t * node,
  mAigEdge_t mAigId)
{
  assert(node != NIL(Ntk_Node_t));
  node->mAigId = mAigId;
}

void
Ntk_NodeSetTable(
  Ntk_Node_t * node,
  Tbl_Table_t *table)
{

  assert(node != NIL(Ntk_Node_t));
  assert((node->type == NtkCombinational_c) || (node->type == NtkPseudoInput_c));

  node->table = table;
}

int
Ntk_NodeReadOutputIndex(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  assert((node->type == NtkCombinational_c) || (node->type == NtkPseudoInput_c));
  return (node->outputIndex);
}


int
Ntk_NodeReadMddId(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->mddId);
}


void
Ntk_NodeSetMddId(
  Ntk_Node_t * node,
  int  id)
{
  Ntk_Network_t *network = node->network;
  char *entry;
  
  assert(node != NIL(Ntk_Node_t));

  /* If the node already has an assigned id, then clean it from the table. */
  if (node->mddId != NTK_UNASSIGNED_MDD_ID) {
    entry = (char *) (long) node->mddId;
    (void) st_delete(network->mddIdToNode, &entry, NIL(char *));
  }

  /* Set the new id, and add it to the table (if it's not unassigned). */
  node->mddId = id;
  if (id != NTK_UNASSIGNED_MDD_ID) {
    st_insert(network->mddIdToNode, (char *) (long) id, (char *) node);
  }
}


void *
Ntk_NodeReadUndef(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->undef);
}


void
Ntk_NodeSetUndef(
  Ntk_Node_t * node,
  void * value)
{
  assert(node != NIL(Ntk_Node_t));
  node->undef = value;
}


boolean
Ntk_NodeTestIsPrimaryInput(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->type == NtkPrimaryInput_c);
}


boolean
Ntk_NodeTestIsPseudoInput(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->type == NtkPseudoInput_c);
}


boolean
Ntk_NodeTestIsInput(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return ((node->type == NtkPrimaryInput_c) || (node->type == NtkPseudoInput_c));
  
}


boolean
Ntk_NodeTestIsUndefined(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->type == NtkUnassigned_c);
}


boolean
Ntk_NodeTestIsLatch(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->type == NtkLatch_c);
}


boolean
Ntk_NodeTestIsNextStateNode(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  if (Ntk_NodeTestIsShadow(node)) {
    Ntk_Node_t *origin = Ntk_ShadowReadOrigin(node);
    if (Ntk_NodeTestIsLatch(origin)) {
      return (TRUE);
    }
  }
  
  return (FALSE);
}


boolean
Ntk_NodeTestIsShadow(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->type == NtkShadow_c);
}


boolean
Ntk_NodeTestIsCombInput(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return ((node->type == NtkLatch_c)
          || (node->type == NtkPrimaryInput_c)
          || (node->type == NtkPseudoInput_c));
}


boolean
Ntk_NodeTestIsCombOutput(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (Ntk_NodeTestIsPrimaryOutput(node)
          || Ntk_NodeTestIsLatchDataInput(node)
          || Ntk_NodeTestIsLatchInitialInput(node));
}


boolean
Ntk_NodeTestIsCombinational(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->type == NtkCombinational_c);
}


boolean
Ntk_NodeTestIsPrimaryOutput(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->outputFlag);
}


boolean
Ntk_NodeTestIsLatchDataInput(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->latchDataInput);
}


boolean
Ntk_NodeTestIsLatchInitialInput(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->latchInitialInput);
}


boolean
Ntk_NodeTestIsConstant(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->constant);
}


Ntk_Node_t *
Ntk_NodeReadShadow(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  assert(node->type != NtkShadow_c);
  return (node->shadowInfo.shadow);
}


Ntk_Node_t *
Ntk_ShadowReadOrigin(
  Ntk_Node_t * shadow)
{
  assert(shadow != NIL(Ntk_Node_t));
  assert(shadow->type == NtkShadow_c);
  return (shadow->shadowInfo.origin);
}


Ntk_Node_t *
Ntk_LatchReadDataInput(
  Ntk_Node_t * node)
{
  Ntk_Node_t *data;
  
  assert(node != NIL(Ntk_Node_t));
  assert(node->type == NtkLatch_c);
  data = array_fetch(Ntk_Node_t *, node->fanins, LATCH_DATA);
  
  return (data);
}


Ntk_Node_t *
Ntk_LatchReadInitialInput(
  Ntk_Node_t * node)
{
  Ntk_Node_t *initial;
  
  assert(node != NIL(Ntk_Node_t));
  assert(node->type == NtkLatch_c);
  initial = array_fetch(Ntk_Node_t *, node->fanins, LATCH_INITIAL);
  
  return (initial);
}


int
Ntk_NodeReadNumFanins(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (array_n(node->fanins));
}


int
Ntk_NodeReadNumFanouts(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (array_n(node->fanouts));
}


Ntk_Node_t *
Ntk_NodeReadFaninNode(
  Ntk_Node_t * node,
  int  faninIndex)
{
  Ntk_Node_t *faninNode;
  
  assert(node != NIL(Ntk_Node_t));
  assert((faninIndex >= 0) && (faninIndex < Ntk_NodeReadNumFanins(node)));
  faninNode = array_fetch(Ntk_Node_t *, node->fanins, faninIndex);
  return (faninNode);
}

  
int
Ntk_NodeReadFaninIndex(
  Ntk_Node_t * node,
  Ntk_Node_t * faninNode)
{
  int         i;
  Ntk_Node_t *tempNode;
  
  assert(node != NIL(Ntk_Node_t));
  Ntk_NodeForEachFanin(node, i, tempNode) {
    if (tempNode == faninNode) {
      return (i);
    }
  }

  return (NTK_UNDEFINED_FANIN_INDEX);
}


array_t *
Ntk_NodeReadFanins(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->fanins);
}


array_t *
Ntk_NodeReadFanouts(
  Ntk_Node_t * node)
{
  assert(node != NIL(Ntk_Node_t));
  return (node->fanouts);
}


void
Ntk_NodeSetFanins(
  Ntk_Node_t * node,
  array_t *faninArray)
{
  assert(node != NIL(Ntk_Node_t));
  if (node->fanins)
    array_free(node->fanins);
  
  node->fanins = faninArray;

  return;
}


void
Ntk_NodeSetFanouts(
  Ntk_Node_t * node,
  array_t *fanoutArray)
{
  assert(node != NIL(Ntk_Node_t));
  if (node->fanouts)
    array_free(node->fanouts);
  
  node->fanouts = fanoutArray;

  return;
}


char *
Ntk_NodeObtainTypeAsString(
  Ntk_Node_t * node)
{
  char *typeString;

  assert(node != NIL(Ntk_Node_t));
  switch(node->type) {
      case NtkLatch_c:
        typeString = util_strsav("latch");
        break;
      case NtkShadow_c:
        typeString = util_strsav("shadow");
        break;
      case NtkPrimaryInput_c:
        typeString = util_strsav("primary-input");
        break;
      case NtkPseudoInput_c:
        typeString = util_strsav("pseudo-input");
        break;
      case NtkCombinational_c:
        typeString = util_strsav("combinational");
        break;
      case NtkUnassigned_c:
        typeString = util_strsav("unassigned");
        break;
      default:
        fail("Unexpected type");
  }
  return (typeString);
}


void
Ntk_NodePrint(
  FILE * fp,
  Ntk_Node_t * node,
  boolean printIo,
  boolean printTableStats)
{
  int         i;
  Ntk_Node_t *fanin;
  Ntk_Node_t *fanout;
  char       *typeString = Ntk_NodeObtainTypeAsString(node);
  

  /*
   * Print the node's name, MDD id, type, and attributes.
   */
  (void) fprintf(fp, "%s: mdd=%d, %s;%s%s%s%s%s%s\n",
                 Ntk_NodeReadName(node),
                 Ntk_NodeReadMddId(node),
                 typeString,
                 (Ntk_NodeTestIsPrimaryOutput(node) ? " output" : ""),
                 (Ntk_NodeTestIsConstant(node) ? " constant" : ""),
                 (Ntk_NodeTestIsLatchDataInput(node) ? " data-input" : ""),
                 (Ntk_NodeTestIsLatchInitialInput(node) ? " initial-input" : ""),
                 (Ntk_NodeTestIsCombInput(node) ? " comb-input" : ""),
                 (Ntk_NodeTestIsCombOutput(node) ? " comb-output" : "")
                 );

  FREE(typeString);
  
  if (printIo) {
    /*
     * Print the name of each fanin.
     */
    (void) fprintf(fp, "Fanins:  ");
    Ntk_NodeForEachFanin(node, i, fanin) {
      if (i != 0) (void) fprintf(fp, ",");
      (void) fprintf(fp, " %s", Ntk_NodeReadName(fanin));
    }
    (void) fprintf(fp, "\n");

    /*
     * Print the name of each fanout.
     */
    (void) fprintf(fp, "Fanouts: ");
    Ntk_NodeForEachFanout(node, i, fanout) {
      if (i != 0) (void) fprintf(fp, ",");
      (void) fprintf(fp, " %s", Ntk_NodeReadName(fanout));
    }
    (void) fprintf(fp, "\n");
  }

  if (printTableStats) {
    if (Ntk_NodeTestIsCombinational(node) || Ntk_NodeTestIsPseudoInput(node)) {
      Tbl_TablePrintStats(Ntk_NodeReadTable(node), fp);
    }
  }
}


Ntk_Node_t *
Ntk_NodeCreateInNetwork(
  Ntk_Network_t * network,
  char * name,
  Var_Variable_t *variable)
{
  Ntk_Node_t *node = ALLOC(Ntk_Node_t, 1);

  assert(network != NIL(Ntk_Network_t));
  assert(name != NIL(char));
  assert(variable != NIL(Var_Variable_t));
  
  node->name                  = util_strsav(name);
  node->network               = network;
  node->variable              = variable;
  node->type                  = NtkUnassigned_c;
  node->fanins                = array_alloc(Ntk_Node_t *, 0);
  node->fanouts               = array_alloc(Ntk_Node_t *, 0);
  node->table                 = NIL(Tbl_Table_t);
  node->outputIndex           = UNASSIGNED_OUTPUT_INDEX;
  node->mddId                 = NTK_UNASSIGNED_MDD_ID;
  node->mAigId                = -1;
  node->shadowInfo.shadow     = NIL(Ntk_Node_t);
  node->outputFlag            = 0;
  node->constant              = 0;
  node->latchDataInput        = 0;
  node->latchInitialInput     = 0;
  node->undef                 = NIL(void);

  /*
   * Update the state of the network. Note: it's important to use node->name
   * here, rather than just name, because we don't own name.
   */
  st_insert(network->actualNameToNode, (char *) node->name, (char *) node);
  lsNewEnd(network->nodes, (lsGeneric) node, LS_NH);

  return (node);
}


void
Ntk_NodeDeclareAsCombinational(
  Ntk_Node_t * node,
  Tbl_Table_t * table,
  array_t * inputNames /* array of char */,
  int  outputIndex)
{
  int            i;
  Ntk_Network_t *network = node->network;

  assert(node->type == NtkUnassigned_c);
  
  node->type        = NtkCombinational_c;
  node->table       = table;
  node->outputIndex = outputIndex;

  /*
   * If it can be determined that the corresponding output column of table can
   * take assume just a single value, then set the constant flag. 
   */
  if (Tbl_TableTestIsConstant(table, outputIndex)) {
    node->constant = 1;
  }
  
  /*
   * Create a connection to each input of table. 
   */
  for (i = 0; i < array_n(inputNames); i++) {
    char        *faninName = array_fetch(char *, inputNames, i);
    Ntk_Node_t  *fanin     = Ntk_NetworkFindNodeByName(network, faninName);

    assert(fanin != NIL(Ntk_Node_t));

    /*
     * Make the connections between node and fanin.  Note: it is critical
     * that the fanins of node are added to node->fanins in the same order
     * they appear in the table.
     */
    array_insert_last(Ntk_Node_t *, fanin->fanouts, node);
    array_insert_last(Ntk_Node_t *, node->fanins, fanin);
  }
}


void
Ntk_NodeDeclareAsLatch(
  Ntk_Node_t * latch,
  char * dataName,
  char * initName)
{
  Ntk_Node_t    *dataNode;
  Ntk_Node_t    *initNode;
  Ntk_Network_t *network = latch->network;
  
  assert(latch->type == NtkUnassigned_c);
  latch->type = NtkLatch_c;

  /*
   * Get the nodes corresponding to dataName and initName.
   */
  dataNode = Ntk_NetworkFindNodeByName(network, dataName);
  initNode = Ntk_NetworkFindNodeByName(network, initName);
  assert(dataNode != NIL(Ntk_Node_t));
  assert(initNode != NIL(Ntk_Node_t));

  /*
   * Make the necessary connections. Note the predefined locations of the data
   * and initial inputs in the fanin array of latch.
   */
  array_insert(Ntk_Node_t *, latch->fanins, LATCH_DATA, dataNode);
  array_insert(Ntk_Node_t *, latch->fanins, LATCH_INITIAL, initNode);

  array_insert_last(Ntk_Node_t *, dataNode->fanouts, latch);
  array_insert_last(Ntk_Node_t *, initNode->fanouts, latch);

  /*
   * Set the special flags in the data and init nodes, and add them to the
   * list of combinational outputs.
   */
  dataNode->latchDataInput = 1;
  NetworkAddCombOutput(network, dataNode);

  initNode->latchInitialInput = 1;
  NetworkAddCombOutput(network, initNode);

  /*
   * Add the latch to the appropriate lists in network.
   */
  lsNewEnd(network->latches,    (lsGeneric) latch, LS_NH);
  lsNewEnd(network->combInputs, (lsGeneric) latch, LS_NH);
}


void
Ntk_NodeDeclareAsPrimaryInput(
  Ntk_Node_t * node)
{
  assert(node->type == NtkUnassigned_c);
  node->type = NtkPrimaryInput_c;

  lsNewEnd(node->network->primaryInputs, (lsGeneric) node, LS_NH);
  lsNewEnd(node->network->inputs,        (lsGeneric) node, LS_NH);
  lsNewEnd(node->network->combInputs,    (lsGeneric) node, LS_NH);
}


void
Ntk_NodeDeclareAsPseudoInput(
  Ntk_Node_t * node,
  Tbl_Table_t * table,
  int  outputIndex)
{
  assert(node->type == NtkUnassigned_c);

  node->type        = NtkPseudoInput_c;
  node->table       = table;
  node->outputIndex = outputIndex;
  
  if (Tbl_TableTestIsConstant(table, outputIndex)) {
    node->constant = 1;
  }
  
  lsNewEnd(node->network->pseudoInputs, (lsGeneric) node, LS_NH);
  lsNewEnd(node->network->inputs,       (lsGeneric) node, LS_NH);
  lsNewEnd(node->network->combInputs,   (lsGeneric) node, LS_NH);
}


void
Ntk_NodeDeclareAsPrimaryOutput(
  Ntk_Node_t * node)
{
  assert(node->type != NtkShadow_c);
  node->outputFlag = 1;
  lsNewEnd(node->network->primaryOutputs, (lsGeneric) node, LS_NH);
  NetworkAddCombOutput(node->network, node);
}


void
Ntk_NodeDeclareAsShadow(
  Ntk_Node_t * shadow,
  Ntk_Node_t * origin)
{
  assert(shadow->type == NtkUnassigned_c);
  assert(origin->type != NtkShadow_c);
  
  shadow->type = NtkShadow_c;

  shadow->shadowInfo.origin = origin;
  origin->shadowInfo.shadow = shadow;
}


void
Ntk_NodeFree(
  Ntk_Node_t * node)
{
  FREE(node->name);
  array_free(node->fanins);
  array_free(node->fanouts);
  Tbl_TableFree(node->table);
  
  /*
   * Unassign a few key fields for safety's sake.
   */
  node->name              = NIL(char);
  node->network           = NIL(Ntk_Network_t);
  node->variable          = NIL(Var_Variable_t);
  node->type              = NtkUnassigned_c;
  node->fanins            = NIL(array_t);
  node->fanouts           = NIL(array_t);
  node->table             = NIL(Tbl_Table_t);
  node->mddId             = NTK_UNASSIGNED_MDD_ID;

  FREE(node);
}


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


/*---------------------------------------------------------------------------*/
/* Definition of static functions                                            */
/*---------------------------------------------------------------------------*/
static void
NetworkAddCombOutput(
  Ntk_Network_t *network,
  Ntk_Node_t    *node)
{
  if (!st_is_member(network->combOutputsTable, (char *) node)) {
    st_insert(network->combOutputsTable, (char *) node, (char *) 0);
    lsNewEnd(network->combOutputs, (lsGeneric) node, LS_NH);
  }
}