ntki.c

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

        }
    }

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

    // print nodes by level
    Ntk_NetworkRenameNodes( pNet );
    fprintf( pOut, "The names of all nodes have been changed.\n" );
    return 0;

usage:
    fprintf( pErr, "usage: rename [-h]\n" );
    fprintf( pErr, "\t     renames all nodes in the network\n" );
    fprintf( pErr, "\t-h     : print the command usage\n");
    return 1;
}


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

  Synopsis    []

  Description []

  SideEffects []

  SeeAlso     []

******************************************************************************/
int Ntk_CommandChangeNameMode( Mv_Frame_t * pMvsis, int argc, char **argv )
{
    FILE * pOut, * pErr;

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

    if ( argc != 1 )
    {
        fprintf( pErr, "usage: chname\n" );
        fprintf( pErr, "       toggles between the short and long name modes\n" );
        return 1;
    }

    if ( Mv_FrameReadMode(pMvsis) )
    {
        Mv_FrameSetMode( pMvsis, 0 );
        fprintf( pOut, "Changing to long name mode.\n");
    }
    else 
    {
        Mv_FrameSetMode( pMvsis, 1 );
        fprintf( pOut, "Changing to short name mode.\n");
    }
    return 0;
}


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

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

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

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

    Degree = 2;
    util_getopt_reset();
    while ( ( c = util_getopt( argc, argv, "nh" ) ) != EOF )
    {
        switch ( c )
        {
            case 'n':
                if ( util_optind >= argc )
                {
                    fprintf( pErr, "Command line switch \"-n\" should be followed by an integer.\n" );
                    goto usage;
                }
                Degree = atoi(argv[util_optind]);
                util_optind++;
                if ( Degree < 0 ) 
                    goto usage;
                break;
            case 'h':
                goto usage;
                break;
            default:
            goto usage;
        }
    }

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

    // write the clauses
    Ntk_NetworkComputePower( pNet, Degree ); 
    return 0;

usage:
    fprintf( pErr, "usage: _power [-n num]\n" );
    fprintf( pErr, "\t           generates the \"power\" of the given network\n" );
    fprintf( pErr, "\t-n num   : the number of levels [default = %d].\n", Degree );
    return 1;
}

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

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
int Ntk_CommandNetworkNDize( Mv_Frame_t * pMvsis, int argc, char ** argv )
{
    FILE * pOut, * pErr;
    Ntk_Network_t * pNet;
    double Prob;
    int c;

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

    Prob = 0.1;
    util_getopt_reset();
    while ( ( c = util_getopt( argc, argv, "ph" ) ) != EOF )
    {
        switch ( c )
        {
        case 'p':
            Prob = atof(argv[util_optind]);
            util_optind++;
            if ( Prob < 0 ) 
                goto usage;
            break;
        case 'h':
            goto usage;
            break;
        default:
            goto usage;
        }
    }

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

    // write the clauses
    Ntk_NetworkNonDeterminize( pNet, Prob ); 
    return 0;

usage:
    fprintf( pErr, "usage: _ndize [-p num] [-h]\n" );
    fprintf( pErr, "\t          non-determinizes the network by adding ND buffers\n" );
    fprintf( pErr, "\t-p num  : a floating point number (0 <= num <= 1) [default = %.2f].\n", Prob );
    return 1;
}

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

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
int Ntk_CommandNetworkDize( Mv_Frame_t * pMvsis, int argc, char ** argv )
{
    FILE * pOut, * pErr;
    Ntk_Network_t * pNet;
    Ntk_Node_t * pNode;
    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;
    }

    // write the clauses
    Ntk_NetworkForEachNode( pNet, pNode )
        Ntk_NodeDeterminize( pNode );

//    Ntk_NetworkEncode( pNet );
    return 0;

usage:
    fprintf( pErr, "usage: dize [-h]\n" );
    fprintf( pErr, "\t          determinizes ND nodes in the network\n" );
    return 1;
}

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

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

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

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

    util_getopt_reset();
    while ( ( c = util_getopt( argc, argv, "vh" ) ) != 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;
    }

    // reorder the local function of each node
    Ntk_NetworkReorder( pNet, fVerbose );
    return 0;

usage:
    fprintf( pErr, "usage: reorder [-v]\n" );
    fprintf( pErr, "\t         reorders BDDs of the local MV relations of the nodes\n" );
    fprintf( pErr, "\t-v     : enable printing out statistics [default = %d].\n", fVerbose? "yes": "no" );  
    return 1;
}

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

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Ntk_CommandNetworkCopy( 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;
            default:
                goto usage;
        }
    }

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

    // replace the current network without modifying the stack of saved networks
    Mv_FrameReplaceCurrentNetwork( pMvsis, Ntk_NetworkDup(pNet, pNet->pMan) );
    return 0;

usage:
    fprintf( pErr, "usage: copy [-h]\n");
    fprintf( pErr, "\t         replaces the current network by its copy\n" );  
    fprintf( pErr, "\t         does not modify the stack of the saved networks\n" );  
    fprintf( pErr, "\t-h     : print the command usage\n");
    return 1;       /* error exit */
}


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

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

***********************************************************************/
Ntk_CommandNetworkFree( 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;
            default:
                goto usage;
        }
    }

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

    // get the value
    if ( util_optind < argc )
    {
        Ntk_Node_t * pNode;
        if ( strcmp( argv[util_optind], "cvr" ) == 0 )
        {
            Ntk_NetworkForEachNode( pNet, pNode )
            {
                Ntk_NodeGetFuncMvr( pNode );
                Ntk_NodeFreeFuncCvr( pNode );
            }
            return 0;
        }
        else if ( strcmp( argv[util_optind], "mvr" ) == 0 )
        {
            Ntk_NetworkForEachNode( pNet, pNode )
            {
                Ntk_NodeGetFuncCvr( pNode );
                Ntk_NodeFreeFuncMvr( pNode );
            }
            return 0;
        }
    }

    fprintf( pOut, "The object to free is not specified\n" );  
    return 0;

usage:
    fprintf( pErr, "usage: free <object> [-h]\n");
    fprintf( pErr, "\t           frees MV SOPs (\"cvr\") or MV relations (\"mvr\") in all nodes\n" );  
    fprintf( pErr, "\t<object> : the representation to free (\"cvr\" or \"mvr\")\n" );
    fprintf( pErr, "\t-h       : print the command usage\n");
    return 1;       /* error exit */
}

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

  Synopsis    []

  Description []
               
  SideEffects []

  SeeAlso     []

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

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

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