summaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/base/abc/abc.h4
-rw-r--r--src/base/abc/abcFunc.c2
-rw-r--r--src/base/abc/abcLib.c5
-rw-r--r--src/base/abc/abcNtk.c4
-rw-r--r--src/base/abc/abcObj.c4
-rw-r--r--src/base/abci/abc.c241
-rw-r--r--src/base/abci/abcDsd.c2
-rw-r--r--src/base/abci/abcExtract.c51
-rw-r--r--src/base/abci/abcFpgaFast.c141
-rw-r--r--src/base/abci/abcIvy.c83
-rw-r--r--src/base/abci/abcMini.c1
-rw-r--r--src/base/abci/abcNtbdd.c3
-rw-r--r--src/base/abci/abcPrint.c4
-rw-r--r--src/base/abci/abcProve.c23
-rw-r--r--src/base/abci/abcSat.c35
-rw-r--r--src/base/abci/abcVerify.c22
-rw-r--r--src/base/abci/module.make4
-rw-r--r--src/base/io/io.c15
-rw-r--r--src/base/io/ioWriteVer.c78
-rw-r--r--src/misc/nm/nmApi.c4
-rw-r--r--src/misc/st/st.c16
-rw-r--r--src/sat/asat/asat60525.zipbin25597 -> 0 bytes
-rw-r--r--src/sat/asat_fixed/satSolver.c1191
-rw-r--r--src/sat/asat_fixed/satSolver.h137
-rw-r--r--src/sat/bsat/module.make3
-rw-r--r--src/sat/bsat/satMem.c (renamed from src/temp/ivy/satMem.c)0
-rw-r--r--src/sat/bsat/satMem.h (renamed from src/temp/ivy/satMem.h)0
-rw-r--r--src/sat/bsat/satSolver.c (renamed from src/temp/ivy/satSolver.c)59
-rw-r--r--src/sat/bsat/satSolver.h (renamed from src/temp/ivy/satSolver.h)11
-rw-r--r--src/sat/bsat/satUtil.c (renamed from src/temp/ivy/satUtil.c)0
-rw-r--r--src/sat/bsat/satVec.h (renamed from src/temp/ivy/satVec.h)4
-rw-r--r--src/sat/csat/csat_apis.c7
-rw-r--r--src/sat/fraig/fraigMan.c4
-rw-r--r--src/temp/aig/aig.h2
-rw-r--r--src/temp/aig/aigDfs.c54
-rw-r--r--src/temp/aig/aigUtil.c72
-rw-r--r--src/temp/aig/cudd2.c337
-rw-r--r--src/temp/aig/cudd2.h (renamed from src/temp/vec/vec.h)44
-rw-r--r--src/temp/aig/module.make9
-rw-r--r--src/temp/esop/esop.h723
-rw-r--r--src/temp/esop/esopMan.c117
-rw-r--r--src/temp/esop/esopMin.c299
-rw-r--r--src/temp/esop/esopUtil.c277
-rw-r--r--src/temp/esop/module.make3
-rw-r--r--src/temp/ivy/ivy.h13
-rw-r--r--src/temp/ivy/ivyFastMap.c41
-rw-r--r--src/temp/ivy/ivyFraig.c626
-rw-r--r--src/temp/ivy/ivyMan.c104
-rw-r--r--src/temp/ivy/ivyResyn.c50
-rw-r--r--src/temp/ivy/module.make4
-rw-r--r--src/temp/player/module.make4
-rw-r--r--src/temp/player/player.h113
-rw-r--r--src/temp/player/playerAbc.c228
-rw-r--r--src/temp/player/playerBuild.c283
-rw-r--r--src/temp/player/playerCore.c376
-rw-r--r--src/temp/player/playerMan.c125
-rw-r--r--src/temp/player/playerToAbc.c523
-rw-r--r--src/temp/player/playerUtil.c353
-rw-r--r--src/temp/vec/module.make1
-rw-r--r--src/temp/vec/vecInt.h775
-rw-r--r--src/temp/vec/vecPtr.h587
-rw-r--r--src/temp/vec/vecStr.h510
-rw-r--r--src/temp/vec/vecVec.h289
-rw-r--r--src/temp/ver/module.make4
-rw-r--r--src/temp/ver/verCore.c30
-rw-r--r--src/temp/ver/verFormula.c27
-rw-r--r--src/temp/ver/verParse.c6
67 files changed, 1800 insertions, 7367 deletions
diff --git a/src/base/abc/abc.h b/src/base/abc/abc.h
index b619e8b9..149748fc 100644
--- a/src/base/abc/abc.h
+++ b/src/base/abc/abc.h
@@ -698,6 +698,10 @@ extern int Abc_NodeRef_rec( Abc_Obj_t * pNode );
/*=== abcRenode.c ==========================================================*/
extern Abc_Ntk_t * Abc_NtkRenode( Abc_Ntk_t * pNtk, int nThresh, int nFaninMax, int fCnf, int fMulti, int fSimple, int fFactor );
extern DdNode * Abc_NtkRenodeDeriveBdd( DdManager * dd, Abc_Obj_t * pNodeOld, Vec_Ptr_t * vFaninsOld );
+/*=== abcRefactor.c ==========================================================*/
+extern int Abc_NtkRefactor( Abc_Ntk_t * pNtk, int nNodeSizeMax, int nConeSizeMax, bool fUpdateLevel, bool fUseZeros, bool fUseDcs, bool fVerbose );
+/*=== abcRewrite.c ==========================================================*/
+extern int Abc_NtkRewrite( Abc_Ntk_t * pNtk, int fUpdateLevel, int fUseZeros, int fVerbose );
/*=== abcSat.c ==========================================================*/
extern int Abc_NtkMiterSat( Abc_Ntk_t * pNtk, sint64 nConfLimit, sint64 nInsLimit, int fJFront, int fVerbose, sint64 * pNumConfs, sint64 * pNumInspects );
extern solver * Abc_NtkMiterSatCreate( Abc_Ntk_t * pNtk, int fJFront );
diff --git a/src/base/abc/abcFunc.c b/src/base/abc/abcFunc.c
index 7818cc05..23afcd25 100644
--- a/src/base/abc/abcFunc.c
+++ b/src/base/abc/abcFunc.c
@@ -536,7 +536,7 @@ int Abc_NtkSopToAig( Abc_Ntk_t * pNtk )
Aig_Man_t * pMan;
int i;
- assert( Abc_NtkIsSopLogic(pNtk) );
+ assert( Abc_NtkIsSopLogic(pNtk) || Abc_NtkIsSopNetlist(pNtk) );
// start the functionality manager
pMan = Aig_ManStart();
diff --git a/src/base/abc/abcLib.c b/src/base/abc/abcLib.c
index 3a7e4d5b..be0d34b7 100644
--- a/src/base/abc/abcLib.c
+++ b/src/base/abc/abcLib.c
@@ -163,7 +163,7 @@ int Abc_LibDeriveBlackBoxes( Abc_Ntk_t * pNtk, Abc_Lib_t * pLib )
}
return Vec_PtrSize(pNtk->vBoxes);
*/
- return 1;
+ return 0;
}
/**Function*************************************************************
@@ -205,7 +205,7 @@ void Abc_NodeStrashUsingNetwork_rec( Abc_Ntk_t * pNtkAig, Abc_Obj_t * pObj )
***********************************************************************/
void Abc_NodeStrashUsingNetwork( Abc_Ntk_t * pNtkAig, Abc_Obj_t * pBox )
-{
+{
Abc_Ntk_t * pNtkGate;
Abc_Obj_t * pObj;
unsigned * pPolarity;
@@ -229,6 +229,7 @@ void Abc_NodeStrashUsingNetwork( Abc_Ntk_t * pNtkAig, Abc_Obj_t * pBox )
Abc_NodeStrashUsingNetwork_rec( pNtkAig, Abc_ObjFanin0Ntk(Abc_ObjFanin0(pObj)) );
Abc_ObjFanout(pBox,i)->pCopy = Abc_ObjFanin0(pObj)->pCopy;
}
+//printf( "processing %d\n", pBox->Id );
}
/**Function*************************************************************
diff --git a/src/base/abc/abcNtk.c b/src/base/abc/abcNtk.c
index 215e80ec..c99be016 100644
--- a/src/base/abc/abcNtk.c
+++ b/src/base/abc/abcNtk.c
@@ -514,10 +514,6 @@ Abc_Ntk_t * Abc_NtkCreateTarget( Abc_Ntk_t * pNtk, Vec_Ptr_t * vRoots, Vec_Int_t
int i;
assert( Abc_NtkIsLogic(pNtk) );
-
- // convert the network into the AIG form
- if ( !Abc_NtkLogicToAig(pNtk) )
- return NULL;
// start the network
Abc_NtkCleanCopy( pNtk );
diff --git a/src/base/abc/abcObj.c b/src/base/abc/abcObj.c
index 48b6b187..68bbdb40 100644
--- a/src/base/abc/abcObj.c
+++ b/src/base/abc/abcObj.c
@@ -390,10 +390,10 @@ Abc_Obj_t * Abc_NtkFindNode( Abc_Ntk_t * pNtk, char * pName )
// try to find the terminal
Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_PO );
if ( Num >= 0 )
- return Abc_NtkObj( pNtk, Num );
+ return Abc_ObjFanin0( Abc_NtkObj( pNtk, Num ) );
Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_BO );
if ( Num >= 0 )
- return Abc_NtkObj( pNtk, Num );
+ return Abc_ObjFanin0( Abc_NtkObj( pNtk, Num ) );
Num = Nm_ManFindIdByName( pNtk->pManName, pName, ABC_OBJ_NODE );
if ( Num >= 0 )
return Abc_NtkObj( pNtk, Num );
diff --git a/src/base/abci/abc.c b/src/base/abci/abc.c
index 2427146c..b25ca2f7 100644
--- a/src/base/abci/abc.c
+++ b/src/base/abci/abc.c
@@ -117,6 +117,7 @@ static int Abc_CommandSuperChoice ( Abc_Frame_t * pAbc, int argc, char ** arg
static int Abc_CommandSuperChoiceLut ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandFpga ( Abc_Frame_t * pAbc, int argc, char ** argv );
+static int Abc_CommandFpgaFast ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandPga ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandScut ( Abc_Frame_t * pAbc, int argc, char ** argv );
@@ -246,6 +247,7 @@ void Abc_Init( Abc_Frame_t * pAbc )
Cmd_CommandAdd( pAbc, "SC mapping", "scl", Abc_CommandSuperChoiceLut, 1 );
Cmd_CommandAdd( pAbc, "FPGA mapping", "fpga", Abc_CommandFpga, 1 );
+ Cmd_CommandAdd( pAbc, "FPGA mapping", "ffpga", Abc_CommandFpgaFast, 1 );
Cmd_CommandAdd( pAbc, "FPGA mapping", "pga", Abc_CommandPga, 1 );
Cmd_CommandAdd( pAbc, "Sequential", "scut", Abc_CommandScut, 0 );
@@ -4007,6 +4009,7 @@ int Abc_CommandOneOutput( Abc_Frame_t * pAbc, int argc, char ** argv )
goto usage;
}
+ pNodeCo = NULL;
if ( argc == globalUtilOptind + 1 )
{
pNode = Abc_NtkFindNode( pNtk, argv[globalUtilOptind] );
@@ -4827,7 +4830,7 @@ usage:
int Abc_CommandXyz( Abc_Frame_t * pAbc, int argc, char ** argv )
{
FILE * pOut, * pErr;
- Abc_Ntk_t * pNtk, * pNtkRes;
+ Abc_Ntk_t * pNtk, * pNtkRes;//, * pNtkTemp;
int c;
int nLutMax;
int nPlaMax;
@@ -4844,13 +4847,13 @@ int Abc_CommandXyz( Abc_Frame_t * pAbc, int argc, char ** argv )
pErr = Abc_FrameReadErr(pAbc);
// set defaults
- nLutMax = 6;
+ nLutMax = 8;
nPlaMax = 128;
RankCost = 96000;
fFastMode = 1;
fRewriting = 0;
fSynthesis = 0;
- fVerbose = 1;
+ fVerbose = 0;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "LPRfrsvh" ) ) != EOF )
{
@@ -4927,8 +4930,17 @@ int Abc_CommandXyz( Abc_Frame_t * pAbc, int argc, char ** argv )
*/
// run the command
// pNtkRes = Abc_NtkXyz( pNtk, nPlaMax, 1, 0, fInvs, fVerbose );
- pNtkRes = Abc_NtkPlayer( pNtk, nLutMax, nPlaMax, RankCost, fFastMode, fRewriting, fSynthesis, fVerbose );
-// pNtkRes = NULL;
+/*
+ if ( !Abc_NtkIsStrash(pNtk) )
+ {
+ pNtkTemp = Abc_NtkStrash( pNtk, 0, 1 );
+ pNtkRes = Abc_NtkPlayer( pNtkTemp, nLutMax, nPlaMax, RankCost, fFastMode, fRewriting, fSynthesis, fVerbose );
+ Abc_NtkDelete( pNtkTemp );
+ }
+ else
+ pNtkRes = Abc_NtkPlayer( pNtk, nLutMax, nPlaMax, RankCost, fFastMode, fRewriting, fSynthesis, fVerbose );
+*/
+ pNtkRes = NULL;
if ( pNtkRes == NULL )
{
fprintf( pErr, "Command has failed.\n" );
@@ -5537,10 +5549,10 @@ int Abc_CommandIFraig( Abc_Frame_t * pAbc, int argc, char ** argv )
{
FILE * pOut, * pErr;
Abc_Ntk_t * pNtk, * pNtkRes;
- int c, fUpdateLevel, fVerbose;
+ int c, fProve, fVerbose;
int nConfLimit;
- extern Abc_Ntk_t * Abc_NtkIvyFraig( Abc_Ntk_t * pNtk, int nConfLimit, int fVerbose );
+ extern Abc_Ntk_t * Abc_NtkIvyFraig( Abc_Ntk_t * pNtk, int nConfLimit, int fProve, int fVerbose );
pNtk = Abc_FrameReadNtk(pAbc);
pOut = Abc_FrameReadOut(pAbc);
@@ -5548,10 +5560,10 @@ int Abc_CommandIFraig( Abc_Frame_t * pAbc, int argc, char ** argv )
// set defaults
nConfLimit = 100;
- fUpdateLevel = 1;
+ fProve = 0;
fVerbose = 0;
Extra_UtilGetoptReset();
- while ( ( c = Extra_UtilGetopt( argc, argv, "Clzvh" ) ) != EOF )
+ while ( ( c = Extra_UtilGetopt( argc, argv, "Cpvh" ) ) != EOF )
{
switch ( c )
{
@@ -5566,8 +5578,8 @@ int Abc_CommandIFraig( Abc_Frame_t * pAbc, int argc, char ** argv )
if ( nConfLimit < 0 )
goto usage;
break;
- case 'l':
- fUpdateLevel ^= 1;
+ case 'p':
+ fProve ^= 1;
break;
case 'v':
fVerbose ^= 1;
@@ -5589,7 +5601,7 @@ int Abc_CommandIFraig( Abc_Frame_t * pAbc, int argc, char ** argv )
return 1;
}
- pNtkRes = Abc_NtkIvyFraig( pNtk, nConfLimit, fVerbose );
+ pNtkRes = Abc_NtkIvyFraig( pNtk, nConfLimit, fProve, fVerbose );
if ( pNtkRes == NULL )
{
fprintf( pErr, "Command has failed.\n" );
@@ -5600,10 +5612,10 @@ int Abc_CommandIFraig( Abc_Frame_t * pAbc, int argc, char ** argv )
return 0;
usage:
- fprintf( pErr, "usage: ifraig [-C num] [-vh]\n" );
+ fprintf( pErr, "usage: ifraig [-C num] [-pvh]\n" );
fprintf( pErr, "\t performs fraiging using a new method\n" );
- fprintf( pErr, "\t-C num : limit on the number of conflicts [default = %d]\n", nConfLimit );
-// fprintf( pErr, "\t-l : toggle preserving the number of levels [default = %s]\n", fUpdateLevel? "yes": "no" );
+ fprintf( pErr, "\t-C num : limit on the number of conflicts [default = %d]\n", nConfLimit );
+ fprintf( pErr, "\t-p : toggle proving miter outputs [default = %s]\n", fProve? "yes": "no" );
fprintf( pErr, "\t-v : toggle verbose printout [default = %s]\n", fVerbose? "yes": "no" );
fprintf( pErr, "\t-h : print the command usage\n");
return 1;
@@ -5622,29 +5634,31 @@ usage:
***********************************************************************/
int Abc_CommandIProve( Abc_Frame_t * pAbc, int argc, char ** argv )
{
+ Prove_Params_t Params, * pParams = &Params;
FILE * pOut, * pErr;
- Abc_Ntk_t * pNtk, * pNtkRes;
- int c, fUpdateLevel, fVerbose;
+ Abc_Ntk_t * pNtk, * pNtkTemp;
+ int c, clk, RetValue;
- extern Abc_Ntk_t * Abc_NtkIvyProve( Abc_Ntk_t * pNtk );
+ extern int Abc_NtkIvyProve( Abc_Ntk_t ** ppNtk, void * pPars );
pNtk = Abc_FrameReadNtk(pAbc);
pOut = Abc_FrameReadOut(pAbc);
pErr = Abc_FrameReadErr(pAbc);
// set defaults
- fUpdateLevel = 1;
- fVerbose = 0;
+ Prove_ParamsSetDefault( pParams );
+ pParams->fUseRewriting = 1;
+ pParams->fVerbose = 0;
Extra_UtilGetoptReset();
- while ( ( c = Extra_UtilGetopt( argc, argv, "lzvh" ) ) != EOF )
+ while ( ( c = Extra_UtilGetopt( argc, argv, "rvh" ) ) != EOF )
{
switch ( c )
{
- case 'l':
- fUpdateLevel ^= 1;
+ case 'r':
+ pParams->fUseRewriting ^= 1;
break;
case 'v':
- fVerbose ^= 1;
+ pParams->fVerbose ^= 1;
break;
case 'h':
goto usage;
@@ -5663,21 +5677,43 @@ int Abc_CommandIProve( Abc_Frame_t * pAbc, int argc, char ** argv )
return 1;
}
- pNtkRes = Abc_NtkIvyProve( pNtk );
- if ( pNtkRes == NULL )
+
+ clk = clock();
+
+ if ( Abc_NtkIsStrash(pNtk) )
+ pNtkTemp = Abc_NtkDup( pNtk );
+ else
+ pNtkTemp = Abc_NtkStrash( pNtk, 0, 0 );
+
+ RetValue = Abc_NtkIvyProve( &pNtkTemp, pParams );
+
+ // verify that the pattern is correct
+ if ( RetValue == 0 )
{
- fprintf( pErr, "Command has failed.\n" );
- return 0;
+ int * pSimInfo = Abc_NtkVerifySimulatePattern( pNtk, pNtkTemp->pModel );
+ if ( pSimInfo[0] != 1 )
+ printf( "ERROR in Abc_NtkMiterProve(): Generated counter-example is invalid.\n" );
+ free( pSimInfo );
}
+
+ if ( RetValue == -1 )
+ printf( "UNDECIDED " );
+ else if ( RetValue == 0 )
+ printf( "SATISFIABLE " );
+ else
+ printf( "UNSATISFIABLE " );
+ //printf( "\n" );
+
+ PRT( "Time", clock() - clk );
// replace the current network
- Abc_FrameReplaceCurrentNetwork( pAbc, pNtkRes );
+ Abc_FrameReplaceCurrentNetwork( pAbc, pNtkTemp );
return 0;
usage:
- fprintf( pErr, "usage: iprove [-h]\n" );
+ fprintf( pErr, "usage: iprove [-rvh]\n" );
fprintf( pErr, "\t performs CEC using a new method\n" );
-// fprintf( pErr, "\t-l : toggle preserving the number of levels [default = %s]\n", fUpdateLevel? "yes": "no" );
-// fprintf( pErr, "\t-v : toggle verbose printout [default = %s]\n", fVerbose? "yes": "no" );
+ fprintf( pErr, "\t-r : toggle AIG rewriting [default = %s]\n", pParams->fUseRewriting? "yes": "no" );
+ fprintf( pErr, "\t-v : toggle verbose printout [default = %s]\n", pParams->fVerbose? "yes": "no" );
fprintf( pErr, "\t-h : print the command usage\n");
return 1;
}
@@ -6932,6 +6968,147 @@ usage:
SeeAlso []
***********************************************************************/
+int Abc_CommandFpgaFast( Abc_Frame_t * pAbc, int argc, char ** argv )
+{
+ char Buffer[100];
+ FILE * pOut, * pErr;
+ Abc_Ntk_t * pNtk, * pNtkRes;
+ int c;
+ int fRecovery;
+ int fVerbose;
+ int nLutSize;
+ float DelayTarget;
+
+ extern Abc_Ntk_t * Abc_NtkFpgaFast( Abc_Ntk_t * pNtk, int nLutSize, int fRecovery, int fVerbose );
+
+ pNtk = Abc_FrameReadNtk(pAbc);
+ pOut = Abc_FrameReadOut(pAbc);
+ pErr = Abc_FrameReadErr(pAbc);
+
+ // set defaults
+ fRecovery = 1;
+ fVerbose = 0;
+ DelayTarget =-1;
+ nLutSize = 8;
+ Extra_UtilGetoptReset();
+ while ( ( c = Extra_UtilGetopt( argc, argv, "avhDK" ) ) != EOF )
+ {
+ switch ( c )
+ {
+ case 'a':
+ fRecovery ^= 1;
+ break;
+ case 'v':
+ fVerbose ^= 1;
+ break;
+ case 'h':
+ goto usage;
+ case 'D':
+ if ( globalUtilOptind >= argc )
+ {
+ fprintf( pErr, "Command line switch \"-D\" should be followed by a floating point number.\n" );
+ goto usage;
+ }
+ DelayTarget = (float)atof(argv[globalUtilOptind]);
+ globalUtilOptind++;
+ if ( DelayTarget <= 0.0 )
+ goto usage;
+ break;
+ case 'K':
+ if ( globalUtilOptind >= argc )
+ {
+ fprintf( pErr, "Command line switch \"-K\" should be followed by a positive integer.\n" );
+ goto usage;
+ }
+ nLutSize = atoi(argv[globalUtilOptind]);
+ globalUtilOptind++;
+ if ( nLutSize < 0 )
+ goto usage;
+ break;
+ default:
+ goto usage;
+ }
+ }
+
+ if ( pNtk == NULL )
+ {
+ fprintf( pErr, "Empty network.\n" );
+ return 1;
+ }
+
+ if ( Abc_NtkIsSeq(pNtk) )
+ {
+ fprintf( pErr, "Cannot FPGA map a sequential AIG.\n" );
+ return 1;
+ }
+
+ if ( !Abc_NtkIsStrash(pNtk) )
+ {
+ // strash and balance the network
+ pNtk = Abc_NtkStrash( pNtk, 0, 0 );
+ if ( pNtk == NULL )
+ {
+ fprintf( pErr, "Strashing before FPGA mapping has failed.\n" );
+ return 1;
+ }
+ pNtk = Abc_NtkBalance( pNtkRes = pNtk, 0, 0, 1 );
+ Abc_NtkDelete( pNtkRes );
+ if ( pNtk == NULL )
+ {
+ fprintf( pErr, "Balancing before FPGA mapping has failed.\n" );
+ return 1;
+ }
+ fprintf( pOut, "The network was strashed and balanced before FPGA mapping.\n" );
+ // get the new network
+ pNtkRes = Abc_NtkFpgaFast( pNtk, nLutSize, fRecovery, fVerbose );
+ if ( pNtkRes == NULL )
+ {
+ Abc_NtkDelete( pNtk );
+ fprintf( pErr, "FPGA mapping has failed.\n" );
+ return 1;
+ }
+ Abc_NtkDelete( pNtk );
+ }
+ else
+ {
+ // get the new network
+ pNtkRes = Abc_NtkFpgaFast( pNtk, nLutSize, fRecovery, fVerbose );
+ if ( pNtkRes == NULL )
+ {
+ fprintf( pErr, "FPGA mapping has failed.\n" );
+ return 1;
+ }
+ }
+ // replace the current network
+ Abc_FrameReplaceCurrentNetwork( pAbc, pNtkRes );
+ return 0;
+
+usage:
+ if ( DelayTarget == -1 )
+ sprintf( Buffer, "not used" );
+ else
+ sprintf( Buffer, "%.2f", DelayTarget );
+ fprintf( pErr, "usage: ffpga [-K num] [-avh]\n" );
+ fprintf( pErr, "\t performs fast FPGA mapping of the current network\n" );
+ fprintf( pErr, "\t-a : toggles area recovery [default = %s]\n", fRecovery? "yes": "no" );
+// fprintf( pErr, "\t-D float : sets the required time for the mapping [default = %s]\n", Buffer );
+ fprintf( pErr, "\t-K num : the number of LUT inputs (2 < num < 32) [default = %d]\n", nLutSize );
+ fprintf( pErr, "\t-v : toggles verbose output [default = %s]\n", fVerbose? "yes": "no" );
+ fprintf( pErr, "\t-h : prints the command usage\n");
+ return 1;
+}
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
int Abc_CommandPga( Abc_Frame_t * pAbc, int argc, char ** argv )
{
FILE * pOut, * pErr;
diff --git a/src/base/abci/abcDsd.c b/src/base/abci/abcDsd.c
index cd8f9047..6708217c 100644
--- a/src/base/abci/abcDsd.c
+++ b/src/base/abci/abcDsd.c
@@ -172,7 +172,7 @@ void Abc_NtkDsdConstruct( Dsd_Manager_t * pManDsd, Abc_Ntk_t * pNtk, Abc_Ntk_t *
int i, nNodesDsd;
// save the CI nodes in the DSD nodes
- Dsd_NodeSetMark( Dsd_ManagerReadConst1(pManDsd), (int)Abc_AigConst1(pNtkNew) );
+ Dsd_NodeSetMark( Dsd_ManagerReadConst1(pManDsd), (int)Abc_NodeCreateConst1(pNtkNew) );
Abc_NtkForEachCi( pNtk, pNode, i )
{
pNodeDsd = Dsd_ManagerReadInput( pManDsd, i );
diff --git a/src/base/abci/abcExtract.c b/src/base/abci/abcExtract.c
new file mode 100644
index 00000000..52ea03a3
--- /dev/null
+++ b/src/base/abci/abcExtract.c
@@ -0,0 +1,51 @@
+/**CFile****************************************************************
+
+ FileName [abcMvCost.c]
+
+ SystemName [ABC: Logic synthesis and verification system.]
+
+ PackageName [Network and node package.]
+
+ Synopsis [Calculating the cost of one MV block.]
+
+ Author [Alan Mishchenko]
+
+ Affiliation [UC Berkeley]
+
+ Date [Ver. 1.0. Started - June 20, 2005.]
+
+ Revision [$Id: abcMvCost.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "abc.h"
+
+////////////////////////////////////////////////////////////////////////
+/// DECLARATIONS ///
+////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+/// FUNCTION DEFINITIONS ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+ Synopsis []
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Abc_MvCostTest( Abc_Ntk_t * pNtk )
+{
+
+}
+
+////////////////////////////////////////////////////////////////////////
+/// END OF FILE ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/base/abci/abcFpgaFast.c b/src/base/abci/abcFpgaFast.c
index 2d5813c7..b307273f 100644
--- a/src/base/abci/abcFpgaFast.c
+++ b/src/base/abci/abcFpgaFast.c
@@ -19,11 +19,20 @@
***********************************************************************/
#include "abc.h"
+#include "ivy.h"
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
+extern Ivy_Man_t * Abc_NtkIvyBefore( Abc_Ntk_t * pNtk, int fSeq, int fUseDc );
+
+static Abc_Ntk_t * Ivy_ManFpgaToAbc( Abc_Ntk_t * pNtk, Ivy_Man_t * pMan );
+static Abc_Obj_t * Ivy_ManToAbcFast_rec( Abc_Ntk_t * pNtkNew, Ivy_Man_t * pMan, Ivy_Obj_t * pObjIvy, Vec_Int_t * vNodes );
+
+static inline void Abc_ObjSetIvy2Abc( Ivy_Man_t * p, int IvyId, Abc_Obj_t * pObjAbc ) { assert(Vec_PtrEntry(p->pCopy, IvyId) == NULL); assert(!Abc_ObjIsComplement(pObjAbc)); Vec_PtrWriteEntry( p->pCopy, IvyId, pObjAbc ); }
+static inline Abc_Obj_t * Abc_ObjGetIvy2Abc( Ivy_Man_t * p, int IvyId ) { return Vec_PtrEntry( p->pCopy, IvyId ); }
+
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
@@ -43,25 +52,20 @@
SeeAlso []
***********************************************************************/
-Abc_Ntk_t * Abc_NtkFpgaFast( Abc_Ntk_t * pNtk, int nLutSize, int fVerbose )
+Abc_Ntk_t * Abc_NtkFpgaFast( Abc_Ntk_t * pNtk, int nLutSize, int fRecovery, int fVerbose )
{
+ Ivy_Man_t * pMan;
Abc_Ntk_t * pNtkNew;
- Abc_Obj_t * pObj;
- int i;
-
// make sure the network is an AIG
assert( Abc_NtkIsStrash(pNtk) );
-
- // iterate over the nodes in the network
- Abc_NtkForEachNode( pNtk, pObj, i )
- {
- }
-
- // create the new network after mapping
- pNtkNew = Abc_NtkStartFrom( pNtk, ABC_NTK_LOGIC, ABC_FUNC_BDD );
-
- // here we need to create nodes of the new network
-
+ // convert the network into the AIG
+ pMan = Abc_NtkIvyBefore( pNtk, 0, 0 );
+ // perform fast FPGA mapping
+ Ivy_FastMapPerform( pMan, nLutSize, fRecovery, fVerbose );
+ // convert back into the ABC network
+ pNtkNew = Ivy_ManFpgaToAbc( pNtk, pMan );
+ Ivy_FastMapStop( pMan );
+ Ivy_ManStop( pMan );
// make sure that the final network passes the test
if ( pNtkNew != NULL && !Abc_NtkCheck( pNtkNew ) )
{
@@ -72,6 +76,113 @@ Abc_Ntk_t * Abc_NtkFpgaFast( Abc_Ntk_t * pNtk, int nLutSize, int fVerbose )
return pNtkNew;
}
+/**Function*************************************************************
+
+ Synopsis [Constructs the ABC network after mapping.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+Abc_Ntk_t * Ivy_ManFpgaToAbc( Abc_Ntk_t * pNtk, Ivy_Man_t * pMan )
+{
+ Abc_Ntk_t * pNtkNew;
+ Abc_Obj_t * pObjAbc, * pObj;
+ Ivy_Obj_t * pObjIvy;
+ Vec_Int_t * vNodes;
+ int i;
+ // start mapping from Ivy into Abc
+ pMan->pCopy = Vec_PtrStart( Ivy_ManObjIdMax(pMan) + 1 );
+ // start the new ABC network
+ pNtkNew = Abc_NtkStartFrom( pNtk, ABC_NTK_LOGIC, ABC_FUNC_AIG );
+ // transfer the pointers to the basic nodes
+ Abc_ObjSetIvy2Abc( pMan, Ivy_ManConst1(pMan)->Id, Abc_NodeCreateConst1(pNtkNew) );
+ Abc_NtkForEachCi( pNtkNew, pObjAbc, i )
+ Abc_ObjSetIvy2Abc( pMan, Ivy_ManPi(pMan, i)->Id, pObjAbc );
+ // recursively construct the network
+ vNodes = Vec_IntAlloc( 100 );
+ Ivy_ManForEachPo( pMan, pObjIvy, i )
+ {
+ // get the new ABC node corresponding to the old fanin of the PO in IVY
+ pObjAbc = Ivy_ManToAbcFast_rec( pNtkNew, pMan, Ivy_ObjFanin0(pObjIvy), vNodes );
+ // consider the case of complemented fanin of the PO
+ if ( Ivy_ObjFaninC0(pObjIvy) ) // complement
+ {
+ if ( Abc_ObjIsCi(pObjAbc) )
+ pObjAbc = Abc_NodeCreateInv( pNtkNew, pObjAbc );
+ else
+ {
+ // clone the node
+ pObj = Abc_NtkCloneObj( pObjAbc );
+ // set complemented functions
+ pObj->pData = Aig_Not( pObjAbc->pData );
+ // return the new node
+ pObjAbc = pObj;
+ }
+ }
+ Abc_ObjAddFanin( Abc_NtkCo(pNtkNew, i), pObjAbc );
+ }
+ Vec_IntFree( vNodes );
+ Vec_PtrFree( pMan->pCopy );
+ pMan->pCopy = NULL;
+ // remove dangling nodes
+ Abc_NtkCleanup( pNtkNew, 0 );
+ // fix CIs feeding directly into COs
+ Abc_NtkLogicMakeSimpleCos( pNtkNew, 0 );
+ return pNtkNew;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Recursively construct the new node.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+Abc_Obj_t * Ivy_ManToAbcFast_rec( Abc_Ntk_t * pNtkNew, Ivy_Man_t * pMan, Ivy_Obj_t * pObjIvy, Vec_Int_t * vNodes )
+{
+ Vec_Int_t Supp, * vSupp = &Supp;
+ Abc_Obj_t * pObjAbc, * pFaninAbc;
+ Ivy_Obj_t * pNodeIvy;
+ int i, Entry;
+ // skip the node if it is a constant or already processed
+ pObjAbc = Abc_ObjGetIvy2Abc( pMan, pObjIvy->Id );
+ if ( pObjAbc )
+ return pObjAbc;
+ assert( Ivy_ObjIsAnd(pObjIvy) || Ivy_ObjIsExor(pObjIvy) );
+ // get the support of K-LUT
+ Ivy_FastMapReadSupp( pMan, pObjIvy, vSupp );
+ // create new ABC node and its fanins
+ pObjAbc = Abc_NtkCreateNode( pNtkNew );
+ Vec_IntForEachEntry( vSupp, Entry, i )
+ {
+ pFaninAbc = Ivy_ManToAbcFast_rec( pNtkNew, pMan, Ivy_ManObj(pMan, Entry), vNodes );
+ Abc_ObjAddFanin( pObjAbc, pFaninAbc );
+ }
+ // collect the nodes used in the cut
+ Ivy_ManCollectCut( pMan, pObjIvy, vSupp, vNodes );
+ // create the local function
+ Ivy_ManForEachNodeVec( pMan, vNodes, pNodeIvy, i )
+ {
+ if ( i < Vec_IntSize(vSupp) )
+ pNodeIvy->pEquiv = (Ivy_Obj_t *)Aig_IthVar( pNtkNew->pManFunc, i );
+ else
+ pNodeIvy->pEquiv = (Ivy_Obj_t *)Aig_And( pNtkNew->pManFunc, (Aig_Obj_t *)Ivy_ObjChild0Equiv(pNodeIvy), (Aig_Obj_t *)Ivy_ObjChild1Equiv(pNodeIvy) );
+ }
+ // set the local function
+ pObjAbc->pData = (Abc_Obj_t *)pObjIvy->pEquiv;
+ // set the node
+ Abc_ObjSetIvy2Abc( pMan, pObjIvy->Id, pObjAbc );
+ return pObjAbc;
+}
+
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
diff --git a/src/base/abci/abcIvy.c b/src/base/abci/abcIvy.c
index 320c76dd..82e03119 100644
--- a/src/base/abci/abcIvy.c
+++ b/src/base/abci/abcIvy.c
@@ -21,6 +21,7 @@
#include "abc.h"
#include "dec.h"
#include "ivy.h"
+#include "fraig.h"
////////////////////////////////////////////////////////////////////////
/// DECLARATIONS ///
@@ -81,7 +82,7 @@ Ivy_Man_t * Abc_NtkIvyBefore( Abc_Ntk_t * pNtk, int fSeq, int fUseDc )
return NULL;
}
}
- if ( Abc_NtkCountSelfFeedLatches(pNtk) )
+ if ( fSeq && Abc_NtkCountSelfFeedLatches(pNtk) )
{
printf( "Warning: The network has %d self-feeding latches. Quitting.\n", Abc_NtkCountSelfFeedLatches(pNtk) );
return NULL;
@@ -368,7 +369,7 @@ Abc_Ntk_t * Abc_NtkIvySat( Abc_Ntk_t * pNtk, int nConfLimit, int fVerbose )
SeeAlso []
***********************************************************************/
-Abc_Ntk_t * Abc_NtkIvyFraig( Abc_Ntk_t * pNtk, int nConfLimit, int fVerbose )
+Abc_Ntk_t * Abc_NtkIvyFraig( Abc_Ntk_t * pNtk, int nConfLimit, int fProve, int fVerbose )
{
Ivy_FraigParams_t Params, * pParams = &Params;
Abc_Ntk_t * pNtkAig;
@@ -379,6 +380,7 @@ Abc_Ntk_t * Abc_NtkIvyFraig( Abc_Ntk_t * pNtk, int nConfLimit, int fVerbose )
Ivy_FraigParamsDefault( pParams );
pParams->nBTLimitNode = nConfLimit;
pParams->fVerbose = fVerbose;
+ pParams->fProve = fProve;
pMan = Ivy_FraigPerform( pTemp = pMan, pParams );
Ivy_ManStop( pTemp );
pNtkAig = Abc_NtkIvyAfter( pNtk, pMan, 0, 0 );
@@ -394,23 +396,76 @@ Abc_Ntk_t * Abc_NtkIvyFraig( Abc_Ntk_t * pNtk, int nConfLimit, int fVerbose )
SideEffects []
- SeeAlso []
+ SeeAlso []
***********************************************************************/
-Abc_Ntk_t * Abc_NtkIvyProve( Abc_Ntk_t * pNtk )
+int Abc_NtkIvyProve( Abc_Ntk_t ** ppNtk, void * pPars )
{
- Ivy_FraigParams_t Params, * pParams = &Params;
- Abc_Ntk_t * pNtkAig;
- Ivy_Man_t * pMan, * pTemp;
+ Prove_Params_t * pParams = pPars;
+ Abc_Ntk_t * pNtk = *ppNtk, * pNtkTemp;
+ Ivy_Man_t * pMan;
+ int RetValue;
+ assert( Abc_NtkIsStrash(pNtk) || Abc_NtkIsLogic(pNtk) );
+ // experiment with various parameters settings
+// pParams->fUseBdds = 1;
+// pParams->fBddReorder = 1;
+// pParams->nTotalBacktrackLimit = 10000;
+
+ // strash the network if it is not strashed already
+ if ( !Abc_NtkIsStrash(pNtk) )
+ {
+ pNtk = Abc_NtkStrash( pNtkTemp = pNtk, 0, 1 );
+ Abc_NtkDelete( pNtkTemp );
+ }
+
+ // if SAT only, solve without iteration
+ RetValue = Abc_NtkMiterSat( pNtk, 2*(sint64)pParams->nMiteringLimitStart, (sint64)0, 0, 0, NULL, NULL );
+ if ( RetValue >= 0 )
+ return RetValue;
+
+ // apply AIG rewriting
+ if ( pParams->fUseRewriting && Abc_NtkNodeNum(pNtk) > 500 )
+ {
+ pParams->fUseRewriting = 0;
+ Abc_NtkRewrite( pNtk, 0, 0, 0 );
+ pNtk = Abc_NtkBalance( pNtkTemp = pNtk, 0, 0, 0 );
+ Abc_NtkDelete( pNtkTemp );
+ Abc_NtkRewrite( pNtk, 0, 0, 0 );
+ Abc_NtkRefactor( pNtk, 10, 16, 0, 0, 0, 0 );
+ }
+
+ // convert ABC network into IVY network
pMan = Abc_NtkIvyBefore( pNtk, 0, 0 );
- if ( pMan == NULL )
- return NULL;
- Ivy_FraigParamsDefault( pParams );
- pMan = Ivy_FraigProve( pTemp = pMan, pParams );
- Ivy_ManStop( pTemp );
- pNtkAig = Abc_NtkIvyAfter( pNtk, pMan, 0, 0 );
+ // solve the CEC problem
+ RetValue = Ivy_FraigProve( &pMan, pParams );
+ // convert IVY network into ABC network
+ pNtk = Abc_NtkIvyAfter( pNtkTemp = pNtk, pMan, 0, 0 );
+ Abc_NtkDelete( pNtkTemp );
+ // transfer model if given
+ pNtk->pModel = pMan->pData; pMan->pData = NULL;
Ivy_ManStop( pMan );
- return pNtkAig;
+
+ // try to prove it using brute force SAT
+ if ( RetValue < 0 && pParams->fUseBdds )
+ {
+ if ( pParams->fVerbose )
+ {
+ printf( "Attempting BDDs with node limit %d ...\n", pParams->nBddSizeLimit );
+ fflush( stdout );
+ }
+ pNtk = Abc_NtkCollapse( pNtkTemp = pNtk, pParams->nBddSizeLimit, 0, pParams->fBddReorder, 0 );
+ if ( pNtk )
+ {
+ Abc_NtkDelete( pNtkTemp );
+ RetValue = ( (Abc_NtkNodeNum(pNtk) == 1) && (Abc_ObjFanin0(Abc_NtkPo(pNtk,0))->pData == Cudd_ReadLogicZero(pNtk->pManFunc)) );
+ }
+ else
+ pNtk = pNtkTemp;
+ }
+
+ // return the result
+ *ppNtk = pNtk;
+ return RetValue;
}
/**Function*************************************************************
diff --git a/src/base/abci/abcMini.c b/src/base/abci/abcMini.c
index 037f058a..014eafd3 100644
--- a/src/base/abci/abcMini.c
+++ b/src/base/abci/abcMini.c
@@ -59,6 +59,7 @@ Abc_Ntk_t * Abc_NtkMiniBalance( Abc_Ntk_t * pNtk )
}
// perform balance
Aig_ManPrintStats( pMan );
+// Aig_ManDumpBlif( pMan, "aig_temp.blif" );
pMan = Aig_ManBalance( pTemp = pMan, 1 );
Aig_ManStop( pTemp );
Aig_ManPrintStats( pMan );
diff --git a/src/base/abci/abcNtbdd.c b/src/base/abci/abcNtbdd.c
index 9a88db99..9b67ab13 100644
--- a/src/base/abci/abcNtbdd.c
+++ b/src/base/abci/abcNtbdd.c
@@ -189,7 +189,6 @@ Abc_Obj_t * Abc_NodeBddToMuxes( Abc_Obj_t * pNodeOld, Abc_Ntk_t * pNtkNew )
// create the table mapping BDD nodes into the ABC nodes
tBdd2Node = st_init_table( st_ptrcmp, st_ptrhash );
// add the constant and the elementary vars
- st_insert( tBdd2Node, (char *)b1, (char *)Abc_AigConst1(pNtkNew) );
Abc_ObjForEachFanin( pNodeOld, pFaninOld, i )
st_insert( tBdd2Node, (char *)Cudd_bddIthVar(dd, i), (char *)pFaninOld->pCopy );
// create the new nodes recursively
@@ -215,6 +214,8 @@ Abc_Obj_t * Abc_NodeBddToMuxes_rec( DdManager * dd, DdNode * bFunc, Abc_Ntk_t *
{
Abc_Obj_t * pNodeNew, * pNodeNew0, * pNodeNew1, * pNodeNewC;
assert( !Cudd_IsComplement(bFunc) );
+ if ( bFunc == b1 )
+ return Abc_NodeCreateConst1(pNtkNew);
if ( st_lookup( tBdd2Node, (char *)bFunc, (char **)&pNodeNew ) )
return pNodeNew;
// solve for the children nodes
diff --git a/src/base/abci/abcPrint.c b/src/base/abci/abcPrint.c
index c7e2acc0..afc635e9 100644
--- a/src/base/abci/abcPrint.c
+++ b/src/base/abci/abcPrint.c
@@ -144,7 +144,7 @@ void Abc_NtkPrintStats( FILE * pFile, Abc_Ntk_t * pNtk, int fFactored )
}
*/
-
+/*
// print the statistic into a file
{
FILE * pTable;
@@ -157,7 +157,7 @@ void Abc_NtkPrintStats( FILE * pFile, Abc_Ntk_t * pNtk, int fFactored )
fprintf( pTable, "\n" );
fclose( pTable );
}
-
+*/
/*
// print the statistic into a file
diff --git a/src/base/abci/abcProve.c b/src/base/abci/abcProve.c
index f3c1a825..c9e5bfd7 100644
--- a/src/base/abci/abcProve.c
+++ b/src/base/abci/abcProve.c
@@ -314,6 +314,29 @@ void Abc_NtkMiterPrint( Abc_Ntk_t * pNtk, char * pString, int clk, int fVerbose
PRT( pString, clock() - clk );
}
+
+/**Function*************************************************************
+
+ Synopsis [Implements resynthesis for CEC.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+Abc_Ntk_t * Abc_NtkMiterRwsat( Abc_Ntk_t * pNtk )
+{
+ Abc_Ntk_t * pNtkTemp;
+ Abc_NtkRewrite( pNtk, 0, 0, 0 );
+ pNtk = Abc_NtkBalance( pNtkTemp = pNtk, 0, 0, 0 ); Abc_NtkDelete( pNtkTemp );
+ Abc_NtkRewrite( pNtk, 0, 0, 0 );
+ Abc_NtkRefactor( pNtk, 10, 16, 0, 0, 0, 0 );
+ return pNtk;
+}
+
+
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
diff --git a/src/base/abci/abcSat.c b/src/base/abci/abcSat.c
index 3e0d6ba0..8d5dd2a7 100644
--- a/src/base/abci/abcSat.c
+++ b/src/base/abci/abcSat.c
@@ -56,8 +56,8 @@ int Abc_NtkMiterSat( Abc_Ntk_t * pNtk, sint64 nConfLimit, sint64 nInsLimit, int
assert( Abc_NtkIsStrash(pNtk) );
assert( Abc_NtkLatchNum(pNtk) == 0 );
- if ( Abc_NtkPoNum(pNtk) > 1 )
- fprintf( stdout, "Warning: The miter has %d outputs. SAT will try to prove all of them.\n", Abc_NtkPoNum(pNtk) );
+// if ( Abc_NtkPoNum(pNtk) > 1 )
+// fprintf( stdout, "Warning: The miter has %d outputs. SAT will try to prove all of them.\n", Abc_NtkPoNum(pNtk) );
// load clauses into the solver
clk = clock();
@@ -180,6 +180,29 @@ int Abc_NtkClauseTriv( solver * pSat, Abc_Obj_t * pNode, Vec_Int_t * vVars )
SeeAlso []
***********************************************************************/
+int Abc_NtkClauseTop( solver * pSat, Vec_Ptr_t * vNodes, Vec_Int_t * vVars )
+{
+ Abc_Obj_t * pNode;
+ int i;
+//printf( "Adding triv %d. %d\n", Abc_ObjRegular(pNode)->Id, (int)pSat->solver_stats.clauses );
+ vVars->nSize = 0;
+ Vec_PtrForEachEntry( vNodes, pNode, i )
+ Vec_IntPush( vVars, toLitCond( (int)Abc_ObjRegular(pNode)->pCopy, Abc_ObjIsComplement(pNode) ) );
+// Vec_IntPush( vVars, toLitCond( (int)Abc_ObjRegular(pNode)->Id, Abc_ObjIsComplement(pNode) ) );
+ return solver_addclause( pSat, vVars->pArray, vVars->pArray + vVars->nSize );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Adds trivial clause.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
int Abc_NtkClauseAnd( solver * pSat, Abc_Obj_t * pNode, Vec_Ptr_t * vSuper, Vec_Int_t * vVars )
{
int fComp1, Var, Var1, i;
@@ -467,8 +490,8 @@ int Abc_NtkMiterSatCreateInt( solver * pSat, Abc_Ntk_t * pNtk, int fJFront )
Vec_PtrPush( vNodes, pNode );
}
*/
-
// collect the nodes that need clauses and top-level assignments
+ Vec_PtrClear( vSuper );
Abc_NtkForEachCo( pNtk, pNode, i )
{
// get the fanin
@@ -481,9 +504,11 @@ int Abc_NtkMiterSatCreateInt( solver * pSat, Abc_Ntk_t * pNtk, int fJFront )
Vec_PtrPush( vNodes, pFanin );
}
// add the trivial clause
- if ( !Abc_NtkClauseTriv( pSat, Abc_ObjChild0(pNode), vVars ) )
- goto Quits;
+ Vec_PtrPush( vSuper, Abc_ObjChild0(pNode) );
}
+ if ( !Abc_NtkClauseTop( pSat, vSuper, vVars ) )
+ goto Quits;
+
// add the clauses
Vec_PtrForEachEntry( vNodes, pNode, i )
diff --git a/src/base/abci/abcVerify.c b/src/base/abci/abcVerify.c
index 1fddc8cb..622b4103 100644
--- a/src/base/abci/abcVerify.c
+++ b/src/base/abci/abcVerify.c
@@ -174,7 +174,8 @@ void Abc_NtkCecFraig( Abc_Ntk_t * pNtk1, Abc_Ntk_t * pNtk2, int nSeconds, int fV
// solve the CNF using the SAT solver
Prove_ParamsSetDefault( pParams );
pParams->nItersMax = 5;
- RetValue = Abc_NtkMiterProve( &pMiter, pParams );
+// RetValue = Abc_NtkMiterProve( &pMiter, pParams );
+ RetValue = Abc_NtkIvyProve( &pMiter, pParams );
if ( RetValue == -1 )
printf( "Networks are undecided (resource limits is reached).\n" );
else if ( RetValue == 0 )
@@ -399,12 +400,11 @@ int * Abc_NtkVerifyGetCleanModel( Abc_Ntk_t * pNtk, int nFrames )
SideEffects []
- SeeAlso []
+ SeeAlso []
***********************************************************************/
int * Abc_NtkVerifySimulatePattern( Abc_Ntk_t * pNtk, int * pModel )
{
- Vec_Ptr_t * vNodes;
Abc_Obj_t * pNode;
int * pValues, Value0, Value1, i;
int fStrashed = 0;
@@ -416,22 +416,16 @@ int * Abc_NtkVerifySimulatePattern( Abc_Ntk_t * pNtk, int * pModel )
// increment the trav ID
Abc_NtkIncrementTravId( pNtk );
// set the CI values
+ Abc_AigConst1(pNtk)->pCopy = (void *)1;
Abc_NtkForEachCi( pNtk, pNode, i )
pNode->pCopy = (void *)pModel[i];
// simulate in the topological order
- vNodes = Abc_NtkDfs( pNtk, 1 );
- Vec_PtrForEachEntry( vNodes, pNode, i )
+ Abc_NtkForEachNode( pNtk, pNode, i )
{
-// if ( Abc_NodeIsConst(pNode) )
-// pNode->pCopy = NULL;
-// else
- {
- Value0 = ((int)Abc_ObjFanin0(pNode)->pCopy) ^ Abc_ObjFaninC0(pNode);
- Value1 = ((int)Abc_ObjFanin1(pNode)->pCopy) ^ Abc_ObjFaninC1(pNode);
- pNode->pCopy = (void *)(Value0 & Value1);
- }
+ Value0 = ((int)Abc_ObjFanin0(pNode)->pCopy) ^ Abc_ObjFaninC0(pNode);
+ Value1 = ((int)Abc_ObjFanin1(pNode)->pCopy) ^ Abc_ObjFaninC1(pNode);
+ pNode->pCopy = (void *)(Value0 & Value1);
}
- Vec_PtrFree( vNodes );
// fill the output values
pValues = ALLOC( int, Abc_NtkCoNum(pNtk) );
Abc_NtkForEachCo( pNtk, pNode, i )
diff --git a/src/base/abci/module.make b/src/base/abci/module.make
index dba9e6fd..bb2ae1a0 100644
--- a/src/base/abci/module.make
+++ b/src/base/abci/module.make
@@ -7,12 +7,16 @@ SRC += src/base/abci/abc.c \
src/base/abci/abcCut.c \
src/base/abci/abcDsd.c \
src/base/abci/abcEspresso.c \
+ src/base/abci/abcExtract.c \
src/base/abci/abcFpga.c \
+ src/base/abci/abcFpgaFast.c \
src/base/abci/abcFraig.c \
src/base/abci/abcFxu.c \
src/base/abci/abcGen.c \
+ src/base/abci/abcIvy.c \
src/base/abci/abcLut.c \
src/base/abci/abcMap.c \
+ src/base/abci/abcMini.c \
src/base/abci/abcMiter.c \
src/base/abci/abcNtbdd.c \
src/base/abci/abcOrder.c \
diff --git a/src/base/io/io.c b/src/base/io/io.c
index 8b80103b..9c1b94ab 100644
--- a/src/base/io/io.c
+++ b/src/base/io/io.c
@@ -31,7 +31,7 @@ static int IoCommandReadBlif ( Abc_Frame_t * pAbc, int argc, char **argv );
static int IoCommandReadBench ( Abc_Frame_t * pAbc, int argc, char **argv );
static int IoCommandReadEdif ( Abc_Frame_t * pAbc, int argc, char **argv );
static int IoCommandReadEqn ( Abc_Frame_t * pAbc, int argc, char **argv );
-static int IoCommandReadVerilog ( Abc_Frame_t * pAbc, int argc, char **argv );
+//static int IoCommandReadVerilog ( Abc_Frame_t * pAbc, int argc, char **argv );
static int IoCommandReadVer ( Abc_Frame_t * pAbc, int argc, char **argv );
static int IoCommandReadVerLib ( Abc_Frame_t * pAbc, int argc, char **argv );
static int IoCommandReadPla ( Abc_Frame_t * pAbc, int argc, char **argv );
@@ -75,7 +75,7 @@ void Io_Init( Abc_Frame_t * pAbc )
Cmd_CommandAdd( pAbc, "I/O", "read_bench", IoCommandReadBench, 1 );
Cmd_CommandAdd( pAbc, "I/O", "read_edif", IoCommandReadEdif, 1 );
Cmd_CommandAdd( pAbc, "I/O", "read_eqn", IoCommandReadEqn, 1 );
- Cmd_CommandAdd( pAbc, "I/O", "read_verilog", IoCommandReadVerilog, 1 );
+// Cmd_CommandAdd( pAbc, "I/O", "read_verilog", IoCommandReadVerilog, 1 );
Cmd_CommandAdd( pAbc, "I/O", "read_ver", IoCommandReadVer, 1 );
Cmd_CommandAdd( pAbc, "I/O", "read_verlib", IoCommandReadVerLib, 0 );
Cmd_CommandAdd( pAbc, "I/O", "read_pla", IoCommandReadPla, 1 );
@@ -1622,20 +1622,27 @@ int IoCommandWriteVerilog( Abc_Frame_t * pAbc, int argc, char **argv )
// get the input file name
FileName = argv[globalUtilOptind];
+ if ( Abc_NtkLatchNum(pNtk) > 0 )
+ {
+ fprintf( pAbc->Out, "Currently cannot write verilog for sequential networks.\n" );
+ return 0;
+ }
+
// derive the netlist
pNtkTemp = Abc_NtkLogicToNetlist(pNtk,0);
+ Abc_NtkSopToAig( pNtkTemp );
if ( pNtkTemp == NULL )
{
fprintf( pAbc->Out, "Writing PLA has failed.\n" );
return 0;
}
- Io_WriteVerilog( pNtkTemp, FileName, 0 );
+ Io_WriteVerilog( pNtkTemp, FileName, 1 );
Abc_NtkDelete( pNtkTemp );
return 0;
usage:
fprintf( pAbc->Err, "usage: write_verilog [-h] <file>\n" );
- fprintf( pAbc->Err, "\t write a very special subset of Verilog\n" );
+ fprintf( pAbc->Err, "\t write the current network in Verilog format\n" );
fprintf( pAbc->Err, "\t-h : print the help massage\n" );
fprintf( pAbc->Err, "\tfile : the name of the file to write\n" );
return 1;
diff --git a/src/base/io/ioWriteVer.c b/src/base/io/ioWriteVer.c
index 64438b05..381e6e28 100644
--- a/src/base/io/ioWriteVer.c
+++ b/src/base/io/ioWriteVer.c
@@ -57,7 +57,12 @@ static int Io_WriteVerilogWiresCount( Abc_Ntk_t * pNtk );
void Io_WriteVerilog( Abc_Ntk_t * pNtk, char * pFileName, int fVerLibStyle )
{
FILE * pFile;
-
+ if ( !Abc_NtkIsAigNetlist(pNtk) )
+ {
+ printf( "Io_WriteVerilog(): Can produce Verilog for AIG netlists only.\n" );
+ return;
+ }
+/*
if ( !(Abc_NtkIsNetlist(pNtk) && (Abc_NtkHasMapping(pNtk) || Io_WriteVerilogCheckNtk(pNtk))) )
{
printf( "Io_WriteVerilog(): Can produce Verilog for a subset of logic networks.\n" );
@@ -65,7 +70,7 @@ void Io_WriteVerilog( Abc_Ntk_t * pNtk, char * pFileName, int fVerLibStyle )
printf( "The current network is not in the subset; the output files is not written.\n" );
return;
}
-
+*/
// start the output stream
pFile = fopen( pFileName, "w" );
if ( pFile == NULL )
@@ -139,13 +144,15 @@ void Io_WriteVerilogLibrary( Abc_Lib_t * pLibrary, char * pFileName )
void Io_WriteVerilogInt( FILE * pFile, Abc_Ntk_t * pNtk, int fVerLibStyle )
{
// write inputs and outputs
- fprintf( pFile, "module %s ( gclk,\n ", Abc_NtkName(pNtk) );
+// fprintf( pFile, "module %s ( gclk,\n ", Abc_NtkName(pNtk) );
+ fprintf( pFile, "module %s ( \n ", Abc_NtkName(pNtk) );
Io_WriteVerilogPis( pFile, pNtk, 3 );
fprintf( pFile, ",\n " );
Io_WriteVerilogPos( pFile, pNtk, 3 );
fprintf( pFile, " );\n" );
// write inputs, outputs, registers, and wires
- fprintf( pFile, " input gclk," );
+// fprintf( pFile, " input gclk," );
+ fprintf( pFile, " input " );
Io_WriteVerilogPis( pFile, pNtk, 10 );
fprintf( pFile, ";\n" );
fprintf( pFile, " output" );
@@ -201,7 +208,7 @@ void Io_WriteVerilogPis( FILE * pFile, Abc_Ntk_t * pNtk, int Start )
{
pNet = Abc_ObjFanout0(pTerm);
// get the line length after this name is written
- AddedLength = strlen(Abc_ObjName(pNet)) + 2;
+ AddedLength = strlen(Io_WriteVerilogGetName(pNet)) + 2;
if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
{ // write the line extender
fprintf( pFile, "\n " );
@@ -209,11 +216,11 @@ void Io_WriteVerilogPis( FILE * pFile, Abc_Ntk_t * pNtk, int Start )
LineLength = 3;
NameCounter = 0;
}
- fprintf( pFile, " %s%s", Abc_ObjName(pNet), (i==Abc_NtkPiNum(pNtk)-1)? "" : "," );
+ fprintf( pFile, " %s%s", Io_WriteVerilogGetName(pNet), (i==Abc_NtkPiNum(pNtk)-1)? "" : "," );
LineLength += AddedLength;
NameCounter++;
}
-}
+}
/**Function*************************************************************
@@ -240,7 +247,7 @@ void Io_WriteVerilogPos( FILE * pFile, Abc_Ntk_t * pNtk, int Start )
{
pNet = Abc_ObjFanin0(pTerm);
// get the line length after this name is written
- AddedLength = strlen(Abc_ObjName(pNet)) + 2;
+ AddedLength = strlen(Io_WriteVerilogGetName(pNet)) + 2;
if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
{ // write the line extender
fprintf( pFile, "\n " );
@@ -248,7 +255,7 @@ void Io_WriteVerilogPos( FILE * pFile, Abc_Ntk_t * pNtk, int Start )
LineLength = 3;
NameCounter = 0;
}
- fprintf( pFile, " %s%s", Abc_ObjName(pNet), (i==Abc_NtkPoNum(pNtk)-1)? "" : "," );
+ fprintf( pFile, " %s%s", Io_WriteVerilogGetName(pNet), (i==Abc_NtkPoNum(pNtk)-1)? "" : "," );
LineLength += AddedLength;
NameCounter++;
}
@@ -317,7 +324,7 @@ void Io_WriteVerilogWires( FILE * pFile, Abc_Ntk_t * pNtk, int Start )
continue;
Counter++;
// get the line length after this name is written
- AddedLength = strlen(Abc_ObjName(pNet)) + 2;
+ AddedLength = strlen(Io_WriteVerilogGetName(pNet)) + 2;
if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
{ // write the line extender
fprintf( pFile, "\n " );
@@ -334,7 +341,7 @@ void Io_WriteVerilogWires( FILE * pFile, Abc_Ntk_t * pNtk, int Start )
pNet = Abc_ObjFanin0(Abc_ObjFanin0(pTerm));
Counter++;
// get the line length after this name is written
- AddedLength = strlen(Abc_ObjName(pNet)) + 2;
+ AddedLength = strlen(Io_WriteVerilogGetName(pNet)) + 2;
if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
{ // write the line extender
fprintf( pFile, "\n " );
@@ -380,7 +387,7 @@ void Io_WriteVerilogRegs( FILE * pFile, Abc_Ntk_t * pNtk, int Start )
pNet = Abc_ObjFanout0(Abc_ObjFanout0(pLatch));
Counter++;
// get the line length after this name is written
- AddedLength = strlen(Abc_ObjName(pNet)) + 2;
+ AddedLength = strlen(Io_WriteVerilogGetName(pNet)) + 2;
if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH )
{ // write the line extender
fprintf( pFile, "\n " );
@@ -412,14 +419,14 @@ void Io_WriteVerilogLatches( FILE * pFile, Abc_Ntk_t * pNtk )
Abc_NtkForEachLatch( pNtk, pLatch, i )
{
// fprintf( pFile, " always@(posedge gclk) begin %s", Abc_ObjName(Abc_ObjFanout0(pLatch)) );
- fprintf( pFile, " always begin %s", Abc_ObjName(Abc_ObjFanout0(Abc_ObjFanout0(pLatch))) );
- fprintf( pFile, " = %s; end\n", Abc_ObjName(Abc_ObjFanin0(Abc_ObjFanin0(pLatch))) );
+ fprintf( pFile, " always begin %s", Io_WriteVerilogGetName(Abc_ObjFanout0(Abc_ObjFanout0(pLatch))) );
+ fprintf( pFile, " = %s; end\n", Io_WriteVerilogGetName(Abc_ObjFanin0(Abc_ObjFanin0(pLatch))) );
if ( Abc_LatchInit(pLatch) == ABC_INIT_ZERO )
-// fprintf( pFile, " initial begin %s = 1\'b0; end\n", Abc_ObjName(Abc_ObjFanout0(pLatch)) );
- fprintf( pFile, " initial begin %s = 0; end\n", Abc_ObjName(Abc_ObjFanout0(Abc_ObjFanout0(pLatch))) );
+// fprintf( pFile, " initial begin %s = 1\'b0; end\n", Io_WriteVerilogGetName(Abc_ObjFanout0(pLatch)) );
+ fprintf( pFile, " initial begin %s = 0; end\n", Io_WriteVerilogGetName(Abc_ObjFanout0(Abc_ObjFanout0(pLatch))) );
else if ( Abc_LatchInit(pLatch) == ABC_INIT_ONE )
-// fprintf( pFile, " initial begin %s = 1\'b1; end\n", Abc_ObjName(Abc_ObjFanout0(pLatch)) );
- fprintf( pFile, " initial begin %s = 1; end\n", Abc_ObjName(Abc_ObjFanout0(Abc_ObjFanout0(pLatch))) );
+// fprintf( pFile, " initial begin %s = 1\'b1; end\n", Io_WriteVerilogGetName(Abc_ObjFanout0(pLatch)) );
+ fprintf( pFile, " initial begin %s = 1; end\n", Io_WriteVerilogGetName(Abc_ObjFanout0(Abc_ObjFanout0(pLatch))) );
}
}
@@ -431,11 +438,11 @@ void Io_WriteVerilogLatches( FILE * pFile, Abc_Ntk_t * pNtk )
Abc_NtkForEachLatch( pNtk, pLatch, i )
{
if ( Abc_LatchInit(pLatch) == ABC_INIT_ZERO )
- fprintf( pFile, " initial begin %s <= 1\'b0; end\n", Abc_ObjName(Abc_ObjFanout0(Abc_ObjFanout0(pLatch))) );
+ fprintf( pFile, " initial begin %s <= 1\'b0; end\n", Io_WriteVerilogGetName(Abc_ObjFanout0(Abc_ObjFanout0(pLatch))) );
else if ( Abc_LatchInit(pLatch) == ABC_INIT_ONE )
- fprintf( pFile, " initial begin %s <= 1\'b1; end\n", Abc_ObjName(Abc_ObjFanout0(Abc_ObjFanout0(pLatch))) );
- fprintf( pFile, " always@(posedge gclk) begin %s", Abc_ObjName(Abc_ObjFanout0(Abc_ObjFanout0(pLatch))) );
- fprintf( pFile, " <= %s; end\n", Abc_ObjName(Abc_ObjFanin0(Abc_ObjFanin0(pLatch))) );
+ fprintf( pFile, " initial begin %s <= 1\'b1; end\n", Io_WriteVerilogGetName(Abc_ObjFanout0(Abc_ObjFanout0(pLatch))) );
+ fprintf( pFile, " always@(posedge gclk) begin %s", Io_WriteVerilogGetName(Abc_ObjFanout0(Abc_ObjFanout0(pLatch))) );
+ fprintf( pFile, " <= %s; end\n", Io_WriteVerilogGetName(Abc_ObjFanin0(Abc_ObjFanin0(pLatch))) );
}
}
*/
@@ -658,15 +665,28 @@ int Io_WriteVerilogCheckNtk( Abc_Ntk_t * pNtk )
***********************************************************************/
char * Io_WriteVerilogGetName( Abc_Obj_t * pObj )
{
- static char Buffer[20];
+ static char Buffer[500];
char * pName;
+ int Length, i;
pName = Abc_ObjName(pObj);
- if ( pName[0] != '[' )
- return pName;
- // replace the brackets; as a result, the length of the name does not change
- strcpy( Buffer, pName );
- Buffer[0] = 'x';
- Buffer[strlen(Buffer)-1] = 'x';
+ Length = strlen(pName);
+ // consider the case of a signal having name "0" or "1"
+ if ( !(Length == 1 && (pName[0] == '0' || pName[0] == '1')) )
+ {
+ for ( i = 0; i < Length; i++ )
+ if ( !((pName[i] >= 'a' && pName[i] <= 'z') ||
+ (pName[i] >= 'A' && pName[i] <= 'Z') ||
+ (pName[i] >= '0' && pName[i] <= '9') || pName[i] == '_') )
+ break;
+ if ( i == Length )
+ return pName;
+ }
+ // create Verilog style name
+ Buffer[0] = '\\';
+ for ( i = 0; i < Length; i++ )
+ Buffer[i+1] = pName[i];
+ Buffer[Length+1] = ' ';
+ Buffer[Length+2] = 0;
return Buffer;
}
diff --git a/src/misc/nm/nmApi.c b/src/misc/nm/nmApi.c
index f7bb0fe7..05fe80a1 100644
--- a/src/misc/nm/nmApi.c
+++ b/src/misc/nm/nmApi.c
@@ -175,9 +175,9 @@ char * Nm_ManCreateUniqueName( Nm_Man_t * p, int ObjId )
int i;
if ( pEntry = Nm_ManTableLookupId(p, ObjId) )
return pEntry->Name;
- sprintf( NameStr, "[%d]", ObjId );
+ sprintf( NameStr, "n%d", ObjId );
for ( i = 1; Nm_ManTableLookupName(p, NameStr, -1); i++ )
- sprintf( NameStr, "[%d]_%d", ObjId, i );
+ sprintf( NameStr, "n%d_%d", ObjId, i );
return NameStr;
}
diff --git a/src/misc/st/st.c b/src/misc/st/st.c
index e1e5022a..892a33af 100644
--- a/src/misc/st/st.c
+++ b/src/misc/st/st.c
@@ -8,13 +8,27 @@
*
*/
#include <stdio.h>
-#include "extra.h"
+//#include "extra.h"
#include "st.h"
#ifndef ABS
# define ABS(a) ((a) < 0 ? -(a) : (a))
#endif
+#ifndef ALLOC
+#define ALLOC(type, num) ((type *) malloc(sizeof(type) * (num)))
+#endif
+
+#ifndef FREE
+#define FREE(obj) ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
+#endif
+
+#ifndef REALLOC
+#define REALLOC(type, obj, num) \
+ ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \
+ ((type *) malloc(sizeof(type) * (num))))
+#endif
+
#define ST_NUMCMP(x,y) ((x) != (y))
#define ST_NUMHASH(x,size) (ABS((long)x)%(size))
#define ST_PTRHASH(x,size) ((int)((unsigned long)(x)>>2)%size)
diff --git a/src/sat/asat/asat60525.zip b/src/sat/asat/asat60525.zip
deleted file mode 100644
index b8361af1..00000000
--- a/src/sat/asat/asat60525.zip
+++ /dev/null
Binary files differ
diff --git a/src/sat/asat_fixed/satSolver.c b/src/sat/asat_fixed/satSolver.c
deleted file mode 100644
index d3b99c9d..00000000
--- a/src/sat/asat_fixed/satSolver.c
+++ /dev/null
@@ -1,1191 +0,0 @@
-/**************************************************************************************************
-MiniSat -- Copyright (c) 2005, Niklas Sorensson
-http://www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-// Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
-
-#include <stdio.h>
-#include <assert.h>
-#include <math.h>
-
-#include "solver.h"
-
-//=================================================================================================
-// Debug:
-
-//#define VERBOSEDEBUG
-
-// For derivation output (verbosity level 2)
-#define L_IND "%-*d"
-#define L_ind solver_dlevel(s)*3+3,solver_dlevel(s)
-#define L_LIT "%sx%d"
-#define L_lit(p) lit_sign(p)?"~":"", (lit_var(p))
-
-// Just like 'assert()' but expression will be evaluated in the release version as well.
-static inline void check(int expr) { assert(expr); }
-
-static void printlits(lit* begin, lit* end)
-{
- int i;
- for (i = 0; i < end - begin; i++)
- printf(L_LIT" ",L_lit(begin[i]));
-}
-
-//=================================================================================================
-// Random numbers:
-
-
-// Returns a random float 0 <= x < 1. Seed must never be 0.
-static inline double drand(double* seed) {
- int q;
- *seed *= 1389796;
- q = (int)(*seed / 2147483647);
- *seed -= (double)q * 2147483647;
- return *seed / 2147483647; }
-
-
-// Returns a random integer 0 <= x < size. Seed must never be 0.
-static inline int irand(double* seed, int size) {
- return (int)(drand(seed) * size); }
-
-
-//=================================================================================================
-// Predeclarations:
-
-void sort(void** array, int size, int(*comp)(const void *, const void *));
-
-//=================================================================================================
-// Clause datatype + minor functions:
-
-struct clause_t
-{
- int size_learnt;
- lit lits[0];
-};
-
-static inline int clause_size (clause* c) { return c->size_learnt >> 1; }
-static inline lit* clause_begin (clause* c) { return c->lits; }
-static inline int clause_learnt (clause* c) { return c->size_learnt & 1; }
-static inline float clause_activity (clause* c) { return *((float*)&c->lits[c->size_learnt>>1]); }
-static inline void clause_setactivity(clause* c, float a) { *((float*)&c->lits[c->size_learnt>>1]) = a; }
-
-//=================================================================================================
-// Encode literals in clause pointers:
-
-clause* clause_from_lit (lit l) { return (clause*)((unsigned long)l + (unsigned long)l + 1); }
-bool clause_is_lit (clause* c) { return ((unsigned long)c & 1); }
-lit clause_read_lit (clause* c) { return (lit)((unsigned long)c >> 1); }
-
-//=================================================================================================
-// Simple helpers:
-
-static inline int solver_dlevel(solver* s) { return veci_size(&s->trail_lim); }
-static inline vecp* solver_read_wlist (solver* s, lit l){ return &s->wlists[l]; }
-static inline void vecp_remove(vecp* v, void* e)
-{
- void** ws = vecp_begin(v);
- int j = 0;
-
- for (; ws[j] != e ; j++);
- assert(j < vecp_size(v));
- for (; j < vecp_size(v)-1; j++) ws[j] = ws[j+1];
- vecp_resize(v,vecp_size(v)-1);
-}
-
-//=================================================================================================
-// Variable order functions:
-
-static inline void order_update(solver* s, int v) // updateorder
-{
- int* orderpos = s->orderpos;
- double* activity = s->activity;
- int* heap = veci_begin(&s->order);
- int i = orderpos[v];
- int x = heap[i];
- int parent = (i - 1) / 2;
-
- assert(s->orderpos[v] != -1);
-
- while (i != 0 && activity[x] > activity[heap[parent]]){
- heap[i] = heap[parent];
- orderpos[heap[i]] = i;
- i = parent;
- parent = (i - 1) / 2;
- }
- heap[i] = x;
- orderpos[x] = i;
-}
-
-static inline void order_assigned(solver* s, int v)
-{
-}
-
-static inline void order_unassigned(solver* s, int v) // undoorder
-{
- int* orderpos = s->orderpos;
- if (orderpos[v] == -1){
- orderpos[v] = veci_size(&s->order);
- veci_push(&s->order,v);
- order_update(s,v);
- }
-}
-
-static int order_select(solver* s, float random_var_freq) // selectvar
-{
- int* heap;
- double* activity;
- int* orderpos;
-
- lbool* values = s->assigns;
-
- // Random decision:
- if (drand(&s->random_seed) < random_var_freq){
- int next = irand(&s->random_seed,s->size);
- assert(next >= 0 && next < s->size);
- if (values[next] == l_Undef)
- return next;
- }
-
- // Activity based decision:
-
- heap = veci_begin(&s->order);
- activity = s->activity;
- orderpos = s->orderpos;
-
-
- while (veci_size(&s->order) > 0){
- int next = heap[0];
- int size = veci_size(&s->order)-1;
- int x = heap[size];
-
- veci_resize(&s->order,size);
-
- orderpos[next] = -1;
-
- if (size > 0){
- double act = activity[x];
-
- int i = 0;
- int child = 1;
-
-
- while (child < size){
- if (child+1 < size && activity[heap[child]] < activity[heap[child+1]])
- child++;
-
- assert(child < size);
-
- if (act >= activity[heap[child]])
- break;
-
- heap[i] = heap[child];
- orderpos[heap[i]] = i;
- i = child;
- child = 2 * child + 1;
- }
- heap[i] = x;
- orderpos[heap[i]] = i;
- }
-
- if (values[next] == l_Undef)
- return next;
- }
-
- return var_Undef;
-}
-
-//=================================================================================================
-// Activity functions:
-
-static inline void act_var_rescale(solver* s) {
- double* activity = s->activity;
- int i;
- for (i = 0; i < s->size; i++)
- activity[i] *= 1e-100;
- s->var_inc *= 1e-100;
-}
-
-static inline void act_var_bump(solver* s, int v) {
- double* activity = s->activity;
- if ((activity[v] += s->var_inc) > 1e100)
- act_var_rescale(s);
-
- //printf("bump %d %f\n", v-1, activity[v]);
-
- if (s->orderpos[v] != -1)
- order_update(s,v);
-
-}
-
-static inline void act_var_decay(solver* s) { s->var_inc *= s->var_decay; }
-
-static inline void act_clause_rescale(solver* s) {
- clause** cs = (clause**)vecp_begin(&s->learnts);
- int i;
- for (i = 0; i < vecp_size(&s->learnts); i++){
- float a = clause_activity(cs[i]);
- clause_setactivity(cs[i], a * (float)1e-20);
- }
- s->cla_inc *= (float)1e-20;
-}
-
-
-static inline void act_clause_bump(solver* s, clause *c) {
- float a = clause_activity(c) + s->cla_inc;
- clause_setactivity(c,a);
- if (a > 1e20) act_clause_rescale(s);
-}
-
-static inline void act_clause_decay(solver* s) { s->cla_inc *= s->cla_decay; }
-
-
-//=================================================================================================
-// Clause functions:
-
-/* pre: size > 1 && no variable occurs twice
- */
-static clause* clause_new(solver* s, lit* begin, lit* end, int learnt)
-{
- int size;
- clause* c;
- int i;
-
- assert(end - begin > 1);
- assert(learnt >= 0 && learnt < 2);
- size = end - begin;
- c = (clause*)malloc(sizeof(clause) + sizeof(lit) * size + learnt * sizeof(float));
- c->size_learnt = (size << 1) | learnt;
- assert(((unsigned int)c & 1) == 0);
-
- for (i = 0; i < size; i++)
- c->lits[i] = begin[i];
-
- if (learnt)
- *((float*)&c->lits[size]) = 0.0;
-
- assert(begin[0] >= 0);
- assert(begin[0] < s->size*2);
- assert(begin[1] >= 0);
- assert(begin[1] < s->size*2);
-
- assert(lit_neg(begin[0]) < s->size*2);
- assert(lit_neg(begin[1]) < s->size*2);
-
- //vecp_push(solver_read_wlist(s,lit_neg(begin[0])),(void*)c);
- //vecp_push(solver_read_wlist(s,lit_neg(begin[1])),(void*)c);
-
- vecp_push(solver_read_wlist(s,lit_neg(begin[0])),(void*)(size > 2 ? c : clause_from_lit(begin[1])));
- vecp_push(solver_read_wlist(s,lit_neg(begin[1])),(void*)(size > 2 ? c : clause_from_lit(begin[0])));
-
- return c;
-}
-
-
-static void clause_remove(solver* s, clause* c)
-{
- lit* lits = clause_begin(c);
- assert(lit_neg(lits[0]) < s->size*2);
- assert(lit_neg(lits[1]) < s->size*2);
-
- //vecp_remove(solver_read_wlist(s,lit_neg(lits[0])),(void*)c);
- //vecp_remove(solver_read_wlist(s,lit_neg(lits[1])),(void*)c);
-
- assert(lits[0] < s->size*2);
- vecp_remove(solver_read_wlist(s,lit_neg(lits[0])),(void*)(clause_size(c) > 2 ? c : clause_from_lit(lits[1])));
- vecp_remove(solver_read_wlist(s,lit_neg(lits[1])),(void*)(clause_size(c) > 2 ? c : clause_from_lit(lits[0])));
-
- if (clause_learnt(c)){
- s->stats.learnts--;
- s->stats.learnts_literals -= clause_size(c);
- }else{
- s->stats.clauses--;
- s->stats.clauses_literals -= clause_size(c);
- }
-
- free(c);
-}
-
-
-static lbool clause_simplify(solver* s, clause* c)
-{
- lit* lits = clause_begin(c);
- lbool* values = s->assigns;
- int i;
-
- assert(solver_dlevel(s) == 0);
-
- for (i = 0; i < clause_size(c); i++){
- lbool sig = !lit_sign(lits[i]); sig += sig - 1;
- if (values[lit_var(lits[i])] == sig)
- return l_True;
- }
- return l_False;
-}
-
-//=================================================================================================
-// Minor (solver) functions:
-
-void solver_setnvars(solver* s,int n)
-{
- int var;
-
- if (s->cap < n){
-
- while (s->cap < n) s->cap = s->cap*2+1;
-
- s->wlists = (vecp*) realloc(s->wlists, sizeof(vecp)*s->cap*2);
- s->activity = (double*) realloc(s->activity, sizeof(double)*s->cap);
- s->assigns = (lbool*) realloc(s->assigns, sizeof(lbool)*s->cap);
- s->orderpos = (int*) realloc(s->orderpos, sizeof(int)*s->cap);
- s->reasons = (clause**)realloc(s->reasons, sizeof(clause*)*s->cap);
- s->levels = (int*) realloc(s->levels, sizeof(int)*s->cap);
- s->tags = (lbool*) realloc(s->tags, sizeof(lbool)*s->cap);
- s->trail = (lit*) realloc(s->trail, sizeof(lit)*s->cap);
- }
-
- for (var = s->size; var < n; var++){
- vecp_new(&s->wlists[2*var]);
- vecp_new(&s->wlists[2*var+1]);
- s->activity [var] = 0;
- s->assigns [var] = l_Undef;
- s->orderpos [var] = veci_size(&s->order);
- s->reasons [var] = (clause*)0;
- s->levels [var] = 0;
- s->tags [var] = l_Undef;
-
- /* does not hold because variables enqueued at top level will not be reinserted in the heap
- assert(veci_size(&s->order) == var);
- */
- veci_push(&s->order,var);
- order_update(s, var);
- }
-
- s->size = n > s->size ? n : s->size;
-}
-
-
-static inline bool enqueue(solver* s, lit l, clause* from)
-{
- lbool* values = s->assigns;
- int v = lit_var(l);
- lbool val = values[v];
-#ifdef VERBOSEDEBUG
- printf(L_IND"enqueue("L_LIT")\n", L_ind, L_lit(l));
-#endif
-
- lbool sig = !lit_sign(l); sig += sig - 1;
- if (val != l_Undef){
- return val == sig;
- }else{
- // New fact -- store it.
-#ifdef VERBOSEDEBUG
- printf(L_IND"bind("L_LIT")\n", L_ind, L_lit(l));
-#endif
- int* levels = s->levels;
- clause** reasons = s->reasons;
-
- values [v] = sig;
- levels [v] = solver_dlevel(s);
- reasons[v] = from;
- s->trail[s->qtail++] = l;
-
- order_assigned(s, v);
- return true;
- }
-}
-
-
-static inline void assume(solver* s, lit l){
- assert(s->qtail == s->qhead);
- assert(s->assigns[lit_var(l)] == l_Undef);
-#ifdef VERBOSEDEBUG
- printf(L_IND"assume("L_LIT")\n", L_ind, L_lit(l));
-#endif
- veci_push(&s->trail_lim,s->qtail);
- enqueue(s,l,(clause*)0);
-}
-
-
-static inline void solver_canceluntil(solver* s, int level) {
- lit* trail;
- lbool* values;
- clause** reasons;
- int bound;
- int c;
-
- if (solver_dlevel(s) <= level)
- return;
-
- trail = s->trail;
- values = s->assigns;
- reasons = s->reasons;
- bound = (veci_begin(&s->trail_lim))[level];
-
- for (c = s->qtail-1; c >= bound; c--) {
- int x = lit_var(trail[c]);
- values [x] = l_Undef;
- reasons[x] = (clause*)0;
- }
-
- for (c = s->qhead-1; c >= bound; c--)
- order_unassigned(s,lit_var(trail[c]));
-
- s->qhead = s->qtail = bound;
- veci_resize(&s->trail_lim,level);
-}
-
-static void solver_record(solver* s, veci* cls)
-{
- lit* begin = veci_begin(cls);
- lit* end = begin + veci_size(cls);
- clause* c = (veci_size(cls) > 1) ? clause_new(s,begin,end,1) : (clause*)0;
- enqueue(s,*begin,c);
-
- assert(veci_size(cls) > 0);
-
- if (c != 0) {
- vecp_push(&s->learnts,c);
- act_clause_bump(s,c);
- s->stats.learnts++;
- s->stats.learnts_literals += veci_size(cls);
- }
-}
-
-
-static double solver_progress(solver* s)
-{
- lbool* values = s->assigns;
- int* levels = s->levels;
- int i;
-
- double progress = 0;
- double F = 1.0 / s->size;
- for (i = 0; i < s->size; i++)
- if (values[i] != l_Undef)
- progress += pow(F, levels[i]);
- return progress / s->size;
-}
-
-//=================================================================================================
-// Major methods:
-
-static bool solver_lit_removable(solver* s, lit l, int minl)
-{
- lbool* tags = s->tags;
- clause** reasons = s->reasons;
- int* levels = s->levels;
- int top = veci_size(&s->tagged);
-
- assert(lit_var(l) >= 0 && lit_var(l) < s->size);
- assert(reasons[lit_var(l)] != 0);
- veci_resize(&s->stack,0);
- veci_push(&s->stack,lit_var(l));
-
- while (veci_size(&s->stack) > 0){
- clause* c;
- int v = veci_begin(&s->stack)[veci_size(&s->stack)-1];
- assert(v >= 0 && v < s->size);
- veci_resize(&s->stack,veci_size(&s->stack)-1);
- assert(reasons[v] != 0);
- c = reasons[v];
-
- if (clause_is_lit(c)){
- int v = lit_var(clause_read_lit(c));
- if (tags[v] == l_Undef && levels[v] != 0){
- if (reasons[v] != 0 && ((1 << (levels[v] & 31)) & minl)){
- veci_push(&s->stack,v);
- tags[v] = l_True;
- veci_push(&s->tagged,v);
- }else{
- int* tagged = veci_begin(&s->tagged);
- int j;
- for (j = top; j < veci_size(&s->tagged); j++)
- tags[tagged[j]] = l_Undef;
- veci_resize(&s->tagged,top);
- return false;
- }
- }
- }else{
- lit* lits = clause_begin(c);
- int i, j;
-
- for (i = 1; i < clause_size(c); i++){
- int v = lit_var(lits[i]);
- if (tags[v] == l_Undef && levels[v] != 0){
- if (reasons[v] != 0 && ((1 << (levels[v] & 31)) & minl)){
-
- veci_push(&s->stack,lit_var(lits[i]));
- tags[v] = l_True;
- veci_push(&s->tagged,v);
- }else{
- int* tagged = veci_begin(&s->tagged);
- for (j = top; j < veci_size(&s->tagged); j++)
- tags[tagged[j]] = l_Undef;
- veci_resize(&s->tagged,top);
- return false;
- }
- }
- }
- }
- }
-
- return true;
-}
-
-static void solver_analyze(solver* s, clause* c, veci* learnt)
-{
- lit* trail = s->trail;
- lbool* tags = s->tags;
- clause** reasons = s->reasons;
- int* levels = s->levels;
- int cnt = 0;
- lit p = lit_Undef;
- int ind = s->qtail-1;
- lit* lits;
- int i, j, minl;
- int* tagged;
-
- veci_push(learnt,lit_Undef);
-
- do{
- assert(c != 0);
-
- if (clause_is_lit(c)){
- lit q = clause_read_lit(c);
- assert(lit_var(q) >= 0 && lit_var(q) < s->size);
- if (tags[lit_var(q)] == l_Undef && levels[lit_var(q)] > 0){
- tags[lit_var(q)] = l_True;
- veci_push(&s->tagged,lit_var(q));
- act_var_bump(s,lit_var(q));
- if (levels[lit_var(q)] == solver_dlevel(s))
- cnt++;
- else
- veci_push(learnt,q);
- }
- }else{
-
- if (clause_learnt(c))
- act_clause_bump(s,c);
-
- lits = clause_begin(c);
- //printlits(lits,lits+clause_size(c)); printf("\n");
- for (j = (p == lit_Undef ? 0 : 1); j < clause_size(c); j++){
- lit q = lits[j];
- assert(lit_var(q) >= 0 && lit_var(q) < s->size);
- if (tags[lit_var(q)] == l_Undef && levels[lit_var(q)] > 0){
- tags[lit_var(q)] = l_True;
- veci_push(&s->tagged,lit_var(q));
- act_var_bump(s,lit_var(q));
- if (levels[lit_var(q)] == solver_dlevel(s))
- cnt++;
- else
- veci_push(learnt,q);
- }
- }
- }
-
- while (tags[lit_var(trail[ind--])] == l_Undef);
-
- p = trail[ind+1];
- c = reasons[lit_var(p)];
- cnt--;
-
- }while (cnt > 0);
-
- *veci_begin(learnt) = lit_neg(p);
-
- lits = veci_begin(learnt);
- minl = 0;
- for (i = 1; i < veci_size(learnt); i++){
- int lev = levels[lit_var(lits[i])];
- minl |= 1 << (lev & 31);
- }
-
- // simplify (full)
- for (i = j = 1; i < veci_size(learnt); i++){
- if (reasons[lit_var(lits[i])] == 0 || !solver_lit_removable(s,lits[i],minl))
- lits[j++] = lits[i];
- }
-
- // update size of learnt + statistics
- s->stats.max_literals += veci_size(learnt);
- veci_resize(learnt,j);
- s->stats.tot_literals += j;
-
- // clear tags
- tagged = veci_begin(&s->tagged);
- for (i = 0; i < veci_size(&s->tagged); i++)
- tags[tagged[i]] = l_Undef;
- veci_resize(&s->tagged,0);
-
-#ifdef DEBUG
- for (i = 0; i < s->size; i++)
- assert(tags[i] == l_Undef);
-#endif
-
-#ifdef VERBOSEDEBUG
- printf(L_IND"Learnt {", L_ind);
- for (i = 0; i < veci_size(learnt); i++) printf(" "L_LIT, L_lit(lits[i]));
-#endif
- if (veci_size(learnt) > 1){
- int max_i = 1;
- int max = levels[lit_var(lits[1])];
- lit tmp;
-
- for (i = 2; i < veci_size(learnt); i++)
- if (levels[lit_var(lits[i])] > max){
- max = levels[lit_var(lits[i])];
- max_i = i;
- }
-
- tmp = lits[1];
- lits[1] = lits[max_i];
- lits[max_i] = tmp;
- }
-#ifdef VERBOSEDEBUG
- {
- int lev = veci_size(learnt) > 1 ? levels[lit_var(lits[1])] : 0;
- printf(" } at level %d\n", lev);
- }
-#endif
-}
-
-
-clause* solver_propagate(solver* s)
-{
- lbool* values = s->assigns;
- clause* confl = (clause*)0;
- lit* lits;
-
- //printf("solver_propagate\n");
- while (confl == 0 && s->qtail - s->qhead > 0){
- lit p = s->trail[s->qhead++];
- vecp* ws = solver_read_wlist(s,p);
- clause **begin = (clause**)vecp_begin(ws);
- clause **end = begin + vecp_size(ws);
- clause **i, **j;
-
- s->stats.propagations++;
- s->simpdb_props--;
-
- //printf("checking lit %d: "L_LIT"\n", veci_size(ws), L_lit(p));
- for (i = j = begin; i < end; ){
- if (clause_is_lit(*i)){
- *j++ = *i;
- if (!enqueue(s,clause_read_lit(*i),clause_from_lit(p))){
- confl = s->binary;
- (clause_begin(confl))[1] = lit_neg(p);
- (clause_begin(confl))[0] = clause_read_lit(*i++);
-
- // Copy the remaining watches:
- while (i < end)
- *j++ = *i++;
- }
- }else{
- lit false_lit;
- lbool sig;
-
- lits = clause_begin(*i);
-
- // Make sure the false literal is data[1]:
- false_lit = lit_neg(p);
- if (lits[0] == false_lit){
- lits[0] = lits[1];
- lits[1] = false_lit;
- }
- assert(lits[1] == false_lit);
- //printf("checking clause: "); printlits(lits, lits+clause_size(*i)); printf("\n");
-
- // If 0th watch is true, then clause is already satisfied.
- sig = !lit_sign(lits[0]); sig += sig - 1;
- if (values[lit_var(lits[0])] == sig){
- *j++ = *i;
- }else{
- // Look for new watch:
- lit* stop = lits + clause_size(*i);
- lit* k;
- for (k = lits + 2; k < stop; k++){
- lbool sig = lit_sign(*k); sig += sig - 1;
- if (values[lit_var(*k)] != sig){
- lits[1] = *k;
- *k = false_lit;
- vecp_push(solver_read_wlist(s,lit_neg(lits[1])),*i);
- goto next; }
- }
-
- *j++ = *i;
- // Clause is unit under assignment:
- if (!enqueue(s,lits[0], *i)){
- confl = *i++;
- // Copy the remaining watches:
- while (i < end)
- *j++ = *i++;
- }
- }
- }
- next:
- i++;
- }
-
- s->stats.inspects += j - (clause**)vecp_begin(ws);
- vecp_resize(ws,j - (clause**)vecp_begin(ws));
- }
-
- return confl;
-}
-
-static inline int clause_cmp (const void* x, const void* y) {
- return clause_size((clause*)x) > 2 && (clause_size((clause*)y) == 2 || clause_activity((clause*)x) < clause_activity((clause*)y)) ? -1 : 1; }
-
-void solver_reducedb(solver* s)
-{
- int i, j;
- double extra_lim = s->cla_inc / vecp_size(&s->learnts); // Remove any clause below this activity
- clause** learnts = (clause**)vecp_begin(&s->learnts);
- clause** reasons = s->reasons;
-
- sort(vecp_begin(&s->learnts), vecp_size(&s->learnts), &clause_cmp);
-
- for (i = j = 0; i < vecp_size(&s->learnts) / 2; i++){
- if (clause_size(learnts[i]) > 2 && reasons[lit_var(*clause_begin(learnts[i]))] != learnts[i])
- clause_remove(s,learnts[i]);
- else
- learnts[j++] = learnts[i];
- }
- for (; i < vecp_size(&s->learnts); i++){
- if (clause_size(learnts[i]) > 2 && reasons[lit_var(*clause_begin(learnts[i]))] != learnts[i] && clause_activity(learnts[i]) < extra_lim)
- clause_remove(s,learnts[i]);
- else
- learnts[j++] = learnts[i];
- }
-
- //printf("reducedb deleted %d\n", vecp_size(&s->learnts) - j);
-
-
- vecp_resize(&s->learnts,j);
-}
-
-static lbool solver_search(solver* s, int nof_conflicts, int nof_learnts)
-{
- int* levels = s->levels;
- double var_decay = 0.95;
- double clause_decay = 0.999;
- double random_var_freq = 0.02;
-
- int conflictC = 0;
- veci learnt_clause;
-
- assert(s->root_level == solver_dlevel(s));
-
- s->stats.starts++;
- s->var_decay = (float)(1 / var_decay );
- s->cla_decay = (float)(1 / clause_decay);
- veci_resize(&s->model,0);
- veci_new(&learnt_clause);
-
- for (;;){
- clause* confl = solver_propagate(s);
- if (confl != 0){
- // CONFLICT
- int blevel;
-
-#ifdef VERBOSEDEBUG
- printf(L_IND"**CONFLICT**\n", L_ind);
-#endif
- s->stats.conflicts++; conflictC++;
- if (solver_dlevel(s) == s->root_level){
- veci_delete(&learnt_clause);
- return l_False;
- }
-
- veci_resize(&learnt_clause,0);
- solver_analyze(s, confl, &learnt_clause);
- blevel = veci_size(&learnt_clause) > 1 ? levels[lit_var(veci_begin(&learnt_clause)[1])] : s->root_level;
- blevel = s->root_level > blevel ? s->root_level : blevel;
- solver_canceluntil(s,blevel);
- solver_record(s,&learnt_clause);
- act_var_decay(s);
- act_clause_decay(s);
-
- }else{
- // NO CONFLICT
- int next;
-
- if (nof_conflicts >= 0 && conflictC >= nof_conflicts){
- // Reached bound on number of conflicts:
- s->progress_estimate = solver_progress(s);
- solver_canceluntil(s,s->root_level);
- veci_delete(&learnt_clause);
- return l_Undef; }
-
- if (solver_dlevel(s) == 0)
- // Simplify the set of problem clauses:
- solver_simplify(s);
-
- if (nof_learnts >= 0 && vecp_size(&s->learnts) - s->qtail >= nof_learnts)
- // Reduce the set of learnt clauses:
- solver_reducedb(s);
-
- // New variable decision:
- s->stats.decisions++;
- next = order_select(s,(float)random_var_freq);
-
- if (next == var_Undef){
- // Model found:
- lbool* values = s->assigns;
- int i;
- for (i = 0; i < s->size; i++) veci_push(&s->model,(int)values[i]);
- solver_canceluntil(s,s->root_level);
- veci_delete(&learnt_clause);
-
- /*
- veci apa; veci_new(&apa);
- for (i = 0; i < s->size; i++)
- veci_push(&apa,(int)(s->model.ptr[i] == l_True ? toLit(i) : lit_neg(toLit(i))));
- printf("model: "); printlits((lit*)apa.ptr, (lit*)apa.ptr + veci_size(&apa)); printf("\n");
- veci_delete(&apa);
- */
-
- return l_True;
- }
-
- assume(s,lit_neg(toLit(next)));
- }
- }
-
- return l_Undef; // cannot happen
-}
-
-//=================================================================================================
-// External solver functions:
-
-solver* solver_new(void)
-{
- solver* s = (solver*)malloc(sizeof(solver));
-
- // initialize vectors
- vecp_new(&s->clauses);
- vecp_new(&s->learnts);
- veci_new(&s->order);
- veci_new(&s->trail_lim);
- veci_new(&s->tagged);
- veci_new(&s->stack);
- veci_new(&s->model);
-
- // initialize arrays
- s->wlists = 0;
- s->activity = 0;
- s->assigns = 0;
- s->orderpos = 0;
- s->reasons = 0;
- s->levels = 0;
- s->tags = 0;
- s->trail = 0;
-
-
- // initialize other vars
- s->size = 0;
- s->cap = 0;
- s->qhead = 0;
- s->qtail = 0;
- s->cla_inc = 1;
- s->cla_decay = 1;
- s->var_inc = 1;
- s->var_decay = 1;
- s->root_level = 0;
- s->simpdb_assigns = 0;
- s->simpdb_props = 0;
- s->random_seed = 91648253;
- s->progress_estimate = 0;
- s->binary = (clause*)malloc(sizeof(clause) + sizeof(lit)*2);
- s->binary->size_learnt = (2 << 1);
- s->verbosity = 0;
-
- s->stats.starts = 0;
- s->stats.decisions = 0;
- s->stats.propagations = 0;
- s->stats.inspects = 0;
- s->stats.conflicts = 0;
- s->stats.clauses = 0;
- s->stats.clauses_literals = 0;
- s->stats.learnts = 0;
- s->stats.learnts_literals = 0;
- s->stats.max_literals = 0;
- s->stats.tot_literals = 0;
-
- return s;
-}
-
-
-void solver_delete(solver* s)
-{
- int i;
- for (i = 0; i < vecp_size(&s->clauses); i++)
- free(vecp_begin(&s->clauses)[i]);
-
- for (i = 0; i < vecp_size(&s->learnts); i++)
- free(vecp_begin(&s->learnts)[i]);
-
- // delete vectors
- vecp_delete(&s->clauses);
- vecp_delete(&s->learnts);
- veci_delete(&s->order);
- veci_delete(&s->trail_lim);
- veci_delete(&s->tagged);
- veci_delete(&s->stack);
- veci_delete(&s->model);
- free(s->binary);
-
- // delete arrays
- if (s->wlists != 0){
- int i;
- for (i = 0; i < s->size*2; i++)
- vecp_delete(&s->wlists[i]);
-
- // if one is different from null, all are
- free(s->wlists);
- free(s->activity );
- free(s->assigns );
- free(s->orderpos );
- free(s->reasons );
- free(s->levels );
- free(s->trail );
- free(s->tags );
- }
-
- free(s);
-}
-
-
-bool solver_addclause(solver* s, lit* begin, lit* end)
-{
- lit *i,*j;
- int maxvar;
- lbool* values;
- lit last;
-
- if (begin == end) return false;
-
- //printlits(begin,end); printf("\n");
- // insertion sort
- maxvar = lit_var(*begin);
- for (i = begin + 1; i < end; i++){
- lit l = *i;
- maxvar = lit_var(l) > maxvar ? lit_var(l) : maxvar;
- for (j = i; j > begin && *(j-1) > l; j--)
- *j = *(j-1);
- *j = l;
- }
- solver_setnvars(s,maxvar+1);
-
- //printlits(begin,end); printf("\n");
- values = s->assigns;
-
- // delete duplicates
- last = lit_Undef;
- for (i = j = begin; i < end; i++){
- //printf("lit: "L_LIT", value = %d\n", L_lit(*i), (lit_sign(*i) ? -values[lit_var(*i)] : values[lit_var(*i)]));
- lbool sig = !lit_sign(*i); sig += sig - 1;
- if (*i == lit_neg(last) || sig == values[lit_var(*i)])
- return true; // tautology
- else if (*i != last && values[lit_var(*i)] == l_Undef)
- last = *j++ = *i;
- }
-
- //printf("final: "); printlits(begin,j); printf("\n");
-
- if (j == begin) // empty clause
- return false;
- else if (j - begin == 1) // unit clause
- return enqueue(s,*begin,(clause*)0);
-
- // create new clause
- vecp_push(&s->clauses,clause_new(s,begin,j,0));
-
-
- s->stats.clauses++;
- s->stats.clauses_literals += j - begin;
-
- return true;
-}
-
-
-bool solver_simplify(solver* s)
-{
- clause** reasons;
- int type;
-
- assert(solver_dlevel(s) == 0);
-
- if (solver_propagate(s) != 0)
- return false;
-
- if (s->qhead == s->simpdb_assigns || s->simpdb_props > 0)
- return true;
-
- reasons = s->reasons;
- for (type = 0; type < 2; type++){
- vecp* cs = type ? &s->learnts : &s->clauses;
- clause** cls = (clause**)vecp_begin(cs);
-
- int i, j;
- for (j = i = 0; i < vecp_size(cs); i++){
- if (reasons[lit_var(*clause_begin(cls[i]))] != cls[i] &&
- clause_simplify(s,cls[i]) == l_True)
- clause_remove(s,cls[i]);
- else
- cls[j++] = cls[i];
- }
- vecp_resize(cs,j);
- }
-
- s->simpdb_assigns = s->qhead;
- // (shouldn't depend on 'stats' really, but it will do for now)
- s->simpdb_props = (int)(s->stats.clauses_literals + s->stats.learnts_literals);
-
- return true;
-}
-
-
-bool solver_solve(solver* s, lit* begin, lit* end)
-{
- double nof_conflicts = 100;
- double nof_learnts = solver_nclauses(s) / 3;
- lbool status = l_Undef;
- lbool* values = s->assigns;
- lit* i;
-
- //printf("solve: "); printlits(begin, end); printf("\n");
- for (i = begin; i < end; i++){
- switch (lit_sign(*i) ? -values[lit_var(*i)] : values[lit_var(*i)]){
- case 1: /* l_True: */
- break;
- case 0: /* l_Undef */
- assume(s, *i);
- if (solver_propagate(s) == NULL)
- break;
- // falltrough
- case -1: /* l_False */
- solver_canceluntil(s, 0);
- return false;
- }
- }
-
- s->root_level = solver_dlevel(s);
-
- if (s->verbosity >= 1){
- printf("==================================[MINISAT]===================================\n");
- printf("| Conflicts | ORIGINAL | LEARNT | Progress |\n");
- printf("| | Clauses Literals | Limit Clauses Literals Lit/Cl | |\n");
- printf("==============================================================================\n");
- }
-
- while (status == l_Undef){
- double Ratio = (s->stats.learnts == 0)? 0.0 :
- s->stats.learnts_literals / (double)s->stats.learnts;
-
- if (s->verbosity >= 1){
- printf("| %9.0f | %7.0f %8.0f | %7.0f %7.0f %8.0f %7.1f | %6.3f %% |\n",
- (double)s->stats.conflicts,
- (double)s->stats.clauses,
- (double)s->stats.clauses_literals,
- (double)nof_learnts,
- (double)s->stats.learnts,
- (double)s->stats.learnts_literals,
- Ratio,
- s->progress_estimate*100);
- fflush(stdout);
- }
- status = solver_search(s,(int)nof_conflicts, (int)nof_learnts);
- nof_conflicts *= 1.5;
- nof_learnts *= 1.1;
- }
- if (s->verbosity >= 1)
- printf("==============================================================================\n");
-
- solver_canceluntil(s,0);
- return status != l_False;
-}
-
-
-int solver_nvars(solver* s)
-{
- return s->size;
-}
-
-
-int solver_nclauses(solver* s)
-{
- return vecp_size(&s->clauses);
-}
-
-
-int solver_nconflicts(solver* s)
-{
- return (int)s->stats.conflicts;
-}
-
-//=================================================================================================
-// Sorting functions (sigh):
-
-static inline void selectionsort(void** array, int size, int(*comp)(const void *, const void *))
-{
- int i, j, best_i;
- void* tmp;
-
- for (i = 0; i < size-1; i++){
- best_i = i;
- for (j = i+1; j < size; j++){
- if (comp(array[j], array[best_i]) < 0)
- best_i = j;
- }
- tmp = array[i]; array[i] = array[best_i]; array[best_i] = tmp;
- }
-}
-
-
-static void sortrnd(void** array, int size, int(*comp)(const void *, const void *), double* seed)
-{
- if (size <= 15)
- selectionsort(array, size, comp);
-
- else{
- void* pivot = array[irand(seed, size)];
- void* tmp;
- int i = -1;
- int j = size;
-
- for(;;){
- do i++; while(comp(array[i], pivot)<0);
- do j--; while(comp(pivot, array[j])<0);
-
- if (i >= j) break;
-
- tmp = array[i]; array[i] = array[j]; array[j] = tmp;
- }
-
- sortrnd(array , i , comp, seed);
- sortrnd(&array[i], size-i, comp, seed);
- }
-}
-
-void sort(void** array, int size, int(*comp)(const void *, const void *))
-{
- double seed = 91648253;
- sortrnd(array,size,comp,&seed);
-}
diff --git a/src/sat/asat_fixed/satSolver.h b/src/sat/asat_fixed/satSolver.h
deleted file mode 100644
index c9ce0219..00000000
--- a/src/sat/asat_fixed/satSolver.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/**************************************************************************************************
-MiniSat -- Copyright (c) 2005, Niklas Sorensson
-http://www.cs.chalmers.se/Cs/Research/FormalMethods/MiniSat/
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
-associated documentation files (the "Software"), to deal in the Software without restriction,
-including without limitation the rights to use, copy, modify, merge, publish, distribute,
-sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or
-substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
-NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
-OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-**************************************************************************************************/
-// Modified to compile with MS Visual Studio 6.0 by Alan Mishchenko
-
-#ifndef solver_h
-#define solver_h
-
-#ifdef _WIN32
-#define inline __inline // compatible with MS VS 6.0
-#endif
-
-#include "vec.h"
-
-//=================================================================================================
-// Simple types:
-
-// does not work for c++
-typedef int bool;
-static const bool true = 1;
-static const bool false = 0;
-
-typedef int lit;
-typedef char lbool;
-
-#ifdef _WIN32
-typedef signed __int64 uint64; // compatible with MS VS 6.0
-#else
-typedef unsigned long long uint64;
-#endif
-
-static const int var_Undef = -1;
-static const lit lit_Undef = -2;
-
-static const lbool l_Undef = 0;
-static const lbool l_True = 1;
-static const lbool l_False = -1;
-
-static inline lit toLit (int v) { return v + v; }
-static inline lit lit_neg (lit l) { return l ^ 1; }
-static inline int lit_var (lit l) { return l >> 1; }
-static inline int lit_sign(lit l) { return (l & 1); }
-
-
-//=================================================================================================
-// Public interface:
-
-struct solver_t;
-typedef struct solver_t solver;
-
-extern solver* solver_new(void);
-extern void solver_delete(solver* s);
-
-extern bool solver_addclause(solver* s, lit* begin, lit* end);
-extern bool solver_simplify(solver* s);
-extern bool solver_solve(solver* s, lit* begin, lit* end);
-
-extern int solver_nvars(solver* s);
-extern int solver_nclauses(solver* s);
-extern int solver_nconflicts(solver* s);
-
-extern void solver_setnvars(solver* s,int n);
-
-struct stats_t
-{
- uint64 starts, decisions, propagations, inspects, conflicts;
- uint64 clauses, clauses_literals, learnts, learnts_literals, max_literals, tot_literals;
-};
-typedef struct stats_t stats;
-
-//=================================================================================================
-// Solver representation:
-
-struct clause_t;
-typedef struct clause_t clause;
-
-struct solver_t
-{
- int size; // nof variables
- int cap; // size of varmaps
- int qhead; // Head index of queue.
- int qtail; // Tail index of queue.
-
- // clauses
- vecp clauses; // List of problem constraints. (contains: clause*)
- vecp learnts; // List of learnt clauses. (contains: clause*)
-
- // activities
- double var_inc; // Amount to bump next variable with.
- double var_decay; // INVERSE decay factor for variable activity: stores 1/decay.
- float cla_inc; // Amount to bump next clause with.
- float cla_decay; // INVERSE decay factor for clause activity: stores 1/decay.
-
- vecp* wlists; //
- double* activity; // A heuristic measurement of the activity of a variable.
- lbool* assigns; // Current values of variables.
- int* orderpos; // Index in variable order.
- clause** reasons; //
- int* levels; //
- lit* trail;
-
- clause* binary; // A temporary binary clause
- lbool* tags; //
- veci tagged; // (contains: var)
- veci stack; // (contains: var)
-
- veci order; // Variable order. (heap) (contains: var)
- veci trail_lim; // Separator indices for different decision levels in 'trail'. (contains: int)
- veci model; // If problem is solved, this vector contains the model (contains: lbool).
-
- int root_level; // Level of first proper decision.
- int simpdb_assigns;// Number of top-level assignments at last 'simplifyDB()'.
- int simpdb_props; // Number of propagations before next 'simplifyDB()'.
- double random_seed;
- double progress_estimate;
- int verbosity; // Verbosity level. 0=silent, 1=some progress report, 2=everything
-
- stats stats;
-};
-
-#endif
diff --git a/src/sat/bsat/module.make b/src/sat/bsat/module.make
new file mode 100644
index 00000000..c8ec65dd
--- /dev/null
+++ b/src/sat/bsat/module.make
@@ -0,0 +1,3 @@
+SRC += src/sat/bsat/satMem.c \
+ src/sat/bsat/satSolver.c \
+ src/sat/bsat/satUtil.c
diff --git a/src/temp/ivy/satMem.c b/src/sat/bsat/satMem.c
index bb234f66..bb234f66 100644
--- a/src/temp/ivy/satMem.c
+++ b/src/sat/bsat/satMem.c
diff --git a/src/temp/ivy/satMem.h b/src/sat/bsat/satMem.h
index 5c5ddd9c..5c5ddd9c 100644
--- a/src/temp/ivy/satMem.h
+++ b/src/sat/bsat/satMem.h
diff --git a/src/temp/ivy/satSolver.c b/src/sat/bsat/satSolver.c
index 38e73c7d..a84c82ef 100644
--- a/src/temp/ivy/satSolver.c
+++ b/src/sat/bsat/satSolver.c
@@ -26,7 +26,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA
#include "satSolver.h"
-//#define ASAT_USE_SYSTEM_MEMORY_MANAGEMENT
+//#define SAT_USE_SYSTEM_MEMORY_MANAGEMENT
//=================================================================================================
// Debug:
@@ -213,21 +213,6 @@ static int order_select(sat_solver* s, float random_var_freq) // selectvar
return var_Undef;
}
-void sat_solver_order_clean(sat_solver* s) // removes all variables from the queue
-{
- while ( order_select(s, 0.0) != var_Undef );
-}
-
-void sat_solver_order_unassigned(sat_solver* s, int v) // undoorder
-{
- order_unassigned(s, v);
-}
-
-void sat_solver_order_update(sat_solver* s, int v) // updateorder
-{
- order_update(s, v);
-}
-
//=================================================================================================
// Activity functions:
@@ -240,27 +225,21 @@ static inline void act_var_rescale(sat_solver* s) {
}
static inline void act_var_bump(sat_solver* s, int v) {
- double* activity = s->activity;
- if ((activity[v] += s->var_inc) > 1e100)
+ s->activity[v] += s->var_inc;
+ if (s->activity[v] > 1e100)
act_var_rescale(s);
-
//printf("bump %d %f\n", v-1, activity[v]);
-
if (s->orderpos[v] != -1)
order_update(s,v);
-
}
-void sat_solver_act_var_bump_factor(sat_solver* s, int v, double factor) {
- double* activity = s->activity;
- if ((activity[v] += s->var_inc * factor) > 1e100)
+static inline void act_var_bump_factor(sat_solver* s, int v) {
+ s->activity[v] += (s->var_inc * s->factors[v]);
+ if (s->activity[v] > 1e100)
act_var_rescale(s);
-
//printf("bump %d %f\n", v-1, activity[v]);
-
if (s->orderpos[v] != -1)
order_update(s,v);
-
}
static inline void act_var_decay(sat_solver* s) { s->var_inc *= s->var_decay; }
@@ -284,8 +263,6 @@ static inline void act_clause_bump(sat_solver* s, clause *c) {
static inline void act_clause_decay(sat_solver* s) { s->cla_inc *= s->cla_decay; }
-double* sat_solver_activity(sat_solver* s) { return s->activity; }
-
//=================================================================================================
// Clause functions:
@@ -301,7 +278,7 @@ static clause* clause_new(sat_solver* s, lit* begin, lit* end, int learnt)
assert(learnt >= 0 && learnt < 2);
size = end - begin;
// c = (clause*)malloc(sizeof(clause) + sizeof(lit) * size + learnt * sizeof(float));
-#ifdef ASAT_USE_SYSTEM_MEMORY_MANAGEMENT
+#ifdef SAT_USE_SYSTEM_MEMORY_MANAGEMENT
c = (clause*)malloc(sizeof(clause) + sizeof(lit) * size + learnt * sizeof(float));
#else
c = (clause*)Sat_MmStepEntryFetch( s->pMem, sizeof(clause) + sizeof(lit) * size + learnt * sizeof(float) );
@@ -355,7 +332,7 @@ static void clause_remove(sat_solver* s, clause* c)
s->stats.clauses_literals -= clause_size(c);
}
-#ifdef ASAT_USE_SYSTEM_MEMORY_MANAGEMENT
+#ifdef SAT_USE_SYSTEM_MEMORY_MANAGEMENT
free(c);
#else
Sat_MmStepEntryRecycle( s->pMem, (char *)c, sizeof(clause) + sizeof(lit) * clause_size(c) + clause_learnt(c) * sizeof(float) );
@@ -392,6 +369,7 @@ void sat_solver_setnvars(sat_solver* s,int n)
s->wlists = (vecp*) realloc(s->wlists, sizeof(vecp)*s->cap*2);
s->activity = (double*) realloc(s->activity, sizeof(double)*s->cap);
+ s->factors = (double*) realloc(s->factors, sizeof(double)*s->cap);
s->assigns = (lbool*) realloc(s->assigns, sizeof(lbool)*s->cap);
s->orderpos = (int*) realloc(s->orderpos, sizeof(int)*s->cap);
s->reasons = (clause**)realloc(s->reasons, sizeof(clause*)*s->cap);
@@ -404,6 +382,7 @@ void sat_solver_setnvars(sat_solver* s,int n)
vecp_new(&s->wlists[2*var]);
vecp_new(&s->wlists[2*var+1]);
s->activity [var] = 0;
+ s->factors [var] = 0;
s->assigns [var] = l_Undef;
s->orderpos [var] = veci_size(&s->order);
s->reasons [var] = (clause*)0;
@@ -831,15 +810,22 @@ static lbool sat_solver_search(sat_solver* s, int nof_conflicts, int nof_learnts
int conflictC = 0;
veci learnt_clause;
+ int i;
assert(s->root_level == sat_solver_dlevel(s));
+ s->nRestarts++;
s->stats.starts++;
s->var_decay = (float)(1 / var_decay );
s->cla_decay = (float)(1 / clause_decay);
veci_resize(&s->model,0);
veci_new(&learnt_clause);
+ // use activity factors in every even restart
+ if ( (s->nRestarts & 1) && veci_size(&s->act_vars) > 0 )
+ for ( i = 0; i < s->act_vars.size; i++ )
+ act_var_bump_factor(s, s->act_vars.ptr[i]);
+
for (;;){
clause* confl = sat_solver_propagate(s);
if (confl != 0){
@@ -941,10 +927,12 @@ sat_solver* sat_solver_new(void)
veci_new(&s->tagged);
veci_new(&s->stack);
veci_new(&s->model);
+ veci_new(&s->act_vars);
// initialize arrays
s->wlists = 0;
s->activity = 0;
+ s->factors = 0;
s->assigns = 0;
s->orderpos = 0;
s->reasons = 0;
@@ -983,7 +971,7 @@ sat_solver* sat_solver_new(void)
s->stats.max_literals = 0;
s->stats.tot_literals = 0;
-#ifdef ASAT_USE_SYSTEM_MEMORY_MANAGEMENT
+#ifdef SAT_USE_SYSTEM_MEMORY_MANAGEMENT
s->pMem = NULL;
#else
s->pMem = Sat_MmStepStart( 10 );
@@ -995,7 +983,7 @@ sat_solver* sat_solver_new(void)
void sat_solver_delete(sat_solver* s)
{
-#ifdef ASAT_USE_SYSTEM_MEMORY_MANAGEMENT
+#ifdef SAT_USE_SYSTEM_MEMORY_MANAGEMENT
int i;
for (i = 0; i < vecp_size(&s->clauses); i++)
free(vecp_begin(&s->clauses)[i]);
@@ -1013,6 +1001,7 @@ void sat_solver_delete(sat_solver* s)
veci_delete(&s->tagged);
veci_delete(&s->stack);
veci_delete(&s->model);
+ veci_delete(&s->act_vars);
free(s->binary);
// delete arrays
@@ -1022,8 +1011,9 @@ void sat_solver_delete(sat_solver* s)
vecp_delete(&s->wlists[i]);
// if one is different from null, all are
- free(s->wlists);
+ free(s->wlists );
free(s->activity );
+ free(s->factors );
free(s->assigns );
free(s->orderpos );
free(s->reasons );
@@ -1135,6 +1125,7 @@ int sat_solver_solve(sat_solver* s, lit* begin, lit* end, sint64 nConfLimit, sin
lit* i;
// set the external limits
+ s->nRestarts = 0;
s->nConfLimit = 0;
s->nInsLimit = 0;
if ( nConfLimit )
diff --git a/src/temp/ivy/satSolver.h b/src/sat/bsat/satSolver.h
index a7ace8ed..6c05a14a 100644
--- a/src/temp/ivy/satSolver.h
+++ b/src/sat/bsat/satSolver.h
@@ -79,13 +79,6 @@ extern int sat_solver_nconflicts(sat_solver* s);
extern void sat_solver_setnvars(sat_solver* s,int n);
-extern void sat_solver_order_clean(sat_solver* s);
-extern void sat_solver_order_unassigned(sat_solver* s, int v);
-extern void sat_solver_order_update(sat_solver* s, int v);
-
-extern double* sat_solver_activity(sat_solver* s);
-extern void sat_solver_act_var_bump_factor(sat_solver* s, int v, double factor);
-
struct stats_t
{
sint64 starts, decisions, propagations, inspects, conflicts;
@@ -148,6 +141,10 @@ struct sat_solver_t
sint64 nConfLimit; // external limit on the number of conflicts
sint64 nInsLimit; // external limit on the number of implications
+ veci act_vars; // variables whose activity has changed
+ double* factors; // the activity factors
+ int nRestarts; // the number of local restarts
+
Sat_MmStep_t * pMem;
};
diff --git a/src/temp/ivy/satUtil.c b/src/sat/bsat/satUtil.c
index f2b78fe6..f2b78fe6 100644
--- a/src/temp/ivy/satUtil.c
+++ b/src/sat/bsat/satUtil.c
diff --git a/src/temp/ivy/satVec.h b/src/sat/bsat/satVec.h
index ffa9c431..d7fce5c0 100644
--- a/src/temp/ivy/satVec.h
+++ b/src/sat/bsat/satVec.h
@@ -45,7 +45,7 @@ static inline void veci_resize (veci* v, int k) { v->size = k; } // only
static inline void veci_push (veci* v, int e)
{
if (v->size == v->cap) {
- int newsize = v->cap * 2+1;
+ int newsize = v->cap * 2;//+1;
v->ptr = (int*)realloc(v->ptr,sizeof(int)*newsize);
v->cap = newsize; }
v->ptr[v->size++] = e;
@@ -73,7 +73,7 @@ static inline void vecp_resize (vecp* v, int k) { v->size = k; } // only
static inline void vecp_push (vecp* v, void* e)
{
if (v->size == v->cap) {
- int newsize = v->cap * 2+1;
+ int newsize = v->cap * 2;//+1;
v->ptr = (void**)realloc(v->ptr,sizeof(void*)*newsize);
v->cap = newsize; }
v->ptr[v->size++] = e;
diff --git a/src/sat/csat/csat_apis.c b/src/sat/csat/csat_apis.c
index 76543e37..5bf0158c 100644
--- a/src/sat/csat/csat_apis.c
+++ b/src/sat/csat/csat_apis.c
@@ -571,8 +571,8 @@ void ABC_SolveInit( ABC_Manager mng )
if ( mng->pTarget ) Abc_NtkDelete( mng->pTarget );
// set the new target network
- mng->pTarget = Abc_NtkCreateTarget( mng->pNtk, mng->vNodes, mng->vValues );
-
+// mng->pTarget = Abc_NtkCreateTarget( mng->pNtk, mng->vNodes, mng->vValues );
+ mng->pTarget = Abc_NtkStrash( mng->pNtk, 0, 1 );
}
/**Function*************************************************************
@@ -614,7 +614,8 @@ enum CSAT_StatusT ABC_Solve( ABC_Manager mng )
if ( mng->mode )
RetValue = Abc_NtkMiterSat( mng->pTarget, (sint64)pParams->nMiteringLimitLast, (sint64)0, 0, 0, NULL, NULL );
else
- RetValue = Abc_NtkMiterProve( &mng->pTarget, pParams );
+// RetValue = Abc_NtkMiterProve( &mng->pTarget, pParams ); // old CEC engine
+ RetValue = Abc_NtkIvyProve( &mng->pTarget, pParams ); // new CEC engine
// analyze the result
mng->pResult = ABC_TargetResAlloc( Abc_NtkCiNum(mng->pTarget) );
diff --git a/src/sat/fraig/fraigMan.c b/src/sat/fraig/fraigMan.c
index ffb51a07..b43f1093 100644
--- a/src/sat/fraig/fraigMan.c
+++ b/src/sat/fraig/fraigMan.c
@@ -52,9 +52,9 @@ void Prove_ParamsSetDefault( Prove_Params_t * pParams )
// iterations
pParams->nItersMax = 6; // the number of iterations
// mitering
- pParams->nMiteringLimitStart = 1000; // starting mitering limit
+ pParams->nMiteringLimitStart = 300; // starting mitering limit
pParams->nMiteringLimitMulti = 2.0; // multiplicative coefficient to increase the limit in each iteration
- // rewriting
+ // rewriting (currently not used)
pParams->nRewritingLimitStart = 3; // the number of rewriting iterations
pParams->nRewritingLimitMulti = 1.0; // multiplicative coefficient to increase the limit in each iteration
// fraiging
diff --git a/src/temp/aig/aig.h b/src/temp/aig/aig.h
index 5166d0c3..fbf234ac 100644
--- a/src/temp/aig/aig.h
+++ b/src/temp/aig/aig.h
@@ -252,6 +252,7 @@ extern void Aig_ManCreateRefs( Aig_Man_t * p );
extern int Aig_DagSize( Aig_Obj_t * pObj );
extern void Aig_ConeUnmark_rec( Aig_Obj_t * pObj );
extern Aig_Obj_t * Aig_Transfer( Aig_Man_t * pSour, Aig_Man_t * pDest, Aig_Obj_t * pObj, int nVars );
+extern Aig_Obj_t * Aig_Compose( Aig_Man_t * p, Aig_Obj_t * pRoot, Aig_Obj_t * pFunc, int iVar );
/*=== aigMan.c ==========================================================*/
extern Aig_Man_t * Aig_ManStart();
extern Aig_Man_t * Aig_ManDup( Aig_Man_t * p );
@@ -297,6 +298,7 @@ extern Aig_Obj_t * Aig_ObjRecognizeMux( Aig_Obj_t * pObj, Aig_Obj_t ** ppObj
extern void Aig_ObjPrintVerilog( FILE * pFile, Aig_Obj_t * pObj, Vec_Vec_t * vLevels, int Level );
extern void Aig_ObjPrintVerbose( Aig_Obj_t * pObj, int fHaig );
extern void Aig_ManPrintVerbose( Aig_Man_t * p, int fHaig );
+extern void Aig_ManDumpBlif( Aig_Man_t * p, char * pFileName );
#ifdef __cplusplus
}
diff --git a/src/temp/aig/aigDfs.c b/src/temp/aig/aigDfs.c
index 2fe8b2ef..c004cab0 100644
--- a/src/temp/aig/aigDfs.c
+++ b/src/temp/aig/aigDfs.c
@@ -338,6 +338,60 @@ Aig_Obj_t * Aig_Transfer( Aig_Man_t * pSour, Aig_Man_t * pDest, Aig_Obj_t * pRoo
return Aig_NotCond( Aig_Regular(pRoot)->pData, Aig_IsComplement(pRoot) );
}
+/**Function*************************************************************
+
+ Synopsis [Composes the AIG (pRoot) with the function (pFunc) using PI var (iVar).]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Aig_Compose_rec( Aig_Man_t * p, Aig_Obj_t * pObj, Aig_Obj_t * pFunc, Aig_Obj_t * pVar )
+{
+ assert( !Aig_IsComplement(pObj) );
+ if ( Aig_ObjIsMarkA(pObj) )
+ return;
+ if ( Aig_ObjIsConst1(pObj) || Aig_ObjIsPi(pObj) )
+ {
+ pObj->pData = pObj == pVar ? pFunc : pObj;
+ return;
+ }
+ Aig_Compose_rec( p, Aig_ObjFanin0(pObj), pFunc, pVar );
+ Aig_Compose_rec( p, Aig_ObjFanin1(pObj), pFunc, pVar );
+ pObj->pData = Aig_And( p, Aig_ObjChild0Copy(pObj), Aig_ObjChild1Copy(pObj) );
+ assert( !Aig_ObjIsMarkA(pObj) ); // loop detection
+ Aig_ObjSetMarkA( pObj );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Composes the AIG (pRoot) with the function (pFunc) using PI var (iVar).]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+Aig_Obj_t * Aig_Compose( Aig_Man_t * p, Aig_Obj_t * pRoot, Aig_Obj_t * pFunc, int iVar )
+{
+ // quit if the PI variable is not defined
+ if ( iVar >= Aig_ManPiNum(p) )
+ {
+ printf( "Aig_Compose(): The PI variable %d is not defined.\n", iVar );
+ return NULL;
+ }
+ // recursively perform composition
+ Aig_Compose_rec( p, Aig_Regular(pRoot), pFunc, Aig_ManPi(p, iVar) );
+ // clear the markings
+ Aig_ConeUnmark_rec( Aig_Regular(pRoot) );
+ return Aig_NotCond( Aig_Regular(pRoot)->pData, Aig_IsComplement(pRoot) );
+}
+
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
diff --git a/src/temp/aig/aigUtil.c b/src/temp/aig/aigUtil.c
index 99966e7d..6534a460 100644
--- a/src/temp/aig/aigUtil.c
+++ b/src/temp/aig/aigUtil.c
@@ -421,7 +421,79 @@ void Aig_ManPrintVerbose( Aig_Man_t * p, int fHaig )
printf( "\n" );
}
+/**Function*************************************************************
+
+ Synopsis [Writes the AIG into the BLIF file.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+***********************************************************************/
+void Aig_ManDumpBlif( Aig_Man_t * p, char * pFileName )
+{
+ FILE * pFile;
+ Vec_Ptr_t * vNodes;
+ Aig_Obj_t * pObj, * pConst1 = NULL;
+ int i, nDigits, Counter = 0;
+ if ( Aig_ManPoNum(p) == 0 )
+ {
+ printf( "Aig_ManDumpBlif(): AIG manager does not have POs.\n" );
+ return;
+ }
+ // collect nodes in the DFS order
+ vNodes = Aig_ManDfs( p );
+ // assign IDs to objects
+ Aig_ManConst1(p)->pData = (void *)Counter++;
+ Aig_ManForEachPi( p, pObj, i )
+ pObj->pData = (void *)Counter++;
+ Aig_ManForEachPo( p, pObj, i )
+ pObj->pData = (void *)Counter++;
+ Vec_PtrForEachEntry( vNodes, pObj, i )
+ pObj->pData = (void *)Counter++;
+ nDigits = Extra_Base10Log( Counter );
+ // write the file
+ pFile = fopen( pFileName, "w" );
+ fprintf( pFile, "# BLIF file written by procedure Aig_ManDumpBlif() in ABC\n" );
+ fprintf( pFile, "# http://www.eecs.berkeley.edu/~alanmi/abc/\n" );
+ fprintf( pFile, ".model test\n" );
+ // write PIs
+ fprintf( pFile, ".inputs" );
+ Aig_ManForEachPi( p, pObj, i )
+ fprintf( pFile, " n%0*d", nDigits, (int)pObj->pData );
+ fprintf( pFile, "\n" );
+ // write POs
+ fprintf( pFile, ".outputs" );
+ Aig_ManForEachPo( p, pObj, i )
+ fprintf( pFile, " n%0*d", nDigits, (int)pObj->pData );
+ fprintf( pFile, "\n" );
+ // write nodes
+ Vec_PtrForEachEntry( vNodes, pObj, i )
+ {
+ fprintf( pFile, ".names n%0*d n%0*d n%0*d\n",
+ nDigits, (int)Aig_ObjFanin0(pObj)->pData,
+ nDigits, (int)Aig_ObjFanin1(pObj)->pData,
+ nDigits, (int)pObj->pData );
+ fprintf( pFile, "%d%d 1\n", !Aig_ObjFaninC0(pObj), !Aig_ObjFaninC1(pObj) );
+ }
+ // write POs
+ Aig_ManForEachPo( p, pObj, i )
+ {
+ fprintf( pFile, ".names n%0*d n%0*d\n",
+ nDigits, (int)Aig_ObjFanin0(pObj)->pData,
+ nDigits, (int)pObj->pData );
+ fprintf( pFile, "%d 1\n", !Aig_ObjFaninC0(pObj) );
+ if ( Aig_ObjIsConst1(Aig_ObjFanin0(pObj)) )
+ pConst1 = Aig_ManConst1(p);
+ }
+ if ( pConst1 )
+ fprintf( pFile, ".names n%0*d\n 1\n", nDigits, (int)pConst1->pData );
+ fprintf( pFile, ".end\n\n" );
+ fclose( pFile );
+ Vec_PtrFree( vNodes );
+}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
diff --git a/src/temp/aig/cudd2.c b/src/temp/aig/cudd2.c
new file mode 100644
index 00000000..95663420
--- /dev/null
+++ b/src/temp/aig/cudd2.c
@@ -0,0 +1,337 @@
+/**CFile****************************************************************
+
+ FileName [cudd2.c]
+
+ SystemName [ABC: Logic synthesis and verification system.]
+
+ PackageName [Minimalistic And-Inverter Graph package.]
+
+ Synopsis [Recording AIGs for the BDD operations.]
+
+ Author [Alan Mishchenko]
+
+ Affiliation [UC Berkeley]
+
+ Date [Ver. 1.0. Started - October 3, 2006.]
+
+ Revision [$Id: cudd2.c,v 1.00 2006/10/03 00:00:00 alanmi Exp $]
+
+***********************************************************************/
+
+#include "aig.h"
+#include "st.h"
+
+////////////////////////////////////////////////////////////////////////
+/// DECLARATIONS ///
+////////////////////////////////////////////////////////////////////////
+
+typedef struct Aig_CuddMan_t_ Aig_CuddMan_t;
+struct Aig_CuddMan_t_
+{
+ Aig_Man_t * pAig; // internal AIG package
+ st_table * pTable; // hash table mapping BDD nodes into AIG nodes
+};
+
+// static Cudd AIG manager used in this experiment
+static Aig_CuddMan_t * s_pCuddMan = NULL;
+
+////////////////////////////////////////////////////////////////////////
+/// FUNCTION DEFINITIONS ///
+////////////////////////////////////////////////////////////////////////
+
+/**Function*************************************************************
+
+ Synopsis [Start AIG recording.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_Init( unsigned int numVars, unsigned int numVarsZ, unsigned int numSlots, unsigned int cacheSize, unsigned long maxMemory, void * pCudd )
+{
+ int v;
+ assert( s_pCuddMan == NULL );
+ s_pCuddMan = ALLOC( Aig_CuddMan_t, 1 );
+ s_pCuddMan->pAig = Aig_ManStart();
+ s_pCuddMan->pTable = st_init_table( st_ptrcmp, st_ptrhash );
+ for ( v = 0; v < (int)numVars; v++ )
+ Aig_ObjCreatePi( s_pCuddMan->pAig );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Stops AIG recording.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_Quit( void * pCudd )
+{
+ assert( s_pCuddMan != NULL );
+ Aig_ManDumpBlif( s_pCuddMan->pAig, "aig_temp.blif" );
+ Aig_ManStop( s_pCuddMan->pAig );
+ st_free_table( s_pCuddMan->pTable );
+ free( s_pCuddMan );
+ s_pCuddMan = NULL;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Fetches AIG node corresponding to the BDD node from the hash table.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static Aig_Obj_t * Cudd2_GetArg( void * pArg )
+{
+ Aig_Obj_t * pNode;
+ assert( s_pCuddMan != NULL );
+ if ( !st_lookup( s_pCuddMan->pTable, (char *)Aig_Regular(pArg), (char **)&pNode ) )
+ {
+ printf( "Cudd2_GetArg(): An argument BDD is not in the hash table.\n" );
+ return NULL;
+ }
+ return Aig_NotCond( pNode, Aig_IsComplement(pArg) );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Inserts the AIG node corresponding to the BDD node into the hash table.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+static void Cudd2_SetArg( Aig_Obj_t * pNode, void * pResult )
+{
+ assert( s_pCuddMan != NULL );
+ if ( st_is_member( s_pCuddMan->pTable, (char *)Aig_Regular(pResult) ) )
+ return;
+ pNode = Aig_NotCond( pNode, Aig_IsComplement(pResult) );
+ st_insert( s_pCuddMan->pTable, (char *)Aig_Regular(pResult), (char *)pNode );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Adds elementary variable.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_bddIthVar( void * pCudd, int iVar, void * pResult )
+{
+ int v;
+ assert( s_pCuddMan != NULL );
+ for ( v = Aig_ManPiNum(s_pCuddMan->pAig); v <= iVar; v++ )
+ Aig_ObjCreatePi( s_pCuddMan->pAig );
+ Cudd2_SetArg( Aig_ManPi(s_pCuddMan->pAig, iVar), pResult );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Performs BDD operation.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_bddAnd( void * pCudd, void * pArg0, void * pArg1, void * pResult )
+{
+ Aig_Obj_t * pNode0, * pNode1, * pNode;
+ pNode0 = Cudd2_GetArg( pArg0 );
+ pNode1 = Cudd2_GetArg( pArg1 );
+ pNode = Aig_And( s_pCuddMan->pAig, pNode0, pNode1 );
+ Cudd2_SetArg( pNode, pResult );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Performs BDD operation.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_bddOr( void * pCudd, void * pArg0, void * pArg1, void * pResult )
+{
+ Cudd2_bddAnd( pCudd, Aig_Not(pArg0), Aig_Not(pArg1), Aig_Not(pResult) );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Performs BDD operation.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_bddNand( void * pCudd, void * pArg0, void * pArg1, void * pResult )
+{
+ Cudd2_bddAnd( pCudd, pArg0, pArg1, Aig_Not(pResult) );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Performs BDD operation.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_bddNor( void * pCudd, void * pArg0, void * pArg1, void * pResult )
+{
+ Cudd2_bddAnd( pCudd, Aig_Not(pArg0), Aig_Not(pArg1), pResult );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Performs BDD operation.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_bddXor( void * pCudd, void * pArg0, void * pArg1, void * pResult )
+{
+ Aig_Obj_t * pNode0, * pNode1, * pNode;
+ pNode0 = Cudd2_GetArg( pArg0 );
+ pNode1 = Cudd2_GetArg( pArg1 );
+ pNode = Aig_Exor( s_pCuddMan->pAig, pNode0, pNode1 );
+ Cudd2_SetArg( pNode, pResult );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Performs BDD operation.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_bddXnor( void * pCudd, void * pArg0, void * pArg1, void * pResult )
+{
+ Cudd2_bddXor( pCudd, pArg0, pArg1, Aig_Not(pResult) );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Performs BDD operation.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_bddIte( void * pCudd, void * pArg0, void * pArg1, void * pArg2, void * pResult )
+{
+ Aig_Obj_t * pNode0, * pNode1, * pNode2, * pNode;
+ pNode0 = Cudd2_GetArg( pArg0 );
+ pNode1 = Cudd2_GetArg( pArg1 );
+ pNode2 = Cudd2_GetArg( pArg2 );
+ pNode = Aig_Mux( s_pCuddMan->pAig, pNode0, pNode1, pNode2 );
+ Cudd2_SetArg( pNode, pResult );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Performs BDD operation.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_bddCompose( void * pCudd, void * pArg0, void * pArg1, int v, void * pResult )
+{
+ Aig_Obj_t * pNode0, * pNode1, * pNode;
+ pNode0 = Cudd2_GetArg( pArg0 );
+ pNode1 = Cudd2_GetArg( pArg1 );
+ pNode = Aig_Compose( s_pCuddMan->pAig, pNode0, pNode1, v );
+ Cudd2_SetArg( pNode, pResult );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Should be called after each containment check.]
+
+ Description [Result should be 1 if Cudd2_bddLeq returned 1.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_bddLeq( void * pCudd, void * pArg0, void * pArg1, int Result )
+{
+ Aig_Obj_t * pNode0, * pNode1, * pNode;
+ pNode0 = Cudd2_GetArg( pArg0 );
+ pNode1 = Cudd2_GetArg( pArg1 );
+ pNode = Aig_And( s_pCuddMan->pAig, pNode0, Aig_Not(pNode1) );
+ Aig_ObjCreatePo( s_pCuddMan->pAig, pNode );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Should be called after each equality check.]
+
+ Description [Result should be 1 if they are equal.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Cudd2_bddEqual( void * pCudd, void * pArg0, void * pArg1, int Result )
+{
+ Aig_Obj_t * pNode0, * pNode1, * pNode;
+ pNode0 = Cudd2_GetArg( pArg0 );
+ pNode1 = Cudd2_GetArg( pArg1 );
+ pNode = Aig_Exor( s_pCuddMan->pAig, pNode0, pNode1 );
+ Aig_ObjCreatePo( s_pCuddMan->pAig, pNode );
+}
+
+////////////////////////////////////////////////////////////////////////
+/// END OF FILE ///
+////////////////////////////////////////////////////////////////////////
+
+
diff --git a/src/temp/vec/vec.h b/src/temp/aig/cudd2.h
index 6ab23298..800ee33f 100644
--- a/src/temp/vec/vec.h
+++ b/src/temp/aig/cudd2.h
@@ -1,10 +1,10 @@
/**CFile****************************************************************
- FileName [vec.h]
+ FileName [cudd2.h]
SystemName [ABC: Logic synthesis and verification system.]
- PackageName [Resizable arrays.]
+ PackageName [Minimalistic And-Inverter Graph package.]
Synopsis [External declarations.]
@@ -12,32 +12,23 @@
Affiliation [UC Berkeley]
- Date [Ver. 1.0. Started - June 20, 2005.]
+ Date [Ver. 1.0. Started - October 3, 2006.]
- Revision [$Id: vec.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
+ Revision [$Id: cudd2.h,v 1.00 2006/05/11 00:00:00 alanmi Exp $]
***********************************************************************/
-
-#ifndef __VEC_H__
-#define __VEC_H__
+
+#ifndef __CUDD2_H__
+#define __CUDD2_H__
#ifdef __cplusplus
extern "C" {
-#endif
+#endif
////////////////////////////////////////////////////////////////////////
/// INCLUDES ///
////////////////////////////////////////////////////////////////////////
-#ifdef _WIN32
-#define inline __inline // compatible with MS VS 6.0
-#endif
-
-#include "vecInt.h"
-#include "vecStr.h"
-#include "vecPtr.h"
-#include "vecVec.h"
-
////////////////////////////////////////////////////////////////////////
/// PARAMETERS ///
////////////////////////////////////////////////////////////////////////
@@ -50,10 +41,29 @@ extern "C" {
/// MACRO DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////////////////////
+/// ITERATORS ///
+////////////////////////////////////////////////////////////////////////
+
////////////////////////////////////////////////////////////////////////
/// FUNCTION DECLARATIONS ///
////////////////////////////////////////////////////////////////////////
+extern void Cudd2_Init ( unsigned int numVars, unsigned int numVarsZ, unsigned int numSlots, unsigned int cacheSize, unsigned long maxMemory, void * pCudd );
+extern void Cudd2_Quit ( void * pCudd );
+extern void Cudd2_bddIthVar ( void * pCudd, int iVar, void * pResult );
+extern void Cudd2_bddAnd ( void * pCudd, void * pArg0, void * pArg1, void * pResult );
+extern void Cudd2_bddOr ( void * pCudd, void * pArg0, void * pArg1, void * pResult );
+extern void Cudd2_bddNand ( void * pCudd, void * pArg0, void * pArg1, void * pResult );
+extern void Cudd2_bddNor ( void * pCudd, void * pArg0, void * pArg1, void * pResult );
+extern void Cudd2_bddXor ( void * pCudd, void * pArg0, void * pArg1, void * pResult );
+extern void Cudd2_bddXnor ( void * pCudd, void * pArg0, void * pArg1, void * pResult );
+extern void Cudd2_bddIte ( void * pCudd, void * pArg0, void * pArg1, void * pArg2, void * pResult );
+extern void Cudd2_bddCompose( void * pCudd, void * pArg0, void * pArg1, int v, void * pResult );
+extern void Cudd2_bddLeq ( void * pCudd, void * pArg0, void * pArg1, int Result );
+extern void Cudd2_bddEqual ( void * pCudd, void * pArg0, void * pArg1, int Result );
+
#ifdef __cplusplus
}
#endif
diff --git a/src/temp/aig/module.make b/src/temp/aig/module.make
new file mode 100644
index 00000000..ef9b587c
--- /dev/null
+++ b/src/temp/aig/module.make
@@ -0,0 +1,9 @@
+SRC += src/temp/aig/aigBalance.c \
+ src/temp/aig/aigCheck.c \
+ src/temp/aig/aigDfs.c \
+ src/temp/aig/aigMan.c \
+ src/temp/aig/aigMem.c \
+ src/temp/aig/aigObj.c \
+ src/temp/aig/aigOper.c \
+ src/temp/aig/aigTable.c \
+ src/temp/aig/aigUtil.c
diff --git a/src/temp/esop/esop.h b/src/temp/esop/esop.h
deleted file mode 100644
index 5f95f371..00000000
--- a/src/temp/esop/esop.h
+++ /dev/null
@@ -1,723 +0,0 @@
-/**CFile****************************************************************
-
- FileName [esop.h]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [Cover manipulation package.]
-
- Synopsis [Internal declarations.]
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - June 20, 2005.]
-
- Revision [$Id: esop.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#ifndef __ESOP_H__
-#define __ESOP_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdio.h>
-#include "vec.h"
-#include "mem.h"
-
-////////////////////////////////////////////////////////////////////////
-/// DECLARATIONS ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Esop_Man_t_ Esop_Man_t;
-typedef struct Esop_Cube_t_ Esop_Cube_t;
-typedef struct Mem_Fixed_t_ Mem_Fixed_t;
-
-struct Esop_Man_t_
-{
- int nVars; // the number of vars
- int nWords; // the number of words
- Mem_Fixed_t * pMemMan1; // memory manager for cubes
- Mem_Fixed_t * pMemMan2; // memory manager for cubes
- Mem_Fixed_t * pMemMan4; // memory manager for cubes
- Mem_Fixed_t * pMemMan8; // memory manager for cubes
- // temporary cubes
- Esop_Cube_t * pOne0; // tautology cube
- Esop_Cube_t * pOne1; // tautology cube
- Esop_Cube_t * pTriv0; // trivial cube
- Esop_Cube_t * pTriv1; // trivial cube
- Esop_Cube_t * pTemp; // cube for computing the distance
- Esop_Cube_t * pBubble; // cube used as a separator
- // temporary storage for the new cover
- int nCubes; // the number of cubes
- Esop_Cube_t ** ppStore; // storage for cubes by number of literals
-};
-
-struct Esop_Cube_t_
-{
- Esop_Cube_t * pNext; // the pointer to the next cube in the cover
- unsigned nVars : 10; // the number of variables
- unsigned nWords : 12; // the number of machine words
- unsigned nLits : 10; // the number of literals in the cube
- unsigned uData[1]; // the bit-data for the cube
-};
-
-#define ALLOC(type, num) ((type *) malloc(sizeof(type) * (num)))
-#define FREE(obj) ((obj) ? (free((char *) (obj)), (obj) = 0) : 0)
-#define REALLOC(type, obj, num) \
- ((obj) ? ((type *) realloc((char *)(obj), sizeof(type) * (num))) : \
- ((type *) malloc(sizeof(type) * (num))))
-
-// iterators through the entries in the linked lists of cubes
-#define Esop_CoverForEachCube( pCover, pCube ) \
- for ( pCube = pCover; \
- pCube; \
- pCube = pCube->pNext )
-#define Esop_CoverForEachCubeSafe( pCover, pCube, pCube2 ) \
- for ( pCube = pCover, \
- pCube2 = pCube? pCube->pNext: NULL; \
- pCube; \
- pCube = pCube2, \
- pCube2 = pCube? pCube->pNext: NULL )
-#define Esop_CoverForEachCubePrev( pCover, pCube, ppPrev ) \
- for ( pCube = pCover, \
- ppPrev = &(pCover); \
- pCube; \
- ppPrev = &pCube->pNext, \
- pCube = pCube->pNext )
-
-
-// macros to get hold of bits and values in the cubes
-static inline int Esop_CubeHasBit( Esop_Cube_t * p, int i ) { return (p->uData[i >> 5] & (1<<(i & 31))) > 0; }
-static inline void Esop_CubeSetBit( Esop_Cube_t * p, int i ) { p->uData[i >> 5] |= (1<<(i & 31)); }
-static inline void Esop_CubeXorBit( Esop_Cube_t * p, int i ) { p->uData[i >> 5] ^= (1<<(i & 31)); }
-static inline int Esop_CubeGetVar( Esop_Cube_t * p, int Var ) { return 3 & (p->uData[(Var<<1)>>5] >> ((Var<<1) & 31)); }
-static inline void Esop_CubeXorVar( Esop_Cube_t * p, int Var, int Value ) { p->uData[(Var<<1)>>5] ^= (Value<<((Var<<1) & 31)); }
-static inline int Esop_BitWordNum( int nBits ) { return (nBits>>5) + ((nBits&31) > 0); }
-
-/*=== esopMem.c ===========================================================*/
-extern Mem_Fixed_t * Mem_FixedStart( int nEntrySize );
-extern void Mem_FixedStop( Mem_Fixed_t * p, int fVerbose );
-extern char * Mem_FixedEntryFetch( Mem_Fixed_t * p );
-extern void Mem_FixedEntryRecycle( Mem_Fixed_t * p, char * pEntry );
-extern void Mem_FixedRestart( Mem_Fixed_t * p );
-extern int Mem_FixedReadMemUsage( Mem_Fixed_t * p );
-/*=== esopMin.c ===========================================================*/
-extern void Esop_EsopMinimize( Esop_Man_t * p );
-extern void Esop_EsopAddCube( Esop_Man_t * p, Esop_Cube_t * pCube );
-/*=== esopMan.c ===========================================================*/
-extern Esop_Man_t * Esop_ManAlloc( int nVars );
-extern void Esop_ManClean( Esop_Man_t * p, int nSupp );
-extern void Esop_ManFree( Esop_Man_t * p );
-/*=== esopUtil.c ===========================================================*/
-extern void Esop_CubeWrite( FILE * pFile, Esop_Cube_t * pCube );
-extern void Esop_CoverWrite( FILE * pFile, Esop_Cube_t * pCover );
-extern void Esop_CoverWriteStore( FILE * pFile, Esop_Man_t * p );
-extern void Esop_CoverWriteFile( Esop_Cube_t * pCover, char * pName, int fEsop );
-extern void Esop_CoverCheck( Esop_Man_t * p );
-extern int Esop_CubeCheck( Esop_Cube_t * pCube );
-extern Esop_Cube_t * Esop_CoverCollect( Esop_Man_t * p, int nSuppSize );
-extern void Esop_CoverExpand( Esop_Man_t * p, Esop_Cube_t * pCover );
-extern int Esop_CoverSuppVarNum( Esop_Man_t * p, Esop_Cube_t * pCover );
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis [Creates the cube.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Esop_Cube_t * Esop_CubeAlloc( Esop_Man_t * p )
-{
- Esop_Cube_t * pCube;
- if ( p->nWords <= 1 )
- pCube = (Esop_Cube_t *)Mem_FixedEntryFetch( p->pMemMan1 );
- else if ( p->nWords <= 2 )
- pCube = (Esop_Cube_t *)Mem_FixedEntryFetch( p->pMemMan2 );
- else if ( p->nWords <= 4 )
- pCube = (Esop_Cube_t *)Mem_FixedEntryFetch( p->pMemMan4 );
- else if ( p->nWords <= 8 )
- pCube = (Esop_Cube_t *)Mem_FixedEntryFetch( p->pMemMan8 );
- pCube->pNext = NULL;
- pCube->nVars = p->nVars;
- pCube->nWords = p->nWords;
- pCube->nLits = 0;
- memset( pCube->uData, 0xff, sizeof(unsigned) * p->nWords );
- return pCube;
-}
-
-/**Function*************************************************************
-
- Synopsis [Creates the cube representing elementary var.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Esop_Cube_t * Esop_CubeAllocVar( Esop_Man_t * p, int iVar, int fCompl )
-{
- Esop_Cube_t * pCube;
- pCube = Esop_CubeAlloc( p );
- Esop_CubeXorBit( pCube, iVar*2+fCompl );
- pCube->nLits = 1;
- return pCube;
-}
-
-/**Function*************************************************************
-
- Synopsis [Creates the cube.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Esop_Cube_t * Esop_CubeDup( Esop_Man_t * p, Esop_Cube_t * pCopy )
-{
- Esop_Cube_t * pCube;
- pCube = Esop_CubeAlloc( p );
- memcpy( pCube->uData, pCopy->uData, sizeof(unsigned) * p->nWords );
- pCube->nLits = pCopy->nLits;
- return pCube;
-}
-
-/**Function*************************************************************
-
- Synopsis [Recycles the cube.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Esop_CubeRecycle( Esop_Man_t * p, Esop_Cube_t * pCube )
-{
- if ( pCube->nWords <= 1 )
- Mem_FixedEntryRecycle( p->pMemMan1, (char *)pCube );
- else if ( pCube->nWords <= 2 )
- Mem_FixedEntryRecycle( p->pMemMan2, (char *)pCube );
- else if ( pCube->nWords <= 4 )
- Mem_FixedEntryRecycle( p->pMemMan4, (char *)pCube );
- else if ( pCube->nWords <= 8 )
- Mem_FixedEntryRecycle( p->pMemMan8, (char *)pCube );
-}
-
-/**Function*************************************************************
-
- Synopsis [Recycles the cube cover.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Esop_CoverRecycle( Esop_Man_t * p, Esop_Cube_t * pCover )
-{
- Esop_Cube_t * pCube, * pCube2;
- if ( pCover == NULL )
- return;
- if ( pCover->nWords <= 1 )
- Esop_CoverForEachCubeSafe( pCover, pCube, pCube2 )
- Mem_FixedEntryRecycle( p->pMemMan1, (char *)pCube );
- else if ( pCover->nWords <= 2 )
- Esop_CoverForEachCubeSafe( pCover, pCube, pCube2 )
- Mem_FixedEntryRecycle( p->pMemMan2, (char *)pCube );
- else if ( pCover->nWords <= 4 )
- Esop_CoverForEachCubeSafe( pCover, pCube, pCube2 )
- Mem_FixedEntryRecycle( p->pMemMan4, (char *)pCube );
- else if ( pCover->nWords <= 8 )
- Esop_CoverForEachCubeSafe( pCover, pCube, pCube2 )
- Mem_FixedEntryRecycle( p->pMemMan8, (char *)pCube );
-}
-
-/**Function*************************************************************
-
- Synopsis [Recycles the cube cover.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Esop_Cube_t * Esop_CoverDup( Esop_Man_t * p, Esop_Cube_t * pCover )
-{
- Esop_Cube_t * pCube, * pCubeNew;
- Esop_Cube_t * pCoverNew = NULL, ** ppTail = &pCoverNew;
- Esop_CoverForEachCube( pCover, pCube )
- {
- pCubeNew = Esop_CubeDup( p, pCube );
- *ppTail = pCubeNew;
- ppTail = &pCubeNew->pNext;
- }
- *ppTail = NULL;
- return pCoverNew;
-}
-
-
-/**Function*************************************************************
-
- Synopsis [Counts the number of cubes in the cover.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Esop_CubeCountLits( Esop_Cube_t * pCube )
-{
- unsigned uData;
- int Count = 0, i, w;
- for ( w = 0; w < (int)pCube->nWords; w++ )
- {
- uData = pCube->uData[w] ^ (pCube->uData[w] >> 1);
- for ( i = 0; i < 32; i += 2 )
- if ( uData & (1 << i) )
- Count++;
- }
- return Count;
-}
-
-/**Function*************************************************************
-
- Synopsis [Counts the number of cubes in the cover.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Esop_CubeGetLits( Esop_Cube_t * pCube, Vec_Int_t * vLits )
-{
- unsigned uData;
- int i, w;
- Vec_IntClear( vLits );
- for ( w = 0; w < (int)pCube->nWords; w++ )
- {
- uData = pCube->uData[w] ^ (pCube->uData[w] >> 1);
- for ( i = 0; i < 32; i += 2 )
- if ( uData & (1 << i) )
- Vec_IntPush( vLits, w*16 + i/2 );
- }
-}
-
-/**Function*************************************************************
-
- Synopsis [Counts the number of cubes in the cover.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Esop_CoverCountCubes( Esop_Cube_t * pCover )
-{
- Esop_Cube_t * pCube;
- int Count = 0;
- Esop_CoverForEachCube( pCover, pCube )
- Count++;
- return Count;
-}
-
-
-/**Function*************************************************************
-
- Synopsis [Checks if two cubes are disjoint.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Esop_CubesDisjoint( Esop_Cube_t * pCube0, Esop_Cube_t * pCube1 )
-{
- unsigned uData;
- int i;
- assert( pCube0->nVars == pCube1->nVars );
- for ( i = 0; i < (int)pCube0->nWords; i++ )
- {
- uData = pCube0->uData[i] & pCube1->uData[i];
- uData = (uData | (uData >> 1)) & 0x55555555;
- if ( uData != 0x55555555 )
- return 1;
- }
- return 0;
-}
-
-/**Function*************************************************************
-
- Synopsis [Collects the disjoint variables of the two cubes.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Esop_CoverGetDisjVars( Esop_Cube_t * pThis, Esop_Cube_t * pCube, Vec_Int_t * vVars )
-{
- unsigned uData;
- int i, w;
- Vec_IntClear( vVars );
- for ( w = 0; w < (int)pCube->nWords; w++ )
- {
- uData = pThis->uData[w] & (pThis->uData[w] >> 1) & 0x55555555;
- uData &= (pCube->uData[w] ^ (pCube->uData[w] >> 1));
- if ( uData == 0 )
- continue;
- for ( i = 0; i < 32; i += 2 )
- if ( uData & (1 << i) )
- Vec_IntPush( vVars, w*16 + i/2 );
- }
-}
-
-/**Function*************************************************************
-
- Synopsis [Checks if two cubes are disjoint.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Esop_CubesDistOne( Esop_Cube_t * pCube0, Esop_Cube_t * pCube1, Esop_Cube_t * pTemp )
-{
- unsigned uData;
- int i, fFound = 0;
- for ( i = 0; i < (int)pCube0->nWords; i++ )
- {
- uData = pCube0->uData[i] ^ pCube1->uData[i];
- if ( uData == 0 )
- {
- if ( pTemp ) pTemp->uData[i] = 0;
- continue;
- }
- if ( fFound )
- return 0;
- uData = (uData | (uData >> 1)) & 0x55555555;
- if ( (uData & (uData-1)) > 0 ) // more than one 1
- return 0;
- if ( pTemp ) pTemp->uData[i] = uData | (uData << 1);
- fFound = 1;
- }
- if ( fFound == 0 )
- {
- printf( "\n" );
- Esop_CubeWrite( stdout, pCube0 );
- Esop_CubeWrite( stdout, pCube1 );
- printf( "Error: Esop_CubesDistOne() looks at two equal cubes!\n" );
- }
- return 1;
-}
-
-/**Function*************************************************************
-
- Synopsis [Checks if two cubes are disjoint.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Esop_CubesDistTwo( Esop_Cube_t * pCube0, Esop_Cube_t * pCube1, int * pVar0, int * pVar1 )
-{
- unsigned uData;//, uData2;
- int i, k, Var0 = -1, Var1 = -1;
- for ( i = 0; i < (int)pCube0->nWords; i++ )
- {
- uData = pCube0->uData[i] ^ pCube1->uData[i];
- if ( uData == 0 )
- continue;
- if ( Var0 >= 0 && Var1 >= 0 ) // more than two 1s
- return 0;
- uData = (uData | (uData >> 1)) & 0x55555555;
- if ( (Var0 >= 0 || Var1 >= 0) && (uData & (uData-1)) > 0 )
- return 0;
- for ( k = 0; k < 32; k += 2 )
- if ( uData & (1 << k) )
- {
- if ( Var0 == -1 )
- Var0 = 16 * i + k/2;
- else if ( Var1 == -1 )
- Var1 = 16 * i + k/2;
- else
- return 0;
- }
- /*
- if ( Var0 >= 0 )
- {
- uData &= 0xFFFF;
- uData2 = (uData >> 16);
- if ( uData && uData2 )
- return 0;
- if ( uData )
- {
- }
- uData }= uData2;
- uData &= 0x
- }
- */
- }
- if ( Var0 >= 0 && Var1 >= 0 )
- {
- *pVar0 = Var0;
- *pVar1 = Var1;
- return 1;
- }
- if ( Var0 == -1 || Var1 == -1 )
- {
- printf( "\n" );
- Esop_CubeWrite( stdout, pCube0 );
- Esop_CubeWrite( stdout, pCube1 );
- printf( "Error: Esop_CubesDistTwo() looks at two equal cubes or dist1 cubes!\n" );
- }
- return 0;
-}
-
-/**Function*************************************************************
-
- Synopsis [Makes the produce of two cubes.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Esop_Cube_t * Esop_CubesProduct( Esop_Man_t * p, Esop_Cube_t * pCube0, Esop_Cube_t * pCube1 )
-{
- Esop_Cube_t * pCube;
- int i;
- assert( pCube0->nVars == pCube1->nVars );
- pCube = Esop_CubeAlloc( p );
- for ( i = 0; i < p->nWords; i++ )
- pCube->uData[i] = pCube0->uData[i] & pCube1->uData[i];
- pCube->nLits = Esop_CubeCountLits( pCube );
- return pCube;
-}
-
-/**Function*************************************************************
-
- Synopsis [Makes the produce of two cubes.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Esop_Cube_t * Esop_CubesXor( Esop_Man_t * p, Esop_Cube_t * pCube0, Esop_Cube_t * pCube1 )
-{
- Esop_Cube_t * pCube;
- int i;
- assert( pCube0->nVars == pCube1->nVars );
- pCube = Esop_CubeAlloc( p );
- for ( i = 0; i < p->nWords; i++ )
- pCube->uData[i] = pCube0->uData[i] ^ pCube1->uData[i];
- pCube->nLits = Esop_CubeCountLits( pCube );
- return pCube;
-}
-
-/**Function*************************************************************
-
- Synopsis [Makes the produce of two cubes.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Esop_CubesAreEqual( Esop_Cube_t * pCube0, Esop_Cube_t * pCube1 )
-{
- int i;
- for ( i = 0; i < (int)pCube0->nWords; i++ )
- if ( pCube0->uData[i] != pCube1->uData[i] )
- return 0;
- return 1;
-}
-
-/**Function*************************************************************
-
- Synopsis [Returns 1 if pCube1 is contained in pCube0, bitwise.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Esop_CubeIsContained( Esop_Cube_t * pCube0, Esop_Cube_t * pCube1 )
-{
- int i;
- for ( i = 0; i < (int)pCube0->nWords; i++ )
- if ( (pCube0->uData[i] & pCube1->uData[i]) != pCube1->uData[i] )
- return 0;
- return 1;
-}
-
-/**Function*************************************************************
-
- Synopsis [Transforms the cube into the result of merging.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Esop_CubesTransform( Esop_Cube_t * pCube, Esop_Cube_t * pDist, Esop_Cube_t * pMask )
-{
- int w;
- for ( w = 0; w < (int)pCube->nWords; w++ )
- {
- pCube->uData[w] = pCube->uData[w] ^ pDist->uData[w];
- pCube->uData[w] |= (pDist->uData[w] & ~pMask->uData[w]);
- }
-}
-
-/**Function*************************************************************
-
- Synopsis [Transforms the cube into the result of distance-1 merging.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Esop_CubesTransformOr( Esop_Cube_t * pCube, Esop_Cube_t * pDist )
-{
- int w;
- for ( w = 0; w < (int)pCube->nWords; w++ )
- pCube->uData[w] |= pDist->uData[w];
-}
-
-
-
-/**Function*************************************************************
-
- Synopsis [Sorts the cover in the increasing number of literals.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Esop_CoverExpandRemoveEqual( Esop_Man_t * p, Esop_Cube_t * pCover )
-{
- Esop_Cube_t * pCube, * pCube2, * pThis;
- if ( pCover == NULL )
- {
- Esop_ManClean( p, p->nVars );
- return;
- }
- Esop_ManClean( p, pCover->nVars );
- Esop_CoverForEachCubeSafe( pCover, pCube, pCube2 )
- {
- // go through the linked list
- Esop_CoverForEachCube( p->ppStore[pCube->nLits], pThis )
- if ( Esop_CubesAreEqual( pCube, pThis ) )
- {
- Esop_CubeRecycle( p, pCube );
- break;
- }
- if ( pThis != NULL )
- continue;
- pCube->pNext = p->ppStore[pCube->nLits];
- p->ppStore[pCube->nLits] = pCube;
- p->nCubes++;
- }
-}
-
-/**Function*************************************************************
-
- Synopsis [Returns 1 if the given cube is contained in one of the cubes of the cover.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Esop_CoverContainsCube( Esop_Man_t * p, Esop_Cube_t * pCube )
-{
- Esop_Cube_t * pThis;
- int i;
-/*
- // this cube cannot be equal to any cube
- Esop_CoverForEachCube( p->ppStore[pCube->nLits], pThis )
- {
- if ( Esop_CubesAreEqual( pCube, pThis ) )
- {
- Esop_CubeWrite( stdout, pCube );
- assert( 0 );
- }
- }
-*/
- // try to find a containing cube
- for ( i = 0; i <= (int)pCube->nLits; i++ )
- Esop_CoverForEachCube( p->ppStore[i], pThis )
- {
- // skip the bubble
- if ( pThis != p->pBubble && Esop_CubeIsContained( pThis, pCube ) )
- return 1;
- }
- return 0;
-}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/temp/esop/esopMan.c b/src/temp/esop/esopMan.c
deleted file mode 100644
index 5c411349..00000000
--- a/src/temp/esop/esopMan.c
+++ /dev/null
@@ -1,117 +0,0 @@
-/**CFile****************************************************************
-
- FileName [esopMan.c]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [Cover manipulation package.]
-
- Synopsis [SOP manipulation.]
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - June 20, 2005.]
-
- Revision [$Id: esopMan.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "esop.h"
-
-////////////////////////////////////////////////////////////////////////
-/// DECLARATIONS ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis [Starts the minimization manager.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Esop_Man_t * Esop_ManAlloc( int nVars )
-{
- Esop_Man_t * pMan;
- // start the manager
- pMan = ALLOC( Esop_Man_t, 1 );
- memset( pMan, 0, sizeof(Esop_Man_t) );
- pMan->nVars = nVars;
- pMan->nWords = Esop_BitWordNum( nVars * 2 );
- pMan->pMemMan1 = Mem_FixedStart( sizeof(Esop_Cube_t) + sizeof(unsigned) * (1 - 1) );
- pMan->pMemMan2 = Mem_FixedStart( sizeof(Esop_Cube_t) + sizeof(unsigned) * (2 - 1) );
- pMan->pMemMan4 = Mem_FixedStart( sizeof(Esop_Cube_t) + sizeof(unsigned) * (4 - 1) );
- pMan->pMemMan8 = Mem_FixedStart( sizeof(Esop_Cube_t) + sizeof(unsigned) * (8 - 1) );
- // allocate storage for the temporary cover
- pMan->ppStore = ALLOC( Esop_Cube_t *, pMan->nVars + 1 );
- // create tautology cubes
- Esop_ManClean( pMan, nVars );
- pMan->pOne0 = Esop_CubeAlloc( pMan );
- pMan->pOne1 = Esop_CubeAlloc( pMan );
- pMan->pTemp = Esop_CubeAlloc( pMan );
- pMan->pBubble = Esop_CubeAlloc( pMan ); pMan->pBubble->uData[0] = 0;
- // create trivial cubes
- Esop_ManClean( pMan, 1 );
- pMan->pTriv0 = Esop_CubeAllocVar( pMan, 0, 0 );
- pMan->pTriv1 = Esop_CubeAllocVar( pMan, 0, 0 );
- Esop_ManClean( pMan, nVars );
- return pMan;
-}
-
-/**Function*************************************************************
-
- Synopsis [Cleans the minimization manager.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Esop_ManClean( Esop_Man_t * p, int nSupp )
-{
- // set the size of the cube manager
- p->nVars = nSupp;
- p->nWords = Esop_BitWordNum(2*nSupp);
- // clean the storage
- memset( p->ppStore, 0, sizeof(Esop_Cube_t *) * (nSupp + 1) );
- p->nCubes = 0;
-}
-
-/**Function*************************************************************
-
- Synopsis [Stops the minimization manager.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Esop_ManFree( Esop_Man_t * p )
-{
- Mem_FixedStop ( p->pMemMan1, 0 );
- Mem_FixedStop ( p->pMemMan2, 0 );
- Mem_FixedStop ( p->pMemMan4, 0 );
- Mem_FixedStop ( p->pMemMan8, 0 );
- free( p->ppStore );
- free( p );
-}
-
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/temp/esop/esopMin.c b/src/temp/esop/esopMin.c
deleted file mode 100644
index 7a460f8e..00000000
--- a/src/temp/esop/esopMin.c
+++ /dev/null
@@ -1,299 +0,0 @@
-/**CFile****************************************************************
-
- FileName [esopMin.c]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [Cover manipulation package.]
-
- Synopsis [ESOP manipulation.]
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - June 20, 2005.]
-
- Revision [$Id: esopMin.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "esop.h"
-
-////////////////////////////////////////////////////////////////////////
-/// DECLARATIONS ///
-////////////////////////////////////////////////////////////////////////
-
-static void Esop_EsopRewrite( Esop_Man_t * p );
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis [ESOP minimization procedure.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Esop_EsopMinimize( Esop_Man_t * p )
-{
- int nCubesInit, nCubesOld, nIter;
- if ( p->nCubes < 3 )
- return;
- nIter = 0;
- nCubesInit = p->nCubes;
- do {
- nCubesOld = p->nCubes;
- Esop_EsopRewrite( p );
- nIter++;
- }
- while ( 100.0*(nCubesOld - p->nCubes)/nCubesOld > 3.0 );
-
-// printf( "%d:%d->%d ", nIter, nCubesInit, p->nCubes );
-}
-
-/**Function*************************************************************
-
- Synopsis [Performs one round of rewriting using distance 2 cubes.]
-
- Description [The weakness of this procedure is that it tries each cube
- with only one distance-2 cube. If this pair does not lead to improvement
- the cube is inserted into the cover anyhow, and we try another pair.
- A possible improvement would be to try this cube with all distance-2
- cubes, until an improvement is found, or until all such cubes are tried.]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Esop_EsopRewrite( Esop_Man_t * p )
-{
- Esop_Cube_t * pCube, ** ppPrev;
- Esop_Cube_t * pThis, ** ppPrevT;
- int v00, v01, v10, v11, Var0, Var1, Index, nCubesOld;
- int nPairs = 0;
-
- // insert the bubble before the first cube
- p->pBubble->pNext = p->ppStore[0];
- p->ppStore[0] = p->pBubble;
- p->pBubble->nLits = 0;
-
- // go through the cubes
- while ( 1 )
- {
- // get the index of the bubble
- Index = p->pBubble->nLits;
-
- // find the bubble
- Esop_CoverForEachCubePrev( p->ppStore[Index], pCube, ppPrev )
- if ( pCube == p->pBubble )
- break;
- assert( pCube == p->pBubble );
-
- // remove the bubble, get the next cube after the bubble
- *ppPrev = p->pBubble->pNext;
- pCube = p->pBubble->pNext;
- if ( pCube == NULL )
- for ( Index++; Index <= p->nVars; Index++ )
- if ( p->ppStore[Index] )
- {
- ppPrev = &(p->ppStore[Index]);
- pCube = p->ppStore[Index];
- break;
- }
- // stop if there is no more cubes
- if ( pCube == NULL )
- break;
-
- // find the first dist2 cube
- Esop_CoverForEachCubePrev( pCube->pNext, pThis, ppPrevT )
- if ( Esop_CubesDistTwo( pCube, pThis, &Var0, &Var1 ) )
- break;
- if ( pThis == NULL && Index < p->nVars )
- Esop_CoverForEachCubePrev( p->ppStore[Index+1], pThis, ppPrevT )
- if ( Esop_CubesDistTwo( pCube, pThis, &Var0, &Var1 ) )
- break;
- if ( pThis == NULL && Index < p->nVars - 1 )
- Esop_CoverForEachCubePrev( p->ppStore[Index+2], pThis, ppPrevT )
- if ( Esop_CubesDistTwo( pCube, pThis, &Var0, &Var1 ) )
- break;
- // continue if there is no dist2 cube
- if ( pThis == NULL )
- {
- // insert the bubble after the cube
- p->pBubble->pNext = pCube->pNext;
- pCube->pNext = p->pBubble;
- p->pBubble->nLits = pCube->nLits;
- continue;
- }
- nPairs++;
-
- // remove the cubes, insert the bubble instead of pCube
- *ppPrevT = pThis->pNext;
- *ppPrev = p->pBubble;
- p->pBubble->pNext = pCube->pNext;
- p->pBubble->nLits = pCube->nLits;
- p->nCubes -= 2;
-
- // Exorlink-2:
- // A{v00} B{v01} + A{v10} B{v11} =
- // A{v00+v10} B{v01} + A{v10} B{v01+v11} =
- // A{v00} B{v01+v11} + A{v00+v10} B{v11}
-
- // save the dist2 parameters
- v00 = Esop_CubeGetVar( pCube, Var0 );
- v01 = Esop_CubeGetVar( pCube, Var1 );
- v10 = Esop_CubeGetVar( pThis, Var0 );
- v11 = Esop_CubeGetVar( pThis, Var1 );
-//printf( "\n" );
-//Esop_CubeWrite( stdout, pCube );
-//Esop_CubeWrite( stdout, pThis );
-
- // derive the first pair of resulting cubes
- Esop_CubeXorVar( pCube, Var0, v10 );
- pCube->nLits -= (v00 != 3);
- pCube->nLits += ((v00 ^ v10) != 3);
- Esop_CubeXorVar( pThis, Var1, v01 );
- pThis->nLits -= (v11 != 3);
- pThis->nLits += ((v01 ^ v11) != 3);
-
- // add the cubes
- nCubesOld = p->nCubes;
- Esop_EsopAddCube( p, pCube );
- Esop_EsopAddCube( p, pThis );
- // check if the cubes were absorbed
- if ( p->nCubes < nCubesOld + 2 )
- continue;
-
- // pull out both cubes
- assert( pThis == p->ppStore[pThis->nLits] );
- p->ppStore[pThis->nLits] = pThis->pNext;
- assert( pCube == p->ppStore[pCube->nLits] );
- p->ppStore[pCube->nLits] = pCube->pNext;
- p->nCubes -= 2;
-
- // derive the second pair of resulting cubes
- Esop_CubeXorVar( pCube, Var0, v10 );
- pCube->nLits -= ((v00 ^ v10) != 3);
- pCube->nLits += (v00 != 3);
- Esop_CubeXorVar( pCube, Var1, v11 );
- pCube->nLits -= (v01 != 3);
- pCube->nLits += ((v01 ^ v11) != 3);
-
- Esop_CubeXorVar( pThis, Var0, v00 );
- pThis->nLits -= (v10 != 3);
- pThis->nLits += ((v00 ^ v10) != 3);
- Esop_CubeXorVar( pThis, Var1, v01 );
- pThis->nLits -= ((v01 ^ v11) != 3);
- pThis->nLits += (v11 != 3);
-
- // add them anyhow
- Esop_EsopAddCube( p, pCube );
- Esop_EsopAddCube( p, pThis );
- }
-// printf( "Pairs = %d ", nPairs );
-}
-
-/**Function*************************************************************
-
- Synopsis [Adds the cube to storage.]
-
- Description [Returns 0 if the cube is added or removed. Returns 1
- if the cube is glued with some other cube and has to be added again.
- Do not forget to clean the storage!]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-int Esop_EsopAddCubeInt( Esop_Man_t * p, Esop_Cube_t * pCube )
-{
- Esop_Cube_t * pThis, ** ppPrev;
- // try to find the identical cube
- Esop_CoverForEachCubePrev( p->ppStore[pCube->nLits], pThis, ppPrev )
- {
- if ( Esop_CubesAreEqual( pCube, pThis ) )
- {
- *ppPrev = pThis->pNext;
- Esop_CubeRecycle( p, pCube );
- Esop_CubeRecycle( p, pThis );
- p->nCubes--;
- return 0;
- }
- }
- // find a distance-1 cube if it exists
- if ( pCube->nLits < pCube->nVars )
- Esop_CoverForEachCubePrev( p->ppStore[pCube->nLits+1], pThis, ppPrev )
- {
- if ( Esop_CubesDistOne( pCube, pThis, p->pTemp ) )
- {
- *ppPrev = pThis->pNext;
- Esop_CubesTransform( pCube, pThis, p->pTemp );
- pCube->nLits++;
- Esop_CubeRecycle( p, pThis );
- p->nCubes--;
- return 1;
- }
- }
- Esop_CoverForEachCubePrev( p->ppStore[pCube->nLits], pThis, ppPrev )
- {
- if ( Esop_CubesDistOne( pCube, pThis, p->pTemp ) )
- {
- *ppPrev = pThis->pNext;
- Esop_CubesTransform( pCube, pThis, p->pTemp );
- pCube->nLits--;
- Esop_CubeRecycle( p, pThis );
- p->nCubes--;
- return 1;
- }
- }
- if ( pCube->nLits > 0 )
- Esop_CoverForEachCubePrev( p->ppStore[pCube->nLits-1], pThis, ppPrev )
- {
- if ( Esop_CubesDistOne( pCube, pThis, p->pTemp ) )
- {
- *ppPrev = pThis->pNext;
- Esop_CubesTransform( pCube, pThis, p->pTemp );
- Esop_CubeRecycle( p, pThis );
- p->nCubes--;
- return 1;
- }
- }
- // add the cube
- pCube->pNext = p->ppStore[pCube->nLits];
- p->ppStore[pCube->nLits] = pCube;
- p->nCubes++;
- return 0;
-}
-
-/**Function*************************************************************
-
- Synopsis [Adds the cube to storage.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Esop_EsopAddCube( Esop_Man_t * p, Esop_Cube_t * pCube )
-{
- assert( pCube != p->pBubble );
- assert( (int)pCube->nLits == Esop_CubeCountLits(pCube) );
- while ( Esop_EsopAddCubeInt( p, pCube ) );
-}
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/temp/esop/esopUtil.c b/src/temp/esop/esopUtil.c
deleted file mode 100644
index 7230cc87..00000000
--- a/src/temp/esop/esopUtil.c
+++ /dev/null
@@ -1,277 +0,0 @@
-/**CFile****************************************************************
-
- FileName [esopUtil.c]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [Cover manipulation package.]
-
- Synopsis [Utilities.]
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - June 20, 2005.]
-
- Revision [$Id: esopUtil.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "esop.h"
-
-////////////////////////////////////////////////////////////////////////
-/// DECLARATIONS ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Esop_CubeWrite( FILE * pFile, Esop_Cube_t * pCube )
-{
- int i;
- assert( (int)pCube->nLits == Esop_CubeCountLits(pCube) );
- for ( i = 0; i < (int)pCube->nVars; i++ )
- if ( Esop_CubeHasBit(pCube, i*2) )
- {
- if ( Esop_CubeHasBit(pCube, i*2+1) )
- fprintf( pFile, "-" );
- else
- fprintf( pFile, "0" );
- }
- else
- {
- if ( Esop_CubeHasBit(pCube, i*2+1) )
- fprintf( pFile, "1" );
- else
- fprintf( pFile, "?" );
- }
- fprintf( pFile, " 1\n" );
-// fprintf( pFile, " %d\n", pCube->nLits );
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Esop_CoverWrite( FILE * pFile, Esop_Cube_t * pCover )
-{
- Esop_Cube_t * pCube;
- Esop_CoverForEachCube( pCover, pCube )
- Esop_CubeWrite( pFile, pCube );
- printf( "\n" );
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Esop_CoverWriteStore( FILE * pFile, Esop_Man_t * p )
-{
- Esop_Cube_t * pCube;
- int i;
- for ( i = 0; i <= p->nVars; i++ )
- {
- Esop_CoverForEachCube( p->ppStore[i], pCube )
- {
- printf( "%2d : ", i );
- if ( pCube == p->pBubble )
- {
- printf( "Bubble\n" );
- continue;
- }
- Esop_CubeWrite( pFile, pCube );
- }
- }
- printf( "\n" );
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Esop_CoverWriteFile( Esop_Cube_t * pCover, char * pName, int fEsop )
-{
- char Buffer[1000];
- Esop_Cube_t * pCube;
- FILE * pFile;
- int i;
- sprintf( Buffer, "%s.%s", pName, fEsop? "esop" : "pla" );
- for ( i = strlen(Buffer) - 1; i >= 0; i-- )
- if ( Buffer[i] == '<' || Buffer[i] == '>' )
- Buffer[i] = '_';
- pFile = fopen( Buffer, "w" );
- fprintf( pFile, "# %s cover for output %s generated by ABC\n", fEsop? "ESOP":"SOP", pName );
- fprintf( pFile, ".i %d\n", pCover? pCover->nVars : 0 );
- fprintf( pFile, ".o %d\n", 1 );
- fprintf( pFile, ".p %d\n", Esop_CoverCountCubes(pCover) );
- if ( fEsop ) fprintf( pFile, ".type esop\n" );
- Esop_CoverForEachCube( pCover, pCube )
- Esop_CubeWrite( pFile, pCube );
- fprintf( pFile, ".e\n" );
- fclose( pFile );
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Esop_CoverCheck( Esop_Man_t * p )
-{
- Esop_Cube_t * pCube;
- int i;
- for ( i = 0; i <= p->nVars; i++ )
- Esop_CoverForEachCube( p->ppStore[i], pCube )
- assert( i == (int)pCube->nLits );
-}
-
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-int Esop_CubeCheck( Esop_Cube_t * pCube )
-{
- int i;
- for ( i = 0; i < (int)pCube->nVars; i++ )
- if ( Esop_CubeGetVar( pCube, i ) == 0 )
- return 0;
- return 1;
-}
-
-/**Function*************************************************************
-
- Synopsis [Converts the cover from the sorted structure.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Esop_Cube_t * Esop_CoverCollect( Esop_Man_t * p, int nSuppSize )
-{
- Esop_Cube_t * pCov = NULL, ** ppTail = &pCov;
- Esop_Cube_t * pCube, * pCube2;
- int i;
- for ( i = 0; i <= nSuppSize; i++ )
- {
- Esop_CoverForEachCubeSafe( p->ppStore[i], pCube, pCube2 )
- {
- assert( i == (int)pCube->nLits );
- *ppTail = pCube;
- ppTail = &pCube->pNext;
- assert( pCube->uData[0] ); // not a bubble
- }
- }
- *ppTail = NULL;
- return pCov;
-}
-
-/**Function*************************************************************
-
- Synopsis [Sorts the cover in the increasing number of literals.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Esop_CoverExpand( Esop_Man_t * p, Esop_Cube_t * pCover )
-{
- Esop_Cube_t * pCube, * pCube2;
- Esop_ManClean( p, p->nVars );
- Esop_CoverForEachCubeSafe( pCover, pCube, pCube2 )
- {
- pCube->pNext = p->ppStore[pCube->nLits];
- p->ppStore[pCube->nLits] = pCube;
- p->nCubes++;
- }
-}
-
-/**Function*************************************************************
-
- Synopsis [Sorts the cover in the increasing number of literals.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-int Esop_CoverSuppVarNum( Esop_Man_t * p, Esop_Cube_t * pCover )
-{
- Esop_Cube_t * pCube;
- int i, Counter;
- if ( pCover == NULL )
- return 0;
- // clean the cube
- for ( i = 0; i < (int)pCover->nWords; i++ )
- p->pTemp->uData[i] = ~((unsigned)0);
- // add the bit data
- Esop_CoverForEachCube( pCover, pCube )
- for ( i = 0; i < (int)pCover->nWords; i++ )
- p->pTemp->uData[i] &= pCube->uData[i];
- // count the vars
- Counter = 0;
- for ( i = 0; i < (int)pCover->nVars; i++ )
- Counter += ( Esop_CubeGetVar(p->pTemp, i) != 3 );
- return Counter;
-}
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/temp/esop/module.make b/src/temp/esop/module.make
deleted file mode 100644
index 1003ccc1..00000000
--- a/src/temp/esop/module.make
+++ /dev/null
@@ -1,3 +0,0 @@
-SRC += src/temp/esop/esopMan.c \
- src/temp/esop/esopMin.c \
- src/temp/esop/esopUtil.c
diff --git a/src/temp/ivy/ivy.h b/src/temp/ivy/ivy.h
index d9c17d80..e7c9bc2e 100644
--- a/src/temp/ivy/ivy.h
+++ b/src/temp/ivy/ivy.h
@@ -129,9 +129,12 @@ struct Ivy_Man_t_
struct Ivy_FraigParams_t_
{
int nSimWords; // the number of words in the simulation info
- double SimSatur; // the ratio of refined classes when saturation is reached
+ double dSimSatur; // the ratio of refined classes when saturation is reached
int fPatScores; // enables simulation pattern scoring
int MaxScore; // max score after which resimulation is used
+ double dActConeRatio; // the ratio of cone to be bumped
+ double dActConeBumpMax; // the largest bump in activity
+ int fProve; // prove the miter outputs
int fVerbose; // verbose output
int nBTLimitNode; // conflict limit at a node
int nBTLimitMiter; // conflict limit at an output
@@ -445,14 +448,14 @@ extern void Ivy_ObjCollectFanouts( Ivy_Man_t * p, Ivy_Obj_t * pObj, V
extern Ivy_Obj_t * Ivy_ObjReadFirstFanout( Ivy_Man_t * p, Ivy_Obj_t * pObj );
extern int Ivy_ObjFanoutNum( Ivy_Man_t * p, Ivy_Obj_t * pObj );
/*=== ivyFastMap.c =============================================================*/
-extern void Ivy_FastMapPerform( Ivy_Man_t * pAig, int nLimit );
+extern void Ivy_FastMapPerform( Ivy_Man_t * pAig, int nLimit, int fRecovery, int fVerbose );
extern void Ivy_FastMapStop( Ivy_Man_t * pAig );
extern void Ivy_FastMapReadSupp( Ivy_Man_t * pAig, Ivy_Obj_t * pObj, Vec_Int_t * vLeaves );
extern void Ivy_FastMapReverseLevel( Ivy_Man_t * pAig );
/*=== ivyFraig.c ==========================================================*/
-extern Ivy_Man_t * Ivy_FraigMiter( Ivy_Man_t * pManAig, Ivy_FraigParams_t * pParams );
+extern int Ivy_FraigProve( Ivy_Man_t ** ppManAig, void * pPars );
extern Ivy_Man_t * Ivy_FraigPerform( Ivy_Man_t * pManAig, Ivy_FraigParams_t * pParams );
-extern Ivy_Man_t * Ivy_FraigProve( Ivy_Man_t * pManAig, Ivy_FraigParams_t * pParams );
+extern Ivy_Man_t * Ivy_FraigMiter( Ivy_Man_t * pManAig, Ivy_FraigParams_t * pParams );
extern void Ivy_FraigParamsDefault( Ivy_FraigParams_t * pParams );
/*=== ivyHaig.c ==========================================================*/
extern void Ivy_ManHaigStart( Ivy_Man_t * p, int fVerbose );
@@ -505,6 +508,7 @@ extern Ivy_Obj_t * Ivy_Latch( Ivy_Man_t * p, Ivy_Obj_t * pObj, Ivy_Init_t In
/*=== ivyResyn.c =========================================================*/
extern Ivy_Man_t * Ivy_ManResyn0( Ivy_Man_t * p, int fUpdateLevel, int fVerbose );
extern Ivy_Man_t * Ivy_ManResyn( Ivy_Man_t * p, int fUpdateLevel, int fVerbose );
+extern Ivy_Man_t * Ivy_ManRwsat( Ivy_Man_t * pMan, int fVerbose );
/*=== ivyRewrite.c =========================================================*/
extern int Ivy_ManSeqRewrite( Ivy_Man_t * p, int fUpdateLevel, int fUseZeroCost );
extern int Ivy_ManRewriteAlg( Ivy_Man_t * p, int fUpdateLevel, int fUseZeroCost );
@@ -524,6 +528,7 @@ extern void Ivy_TableProfile( Ivy_Man_t * p );
extern void Ivy_ManIncrementTravId( Ivy_Man_t * p );
extern void Ivy_ManCleanTravId( Ivy_Man_t * p );
extern unsigned * Ivy_ManCutTruth( Ivy_Man_t * p, Ivy_Obj_t * pRoot, Vec_Int_t * vLeaves, Vec_Int_t * vNodes, Vec_Int_t * vTruth );
+extern void Ivy_ManCollectCut( Ivy_Man_t * p, Ivy_Obj_t * pRoot, Vec_Int_t * vLeaves, Vec_Int_t * vNodes );
extern Vec_Int_t * Ivy_ManLatches( Ivy_Man_t * p );
extern int Ivy_ManLevels( Ivy_Man_t * p );
extern void Ivy_ManResetLevels( Ivy_Man_t * p );
diff --git a/src/temp/ivy/ivyFastMap.c b/src/temp/ivy/ivyFastMap.c
index 39c632c7..c4a043f2 100644
--- a/src/temp/ivy/ivyFastMap.c
+++ b/src/temp/ivy/ivyFastMap.c
@@ -64,7 +64,7 @@ static inline Ivy_Supp_t * Ivy_ObjSuppStart( Ivy_Man_t * pAig, Ivy_Obj_t * pObj
return pSupp;
}
-static int Ivy_FastMapPrint( Ivy_Man_t * pAig, int Time );
+static void Ivy_FastMapPrint( Ivy_Man_t * pAig, int Delay, int Area, int Time, char * pStr );
static int Ivy_FastMapDelay( Ivy_Man_t * pAig );
static int Ivy_FastMapArea( Ivy_Man_t * pAig );
static void Ivy_FastMapNode( Ivy_Man_t * pAig, Ivy_Obj_t * pObj, int nLimit );
@@ -99,11 +99,11 @@ extern int s_MappingMem;
SeeAlso []
***********************************************************************/
-void Ivy_FastMapPerform( Ivy_Man_t * pAig, int nLimit )
+void Ivy_FastMapPerform( Ivy_Man_t * pAig, int nLimit, int fRecovery, int fVerbose )
{
Ivy_SuppMan_t * pMan;
Ivy_Obj_t * pObj;
- int i, Delay, clk, clkTotal = clock();
+ int i, Delay, Area, clk, clkTotal = clock();
// start the memory for supports
pMan = ALLOC( Ivy_SuppMan_t, 1 );
memset( pMan, 0, sizeof(Ivy_SuppMan_t) );
@@ -123,32 +123,43 @@ clk = clock();
Ivy_ManForEachNode( pAig, pObj, i )
Ivy_FastMapNode( pAig, pObj, nLimit );
// find the best arrival time and area
- printf( "Delay oriented mapping: " );
- Delay = Ivy_FastMapPrint( pAig, clock() - clk );
+ Delay = Ivy_FastMapDelay( pAig );
+ Area = Ivy_FastMapArea(pAig);
+ if ( fVerbose )
+ Ivy_FastMapPrint( pAig, Delay, Area, clock() - clk, "Delay oriented mapping: " );
// 2-1-2 (doing 2-1-2-1-2 improves 0.5%)
+ if ( fRecovery )
+ {
clk = clock();
Ivy_FastMapRequired( pAig, Delay, 0 );
// remap the nodes
Ivy_FastMapRecover( pAig, nLimit );
- printf( "Area recovery 2 : " );
- Delay = Ivy_FastMapPrint( pAig, clock() - clk );
+ Delay = Ivy_FastMapDelay( pAig );
+ Area = Ivy_FastMapArea(pAig);
+ if ( fVerbose )
+ Ivy_FastMapPrint( pAig, Delay, Area, clock() - clk, "Area recovery 2 : " );
clk = clock();
Ivy_FastMapRequired( pAig, Delay, 0 );
// iterate through all nodes in the topological order
Ivy_ManForEachNode( pAig, pObj, i )
Ivy_FastMapNodeArea( pAig, pObj, nLimit );
- printf( "Area recovery 1 : " );
- Delay = Ivy_FastMapPrint( pAig, clock() - clk );
+ Delay = Ivy_FastMapDelay( pAig );
+ Area = Ivy_FastMapArea(pAig);
+ if ( fVerbose )
+ Ivy_FastMapPrint( pAig, Delay, Area, clock() - clk, "Area recovery 1 : " );
clk = clock();
Ivy_FastMapRequired( pAig, Delay, 0 );
// remap the nodes
Ivy_FastMapRecover( pAig, nLimit );
- printf( "Area recovery 2 : " );
- Delay = Ivy_FastMapPrint( pAig, clock() - clk );
+ Delay = Ivy_FastMapDelay( pAig );
+ Area = Ivy_FastMapArea(pAig);
+ if ( fVerbose )
+ Ivy_FastMapPrint( pAig, Delay, Area, clock() - clk, "Area recovery 2 : " );
+ }
s_MappingTime = clock() - clkTotal;
@@ -196,14 +207,10 @@ void Ivy_FastMapStop( Ivy_Man_t * pAig )
SeeAlso []
***********************************************************************/
-int Ivy_FastMapPrint( Ivy_Man_t * pAig, int Time )
+void Ivy_FastMapPrint( Ivy_Man_t * pAig, int Delay, int Area, int Time, char * pStr )
{
- int Delay, Area;
- Delay = Ivy_FastMapDelay( pAig );
- Area = Ivy_FastMapArea( pAig );
- printf( "Delay = %3d. Area = %6d. ", Delay, Area );
+ printf( "%s : Delay = %3d. Area = %6d. ", pStr, Delay, Area );
PRT( "Time", Time );
- return Delay;
}
/**Function*************************************************************
diff --git a/src/temp/ivy/ivyFraig.c b/src/temp/ivy/ivyFraig.c
index 88c726c7..9c729b23 100644
--- a/src/temp/ivy/ivyFraig.c
+++ b/src/temp/ivy/ivyFraig.c
@@ -98,6 +98,38 @@ struct Ivy_FraigMan_t_
int time2;
};
+typedef struct Prove_ParamsStruct_t_ Prove_Params_t;
+struct Prove_ParamsStruct_t_
+{
+ // general parameters
+ int fUseFraiging; // enables fraiging
+ int fUseRewriting; // enables rewriting
+ int fUseBdds; // enables BDD construction when other methods fail
+ int fVerbose; // prints verbose stats
+ // iterations
+ int nItersMax; // the number of iterations
+ // mitering
+ int nMiteringLimitStart; // starting mitering limit
+ float nMiteringLimitMulti; // multiplicative coefficient to increase the limit in each iteration
+ // rewriting
+ int nRewritingLimitStart; // the number of rewriting iterations
+ float nRewritingLimitMulti; // multiplicative coefficient to increase the limit in each iteration
+ // fraiging
+ int nFraigingLimitStart; // starting backtrack(conflict) limit
+ float nFraigingLimitMulti; // multiplicative coefficient to increase the limit in each iteration
+ // last-gasp BDD construction
+ int nBddSizeLimit; // the number of BDD nodes when construction is aborted
+ int fBddReorder; // enables dynamic BDD variable reordering
+ // last-gasp mitering
+ int nMiteringLimitLast; // final mitering limit
+ // global SAT solver limits
+ sint64 nTotalBacktrackLimit; // global limit on the number of backtracks
+ sint64 nTotalInspectLimit; // global limit on the number of clause inspects
+ // global resources applied
+ sint64 nTotalBacktracksMade; // the total number of backtracks made
+ sint64 nTotalInspectsMade; // the total number of inspects made
+};
+
static inline Ivy_FraigSim_t * Ivy_ObjSim( Ivy_Obj_t * pObj ) { return (Ivy_FraigSim_t *)pObj->pFanout; }
static inline Ivy_Obj_t * Ivy_ObjClassNodeLast( Ivy_Obj_t * pObj ) { return pObj->pNextFan0; }
static inline Ivy_Obj_t * Ivy_ObjClassNodeRepr( Ivy_Obj_t * pObj ) { return pObj->pNextFan0; }
@@ -146,6 +178,7 @@ static inline unsigned Ivy_ObjRandomSim() { return (ran
static Ivy_FraigMan_t * Ivy_FraigStart( Ivy_Man_t * pManAig, Ivy_FraigParams_t * pParams );
static Ivy_FraigMan_t * Ivy_FraigStartSimple( Ivy_Man_t * pManAig, Ivy_FraigParams_t * pParams );
+static Ivy_Man_t * Ivy_FraigPerform_int( Ivy_Man_t * pManAig, Ivy_FraigParams_t * pParams, sint64 * pnSatConfs, sint64 * pnSatInspects );
static void Ivy_FraigPrint( Ivy_FraigMan_t * p );
static void Ivy_FraigStop( Ivy_FraigMan_t * p );
static void Ivy_FraigSimulate( Ivy_FraigMan_t * p );
@@ -154,10 +187,12 @@ static Ivy_Obj_t * Ivy_FraigAnd( Ivy_FraigMan_t * p, Ivy_Obj_t * pObjOld );
static int Ivy_FraigNodesAreEquiv( Ivy_FraigMan_t * p, Ivy_Obj_t * pObj0, Ivy_Obj_t * pObj1 );
static int Ivy_FraigNodeIsConst( Ivy_FraigMan_t * p, Ivy_Obj_t * pObj );
static void Ivy_FraigNodeAddToSolver( Ivy_FraigMan_t * p, Ivy_Obj_t * pObj0, Ivy_Obj_t * pObj1 );
-static int Ivy_FraigMarkConeSetActivity( Ivy_FraigMan_t * p, Ivy_Obj_t * pOld, Ivy_Obj_t * pNew );
+static int Ivy_FraigSetActivityFactors( Ivy_FraigMan_t * p, Ivy_Obj_t * pOld, Ivy_Obj_t * pNew );
static void Ivy_FraigAddToPatScores( Ivy_FraigMan_t * p, Ivy_Obj_t * pClass, Ivy_Obj_t * pClassNew );
-static int Ivy_FraigMiterStatus( Ivy_FraigMan_t * p );
+static int Ivy_FraigMiterStatus( Ivy_Man_t * pMan );
static void Ivy_FraigMiterProve( Ivy_FraigMan_t * p );
+static void Ivy_FraigMiterPrint( Ivy_Man_t * pNtk, char * pString, int clk, int fVerbose );
+static int * Ivy_FraigCreateModel( Ivy_FraigMan_t * p );
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
@@ -165,7 +200,7 @@ static void Ivy_FraigMiterProve( Ivy_FraigMan_t * p );
/**Function*************************************************************
- Synopsis [Performs fraiging of the initial AIG.]
+ Synopsis [Sets the default solving parameters.]
Description []
@@ -174,11 +209,184 @@ static void Ivy_FraigMiterProve( Ivy_FraigMan_t * p );
SeeAlso []
***********************************************************************/
-Ivy_Man_t * Ivy_FraigProve( Ivy_Man_t * pManAig, Ivy_FraigParams_t * pParams )
+void Ivy_FraigParamsDefault( Ivy_FraigParams_t * pParams )
{
+ memset( pParams, 0, sizeof(Ivy_FraigParams_t) );
+ pParams->nSimWords = 32; // the number of words in the simulation info
+ pParams->dSimSatur = 0.005; // the ratio of refined classes when saturation is reached
+ pParams->fPatScores = 0; // enables simulation pattern scoring
+ pParams->MaxScore = 25; // max score after which resimulation is used
+// pParams->dActConeRatio = 0.05; // the ratio of cone to be bumped
+// pParams->dActConeBumpMax = 5.0; // the largest bump of activity
+ pParams->dActConeRatio = 0.3; // the ratio of cone to be bumped
+ pParams->dActConeBumpMax = 10.0; // the largest bump of activity
+
+ pParams->nBTLimitNode = 100; // conflict limit at a node
+ pParams->nBTLimitMiter = 500000; // conflict limit at an output
+ pParams->nBTLimitGlobal = 0; // conflict limit global
+ pParams->nInsLimitNode = 0; // inspection limit at a node
+ pParams->nInsLimitMiter = 0; // inspection limit at an output
+ pParams->nInsLimitGlobal = 0; // inspection limit global
+}
+
+/**Function*************************************************************
+
+ Synopsis [Performs combinational equivalence checking for the miter.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+int Ivy_FraigProve( Ivy_Man_t ** ppManAig, void * pPars )
+{
+ Prove_Params_t * pParams = pPars;
+ Ivy_FraigParams_t Params, * pIvyParams = &Params;
+ Ivy_Man_t * pManAig, * pManTemp;
+ int RetValue, nIter, Counter, clk, timeStart = clock();
+ sint64 nSatConfs, nSatInspects, nInspectLimit;
+
+ // start the network and parameters
+ pManAig = *ppManAig;
+ Ivy_FraigParamsDefault( pIvyParams );
+ pIvyParams->fVerbose = pParams->fVerbose;
+ pIvyParams->fProve = 1;
+
+ if ( pParams->fVerbose )
+ {
+ printf( "RESOURCE LIMITS: Iterations = %d. Rewriting = %s. Fraiging = %s.\n",
+ pParams->nItersMax, pParams->fUseRewriting? "yes":"no", pParams->fUseFraiging? "yes":"no" );
+ printf( "Mitering = %d (%3.1f). Rewriting = %d (%3.1f). Fraiging = %d (%3.1f).\n",
+ pParams->nMiteringLimitStart, pParams->nMiteringLimitMulti,
+ pParams->nRewritingLimitStart, pParams->nRewritingLimitMulti,
+ pParams->nFraigingLimitStart, pParams->nFraigingLimitMulti );
+ printf( "Mitering last = %d.\n",
+ pParams->nMiteringLimitLast );
+ }
+
+ // if SAT only, solve without iteration
+ if ( !pParams->fUseRewriting && !pParams->fUseFraiging )
+ {
+ clk = clock();
+ pIvyParams->nBTLimitMiter = pParams->nMiteringLimitLast / Ivy_ManPoNum(pManAig);
+ pManAig = Ivy_FraigMiter( pManTemp = pManAig, pIvyParams ); Ivy_ManStop( pManTemp );
+ RetValue = Ivy_FraigMiterStatus( pManAig );
+ Ivy_FraigMiterPrint( pManAig, "SAT solving", clk, pParams->fVerbose );
+ *ppManAig = pManAig;
+ return RetValue;
+ }
+
+ if ( Ivy_ManNodeNum(pManAig) < 500 )
+ {
+ // run the first mitering
+ clk = clock();
+ pIvyParams->nBTLimitMiter = pParams->nMiteringLimitStart / Ivy_ManPoNum(pManAig);
+ pManAig = Ivy_FraigMiter( pManTemp = pManAig, pIvyParams ); Ivy_ManStop( pManTemp );
+ RetValue = Ivy_FraigMiterStatus( pManAig );
+ Ivy_FraigMiterPrint( pManAig, "SAT solving", clk, pParams->fVerbose );
+ if ( RetValue >= 0 )
+ {
+ *ppManAig = pManAig;
+ return RetValue;
+ }
+ }
+
+ // check the current resource limits
+ RetValue = -1;
+ for ( nIter = 0; nIter < pParams->nItersMax; nIter++ )
+ {
+ if ( pParams->fVerbose )
+ {
+ printf( "ITERATION %2d : Confs = %6d. FraigBTL = %3d. \n", nIter+1,
+ (int)(pParams->nMiteringLimitStart * pow(pParams->nMiteringLimitMulti,nIter)),
+ (int)(pParams->nFraigingLimitStart * pow(pParams->nFraigingLimitMulti,nIter)) );
+ fflush( stdout );
+ }
+
+ // try rewriting
+ if ( pParams->fUseRewriting )
+ {
+ clk = clock();
+ Counter = (int)(pParams->nRewritingLimitStart * pow(pParams->nRewritingLimitMulti,nIter));
+ pManAig = Ivy_ManRwsat( pManAig, 0 );
+ RetValue = Ivy_FraigMiterStatus( pManAig );
+ Ivy_FraigMiterPrint( pManAig, "Rewriting ", clk, pParams->fVerbose );
+ }
+ if ( RetValue >= 0 )
+ break;
+
+ // try fraiging followed by mitering
+ if ( pParams->fUseFraiging )
+ {
+ clk = clock();
+ nInspectLimit = pParams->nTotalInspectLimit? pParams->nTotalInspectLimit - pParams->nTotalInspectsMade : 0;
+ pIvyParams->nBTLimitNode = (int)(pParams->nFraigingLimitStart * pow(pParams->nFraigingLimitMulti,nIter));
+ pIvyParams->nBTLimitMiter = (int)(pParams->nMiteringLimitStart * pow(pParams->nMiteringLimitMulti,nIter)) / Ivy_ManPoNum(pManAig);
+ pManAig = Ivy_FraigPerform_int( pManTemp = pManAig, pIvyParams, &nSatConfs, &nSatInspects ); Ivy_ManStop( pManTemp );
+ RetValue = Ivy_FraigMiterStatus( pManAig );
+ Ivy_FraigMiterPrint( pManAig, "Fraiging ", clk, pParams->fVerbose );
+ }
+ if ( RetValue >= 0 )
+ break;
+
+ // add to the number of backtracks and inspects
+ pParams->nTotalBacktracksMade += nSatConfs;
+ pParams->nTotalInspectsMade += nSatInspects;
+ // check if global resource limit is reached
+ if ( (pParams->nTotalBacktrackLimit && pParams->nTotalBacktracksMade >= pParams->nTotalBacktrackLimit) ||
+ (pParams->nTotalInspectLimit && pParams->nTotalInspectsMade >= pParams->nTotalInspectLimit) )
+ {
+ printf( "Reached global limit on conflicts/inspects. Quitting.\n" );
+ *ppManAig = pManAig;
+ return -1;
+ }
+ }
+
+ if ( RetValue < 0 )
+ {
+ if ( pParams->fVerbose )
+ {
+ printf( "Attempting SAT with conflict limit %d ...\n", pParams->nMiteringLimitLast );
+ fflush( stdout );
+ }
+ clk = clock();
+ nInspectLimit = pParams->nTotalInspectLimit? pParams->nTotalInspectLimit - pParams->nTotalInspectsMade : 0;
+ pIvyParams->nBTLimitMiter = pParams->nMiteringLimitLast / Ivy_ManPoNum(pManAig);
+ pManAig = Ivy_FraigMiter( pManTemp = pManAig, pIvyParams ); Ivy_ManStop( pManTemp );
+ RetValue = Ivy_FraigMiterStatus( pManAig );
+ Ivy_FraigMiterPrint( pManAig, "SAT solving", clk, pParams->fVerbose );
+ }
+
+ // assign the model if it was proved by rewriting (const 1 miter)
+ if ( RetValue == 0 && pManAig->pData == NULL )
+ {
+ pManAig->pData = ALLOC( int, Ivy_ManPiNum(pManAig) );
+ memset( pManAig->pData, 0, sizeof(int) * Ivy_ManPiNum(pManAig) );
+ }
+ *ppManAig = pManAig;
+ return RetValue;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Performs fraiging of the AIG.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+Ivy_Man_t * Ivy_FraigPerform_int( Ivy_Man_t * pManAig, Ivy_FraigParams_t * pParams, sint64 * pnSatConfs, sint64 * pnSatInspects )
+{
Ivy_FraigMan_t * p;
Ivy_Man_t * pManAigNew;
int clk;
+ if ( Ivy_ManNodeNum(pManAig) == 0 )
+ return Ivy_ManDup(pManAig);
clk = clock();
assert( Ivy_ManLatchNum(pManAig) == 0 );
p = Ivy_FraigStart( pManAig, pParams );
@@ -186,13 +394,17 @@ clk = clock();
Ivy_FraigSweep( p );
pManAigNew = p->pManFraig;
p->timeTotal = clock() - clk;
+ if ( pnSatConfs )
+ *pnSatConfs = p->pSat? p->pSat->stats.conflicts : 0;
+ if ( pnSatInspects )
+ *pnSatInspects = p->pSat? p->pSat->stats.inspects : 0;
Ivy_FraigStop( p );
return pManAigNew;
}
/**Function*************************************************************
- Synopsis [Performs fraiging of the initial AIG.]
+ Synopsis [Performs fraiging of the AIG.]
Description []
@@ -206,6 +418,8 @@ Ivy_Man_t * Ivy_FraigPerform( Ivy_Man_t * pManAig, Ivy_FraigParams_t * pParams )
Ivy_FraigMan_t * p;
Ivy_Man_t * pManAigNew;
int clk;
+ if ( Ivy_ManNodeNum(pManAig) == 0 )
+ return Ivy_ManDup(pManAig);
clk = clock();
assert( Ivy_ManLatchNum(pManAig) == 0 );
p = Ivy_FraigStart( pManAig, pParams );
@@ -219,7 +433,7 @@ p->timeTotal = clock() - clk;
/**Function*************************************************************
- Synopsis [Performs fraiging of the initial AIG.]
+ Synopsis [Applies brute-force SAT to the miter.]
Description []
@@ -256,39 +470,16 @@ clk = clock();
Ivy_ManCleanup( p->pManFraig );
pManAigNew = p->pManFraig;
p->timeTotal = clock() - clk;
+
+//printf( "Final nodes = %6d. ", Ivy_ManNodeNum(pManAigNew) );
+//PRT( "Time", p->timeTotal );
Ivy_FraigStop( p );
return pManAigNew;
}
/**Function*************************************************************
- Synopsis [Performs fraiging of the initial AIG.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Ivy_FraigParamsDefault( Ivy_FraigParams_t * pParams )
-{
- memset( pParams, 0, sizeof(Ivy_FraigParams_t) );
- pParams->nSimWords = 32;
- pParams->SimSatur = 0.005;
- pParams->fPatScores = 0;
- pParams->MaxScore = 25;
- pParams->nBTLimitNode = 100; // conflict limit at a node
- pParams->nBTLimitMiter = 500000; // conflict limit at an output
- pParams->nBTLimitGlobal = 0; // conflict limit global
- pParams->nInsLimitNode = 0; // inspection limit at a node
- pParams->nInsLimitMiter = 0; // inspection limit at an output
- pParams->nInsLimitGlobal = 0; // inspection limit global
-}
-
-/**Function*************************************************************
-
- Synopsis [Starts the fraiging manager.]
+ Synopsis [Starts the fraiging manager without simulation info.]
Description []
@@ -388,6 +579,29 @@ Ivy_FraigMan_t * Ivy_FraigStart( Ivy_Man_t * pManAig, Ivy_FraigParams_t * pParam
SeeAlso []
***********************************************************************/
+void Ivy_FraigStop( Ivy_FraigMan_t * p )
+{
+ if ( p->pParams->fVerbose )
+ Ivy_FraigPrint( p );
+ if ( p->vPiVars ) Vec_PtrFree( p->vPiVars );
+ if ( p->pSat ) sat_solver_delete( p->pSat );
+ FREE( p->pPatScores );
+ FREE( p->pPatWords );
+ FREE( p->pSimWords );
+ free( p );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Prints stats for the fraiging manager.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
void Ivy_FraigPrint( Ivy_FraigMan_t * p )
{
double nMemory;
@@ -408,12 +622,14 @@ void Ivy_FraigPrint( Ivy_FraigMan_t * p )
PRT( " Fail ", p->timeSatFail );
PRT( "Class refining ", p->timeRef );
PRT( "TOTAL RUNTIME ", p->timeTotal );
- PRT( "time1 ", p->time1 );
+ if ( p->time1 ) { PRT( "time1 ", p->time1 ); }
}
+
+
/**Function*************************************************************
- Synopsis [Stops the fraiging manager.]
+ Synopsis [Assigns random patterns to the PI node.]
Description []
@@ -422,22 +638,19 @@ void Ivy_FraigPrint( Ivy_FraigMan_t * p )
SeeAlso []
***********************************************************************/
-void Ivy_FraigStop( Ivy_FraigMan_t * p )
+void Ivy_NodeAssignRandom( Ivy_FraigMan_t * p, Ivy_Obj_t * pObj )
{
- if ( p->pParams->fVerbose )
- Ivy_FraigPrint( p );
- if ( p->vPiVars ) Vec_PtrFree( p->vPiVars );
- if ( p->pSat ) sat_solver_delete( p->pSat );
- FREE( p->pPatScores );
- FREE( p->pPatWords );
- FREE( p->pSimWords );
- free( p );
+ Ivy_FraigSim_t * pSims;
+ int i;
+ assert( Ivy_ObjIsPi(pObj) );
+ pSims = Ivy_ObjSim(pObj);
+ for ( i = 0; i < p->nSimWords; i++ )
+ pSims->pData[i] = Ivy_ObjRandomSim();
}
-
/**Function*************************************************************
- Synopsis [Simulates one node.]
+ Synopsis [Assigns constant patterns to the PI node.]
Description []
@@ -446,18 +659,19 @@ void Ivy_FraigStop( Ivy_FraigMan_t * p )
SeeAlso []
***********************************************************************/
-void Ivy_NodeAssignRandom( Ivy_FraigMan_t * p, Ivy_Obj_t * pObj )
+void Ivy_NodeAssignConst( Ivy_FraigMan_t * p, Ivy_Obj_t * pObj, int fConst1 )
{
Ivy_FraigSim_t * pSims;
int i;
+ assert( Ivy_ObjIsPi(pObj) );
pSims = Ivy_ObjSim(pObj);
for ( i = 0; i < p->nSimWords; i++ )
- pSims->pData[i] = Ivy_ObjRandomSim();
+ pSims->pData[i] = fConst1? ~(unsigned)0 : 0;
}
/**Function*************************************************************
- Synopsis [Simulates one node.]
+ Synopsis [Assings random simulation info for the PIs.]
Description []
@@ -466,13 +680,34 @@ void Ivy_NodeAssignRandom( Ivy_FraigMan_t * p, Ivy_Obj_t * pObj )
SeeAlso []
***********************************************************************/
-void Ivy_NodeAssignConst( Ivy_FraigMan_t * p, Ivy_Obj_t * pObj, int fConst1 )
+void Ivy_FraigAssignRandom( Ivy_FraigMan_t * p )
{
- Ivy_FraigSim_t * pSims;
+ Ivy_Obj_t * pObj;
int i;
- pSims = Ivy_ObjSim(pObj);
- for ( i = 0; i < p->nSimWords; i++ )
- pSims->pData[i] = fConst1? ~(unsigned)0 : 0;
+ Ivy_ManForEachPi( p->pManAig, pObj, i )
+ Ivy_NodeAssignRandom( p, pObj );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Assings distance-1 simulation info for the PIs.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Ivy_FraigAssignDist1( Ivy_FraigMan_t * p, unsigned * pPat )
+{
+ Ivy_Obj_t * pObj;
+ int i, Limit;
+ Ivy_ManForEachPi( p->pManAig, pObj, i )
+ Ivy_NodeAssignConst( p, pObj, Ivy_InfoHasBit(pPat, i) );
+ Limit = IVY_MIN( Ivy_ManPiNum(p->pManAig), p->nSimWords * 32 - 1 );
+ for ( i = 0; i < Limit; i++ )
+ Ivy_InfoXorBit( Ivy_ObjSim( Ivy_ManPi(p->pManAig,i) )->pData, i+1 );
}
/**Function*************************************************************
@@ -733,52 +968,7 @@ p->nSimRounds++;
/**Function*************************************************************
- Synopsis [Simulates AIG manager.]
-
- Description [Assumes that the PI simulation info is attached.]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Ivy_FraigAssignRandom( Ivy_FraigMan_t * p )
-{
- Ivy_Obj_t * pObj;
- int i;
- Ivy_ManForEachPi( p->pManAig, pObj, i )
- Ivy_NodeAssignRandom( p, pObj );
-}
-
-/**Function*************************************************************
-
- Synopsis [Simulates AIG manager.]
-
- Description [Assumes that the PI simulation info is attached.]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Ivy_FraigAssignDist1( Ivy_FraigMan_t * p, unsigned * pPat )
-{
- Ivy_Obj_t * pObj;
- int i, Limit;
- Ivy_ManForEachPi( p->pManAig, pObj, i )
- Ivy_NodeAssignConst( p, pObj, Ivy_InfoHasBit(pPat, i) );
- Limit = IVY_MIN( Ivy_ManPiNum(p->pManAig), p->nSimWords * 32 - 1 );
- for ( i = 0; i < Limit; i++ )
- Ivy_InfoXorBit( Ivy_ObjSim( Ivy_ManPi(p->pManAig,i) )->pData, i+1 );
-/*
- for ( i = 0; i < Limit; i++ )
- Extra_PrintBinary( stdout, Ivy_ObjSim( Ivy_ManPi(p->pManAig,i) ), 30 ), printf( "\n" );
-*/
-}
-
-/**Function*************************************************************
-
- Synopsis [Adds new nodes to the equivalence class.]
+ Synopsis [Adds one node to the equivalence class.]
Description []
@@ -800,7 +990,7 @@ void Ivy_NodeAddToClass( Ivy_Obj_t * pClass, Ivy_Obj_t * pObj )
/**Function*************************************************************
- Synopsis [Adds new nodes to the equivalence class.]
+ Synopsis [Adds equivalence class to the list of classes.]
Description []
@@ -853,7 +1043,7 @@ void Ivy_FraigInsertClass( Ivy_FraigList_t * pList, Ivy_Obj_t * pBase, Ivy_Obj_t
/**Function*************************************************************
- Synopsis [Updates the list of classes after base class has split.]
+ Synopsis [Removes equivalence class from the list of classes.]
Description []
@@ -1045,7 +1235,7 @@ int Ivy_FraigRefineClass_rec( Ivy_FraigMan_t * p, Ivy_Obj_t * pClass )
Description [Assumes that simulation info is assigned. Returns the
number of classes refined.]
- SideEffects []
+ SideEffects [Large equivalence class of constant 0 may cause problems.]
SeeAlso []
@@ -1063,8 +1253,8 @@ clk = clock();
Counter += ( RetValue > 0 );
//if ( Ivy_ObjIsConst1(pClass) )
//printf( "%d ", RetValue );
-if ( Ivy_ObjIsConst1(pClass) )
- p->time1 += clock() - clk;
+//if ( Ivy_ObjIsConst1(pClass) )
+// p->time1 += clock() - clk;
}
p->timeRef += clock() - clk;
return Counter;
@@ -1112,7 +1302,7 @@ int Ivy_FraigCountClassNodes( Ivy_Obj_t * pClass )
/**Function*************************************************************
- Synopsis [Stops the fraiging manager.]
+ Synopsis [Prints simulation classes.]
Description []
@@ -1134,7 +1324,7 @@ void Ivy_FraigPrintSimClasses( Ivy_FraigMan_t * p )
/**Function*************************************************************
- Synopsis [Copy pattern from the solver into the internal storage.]
+ Synopsis [Generated const 0 pattern.]
Description []
@@ -1150,7 +1340,7 @@ void Ivy_FraigSavePattern0( Ivy_FraigMan_t * p )
/**Function*************************************************************
- Synopsis [Copy pattern from the solver into the internal storage.]
+ Synopsis [[Generated const 1 pattern.]
Description []
@@ -1166,6 +1356,28 @@ void Ivy_FraigSavePattern1( Ivy_FraigMan_t * p )
/**Function*************************************************************
+ Synopsis [Generates the counter-example satisfying the miter.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+int * Ivy_FraigCreateModel( Ivy_FraigMan_t * p )
+{
+ int * pModel;
+ Ivy_Obj_t * pObj;
+ int i;
+ pModel = ALLOC( int, Ivy_ManPiNum(p->pManFraig) );
+ Ivy_ManForEachPi( p->pManFraig, pObj, i )
+ pModel[i] = ( p->pSat->model.ptr[Ivy_ObjSatNum(pObj)] == l_True );
+ return pModel;
+}
+
+/**Function*************************************************************
+
Synopsis [Copy pattern from the solver into the internal storage.]
Description []
@@ -1256,7 +1468,7 @@ int Ivy_FraigCheckOutputSims( Ivy_FraigMan_t * p )
/**Function*************************************************************
- Synopsis [Stops the fraiging manager.]
+ Synopsis [Performs simulation of the manager.]
Description []
@@ -1291,11 +1503,12 @@ void Ivy_FraigSimulate( Ivy_FraigMan_t * p )
nClasses = p->lClasses.nItems;
nChanges = Ivy_FraigRefineClasses( p );
//printf( "Refined classes = %5d. Changes = %4d. Pairs = %6d.\n", p->lClasses.nItems, nChanges, Ivy_FraigCountPairsClasses(p) );
- } while ( (double)nChanges / nClasses > p->pParams->SimSatur );
+ } while ( (double)nChanges / nClasses > p->pParams->dSimSatur );
// Ivy_FraigPrintSimClasses( p );
+
// check if some outputs already became non-constant
- if ( Ivy_FraigCheckOutputSims(p) )
- printf( "Special case: One of the POs is already non-const zero.\n" );
+// if ( Ivy_FraigCheckOutputSims(p) )
+// printf( "Special case: One of the POs is already non-const zero.\n" );
}
@@ -1390,7 +1603,7 @@ int Ivy_FraigSelectBestPat( Ivy_FraigMan_t * p )
/**Function*************************************************************
- Synopsis [Stops the fraiging manager.]
+ Synopsis [Resimulates fraiging manager after finding a counter-example.]
Description []
@@ -1431,6 +1644,25 @@ void Ivy_FraigResimulate( Ivy_FraigMan_t * p )
/**Function*************************************************************
+ Synopsis [Prints the status of the miter.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Ivy_FraigMiterPrint( Ivy_Man_t * pNtk, char * pString, int clk, int fVerbose )
+{
+ if ( !fVerbose )
+ return;
+ printf( "Nodes = %7d. Levels = %4d. ", Ivy_ManNodeNum(pNtk), Ivy_ManLevels(pNtk) );
+ PRT( pString, clock() - clk );
+}
+
+/**Function*************************************************************
+
Synopsis [Reports the status of the miter.]
Description []
@@ -1440,21 +1672,23 @@ void Ivy_FraigResimulate( Ivy_FraigMan_t * p )
SeeAlso []
***********************************************************************/
-int Ivy_FraigMiterStatus( Ivy_FraigMan_t * p )
+int Ivy_FraigMiterStatus( Ivy_Man_t * pMan )
{
Ivy_Obj_t * pObj, * pObjNew;
int i, CountConst0 = 0, CountNonConst0 = 0, CountUndecided = 0;
- Ivy_ManForEachPo( p->pManAig, pObj, i )
+ if ( pMan->pData )
+ return 0;
+ Ivy_ManForEachPo( pMan, pObj, i )
{
- pObjNew = Ivy_ObjChild0Equiv(pObj);
+ pObjNew = Ivy_ObjChild0(pObj);
// check if the output is constant 1
- if ( pObjNew == p->pManFraig->pConst1 )
+ if ( pObjNew == pMan->pConst1 )
{
CountNonConst0++;
continue;
}
// check if the output is constant 0
- if ( pObjNew == Ivy_Not(p->pManFraig->pConst1) )
+ if ( pObjNew == Ivy_Not(pMan->pConst1) )
{
CountConst0++;
continue;
@@ -1467,6 +1701,7 @@ int Ivy_FraigMiterStatus( Ivy_FraigMan_t * p )
}
CountUndecided++;
}
+/*
if ( p->pParams->fVerbose )
{
printf( "Miter has %d outputs. ", Ivy_ManPoNum(p->pManAig) );
@@ -1475,14 +1710,19 @@ int Ivy_FraigMiterStatus( Ivy_FraigMan_t * p )
printf( "Undecided = %d. ", CountUndecided );
printf( "\n" );
}
+*/
+ if ( CountNonConst0 )
+ return 0;
+ if ( CountUndecided )
+ return -1;
return 1;
}
/**Function*************************************************************
- Synopsis [Works on the miter.]
+ Synopsis [Tries to prove each output of the miter until encountering a sat output.]
- Description [Tries to prove each output until encountering a sat output.]
+ Description []
SideEffects []
@@ -1493,7 +1733,7 @@ void Ivy_FraigMiterProve( Ivy_FraigMan_t * p )
{
Ivy_Obj_t * pObj, * pObjNew;
int i, RetValue, clk = clock();
- int fVerbose = p->pParams->fVerbose;
+ int fVerbose = 0;
Ivy_ManForEachPo( p->pManAig, pObj, i )
{
if ( i && fVerbose )
@@ -1520,6 +1760,9 @@ void Ivy_FraigMiterProve( Ivy_FraigMan_t * p )
{
if ( fVerbose )
printf( "Output %2d (out of %2d) cannot be constant 0. ", i, Ivy_ManPoNum(p->pManAig) );
+ // assing constant 0 model
+ p->pManFraig->pData = ALLOC( int, Ivy_ManPiNum(p->pManFraig) );
+ memset( p->pManFraig->pData, 0, sizeof(int) * Ivy_ManPiNum(p->pManFraig) );
break;
}
// try to prove the output constant 0
@@ -1529,7 +1772,7 @@ void Ivy_FraigMiterProve( Ivy_FraigMan_t * p )
if ( fVerbose )
printf( "Output %2d (out of %2d) was proved constant 0. ", i, Ivy_ManPoNum(p->pManAig) );
// set the constant miter
- Ivy_ObjFanin0(pObj)->pEquiv = Ivy_NotCond( p->pManFraig->pConst1, !Ivy_IsComplement(pObj) );
+ Ivy_ObjFanin0(pObj)->pEquiv = Ivy_NotCond( p->pManFraig->pConst1, !Ivy_ObjFaninC0(pObj) );
continue;
}
if ( RetValue == -1 ) // failed
@@ -1541,6 +1784,8 @@ void Ivy_FraigMiterProve( Ivy_FraigMan_t * p )
// proved satisfiable
if ( fVerbose )
printf( "Output %2d (out of %2d) was proved NOT a constant 0. ", i, Ivy_ManPoNum(p->pManAig) );
+ // create the model
+ p->pManFraig->pData = Ivy_FraigCreateModel(p);
break;
}
if ( fVerbose )
@@ -1564,7 +1809,7 @@ void Ivy_FraigSweep( Ivy_FraigMan_t * p )
{
Ivy_Obj_t * pObj;
int i, k = 0;
-p->nClassesZero = Ivy_ObjIsConst1(p->lClasses.pHead) ? Ivy_FraigCountClassNodes(p->lClasses.pHead) : 0;
+p->nClassesZero = p->lClasses.pHead? (Ivy_ObjIsConst1(p->lClasses.pHead) ? Ivy_FraigCountClassNodes(p->lClasses.pHead) : 0) : 0;
p->nClassesBeg = p->lClasses.nItems;
// duplicate internal nodes
p->pProgress = Extra_ProgressBarStart( stdout, Ivy_ManNodeNum(p->pManAig) );
@@ -1577,8 +1822,9 @@ p->nClassesBeg = p->lClasses.nItems;
p->nClassesEnd = p->lClasses.nItems;
// try to prove the outputs of the miter
p->nNodesMiter = Ivy_ManNodeNum(p->pManFraig);
- Ivy_FraigMiterStatus( p );
- Ivy_FraigMiterProve( p );
+// Ivy_FraigMiterStatus( p->pManFraig );
+ if ( p->pParams->fProve )
+ Ivy_FraigMiterProve( p );
// add the POs
Ivy_ManForEachPo( p->pManAig, pObj, i )
Ivy_ObjCreatePo( p->pManFraig, Ivy_ObjChild0Equiv(pObj) );
@@ -1651,32 +1897,9 @@ Ivy_Obj_t * Ivy_FraigAnd( Ivy_FraigMan_t * p, Ivy_Obj_t * pObjOld )
/**Function*************************************************************
- Synopsis [Performs fraiging for one node.]
+ Synopsis [Prints variable activity.]
- Description [Returns the fraiged node.]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Ivy_FraigCleanActivity( Ivy_FraigMan_t * p )
-{
- double * pActivity;
- int i;
- pActivity = sat_solver_activity(p->pSat);
- for ( i = 0; i < p->nSatVars; i++ )
- {
- pActivity[i] = 0.0;
- sat_solver_order_update( p->pSat, i );
- }
-}
-
-/**Function*************************************************************
-
- Synopsis [Performs fraiging for one node.]
-
- Description [Returns the fraiged node.]
+ Description []
SideEffects []
@@ -1685,19 +1908,17 @@ void Ivy_FraigCleanActivity( Ivy_FraigMan_t * p )
***********************************************************************/
void Ivy_FraigPrintActivity( Ivy_FraigMan_t * p )
{
- double * pActivity;
int i;
- pActivity = sat_solver_activity(p->pSat);
for ( i = 0; i < p->nSatVars; i++ )
- printf( "%d %.3f ", i, pActivity[i] );
+ printf( "%d %.3f ", i, p->pSat->activity[i] );
printf( "\n" );
}
/**Function*************************************************************
- Synopsis [Performs fraiging for one node.]
+ Synopsis [Runs equivalence test for the two nodes.]
- Description [Returns the fraiged node.]
+ Description []
SideEffects []
@@ -1721,11 +1942,10 @@ int Ivy_FraigNodesAreEquiv( Ivy_FraigMan_t * p, Ivy_Obj_t * pOld, Ivy_Obj_t * pN
{
p->nSatFails++;
// fail immediately
- return -1;
-
+// return -1;
if ( nBTLimit <= 10 )
return -1;
- nBTLimit = (int)sqrt(nBTLimit);
+ nBTLimit = (int)pow(nBTLimit, 0.7);
}
p->nSatCalls++;
@@ -1740,6 +1960,9 @@ int Ivy_FraigNodesAreEquiv( Ivy_FraigMan_t * p, Ivy_Obj_t * pOld, Ivy_Obj_t * pN
// if the nodes do not have SAT variables, allocate them
Ivy_FraigNodeAddToSolver( p, pOld, pNew );
+ // prepare variable activity
+ Ivy_FraigSetActivityFactors( p, pOld, pNew );
+
// solve under assumptions
// A = 1; B = 0 OR A = 1; B = 1
clk = clock();
@@ -1827,7 +2050,7 @@ p->timeSatFail += clock() - clk;
/**Function*************************************************************
- Synopsis [Performs fraiging for one node.]
+ Synopsis [Runs equivalence test for one node.]
Description [Returns the fraiged node.]
@@ -1857,7 +2080,7 @@ int Ivy_FraigNodeIsConst( Ivy_FraigMan_t * p, Ivy_Obj_t * pNew )
Ivy_FraigNodeAddToSolver( p, NULL, pNew );
// prepare variable activity
- Ivy_FraigMarkConeSetActivity( p, NULL, pNew );
+ Ivy_FraigSetActivityFactors( p, NULL, pNew );
// solve under assumptions
clk = clock();
@@ -1878,7 +2101,8 @@ p->timeSatUnsat += clock() - clk;
else if ( RetValue1 == l_True )
{
p->timeSatSat += clock() - clk;
- Ivy_FraigSavePattern( p );
+ if ( p->pPatWords )
+ Ivy_FraigSavePattern( p );
p->nSatCallsSat++;
return 0;
}
@@ -2065,7 +2289,7 @@ Vec_Ptr_t * Ivy_FraigCollectSuper( Ivy_Obj_t * pObj, int fUseMuxes )
/**Function*************************************************************
- Synopsis [Collects the supergate.]
+ Synopsis [Updates the solver clause database.]
Description []
@@ -2091,7 +2315,7 @@ void Ivy_FraigObjAddToFrontier( Ivy_FraigMan_t * p, Ivy_Obj_t * pObj, Vec_Ptr_t
/**Function*************************************************************
- Synopsis [Addes clauses to the solver.]
+ Synopsis [Updates the solver clause database.]
Description []
@@ -2145,90 +2369,70 @@ void Ivy_FraigNodeAddToSolver( Ivy_FraigMan_t * p, Ivy_Obj_t * pOld, Ivy_Obj_t *
/**Function*************************************************************
- Synopsis [Performs fraiging for one node.]
+ Synopsis [Sets variable activities in the cone.]
- Description [Returns the fraiged node.]
+ Description []
SideEffects []
SeeAlso []
***********************************************************************/
-int Ivy_FraigMarkConeSetActivity_rec( Ivy_FraigMan_t * p, Ivy_Obj_t * pObj, double * pActivity, int LevelMax, Vec_Ptr_t * vPiVars )
+int Ivy_FraigSetActivityFactors_rec( Ivy_FraigMan_t * p, Ivy_Obj_t * pObj, int LevelMin, int LevelMax )
{
Vec_Ptr_t * vFanins;
Ivy_Obj_t * pFanin;
- int i, Counter;
+ int i, Counter = 0;
assert( !Ivy_IsComplement(pObj) );
- if ( Ivy_ObjIsConst1(pObj) )
- return 0;
assert( Ivy_ObjSatNum(pObj) );
+ // skip visited variables
if ( Ivy_ObjIsTravIdCurrent(p->pManFraig, pObj) )
return 0;
Ivy_ObjSetTravIdCurrent(p->pManFraig, pObj);
-
- // add this variable to the decision
- assert( Ivy_ObjSatNum(pObj) > 0 );
-// pActivity[Ivy_ObjSatNum(pObj)] = 3.0 * pow( 0.97, LevelMax - pObj->Level );
-// sat_solver_order_unassigned( p->pSat, Ivy_ObjSatNum(pObj) );
-
-// pActivity[Ivy_ObjSatNum(pObj)] += 3.0 * pObj->Level / LevelMax;
-// sat_solver_order_update( p->pSat, Ivy_ObjSatNum(pObj) );
-
- if ( LevelMax > 150 && (int)pObj->Level > LevelMax - 100 )
- sat_solver_act_var_bump_factor( p->pSat, Ivy_ObjSatNum(pObj), 1.0 + 10.0 * (pObj->Level - (LevelMax - 100)) / 100 );
-
// add the PI to the list
- if ( Ivy_ObjIsPi(pObj) )
- {
- Vec_PtrPush( vPiVars, pObj );
+ if ( pObj->Level <= (unsigned)LevelMin || Ivy_ObjIsPi(pObj) )
return 0;
- }
-
+ // set the factor of this variable
+ // (LevelMax-LevelMin) / (pObj->Level-LevelMin) = p->pParams->dActConeBumpMax / ThisBump
+ p->pSat->factors[Ivy_ObjSatNum(pObj)] = p->pParams->dActConeBumpMax * (pObj->Level - LevelMin)/(LevelMax - LevelMin);
+ veci_push(&p->pSat->act_vars, Ivy_ObjSatNum(pObj));
// explore the fanins
vFanins = Ivy_ObjFaninVec( pObj );
- Counter = 1;
Vec_PtrForEachEntry( vFanins, pFanin, i )
- Counter += Ivy_FraigMarkConeSetActivity_rec( p, Ivy_Regular(pFanin), pActivity, LevelMax, vPiVars );
- return Counter;
-
-// Counter = Ivy_FraigMarkConeSetActivity_rec( p, Ivy_ObjFanin0(pObj), pActivity, LevelMax, vPiVars );
-// Counter += Ivy_FraigMarkConeSetActivity_rec( p, Ivy_ObjFanin1(pObj), pActivity, LevelMax, vPiVars );
-// return Counter;
+ Counter += Ivy_FraigSetActivityFactors_rec( p, Ivy_Regular(pFanin), LevelMin, LevelMax );
+ return 1 + Counter;
}
/**Function*************************************************************
- Synopsis [Performs fraiging for one node.]
+ Synopsis [Sets variable activities in the cone.]
- Description [Returns the fraiged node.]
+ Description []
SideEffects []
SeeAlso []
***********************************************************************/
-int Ivy_FraigMarkConeSetActivity( Ivy_FraigMan_t * p, Ivy_Obj_t * pOld, Ivy_Obj_t * pNew )
+int Ivy_FraigSetActivityFactors( Ivy_FraigMan_t * p, Ivy_Obj_t * pOld, Ivy_Obj_t * pNew )
{
- int clk, LevelMax, Counter;
+ int clk, LevelMin, LevelMax;
assert( pOld || pNew );
clk = clock();
- Vec_PtrClear( p->vPiVars );
+ // reset the active variables
+ veci_resize(&p->pSat->act_vars, 0);
+ // prepare for traversal
Ivy_ManIncrementTravId( p->pManFraig );
-// Ivy_FraigCleanActivity( p );
-// sat_solver_order_clean( p->pSat );
-//printf( "\n" );
-//printf( "Adding\n" );
- LevelMax = IVY_MAX( pNew ? pNew->Level : 0, pOld ? pOld->Level : 0 );
- Counter = 0;
- if ( pOld )
- Counter += Ivy_FraigMarkConeSetActivity_rec( p, pOld, sat_solver_activity(p->pSat), LevelMax, p->vPiVars );
- if ( pNew )
- Counter += Ivy_FraigMarkConeSetActivity_rec( p, pNew, sat_solver_activity(p->pSat), LevelMax, p->vPiVars );
+ // determine the min and max level to visit
+ assert( p->pParams->dActConeRatio > 0 && p->pParams->dActConeRatio < 1 );
+ LevelMax = IVY_MAX( (pNew ? pNew->Level : 0), (pOld ? pOld->Level : 0) );
+ LevelMin = (int)(LevelMax * (1.0 - p->pParams->dActConeRatio));
+ // traverse
+ if ( pOld && !Ivy_ObjIsConst1(pOld) )
+ Ivy_FraigSetActivityFactors_rec( p, pOld, LevelMin, LevelMax );
+ if ( pNew && !Ivy_ObjIsConst1(pNew) )
+ Ivy_FraigSetActivityFactors_rec( p, pNew, LevelMin, LevelMax );
//Ivy_FraigPrintActivity( p );
-//printf( "\n" );
-//printf( "Solving\n" );
-// printf( "%d ", Vec_PtrSize(p->vPiVars) );
p->timeTrav += clock() - clk;
return 1;
}
diff --git a/src/temp/ivy/ivyMan.c b/src/temp/ivy/ivyMan.c
index c6ad75e8..e2689580 100644
--- a/src/temp/ivy/ivyMan.c
+++ b/src/temp/ivy/ivyMan.c
@@ -123,7 +123,10 @@ Ivy_Man_t * Ivy_ManDup( Ivy_Man_t * p )
pObj->pEquiv = Ivy_ObjCreatePi(pNew);
// duplicate internal nodes
Ivy_ManForEachNodeVec( p, vNodes, pObj, i )
- pObj->pEquiv = Ivy_And( pNew, Ivy_ObjChild0Equiv(pObj), Ivy_ObjChild1Equiv(pObj) );
+ if ( Ivy_ObjIsBuf(pObj) )
+ pObj->pEquiv = Ivy_ObjChild0Equiv(pObj);
+ else
+ pObj->pEquiv = Ivy_And( pNew, Ivy_ObjChild0Equiv(pObj), Ivy_ObjChild1Equiv(pObj) );
// add the POs
Ivy_ManForEachPo( p, pObj, i )
Ivy_ObjCreatePo( pNew, Ivy_ObjChild0Equiv(pObj) );
@@ -181,9 +184,9 @@ void Ivy_ManStop( Ivy_Man_t * p )
/**Function*************************************************************
- Synopsis [Returns the number of dangling nodes removed.]
+ Synopsis [Removes nodes without fanout.]
- Description []
+ Description [Returns the number of dangling nodes removed.]
SideEffects []
@@ -199,11 +202,97 @@ int Ivy_ManCleanup( Ivy_Man_t * p )
if ( Ivy_ObjIsNode(pNode) || Ivy_ObjIsLatch(pNode) || Ivy_ObjIsBuf(pNode) )
if ( Ivy_ObjRefs(pNode) == 0 )
Ivy_ObjDelete_rec( p, pNode, 1 );
+//printf( "Cleanup removed %d nodes.\n", nNodesOld - Ivy_ManNodeNum(p) );
return nNodesOld - Ivy_ManNodeNum(p);
}
/**Function*************************************************************
+ Synopsis [Marks nodes reachable from the given one.]
+
+ Description [Returns the number of dangling nodes removed.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+void Ivy_ManCleanupSeq_rec( Ivy_Obj_t * pObj )
+{
+ if ( Ivy_ObjIsMarkA(pObj) )
+ return;
+ Ivy_ObjSetMarkA(pObj);
+ if ( pObj->pFanin0 != NULL )
+ Ivy_ManCleanupSeq_rec( Ivy_ObjFanin0(pObj) );
+ if ( pObj->pFanin1 != NULL )
+ Ivy_ManCleanupSeq_rec( Ivy_ObjFanin1(pObj) );
+}
+
+/**Function*************************************************************
+
+ Synopsis [Removes logic that does not feed into POs.]
+
+ Description [Returns the number of dangling nodes removed.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+int Ivy_ManCleanupSeq( Ivy_Man_t * p )
+{
+ Vec_Ptr_t * vNodes;
+ Ivy_Obj_t * pObj;
+ int i, RetValue;
+ // mark the constant and PIs
+ Ivy_ObjSetMarkA( Ivy_ManConst1(p) );
+ Ivy_ManForEachPi( p, pObj, i )
+ Ivy_ObjSetMarkA( pObj );
+ // mark nodes visited from POs
+ Ivy_ManForEachPo( p, pObj, i )
+ Ivy_ManCleanupSeq_rec( pObj );
+ // collect unmarked nodes
+ vNodes = Vec_PtrAlloc( 100 );
+ Ivy_ManForEachObj( p, pObj, i )
+ {
+ if ( Ivy_ObjIsMarkA(pObj) )
+ Ivy_ObjClearMarkA(pObj);
+ else
+ Vec_PtrPush( vNodes, pObj );
+ }
+ if ( Vec_PtrSize(vNodes) == 0 )
+ {
+ Vec_PtrFree( vNodes );
+//printf( "Sequential sweep cleaned out %d nodes.\n", 0 );
+ return 0;
+ }
+ // disconnect the marked objects
+ Vec_PtrForEachEntry( vNodes, pObj, i )
+ Ivy_ObjDisconnect( p, pObj );
+ // remove the dangling objects
+ Vec_PtrForEachEntry( vNodes, pObj, i )
+ {
+ assert( Ivy_ObjIsNode(pObj) || Ivy_ObjIsLatch(pObj) || Ivy_ObjIsBuf(pObj) );
+ assert( Ivy_ObjRefs(pObj) == 0 );
+ // update node counters of the manager
+ p->nObjs[pObj->Type]--;
+ p->nDeleted++;
+ // delete buffer from the array of buffers
+ if ( p->fFanout && Ivy_ObjIsBuf(pObj) )
+ Vec_PtrRemove( p->vBufs, pObj );
+ // free the node
+ Vec_PtrWriteEntry( p->vObjs, pObj->Id, NULL );
+ Ivy_ManRecycleMemory( p, pObj );
+ }
+ // return the number of nodes freed
+ RetValue = Vec_PtrSize(vNodes);
+ Vec_PtrFree( vNodes );
+//printf( "Sequential sweep cleaned out %d nodes.\n", RetValue );
+ return RetValue;
+}
+
+/**Function*************************************************************
+
Synopsis [Returns the number of dangling nodes removed.]
Description []
@@ -216,13 +305,21 @@ int Ivy_ManCleanup( Ivy_Man_t * p )
int Ivy_ManPropagateBuffers( Ivy_Man_t * p, int fUpdateLevel )
{
Ivy_Obj_t * pNode;
+ int LimitFactor = 20;
int nSteps;
for ( nSteps = 0; Vec_PtrSize(p->vBufs) > 0; nSteps++ )
{
pNode = Vec_PtrEntryLast(p->vBufs);
while ( Ivy_ObjIsBuf(pNode) )
pNode = Ivy_ObjReadFirstFanout( p, pNode );
+//printf( "Propagating buffer %d with input %d and output %d\n", Ivy_ObjFaninId0(pNode), Ivy_ObjFaninId0(Ivy_ObjFanin0(pNode)), pNode->Id );
+//printf( "Latch num %d\n", Ivy_ManLatchNum(p) );
Ivy_NodeFixBufferFanins( p, pNode, fUpdateLevel );
+ if ( nSteps > Ivy_ManNodeNum(p) * LimitFactor )
+ {
+ printf( "This circuit cannot be forward retimed completely. Structural hashing is not finished after %d forward latch moves.\n", Ivy_ManNodeNum(p) * LimitFactor );
+ break;
+ }
}
// printf( "Number of steps = %d\n", nSteps );
return nSteps;
@@ -307,6 +404,7 @@ void Ivy_ManMakeSeq( Ivy_Man_t * p, int nLatches, int * pInits )
p->nDeleted -= 2 * nLatches;
// remove dangling nodes
Ivy_ManCleanup(p);
+ Ivy_ManCleanupSeq(p);
/*
// check for dangling nodes
Ivy_ManForEachObj( p, pObj, i )
diff --git a/src/temp/ivy/ivyResyn.c b/src/temp/ivy/ivyResyn.c
index b2e4a4dd..f42d7464 100644
--- a/src/temp/ivy/ivyResyn.c
+++ b/src/temp/ivy/ivyResyn.c
@@ -138,6 +138,56 @@ if ( fVerbose ) Ivy_ManPrintStats( pMan );
return pMan;
}
+/**Function*************************************************************
+
+ Synopsis [Performs several passes of rewriting on the AIG.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+Ivy_Man_t * Ivy_ManRwsat( Ivy_Man_t * pMan, int fVerbose )
+{
+ int clk;
+ Ivy_Man_t * pTemp;
+
+if ( fVerbose ) { printf( "Original:\n" ); }
+if ( fVerbose ) Ivy_ManPrintStats( pMan );
+
+clk = clock();
+ Ivy_ManRewritePre( pMan, 0, 0, 0 );
+if ( fVerbose ) { printf( "\n" ); }
+if ( fVerbose ) { PRT( "Rewrite", clock() - clk ); }
+if ( fVerbose ) Ivy_ManPrintStats( pMan );
+
+clk = clock();
+ pMan = Ivy_ManBalance( pTemp = pMan, 0 );
+// pMan = Ivy_ManDup( pTemp = pMan );
+ Ivy_ManStop( pTemp );
+if ( fVerbose ) { printf( "\n" ); }
+if ( fVerbose ) { PRT( "Balance", clock() - clk ); }
+if ( fVerbose ) Ivy_ManPrintStats( pMan );
+
+/*
+clk = clock();
+ Ivy_ManRewritePre( pMan, 0, 0, 0 );
+if ( fVerbose ) { printf( "\n" ); }
+if ( fVerbose ) { PRT( "Rewrite", clock() - clk ); }
+if ( fVerbose ) Ivy_ManPrintStats( pMan );
+
+clk = clock();
+ pMan = Ivy_ManBalance( pTemp = pMan, 0 );
+ Ivy_ManStop( pTemp );
+if ( fVerbose ) { printf( "\n" ); }
+if ( fVerbose ) { PRT( "Balance", clock() - clk ); }
+if ( fVerbose ) Ivy_ManPrintStats( pMan );
+*/
+ return pMan;
+}
+
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
diff --git a/src/temp/ivy/module.make b/src/temp/ivy/module.make
index 05409745..f5f34f27 100644
--- a/src/temp/ivy/module.make
+++ b/src/temp/ivy/module.make
@@ -2,10 +2,13 @@ SRC += src/temp/ivy/ivyBalance.c \
src/temp/ivy/ivyCanon.c \
src/temp/ivy/ivyCheck.c \
src/temp/ivy/ivyCut.c \
+ src/temp/ivy/ivyCutTrav.c \
src/temp/ivy/ivyDfs.c \
src/temp/ivy/ivyDsd.c \
src/temp/ivy/ivyFanout.c \
src/temp/ivy/ivyFastMap.c \
+ src/temp/ivy/ivyFraig.c \
+ src/temp/ivy/ivyHaig.c \
src/temp/ivy/ivyIsop.c \
src/temp/ivy/ivyMan.c \
src/temp/ivy/ivyMem.c \
@@ -15,5 +18,6 @@ SRC += src/temp/ivy/ivyBalance.c \
src/temp/ivy/ivyResyn.c \
src/temp/ivy/ivyRwr.c \
src/temp/ivy/ivySeq.c \
+ src/temp/ivy/ivyShow.c \
src/temp/ivy/ivyTable.c \
src/temp/ivy/ivyUtil.c
diff --git a/src/temp/player/module.make b/src/temp/player/module.make
deleted file mode 100644
index 5185f56e..00000000
--- a/src/temp/player/module.make
+++ /dev/null
@@ -1,4 +0,0 @@
-SRC += src/temp/player/playerToAbc.c \
- src/temp/player/playerCore.c \
- src/temp/player/playerMan.c \
- src/temp/player/playerUtil.c
diff --git a/src/temp/player/player.h b/src/temp/player/player.h
deleted file mode 100644
index a4ee5650..00000000
--- a/src/temp/player/player.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/**CFile****************************************************************
-
- FileName [player.h]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [PLA decomposition package.]
-
- Synopsis [External declarations.]
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - June 20, 2005.]
-
- Revision [$Id: player.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#ifndef __XYZ_H__
-#define __XYZ_H__
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "ivy.h"
-#include "esop.h"
-#include "vec.h"
-
-////////////////////////////////////////////////////////////////////////
-/// DECLARATIONS ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Pla_Man_t_ Pla_Man_t;
-typedef struct Pla_Obj_t_ Pla_Obj_t;
-
-// storage for node information
-struct Pla_Obj_t_
-{
- unsigned fFixed : 1; // fixed node
- unsigned Depth : 31; // the depth in terms of LUTs/PLAs
- int nRefs; // the number of references
- Vec_Int_t vSupp[2]; // supports in two frames
- Esop_Cube_t * pCover[2]; // esops in two frames
-};
-
-// storage for additional information
-struct Pla_Man_t_
-{
- // general characteristics
- int nLutMax; // the number of vars
- int nPlaMax; // the number of vars
- int nCubesMax; // the limit on the number of cubes in the intermediate covers
- Ivy_Man_t * pManAig; // the AIG manager
- Pla_Obj_t * pPlaStrs; // memory for structures
- Esop_Man_t * pManMin; // the cube manager
- // arrays to map local variables
- Vec_Int_t * vComTo0; // mapping of common variables into first fanin
- Vec_Int_t * vComTo1; // mapping of common variables into second fanin
- Vec_Int_t * vPairs0; // the first var in each pair of common vars
- Vec_Int_t * vPairs1; // the second var in each pair of common vars
- Vec_Int_t * vTriv0; // trival support of the first node
- Vec_Int_t * vTriv1; // trival support of the second node
- // statistics
- int nNodes; // the number of nodes processed
- int nNodesLut; // the number of nodes processed
- int nNodesPla; // the number of nodes processed
- int nNodesBoth; // the number of nodes processed
- int nNodesDeref; // the number of nodes processed
-};
-
-#define PLAYER_FANIN_LIMIT 128
-
-#define PLA_MIN(a,b) (((a) < (b))? (a) : (b))
-#define PLA_MAX(a,b) (((a) > (b))? (a) : (b))
-
-#define PLA_EMPTY ((Esop_Cube_t *)1)
-
-static inline Pla_Man_t * Ivy_ObjPlaMan( Ivy_Man_t * p, Ivy_Obj_t * pObj ) { return (Pla_Man_t *)p->pData; }
-static inline Pla_Obj_t * Ivy_ObjPlaStr( Ivy_Man_t * p, Ivy_Obj_t * pObj ) { return ((Pla_Man_t *)p->pData)->pPlaStrs + pObj->Id; }
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/*=== playerToAbc.c ==============================================================*/
-extern void * Abc_NtkPlayer( void * pNtk, int nLutMax, int nPlaMax, int RankCost, int fFastMode, int fRewriting, int fSynthesis, int fVerbose );
-/*=== playerCore.c =============================================================*/
-extern Pla_Man_t * Pla_ManDecompose( Ivy_Man_t * p, int nLutMax, int nPlaMax, int fVerbose );
-/*=== playerMan.c ==============================================================*/
-extern Pla_Man_t * Pla_ManAlloc( Ivy_Man_t * p, int nLutMax, int nPlaMax );
-extern void Pla_ManFree( Pla_Man_t * p );
-extern void Pla_ManFreeStr( Pla_Man_t * p, Pla_Obj_t * pStr );
-/*=== playerUtil.c =============================================================*/
-extern int Pla_ManMergeTwoSupports( Pla_Man_t * p, Vec_Int_t * vSupp0, Vec_Int_t * vSupp1, Vec_Int_t * vSupp );
-extern Esop_Cube_t * Pla_ManAndTwoCovers( Pla_Man_t * p, Esop_Cube_t * pCover0, Esop_Cube_t * pCover1, int nSupp, int fStopAtLimit );
-extern Esop_Cube_t * Pla_ManExorTwoCovers( Pla_Man_t * p, Esop_Cube_t * pCover0, Esop_Cube_t * pCover1, int nSupp, int fStopAtLimit );
-extern void Pla_ManComputeStats( Ivy_Man_t * pAig, Vec_Int_t * vNodes );
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
-
-
diff --git a/src/temp/player/playerAbc.c b/src/temp/player/playerAbc.c
deleted file mode 100644
index 4f45b607..00000000
--- a/src/temp/player/playerAbc.c
+++ /dev/null
@@ -1,228 +0,0 @@
-/**CFile****************************************************************
-
- FileName [playerAbc.c]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [PLAyer decomposition package.]
-
- Synopsis [Bridge between ABC and PLAyer.]
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - May 20, 2006.]
-
- Revision [$Id: playerAbc.c,v 1.00 2006/05/11 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "player.h"
-#include "abc.h"
-
-////////////////////////////////////////////////////////////////////////
-/// DECLARATIONS ///
-////////////////////////////////////////////////////////////////////////
-
-static Ivy_Man_t * Ivy_ManFromAbc( Abc_Ntk_t * p );
-static Abc_Ntk_t * Ivy_ManToAbc( Abc_Ntk_t * pNtkOld, Ivy_Man_t * p );
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-#if 0
-
-/**Function*************************************************************
-
- Synopsis [Gives the current ABC network to PLAyer for processing.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void * Abc_NtkPlayer( void * pNtk, int nLutMax, int nPlaMax, int RankCost, int fFastMode, int fVerbose )
-{
- int fUseRewriting = 1;
- Ivy_Man_t * pMan, * pManExt;
- Abc_Ntk_t * pNtkAig;
-
- if ( !Abc_NtkIsStrash(pNtk) )
- return NULL;
- // convert to the new AIG manager
- pMan = Ivy_ManFromAbc( pNtk );
- // check the correctness of conversion
- if ( !Ivy_ManCheck( pMan ) )
- {
- printf( "Abc_NtkPlayer: Internal AIG check has failed.\n" );
- Ivy_ManStop( pMan );
- return NULL;
- }
- if ( fVerbose )
- Ivy_ManPrintStats( pMan );
- if ( fUseRewriting )
- {
- // simplify
- pMan = Ivy_ManResyn( pManExt = pMan, 1, 0 );
- Ivy_ManStop( pManExt );
- if ( fVerbose )
- Ivy_ManPrintStats( pMan );
- }
- // perform decomposition/mapping into PLAs/LUTs
- pManExt = Pla_ManDecompose( pMan, nLutMax, nPlaMax, fVerbose );
- Ivy_ManStop( pMan );
- pMan = pManExt;
- if ( fVerbose )
- Ivy_ManPrintStats( pMan );
- // convert from the extended AIG manager into an SOP network
- pNtkAig = Ivy_ManToAbc( pNtk, pMan );
- Ivy_ManStop( pMan );
- // chech the resulting network
- if ( !Abc_NtkCheck( pNtkAig ) )
- {
- printf( "Abc_NtkPlayer: The network check has failed.\n" );
- Abc_NtkDelete( pNtkAig );
- return NULL;
- }
- return pNtkAig;
-}
-
-/**Function*************************************************************
-
- Synopsis [Converts from strashed AIG in ABC into strash AIG in IVY.]
-
- Description [Assumes DFS ordering of nodes in the AIG of ABC.]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Ivy_Man_t * Ivy_ManFromAbc( Abc_Ntk_t * pNtk )
-{
- Ivy_Man_t * pMan;
- Abc_Obj_t * pObj;
- int i;
- // create the manager
- pMan = Ivy_ManStart( Abc_NtkCiNum(pNtk), Abc_NtkCoNum(pNtk), Abc_NtkNodeNum(pNtk) + 10 );
- // create the PIs
- Abc_AigConst1(pNtk)->pCopy = (Abc_Obj_t *)Ivy_ManConst1(pMan);
- Abc_NtkForEachCi( pNtk, pObj, i )
- pObj->pCopy = (Abc_Obj_t *)Ivy_ManPi(pMan, i);
- // perform the conversion of the internal nodes
- Abc_AigForEachAnd( pNtk, pObj, i )
- pObj->pCopy = (Abc_Obj_t *)Ivy_And( (Ivy_Obj_t *)Abc_ObjChild0Copy(pObj), (Ivy_Obj_t *)Abc_ObjChild1Copy(pObj) );
- // create the POs
- Abc_NtkForEachCo( pNtk, pObj, i )
- Ivy_ObjConnect( Ivy_ManPo(pMan, i), (Ivy_Obj_t *)Abc_ObjChild0Copy(pObj) );
- Ivy_ManCleanup( pMan );
- return pMan;
-}
-
-/**Function*************************************************************
-
- Synopsis [Converts AIG manager after PLA/LUT mapping into a logic ABC network.]
-
- Description [The AIG manager contains nodes with extended functionality.
- Node types are in pObj->Type. Node fanins are in pObj->vFanins. Functions
- of LUT nodes are in pMan->vTruths.]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Abc_Ntk_t * Ivy_ManToAbc( Abc_Ntk_t * pNtkOld, Ivy_Man_t * pMan )
-{
- Abc_Ntk_t * pNtkNew;
- Vec_Int_t * vIvyNodes, * vIvyFanins, * vTruths = pMan->vTruths;
- Abc_Obj_t * pObj, * pObjNew, * pFaninNew;
- Ivy_Obj_t * pIvyNode, * pIvyFanin;
- int pCompls[PLAYER_FANIN_LIMIT];
- int i, k, Fanin, nFanins;
- // start the new ABC network
- pNtkNew = Abc_NtkStartFrom( pNtkOld, ABC_NTK_LOGIC, ABC_FUNC_SOP );
- // transfer the pointers to the basic nodes
- Ivy_ManCleanTravId(pMan);
- Ivy_ManConst1(pMan)->TravId = Abc_AigConst1(pNtkNew)->Id;
- Abc_NtkForEachCi( pNtkNew, pObjNew, i )
- Ivy_ManPi(pMan, i)->TravId = pObjNew->Id;
- // construct the logic network isomorphic to logic network in the AIG manager
- vIvyNodes = Ivy_ManDfsExt( pMan );
- Ivy_ManForEachNodeVec( pMan, vIvyNodes, pIvyNode, i )
- {
- // get fanins of the old node
- vIvyFanins = Ivy_ObjGetFanins( pIvyNode );
- nFanins = Vec_IntSize(vIvyFanins);
- // create the new node
- pObjNew = Abc_NtkCreateNode( pNtkNew );
- Vec_IntForEachEntry( vIvyFanins, Fanin, k )
- {
- pIvyFanin = Ivy_ObjObj( pIvyNode, Ivy_EdgeId(Fanin) );
- pFaninNew = Abc_NtkObj( pNtkNew, pIvyFanin->TravId );
- Abc_ObjAddFanin( pObjNew, pFaninNew );
- pCompls[k] = Ivy_EdgeIsComplement(Fanin);
- assert( Ivy_ObjIsAndMulti(pIvyNode) || nFanins == 1 || pCompls[k] == 0 ); // EXOR/LUT cannot have complemented fanins
- }
- assert( k <= PLAYER_FANIN_LIMIT );
- // create logic function of the node
- if ( Ivy_ObjIsAndMulti(pIvyNode) )
- pObjNew->pData = Abc_SopCreateAnd( pNtkNew->pManFunc, nFanins, pCompls );
- else if ( Ivy_ObjIsExorMulti(pIvyNode) )
- pObjNew->pData = Abc_SopCreateXorSpecial( pNtkNew->pManFunc, nFanins );
- else if ( Ivy_ObjIsLut(pIvyNode) )
- pObjNew->pData = Abc_SopCreateFromTruth( pNtkNew->pManFunc, nFanins, Ivy_ObjGetTruth(pIvyNode) );
- else assert( 0 );
- assert( Abc_SopGetVarNum(pObjNew->pData) == nFanins );
- pIvyNode->TravId = pObjNew->Id;
- }
-//Pla_ManComputeStats( pMan, vIvyNodes );
- Vec_IntFree( vIvyNodes );
- // connect the PO nodes
- Abc_NtkForEachCo( pNtkOld, pObj, i )
- {
- // get the old fanin of the PO node
- vIvyFanins = Ivy_ObjGetFanins( Ivy_ManPo(pMan, i) );
- Fanin = Vec_IntEntry( vIvyFanins, 0 );
- pIvyFanin = Ivy_ManObj( pMan, Ivy_EdgeId(Fanin) );
- // get the new ABC node corresponding to the old fanin
- pFaninNew = Abc_NtkObj( pNtkNew, pIvyFanin->TravId );
- if ( Ivy_EdgeIsComplement(Fanin) ) // complement
- {
-// pFaninNew = Abc_NodeCreateInv(pNtkNew, pFaninNew);
- if ( Abc_ObjIsCi(pFaninNew) )
- pFaninNew = Abc_NodeCreateInv(pNtkNew, pFaninNew);
- else
- {
- // clone the node
- pObjNew = Abc_NtkCloneObj( pFaninNew );
- // set complemented functions
- pObjNew->pData = Abc_SopRegister( pNtkNew->pManFunc, pFaninNew->pData );
- Abc_SopComplement(pObjNew->pData);
- // return the new node
- pFaninNew = pObjNew;
- }
- assert( Abc_SopGetVarNum(pFaninNew->pData) == Abc_ObjFaninNum(pFaninNew) );
- }
- Abc_ObjAddFanin( pObj->pCopy, pFaninNew );
- }
- // remove dangling nodes
- Abc_NtkForEachNode(pNtkNew, pObj, i)
- if ( Abc_ObjFanoutNum(pObj) == 0 )
- Abc_NtkDeleteObj(pObj);
- // fix CIs feeding directly into COs
- Abc_NtkLogicMakeSimpleCos( pNtkNew, 0 );
- return pNtkNew;
-}
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/temp/player/playerBuild.c b/src/temp/player/playerBuild.c
deleted file mode 100644
index e878f19c..00000000
--- a/src/temp/player/playerBuild.c
+++ /dev/null
@@ -1,283 +0,0 @@
-/**CFile****************************************************************
-
- FileName [playerBuild.c]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [PLA decomposition package.]
-
- Synopsis []
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - May 11, 2006.]
-
- Revision [$Id: playerBuild.c,v 1.00 2006/05/11 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "player.h"
-
-////////////////////////////////////////////////////////////////////////
-/// DECLARATIONS ///
-////////////////////////////////////////////////////////////////////////
-
-static Ivy_Obj_t * Pla_ManToAig_rec( Ivy_Man_t * pNew, Ivy_Obj_t * pObjOld );
-static Ivy_Obj_t * Ivy_ManToAigCube( Ivy_Man_t * pNew, Ivy_Obj_t * pObj, Esop_Cube_t * pCube, Vec_Int_t * vSupp );
-static Ivy_Obj_t * Ivy_ManToAigConst( Ivy_Man_t * pNew, int fConst1 );
-static int Pla_ManToAigLutFuncs( Ivy_Man_t * pNew, Ivy_Man_t * pOld );
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-#if 0
-
-/**Function*************************************************************
-
- Synopsis [Constructs the AIG manager (IVY) for the network after mapping.]
-
- Description [Uses extended node types (multi-input AND, multi-input EXOR, LUT).]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Ivy_Man_t * Pla_ManToAig( Ivy_Man_t * pOld )
-{
- Ivy_Man_t * pNew;
- Ivy_Obj_t * pObjOld, * pObjNew;
- int i;
- // start the new manager
- pNew = Ivy_ManStart( Ivy_ManPiNum(pOld), Ivy_ManPoNum(pOld), 2*Ivy_ManNodeNum(pOld) + 10 );
- pNew->fExtended = 1;
- // transfer the const/PI numbers
- Ivy_ManCleanTravId(pOld);
- Ivy_ManConst1(pOld)->TravId = Ivy_ManConst1(pNew)->Id;
- Ivy_ManForEachPi( pOld, pObjOld, i )
- pObjOld->TravId = Ivy_ManPi(pNew, i)->Id;
- // recursively construct the network
- Ivy_ManForEachPo( pOld, pObjOld, i )
- {
- pObjNew = Pla_ManToAig_rec( pNew, Ivy_ObjFanin0(pObjOld) );
- Ivy_ObjStartFanins( Ivy_ManPo(pNew, i), 1 );
- Ivy_ObjAddFanin( Ivy_ManPo(pNew, i), Ivy_EdgeCreate(pObjNew->Id, Ivy_ObjFaninC0(pObjOld)) );
- }
- // compute the LUT functions
- Pla_ManToAigLutFuncs( pNew, pOld );
- return pNew;
-}
-
-/**Function*************************************************************
-
- Synopsis [Recursively construct the new node.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Ivy_Obj_t * Pla_ManToAig_rec( Ivy_Man_t * pNew, Ivy_Obj_t * pObjOld )
-{
- Pla_Man_t * p = Ivy_ObjMan(pObjOld)->pData;
- Vec_Int_t * vSupp;
- Esop_Cube_t * pCover, * pCube;
- Ivy_Obj_t * pFaninOld, * pFaninNew, * pObjNew;
- Pla_Obj_t * pStr;
- int Entry, nCubes, ObjNewId, i;
- // skip the node if it is a constant or already processed
- if ( Ivy_ObjIsConst1(pObjOld) || pObjOld->TravId )
- return Ivy_ManObj( pNew, pObjOld->TravId );
- assert( Ivy_ObjIsAnd(pObjOld) || Ivy_ObjIsExor(pObjOld) );
- // get the support and the cover
- pStr = Ivy_ObjPlaStr( pNew, pObjOld );
- if ( Vec_IntSize( &pStr->vSupp[0] ) <= p->nLutMax )
- {
- vSupp = &pStr->vSupp[0];
- pCover = PLA_EMPTY;
- }
- else
- {
- vSupp = &pStr->vSupp[1];
- pCover = pStr->pCover[1];
- assert( pCover != PLA_EMPTY );
- }
- // process the fanins
- Vec_IntForEachEntry( vSupp, Entry, i )
- Pla_ManToAig_rec( pNew, Ivy_ObjObj(pObjOld, Entry) );
- // consider the case of a LUT
- if ( pCover == PLA_EMPTY )
- {
- pObjNew = Ivy_ObjCreateExt( pNew, IVY_LUT );
- Ivy_ObjStartFanins( pObjNew, p->nLutMax );
- // remember new object ID in case it changes
- ObjNewId = pObjNew->Id;
- Vec_IntForEachEntry( vSupp, Entry, i )
- {
- pFaninOld = Ivy_ObjObj( pObjOld, Entry );
- Ivy_ObjAddFanin( Ivy_ManObj(pNew, ObjNewId), Ivy_EdgeCreate(pFaninOld->TravId, 0) );
- }
- // get the new object
- pObjNew = Ivy_ManObj(pNew, ObjNewId);
- }
- else
- {
- // for each cube, construct the node
- nCubes = Esop_CoverCountCubes( pCover );
- if ( nCubes == 0 )
- pObjNew = Ivy_ManToAigConst( pNew, 0 );
- else if ( nCubes == 1 )
- pObjNew = Ivy_ManToAigCube( pNew, pObjOld, pCover, vSupp );
- else
- {
- pObjNew = Ivy_ObjCreateExt( pNew, IVY_EXORM );
- Ivy_ObjStartFanins( pObjNew, p->nLutMax );
- // remember new object ID in case it changes
- ObjNewId = pObjNew->Id;
- Esop_CoverForEachCube( pCover, pCube )
- {
- pFaninNew = Ivy_ManToAigCube( pNew, pObjOld, pCube, vSupp );
- Ivy_ObjAddFanin( Ivy_ManObj(pNew, ObjNewId), Ivy_EdgeCreate(pFaninNew->Id, 0) );
- }
- // get the new object
- pObjNew = Ivy_ManObj(pNew, ObjNewId);
- }
- }
- pObjOld->TravId = pObjNew->Id;
- pObjNew->TravId = pObjOld->Id;
- return pObjNew;
-}
-
-
-/**Function*************************************************************
-
- Synopsis [Returns constant 1 node.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Ivy_Obj_t * Ivy_ManToAigConst( Ivy_Man_t * pNew, int fConst1 )
-{
- Ivy_Obj_t * pObjNew;
- pObjNew = Ivy_ObjCreateExt( pNew, IVY_ANDM );
- Ivy_ObjStartFanins( pObjNew, 1 );
- Ivy_ObjAddFanin( pObjNew, Ivy_EdgeCreate(0, !fConst1) );
- return pObjNew;
-}
-
-/**Function*************************************************************
-
- Synopsis [Derives the decomposed network.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Ivy_Obj_t * Ivy_ManToAigCube( Ivy_Man_t * pNew, Ivy_Obj_t * pObjOld, Esop_Cube_t * pCube, Vec_Int_t * vSupp )
-{
- Ivy_Obj_t * pObjNew, * pFaninOld;
- int i, Value;
- // if tautology cube, create constant 1 node
- if ( pCube->nLits == 0 )
- return Ivy_ManToAigConst( pNew, 1 );
- // create AND node
- pObjNew = Ivy_ObjCreateExt( pNew, IVY_ANDM );
- Ivy_ObjStartFanins( pObjNew, pCube->nLits );
- // add fanins
- for ( i = 0; i < (int)pCube->nVars; i++ )
- {
- Value = Esop_CubeGetVar( pCube, i );
- assert( Value != 0 );
- if ( Value == 3 )
- continue;
- pFaninOld = Ivy_ObjObj( pObjOld, Vec_IntEntry(vSupp, i) );
- Ivy_ObjAddFanin( pObjNew, Ivy_EdgeCreate( pFaninOld->TravId, Value==1 ) );
- }
- assert( Ivy_ObjFaninNum(pObjNew) == (int)pCube->nLits );
- return pObjNew;
-}
-
-
-/**Function*************************************************************
-
- Synopsis [Recursively construct the new node.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-int Pla_ManToAigLutFuncs( Ivy_Man_t * pNew, Ivy_Man_t * pOld )
-{
- Vec_Int_t * vSupp, * vFanins, * vNodes, * vTemp;
- Ivy_Obj_t * pObjOld, * pObjNew;
- unsigned * pComputed, * pTruth;
- int i, k, Counter = 0;
- // create mapping from the LUT nodes into truth table indices
- assert( pNew->vTruths == NULL );
- vNodes = Vec_IntAlloc( 100 );
- vTemp = Vec_IntAlloc( 100 );
- pNew->vTruths = Vec_IntStart( Ivy_ManObjIdNext(pNew) );
- Ivy_ManForEachObj( pNew, pObjNew, i )
- {
- if ( Ivy_ObjIsLut(pObjNew) )
- Vec_IntWriteEntry( pNew->vTruths, i, 8 * Counter++ );
- else
- Vec_IntWriteEntry( pNew->vTruths, i, -1 );
- }
- // allocate memory
- pNew->pMemory = ALLOC( unsigned, 8 * Counter );
- memset( pNew->pMemory, 0, sizeof(unsigned) * 8 * Counter );
- // derive truth tables
- Ivy_ManForEachObj( pNew, pObjNew, i )
- {
- if ( !Ivy_ObjIsLut(pObjNew) )
- continue;
- pObjOld = Ivy_ManObj( pOld, pObjNew->TravId );
- vSupp = Ivy_ObjPlaStr(pNew, pObjOld)->vSupp;
- assert( Vec_IntSize(vSupp) <= 8 );
- pTruth = Ivy_ObjGetTruth( pObjNew );
- pComputed = Ivy_ManCutTruth( pNew, pObjOld, vSupp, vNodes, vTemp );
- // check if the truth table is constant 0
- for ( k = 0; k < 8; k++ )
- if ( pComputed[k] )
- break;
- if ( k == 8 )
- {
- // create inverter
- for ( k = 0; k < 8; k++ )
- pComputed[k] = 0x55555555;
- // point it to the constant 1 node
- vFanins = Ivy_ObjGetFanins( pObjNew );
- Vec_IntClear( vFanins );
- Vec_IntPush( vFanins, Ivy_EdgeCreate(0, 1) );
- }
- memcpy( pTruth, pComputed, sizeof(unsigned) * 8 );
-// Extra_PrintBinary( stdout, pTruth, 16 ); printf( "\n" );
- }
- Vec_IntFree( vTemp );
- Vec_IntFree( vNodes );
- return Counter;
-}
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/temp/player/playerCore.c b/src/temp/player/playerCore.c
deleted file mode 100644
index da2c6efd..00000000
--- a/src/temp/player/playerCore.c
+++ /dev/null
@@ -1,376 +0,0 @@
-/**CFile****************************************************************
-
- FileName [playerCore.c]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [PLA decomposition package.]
-
- Synopsis []
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - May 11, 2006.]
-
- Revision [$Id: playerCore.c,v 1.00 2006/05/11 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "player.h"
-
-////////////////////////////////////////////////////////////////////////
-/// DECLARATIONS ///
-////////////////////////////////////////////////////////////////////////
-
-static int Pla_ManDecomposeInt( Pla_Man_t * p );
-static int Pla_ManDecomposeNode( Pla_Man_t * p, Ivy_Obj_t * pObj );
-static void Pla_NodeGetSuppsAndCovers( Pla_Man_t * p, Ivy_Obj_t * pObj, int Level,
- Vec_Int_t ** pvSuppA, Vec_Int_t ** pvSuppB, Esop_Cube_t ** pvCovA, Esop_Cube_t ** pvCovB );
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis [Performs decomposition/mapping into PLAs and K-LUTs.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Pla_Man_t * Pla_ManDecompose( Ivy_Man_t * pAig, int nLutMax, int nPlaMax, int fVerbose )
-{
- Pla_Man_t * p;
- p = Pla_ManAlloc( pAig, nLutMax, nPlaMax );
- if ( !Pla_ManDecomposeInt( p ) )
- {
- printf( "Decomposition/mapping failed.\n" );
- Pla_ManFree( p );
- return NULL;
- }
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Performs decomposition/mapping into PLAs and K-LUTs.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-int Pla_ManDecomposeInt( Pla_Man_t * p )
-{
- Ivy_Man_t * pAig = p->pManAig;
- Ivy_Obj_t * pObj;
- Pla_Obj_t * pStr;
- int i;
-
- // prepare the PI structures
- Ivy_ManForEachPi( pAig, pObj, i )
- {
- pStr = Ivy_ObjPlaStr( pAig, pObj );
- pStr->fFixed = 1;
- pStr->Depth = 0;
- pStr->nRefs = (unsigned)pObj->nRefs;
- pStr->pCover[0] = PLA_EMPTY;
- pStr->pCover[1] = PLA_EMPTY;
- }
-
- // assuming DFS ordering of nodes in the manager
- Ivy_ManForEachNode( pAig, pObj, i )
- if ( !Pla_ManDecomposeNode(p, pObj) )
- return 0;
- return 1;
-}
-
-/**Function*************************************************************
-
- Synopsis [Records decomposition statistics for one node.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Pla_ManCountDecNodes( Pla_Man_t * p, Pla_Obj_t * pStr )
-{
- if ( Vec_IntSize(pStr->vSupp) <= p->nLutMax && pStr->pCover[1] != PLA_EMPTY )
- p->nNodesBoth++;
- else if ( Vec_IntSize(pStr->vSupp) <= p->nLutMax )
- p->nNodesLut++;
- else if ( pStr->pCover[1] != PLA_EMPTY )
- p->nNodesPla++;
-}
-
-/**Function*************************************************************
-
- Synopsis [Performs decomposition/mapping for one node.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-int Pla_ManDecomposeNode( Pla_Man_t * p, Ivy_Obj_t * pObj )
-{
- Pla_Obj_t * pStr, * pStr0, * pStr1;
- Vec_Int_t * vSuppA, * vSuppB, * vSupp0, * vSupp1;
- Esop_Cube_t * pCovA, * pCovB;
- int nSuppSize1, nSuppSize2;
-
- assert( pObj->nRefs > 0 );
- p->nNodes++;
-
- // get the structures
- pStr = Ivy_ObjPlaStr( p->pManAig, pObj );
- pStr0 = Ivy_ObjPlaStr( p->pManAig, Ivy_ObjFanin0( pObj ) );
- pStr1 = Ivy_ObjPlaStr( p->pManAig, Ivy_ObjFanin1( pObj ) );
- vSupp0 = &pStr->vSupp[0];
- vSupp1 = &pStr->vSupp[1];
- pStr->pCover[0] = PLA_EMPTY;
- pStr->pCover[1] = PLA_EMPTY;
-
- // process level 1
- Pla_NodeGetSuppsAndCovers( p, pObj, 1, &vSuppA, &vSuppB, &pCovA, &pCovB );
- nSuppSize1 = Pla_ManMergeTwoSupports( p, vSuppA, vSuppB, vSupp0 );
- if ( nSuppSize1 > p->nPlaMax || pCovA == PLA_EMPTY || pCovB == PLA_EMPTY )
- pStr->pCover[0] = PLA_EMPTY;
- else if ( Ivy_ObjIsAnd(pObj) )
- pStr->pCover[0] = Pla_ManAndTwoCovers( p, pCovA, pCovB, nSuppSize1, 1 );
- else
- pStr->pCover[0] = Pla_ManExorTwoCovers( p, pCovA, pCovB, nSuppSize1, 1 );
-
- // process level 2
- if ( PLA_MAX(pStr0->Depth, pStr1->Depth) > 1 )
- {
- Pla_NodeGetSuppsAndCovers( p, pObj, 2, &vSuppA, &vSuppB, &pCovA, &pCovB );
- nSuppSize2 = Pla_ManMergeTwoSupports( p, vSuppA, vSuppB, vSupp1 );
- if ( nSuppSize2 > p->nPlaMax || pCovA == PLA_EMPTY || pCovB == PLA_EMPTY )
- pStr->pCover[1] = PLA_EMPTY;
- else if ( Ivy_ObjIsAnd(pObj) )
- pStr->pCover[1] = Pla_ManAndTwoCovers( p, pCovA, pCovB, nSuppSize2, 1 );
- else
- pStr->pCover[1] = Pla_ManExorTwoCovers( p, pCovA, pCovB, nSuppSize2, 1 );
- }
-
- // determine the level of this node
- pStr->nRefs = (unsigned)pObj->nRefs;
- pStr->Depth = PLA_MAX( pStr0->Depth, pStr1->Depth );
- pStr->Depth = pStr->Depth? pStr->Depth : 1;
- if ( nSuppSize1 > p->nLutMax && pStr->pCover[1] == PLA_EMPTY )
- {
- pStr->Depth++;
- // free second level
- if ( pStr->pCover[1] != PLA_EMPTY )
- Esop_CoverRecycle( p->pManMin, pStr->pCover[1] );
- vSupp1->nCap = 0;
- vSupp1->nSize = 0;
- FREE( vSupp1->pArray );
- pStr->pCover[1] = PLA_EMPTY;
- // move first to second
- pStr->vSupp[1] = pStr->vSupp[0];
- pStr->pCover[1] = pStr->pCover[0];
- vSupp0->nCap = 0;
- vSupp0->nSize = 0;
- vSupp0->pArray = NULL;
- pStr->pCover[0] = PLA_EMPTY;
- // get zero level
- Pla_NodeGetSuppsAndCovers( p, pObj, 0, &vSuppA, &vSuppB, &pCovA, &pCovB );
- nSuppSize2 = Pla_ManMergeTwoSupports( p, vSuppA, vSuppB, vSupp0 );
- assert( nSuppSize2 == 2 );
- if ( pCovA == PLA_EMPTY || pCovB == PLA_EMPTY )
- pStr->pCover[0] = PLA_EMPTY;
- else if ( Ivy_ObjIsAnd(pObj) )
- pStr->pCover[0] = Pla_ManAndTwoCovers( p, pCovA, pCovB, nSuppSize2, 0 );
- else
- pStr->pCover[0] = Pla_ManExorTwoCovers( p, pCovA, pCovB, nSuppSize2, 0 );
- // count stats
- if ( pStr0->fFixed == 0 ) Pla_ManCountDecNodes( p, pStr0 );
- if ( pStr1->fFixed == 0 ) Pla_ManCountDecNodes( p, pStr1 );
- // mark the nodes
- pStr0->fFixed = 1;
- pStr1->fFixed = 1;
- }
- else if ( pStr0->Depth < pStr1->Depth )
- {
- if ( pStr0->fFixed == 0 ) Pla_ManCountDecNodes( p, pStr0 );
- pStr0->fFixed = 1;
- }
- else // if ( pStr0->Depth > pStr1->Depth )
- {
- if ( pStr1->fFixed == 0 ) Pla_ManCountDecNodes( p, pStr1 );
- pStr1->fFixed = 1;
- }
- assert( pStr->Depth );
-
- // free some of the covers to save memory
- assert( pStr0->nRefs > 0 );
- assert( pStr1->nRefs > 0 );
- pStr0->nRefs--;
- pStr1->nRefs--;
-
- if ( pStr0->nRefs == 0 && !pStr0->fFixed )
- Pla_ManFreeStr( p, pStr0 ), p->nNodesDeref++;
- if ( pStr1->nRefs == 0 && !pStr1->fFixed )
- Pla_ManFreeStr( p, pStr1 ), p->nNodesDeref++;
-
- return 1;
-}
-
-/**Function*************************************************************
-
- Synopsis [Returns pointers to the support arrays on the given level.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Pla_NodeGetSuppsAndCovers( Pla_Man_t * p, Ivy_Obj_t * pObj, int Level,
- Vec_Int_t ** pvSuppA, Vec_Int_t ** pvSuppB, Esop_Cube_t ** pvCovA, Esop_Cube_t ** pvCovB )
-{
- Ivy_Obj_t * pFan0, * pFan1;
- Pla_Obj_t * pStr, * pStr0, * pStr1;
- Esop_Cube_t * pCovA, * pCovB;
- int fCompl0, fCompl1;
- assert( Level >= 0 && Level <= 2 );
- // get the complemented attributes
- fCompl0 = Ivy_ObjFaninC0( pObj );
- fCompl1 = Ivy_ObjFaninC1( pObj );
- // get the fanins
- pFan0 = Ivy_ObjFanin0( pObj );
- pFan1 = Ivy_ObjFanin1( pObj );
- // get the structures
- pStr = Ivy_ObjPlaStr( p->pManAig, pObj );
- pStr0 = Ivy_ObjPlaStr( p->pManAig, pFan0 );
- pStr1 = Ivy_ObjPlaStr( p->pManAig, pFan1 );
- // make sure the fanins are processed
- assert( Ivy_ObjIsPi(pFan0) || pStr0->Depth > 0 );
- assert( Ivy_ObjIsPi(pFan1) || pStr1->Depth > 0 );
- // prepare the return values depending on the level
- Vec_IntWriteEntry( p->vTriv0, 0, pFan0->Id );
- Vec_IntWriteEntry( p->vTriv1, 0, pFan1->Id );
- *pvSuppA = p->vTriv0;
- *pvSuppB = p->vTriv1;
- pCovA = p->pManMin->pTriv0;
- pCovB = p->pManMin->pTriv1;
- if ( Level == 1 )
- {
- if ( pStr0->Depth == pStr1->Depth )
- {
- if ( pStr0->Depth > 0 )
- {
- *pvSuppA = &pStr0->vSupp[0];
- *pvSuppB = &pStr1->vSupp[0];
- pCovA = pStr0->pCover[0];
- pCovB = pStr1->pCover[0];
- }
- }
- else if ( pStr0->Depth < pStr1->Depth )
- {
- *pvSuppB = &pStr1->vSupp[0];
- pCovB = pStr1->pCover[0];
- }
- else // if ( pStr0->Depth > pStr1->Depth )
- {
- *pvSuppA = &pStr0->vSupp[0];
- pCovA = pStr0->pCover[0];
- }
- }
- else if ( Level == 2 )
- {
- if ( pStr0->Depth == pStr1->Depth )
- {
- *pvSuppA = &pStr0->vSupp[1];
- *pvSuppB = &pStr1->vSupp[1];
- pCovA = pStr0->pCover[1];
- pCovB = pStr1->pCover[1];
- }
- else if ( pStr0->Depth + 1 == pStr1->Depth )
- {
- *pvSuppA = &pStr0->vSupp[0];
- *pvSuppB = &pStr1->vSupp[1];
- pCovA = pStr0->pCover[0];
- pCovB = pStr1->pCover[1];
- }
- else if ( pStr0->Depth == pStr1->Depth + 1 )
- {
- *pvSuppA = &pStr0->vSupp[1];
- *pvSuppB = &pStr1->vSupp[0];
- pCovA = pStr0->pCover[1];
- pCovB = pStr1->pCover[0];
- }
- else if ( pStr0->Depth < pStr1->Depth )
- {
- *pvSuppB = &pStr1->vSupp[1];
- pCovB = pStr1->pCover[1];
- }
- else // if ( pStr0->Depth > pStr1->Depth )
- {
- *pvSuppA = &pStr0->vSupp[1];
- pCovA = pStr0->pCover[1];
- }
- }
- // complement the first if needed
- if ( pCovA == PLA_EMPTY || !fCompl0 )
- *pvCovA = pCovA;
- else if ( pCovA && pCovA->nLits == 0 ) // topmost one is the tautology cube
- *pvCovA = pCovA->pNext;
- else
- *pvCovA = p->pManMin->pOne0, p->pManMin->pOne0->pNext = pCovA;
- // complement the second if needed
- if ( pCovB == PLA_EMPTY || !fCompl1 )
- *pvCovB = pCovB;
- else if ( pCovB && pCovB->nLits == 0 ) // topmost one is the tautology cube
- *pvCovB = pCovB->pNext;
- else
- *pvCovB = p->pManMin->pOne1, p->pManMin->pOne1->pNext = pCovB;
-}
-
-
-/*
- if ( pObj->Id == 1371 )
- {
- int k;
- printf( "Zero : " );
- for ( k = 0; k < vSuppA->nSize; k++ )
- printf( "%d ", vSuppA->pArray[k] );
- printf( "\n" );
- printf( "One : " );
- for ( k = 0; k < vSuppB->nSize; k++ )
- printf( "%d ", vSuppB->pArray[k] );
- printf( "\n" );
- printf( "Node : " );
- for ( k = 0; k < vSupp0->nSize; k++ )
- printf( "%d ", vSupp0->pArray[k] );
- printf( "\n" );
- printf( "\n" );
- printf( "\n" );
- Esop_CoverWrite( stdout, pCovA );
- printf( "\n" );
- Esop_CoverWrite( stdout, pCovB );
- printf( "\n" );
- }
-*/
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/temp/player/playerMan.c b/src/temp/player/playerMan.c
deleted file mode 100644
index 78b20718..00000000
--- a/src/temp/player/playerMan.c
+++ /dev/null
@@ -1,125 +0,0 @@
-/**CFile****************************************************************
-
- FileName [playerMan.c]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [PLA decomposition package.]
-
- Synopsis []
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - May 11, 2006.]
-
- Revision [$Id: playerMan.c,v 1.00 2006/05/11 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "player.h"
-
-////////////////////////////////////////////////////////////////////////
-/// DECLARATIONS ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis [Allocates the PLA/LUT mapping manager.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Pla_Man_t * Pla_ManAlloc( Ivy_Man_t * pAig, int nLutMax, int nPlaMax )
-{
- Pla_Man_t * pMan;
- assert( !(nLutMax < 2 || nLutMax > 8 || nPlaMax < 8 || nPlaMax > 128) );
- // start the manager
- pMan = ALLOC( Pla_Man_t, 1 );
- memset( pMan, 0, sizeof(Pla_Man_t) );
- pMan->nLutMax = nLutMax;
- pMan->nPlaMax = nPlaMax;
- pMan->nCubesMax = 2 * nPlaMax; // higher limit, later reduced
- pMan->pManAig = pAig;
- // set up the temporaries
- pMan->vComTo0 = Vec_IntAlloc( 2 * nPlaMax );
- pMan->vComTo1 = Vec_IntAlloc( 2 * nPlaMax );
- pMan->vPairs0 = Vec_IntAlloc( nPlaMax );
- pMan->vPairs1 = Vec_IntAlloc( nPlaMax );
- pMan->vTriv0 = Vec_IntAlloc( 1 ); Vec_IntPush( pMan->vTriv0, -1 );
- pMan->vTriv1 = Vec_IntAlloc( 1 ); Vec_IntPush( pMan->vTriv1, -1 );
- // allocate memory for object structures
- pMan->pPlaStrs = ALLOC( Pla_Obj_t, sizeof(Pla_Obj_t) * (Ivy_ManObjIdMax(pAig)+1) );
- memset( pMan->pPlaStrs, 0, sizeof(Pla_Obj_t) * (Ivy_ManObjIdMax(pAig)+1) );
- // create the cube manager
- pMan->pManMin = Esop_ManAlloc( nPlaMax );
- // save the resulting manager
- assert( pAig->pData == NULL );
- pAig->pData = pMan;
- return pMan;
-}
-
-/**Function*************************************************************
-
- Synopsis [Frees the PLA/LUT mapping manager.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Pla_ManFree( Pla_Man_t * p )
-{
- Pla_Obj_t * pStr;
- int i;
- Esop_ManFree( p->pManMin );
- Vec_IntFree( p->vTriv0 );
- Vec_IntFree( p->vTriv1 );
- Vec_IntFree( p->vComTo0 );
- Vec_IntFree( p->vComTo1 );
- Vec_IntFree( p->vPairs0 );
- Vec_IntFree( p->vPairs1 );
- for ( i = 0, pStr = p->pPlaStrs; i <= Ivy_ManObjIdMax(p->pManAig); i++, pStr++ )
- FREE( pStr->vSupp[0].pArray ), FREE( pStr->vSupp[1].pArray );
- free( p->pPlaStrs );
- free( p );
-}
-
-/**Function*************************************************************
-
- Synopsis [Cleans the PLA/LUT structure of the node.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Pla_ManFreeStr( Pla_Man_t * p, Pla_Obj_t * pStr )
-{
- if ( pStr->pCover[0] != PLA_EMPTY ) Esop_CoverRecycle( p->pManMin, pStr->pCover[0] );
- if ( pStr->pCover[1] != PLA_EMPTY ) Esop_CoverRecycle( p->pManMin, pStr->pCover[1] );
- if ( pStr->vSupp[0].pArray ) free( pStr->vSupp[0].pArray );
- if ( pStr->vSupp[1].pArray ) free( pStr->vSupp[1].pArray );
- memset( pStr, 0, sizeof(Pla_Obj_t) );
- pStr->pCover[0] = PLA_EMPTY;
- pStr->pCover[1] = PLA_EMPTY;
-}
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/temp/player/playerToAbc.c b/src/temp/player/playerToAbc.c
deleted file mode 100644
index 7c6ab114..00000000
--- a/src/temp/player/playerToAbc.c
+++ /dev/null
@@ -1,523 +0,0 @@
-/**CFile****************************************************************
-
- FileName [playerToAbc.c]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [PLAyer decomposition package.]
-
- Synopsis [Bridge between ABC and PLAyer.]
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - May 20, 2006.]
-
- Revision [$Id: playerToAbc.c,v 1.00 2006/05/11 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "player.h"
-#include "abc.h"
-
-////////////////////////////////////////////////////////////////////////
-/// DECLARATIONS ///
-////////////////////////////////////////////////////////////////////////
-
-static Ivy_Man_t * Ivy_ManFromAbc( Abc_Ntk_t * p );
-static Abc_Ntk_t * Ivy_ManToAbc( Abc_Ntk_t * pNtk, Ivy_Man_t * pMan, Pla_Man_t * p, int fFastMode );
-static Abc_Obj_t * Ivy_ManToAbc_rec( Abc_Ntk_t * pNtkNew, Ivy_Man_t * pMan, Pla_Man_t * p, Ivy_Obj_t * pObjIvy, Vec_Int_t * vNodes, Vec_Int_t * vTemp );
-static Abc_Obj_t * Ivy_ManToAbcFast_rec( Abc_Ntk_t * pNtkNew, Ivy_Man_t * pMan, Ivy_Obj_t * pObjIvy, Vec_Int_t * vNodes, Vec_Int_t * vTemp );
-static Abc_Obj_t * Ivy_ManToAigCube( Abc_Ntk_t * pNtkNew, Ivy_Man_t * pMan, Ivy_Obj_t * pObjIvy, Esop_Cube_t * pCube, Vec_Int_t * vSupp );
-static int Abc_NtkPlayerCost( Abc_Ntk_t * pNtk, int RankCost, int fVerbose );
-
-static inline void Abc_ObjSetIvy2Abc( Ivy_Man_t * p, int IvyId, Abc_Obj_t * pObjAbc ) { assert(Vec_PtrEntry(p->pCopy, IvyId) == NULL); assert(!Abc_ObjIsComplement(pObjAbc)); Vec_PtrWriteEntry( p->pCopy, IvyId, pObjAbc ); }
-static inline Abc_Obj_t * Abc_ObjGetIvy2Abc( Ivy_Man_t * p, int IvyId ) { return Vec_PtrEntry( p->pCopy, IvyId ); }
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis [Applies PLA/LUT mapping to the ABC network.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void * Abc_NtkPlayer( void * pNtk, int nLutMax, int nPlaMax, int RankCost, int fFastMode, int fRewriting, int fSynthesis, int fVerbose )
-{
- Pla_Man_t * p;
- Ivy_Man_t * pMan, * pManExt;
- Abc_Ntk_t * pNtkNew;
- if ( !Abc_NtkIsStrash(pNtk) )
- return NULL;
- // convert to the new AIG manager
- pMan = Ivy_ManFromAbc( pNtk );
- // check the correctness of conversion
- if ( !Ivy_ManCheck( pMan ) )
- {
- printf( "Abc_NtkPlayer: Internal AIG check has failed.\n" );
- Ivy_ManStop( pMan );
- return NULL;
- }
- if ( fVerbose )
- Ivy_ManPrintStats( pMan );
- if ( fRewriting )
- {
- // simplify
- pMan = Ivy_ManResyn0( pManExt = pMan, 1, 0 );
- Ivy_ManStop( pManExt );
- if ( fVerbose )
- Ivy_ManPrintStats( pMan );
- }
- if ( fSynthesis )
- {
- // simplify
- pMan = Ivy_ManResyn( pManExt = pMan, 1, 0 );
- Ivy_ManStop( pManExt );
- if ( fVerbose )
- Ivy_ManPrintStats( pMan );
- }
- // perform decomposition
- if ( fFastMode )
- {
- // perform mapping into LUTs
- Ivy_FastMapPerform( pMan, nLutMax );
- // convert from the extended AIG manager into an SOP network
- pNtkNew = Ivy_ManToAbc( pNtk, pMan, NULL, fFastMode );
-// pNtkNew = NULL;
- Ivy_FastMapStop( pMan );
- }
- else
- {
- assert( nLutMax >= 2 && nLutMax <= 8 );
- // perform decomposition/mapping into PLAs/LUTs
- p = Pla_ManDecompose( pMan, nLutMax, nPlaMax, fVerbose );
- // convert from the extended AIG manager into an SOP network
- pNtkNew = Ivy_ManToAbc( pNtk, pMan, p, fFastMode );
- Pla_ManFree( p );
- }
- Ivy_ManStop( pMan );
- // chech the resulting network
- if ( pNtkNew && !Abc_NtkCheck( pNtkNew ) )
- {
- printf( "Abc_NtkPlayer: The network check has failed.\n" );
- Abc_NtkDelete( pNtkNew );
- return NULL;
- }
-// Abc_NtkPlayerCost( pNtkNew, RankCost, fVerbose );
- return pNtkNew;
-}
-
-/**Function*************************************************************
-
- Synopsis [Converts from strashed AIG in ABC into strash AIG in IVY.]
-
- Description [Assumes DFS ordering of nodes in the AIG of ABC.]
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Ivy_Man_t * Ivy_ManFromAbc( Abc_Ntk_t * pNtk )
-{
- Ivy_Man_t * pMan;
- Abc_Obj_t * pObj;
- int i;
- // create the manager
- pMan = Ivy_ManStart();
- // create the PIs
- Abc_AigConst1(pNtk)->pCopy = (Abc_Obj_t *)Ivy_ManConst1(pMan);
- Abc_NtkForEachCi( pNtk, pObj, i )
- pObj->pCopy = (Abc_Obj_t *)Ivy_ObjCreatePi(pMan);
- // perform the conversion of the internal nodes
- Abc_AigForEachAnd( pNtk, pObj, i )
- pObj->pCopy = (Abc_Obj_t *)Ivy_And( pMan, (Ivy_Obj_t *)Abc_ObjChild0Copy(pObj), (Ivy_Obj_t *)Abc_ObjChild1Copy(pObj) );
- // create the POs
- Abc_NtkForEachCo( pNtk, pObj, i )
- Ivy_ObjCreatePo( pMan, (Ivy_Obj_t *)Abc_ObjChild0Copy(pObj) );
- Ivy_ManCleanup( pMan );
- return pMan;
-}
-
-/**Function*************************************************************
-
- Synopsis [Constructs the ABD network after mapping.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Abc_Ntk_t * Ivy_ManToAbc( Abc_Ntk_t * pNtk, Ivy_Man_t * pMan, Pla_Man_t * p, int fFastMode )
-{
- Abc_Ntk_t * pNtkNew;
- Abc_Obj_t * pObjAbc, * pObj;
- Ivy_Obj_t * pObjIvy;
- Vec_Int_t * vNodes, * vTemp;
- int i;
- // start mapping from Ivy into Abc
- pMan->pCopy = Vec_PtrStart( Ivy_ManObjIdMax(pMan) + 1 );
- // start the new ABC network
- pNtkNew = Abc_NtkStartFrom( pNtk, ABC_NTK_LOGIC, ABC_FUNC_SOP );
- // transfer the pointers to the basic nodes
- Abc_ObjSetIvy2Abc( pMan, Ivy_ManConst1(pMan)->Id, Abc_NodeCreateConst1(pNtkNew) );
- Abc_NtkForEachCi( pNtkNew, pObjAbc, i )
- Abc_ObjSetIvy2Abc( pMan, Ivy_ManPi(pMan, i)->Id, pObjAbc );
- // recursively construct the network
- vNodes = Vec_IntAlloc( 100 );
- vTemp = Vec_IntAlloc( 100 );
- Ivy_ManForEachPo( pMan, pObjIvy, i )
- {
- // get the new ABC node corresponding to the old fanin of the PO in IVY
- if ( fFastMode )
- pObjAbc = Ivy_ManToAbcFast_rec( pNtkNew, pMan, Ivy_ObjFanin0(pObjIvy), vNodes, vTemp );
- else
- pObjAbc = Ivy_ManToAbc_rec( pNtkNew, pMan, p, Ivy_ObjFanin0(pObjIvy), vNodes, vTemp );
- // consider the case of complemented fanin of the PO
- if ( Ivy_ObjFaninC0(pObjIvy) ) // complement
- {
- if ( Abc_ObjIsCi(pObjAbc) )
- pObjAbc = Abc_NodeCreateInv( pNtkNew, pObjAbc );
- else
- {
- // clone the node
- pObj = Abc_NtkCloneObj( pObjAbc );
- // set complemented functions
- pObj->pData = Abc_SopRegister( pNtkNew->pManFunc, pObjAbc->pData );
- Abc_SopComplement(pObj->pData);
- // return the new node
- pObjAbc = pObj;
- }
- assert( Abc_SopGetVarNum(pObjAbc->pData) == Abc_ObjFaninNum(pObjAbc) );
- }
- Abc_ObjAddFanin( Abc_NtkCo(pNtkNew, i), pObjAbc );
- }
- Vec_IntFree( vTemp );
- Vec_IntFree( vNodes );
- Vec_PtrFree( pMan->pCopy );
- pMan->pCopy = NULL;
- // remove dangling nodes
-// Abc_NtkForEachNode( pNtkNew, pObjAbc, i )
-// if ( Abc_ObjFanoutNum(pObjAbc) == 0 )
-// Abc_NtkDeleteObj(pObjAbc);
- Abc_NtkCleanup( pNtkNew, 0 );
- // fix CIs feeding directly into COs
- Abc_NtkLogicMakeSimpleCos( pNtkNew, 0 );
- return pNtkNew;
-}
-
-/**Function*************************************************************
-
- Synopsis [Recursively construct the new node.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Abc_Obj_t * Ivy_ManToAbc_rec( Abc_Ntk_t * pNtkNew, Ivy_Man_t * pMan, Pla_Man_t * p, Ivy_Obj_t * pObjIvy, Vec_Int_t * vNodes, Vec_Int_t * vTemp )
-{
- Vec_Int_t * vSupp;
- Esop_Cube_t * pCover, * pCube;
- Abc_Obj_t * pObjAbc, * pFaninAbc;
- Pla_Obj_t * pStr;
- int Entry, nCubes, i;
- unsigned * puTruth;
- // skip the node if it is a constant or already processed
- pObjAbc = Abc_ObjGetIvy2Abc( pMan, pObjIvy->Id );
- if ( pObjAbc )
- return pObjAbc;
- assert( Ivy_ObjIsAnd(pObjIvy) || Ivy_ObjIsExor(pObjIvy) );
- // get the support and the cover
- pStr = Ivy_ObjPlaStr( pMan, pObjIvy );
- if ( Vec_IntSize( &pStr->vSupp[0] ) <= p->nLutMax )
- {
- vSupp = &pStr->vSupp[0];
- pCover = PLA_EMPTY;
- }
- else
- {
- vSupp = &pStr->vSupp[1];
- pCover = pStr->pCover[1];
- assert( pCover != PLA_EMPTY );
- }
- // create new node and its fanins
- Vec_IntForEachEntry( vSupp, Entry, i )
- Ivy_ManToAbc_rec( pNtkNew, pMan, p, Ivy_ManObj(pMan, Entry), vNodes, vTemp );
- // consider the case of a LUT
- if ( pCover == PLA_EMPTY )
- {
- pObjAbc = Abc_NtkCreateNode( pNtkNew );
- Vec_IntForEachEntry( vSupp, Entry, i )
- Abc_ObjAddFanin( pObjAbc, Abc_ObjGetIvy2Abc(pMan, Entry) );
- // check if the truth table is constant 0
- puTruth = Ivy_ManCutTruth( pMan, pObjIvy, vSupp, vNodes, vTemp );
- // if the function is constant 0, create constant 0 node
- if ( Extra_TruthIsConst0(puTruth, 8) )
- {
- pObjAbc->pData = Abc_SopCreateAnd( pNtkNew->pManFunc, Vec_IntSize(vSupp), NULL );
- pObjAbc = Abc_NodeCreateConst0( pNtkNew );
- }
- else if ( Extra_TruthIsConst1(puTruth, 8) )
- {
- pObjAbc->pData = Abc_SopCreateAnd( pNtkNew->pManFunc, Vec_IntSize(vSupp), NULL );
- pObjAbc = Abc_NodeCreateConst1( pNtkNew );
- }
- else
- {
- int fCompl = Ivy_TruthIsop( puTruth, Vec_IntSize(vSupp), vNodes, 1 );
- if ( vNodes->nSize == -1 )
- printf( "Ivy_ManToAbc_rec(): Internal error.\n" );
- pObjAbc->pData = Abc_SopCreateFromIsop( pNtkNew->pManFunc, Vec_IntSize(vSupp), vNodes );
- if ( fCompl ) Abc_SopComplement(pObjAbc->pData);
-// printf( "Cover contains %d cubes.\n", Vec_IntSize(vNodes) );
-// pObjAbc->pData = Abc_SopCreateFromTruth( pNtkNew->pManFunc, Vec_IntSize(vSupp), puTruth );
- }
- }
- else
- {
- // for each cube, construct the node
- nCubes = Esop_CoverCountCubes( pCover );
- if ( nCubes == 0 )
- pObjAbc = Abc_NodeCreateConst0( pNtkNew );
- else if ( nCubes == 1 )
- pObjAbc = Ivy_ManToAigCube( pNtkNew, pMan, pObjIvy, pCover, vSupp );
- else
- {
- pObjAbc = Abc_NtkCreateNode( pNtkNew );
- Esop_CoverForEachCube( pCover, pCube )
- {
- pFaninAbc = Ivy_ManToAigCube( pNtkNew, pMan, pObjIvy, pCube, vSupp );
- Abc_ObjAddFanin( pObjAbc, pFaninAbc );
- }
- pObjAbc->pData = Abc_SopCreateXorSpecial( pNtkNew->pManFunc, Abc_ObjFaninNum(pObjAbc) );
- }
- }
- Abc_ObjSetIvy2Abc( pMan, pObjIvy->Id, pObjAbc );
- return pObjAbc;
-}
-
-/**Function*************************************************************
-
- Synopsis [Derives the decomposed network.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Abc_Obj_t * Ivy_ManToAigCube( Abc_Ntk_t * pNtkNew, Ivy_Man_t * pMan, Ivy_Obj_t * pObjIvy, Esop_Cube_t * pCube, Vec_Int_t * vSupp )
-{
- int pCompls[PLAYER_FANIN_LIMIT];
- Abc_Obj_t * pObjAbc, * pFaninAbc;
- int i, k, Value;
- // if tautology cube, create constant 1 node
- if ( pCube->nLits == 0 )
- return Abc_NodeCreateConst1(pNtkNew);
- // create AND node
- pObjAbc = Abc_NtkCreateNode( pNtkNew );
- for ( i = k = 0; i < (int)pCube->nVars; i++ )
- {
- Value = Esop_CubeGetVar( pCube, i );
- assert( Value != 0 );
- if ( Value == 3 )
- continue;
- pFaninAbc = Abc_ObjGetIvy2Abc( pMan, Vec_IntEntry(vSupp, i) );
- pFaninAbc = Abc_ObjNotCond( pFaninAbc, Value==1 );
- Abc_ObjAddFanin( pObjAbc, Abc_ObjRegular(pFaninAbc) );
- pCompls[k++] = Abc_ObjIsComplement(pFaninAbc);
- }
- pObjAbc->pData = Abc_SopCreateAnd( pNtkNew->pManFunc, Abc_ObjFaninNum(pObjAbc), pCompls );
- assert( Abc_ObjFaninNum(pObjAbc) == (int)pCube->nLits );
- return pObjAbc;
-}
-
-
-
-
-/**Function*************************************************************
-
- Synopsis [Recursively construct the new node.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Abc_Obj_t * Ivy_ManToAbcFast_rec( Abc_Ntk_t * pNtkNew, Ivy_Man_t * pMan, Ivy_Obj_t * pObjIvy, Vec_Int_t * vNodes, Vec_Int_t * vTemp )
-{
- Vec_Int_t Supp, * vSupp = &Supp;
- Abc_Obj_t * pObjAbc, * pFaninAbc;
- int i, Entry;
- unsigned * puTruth;
- // skip the node if it is a constant or already processed
- pObjAbc = Abc_ObjGetIvy2Abc( pMan, pObjIvy->Id );
- if ( pObjAbc )
- return pObjAbc;
- assert( Ivy_ObjIsAnd(pObjIvy) || Ivy_ObjIsExor(pObjIvy) );
- // get the support of K-LUT
- Ivy_FastMapReadSupp( pMan, pObjIvy, vSupp );
- // create new ABC node and its fanins
- pObjAbc = Abc_NtkCreateNode( pNtkNew );
- Vec_IntForEachEntry( vSupp, Entry, i )
- {
- pFaninAbc = Ivy_ManToAbcFast_rec( pNtkNew, pMan, Ivy_ManObj(pMan, Entry), vNodes, vTemp );
- Abc_ObjAddFanin( pObjAbc, pFaninAbc );
- }
- // check if the truth table is constant 0
- puTruth = Ivy_ManCutTruth( pMan, pObjIvy, vSupp, vNodes, vTemp );
- // if the function is constant 0, create constant 0 node
- if ( Extra_TruthIsConst0(puTruth, 8) )
- {
- pObjAbc->pData = Abc_SopCreateAnd( pNtkNew->pManFunc, Vec_IntSize(vSupp), NULL );
- pObjAbc = Abc_NodeCreateConst0( pNtkNew );
- }
- else if ( Extra_TruthIsConst1(puTruth, 8) )
- {
- pObjAbc->pData = Abc_SopCreateAnd( pNtkNew->pManFunc, Vec_IntSize(vSupp), NULL );
- pObjAbc = Abc_NodeCreateConst1( pNtkNew );
- }
- else
- {
- int fCompl = Ivy_TruthIsop( puTruth, Vec_IntSize(vSupp), vNodes, 1 );
- if ( vNodes->nSize == -1 )
- printf( "Ivy_ManToAbcFast_rec(): Internal error.\n" );
- pObjAbc->pData = Abc_SopCreateFromIsop( pNtkNew->pManFunc, Vec_IntSize(vSupp), vNodes );
- if ( fCompl ) Abc_SopComplement(pObjAbc->pData);
- }
- Abc_ObjSetIvy2Abc( pMan, pObjIvy->Id, pObjAbc );
- return pObjAbc;
-}
-
-
-/**Function*************************************************************
-
- Synopsis [Computes cost of the node.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Abc_NodePlayerCost( int nFanins )
-{
- if ( nFanins <= 4 )
- return 1;
- if ( nFanins <= 6 )
- return 2;
- if ( nFanins <= 8 )
- return 4;
- if ( nFanins <= 16 )
- return 8;
- if ( nFanins <= 32 )
- return 16;
- if ( nFanins <= 64 )
- return 32;
- if ( nFanins <= 128 )
- return 64;
- assert( 0 );
- return 0;
-}
-
-/**Function*************************************************************
-
- Synopsis [Computes the number of ranks needed for one level.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Abc_NtkPlayerCostOneLevel( int nCost, int RankCost )
-{
- return (nCost / RankCost) + ((nCost % RankCost) > 0);
-}
-
-/**Function*************************************************************
-
- Synopsis [Computes the cost function for the network (number of ranks).]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-int Abc_NtkPlayerCost( Abc_Ntk_t * pNtk, int RankCost, int fVerbose )
-{
- Abc_Obj_t * pObj;
- int * pLevelCosts, * pLevelCostsR;
- int Cost, CostTotal, CostTotalR, nRanksTotal, nRanksTotalR;
- int nFanins, nLevels, LevelR, i;
- // compute the reverse levels
- Abc_NtkStartReverseLevels( pNtk );
- // compute the costs for each level
- nLevels = Abc_NtkGetLevelNum( pNtk );
- pLevelCosts = ALLOC( int, nLevels + 1 );
- pLevelCostsR = ALLOC( int, nLevels + 1 );
- memset( pLevelCosts, 0, sizeof(int) * (nLevels + 1) );
- memset( pLevelCostsR, 0, sizeof(int) * (nLevels + 1) );
- Abc_NtkForEachNode( pNtk, pObj, i )
- {
- nFanins = Abc_ObjFaninNum(pObj);
- if ( nFanins == 0 )
- continue;
- Cost = Abc_NodePlayerCost( nFanins );
- LevelR = Vec_IntEntry( pNtk->vLevelsR, pObj->Id );
- pLevelCosts[ pObj->Level ] += Cost;
- pLevelCostsR[ LevelR ] += Cost;
- }
- // compute the total cost
- CostTotal = CostTotalR = nRanksTotal = nRanksTotalR = 0;
- for ( i = 0; i <= nLevels; i++ )
- {
- CostTotal += pLevelCosts[i];
- CostTotalR += pLevelCostsR[i];
- nRanksTotal += Abc_NtkPlayerCostOneLevel( pLevelCosts[i], RankCost );
- nRanksTotalR += Abc_NtkPlayerCostOneLevel( pLevelCostsR[i], RankCost );
- }
- assert( CostTotal == CostTotalR );
- // print out statistics
- if ( fVerbose )
- {
- for ( i = 1; i <= nLevels; i++ )
- {
- printf( "Level %2d : Cost = %7d. Ranks = %6.3f. Cost = %7d. Ranks = %6.3f.\n", i,
- pLevelCosts[i], ((double)pLevelCosts[i])/RankCost,
- pLevelCostsR[nLevels+1-i], ((double)pLevelCostsR[nLevels+1-i])/RankCost );
- }
- printf( "TOTAL : Cost = %7d. Ranks = %6d. RanksR = %5d. RanksBest = %5d.\n",
- CostTotal, nRanksTotal, nRanksTotalR, nLevels );
- }
- free( pLevelCosts );
- free( pLevelCostsR );
- return nRanksTotal;
-}
-
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/temp/player/playerUtil.c b/src/temp/player/playerUtil.c
deleted file mode 100644
index 1c8aeec2..00000000
--- a/src/temp/player/playerUtil.c
+++ /dev/null
@@ -1,353 +0,0 @@
-/**CFile****************************************************************
-
- FileName [playerUtil.c]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [PLA decomposition package.]
-
- Synopsis []
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - May 11, 2006.]
-
- Revision [$Id: playerUtil.c,v 1.00 2006/05/11 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#include "player.h"
-
-////////////////////////////////////////////////////////////////////////
-/// DECLARATIONS ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis [Merges two supports.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-int Pla_ManMergeTwoSupports( Pla_Man_t * p, Vec_Int_t * vSupp0, Vec_Int_t * vSupp1, Vec_Int_t * vSupp )
-{
- int k0, k1;
-
- assert( vSupp0->nSize && vSupp1->nSize );
-
- Vec_IntFill( p->vComTo0, vSupp0->nSize + vSupp1->nSize, -1 );
- Vec_IntFill( p->vComTo1, vSupp0->nSize + vSupp1->nSize, -1 );
- Vec_IntClear( p->vPairs0 );
- Vec_IntClear( p->vPairs1 );
-
- vSupp->nSize = 0;
- vSupp->nCap = vSupp0->nSize + vSupp1->nSize;
- vSupp->pArray = ALLOC( int, vSupp->nCap );
-
- for ( k0 = k1 = 0; k0 < vSupp0->nSize && k1 < vSupp1->nSize; )
- {
- if ( vSupp0->pArray[k0] == vSupp1->pArray[k1] )
- {
- Vec_IntWriteEntry( p->vComTo0, vSupp->nSize, k0 );
- Vec_IntWriteEntry( p->vComTo1, vSupp->nSize, k1 );
- Vec_IntPush( p->vPairs0, k0 );
- Vec_IntPush( p->vPairs1, k1 );
- Vec_IntPush( vSupp, vSupp0->pArray[k0] );
- k0++; k1++;
- }
- else if ( vSupp0->pArray[k0] < vSupp1->pArray[k1] )
- {
- Vec_IntWriteEntry( p->vComTo0, vSupp->nSize, k0 );
- Vec_IntPush( vSupp, vSupp0->pArray[k0] );
- k0++;
- }
- else
- {
- Vec_IntWriteEntry( p->vComTo1, vSupp->nSize, k1 );
- Vec_IntPush( vSupp, vSupp1->pArray[k1] );
- k1++;
- }
- }
- for ( ; k0 < vSupp0->nSize; k0++ )
- {
- Vec_IntWriteEntry( p->vComTo0, vSupp->nSize, k0 );
- Vec_IntPush( vSupp, vSupp0->pArray[k0] );
- }
- for ( ; k1 < vSupp1->nSize; k1++ )
- {
- Vec_IntWriteEntry( p->vComTo1, vSupp->nSize, k1 );
- Vec_IntPush( vSupp, vSupp1->pArray[k1] );
- }
-/*
- printf( "Zero : " );
- for ( k = 0; k < vSupp0->nSize; k++ )
- printf( "%d ", vSupp0->pArray[k] );
- printf( "\n" );
-
- printf( "One : " );
- for ( k = 0; k < vSupp1->nSize; k++ )
- printf( "%d ", vSupp1->pArray[k] );
- printf( "\n" );
-
- printf( "Sum : " );
- for ( k = 0; k < vSupp->nSize; k++ )
- printf( "%d ", vSupp->pArray[k] );
- printf( "\n" );
- printf( "\n" );
-*/
- return Vec_IntSize(vSupp);
-}
-
-
-/**Function*************************************************************
-
- Synopsis [Computes the produce of two covers.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Esop_Cube_t * Pla_ManAndTwoCovers( Pla_Man_t * p, Esop_Cube_t * pCover0, Esop_Cube_t * pCover1, int nSupp, int fStopAtLimit )
-{
- Esop_Cube_t * pCube, * pCube0, * pCube1;
- Esop_Cube_t * pCover;
- int i, Val0, Val1;
- assert( pCover0 != PLA_EMPTY && pCover1 != PLA_EMPTY );
-
- // clean storage
- assert( nSupp <= p->nPlaMax );
- Esop_ManClean( p->pManMin, nSupp );
- // go through the cube pairs
- Esop_CoverForEachCube( pCover0, pCube0 )
- Esop_CoverForEachCube( pCover1, pCube1 )
- {
- // go through the support variables of the cubes
- for ( i = 0; i < p->vPairs0->nSize; i++ )
- {
- Val0 = Esop_CubeGetVar( pCube0, p->vPairs0->pArray[i] );
- Val1 = Esop_CubeGetVar( pCube1, p->vPairs1->pArray[i] );
- if ( (Val0 & Val1) == 0 )
- break;
- }
- // check disjointness
- if ( i < p->vPairs0->nSize )
- continue;
-
- if ( fStopAtLimit && p->pManMin->nCubes > p->nCubesMax )
- {
- pCover = Esop_CoverCollect( p->pManMin, nSupp );
-//Esop_CoverWriteFile( pCover, "large", 1 );
- Esop_CoverRecycle( p->pManMin, pCover );
- return PLA_EMPTY;
- }
-
- // create the product cube
- pCube = Esop_CubeAlloc( p->pManMin );
-
- // add the literals
- pCube->nLits = 0;
- for ( i = 0; i < nSupp; i++ )
- {
- if ( p->vComTo0->pArray[i] == -1 )
- Val0 = 3;
- else
- Val0 = Esop_CubeGetVar( pCube0, p->vComTo0->pArray[i] );
-
- if ( p->vComTo1->pArray[i] == -1 )
- Val1 = 3;
- else
- Val1 = Esop_CubeGetVar( pCube1, p->vComTo1->pArray[i] );
-
- if ( (Val0 & Val1) == 3 )
- continue;
-
- Esop_CubeXorVar( pCube, i, (Val0 & Val1) ^ 3 );
- pCube->nLits++;
- }
- // add the cube to storage
- Esop_EsopAddCube( p->pManMin, pCube );
- }
-
- // minimize the cover
- Esop_EsopMinimize( p->pManMin );
- pCover = Esop_CoverCollect( p->pManMin, nSupp );
-
- // quit if the cover is too large
- if ( fStopAtLimit && Esop_CoverCountCubes(pCover) > p->nPlaMax )
- {
- Esop_CoverRecycle( p->pManMin, pCover );
- return PLA_EMPTY;
- }
-// if ( pCover && pCover->nWords > 4 )
-// printf( "%d", pCover->nWords );
-// else
-// printf( "." );
- return pCover;
-}
-
-/**Function*************************************************************
-
- Synopsis [Computes the EXOR of two covers.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-Esop_Cube_t * Pla_ManExorTwoCovers( Pla_Man_t * p, Esop_Cube_t * pCover0, Esop_Cube_t * pCover1, int nSupp, int fStopAtLimit )
-{
- Esop_Cube_t * pCube, * pCube0, * pCube1;
- Esop_Cube_t * pCover;
- int i, Val0, Val1;
- assert( pCover0 != PLA_EMPTY && pCover1 != PLA_EMPTY );
-
- // clean storage
- assert( nSupp <= p->nPlaMax );
- Esop_ManClean( p->pManMin, nSupp );
- Esop_CoverForEachCube( pCover0, pCube0 )
- {
- // create the cube
- pCube = Esop_CubeAlloc( p->pManMin );
- pCube->nLits = 0;
- for ( i = 0; i < p->vComTo0->nSize; i++ )
- {
- if ( p->vComTo0->pArray[i] == -1 )
- continue;
- Val0 = Esop_CubeGetVar( pCube0, p->vComTo0->pArray[i] );
- if ( Val0 == 3 )
- continue;
- Esop_CubeXorVar( pCube, i, Val0 ^ 3 );
- pCube->nLits++;
- }
- if ( fStopAtLimit && p->pManMin->nCubes > p->nCubesMax )
- {
- pCover = Esop_CoverCollect( p->pManMin, nSupp );
- Esop_CoverRecycle( p->pManMin, pCover );
- return PLA_EMPTY;
- }
- // add the cube to storage
- Esop_EsopAddCube( p->pManMin, pCube );
- }
- Esop_CoverForEachCube( pCover1, pCube1 )
- {
- // create the cube
- pCube = Esop_CubeAlloc( p->pManMin );
- pCube->nLits = 0;
- for ( i = 0; i < p->vComTo1->nSize; i++ )
- {
- if ( p->vComTo1->pArray[i] == -1 )
- continue;
- Val1 = Esop_CubeGetVar( pCube1, p->vComTo1->pArray[i] );
- if ( Val1 == 3 )
- continue;
- Esop_CubeXorVar( pCube, i, Val1 ^ 3 );
- pCube->nLits++;
- }
- if ( fStopAtLimit && p->pManMin->nCubes > p->nCubesMax )
- {
- pCover = Esop_CoverCollect( p->pManMin, nSupp );
- Esop_CoverRecycle( p->pManMin, pCover );
- return PLA_EMPTY;
- }
- // add the cube to storage
- Esop_EsopAddCube( p->pManMin, pCube );
- }
-
- // minimize the cover
- Esop_EsopMinimize( p->pManMin );
- pCover = Esop_CoverCollect( p->pManMin, nSupp );
-
- // quit if the cover is too large
- if ( fStopAtLimit && Esop_CoverCountCubes(pCover) > p->nPlaMax )
- {
- Esop_CoverRecycle( p->pManMin, pCover );
- return PLA_EMPTY;
- }
- return pCover;
-}
-
-#if 0
-
-/**Function*************************************************************
-
- Synopsis [Computes area/delay of the mapping.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-void Pla_ManComputeStats( Ivy_Man_t * p, Vec_Int_t * vNodes )
-{
- Ivy_Obj_t * pObj, * pFanin;
- Vec_Int_t * vFanins;
- int Area, Delay, Fanin, nFanins, i, k;
-
- Delay = Area = 0;
- // compute levels and area
- Ivy_ManForEachPi( p, pObj, i )
- pObj->Level = 0;
- Ivy_ManForEachNodeVec( p, vNodes, pObj, i )
- {
- // compute level of the node
- pObj->Level = 0;
- vFanins = Ivy_ObjGetFanins( pObj );
- Vec_IntForEachEntry( vFanins, Fanin, k )
- {
- pFanin = Ivy_ManObj(p, Ivy_EdgeId(Fanin));
- pObj->Level = IVY_MAX( pObj->Level, pFanin->Level );
- }
- pObj->Level += 1;
- // compute area of the node
- nFanins = Ivy_ObjFaninNum( pObj );
- if ( nFanins <= 4 )
- Area += 1;
- else if ( nFanins <= 6 )
- Area += 2;
- else if ( nFanins <= 8 )
- Area += 4;
- else if ( nFanins <= 16 )
- Area += 8;
- else if ( nFanins <= 32 )
- Area += 16;
- else if ( nFanins <= 64 )
- Area += 32;
- else if ( nFanins <= 128 )
- Area += 64;
- else
- assert( 0 );
- }
- Ivy_ManForEachPo( p, pObj, i )
- {
- Fanin = Ivy_ObjReadFanin(pObj, 0);
- pFanin = Ivy_ManObj( p, Ivy_EdgeId(Fanin) );
- pObj->Level = pFanin->Level;
- Delay = IVY_MAX( Delay, (int)pObj->Level );
- }
- printf( "Area = %d. Delay = %d.\n", Area, Delay );
-}
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
-
diff --git a/src/temp/vec/module.make b/src/temp/vec/module.make
deleted file mode 100644
index d6d908e7..00000000
--- a/src/temp/vec/module.make
+++ /dev/null
@@ -1 +0,0 @@
-SRC +=
diff --git a/src/temp/vec/vecInt.h b/src/temp/vec/vecInt.h
deleted file mode 100644
index 4a97fc91..00000000
--- a/src/temp/vec/vecInt.h
+++ /dev/null
@@ -1,775 +0,0 @@
-/**CFile****************************************************************
-
- FileName [vecInt.h]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [Resizable arrays.]
-
- Synopsis [Resizable arrays of integers.]
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - June 20, 2005.]
-
- Revision [$Id: vecInt.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#ifndef __VEC_INT_H__
-#define __VEC_INT_H__
-
-////////////////////////////////////////////////////////////////////////
-/// INCLUDES ///
-////////////////////////////////////////////////////////////////////////
-
-#include "extra.h"
-
-////////////////////////////////////////////////////////////////////////
-/// PARAMETERS ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-/// BASIC TYPES ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Vec_Int_t_ Vec_Int_t;
-struct Vec_Int_t_
-{
- int nCap;
- int nSize;
- int * pArray;
-};
-
-////////////////////////////////////////////////////////////////////////
-/// MACRO DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-#define Vec_IntForEachEntry( vVec, Entry, i ) \
- for ( i = 0; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
-#define Vec_IntForEachEntryStart( vVec, Entry, i, Start ) \
- for ( i = Start; (i < Vec_IntSize(vVec)) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
-#define Vec_IntForEachEntryStartStop( vVec, Entry, i, Start, Stop ) \
- for ( i = Start; (i < Stop) && (((Entry) = Vec_IntEntry(vVec, i)), 1); i++ )
-#define Vec_IntForEachEntryReverse( vVec, pEntry, i ) \
- for ( i = Vec_IntSize(vVec) - 1; (i >= 0) && (((pEntry) = Vec_IntEntry(vVec, i)), 1); i-- )
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis [Allocates a vector with the given capacity.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Int_t * Vec_IntAlloc( int nCap )
-{
- Vec_Int_t * p;
- p = ALLOC( Vec_Int_t, 1 );
- if ( nCap > 0 && nCap < 16 )
- nCap = 16;
- p->nSize = 0;
- p->nCap = nCap;
- p->pArray = p->nCap? ALLOC( int, p->nCap ) : NULL;
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Allocates a vector with the given size and cleans it.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Int_t * Vec_IntStart( int nSize )
-{
- Vec_Int_t * p;
- p = Vec_IntAlloc( nSize );
- p->nSize = nSize;
- memset( p->pArray, 0, sizeof(int) * nSize );
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Creates the vector from an integer array of the given size.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Int_t * Vec_IntAllocArray( int * pArray, int nSize )
-{
- Vec_Int_t * p;
- p = ALLOC( Vec_Int_t, 1 );
- p->nSize = nSize;
- p->nCap = nSize;
- p->pArray = pArray;
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Creates the vector from an integer array of the given size.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Int_t * Vec_IntAllocArrayCopy( int * pArray, int nSize )
-{
- Vec_Int_t * p;
- p = ALLOC( Vec_Int_t, 1 );
- p->nSize = nSize;
- p->nCap = nSize;
- p->pArray = ALLOC( int, nSize );
- memcpy( p->pArray, pArray, sizeof(int) * nSize );
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Duplicates the integer array.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Int_t * Vec_IntDup( Vec_Int_t * pVec )
-{
- Vec_Int_t * p;
- p = ALLOC( Vec_Int_t, 1 );
- p->nSize = pVec->nSize;
- p->nCap = pVec->nCap;
- p->pArray = p->nCap? ALLOC( int, p->nCap ) : NULL;
- memcpy( p->pArray, pVec->pArray, sizeof(int) * pVec->nSize );
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Transfers the array into another vector.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Int_t * Vec_IntDupArray( Vec_Int_t * pVec )
-{
- Vec_Int_t * p;
- p = ALLOC( Vec_Int_t, 1 );
- p->nSize = pVec->nSize;
- p->nCap = pVec->nCap;
- p->pArray = pVec->pArray;
- pVec->nSize = 0;
- pVec->nCap = 0;
- pVec->pArray = NULL;
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntFree( Vec_Int_t * p )
-{
- FREE( p->pArray );
- FREE( p );
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int * Vec_IntReleaseArray( Vec_Int_t * p )
-{
- int * pArray = p->pArray;
- p->nCap = 0;
- p->nSize = 0;
- p->pArray = NULL;
- return pArray;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int * Vec_IntArray( Vec_Int_t * p )
-{
- return p->pArray;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_IntSize( Vec_Int_t * p )
-{
- return p->nSize;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_IntEntry( Vec_Int_t * p, int i )
-{
- assert( i >= 0 && i < p->nSize );
- return p->pArray[i];
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntWriteEntry( Vec_Int_t * p, int i, int Entry )
-{
- assert( i >= 0 && i < p->nSize );
- p->pArray[i] = Entry;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntAddToEntry( Vec_Int_t * p, int i, int Addition )
-{
- assert( i >= 0 && i < p->nSize );
- p->pArray[i] += Addition;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_IntEntryLast( Vec_Int_t * p )
-{
- assert( p->nSize > 0 );
- return p->pArray[p->nSize-1];
-}
-
-/**Function*************************************************************
-
- Synopsis [Resizes the vector to the given capacity.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntGrow( Vec_Int_t * p, int nCapMin )
-{
- if ( p->nCap >= nCapMin )
- return;
- p->pArray = REALLOC( int, p->pArray, nCapMin );
- assert( p->pArray );
- p->nCap = nCapMin;
-}
-
-/**Function*************************************************************
-
- Synopsis [Fills the vector with given number of entries.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntFill( Vec_Int_t * p, int nSize, int Entry )
-{
- int i;
- Vec_IntGrow( p, nSize );
- for ( i = 0; i < nSize; i++ )
- p->pArray[i] = Entry;
- p->nSize = nSize;
-}
-
-/**Function*************************************************************
-
- Synopsis [Fills the vector with given number of entries.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntFillExtra( Vec_Int_t * p, int nSize, int Entry )
-{
- int i;
- if ( p->nSize >= nSize )
- return;
- Vec_IntGrow( p, nSize );
- for ( i = p->nSize; i < nSize; i++ )
- p->pArray[i] = Entry;
- p->nSize = nSize;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntShrink( Vec_Int_t * p, int nSizeNew )
-{
- assert( p->nSize >= nSizeNew );
- p->nSize = nSizeNew;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntClear( Vec_Int_t * p )
-{
- p->nSize = 0;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntPush( Vec_Int_t * p, int Entry )
-{
- if ( p->nSize == p->nCap )
- {
- if ( p->nCap < 16 )
- Vec_IntGrow( p, 16 );
- else
- Vec_IntGrow( p, 2 * p->nCap );
- }
- p->pArray[p->nSize++] = Entry;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntPushFirst( Vec_Int_t * p, int Entry )
-{
- int i;
- if ( p->nSize == p->nCap )
- {
- if ( p->nCap < 16 )
- Vec_IntGrow( p, 16 );
- else
- Vec_IntGrow( p, 2 * p->nCap );
- }
- p->nSize++;
- for ( i = p->nSize - 1; i >= 1; i-- )
- p->pArray[i] = p->pArray[i-1];
- p->pArray[0] = Entry;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntPushMem( Extra_MmStep_t * pMemMan, Vec_Int_t * p, int Entry )
-{
- if ( p->nSize == p->nCap )
- {
- int * pArray;
- int i;
-
- if ( p->nSize == 0 )
- p->nCap = 1;
- pArray = (int *)Extra_MmStepEntryFetch( pMemMan, p->nCap * 8 );
-// pArray = ALLOC( int, p->nCap * 2 );
- if ( p->pArray )
- {
- for ( i = 0; i < p->nSize; i++ )
- pArray[i] = p->pArray[i];
- Extra_MmStepEntryRecycle( pMemMan, (char *)p->pArray, p->nCap * 4 );
-// free( p->pArray );
- }
- p->nCap *= 2;
- p->pArray = pArray;
- }
- p->pArray[p->nSize++] = Entry;
-}
-
-/**Function*************************************************************
-
- Synopsis [Inserts the entry while preserving the increasing order.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntPushOrder( Vec_Int_t * p, int Entry )
-{
- int i;
- if ( p->nSize == p->nCap )
- {
- if ( p->nCap < 16 )
- Vec_IntGrow( p, 16 );
- else
- Vec_IntGrow( p, 2 * p->nCap );
- }
- p->nSize++;
- for ( i = p->nSize-2; i >= 0; i-- )
- if ( p->pArray[i] > Entry )
- p->pArray[i+1] = p->pArray[i];
- else
- break;
- p->pArray[i+1] = Entry;
-}
-
-/**Function*************************************************************
-
- Synopsis [Inserts the entry while preserving the increasing order.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_IntPushUniqueOrder( Vec_Int_t * p, int Entry )
-{
- int i;
- for ( i = 0; i < p->nSize; i++ )
- if ( p->pArray[i] == Entry )
- return 1;
- Vec_IntPushOrder( p, Entry );
- return 0;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_IntPushUnique( Vec_Int_t * p, int Entry )
-{
- int i;
- for ( i = 0; i < p->nSize; i++ )
- if ( p->pArray[i] == Entry )
- return 1;
- Vec_IntPush( p, Entry );
- return 0;
-}
-
-/**Function*************************************************************
-
- Synopsis [Returns the pointer to the next nWords entries in the vector.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline unsigned * Vec_IntFetch( Vec_Int_t * p, int nWords )
-{
- p->nSize += nWords;
- if ( p->nSize > p->nCap )
- {
-// Vec_IntGrow( p, 2 * p->nSize );
- return NULL;
- }
- return ((unsigned *)p->pArray) + p->nSize - nWords;
-}
-
-/**Function*************************************************************
-
- Synopsis [Returns the last entry and removes it from the list.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_IntPop( Vec_Int_t * p )
-{
- assert( p->nSize > 0 );
- return p->pArray[--p->nSize];
-}
-
-/**Function*************************************************************
-
- Synopsis [Find entry.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_IntFind( Vec_Int_t * p, int Entry )
-{
- int i;
- for ( i = 0; i < p->nSize; i++ )
- if ( p->pArray[i] == Entry )
- return i;
- return -1;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_IntRemove( Vec_Int_t * p, int Entry )
-{
- int i;
- for ( i = 0; i < p->nSize; i++ )
- if ( p->pArray[i] == Entry )
- break;
- if ( i == p->nSize )
- return 0;
- assert( i < p->nSize );
- for ( i++; i < p->nSize; i++ )
- p->pArray[i-1] = p->pArray[i];
- p->nSize--;
- return 1;
-}
-
-/**Function*************************************************************
-
- Synopsis [Comparison procedure for two integers.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_IntSortCompare1( int * pp1, int * pp2 )
-{
- // for some reason commenting out lines (as shown) led to crashing of the release version
- if ( *pp1 < *pp2 )
- return -1;
- if ( *pp1 > *pp2 ) //
- return 1;
- return 0; //
-}
-
-/**Function*************************************************************
-
- Synopsis [Comparison procedure for two integers.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_IntSortCompare2( int * pp1, int * pp2 )
-{
- // for some reason commenting out lines (as shown) led to crashing of the release version
- if ( *pp1 > *pp2 )
- return -1;
- if ( *pp1 < *pp2 ) //
- return 1;
- return 0; //
-}
-
-/**Function*************************************************************
-
- Synopsis [Sorting the entries by their integer value.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntSort( Vec_Int_t * p, int fReverse )
-{
- if ( fReverse )
- qsort( (void *)p->pArray, p->nSize, sizeof(int),
- (int (*)(const void *, const void *)) Vec_IntSortCompare2 );
- else
- qsort( (void *)p->pArray, p->nSize, sizeof(int),
- (int (*)(const void *, const void *)) Vec_IntSortCompare1 );
-}
-
-
-/**Function*************************************************************
-
- Synopsis [Comparison procedure for two integers.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_IntSortCompareUnsigned( unsigned * pp1, unsigned * pp2 )
-{
- if ( *pp1 < *pp2 )
- return -1;
- if ( *pp1 > *pp2 )
- return 1;
- return 0;
-}
-
-/**Function*************************************************************
-
- Synopsis [Sorting the entries by their integer value.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_IntSortUnsigned( Vec_Int_t * p )
-{
- qsort( (void *)p->pArray, p->nSize, sizeof(int),
- (int (*)(const void *, const void *)) Vec_IntSortCompareUnsigned );
-}
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
diff --git a/src/temp/vec/vecPtr.h b/src/temp/vec/vecPtr.h
deleted file mode 100644
index 07ac0f17..00000000
--- a/src/temp/vec/vecPtr.h
+++ /dev/null
@@ -1,587 +0,0 @@
-/**CFile****************************************************************
-
- FileName [vecPtr.h]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [Resizable arrays.]
-
- Synopsis [Resizable arrays of generic pointers.]
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - June 20, 2005.]
-
- Revision [$Id: vecPtr.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#ifndef __VEC_PTR_H__
-#define __VEC_PTR_H__
-
-////////////////////////////////////////////////////////////////////////
-/// INCLUDES ///
-////////////////////////////////////////////////////////////////////////
-
-#include <stdio.h>
-#include "extra.h"
-
-////////////////////////////////////////////////////////////////////////
-/// PARAMETERS ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-/// BASIC TYPES ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Vec_Ptr_t_ Vec_Ptr_t;
-struct Vec_Ptr_t_
-{
- int nCap;
- int nSize;
- void ** pArray;
-};
-
-////////////////////////////////////////////////////////////////////////
-/// MACRO DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-// iterators through entries
-#define Vec_PtrForEachEntry( vVec, pEntry, i ) \
- for ( i = 0; (i < Vec_PtrSize(vVec)) && (((pEntry) = Vec_PtrEntry(vVec, i)), 1); i++ )
-#define Vec_PtrForEachEntryStart( vVec, pEntry, i, Start ) \
- for ( i = Start; (i < Vec_PtrSize(vVec)) && (((pEntry) = Vec_PtrEntry(vVec, i)), 1); i++ )
-#define Vec_PtrForEachEntryStop( vVec, pEntry, i, Stop ) \
- for ( i = 0; (i < Stop) && (((pEntry) = Vec_PtrEntry(vVec, i)), 1); i++ )
-#define Vec_PtrForEachEntryStartStop( vVec, pEntry, i, Start, Stop ) \
- for ( i = Start; (i < Stop) && (((pEntry) = Vec_PtrEntry(vVec, i)), 1); i++ )
-#define Vec_PtrForEachEntryReverse( vVec, pEntry, i ) \
- for ( i = Vec_PtrSize(vVec) - 1; (i >= 0) && (((pEntry) = Vec_PtrEntry(vVec, i)), 1); i-- )
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis [Allocates a vector with the given capacity.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Ptr_t * Vec_PtrAlloc( int nCap )
-{
- Vec_Ptr_t * p;
- p = ALLOC( Vec_Ptr_t, 1 );
- if ( nCap > 0 && nCap < 8 )
- nCap = 8;
- p->nSize = 0;
- p->nCap = nCap;
- p->pArray = p->nCap? ALLOC( void *, p->nCap ) : NULL;
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Allocates a vector with the given size and cleans it.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Ptr_t * Vec_PtrStart( int nSize )
-{
- Vec_Ptr_t * p;
- p = Vec_PtrAlloc( nSize );
- p->nSize = nSize;
- memset( p->pArray, 0, sizeof(void *) * nSize );
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Creates the vector from an integer array of the given size.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Ptr_t * Vec_PtrAllocArray( void ** pArray, int nSize )
-{
- Vec_Ptr_t * p;
- p = ALLOC( Vec_Ptr_t, 1 );
- p->nSize = nSize;
- p->nCap = nSize;
- p->pArray = pArray;
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Creates the vector from an integer array of the given size.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Ptr_t * Vec_PtrAllocArrayCopy( void ** pArray, int nSize )
-{
- Vec_Ptr_t * p;
- p = ALLOC( Vec_Ptr_t, 1 );
- p->nSize = nSize;
- p->nCap = nSize;
- p->pArray = ALLOC( void *, nSize );
- memcpy( p->pArray, pArray, sizeof(void *) * nSize );
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Duplicates the integer array.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Ptr_t * Vec_PtrDup( Vec_Ptr_t * pVec )
-{
- Vec_Ptr_t * p;
- p = ALLOC( Vec_Ptr_t, 1 );
- p->nSize = pVec->nSize;
- p->nCap = pVec->nCap;
- p->pArray = p->nCap? ALLOC( void *, p->nCap ) : NULL;
- memcpy( p->pArray, pVec->pArray, sizeof(void *) * pVec->nSize );
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Transfers the array into another vector.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Ptr_t * Vec_PtrDupArray( Vec_Ptr_t * pVec )
-{
- Vec_Ptr_t * p;
- p = ALLOC( Vec_Ptr_t, 1 );
- p->nSize = pVec->nSize;
- p->nCap = pVec->nCap;
- p->pArray = pVec->pArray;
- pVec->nSize = 0;
- pVec->nCap = 0;
- pVec->pArray = NULL;
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Frees the vector.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_PtrFree( Vec_Ptr_t * p )
-{
- FREE( p->pArray );
- FREE( p );
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void ** Vec_PtrReleaseArray( Vec_Ptr_t * p )
-{
- void ** pArray = p->pArray;
- p->nCap = 0;
- p->nSize = 0;
- p->pArray = NULL;
- return pArray;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void ** Vec_PtrArray( Vec_Ptr_t * p )
-{
- return p->pArray;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_PtrSize( Vec_Ptr_t * p )
-{
- return p->nSize;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void * Vec_PtrEntry( Vec_Ptr_t * p, int i )
-{
- assert( i >= 0 && i < p->nSize );
- return p->pArray[i];
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void ** Vec_PtrEntryP( Vec_Ptr_t * p, int i )
-{
- assert( i >= 0 && i < p->nSize );
- return p->pArray + i;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_PtrWriteEntry( Vec_Ptr_t * p, int i, void * Entry )
-{
- assert( i >= 0 && i < p->nSize );
- p->pArray[i] = Entry;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void * Vec_PtrEntryLast( Vec_Ptr_t * p )
-{
- assert( p->nSize > 0 );
- return p->pArray[p->nSize-1];
-}
-
-/**Function*************************************************************
-
- Synopsis [Resizes the vector to the given capacity.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_PtrGrow( Vec_Ptr_t * p, int nCapMin )
-{
- if ( p->nCap >= nCapMin )
- return;
- p->pArray = REALLOC( void *, p->pArray, nCapMin );
- p->nCap = nCapMin;
-}
-
-/**Function*************************************************************
-
- Synopsis [Fills the vector with given number of entries.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_PtrFill( Vec_Ptr_t * p, int nSize, void * Entry )
-{
- int i;
- Vec_PtrGrow( p, nSize );
- for ( i = 0; i < nSize; i++ )
- p->pArray[i] = Entry;
- p->nSize = nSize;
-}
-
-/**Function*************************************************************
-
- Synopsis [Fills the vector with given number of entries.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_PtrFillExtra( Vec_Ptr_t * p, int nSize, void * Entry )
-{
- int i;
- if ( p->nSize >= nSize )
- return;
- if ( p->nSize < 2 * nSize )
- Vec_PtrGrow( p, 2 * nSize );
- else
- Vec_PtrGrow( p, p->nSize );
- for ( i = p->nSize; i < nSize; i++ )
- p->pArray[i] = Entry;
- p->nSize = nSize;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_PtrShrink( Vec_Ptr_t * p, int nSizeNew )
-{
- assert( p->nSize >= nSizeNew );
- p->nSize = nSizeNew;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_PtrClear( Vec_Ptr_t * p )
-{
- p->nSize = 0;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_PtrPush( Vec_Ptr_t * p, void * Entry )
-{
- if ( p->nSize == p->nCap )
- {
- if ( p->nCap < 16 )
- Vec_PtrGrow( p, 16 );
- else
- Vec_PtrGrow( p, 2 * p->nCap );
- }
- p->pArray[p->nSize++] = Entry;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_PtrPushUnique( Vec_Ptr_t * p, void * Entry )
-{
- int i;
- for ( i = 0; i < p->nSize; i++ )
- if ( p->pArray[i] == Entry )
- return 1;
- Vec_PtrPush( p, Entry );
- return 0;
-}
-
-/**Function*************************************************************
-
- Synopsis [Returns the last entry and removes it from the list.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void * Vec_PtrPop( Vec_Ptr_t * p )
-{
- assert( p->nSize > 0 );
- return p->pArray[--p->nSize];
-}
-
-/**Function*************************************************************
-
- Synopsis [Find entry.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_PtrFind( Vec_Ptr_t * p, void * Entry )
-{
- int i;
- for ( i = 0; i < p->nSize; i++ )
- if ( p->pArray[i] == Entry )
- return i;
- return -1;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_PtrRemove( Vec_Ptr_t * p, void * Entry )
-{
- int i;
- // delete assuming that it is closer to the end
- for ( i = p->nSize - 1; i >= 0; i-- )
- if ( p->pArray[i] == Entry )
- break;
- assert( i >= 0 );
-/*
- // delete assuming that it is closer to the beginning
- for ( i = 0; i < p->nSize; i++ )
- if ( p->pArray[i] == Entry )
- break;
- assert( i < p->nSize );
-*/
- for ( i++; i < p->nSize; i++ )
- p->pArray[i-1] = p->pArray[i];
- p->nSize--;
-}
-
-/**Function*************************************************************
-
- Synopsis [Moves the first nItems to the end.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_PtrReorder( Vec_Ptr_t * p, int nItems )
-{
- assert( nItems < p->nSize );
- Vec_PtrGrow( p, nItems + p->nSize );
- memmove( (char **)p->pArray + p->nSize, p->pArray, nItems * sizeof(void*) );
- memmove( p->pArray, (char **)p->pArray + nItems, p->nSize * sizeof(void*) );
-}
-
-/**Function*************************************************************
-
- Synopsis [Sorting the entries by their integer value.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_PtrSort( Vec_Ptr_t * p, int (*Vec_PtrSortCompare)() )
-{
- qsort( (void *)p->pArray, p->nSize, sizeof(void *),
- (int (*)(const void *, const void *)) Vec_PtrSortCompare );
-}
-
-#endif
-
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
diff --git a/src/temp/vec/vecStr.h b/src/temp/vec/vecStr.h
deleted file mode 100644
index eb6aa41d..00000000
--- a/src/temp/vec/vecStr.h
+++ /dev/null
@@ -1,510 +0,0 @@
-/**CFile****************************************************************
-
- FileName [vecStr.h]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [Resizable arrays.]
-
- Synopsis [Resizable arrays of characters.]
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - June 20, 2005.]
-
- Revision [$Id: vecStr.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#ifndef __VEC_STR_H__
-#define __VEC_STR_H__
-
-////////////////////////////////////////////////////////////////////////
-/// INCLUDES ///
-////////////////////////////////////////////////////////////////////////
-
-#include <stdio.h>
-#include "extra.h"
-
-////////////////////////////////////////////////////////////////////////
-/// PARAMETERS ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-/// BASIC TYPES ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Vec_Str_t_ Vec_Str_t;
-struct Vec_Str_t_
-{
- int nCap;
- int nSize;
- char * pArray;
-};
-
-////////////////////////////////////////////////////////////////////////
-/// MACRO DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-#define Vec_StrForEachEntry( vVec, Entry, i ) \
- for ( i = 0; (i < Vec_StrSize(vVec)) && (((Entry) = Vec_StrEntry(vVec, i)), 1); i++ )
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis [Allocates a vector with the given capacity.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Str_t * Vec_StrAlloc( int nCap )
-{
- Vec_Str_t * p;
- p = ALLOC( Vec_Str_t, 1 );
- if ( nCap > 0 && nCap < 16 )
- nCap = 16;
- p->nSize = 0;
- p->nCap = nCap;
- p->pArray = p->nCap? ALLOC( char, p->nCap ) : NULL;
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Allocates a vector with the given size and cleans it.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Str_t * Vec_StrStart( int nSize )
-{
- Vec_Str_t * p;
- p = Vec_StrAlloc( nSize );
- p->nSize = nSize;
- memset( p->pArray, 0, sizeof(char) * nSize );
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Creates the vector from an integer array of the given size.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Str_t * Vec_StrAllocArray( char * pArray, int nSize )
-{
- Vec_Str_t * p;
- p = ALLOC( Vec_Str_t, 1 );
- p->nSize = nSize;
- p->nCap = nSize;
- p->pArray = pArray;
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Creates the vector from an integer array of the given size.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Str_t * Vec_StrAllocArrayCopy( char * pArray, int nSize )
-{
- Vec_Str_t * p;
- p = ALLOC( Vec_Str_t, 1 );
- p->nSize = nSize;
- p->nCap = nSize;
- p->pArray = ALLOC( char, nSize );
- memcpy( p->pArray, pArray, sizeof(char) * nSize );
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Duplicates the integer array.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Str_t * Vec_StrDup( Vec_Str_t * pVec )
-{
- Vec_Str_t * p;
- p = ALLOC( Vec_Str_t, 1 );
- p->nSize = pVec->nSize;
- p->nCap = pVec->nCap;
- p->pArray = p->nCap? ALLOC( char, p->nCap ) : NULL;
- memcpy( p->pArray, pVec->pArray, sizeof(char) * pVec->nSize );
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Transfers the array into another vector.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Str_t * Vec_StrDupArray( Vec_Str_t * pVec )
-{
- Vec_Str_t * p;
- p = ALLOC( Vec_Str_t, 1 );
- p->nSize = pVec->nSize;
- p->nCap = pVec->nCap;
- p->pArray = pVec->pArray;
- pVec->nSize = 0;
- pVec->nCap = 0;
- pVec->pArray = NULL;
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_StrFree( Vec_Str_t * p )
-{
- FREE( p->pArray );
- FREE( p );
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline char * Vec_StrReleaseArray( Vec_Str_t * p )
-{
- char * pArray = p->pArray;
- p->nCap = 0;
- p->nSize = 0;
- p->pArray = NULL;
- return pArray;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline char * Vec_StrArray( Vec_Str_t * p )
-{
- return p->pArray;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_StrSize( Vec_Str_t * p )
-{
- return p->nSize;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline char Vec_StrEntry( Vec_Str_t * p, int i )
-{
- assert( i >= 0 && i < p->nSize );
- return p->pArray[i];
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_StrWriteEntry( Vec_Str_t * p, int i, char Entry )
-{
- assert( i >= 0 && i < p->nSize );
- p->pArray[i] = Entry;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline char Vec_StrEntryLast( Vec_Str_t * p )
-{
- assert( p->nSize > 0 );
- return p->pArray[p->nSize-1];
-}
-
-/**Function*************************************************************
-
- Synopsis [Resizes the vector to the given capacity.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_StrGrow( Vec_Str_t * p, int nCapMin )
-{
- if ( p->nCap >= nCapMin )
- return;
- p->pArray = REALLOC( char, p->pArray, 2 * nCapMin );
- p->nCap = 2 * nCapMin;
-}
-
-/**Function*************************************************************
-
- Synopsis [Fills the vector with given number of entries.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_StrFill( Vec_Str_t * p, int nSize, char Entry )
-{
- int i;
- Vec_StrGrow( p, nSize );
- p->nSize = nSize;
- for ( i = 0; i < p->nSize; i++ )
- p->pArray[i] = Entry;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_StrShrink( Vec_Str_t * p, int nSizeNew )
-{
- assert( p->nSize >= nSizeNew );
- p->nSize = nSizeNew;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_StrClear( Vec_Str_t * p )
-{
- p->nSize = 0;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_StrPush( Vec_Str_t * p, char Entry )
-{
- if ( p->nSize == p->nCap )
- {
- if ( p->nCap < 16 )
- Vec_StrGrow( p, 16 );
- else
- Vec_StrGrow( p, 2 * p->nCap );
- }
- p->pArray[p->nSize++] = Entry;
-}
-
-/**Function*************************************************************
-
- Synopsis [Appends the string to the char vector.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_StrAppend( Vec_Str_t * p, char * pString )
-{
- int i, nLength = strlen(pString);
- Vec_StrGrow( p, p->nSize + nLength );
- for ( i = 0; i < nLength; i++ )
- p->pArray[p->nSize + i] = pString[i];
- p->nSize += nLength;
-}
-
-/**Function*************************************************************
-
- Synopsis [Returns the last entry and removes it from the list.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline char Vec_StrPop( Vec_Str_t * p )
-{
- assert( p->nSize > 0 );
- return p->pArray[--p->nSize];
-}
-
-/**Function*************************************************************
-
- Synopsis [Comparison procedure for two clauses.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_StrSortCompare1( char * pp1, char * pp2 )
-{
- // for some reason commenting out lines (as shown) led to crashing of the release version
- if ( *pp1 < *pp2 )
- return -1;
- if ( *pp1 > *pp2 ) //
- return 1;
- return 0; //
-}
-
-/**Function*************************************************************
-
- Synopsis [Comparison procedure for two clauses.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_StrSortCompare2( char * pp1, char * pp2 )
-{
- // for some reason commenting out lines (as shown) led to crashing of the release version
- if ( *pp1 > *pp2 )
- return -1;
- if ( *pp1 < *pp2 ) //
- return 1;
- return 0; //
-}
-
-/**Function*************************************************************
-
- Synopsis [Sorting the entries by their integer value.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_StrSort( Vec_Str_t * p, int fReverse )
-{
- if ( fReverse )
- qsort( (void *)p->pArray, p->nSize, sizeof(char),
- (int (*)(const void *, const void *)) Vec_StrSortCompare2 );
- else
- qsort( (void *)p->pArray, p->nSize, sizeof(char),
- (int (*)(const void *, const void *)) Vec_StrSortCompare1 );
-}
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
diff --git a/src/temp/vec/vecVec.h b/src/temp/vec/vecVec.h
deleted file mode 100644
index 5b725354..00000000
--- a/src/temp/vec/vecVec.h
+++ /dev/null
@@ -1,289 +0,0 @@
-/**CFile****************************************************************
-
- FileName [vecVec.h]
-
- SystemName [ABC: Logic synthesis and verification system.]
-
- PackageName [Resizable arrays.]
-
- Synopsis [Resizable vector of resizable vectors.]
-
- Author [Alan Mishchenko]
-
- Affiliation [UC Berkeley]
-
- Date [Ver. 1.0. Started - June 20, 2005.]
-
- Revision [$Id: vecVec.h,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
-
-***********************************************************************/
-
-#ifndef __VEC_VEC_H__
-#define __VEC_VEC_H__
-
-////////////////////////////////////////////////////////////////////////
-/// INCLUDES ///
-////////////////////////////////////////////////////////////////////////
-
-#include <stdio.h>
-#include "extra.h"
-
-////////////////////////////////////////////////////////////////////////
-/// PARAMETERS ///
-////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////////////////
-/// BASIC TYPES ///
-////////////////////////////////////////////////////////////////////////
-
-typedef struct Vec_Vec_t_ Vec_Vec_t;
-struct Vec_Vec_t_
-{
- int nCap;
- int nSize;
- void ** pArray;
-};
-
-////////////////////////////////////////////////////////////////////////
-/// MACRO DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-// iterators through levels
-#define Vec_VecForEachLevel( vGlob, vVec, i ) \
- for ( i = 0; (i < Vec_VecSize(vGlob)) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i++ )
-#define Vec_VecForEachLevelStart( vGlob, vVec, i, LevelStart ) \
- for ( i = LevelStart; (i < Vec_VecSize(vGlob)) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i++ )
-#define Vec_VecForEachLevelStartStop( vGlob, vVec, i, LevelStart, LevelStop ) \
- for ( i = LevelStart; (i <= LevelStop) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i++ )
-#define Vec_VecForEachLevelReverse( vGlob, vVec, i ) \
- for ( i = Vec_VecSize(vGlob) - 1; (i >= 0) && (((vVec) = (Vec_Ptr_t*)Vec_VecEntry(vGlob, i)), 1); i-- )
-
-// iteratores through entries
-#define Vec_VecForEachEntry( vGlob, pEntry, i, k ) \
- for ( i = 0; i < Vec_VecSize(vGlob); i++ ) \
- Vec_PtrForEachEntry( Vec_VecEntry(vGlob, i), pEntry, k )
-#define Vec_VecForEachEntryStart( vGlob, pEntry, i, k, LevelStart ) \
- for ( i = LevelStart; i < Vec_VecSize(vGlob); i++ ) \
- Vec_PtrForEachEntry( Vec_VecEntry(vGlob, i), pEntry, k )
-#define Vec_VecForEachEntryStartStop( vGlob, pEntry, i, k, LevelStart, LevelStop ) \
- for ( i = LevelStart; i <= LevelStop; i++ ) \
- Vec_PtrForEachEntry( Vec_VecEntry(vGlob, i), pEntry, k )
-#define Vec_VecForEachEntryReverse( vGlob, pEntry, i, k ) \
- for ( i = 0; i < Vec_VecSize(vGlob); i++ ) \
- Vec_PtrForEachEntryReverse( Vec_VecEntry(vGlob, i), pEntry, k )
-#define Vec_VecForEachEntryReverseReverse( vGlob, pEntry, i, k ) \
- for ( i = Vec_VecSize(vGlob) - 1; i >= 0; i-- ) \
- Vec_PtrForEachEntryReverse( Vec_VecEntry(vGlob, i), pEntry, k )
-
-////////////////////////////////////////////////////////////////////////
-/// FUNCTION DEFINITIONS ///
-////////////////////////////////////////////////////////////////////////
-
-/**Function*************************************************************
-
- Synopsis [Allocates a vector with the given capacity.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Vec_t * Vec_VecAlloc( int nCap )
-{
- Vec_Vec_t * p;
- p = ALLOC( Vec_Vec_t, 1 );
- if ( nCap > 0 && nCap < 8 )
- nCap = 8;
- p->nSize = 0;
- p->nCap = nCap;
- p->pArray = p->nCap? ALLOC( void *, p->nCap ) : NULL;
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Allocates a vector with the given capacity.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline Vec_Vec_t * Vec_VecStart( int nSize )
-{
- Vec_Vec_t * p;
- int i;
- p = Vec_VecAlloc( nSize );
- for ( i = 0; i < nSize; i++ )
- p->pArray[i] = Vec_PtrAlloc( 0 );
- p->nSize = nSize;
- return p;
-}
-
-/**Function*************************************************************
-
- Synopsis [Allocates a vector with the given capacity.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_VecExpand( Vec_Vec_t * p, int Level )
-{
- int i;
- if ( p->nSize >= Level + 1 )
- return;
- Vec_PtrGrow( (Vec_Ptr_t *)p, Level + 1 );
- for ( i = p->nSize; i <= Level; i++ )
- p->pArray[i] = Vec_PtrAlloc( 0 );
- p->nSize = Level + 1;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_VecSize( Vec_Vec_t * p )
-{
- return p->nSize;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void * Vec_VecEntry( Vec_Vec_t * p, int i )
-{
- assert( i >= 0 && i < p->nSize );
- return p->pArray[i];
-}
-
-/**Function*************************************************************
-
- Synopsis [Frees the vector.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_VecFree( Vec_Vec_t * p )
-{
- Vec_Ptr_t * vVec;
- int i;
- Vec_VecForEachLevel( p, vVec, i )
- Vec_PtrFree( vVec );
- Vec_PtrFree( (Vec_Ptr_t *)p );
-}
-
-/**Function*************************************************************
-
- Synopsis [Frees the vector of vectors.]
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline int Vec_VecSizeSize( Vec_Vec_t * p )
-{
- Vec_Ptr_t * vVec;
- int i, Counter = 0;
- Vec_VecForEachLevel( p, vVec, i )
- Counter += vVec->nSize;
- return Counter;
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_VecClear( Vec_Vec_t * p )
-{
- Vec_Ptr_t * vVec;
- int i;
- Vec_VecForEachLevel( p, vVec, i )
- Vec_PtrClear( vVec );
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_VecPush( Vec_Vec_t * p, int Level, void * Entry )
-{
- if ( p->nSize < Level + 1 )
- {
- int i;
- Vec_PtrGrow( (Vec_Ptr_t *)p, Level + 1 );
- for ( i = p->nSize; i < Level + 1; i++ )
- p->pArray[i] = Vec_PtrAlloc( 0 );
- p->nSize = Level + 1;
- }
- Vec_PtrPush( (Vec_Ptr_t*)p->pArray[Level], Entry );
-}
-
-/**Function*************************************************************
-
- Synopsis []
-
- Description []
-
- SideEffects []
-
- SeeAlso []
-
-***********************************************************************/
-static inline void Vec_VecPushUnique( Vec_Vec_t * p, int Level, void * Entry )
-{
- if ( p->nSize < Level + 1 )
- Vec_VecPush( p, Level, Entry );
- else
- Vec_PtrPushUnique( (Vec_Ptr_t*)p->pArray[Level], Entry );
-}
-
-#endif
-
-////////////////////////////////////////////////////////////////////////
-/// END OF FILE ///
-////////////////////////////////////////////////////////////////////////
-
diff --git a/src/temp/ver/module.make b/src/temp/ver/module.make
new file mode 100644
index 00000000..a58a2c60
--- /dev/null
+++ b/src/temp/ver/module.make
@@ -0,0 +1,4 @@
+SRC += src/temp/ver/verCore.c \
+ src/temp/ver/verFormula.c \
+ src/temp/ver/verParse.c \
+ src/temp/ver/verStream.c
diff --git a/src/temp/ver/verCore.c b/src/temp/ver/verCore.c
index 6c8192f5..d18d1820 100644
--- a/src/temp/ver/verCore.c
+++ b/src/temp/ver/verCore.c
@@ -285,7 +285,7 @@ int Ver_ParseModule( Ver_Man_t * pMan )
Abc_NtkFindOrCreateNet( pNtk, "1'b1" );
// make sure we stopped at the opening paranthesis
- if ( Ver_StreamScanChar(p) != '(' )
+ if ( Ver_StreamPopChar(p) != '(' )
{
sprintf( pMan->sError, "Cannot find \"(\" after \"module\".", pNtk->pName );
Ver_ParsePrintErrorMessage( pMan );
@@ -293,19 +293,12 @@ int Ver_ParseModule( Ver_Man_t * pMan )
}
// skip to the end of parantheses
- while ( 1 )
- {
- Extra_ProgressBarUpdate( pMan->pProgress, Ver_StreamGetCurPosition(p), NULL );
- Ver_StreamSkipToChars( p, ",/)" );
- while ( Ver_StreamScanChar(p) == '/' )
- {
- Ver_ParseSkipComments( pMan );
- Ver_StreamSkipToChars( p, ",/)" );
- }
+ do {
+ if ( Ver_ParseGetName( pMan ) == NULL )
+ return 0;
Symbol = Ver_StreamPopChar(p);
- if ( Symbol== ')' )
- break;
- }
+ } while ( Symbol == ',' );
+ assert( Symbol == ')' );
if ( !Ver_ParseSkipComments( pMan ) )
return 0;
Symbol = Ver_StreamPopChar(p);
@@ -482,7 +475,6 @@ int Ver_ParseAssign( Ver_Man_t * pMan )
return 0;
}
-
while ( 1 )
{
// get the name of the output signal
@@ -495,6 +487,7 @@ int Ver_ParseAssign( Ver_Man_t * pMan )
{
pWord++;
pWord[strlen(pWord)-1] = 0;
+ assert( pWord[0] != '\\' );
}
// get the fanout net
pNet = Abc_NtkFindNet( pNtk, pWord );
@@ -740,7 +733,7 @@ int Ver_ParseGate( Ver_Man_t * pMan, Abc_Ntk_t * pNtkGate )
Abc_Ntk_t * pNtk = pMan->pNtkCur;
Abc_Obj_t * pNetFormal, * pNetActual;
Abc_Obj_t * pObj, * pNode;
- char * pWord, Symbol;
+ char * pWord, Symbol, * pGateName;
int i, fCompl, fComplUsed = 0;
unsigned * pPolarity;
@@ -754,6 +747,7 @@ int Ver_ParseGate( Ver_Man_t * pMan, Abc_Ntk_t * pNtkGate )
if ( pWord == NULL )
return 0;
// this is gate name - throw it away
+ pGateName = pWord;
if ( Ver_StreamPopChar(p) != '(' )
{
sprintf( pMan->sError, "Cannot parse gate %s (expected opening paranthesis).", pNtkGate->pName );
@@ -893,6 +887,12 @@ int Ver_ParseGate( Ver_Man_t * pMan, Abc_Ntk_t * pNtkGate )
}
// create box to represent this gate
pNode = Abc_NtkCreateBlackbox( pMan->pNtkCur );
+/*
+ if ( pNode->Id == 57548 )
+ {
+ int x = 0;
+ }
+*/
pNode->pNext = (Abc_Obj_t *)pPolarity;
pNode->pData = pNtkGate;
// connect to fanin nets
diff --git a/src/temp/ver/verFormula.c b/src/temp/ver/verFormula.c
index 8bb21547..fd8777c3 100644
--- a/src/temp/ver/verFormula.c
+++ b/src/temp/ver/verFormula.c
@@ -95,7 +95,7 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
sprintf( pErrorMessage, "Parse_FormulaParser(): Different number of opening and closing parantheses ()." );
return NULL;
}
-
+
// add parantheses
pTemp = pFormula + strlen(pFormula) + 2;
*pTemp-- = 0; *pTemp = ')';
@@ -114,7 +114,6 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
case '\t':
case '\r':
case '\n':
- case '\\': // skip name opening statement
continue;
// treat Constant 0 as a variable
@@ -231,6 +230,8 @@ void * Ver_FormulaParser( char * pFormula, void * pMan, Vec_Ptr_t * vNames, Vec_
default:
// scan the next name
v = Ver_FormulaParserFindVar( pTemp, vNames );
+ if ( *pTemp == '\\' )
+ pTemp++;
pTemp += (int)Vec_PtrEntry( vNames, 2*v ) - 1;
// assume operation AND, if vars follow one another
@@ -376,14 +377,24 @@ int Ver_FormulaParserFindVar( char * pString, Vec_Ptr_t * vNames )
{
char * pTemp, * pTemp2;
int nLength, nLength2, i;
- // find the end of the string delimited by other characters
+ // start the string
pTemp = pString;
- while ( *pTemp && *pTemp != ' ' && *pTemp != '\t' && *pTemp != '\r' && *pTemp != '\n' && *pTemp != ',' && *pTemp != '}' &&
- *pTemp != VER_PARSE_SYM_OPEN && *pTemp != VER_PARSE_SYM_CLOSE &&
- *pTemp != VER_PARSE_SYM_NEGBEF1 && *pTemp != VER_PARSE_SYM_NEGBEF2 &&
- *pTemp != VER_PARSE_SYM_AND && *pTemp != VER_PARSE_SYM_OR && *pTemp != VER_PARSE_SYM_XOR &&
- *pTemp != VER_PARSE_SYM_MUX1 && *pTemp != VER_PARSE_SYM_MUX2 )
+ // find the end of the string delimited by other characters
+ if ( *pTemp == '\\' )
+ {
+ pString++;
+ while ( *pTemp && *pTemp != ' ' )
pTemp++;
+ }
+ else
+ {
+ while ( *pTemp && *pTemp != ' ' && *pTemp != '\t' && *pTemp != '\r' && *pTemp != '\n' && *pTemp != ',' && *pTemp != '}' &&
+ *pTemp != VER_PARSE_SYM_OPEN && *pTemp != VER_PARSE_SYM_CLOSE &&
+ *pTemp != VER_PARSE_SYM_NEGBEF1 && *pTemp != VER_PARSE_SYM_NEGBEF2 &&
+ *pTemp != VER_PARSE_SYM_AND && *pTemp != VER_PARSE_SYM_OR && *pTemp != VER_PARSE_SYM_XOR &&
+ *pTemp != VER_PARSE_SYM_MUX1 && *pTemp != VER_PARSE_SYM_MUX2 )
+ pTemp++;
+ }
// look for this string in the array
nLength = pTemp - pString;
for ( i = 0; i < Vec_PtrSize(vNames)/2; i++ )
diff --git a/src/temp/ver/verParse.c b/src/temp/ver/verParse.c
index c8497932..8a78e75b 100644
--- a/src/temp/ver/verParse.c
+++ b/src/temp/ver/verParse.c
@@ -96,8 +96,12 @@ char * Ver_ParseGetName( Ver_Man_t * pMan )
return NULL;
Symbol = Ver_StreamScanChar( p );
if ( Symbol == '\\' )
+ {
Ver_StreamPopChar( p );
- pWord = Ver_StreamGetWord( p, " \t\n\r(),;" );
+ pWord = Ver_StreamGetWord( p, " " );
+ }
+ else
+ pWord = Ver_StreamGetWord( p, " \t\n\r(),;" );
if ( !Ver_ParseSkipComments( pMan ) )
return NULL;
return pWord;