+SOURCE=.\src\aig\gia\giaLf.c

+# End Source File

+# Begin Source File

+

+ int fMuxXor;

+#define Gia_ManForEachAndId( p, i ) \

+ for ( i = 0; (i < p->nObjs); i++ ) if ( !Gia_ObjIsAnd(Gia_ManObj(p, i)) ) {} else

+#define Gia_ManForEachAndReverseId( p, i ) \

+ for ( i = p->nObjs - 1; (i > 0); i-- ) if ( !Gia_ObjIsAnd(Gia_ManObj(p, i)) ) {} else

+#define Gia_ManForEachCoDriverId( p, DriverId, i ) \

+ for ( i = 0; (i < Vec_IntSize(p->vCos)) && (((DriverId) = Gia_ObjFaninId0p(p, Gia_ManCo(p, i))), 1); i++ )

+extern void Gia_ManMappingVerify( Gia_Man_t * p );

+extern void Gia_ManCountMuxXor( Gia_Man_t * p, int * pnMuxes, int * pnXors );

+ int nAnds = Gia_ManAndNum(p)-Gia_ManXorNum(p)-Gia_ManMuxNum(p);

+ int nXors = Gia_ManXorNum(p);

+ int nMuxes = Gia_ManMuxNum(p);

+ int nTotal = nAnds + 3*nXors + 3*nMuxes;

+ Abc_Print( 1, "\nXOR/MUX stats:" );

+ Abc_Print( 1, " xor =%8d (%6.2f %%) ", nXors, 300.0*nXors/nTotal );

+ Abc_Print( 1, " mux =%8d (%6.2f %%) ", nMuxes, 300.0*nMuxes/nTotal );

+ Abc_Print( 1, " and =%8d (%6.2f %%) ", nAnds, 100.0*nAnds/nTotal );

+ }

+ else if ( pPars->fMuxXor )

