src/ntk/ntkCmd.c

Go to the documentation of this file.

#include "ntkInt.h"

static char rcsid[] UNUSED = "$Id: ntkCmd.c,v 1.19 2010/04/09 23:44:05 fabio Exp $";

/*---------------------------------------------------------------------------*/
/* Constant declarations                                                     */
/*---------------------------------------------------------------------------*/
/*
 * States of the state machine used to parse the input variable name list file.
 */
#define STATE_TEST 0 /* next char is in first column */
#define STATE_WAIT 1 /* wait until end of line '\n' is reached */
#define STATE_IN   2 /* parsing a variable name */

/*
 * Maximum permissible length of a variable name in the input variable name list file.
 */
#define MAX_NAME_LENGTH 200

int NtkDebug;

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

static int CommandPrintNetworkStats(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandPrintNetwork(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandPrintNetworkDot(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandWriteNetworkBlifMv(Hrc_Manager_t ** hmgr, int  argc, char ** argv);
static int CommandFlattenHierarchy(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandTestNetworkAcyclic(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandInitVerify(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static int CommandNetworkSweep(Hrc_Manager_t ** hmgr, int argc, char ** argv);
static boolean FileReadNameList(FILE * fp, lsList * nameList, int verbose);

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

void
Ntk_Init(void)
{
  Cmd_CommandAdd("print_network_stats",   CommandPrintNetworkStats,   0);
  Cmd_CommandAdd("print_network",         CommandPrintNetwork,        0);
  Cmd_CommandAdd("print_network_dot",     CommandPrintNetworkDot,     0);
  Cmd_CommandAdd("flatten_hierarchy",     CommandFlattenHierarchy,    1);
  Cmd_CommandAdd("test_network_acyclic",  CommandTestNetworkAcyclic,  0);
  Cmd_CommandAdd("init_verify",           CommandInitVerify,          0);
  Cmd_CommandAdd("network_sweep",         CommandNetworkSweep,        1);
  Cmd_CommandAdd("write_network_blif_mv", CommandWriteNetworkBlifMv,  0);
}


void
Ntk_End(void)
{
}


Ntk_Network_t *
Ntk_HrcManagerReadCurrentNetwork(Hrc_Manager_t *hmgr)
{
  Hrc_Node_t *currentNode;
  Ntk_Network_t *network;

  assert(hmgr != NIL(Hrc_Manager_t));
  currentNode = Hrc_ManagerReadCurrentNode(hmgr);
  if (currentNode == NIL(Hrc_Node_t)) {
    (void) fprintf(vis_stderr, "The hierarchy manager is empty.  Read in design.\n");
    return NIL(Ntk_Network_t);
  }

  network = (Ntk_Network_t *) Hrc_NodeReadApplInfo(currentNode,
                                                   NTK_HRC_NODE_APPL_KEY);
  if (network == NIL(Ntk_Network_t)) {
    (void) fprintf(vis_stdout, "There is no network. Use flatten_hierarchy.\n");
    return NIL(Ntk_Network_t);
  }

  return network;
}

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


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

static int
CommandPrintNetworkStats(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int            c;
  Ntk_Network_t *network = Ntk_HrcManagerReadCurrentNetwork(*hmgr);

  /*
   * Parse the command line.
   */
  util_getopt_reset();
  while ((c = util_getopt(argc, argv, "h")) != EOF) {
    switch (c) {
      case 'h':
        goto usage;
      default:
        goto usage;
    }
  }
  
  if (network == NIL(Ntk_Network_t)) {
    return 1;
  }

  Ntk_NetworkPrintStats(vis_stdout, network);
  return 0;             /* normal exit */

usage:
  (void) fprintf(vis_stderr, "usage: print_network_stats [-h]\n");
  (void) fprintf(vis_stderr, "   -h  print the command usage\n");
  return 1;             /* error exit */
}


static int
CommandPrintNetwork(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int            c;
  boolean        printIo         = FALSE;  /* default */
  boolean        printTableStats = FALSE;  /* default */
  Ntk_Network_t *network         = Ntk_HrcManagerReadCurrentNetwork(*hmgr);

  /*
   * Parse the command line.
   */
  util_getopt_reset();
  while ((c = util_getopt(argc, argv, "fth")) != EOF) {
    switch (c) {
      case 'f':
        printIo = TRUE;
        break;
      case 't':
        printTableStats = TRUE;
        break;
      case 'h':
        goto usage;
      default:
        goto usage;
    }
  }
  
  if (network == NIL(Ntk_Network_t)) {
    return 1;
  }

  Ntk_NetworkPrint(vis_stdout, network, printIo, printTableStats);
  return 0;             /* normal exit */

usage:
  (void) fprintf(vis_stderr, "usage: print_network [-f] [-h] [-t]\n");
  (void) fprintf(vis_stderr, "   -f  print fanins and fanouts of nodes\n");
  (void) fprintf(vis_stderr, "   -h  print the command usage\n");
  (void) fprintf(vis_stderr, "   -t  print table stats of nodes having tables\n");
  return 1;             /* error exit */
}


static int
CommandPrintNetworkDot(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  FILE *fp;
  int c, status;
  Ntk_Network_t *network = Ntk_HrcManagerReadCurrentNetwork(*hmgr);

  util_getopt_reset();
  while ((c = util_getopt(argc,argv,"h")) != EOF){
    switch(c){
      case 'h':
        goto usage;
      default:
        goto usage;
    }
  }

  /* Check if the network has been read in */
  if (network == NIL(Ntk_Network_t)) {
    return 1;
  }

  if (argc == 1) {
    fp = stdout;
  }
  else if (argc == 2) {
    fp = Cmd_FileOpen(*(++argv), "w", NIL(char *), /* silent */ 1);
    if (fp == NIL(FILE)) {
      (void) fprintf(vis_stderr, "Cannot write to %s\n", *argv);
      return 1;
    }
  }
  else {
    goto usage;
  }

  error_init();
  status = Ntk_NetworkPrintDot(fp, network);
  (void) fprintf(vis_stderr, "%s", error_string());
  fflush(fp);
  if (fp != stdout) {
    (void) fclose(fp);
  }
  return (status ? 0 : 1);

 usage:
  (void) fprintf(vis_stderr, "usage: print_network_dot [-h] [file]\n");
  (void) fprintf(vis_stderr, "    -h\t\tprint the command usage\n");
  return 1;
}


static int
CommandWriteNetworkBlifMv(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  FILE *fp;
  int c;
  boolean promotePseudo = FALSE;
  Ntk_Network_t *network = Ntk_HrcManagerReadCurrentNetwork(*hmgr);

  /* Check whether the network has been created. */
  if (network == NIL(Ntk_Network_t)) {
    return 1;
  }

  util_getopt_reset();
  while ((c = util_getopt(argc,argv,"hp")) != EOF){
    switch(c){
    case 'h':
      goto usage;
    case 'p':
      promotePseudo = TRUE;
      argv++;
      argc--;
      break;
    default:
      goto usage;
    }
  }

  if (argc == 1) {
    fp = vis_stdout;
  } else if (argc == 2) {
    fp = Cmd_FileOpen(*(++argv), "w", NIL(char *), /* silent */ 1);
    if (fp == NIL(FILE)) {
      (void) fprintf(vis_stderr, "Cannot write to %s\n", *argv);
      return 1;
    }
  } else {
    goto usage;
  }

  error_init();
  Ntk_NetworkWriteBlifMv(fp, network, promotePseudo);
  (void) fprintf(vis_stderr, "%s", error_string());
  fflush(fp);
  if (fp != vis_stdout) {
    (void) fclose(fp);
  }
  return 1;

 usage:
  (void) fprintf(vis_stderr, "usage: write_network_blif_mv [-h] [file]\n");
  (void) fprintf(vis_stderr, "    -h\t\tprint the command usage\n");
  (void) fprintf(vis_stderr, "    -p\t\tpromote pseudo inputs to primary inputs\n");
  return 1;

} /* CommandWriteNetworkBlifMv */


static int
CommandFlattenHierarchy(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int            c;
  Ntk_Network_t *network;
  char          *fileName    = NIL(char);
  int            verbose     = 0;       /* default */
  int            sweep       = 1;  
  lsList         varNameList = (lsList) NULL;
  Hrc_Node_t    *currentNode = Hrc_ManagerReadCurrentNode(*hmgr);
  
  /*
   * Parse the command line.
   */
  util_getopt_reset();
  while ((c = util_getopt(argc, argv, "a:bhsv:")) != EOF) {
    switch (c) {
      case 'a':
        fileName = util_optarg;
        break;
      case 'b':
        break;
      case 'h':
        goto usage;
      case 's':
        sweep = 0;
        break;        
      case 'v':
        verbose = atoi(util_optarg);
        break;
      default:
        goto usage;
    }
  }

  if (currentNode == NIL(Hrc_Node_t)) { 
    (void) fprintf(vis_stdout, "The hierarchy manager is empty.  Read in design.\n");
    return 1;
  }
    
  /*
   * Process the file containing the variable names.
   */
  if (fileName != NIL(char)) {
    FILE *fp = Cmd_FileOpen(fileName, "r", NIL(char *), 0);
    if (fp == NIL(FILE)) {
      return 1;
    }
    else {
      boolean status;
      
      error_init();
      status = FileReadNameList(fp, &varNameList, verbose);
      (void) fclose(fp);
      if (status == FALSE) {
        (void) fprintf(vis_stderr, "Error reading variable name file:\n");
        (void) fprintf(vis_stderr, "%s", error_string());
        (void) fprintf(vis_stderr, "Cannot perform flatten_hierarchy.\n");
        return 1;
      }
    }
  }

  
  /*
   * If a network already exists, delete it.  Then create the new one, and
   * register it with the hrcNode.
   */
  network = (Ntk_Network_t *) Hrc_NodeReadApplInfo(currentNode,
                                                   NTK_HRC_NODE_APPL_KEY);
  if (network != NIL(Ntk_Network_t)) {
    (void) fprintf(vis_stdout, "Deleting current network and creating new one.\n");
    Hrc_NodeFreeApplInfo(currentNode, NTK_HRC_NODE_APPL_KEY);
  }

  error_init();

  network = Ntk_HrcNodeConvertToNetwork(currentNode, TRUE, varNameList);

  /* Clean up the varNameList. */
  if (varNameList != (lsList) NULL) {
    lsGen  gen;
    char  *varName;
    
    lsForEachItem(varNameList, gen, varName) {
      FREE(varName);
    }
    (void) lsDestroy(varNameList, (void (*) (lsGeneric)) NULL);
  }
  /* sweep network */
  if (network != NIL(Ntk_Network_t) && sweep ==1) {
    Ntk_NetworkSweep(network, verbose); 
  }
  
  if (network == NIL(Ntk_Network_t)) {
    (void) fprintf(vis_stderr, "%s", error_string());
    (void) fprintf(vis_stderr, "Cannot perform flatten_hierarchy.\n");
    return 1;
  }
  
  Hrc_NodeAddApplInfo(currentNode, NTK_HRC_NODE_APPL_KEY,
                      (Hrc_ApplInfoFreeFn) Ntk_NetworkFreeCallback,
                      (Hrc_ApplInfoChangeFn) NULL,  /* not currently used by hrc */
                      (void *) network);

  return 0;             /* normal exit */

usage:
  (void) fprintf(vis_stderr, "usage: flatten_hierarchy [-a file] [-b] [-h] [-s] [-v #]\n");
  (void) fprintf(vis_stderr, "   -a file  variables to abstract\n");
  (void) fprintf(vis_stderr, "   -b       not used any longer\n");
  (void) fprintf(vis_stderr, "   -h       print the command usage\n");
  (void) fprintf(vis_stderr, "   -s       do not perform a sweep\n");  
  (void) fprintf(vis_stderr, "   -v #     verbosity level\n");
  return 1;             /* error exit */
}


static int
CommandTestNetworkAcyclic(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int            c;
  Ntk_Network_t *network = Ntk_HrcManagerReadCurrentNetwork(*hmgr);

  /*
   * Parse the command line.
   */
  util_getopt_reset();
  while ((c = util_getopt(argc, argv, "h")) != EOF) {
    switch (c) {
      case 'h':
        goto usage;
      default:
        goto usage;
    }
  }
  
  if (network == NIL(Ntk_Network_t)) {
    return 1;
  }

  error_init();
  if (Ntk_NetworkTestIsAcyclic(network) == 0) {
    (void) fprintf(vis_stdout, "Combinational cycle found: ");
    (void) fprintf(vis_stdout, "%s", error_string());
    (void) fprintf(vis_stdout, "\n");
  }
  else {
    (void) fprintf(vis_stdout, "Network has no combinational cycles\n");
  }
  return 0;             /* normal exit */


usage:
  (void) fprintf(vis_stderr, "usage: test_network_acyclic [-h]\n");
  (void) fprintf(vis_stderr, "   -h  print the command usage\n");
  return 1;             /* error exit */
}


static int
CommandInitVerify(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int         c;
  Hrc_Node_t *currentNode = Hrc_ManagerReadCurrentNode(*hmgr);
  
  /*
   * Parse the command line.
   */
  util_getopt_reset();
  while ((c = util_getopt(argc, argv, "bh")) != EOF) {
    switch (c) {
      case 'b':
        break;
      case 'h':
        goto usage;
      default:
        goto usage;
    }
  }

  if (currentNode == NIL(Hrc_Node_t)) { 
    (void) fprintf(vis_stdout, "The hierarchy manager is empty.  Read in design.\n");
    return 1;
  }
    
  /*
   * Call the commands one-by-one, returning upon the first error.
   */
  if (Cmd_CommandExecute(hmgr, "flatten_hierarchy")) {
    return 1;
  }
  
  if (Cmd_CommandExecute(hmgr, "static_order")) {
    return 1;
  }
  
  if (Cmd_CommandExecute(hmgr, "build_partition_mdds")) {
    return 1;
  }
  
  return 0;             /* normal exit */


usage:
  (void) fprintf(vis_stderr, "usage: init_verify [-b] [-h]\n");
  (void) fprintf(vis_stderr, "   -b  not used any longer.\n");
  (void) fprintf(vis_stderr, "   -h  print the command usage\n");
  return 1;             /* error exit */
}


static int
CommandNetworkSweep(
  Hrc_Manager_t ** hmgr,
  int  argc,
  char ** argv)
{
  int           c;
  Ntk_Network_t *network = Ntk_HrcManagerReadCurrentNetwork(*hmgr);
  int           verbosity = 0;

  /*
   * Parse the command line.
   */
  util_getopt_reset();
  while ((c = util_getopt(argc, argv, "hv")) != EOF) {
    switch (c) {
      case 'h':
        goto usage;
      case 'v':
        verbosity = 1;
        break;
      default:
        goto usage;
    }
  }
  
  if (network == NIL(Ntk_Network_t)) {
    return 1;
  }
  
  Ntk_NetworkSweep(network, verbosity);
  return 0;

usage:
  (void) fprintf(vis_stderr, "usage: network_sweep [-h][-v]\n");
  (void) fprintf(vis_stderr, "   -h  print the command usage\n");
  (void) fprintf(vis_stderr, "   -v  print debug information\n");  
  return 1;             /* error exit */
}

static boolean
FileReadNameList(
  FILE * fp,
  lsList * nameList /* of char *, for return */,
  int verbose)
{
  int     c;
  int     state;
  int     curPosition = 0;
  char   *name;
  char    string[MAX_NAME_LENGTH];
  boolean returnFlag = TRUE;
  
  *nameList = lsCreate();

  state = STATE_TEST;
  while ((c = fgetc(fp)) != EOF) {

    switch (state) {
      case STATE_TEST:
        /* At start of a new line. */
        if (c == '#') {
          /* Line starting with comment character; wait for newline */
          state = STATE_WAIT;
        }
        else if ((c == ' ') || (c == '\t')) {
          /* Line starting with white space; wait for newline */
          state = STATE_WAIT;
        }
        else if (c == '\n') {
          /* Line starting with newline; go to next line */
          state = STATE_TEST;
        }
        else {
          /* Assume starting a name. */
          curPosition = 0;
          string[curPosition++] = c;
          state = STATE_IN;
        }
        break;
      case STATE_WAIT:
        /*
         * Waiting for the newline character.
         */
        state = (c == '\n') ? STATE_TEST : STATE_WAIT;
        break;
      case STATE_IN:
        /*
         * Parsing a name.  If white space reached, then terminate the
         * name and process it.  Else, continue parsing.
         */
        if ((c == ' ') || (c == '\n') || (c == '\t')) {
          string[curPosition] = '\0';
          name = util_strsav(string);
          if (verbose > 1) {
            (void) fprintf(vis_stdout, "Reading name: %s\n", name);
          }
          (void) lsNewEnd(*nameList, (lsGeneric) name, LS_NH);  
          
          state = (c == '\n') ? STATE_TEST : STATE_WAIT;
        }
        else {
          string[curPosition++] = c;
          if (curPosition >= MAX_NAME_LENGTH) {
            error_append("maximum name length exceeded");
            returnFlag = FALSE;
          }
          state = STATE_IN; /* redundant, but be explicit */
        }
        break;
      default:
        fail("unrecognized state");
    }
  }

  /*
   * Handle case where EOF terminates a name.
   */
  if (state == STATE_IN) {
    string[curPosition] = '\0';
    name = util_strsav(string);
    if (verbose > 1) {
      (void) fprintf(vis_stdout, "Reading name: %s\n", name);
    }
    (void) lsNewEnd(*nameList, (lsGeneric) name, LS_NH);  
          
  }

  if (returnFlag) {
    return TRUE;
  }
  else {
    (void) lsDestroy(*nameList, (void (*) (lsGeneric)) NULL);
    return FALSE;
  }
}