ntki.c

主要进行大规模的电路综合

    {

        pNode1  = Ntk_NetworkCollectNodeByName( pNet, argv[util_optind],   0 );
        if ( !pNode1  )
            return 1;
        Ntk_NetworkCollapseNode( pNet, pNode1 );
    }
    else
    {
        fprintf( pErr, "Incorrect number of command line arguments.\n" );
        return 1;
    }

    return 0;

usage:
    fprintf( pErr, "usage: collapse [-v] [-h] <node1> <node2>\n");
    fprintf( pErr, "\t          collapses the nodes or the network (default)\n" );  
    fprintf( pErr, "\t<node1> : the node to collapse into its fanouts\n");
    fprintf( pErr, "\t<node2> : if given, the node to collapse into <node1>\n");
    fprintf( pErr, "\t-v      : toggles verbose output [default = %s]\n", fVerbose? "yes": "no" );  
    fprintf( pErr, "\t-h      : print the command usage\n");
    return 1;       /* error exit */
}


/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Ntk_CommandNetworkMerge( Mv_Frame_t * pMvsis, int argc, char ** argv )
{
    FILE * pOut, * pErr;
    Ntk_Network_t * pNet;
    int nNodes;
    int fVerbose;
    int c;

    pNet = Mv_FrameReadNet(pMvsis);
    pOut = Mv_FrameReadOut(pMvsis);
    pErr = Mv_FrameReadErr(pMvsis);

    // set the defaults
    fVerbose = 0;
    util_getopt_reset();
    while ( (c = util_getopt(argc, argv, "hv")) != EOF ) 
    {
        switch (c) 
        {
            case 'v':
                fVerbose ^= 1;
                break;
            case 'h':
                goto usage;
                break;
            default:
                goto usage;
        }
    }

    if ( pNet == NULL )
    {
        fprintf( pErr, "Empty network.\n" );
        return 1;
    }

    if ( util_optind == argc )
    {
        fprintf( pErr, "The list of nodes for merging is not given.\n" );
        return 1;
    }

    // collect the nodes
    nNodes = Cmd_CommandGetNodes( pMvsis, argc-util_optind+1, argv+util_optind-1, 0 );
    if ( nNodes < 2 )
    {
        fprintf( pErr, "The list of nodes contains less then two internal nodes.\n" );
        return 1;
    }

    // the nodes to be merged are linked into the special linked list
    Ntk_NetworkMerge( pNet, nNodes );
    return 0;

usage:
    fprintf( pErr, "usage: merge <node_list>\n");
    fprintf( pErr, "\t         merges all the nodes in the list\n" );  
    fprintf( pErr, "\t-h     : print the command usage\n");
    return 1;       /* error exit */
}