+ {

+ int nAnds, nMuxes, nXors, nTotal = Gia_ManAndNum(p);

+ Gia_ManCountMuxXor( p, &nMuxes, &nXors );

+ nAnds = Gia_ManAndNum(p)-3*nMuxes-3*nXors;

+ Abc_Print( 1, "\nXOR/MUX stats:" );

+ Abc_Print( 1, " xor =%8d (%6.2f %%) ", nXors, 300.0*nXors/nTotal );

+ Abc_Print( 1, " mux =%8d (%6.2f %%) ", nMuxes, 300.0*nMuxes/nTotal );

+ Abc_Print( 1, " and =%8d (%6.2f %%) ", nAnds, 100.0*nAnds/nTotal );

+ Synopsis [Assigns references.]

+

+ Description []

+

+ SideEffects []

+

+ SeeAlso []

+

+***********************************************************************/

+void Gia_ManCountMuxXor( Gia_Man_t * p, int * pnMuxes, int * pnXors )

+{

+ Gia_Obj_t * pObj, * pFan0, * pFan1;

+ int i;

+ *pnMuxes = 0;

+ *pnXors = 0;

+ Gia_ManForEachAnd( p, pObj, i )

+ {

+ if ( !Gia_ObjIsMuxType(pObj) )

+ continue;

+ if ( Gia_ObjRecognizeExor(pObj, &pFan0, &pFan1) )

+ (*pnXors)++;

+ else

+ (*pnMuxes)++;

+ }

+}

+

+/**Function*************************************************************

+

+ src/aig/gia/giaLf.c \

+static int Abc_CommandAbc9Lf ( Abc_Frame_t * pAbc, int argc, char ** argv );

+ Cmd_CommandAdd( pAbc, "ABC9", "&lf", Abc_CommandAbc9Lf, 0 );

+ while ( ( c = Extra_UtilGetopt( argc, argv, "Dtpcnlmh" ) ) != EOF )

+ case 'm':

+ pPars->fMuxXor ^= 1;

+ break;

+ Abc_Print( -2, "usage: &ps [-tpcnlmh] [-D file]\n" );

+ Abc_Print( -2, "\t-m : toggle printing MUX/XOR statistics [default = %s]\n", pPars->fMuxXor? "yes": "no" );

+/**Function*************************************************************

+

+ Synopsis []

+

+ Description []

+

+ SideEffects []

+

+ SeeAlso []

+

+***********************************************************************/

+int Abc_CommandAbc9Lf( Abc_Frame_t * pAbc, int argc, char ** argv )

+{

+ extern void Lf_ManSetDefaultPars( Jf_Par_t * pPars );

+ extern Gia_Man_t * Lf_ManPerformMapping( Gia_Man_t * pGia, Jf_Par_t * pPars );

+ char Buffer[200];

+ Jf_Par_t Pars, * pPars = &Pars;

+ Gia_Man_t * pNew; int c;

+ Lf_ManSetDefaultPars( pPars );

+ Extra_UtilGetoptReset();

+ while ( ( c = Extra_UtilGetopt( argc, argv, "KCRDWaekmdcgtsvwh" ) ) != EOF )

+ {

+ switch ( c )

+ {

+ case 'K':

+ if ( globalUtilOptind >= argc )

+ {

+ Abc_Print( -1, "Command line switch \"-K\" should be followed by a positive integer.\n" );

+ goto usage;

+ }

+ pPars->nLutSize = atoi(argv[globalUtilOptind]);

+ globalUtilOptind++;

+ if ( pPars->nLutSize < 2 || pPars->nLutSize > pPars->nLutSizeMax )

+ {

+ Abc_Print( -1, "LUT size %d is not supported.\n", pPars->nLutSize );

+ goto usage;

+ }

+ break;

+ case 'C':

+ if ( globalUtilOptind >= argc )

+ {

+ Abc_Print( -1, "Command line switch \"-C\" should be followed by a positive integer.\n" );

+ goto usage;

+ }

+ pPars->nCutNum = atoi(argv[globalUtilOptind]);

+ globalUtilOptind++;

+ if ( pPars->nCutNum < 1 || pPars->nCutNum > pPars->nCutNumMax )

+ {

+ Abc_Print( -1, "This number of cuts (%d) is not supported.\n", pPars->nCutNum );

+ goto usage;

+ }

+ break;

+ case 'R':

+ if ( globalUtilOptind >= argc )

+ {

+ Abc_Print( -1, "Command line switch \"-R\" should be followed by a positive integer.\n" );

+ goto usage;

+ }

+ pPars->nRounds = atoi(argv[globalUtilOptind]);

+ globalUtilOptind++;

+ if ( pPars->nRounds < 0 )

+ goto usage;

+ break;

+ case 'D':

+ if ( globalUtilOptind >= argc )

+ {

+ Abc_Print( -1, "Command line switch \"-D\" should be followed by a floating point number.\n" );

+ goto usage;

+ }

+ pPars->DelayTarget = atoi(argv[globalUtilOptind]);

+ globalUtilOptind++;

+ if ( pPars->DelayTarget <= 0.0 )

+ goto usage;

+ break;

+ case 'W':

+ if ( globalUtilOptind >= argc )

+ {

+ Abc_Print( -1, "Command line switch \"-W\" should be followed by a positive integer.\n" );

+ goto usage;

+ }

+ pPars->nVerbLimit = atoi(argv[globalUtilOptind]);

+ globalUtilOptind++;

+ if ( pPars->nVerbLimit < 0 )

+ goto usage;

+ break;

+ case 'a':

+ pPars->fAreaOnly ^= 1;

+ break;

+ case 'e':

+ pPars->fOptEdge ^= 1;

+ break;

+ case 'k':

+ pPars->fCoarsen ^= 1;

+ break;

+ case 'm':

+ pPars->fCutMin ^= 1;

+ break;

+ case 'd':

+ pPars->fFuncDsd ^= 1;

+ break;

+ case 'c':

+ pPars->fGenCnf ^= 1;

+ break;

+ case 'g':

+ pPars->fPureAig ^= 1;

+ break;

+ case 't':

+ pPars->fCutHashing ^= 1;

+ break;

+ case 's':

+ pPars->fCutSimple ^= 1;

+ break;

+ case 'v':

+ pPars->fVerbose ^= 1;

+ break;

+ case 'w':

+ pPars->fVeryVerbose ^= 1;

+ break;

+ case 'h':

+ default:

+ goto usage;

+ }

+ }

+

+ if ( pAbc->pGia == NULL )

+ {

+ Abc_Print( -1, "Empty GIA network.\n" );

+ return 1;

+ }

+

+ pNew = Lf_ManPerformMapping( pAbc->pGia, pPars );

+ if ( pNew == NULL )

+ {

+ Abc_Print( -1, "Abc_CommandAbc9Lf(): Mapping into LUTs has failed.\n" );

+ return 1;

+ }

+ Abc_FrameUpdateGia( pAbc, pNew );

+ return 0;

+

+usage:

+ if ( pPars->DelayTarget == -1 )

+ sprintf(Buffer, "best possible" );

+ else

+ sprintf(Buffer, "%d", pPars->DelayTarget );

+ Abc_Print( -2, "usage: &lf [-KCRDW num] [-akmdcgtsvwh]\n" );

+ Abc_Print( -2, "\t performs technology mapping of the network\n" );

+ Abc_Print( -2, "\t-K num : LUT size for the mapping (2 <= K <= %d) [default = %d]\n", pPars->nLutSizeMax, pPars->nLutSize );

+ Abc_Print( -2, "\t-C num : the max number of priority cuts (1 <= C <= %d) [default = %d]\n", pPars->nCutNumMax, pPars->nCutNum );

+ Abc_Print( -2, "\t-R num : the number of mapping rounds [default = %d]\n", pPars->nRounds );

+ Abc_Print( -2, "\t-D num : sets the delay constraint for the mapping [default = %s]\n", Buffer );

+ Abc_Print( -2, "\t-W num : min frequency when printing functions with \"-w\" [default = %d]\n", pPars->nVerbLimit );

+ Abc_Print( -2, "\t-a : toggles area-oriented mapping [default = %s]\n", pPars->fAreaOnly? "yes": "no" );

+ Abc_Print( -2, "\t-e : toggles edge vs node minimization [default = %s]\n", pPars->fOptEdge? "yes": "no" );

+ Abc_Print( -2, "\t-k : toggles coarsening the subject graph [default = %s]\n", pPars->fCoarsen? "yes": "no" );

+ Abc_Print( -2, "\t-m : toggles cut minimization [default = %s]\n", pPars->fCutMin? "yes": "no" );

+ Abc_Print( -2, "\t-d : toggles using DSD to represent cut functions [default = %s]\n", pPars->fFuncDsd? "yes": "no" );

+ Abc_Print( -2, "\t-c : toggles mapping for CNF generation [default = %s]\n", pPars->fGenCnf? "yes": "no" );

+ Abc_Print( -2, "\t-g : toggles generating AIG without mapping [default = %s]\n", pPars->fPureAig? "yes": "no" );

+ Abc_Print( -2, "\t-t : toggles cut computation using hash table [default = %s]\n", pPars->fCutHashing? "yes": "no" );

+ Abc_Print( -2, "\t-s : toggles cut computation using a simple method [default = %s]\n", pPars->fCutSimple? "yes": "no" );

+ Abc_Print( -2, "\t-v : toggles verbose output [default = %s]\n", pPars->fVerbose? "yes": "no" );

+ Abc_Print( -2, "\t-w : toggles very verbose output [default = %s]\n", pPars->fVeryVerbose? "yes": "no" );

+ Abc_Print( -2, "\t-h : prints the command usage\n");

+ return 1;

+}

+

+static inline void Vec_IntDowndateEntry( Vec_Int_t * p, int i, int Value )

+{

+ if ( Vec_IntEntry( p, i ) > Value )

+ Vec_IntWriteEntry( p, i, Value );

+}

+static inline void Vec_PtrFreeData( Vec_Ptr_t * p )

+ void * pTemp; int i;

+}

+static inline void Vec_PtrFreeFree( Vec_Ptr_t * p )

+{

+ if ( p == NULL ) return;

+ Vec_PtrFreeData( p );