summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/aig/gia/giaFadds.c249
-rw-r--r--src/aig/gia/giaTim.c64
-rw-r--r--src/base/abci/abc.c75
-rw-r--r--src/bool/rpo/rpo.h6
4 files changed, 354 insertions, 40 deletions
diff --git a/src/aig/gia/giaFadds.c b/src/aig/gia/giaFadds.c
index 7b463f42..08886088 100644
--- a/src/aig/gia/giaFadds.c
+++ b/src/aig/gia/giaFadds.c
@@ -648,14 +648,15 @@ void Gia_ManDupWithFaddBoxes_rec( Gia_Man_t * pNew, Gia_Man_t * p, Gia_Obj_t * p
Gia_ManDupWithFaddBoxes_rec( pNew, p, Gia_ObjFanin1(pObj), vFadds, vMap, vChains, vMap2Chain, vTruths );
pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
}
-Gia_Man_t * Gia_ManDupWithFaddBoxes( Gia_Man_t * p, int nFaddMin, int fVerbose )
+Gia_Man_t * Gia_ManDupWithNaturalBoxes( Gia_Man_t * p, int nFaddMin, int fVerbose )
{
abctime clk = Abc_Clock();
- Gia_Man_t * pNew, * pTemp;
+ Gia_Man_t * pNew;//, * pTemp;
Vec_Int_t * vFadds, * vMap, * vMap2Chain, * vTruths, * vChain;
Vec_Wec_t * vChains;
Gia_Obj_t * pObj;
int i, nBoxes;
+ assert( Gia_ManBoxNum(p) == 0 );
// detect FADDs
vFadds = Gia_ManDetectFullAdders( p, fVerbose );
@@ -718,13 +719,13 @@ Gia_Man_t * Gia_ManDupWithFaddBoxes( Gia_Man_t * p, int nFaddMin, int fVerbose )
assert( nBoxes == (Gia_ManCoNum(pNew) - Gia_ManCoNum(p)) / 3 );
pNew->pManTime = Gia_ManGenerateTim( Gia_ManCiNum(p), Gia_ManCoNum(p), nBoxes, 3, 2 );
pNew->pAigExtra = Gia_ManGenerateExtraAig( nBoxes, 3, 2 );
-
+/*
// normalize
pNew = Gia_ManDupNormalize( pTemp = pNew );
pNew->pManTime = pTemp->pManTime; pTemp->pManTime = NULL;
pNew->pAigExtra = pTemp->pAigExtra; pTemp->pAigExtra = NULL;
Gia_ManStop( pTemp );
-
+*/
//pNew = Gia_ManDupCollapse( pTemp = pNew, pNew->pAigExtra, NULL );
//Gia_ManStop( pTemp );
@@ -734,6 +735,246 @@ Gia_Man_t * Gia_ManDupWithFaddBoxes( Gia_Man_t * p, int nFaddMin, int fVerbose )
return pNew;
}
+/**Function*************************************************************
+
+ Synopsis [Converting AIG with annotated carry-chains into AIG with boxes.]
+
+ Description [Assumes that annotations are pObj->fMark0 or pObj->fMark1.
+ Only one of these can be set to 1. If fMark0 (fMark1) is set to 1,
+ the first (second) input of an AND-gate is chained.]
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+Gia_Man_t * Gia_ManDupWithArtificalFaddBoxes( Gia_Man_t * p )
+{
+ Gia_Man_t * pNew;
+ Gia_Obj_t * pObj;
+ int i, nRealPis, nRealPos, nBoxes = Gia_ManBoxNum(p);
+ // if AIG already has (natural) FADD boxes, it should not un-normalized
+ Gia_ManFillValue( p );
+ pNew = Gia_ManStart( Gia_ManObjNum(p) );
+ pNew->pName = Abc_UtilStrsav( p->pName );
+ pNew->pSpec = Abc_UtilStrsav( p->pSpec );
+ Gia_ManConst0(p)->Value = 0;
+ Gia_ManForEachObj1( p, pObj, i )
+ {
+ if ( Gia_ObjIsCi(pObj) )
+ pObj->Value = Gia_ManAppendCi( pNew );
+ else if ( Gia_ObjIsCo(pObj) )
+ pObj->Value = Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
+ else if ( !pObj->fMark0 && !pObj->fMark1 ) // AND-gate
+ pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
+ else // AND-gate with chain
+ {
+ int iCiLit, iOtherLit, iLit0, iLit1, iLit2;
+ assert( pObj->fMark0 != pObj->fMark1 );
+ iCiLit = pObj->fMark0 ? Gia_ObjFanin0Copy(pObj) : Gia_ObjFanin1Copy(pObj);
+ iOtherLit = pObj->fMark0 ? Gia_ObjFanin1Copy(pObj) : Gia_ObjFanin0Copy(pObj);
+ iLit0 = Abc_LitNotCond( iCiLit, Abc_LitIsCompl(iCiLit) );
+ iLit1 = Abc_LitNotCond( iOtherLit, Abc_LitIsCompl(iCiLit) );
+ iLit2 = Abc_LitNotCond( 0, Abc_LitIsCompl(iCiLit) );
+ // add COs
+ Gia_ManAppendCo( pNew, iLit0 );
+ Gia_ManAppendCo( pNew, iLit1 );
+ Gia_ManAppendCo( pNew, iLit2 );
+ // add CI (unused sum bit)
+ Gia_ManAppendCi(pNew);
+ // add CI (carry bit)
+ pObj->Value = Abc_LitNotCond( Gia_ManAppendCi(pNew), Abc_LitIsCompl(iCiLit) );
+ nBoxes++;
+ }
+ }
+ // other information
+// nBoxes += (Gia_ManCiNum(pNew) - Gia_ManCiNum(p)) / 2;
+// assert( nBoxes == Gia_ManBoxNum(p) + (Gia_ManCoNum(pNew) - Gia_ManCoNum(p)) / 3 );
+ nRealPis = Gia_ManBoxNum(p) ? Tim_ManPiNum((Tim_Man_t *)p->pManTime) : Gia_ManCiNum(p);
+ nRealPos = Gia_ManBoxNum(p) ? Tim_ManPoNum((Tim_Man_t *)p->pManTime) : Gia_ManCoNum(p);
+ pNew->pManTime = Gia_ManGenerateTim( nRealPis, nRealPos, nBoxes, 3, 2 );
+ pNew->pAigExtra = Gia_ManGenerateExtraAig( nBoxes, 3, 2 );
+ // optionally normalize the AIG
+ return pNew;
+}
+Gia_Man_t * Gia_ManDupWithArtificalFaddBoxesTest( Gia_Man_t * p )
+{
+ Gia_Man_t * pNew;
+ Gia_Obj_t * pObj;
+ int i;
+ // label some and-gates
+ Gia_ManCleanMark01( p );
+ Gia_ManForEachAnd( p, pObj, i )
+ {
+ pObj->fMark0 = i % 5;
+ pObj->fMark1 = i % 7;
+ if ( pObj->fMark0 && pObj->fMark1 )
+ pObj->fMark0 = pObj->fMark1 = 0;
+ }
+
+ // output new AIG
+ pNew = Gia_ManDupWithArtificalFaddBoxes( p );
+ Gia_ManCleanMark01( p );
+ return pNew;
+}
+
+/**Function*************************************************************
+
+ Synopsis [Computes AIG delay information when boxes are used.]
+
+ Description []
+
+ SideEffects []
+
+ SeeAlso []
+
+***********************************************************************/
+int Gia_ManFindAnnotatedDelay( Gia_Man_t * p, int DelayC, int * pnBoxes )
+{
+ Gia_Obj_t * pObj;
+ int * pDelays = Vec_IntArray(p->vLevels);
+ int i, Delay, Delay0, Delay1, DelayMax = 0, nBoxes = 0;
+ Vec_IntFill( p->vLevels, Gia_ManObjNum(p), 0 );
+ Gia_ManForEachObj1( p, pObj, i )
+ {
+ if ( Gia_ObjIsCi(pObj) )
+ continue;
+ if ( Gia_ObjIsCo(pObj) )
+ {
+ pDelays[i] = pDelays[Gia_ObjFaninId0(pObj, i)];
+ DelayMax = Abc_MaxInt( DelayMax, pDelays[i] );
+ continue;
+ }
+ assert( !pObj->fMark0 || !pObj->fMark1 );
+ Delay0 = pDelays[Gia_ObjFaninId0(pObj, i)];
+ Delay1 = pDelays[Gia_ObjFaninId1(pObj, i)];
+ if ( pObj->fMark0 )
+ {
+ Delay = Abc_MaxInt( Delay0 + DelayC, Delay1 + 100 );
+ nBoxes++;
+ }
+ else if ( pObj->fMark1 )
+ {
+ Delay = Abc_MaxInt( Delay1 + DelayC, Delay0 + 100 );
+ nBoxes++;
+ }
+ else
+ Delay = Abc_MaxInt( Delay0 + 100, Delay1 + 100 );
+ pDelays[i] = Delay;
+ }
+ if ( pnBoxes )
+ *pnBoxes = nBoxes;
+ return DelayMax;
+}
+int Gia_ManFindInternalNode( Gia_Man_t * p )
+{
+ Gia_Obj_t * pObj;
+ int * pDelays = Vec_IntArray(p->vLevels);
+ int i, iMax = -1, DelayMax = 0;
+ Gia_ManForEachAnd( p, pObj, i )
+ {
+ if ( pObj->fMark0 || pObj->fMark1 || pObj->fPhase )
+ continue;
+ if ( DelayMax > pDelays[i] )
+ continue;
+ DelayMax = pDelays[i];
+ iMax = i;
+ }
+ return iMax;
+}
+int Gia_ManFindPath( Gia_Man_t * p, int DelayC, int nPathMin, int nPathMax, Vec_Int_t * vPath )
+{
+ Gia_Obj_t * pObj, * pFanin0, * pFanin1;
+ int * pDelays = Vec_IntArray(p->vLevels);
+ int i, iLit, iMax = Gia_ManFindInternalNode( p );
+ if ( iMax == -1 )
+ return -1;
+ Vec_IntClear( vPath );
+ pObj = Gia_ManObj(p, iMax);
+ assert( Gia_ObjIsAnd(pObj) );
+ assert( !(pObj->fMark0 || pObj->fMark1 || pObj->fPhase) );
+ while ( Gia_ObjIsAnd(pObj) )
+ {
+ pFanin0 = Gia_ObjFanin0(pObj);
+ pFanin1 = Gia_ObjFanin1(pObj);
+ if ( (pFanin0->fMark0 || pFanin0->fMark1 || Gia_ObjIsCi(pFanin0)) && (pFanin1->fMark0 || pFanin1->fMark1 || Gia_ObjIsCi(pFanin1)) )
+ break;
+ if ( pFanin0->fMark0 || pFanin0->fMark1 || Gia_ObjIsCi(pFanin0) )
+ {
+ Vec_IntPush( vPath, Abc_Var2Lit(Gia_ObjId(p, pObj), 1) );
+ pObj = pFanin1;
+ }
+ else if ( pFanin1->fMark0 || pFanin1->fMark1 || Gia_ObjIsCi(pFanin1) )
+ {
+ Vec_IntPush( vPath, Abc_Var2Lit(Gia_ObjId(p, pObj), 0) );
+ pObj = pFanin0;
+ }
+ else
+ {
+ if ( pDelays[Gia_ObjId(p, pFanin1)] > pDelays[Gia_ObjId(p, pFanin0)] )
+ {
+ Vec_IntPush( vPath, Abc_Var2Lit(Gia_ObjId(p, pObj), 1) );
+ pObj = pFanin1;
+ }
+ else
+ {
+ Vec_IntPush( vPath, Abc_Var2Lit(Gia_ObjId(p, pObj), 0) );
+ pObj = pFanin0;
+ }
+ }
+ }
+ if ( Vec_IntSize(vPath) < nPathMin )
+ {
+ Gia_ManObj(p, iMax)->fPhase = 1;
+ return 0;
+ }
+ // label nodes
+ if ( Vec_IntSize(vPath) > nPathMax )
+ Vec_IntShrink( vPath, nPathMax );
+ Vec_IntForEachEntry( vPath, iLit, i )
+ if ( Abc_LitIsCompl(iLit) )
+ Gia_ManObj(p, Abc_Lit2Var(iLit))->fMark1 = 1;
+ else
+ Gia_ManObj(p, Abc_Lit2Var(iLit))->fMark0 = 1;
+ return Vec_IntSize(vPath);
+}
+int Gia_ManIteratePaths( Gia_Man_t * p, int DelayC, int nPathMin, int nPathMax, int nPathLimit, int fVerbose )
+{
+ Vec_Int_t * vPath = Vec_IntAlloc( 100 );
+ int i, RetValue, nBoxes, MaxDelay, nPaths = 0;
+ assert( p->vLevels == NULL );
+ p->vLevels = Vec_IntStart( Gia_ManObjNum(p) );
+ Gia_ManCleanMark01( p );
+ Gia_ManCleanPhase( p );
+ if ( fVerbose )
+ printf( "Running path detection: BoxDelay = %d, PathMin = %d, PathMax = %d, PathLimit = %d.\n", DelayC, nPathMin, nPathMax, nPathLimit );
+ for ( i = 0; i < nPathLimit; i++ )
+ {
+ MaxDelay = Gia_ManFindAnnotatedDelay( p, DelayC, &nBoxes );
+ RetValue = Gia_ManFindPath( p, DelayC, nPathMin, nPathMax, vPath );
+ if ( RetValue == -1 )
+ break;
+ nPaths += (RetValue > 0);
+ if ( fVerbose )
+ printf( "Iter %5d : Paths = %2d. Boxes = %2d. Total boxes = %6d. Max delay = %5d.\n", i, nPaths, RetValue, nBoxes, MaxDelay );
+ }
+ Vec_IntFree( vPath );
+ Vec_IntFreeP( &p->vLevels );
+ return 1;
+}
+Gia_Man_t * Gia_ManDupWithArtificialBoxes( Gia_Man_t * p, int DelayC, int nPathMin, int nPathMax, int nPathLimit, int fUseFanout, int fVerbose )
+{
+ Gia_Man_t * pNew;
+ if ( Gia_ManBoxNum(p) > 0 )
+ {
+ printf( "Currently artifical carry-chains cannot be detected when natural ones are present.\n" );
+ return NULL;
+ }
+ Gia_ManIteratePaths( p, DelayC, nPathMin, nPathMax, nPathLimit, fVerbose );
+ pNew = Gia_ManDupWithArtificalFaddBoxes( p );
+ return pNew;
+}
+
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////
diff --git a/src/aig/gia/giaTim.c b/src/aig/gia/giaTim.c
index 1d5a2f36..5640baa4 100644
--- a/src/aig/gia/giaTim.c
+++ b/src/aig/gia/giaTim.c
@@ -822,53 +822,59 @@ int Gia_ManVerifyWithBoxes( Gia_Man_t * pGia, void * pParsInit, char * pFileSpec
printf( "Spec file is not given. Use standard flow.\n" );
return Status;
}
- if ( pGia->pManTime == NULL )
- {
- printf( "Design has no tim manager. Use standard flow.\n" );
- return Status;
- }
- if ( pGia->pAigExtra == NULL )
+ if ( Gia_ManBoxNum(pGia) && pGia->pAigExtra == NULL )
{
printf( "Design has no box logic. Use standard flow.\n" );
return Status;
}
// read original AIG
pSpec = Gia_AigerRead( pFileSpec ? pFileSpec : pGia->pSpec, 0, 0 );
- if ( pSpec->pManTime == NULL )
+ if ( Gia_ManBoxNum(pSpec) && pSpec->pAigExtra == NULL )
{
- printf( "Spec has no tim manager. Use standard flow.\n" );
+ Gia_ManStop( pSpec );
+ printf( "Spec has no box logic. Use standard flow.\n" );
return Status;
}
- if ( pSpec->pAigExtra == NULL )
+ // prepare miter
+ if ( pGia->pManTime == NULL && pSpec->pManTime == NULL )
{
- printf( "Spec has no box logic. Use standard flow.\n" );
- return Status;
+ pGia0 = Gia_ManDup( pSpec );
+ pGia1 = Gia_ManDup( pGia );
}
- // if timing managers have different number of black boxes,
- // it is possible that some of the boxes are swept away
- if ( Tim_ManBlackBoxNum( (Tim_Man_t *)pSpec->pManTime ) > 0 )
+ else
{
- // specification cannot have fewer boxes than implementation
- if ( Tim_ManBoxNum( (Tim_Man_t *)pSpec->pManTime ) < Tim_ManBoxNum( (Tim_Man_t *)pGia->pManTime ) )
+ // if timing managers have different number of black boxes,
+ // it is possible that some of the boxes are swept away
+ if ( pSpec->pManTime && Tim_ManBlackBoxNum((Tim_Man_t *)pSpec->pManTime) > 0 && Gia_ManBoxNum(pGia) > 0 )
{
- printf( "Spec has more boxes than the design. Cannot proceed.\n" );
- return Status;
- }
- // to align the boxes, find what boxes of pSpec are dropped in pGia
- if ( Tim_ManBoxNum( (Tim_Man_t *)pSpec->pManTime ) != Tim_ManBoxNum( (Tim_Man_t *)pGia->pManTime ) )
- {
- vBoxPres = Tim_ManAlignTwo( (Tim_Man_t *)pSpec->pManTime, (Tim_Man_t *)pGia->pManTime );
- if ( vBoxPres == NULL )
+ // specification cannot have fewer boxes than implementation
+ if ( Gia_ManBoxNum(pSpec) < Gia_ManBoxNum(pGia) )
{
- printf( "Boxes of spec and design cannot be aligned. Cannot proceed.\n" );
+ printf( "Spec has less boxes than the design. Cannot proceed.\n" );
return Status;
}
+ // to align the boxes, find what boxes of pSpec are dropped in pGia
+ if ( Gia_ManBoxNum(pSpec) > Gia_ManBoxNum(pGia) )
+ {
+ vBoxPres = Tim_ManAlignTwo( (Tim_Man_t *)pSpec->pManTime, (Tim_Man_t *)pGia->pManTime );
+ if ( vBoxPres == NULL )
+ {
+ printf( "Boxes of spec and design cannot be aligned. Cannot proceed.\n" );
+ return Status;
+ }
+ }
}
+ // collapse two designs
+ if ( Gia_ManBoxNum(pSpec) > 0 )
+ pGia0 = Gia_ManDupCollapse( pSpec, pSpec->pAigExtra, vBoxPres );
+ else
+ pGia0 = Gia_ManDup( pSpec );
+ if ( Gia_ManBoxNum(pGia) > 0 )
+ pGia1 = Gia_ManDupCollapse( pGia, pGia->pAigExtra, NULL );
+ else
+ pGia1 = Gia_ManDup( pGia );
+ Vec_IntFreeP( &vBoxPres );
}
- // collapse two designs
- pGia0 = Gia_ManDupCollapse( pSpec, pSpec->pAigExtra, vBoxPres );
- pGia1 = Gia_ManDupCollapse( pGia, pGia->pAigExtra, NULL );
- Vec_IntFreeP( &vBoxPres );
// compute the miter
pMiter = Gia_ManMiter( pGia0, pGia1, 0, 1, 0, 0, fVerbose );
if ( pMiter )
diff --git a/src/base/abci/abc.c b/src/base/abci/abc.c
index 7b08c564..a6091f59 100644
--- a/src/base/abci/abc.c
+++ b/src/base/abci/abc.c
@@ -36581,11 +36581,13 @@ usage:
***********************************************************************/
int Abc_CommandAbc9Fadds( Abc_Frame_t * pAbc, int argc, char ** argv )
{
- extern Gia_Man_t * Gia_ManDupWithFaddBoxes( Gia_Man_t * p, int nFaddMin, int fVerbose );
+ extern Gia_Man_t * Gia_ManDupWithNaturalBoxes( Gia_Man_t * p, int nFaddMin, int fVerbose );
+ extern Gia_Man_t * Gia_ManDupWithArtificialBoxes( Gia_Man_t * p, int DelayC, int nPathMin, int nPathMax, int nPathLimit, int fUseFanout, int fVerbose );
Gia_Man_t * pTemp;
- int c, nFaddMin = 3, fVerbose = 0;
+ int c, nFaddMin = 3, fUseArt = 0, fVerbose = 0;
+ int DelayC = 0, nPathMin = 3, nPathMax = 32, nPathLimit = 50, fUseFanout = 0;
Extra_UtilGetoptReset();
- while ( ( c = Extra_UtilGetopt( argc, argv, "Nvh" ) ) != EOF )
+ while ( ( c = Extra_UtilGetopt( argc, argv, "NBSLPafvh" ) ) != EOF )
{
switch ( c )
{
@@ -36600,6 +36602,56 @@ int Abc_CommandAbc9Fadds( Abc_Frame_t * pAbc, int argc, char ** argv )
if ( nFaddMin < 0 )
goto usage;
break;
+ case 'B':
+ if ( globalUtilOptind >= argc )
+ {
+ Abc_Print( -1, "Command line switch \"-B\" should be followed by an integer.\n" );
+ goto usage;
+ }
+ DelayC = atoi(argv[globalUtilOptind]);
+ globalUtilOptind++;
+ if ( DelayC < 0 )
+ goto usage;
+ break;
+ case 'S':
+ if ( globalUtilOptind >= argc )
+ {
+ Abc_Print( -1, "Command line switch \"-S\" should be followed by an integer.\n" );
+ goto usage;
+ }
+ nPathMin = atoi(argv[globalUtilOptind]);
+ globalUtilOptind++;
+ if ( nPathMin < 0 )
+ goto usage;
+ break;
+ case 'L':
+ if ( globalUtilOptind >= argc )
+ {
+ Abc_Print( -1, "Command line switch \"-L\" should be followed by an integer.\n" );
+ goto usage;
+ }
+ nPathMax = atoi(argv[globalUtilOptind]);
+ globalUtilOptind++;
+ if ( nPathMax < 0 )
+ goto usage;
+ break;
+ case 'P':
+ if ( globalUtilOptind >= argc )
+ {
+ Abc_Print( -1, "Command line switch \"-P\" should be followed by an integer.\n" );
+ goto usage;
+ }
+ nPathLimit = atoi(argv[globalUtilOptind]);
+ globalUtilOptind++;
+ if ( nPathLimit < 0 )
+ goto usage;
+ break;
+ case 'a':
+ fUseArt ^= 1;
+ break;
+ case 'f':
+ fUseFanout ^= 1;
+ break;
case 'v':
fVerbose ^= 1;
break;
@@ -36614,14 +36666,23 @@ int Abc_CommandAbc9Fadds( Abc_Frame_t * pAbc, int argc, char ** argv )
Abc_Print( -1, "Abc_CommandAbc9Fadds(): There is no AIG.\n" );
return 0;
}
- pTemp = Gia_ManDupWithFaddBoxes( pAbc->pGia, nFaddMin, fVerbose );
+ if ( fUseArt )
+ pTemp = Gia_ManDupWithArtificialBoxes( pAbc->pGia, DelayC, nPathMin, nPathMax, nPathLimit, fUseFanout, fVerbose );
+ else
+ pTemp = Gia_ManDupWithNaturalBoxes( pAbc->pGia, nFaddMin, fVerbose );
Abc_FrameUpdateGia( pAbc, pTemp );
return 0;
usage:
- Abc_Print( -2, "usage: &fadds [-N num] [-vh]\n" );
+ Abc_Print( -2, "usage: &fadds [-NBSLP num] [-afvh]\n" );
Abc_Print( -2, "\t detects full-adder chains and puts them into white boxes\n" );
- Abc_Print( -2, "\t-N num : the minimum length of full-adder chain to box [default = %d]\n", nFaddMin );
- Abc_Print( -2, "\t-v : toggles printing verbose information [default = %s]\n", fVerbose? "yes": "no" );
+ Abc_Print( -2, "\t-N num : minimum length of a natural full-adder chain to detect [default = %d]\n", nFaddMin );
+ Abc_Print( -2, "\t-a : toggles detecting artificial full-adder chains [default = %s]\n", fUseArt? "yes": "no" );
+ Abc_Print( -2, "\t-B num : full-adder box delay (percentage of AND-gate delay) [default = %d]\n", DelayC );
+ Abc_Print( -2, "\t-S num : minimum length of an artificial full-adder chain [default = %d]\n", nPathMin );
+ Abc_Print( -2, "\t-L num : maximum length of an artificial full-adder chain [default = %d]\n", nPathMax );
+ Abc_Print( -2, "\t-P num : maximum number of artificial full-adder chains to detect [default = %d]\n", nPathLimit );
+ Abc_Print( -2, "\t-f : toggles using intermediate fanouts in artificial chains [default = %s]\n", fUseFanout? "yes": "no" );
+ Abc_Print( -2, "\t-v : toggles printing verbose information [default = %s]\n", fVerbose? "yes": "no" );
Abc_Print( -2, "\t-h : print the command usage\n");
return 1;
}
diff --git a/src/bool/rpo/rpo.h b/src/bool/rpo/rpo.h
index 8119bf27..38ad4068 100644
--- a/src/bool/rpo/rpo.h
+++ b/src/bool/rpo/rpo.h
@@ -55,5 +55,11 @@ ABC_NAMESPACE_HEADER_END
#endif
+////////////////////////////////////////////////////////////////////////
+/// END OF FILE ///
+////////////////////////////////////////////////////////////////////////
+
+
+
\ No newline at end of file
generated by cgit v1.2.3 (git 2.25.1) at 2025-01-01 04:55:57 +0000