/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Ntk_CommandNetworkFxu( Mv_Frame_t * pMvsis, int argc, char ** argv )
{
    Ntk_Network_t * pNet;
    FILE * pOut, * pErr;
    Fxu_Data_t * p = NULL;
    int c;

    pNet = Mv_FrameReadNet(pMvsis);
    pOut = Mv_FrameReadOut(pMvsis);
    pErr = Mv_FrameReadErr(pMvsis);

    // allocate the structure
    p = ALLOC( Fxu_Data_t, 1 );
    memset( p, 0, sizeof(Fxu_Data_t) );
    // set the defaults
    p->nPairsMax = 30000;
    p->nNodesExt = 10000;
    p->fOnlyS    = 0;
    p->fOnlyD    = 0;
    p->fUse0     = 0;
    p->fUseCompl = 1;
    p->fVerbose  = 0;
    util_getopt_reset();
    while ( (c = util_getopt(argc, argv, "lnsdzcvh")) != EOF ) 
    {
        switch (c) 
        {
            case 'l':
                if ( util_optind >= argc )
                {
                    fprintf( pErr, "Command line switch \"-l\" should be followed by an integer.\n" );
                    goto usage;
                }
                p->nPairsMax = atoi(argv[util_optind]);
                util_optind++;
                if ( p->nPairsMax < 0 ) 
                    goto usage;
                break;
            case 'n':
                if ( util_optind >= argc )
                {
                    fprintf( pErr, "Command line switch \"-n\" should be followed by an integer.\n" );
                    goto usage;
                }
                p->nNodesExt = atoi(argv[util_optind]);
                util_optind++;
                if ( p->nNodesExt < 0 ) 
                    goto usage;
                break;
            case 's':
                p->fOnlyS ^= 1;
                break;
            case 'd':
                p->fOnlyD ^= 1;
                break;
            case 'z':
                p->fUse0 ^= 1;
                break;
            case 'c':
                p->fUseCompl ^= 1;
                break;
            case 'v':
                p->fVerbose ^= 1;
                break;
            case 'h':
                goto usage;
                break;
            default:
                goto usage;
        }
    }

    if ( pNet == NULL )
    {
        fprintf( pErr, "Empty network.\n" );
        Ntk_NetworkFxFreeInfo( p );
        return 1;
    }

    // the nodes to be merged are linked into the special linked list
    Ntk_NetworkFastExtract( pNet, p );
    Ntk_NetworkFxFreeInfo( p );
    return 0;

usage:
    fprintf( pErr, "usage: fxu [-n num] [-l num] [-s] [-d] [-z] [-c] [-v] [-h]\n");
    fprintf( pErr, "\t         performs unate fast extract on the current network\n");
    fprintf( pErr, "\t-n num : the maximum number of divisors to extract [default = %d]\n", p->nNodesExt );  
    fprintf( pErr, "\t-l num : the maximum number of cube pairs to consider [default = %d]\n", p->nPairsMax );  
    fprintf( pErr, "\t-s     : use only single-cube divisors [default = %s]\n", p->fOnlyS? "yes": "no" );  
    fprintf( pErr, "\t-d     : use only double-cube divisors [default = %s]\n", p->fOnlyD? "yes": "no" );  
    fprintf( pErr, "\t-z     : use zero-weight divisors [default = %s]\n", p->fUse0? "yes": "no" );  
    fprintf( pErr, "\t-c     : use complement in the binary case [default = %s]\n", p->fUseCompl? "yes": "no" );  
    fprintf( pErr, "\t-v     : print verbose information [default = %s]\n", p->fVerbose? "yes": "no" ); 
    fprintf( pErr, "\t-h     : print the command usage\n");
    Ntk_NetworkFxFreeInfo( p );
    return 1;       
}

/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Ntk_CommandNetworkDecomp( Mv_Frame_t * pMvsis, int argc, char ** argv )
{
    FILE * pOut, * pErr;
    Ntk_Network_t * pNet;
    int fVerbose;
    int c;

    pNet = Mv_FrameReadNet(pMvsis);
    pOut = Mv_FrameReadOut(pMvsis);
    pErr = Mv_FrameReadErr(pMvsis);

    // set the defaults
    fVerbose = 0;
    util_getopt_reset();
    while ( (c = util_getopt(argc, argv, "hv")) != EOF ) 
    {
        switch (c) 
        {
            case 'v':
                fVerbose ^= 1;
                break;
            case 'h':
                goto usage;
                break;
            default:
                goto usage;
        }
    }

    if ( pNet == NULL )
    {
        fprintf( pErr, "Empty network.\n" );
        return 1;
    }

    Ntk_NetworkDecomp( pNet );
    return 0;

usage:
    fprintf( pErr, "usage: decomp [-h]\n");
    fprintf( pErr, "\t         decomposes the network using the factored forms\n" );  
    fprintf( pErr, "\t-h     : print the command usage\n");
    return 1;       /* error exit */
}

/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
int Ntk_CommandNetworkStrash( Mv_Frame_t * pMvsis, int argc, char ** argv )
{
    FILE * pOut, * pErr;
    Ntk_Network_t * pNet, * pNetNew;
    int c;

    pNet = Mv_FrameReadNet(pMvsis);
    pOut = Mv_FrameReadOut(pMvsis);
    pErr = Mv_FrameReadErr(pMvsis);

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

    if ( pNet == NULL )
    {
        fprintf( pErr, "Empty network.\n" );
        return 1;
    }

    // create the structurally hashed network
    pNetNew = Ntk_NetworkStrash( pNet );
    if ( pNetNew == NULL )
    {
        fprintf( pErr, "Network strashing has failed!\n" );
        return 1;
    }

    // replace the current network
    Mv_FrameReplaceCurrentNetwork( pMvsis, pNetNew );
    return 0;

usage:
    fprintf( pErr, "usage: strash\n" );
    fprintf( pErr, "\t     replaces the current network by SS-equivalent\n" );
    fprintf( pErr, "\t     structurally hashed network of AND/INV gates\n" );
    fprintf( pErr, "\t-h     : print the command usage\n");
    return 1;
}


/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Ntk_CommandNetworkResetDef( Mv_Frame_t * pMvsis, int argc, char ** argv )
{
    FILE * pOut, * pErr;
    Ntk_Network_t * pNet;
    Ntk_Node_t * pNode;
    int fVerbose;
    int c;

    pNet = Mv_FrameReadNet(pMvsis);
    pOut = Mv_FrameReadOut(pMvsis);
    pErr = Mv_FrameReadErr(pMvsis);

    // set the defaults
    fVerbose = 0;
    util_getopt_reset();
    while ( (c = util_getopt(argc, argv, "hv")) != EOF ) 
    {
        switch (c) 
        {
            case 'v':
                fVerbose ^= 1;
                break;
            case 'h':
                goto usage;
                break;
            default:
                goto usage;
        }
    }

    if ( pNet == NULL )
    {
        fprintf( pErr, "Empty network.\n" );
        return 1;
    }

    // get the node name
    pNode = NULL;
    if ( util_optind < argc )
    {
        pNode = Ntk_NetworkCollectNodeByName( pNet, argv[util_optind], 0 );
        if ( pNode == NULL )
            goto usage;
        Ntk_NodeResetDefault( pNode, Ntk_NetworkGetAcceptType(pNet) );
        return 0;
    }

    Ntk_NetworkResetDefault( pNet );
    return 0;

usage:
    fprintf( pErr, "usage: reset_default [-h] <node>\n");
    fprintf( pErr, "\t         assigns the default values by minimizing MV relations\n" );  
    fprintf( pErr, "\t-h     : print the command usage\n");
    fprintf( pErr, "\t<node> : the name of one node to reset default\n");
    return 1;       /* error exit */
}


/**Function*************************************************************

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Ntk_CommandNetworkFfResetDef( Mv_Frame_t * pMvsis, int argc, char ** argv )
{
    FILE * pOut, * pErr;
    Ntk_Network_t * pNet;
    Ntk_Node_t * pNode;
    int fVerbose;
    int c;

    pNet = Mv_FrameReadNet(pMvsis);
    pOut = Mv_FrameReadOut(pMvsis);
    pErr = Mv_FrameReadErr(pMvsis);

    // set the defaults
    fVerbose = 0;
    util_getopt_reset();
    while ( (c = util_getopt(argc, argv, "hv")) != EOF ) 
    {
        switch (c) 
        {
            case 'v':
                fVerbose ^= 1;
                break;
            case 'h':
                goto usage;
                break;
            default:
                goto usage;
        }
    }

    if ( pNet == NULL )
    {
        fprintf( pErr, "Empty network.\n" );
        return 1;
    }

    // get the node name
    pNode = NULL;
    if ( util_optind < argc )
    {
        pNode = Ntk_NetworkCollectNodeByName( pNet, argv[util_optind], 0 );
        if ( pNode == NULL )
            goto usage;
        Ntk_NodeFfResetDefault( pNode, 0, fVerbose );
        return 0;
    }


    Ntk_NetworkFfResetDefault( pNet, fVerbose );
    return 0;

usage:
    fprintf( pErr, "usage: _ffrsd [-h] <node>\n");
    fprintf( pErr, "\t         phase-assigns binary covers using FF complement\n" );  
    fprintf( pErr, "\t-h     : print the command usage\n");
    fprintf( pErr, "\t<node> : the name of one node to reset default\n");
    return 1;       /* error exit */
}

/**Function*******************