diff options
Diffstat (limited to 'src')
48 files changed, 4994 insertions, 566 deletions
diff --git a/src/aig/gia/gia.h b/src/aig/gia/gia.h index b3efa455..35d80047 100644 --- a/src/aig/gia/gia.h +++ b/src/aig/gia/gia.h @@ -117,6 +117,7 @@ struct Gia_Man_t_ int * pReprsOld; // representatives (for CIs and ANDs) Gia_Rpr_t * pReprs; // representatives (for CIs and ANDs) int * pNexts; // next nodes in the equivalence classes + int * pSibls; // next nodes in the choice nodes int * pIso; // pairs of structurally isomorphic nodes int nTerLoop; // the state where loop begins int nTerStates; // the total number of ternary states @@ -481,6 +482,13 @@ static inline int Gia_ManAppendXor( Gia_Man_t * p, int iLit0, int iLit1 ) { return Gia_ManAppendMux( p, iLit0, Abc_LitNot(iLit1), iLit1 ); } +static inline void Gia_ManPatchCoDriver( Gia_Man_t * p, int iCoIndex, int iLit0 ) +{ + Gia_Obj_t * pObjCo = Gia_ManCo( p, iCoIndex ); + assert( Gia_ObjId(p, pObjCo) > Abc_Lit2Var(iLit0) ); + pObjCo->iDiff0 = Gia_ObjId(p, pObjCo) - Abc_Lit2Var(iLit0); + pObjCo->fCompl0 = Abc_LitIsCompl(iLit0); +} #define GIA_ZER 1 #define GIA_ONE 2 @@ -570,6 +578,8 @@ static inline void Gia_ObjSetReprRev( Gia_Man_t * p, int Id, int Num ){ a static inline void Gia_ObjUnsetRepr( Gia_Man_t * p, int Id ) { p->pReprs[Id].iRepr = GIA_VOID; } static inline int Gia_ObjHasRepr( Gia_Man_t * p, int Id ) { return p->pReprs[Id].iRepr != GIA_VOID; } static inline int Gia_ObjReprSelf( Gia_Man_t * p, int Id ) { return Gia_ObjHasRepr(p, Id) ? Gia_ObjRepr(p, Id) : Id; } +static inline int Gia_ObjSibl( Gia_Man_t * p, int Id ) { return p->pSibls ? p->pSibls[Id] : 0; } +static inline Gia_Obj_t * Gia_ObjSiblObj( Gia_Man_t * p, int Id ) { return (p->pSibls && p->pSibls[Id]) ? Gia_ManObj(p, p->pSibls[Id]) : NULL; } static inline int Gia_ObjProved( Gia_Man_t * p, int Id ) { return p->pReprs[Id].fProved; } static inline void Gia_ObjSetProved( Gia_Man_t * p, int Id ) { p->pReprs[Id].fProved = 1; } @@ -697,6 +707,7 @@ extern int Gia_ManCounterExampleValueLookup( Gia_Man_t * pGia, i extern void Gia_ManVerifyChoices( Gia_Man_t * p ); extern void Gia_ManReverseClasses( Gia_Man_t * p, int fNowIncreasing ); extern int Gia_ManHasChoices( Gia_Man_t * p ); +extern int Gia_ManChoiceLevel( Gia_Man_t * p ); /*=== giaCsatOld.c ============================================================*/ extern Vec_Int_t * Cbs_ManSolveMiter( Gia_Man_t * pGia, int nConfs, Vec_Str_t ** pvStatus, int fVerbose ); /*=== giaCsat.c ============================================================*/ @@ -807,7 +818,14 @@ extern Gia_Man_t * Gia_ManRehash( Gia_Man_t * p, int fAddStrash ); extern void Gia_ManHashProfile( Gia_Man_t * p ); extern int Gia_ManHashLookup( Gia_Man_t * p, Gia_Obj_t * p0, Gia_Obj_t * p1 ); /*=== giaIf.c ===========================================================*/ -extern void Gia_ManPrintNpnClasses( Gia_Man_t * p ); +extern void Gia_ManPrintMappingStats( Gia_Man_t * p ); +extern int Gia_ManLutFaninCount( Gia_Man_t * p ); +extern int Gia_ManLutSizeMax( Gia_Man_t * p ); +extern int Gia_ManLutNum( Gia_Man_t * p ); +extern int Gia_ManLutLevel( Gia_Man_t * p ); +extern void Gia_ManSetRefsMapped( Gia_Man_t * p ); +extern void Gia_ManSetIfParsDefault( void * pIfPars ); +extern Gia_Man_t * Gia_ManPerformMapping( Gia_Man_t * p, void * pIfPars ); /*=== giaIso.c ===========================================================*/ extern Gia_Man_t * Gia_ManIsoCanonicize( Gia_Man_t * p, int fVerbose ); extern Gia_Man_t * Gia_ManIsoReduce( Gia_Man_t * p, Vec_Ptr_t ** pvPosEquivs, int fDualOut, int fVerbose ); @@ -823,12 +841,7 @@ extern void Gia_ManPrintStatsShort( Gia_Man_t * p ); extern void Gia_ManPrintMiterStatus( Gia_Man_t * p ); extern void Gia_ManSetRegNum( Gia_Man_t * p, int nRegs ); extern void Gia_ManReportImprovement( Gia_Man_t * p, Gia_Man_t * pNew ); -/*=== giaMap.c ===========================================================*/ -extern void Gia_ManPrintMappingStats( Gia_Man_t * p ); -extern int Gia_ManLutFaninCount( Gia_Man_t * p ); -extern int Gia_ManLutSizeMax( Gia_Man_t * p ); -extern int Gia_ManLutNum( Gia_Man_t * p ); -extern int Gia_ManLutLevel( Gia_Man_t * p ); +extern void Gia_ManPrintNpnClasses( Gia_Man_t * p ); /*=== giaMem.c ===========================================================*/ extern Gia_MmFixed_t * Gia_MmFixedStart( int nEntrySize, int nEntriesMax ); extern void Gia_MmFixedStop( Gia_MmFixed_t * p, int fVerbose ); @@ -857,6 +870,7 @@ extern int Sat_ManTest( Gia_Man_t * pGia, Gia_Obj_t * pObj, int extern int Gia_ManSeqMarkUsed( Gia_Man_t * p ); extern int Gia_ManCombMarkUsed( Gia_Man_t * p ); extern Gia_Man_t * Gia_ManCleanup( Gia_Man_t * p ); +extern Gia_Man_t * Gia_ManCleanupOutputs( Gia_Man_t * p, int nOutputs ); extern Gia_Man_t * Gia_ManSeqCleanup( Gia_Man_t * p ); extern Gia_Man_t * Gia_ManSeqStructSweep( Gia_Man_t * p, int fConst, int fEquiv, int fVerbose ); /*=== giaShrink.c ===========================================================*/ @@ -906,7 +920,7 @@ extern int Gia_ManLevelNum( Gia_Man_t * p ); extern void Gia_ManCreateValueRefs( Gia_Man_t * p ); extern void Gia_ManCreateRefs( Gia_Man_t * p ); extern int * Gia_ManCreateMuxRefs( Gia_Man_t * p ); -extern int Gia_ManCrossCut( Gia_Man_t * p ); +extern int Gia_ManCrossCut( Gia_Man_t * p, int fReverse ); extern int Gia_ManIsNormalized( Gia_Man_t * p ); extern Vec_Int_t * Gia_ManCollectPoIds( Gia_Man_t * p ); extern int Gia_ObjIsMuxType( Gia_Obj_t * pNode ); @@ -920,6 +934,7 @@ extern void Gia_ObjPrint( Gia_Man_t * p, Gia_Obj_t * pObj ); extern void Gia_ManPrint( Gia_Man_t * p ); extern void Gia_ManInvertConstraints( Gia_Man_t * pAig ); extern int Gia_ManCompare( Gia_Man_t * p1, Gia_Man_t * p2 ); +extern void Gia_ManMarkFanoutDrivers( Gia_Man_t * p ); /*=== giaCTas.c ===========================================================*/ typedef struct Tas_Man_t_ Tas_Man_t; diff --git a/src/aig/gia/giaAig.c b/src/aig/gia/giaAig.c index 224d3bda..5dcc6038 100644 --- a/src/aig/gia/giaAig.c +++ b/src/aig/gia/giaAig.c @@ -42,7 +42,7 @@ static inline Aig_Obj_t * Gia_ObjChild1Copy2( Aig_Obj_t ** ppNodes, Gia_Obj_t * /**Function************************************************************* - Synopsis [Derives combinational miter of the two AIGs.] + Synopsis [Duplicates AIG in the DFS order.] Description [] @@ -70,6 +70,34 @@ void Gia_ManFromAig_rec( Gia_Man_t * pNew, Aig_Man_t * p, Aig_Obj_t * pObj ) pNew->pNexts[iObjNew] = iNextNew; } } +Gia_Man_t * Gia_ManFromAig( Aig_Man_t * p ) +{ + Gia_Man_t * pNew; + Aig_Obj_t * pObj; + int i; + // create the new manager + pNew = Gia_ManStart( Aig_ManObjNum(p) ); + pNew->pName = Abc_UtilStrsav( p->pName ); + pNew->pSpec = Abc_UtilStrsav( p->pSpec ); + pNew->nConstrs = p->nConstrs; + // create room to store equivalences + if ( p->pEquivs ) + pNew->pNexts = ABC_CALLOC( int, Aig_ManObjNum(p) ); + // create the PIs + Aig_ManCleanData( p ); + Aig_ManConst1(p)->iData = 1; + Aig_ManForEachCi( p, pObj, i ) + pObj->iData = Gia_ManAppendCi( pNew ); + // add logic for the POs + Aig_ManForEachCo( p, pObj, i ) + Gia_ManFromAig_rec( pNew, p, Aig_ObjFanin0(pObj) ); + Aig_ManForEachCo( p, pObj, i ) + Gia_ManAppendCo( pNew, Gia_ObjChild0Copy(pObj) ); + Gia_ManSetRegNum( pNew, Aig_ManRegNum(p) ); + if ( pNew->pNexts ) + Gia_ManDeriveReprs( pNew ); + return pNew; +} /**Function************************************************************* @@ -82,19 +110,38 @@ void Gia_ManFromAig_rec( Gia_Man_t * pNew, Aig_Man_t * p, Aig_Obj_t * pObj ) SeeAlso [] ***********************************************************************/ -Gia_Man_t * Gia_ManFromAig( Aig_Man_t * p ) +void Gia_ManFromAigChoices_rec( Gia_Man_t * pNew, Aig_Man_t * p, Aig_Obj_t * pObj ) +{ + if ( pObj == NULL || pObj->iData ) + return; + assert( Aig_ObjIsNode(pObj) ); + Gia_ManFromAigChoices_rec( pNew, p, Aig_ObjFanin0(pObj) ); + Gia_ManFromAigChoices_rec( pNew, p, Aig_ObjFanin1(pObj) ); + Gia_ManFromAigChoices_rec( pNew, p, Aig_ObjEquiv(p, pObj) ); + pObj->iData = Gia_ManAppendAnd( pNew, Gia_ObjChild0Copy(pObj), Gia_ObjChild1Copy(pObj) ); + if ( Aig_ObjEquiv(p, pObj) ) + { + int iObjNew, iNextNew; + iObjNew = Abc_Lit2Var(pObj->iData); + iNextNew = Abc_Lit2Var(Aig_ObjEquiv(p, pObj)->iData); + assert( iObjNew > iNextNew ); + assert( Gia_ObjIsAnd(Gia_ManObj(pNew, iNextNew)) ); + pNew->pSibls[iObjNew] = iNextNew; + } +} +Gia_Man_t * Gia_ManFromAigChoices( Aig_Man_t * p ) { Gia_Man_t * pNew; Aig_Obj_t * pObj; int i; + assert( p->pEquivs != NULL ); // create the new manager pNew = Gia_ManStart( Aig_ManObjNum(p) ); pNew->pName = Abc_UtilStrsav( p->pName ); pNew->pSpec = Abc_UtilStrsav( p->pSpec ); pNew->nConstrs = p->nConstrs; // create room to store equivalences - if ( p->pEquivs ) - pNew->pNexts = ABC_CALLOC( int, Aig_ManObjNum(p) ); + pNew->pSibls = ABC_CALLOC( int, Aig_ManObjNum(p) ); // create the PIs Aig_ManCleanData( p ); Aig_ManConst1(p)->iData = 1; @@ -102,12 +149,11 @@ Gia_Man_t * Gia_ManFromAig( Aig_Man_t * p ) pObj->iData = Gia_ManAppendCi( pNew ); // add logic for the POs Aig_ManForEachCo( p, pObj, i ) - Gia_ManFromAig_rec( pNew, p, Aig_ObjFanin0(pObj) ); + Gia_ManFromAigChoices_rec( pNew, p, Aig_ObjFanin0(pObj) ); Aig_ManForEachCo( p, pObj, i ) Gia_ManAppendCo( pNew, Gia_ObjChild0Copy(pObj) ); Gia_ManSetRegNum( pNew, Aig_ManRegNum(p) ); - if ( pNew->pNexts ) - Gia_ManDeriveReprs( pNew ); + assert( Gia_ManObjNum(pNew) == Aig_ManObjNum(p) ); return pNew; } @@ -195,7 +241,7 @@ Gia_Man_t * Gia_ManFromAigSwitch( Aig_Man_t * p ) /**Function************************************************************* - Synopsis [Derives combinational miter of the two AIGs.] + Synopsis [Duplicates AIG in the DFS order.] Description [] @@ -228,18 +274,6 @@ void Gia_ManToAig_rec( Aig_Man_t * pNew, Aig_Obj_t ** ppNodes, Gia_Man_t * p, Gi pNew->pEquivs[Aig_Regular(pObjNew)->Id] = Aig_Regular(pNextNew); } } - -/**Function************************************************************* - - Synopsis [Duplicates AIG in the DFS order.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ Aig_Man_t * Gia_ManToAig( Gia_Man_t * p, int fChoices ) { Aig_Man_t * pNew; @@ -541,7 +575,8 @@ Gia_Man_t * Gia_ManPerformDch( Gia_Man_t * p, void * pPars ) Aig_Man_t * pNew; pNew = Gia_ManToAig( p, 0 ); pNew = Dar_ManChoiceNew( pNew, (Dch_Pars_t *)pPars ); - pGia = Gia_ManFromAig( pNew ); +// pGia = Gia_ManFromAig( pNew ); + pGia = Gia_ManFromAigChoices( pNew ); Aig_ManStop( pNew ); return pGia; } diff --git a/src/aig/gia/giaAig.h b/src/aig/gia/giaAig.h index b72f6415..6498ec52 100644 --- a/src/aig/gia/giaAig.h +++ b/src/aig/gia/giaAig.h @@ -51,6 +51,7 @@ ABC_NAMESPACE_HEADER_START /*=== giaAig.c =============================================================*/ extern Gia_Man_t * Gia_ManFromAig( Aig_Man_t * p ); +extern Gia_Man_t * Gia_ManFromAigChoices( Aig_Man_t * p ); extern Gia_Man_t * Gia_ManFromAigSimple( Aig_Man_t * p ); extern Gia_Man_t * Gia_ManFromAigSwitch( Aig_Man_t * p ); extern Aig_Man_t * Gia_ManToAig( Gia_Man_t * p, int fChoices ); diff --git a/src/aig/gia/giaChoice.c b/src/aig/gia/giaChoice.c index 85f0a372..ca2acb28 100644 --- a/src/aig/gia/giaChoice.c +++ b/src/aig/gia/giaChoice.c @@ -20,6 +20,7 @@ #include "gia.h" #include "giaAig.h" +#include "misc/tim/tim.h" ABC_NAMESPACE_IMPL_START @@ -261,6 +262,108 @@ int Gia_ManHasChoices( Gia_Man_t * p ) return 1; } + +/**Function************************************************************* + + Synopsis [Computes levels for AIG with choices and white boxes.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManChoiceLevel_rec( Gia_Man_t * p, Gia_Obj_t * pObj ) +{ + Tim_Man_t * pManTime = (Tim_Man_t *)p->pManTime; + Gia_Obj_t * pNext; + int i, iBox, iTerm1, nTerms, LevelMax = 0; + if ( Gia_ObjIsTravIdCurrent( p, pObj ) ) + return; + Gia_ObjSetTravIdCurrent( p, pObj ); + if ( Gia_ObjIsCi(pObj) ) + { + if ( pManTime ) + { + iBox = Tim_ManBoxForCi( pManTime, Gia_ObjCioId(pObj) ); + if ( iBox >= 0 ) // this is not a true PI + { + iTerm1 = Tim_ManBoxInputFirst( pManTime, iBox ); + nTerms = Tim_ManBoxInputNum( pManTime, iBox ); + for ( i = 0; i < nTerms; i++ ) + { + pNext = Gia_ManCo( p, iTerm1 + i ); + Gia_ManChoiceLevel_rec( p, pNext ); + if ( LevelMax < Gia_ObjLevel(p, pNext) ) + LevelMax = Gia_ObjLevel(p, pNext); + } + LevelMax++; + } + } +// Abc_Print( 1, "%d ", pObj->Level ); + } + else if ( Gia_ObjIsCo(pObj) ) + { + pNext = Gia_ObjFanin0(pObj); + Gia_ManChoiceLevel_rec( p, pNext ); + if ( LevelMax < Gia_ObjLevel(p, pNext) ) + LevelMax = Gia_ObjLevel(p, pNext); + } + else if ( Gia_ObjIsAnd(pObj) ) + { + // get the maximum level of the two fanins + pNext = Gia_ObjFanin0(pObj); + Gia_ManChoiceLevel_rec( p, pNext ); + if ( LevelMax < Gia_ObjLevel(p, pNext) ) + LevelMax = Gia_ObjLevel(p, pNext); + pNext = Gia_ObjFanin1(pObj); + Gia_ManChoiceLevel_rec( p, pNext ); + if ( LevelMax < Gia_ObjLevel(p, pNext) ) + LevelMax = Gia_ObjLevel(p, pNext); + LevelMax++; + + // get the level of the nodes in the choice node + if ( p->pSibls && (pNext = Gia_ObjSiblObj(p, Gia_ObjId(p, pObj))) ) + { + Gia_ManChoiceLevel_rec( p, pNext ); + if ( LevelMax < Gia_ObjLevel(p, pNext) ) + LevelMax = Gia_ObjLevel(p, pNext); + } + } + else if ( !Gia_ObjIsConst0(pObj) ) + assert( 0 ); + Gia_ObjSetLevel( p, pObj, LevelMax ); +} +int Gia_ManChoiceLevel( Gia_Man_t * p ) +{ + Gia_Obj_t * pObj; + int i, LevelMax = 0; +// assert( Gia_ManRegNum(p) == 0 ); + Gia_ManCleanLevels( p, Gia_ManObjNum(p) ); + Gia_ManIncrementTravId( p ); + Gia_ManForEachCo( p, pObj, i ) + { + Gia_ManChoiceLevel_rec( p, pObj ); + if ( LevelMax < Gia_ObjLevel(p, pObj) ) + LevelMax = Gia_ObjLevel(p, pObj); + } + // account for dangling boxes + Gia_ManForEachCi( p, pObj, i ) + { + Gia_ManChoiceLevel_rec( p, pObj ); + if ( LevelMax < Gia_ObjLevel(p, pObj) ) + LevelMax = Gia_ObjLevel(p, pObj); +// Abc_Print( 1, "%d ", Gia_ObjLevel(p, pObj) ); + } +// Abc_Print( 1, "\n" ); + Gia_ManForEachAnd( p, pObj, i ) + assert( Gia_ObjLevel(p, pObj) > 0 ); +// printf( "Max level %d\n", LevelMax ); + return LevelMax; +} + + //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/aig/gia/giaFront.c b/src/aig/gia/giaFront.c index 322da785..fc99cfe9 100644 --- a/src/aig/gia/giaFront.c +++ b/src/aig/gia/giaFront.c @@ -103,13 +103,54 @@ void Gia_ManFrontTransform( Gia_Man_t * p ) SeeAlso [] ***********************************************************************/ +int Gia_ManCrossCutSimple( Gia_Man_t * p ) +{ + Gia_Obj_t * pObj; + int i, nCutCur = 0, nCutMax = 0; + Gia_ManCreateValueRefs( p ); + Gia_ManForEachObj( p, pObj, i ) + { + if ( pObj->Value ) + nCutCur++; + if ( nCutMax < nCutCur ) + nCutMax = nCutCur; + if ( Gia_ObjIsAnd(pObj) ) + { + if ( --Gia_ObjFanin0(pObj)->Value == 0 ) + nCutCur--; + if ( --Gia_ObjFanin1(pObj)->Value == 0 ) + nCutCur--; + } + else if ( Gia_ObjIsCo(pObj) ) + { + if ( --Gia_ObjFanin0(pObj)->Value == 0 ) + nCutCur--; + } + } +// Gia_ManForEachObj( p, pObj, i ) +// assert( pObj->Value == 0 ); + return nCutMax; +} + + +/**Function************************************************************* + + Synopsis [Determine the frontier.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ Gia_Man_t * Gia_ManFront( Gia_Man_t * p ) { Gia_Man_t * pNew; Gia_Obj_t * pObj, * pFanin0New, * pFanin1New, * pObjNew; char * pFront; // places used for the frontier int i, iLit, nCrossCut = 0, nCrossCutMax = 0; - int nCrossCutMaxInit = Gia_ManCrossCut( p ); + int nCrossCutMaxInit = Gia_ManCrossCutSimple( p ); int iFront = 0;//, clk = clock(); // set references for all objects Gia_ManCreateValueRefs( p ); diff --git a/src/aig/gia/giaIf.c b/src/aig/gia/giaIf.c index 13e4f429..deab1a60 100644 --- a/src/aig/gia/giaIf.c +++ b/src/aig/gia/giaIf.c @@ -21,7 +21,7 @@ #include "gia.h" #include "aig/aig/aig.h" #include "map/if/if.h" -#include "opt/dar/dar.h" +#include "bool/kit/kit.h" ABC_NAMESPACE_IMPL_START @@ -30,6 +30,9 @@ ABC_NAMESPACE_IMPL_START /// DECLARATIONS /// //////////////////////////////////////////////////////////////////////// +extern int Kit_TruthToGia( Gia_Man_t * pMan, unsigned * pTruth, int nVars, Vec_Int_t * vMemory, Vec_Int_t * vLeaves, int fHash ); +extern int Abc_RecToGia2( Gia_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut, If_Obj_t * pIfObj, Vec_Int_t * vLeaves, int fHash ); + //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// //////////////////////////////////////////////////////////////////////// @@ -45,44 +48,48 @@ ABC_NAMESPACE_IMPL_START SeeAlso [] ***********************************************************************/ -void Gia_ManSetIfParsDefault( If_Par_t * pPars ) +void Gia_ManSetIfParsDefault( void * pp ) { + If_Par_t * pPars = (If_Par_t *)pp; // extern void * Abc_FrameReadLibLut(); + If_Par_t * p = (If_Par_t *)pPars; // set defaults - memset( pPars, 0, sizeof(If_Par_t) ); + memset( p, 0, sizeof(If_Par_t) ); // user-controlable paramters -// pPars->nLutSize = -1; - pPars->nLutSize = 6; - pPars->nCutsMax = 8; - pPars->nFlowIters = 1; - pPars->nAreaIters = 2; - pPars->DelayTarget = -1; - pPars->Epsilon = (float)0.005; - pPars->fPreprocess = 1; - pPars->fArea = 0; - pPars->fFancy = 0; - pPars->fExpRed = 1; //// - pPars->fLatchPaths = 0; - pPars->fEdge = 1; - pPars->fPower = 0; - pPars->fCutMin = 0; - pPars->fSeqMap = 0; - pPars->fVerbose = 0; + p->nLutSize = -1; +// p->nLutSize = 6; + p->nCutsMax = 8; + p->nFlowIters = 1; + p->nAreaIters = 2; + p->DelayTarget = -1; + p->Epsilon = (float)0.005; + p->fPreprocess = 1; + p->fArea = 0; + p->fFancy = 0; + p->fExpRed = 0; //// + p->fLatchPaths = 0; + p->fEdge = 1; + p->fPower = 0; + p->fCutMin = 0; + p->fSeqMap = 0; + p->fVerbose = 0; + p->pLutStruct = NULL; // internal parameters - pPars->fTruth = 0; - pPars->nLatchesCi = 0; - pPars->nLatchesCo = 0; - pPars->fLiftLeaves = 0; -// pPars->pLutLib = Abc_FrameReadLibLut(); - pPars->pLutLib = NULL; - pPars->pTimesArr = NULL; - pPars->pTimesArr = NULL; - pPars->pFuncCost = NULL; + p->fTruth = 0; + p->nLatchesCi = 0; + p->nLatchesCo = 0; + p->fLiftLeaves = 0; + p->fUseCoAttrs = 1; // use CO attributes + p->pLutLib = NULL; + p->pTimesArr = NULL; + p->pTimesArr = NULL; + p->pFuncCost = NULL; } + /**Function************************************************************* - Synopsis [Load the network into FPGA manager.] + Synopsis [Prints mapping statistics.] Description [] @@ -91,97 +98,17 @@ void Gia_ManSetIfParsDefault( If_Par_t * pPars ) SeeAlso [] ***********************************************************************/ -If_Man_t * Gia_ManToIf( Gia_Man_t * p, If_Par_t * pPars, Vec_Ptr_t * vAigToIf ) +int Gia_ManLutFaninCount( Gia_Man_t * p ) { -// extern Vec_Int_t * SGia_ManComputeSwitchProbs( Gia_Man_t * p, int nFrames, int nPref, int fProbOne ); -// Vec_Int_t * vSwitching = NULL, * vSwitching2 = NULL; -// float * pSwitching, * pSwitching2; - If_Man_t * pIfMan; - If_Obj_t * pIfObj; - Gia_Obj_t * pNode; - int i;//, clk = clock(); - Gia_ManLevelNum( p ); -// assert( p->pReprs == NULL ); -/* - // set the number of registers (switch activity will be combinational) - Gia_ManSetRegNum( p, 0 ); - if ( pPars->fPower ) - { - vSwitching = SGia_ManComputeSwitchProbs( p, 48, 16, 0 ); - if ( pPars->fVerbose ) - { - ABC_PRT( "Computing switching activity", clock() - clk ); - } - pSwitching = (float *)vSwitching->pArray; - vSwitching2 = Vec_IntStart( Gia_ManObjNumMax(p) ); - pSwitching2 = (float *)vSwitching2->pArray; - } -*/ - // start the mapping manager and set its parameters - pIfMan = If_ManStart( pPars ); -// pIfMan->vSwitching = vSwitching2; - // load the AIG into the mapper - Gia_ManCreateRefs( p ); - Gia_ManForEachObj( p, pNode, i ) - { - if ( Gia_ObjIsAnd(pNode) ) - pIfObj = If_ManCreateAnd( pIfMan, - If_NotCond( (If_Obj_t *)Vec_PtrEntry(vAigToIf, Gia_ObjFaninId0(pNode, i)), Gia_ObjFaninC0(pNode) ), - If_NotCond( (If_Obj_t *)Vec_PtrEntry(vAigToIf, Gia_ObjFaninId1(pNode, i)), Gia_ObjFaninC1(pNode) ) ); - else if ( Gia_ObjIsCi(pNode) ) - { - pIfObj = If_ManCreateCi( pIfMan ); - If_ObjSetLevel( pIfObj, Gia_ObjLevel(p,pNode) ); -// Abc_Print( 1, "pi=%d ", pIfObj->Level ); - if ( pIfMan->nLevelMax < (int)pIfObj->Level ) - pIfMan->nLevelMax = (int)pIfObj->Level; - } - else if ( Gia_ObjIsCo(pNode) ) - { - pIfObj = If_ManCreateCo( pIfMan, If_NotCond( (If_Obj_t *)Vec_PtrEntry(vAigToIf, Gia_ObjFaninId0(pNode, i)), Gia_ObjFaninC0(pNode) ) ); -// Abc_Print( 1, "po=%d ", pIfObj->Level ); - } - else if ( Gia_ObjIsConst0(pNode) ) - pIfObj = If_Not(If_ManConst1( pIfMan )); - else // add the node to the mapper - assert( 0 ); - // save the result - assert( Vec_PtrEntry(vAigToIf, i) == NULL ); - Vec_PtrWriteEntry( vAigToIf, i, pIfObj ); -// if ( vSwitching2 ) -// pSwitching2[pIfObj->Id] = pSwitching[pNode->Id]; - // set up the choice node -/* -// if ( p->pReprs && p->pNexts && Gia_ObjIsHead( p, i ) ) - if ( p->pNexts && Gia_ObjNext(p, i) && Gia_ObjRefNumId(p, i) ) - { - int iPrev, iFanin; - pIfMan->nChoices++; - for ( iPrev = i, iFanin = Gia_ObjNext(p, i); iFanin; iPrev = iFanin, iFanin = Gia_ObjNext(p, iFanin) ) - If_ObjSetChoice( Vec_PtrEntry(vAigToIf,iPrev), Vec_PtrEntry(vAigToIf,iFanin) ); - If_ManCreateChoice( pIfMan, Vec_PtrEntry(vAigToIf,i) ); - } -*/ -/* // set up the choice node - if ( Gia_ObjIsChoice( p, pNode ) ) - { - pIfMan->nChoices++; - for ( pPrev = pNode, pFanin = Gia_ObjEquiv(p, pNode); pFanin; pPrev = pFanin, pFanin = Gia_ObjEquiv(p, pFanin) ) - If_ObjSetChoice( pPrev->pData, pFanin->pData ); - If_ManCreateChoice( pIfMan, pNode->pData ); - } -// assert( If_ObjLevel(pIfObj) == Gia_ObjLevel(pNode) ); -*/ - } -// if ( vSwitching ) -// Vec_IntFree( vSwitching ); - return pIfMan; + int i, Counter = 0; + Gia_ManForEachLut( p, i ) + Counter += Gia_ObjLutSize(p, i); + return Counter; } - /**Function************************************************************* - Synopsis [] + Synopsis [Prints mapping statistics.] Description [] @@ -190,60 +117,17 @@ If_Man_t * Gia_ManToIf( Gia_Man_t * p, If_Par_t * pPars, Vec_Ptr_t * vAigToIf ) SeeAlso [] ***********************************************************************/ -int * Gia_ManFromIf( If_Man_t * pIfMan, Gia_Man_t * p, Vec_Ptr_t * vAigToIf ) +int Gia_ManLutSizeMax( Gia_Man_t * p ) { - int * pMapping, iOffset; - Vec_Ptr_t * vIfToAig; - Gia_Obj_t * pObj, * pObjRepr; - If_Obj_t * pIfObj; - If_Cut_t * pCutBest; - int i, k, j, nLeaves, * ppLeaves; - int nItems = 0; - assert( Gia_ManCiNum(p) == If_ManCiNum(pIfMan) ); - assert( Gia_ManCoNum(p) == If_ManCoNum(pIfMan) ); - assert( Gia_ManAndNum(p) == If_ManAndNum(pIfMan) ); - // create mapping of IF to AIG - vIfToAig = Vec_PtrStart( If_ManObjNum(pIfMan) ); - Gia_ManForEachObj( p, pObj, i ) - { - pIfObj = (If_Obj_t *)Vec_PtrEntry( vAigToIf, i ); - Vec_PtrWriteEntry( vIfToAig, pIfObj->Id, pObj ); - if ( !Gia_ObjIsAnd(pObj) || pIfObj->nRefs == 0 ) - continue; - nItems += 2 + If_CutLeaveNum( If_ObjCutBest(pIfObj) ); - } - // construct the network - pMapping = ABC_CALLOC( int, Gia_ManObjNum(p) + nItems ); - iOffset = Gia_ManObjNum(p); - Gia_ManForEachObj( p, pObj, i ) - { - pIfObj = (If_Obj_t *)Vec_PtrEntry( vAigToIf, i ); - if ( !Gia_ObjIsAnd(pObj) || pIfObj->nRefs == 0 ) - continue; - pCutBest = If_ObjCutBest( pIfObj ); - nLeaves = If_CutLeaveNum( pCutBest ); - ppLeaves = If_CutLeaves( pCutBest ); - // create node - k = iOffset; - pMapping[k++] = nLeaves; - for ( j = 0; j < nLeaves; j++ ) - { - pObjRepr = (Gia_Obj_t *)Vec_PtrEntry( vIfToAig, ppLeaves[j] ); - pMapping[k++] = Gia_ObjId( p, pObjRepr ); - } - pMapping[k++] = i; - pMapping[i] = iOffset; - iOffset = k; - } - assert( iOffset <= Gia_ManObjNum(p) + nItems ); - Vec_PtrFree( vIfToAig ); -// pNtk->pManTime = Tim_ManDup( pIfMan->pManTim, 0 ); - return pMapping; + int i, nSizeMax = -1; + Gia_ManForEachLut( p, i ) + nSizeMax = Abc_MaxInt( nSizeMax, Gia_ObjLutSize(p, i) ); + return nSizeMax; } /**Function************************************************************* - Synopsis [Interface with the FPGA mapping package.] + Synopsis [Prints mapping statistics.] Description [] @@ -252,39 +136,14 @@ int * Gia_ManFromIf( If_Man_t * pIfMan, Gia_Man_t * p, Vec_Ptr_t * vAigToIf ) SeeAlso [] ***********************************************************************/ -int Gia_MappingIf( Gia_Man_t * p, If_Par_t * pPars ) +int Gia_ManLutNum( Gia_Man_t * p ) { - If_Man_t * pIfMan; - Vec_Ptr_t * vAigToIf; - // set the arrival times - pPars->pTimesArr = ABC_ALLOC( float, Gia_ManCiNum(p) ); - memset( pPars->pTimesArr, 0, sizeof(float) * Gia_ManCiNum(p) ); - // translate into the mapper - vAigToIf = Vec_PtrStart( Gia_ManObjNum(p) ); - pIfMan = Gia_ManToIf( p, pPars, vAigToIf ); - if ( pIfMan == NULL ) - { - Vec_PtrFree( vAigToIf ); - return 0; - } -// pIfMan->pManTim = Tim_ManDup( pManTime, 0 ); - if ( !If_ManPerformMapping( pIfMan ) ) - { - Vec_PtrFree( vAigToIf ); - If_ManStop( pIfMan ); - return 0; - } - // transform the result of mapping into the new network - ABC_FREE( p->pMapping ); - p->pMapping = Gia_ManFromIf( pIfMan, p, vAigToIf ); -// if ( pPars->fBidec && pPars->nLutSize <= 8 ) -// Gia_ManBidecResyn( pNtk, 0 ); - If_ManStop( pIfMan ); - Vec_PtrFree( vAigToIf ); - return 1; + int i, Counter = 0; + Gia_ManForEachLut( p, i ) + Counter ++; + return Counter; } - /**Function************************************************************* Synopsis [Prints mapping statistics.] @@ -296,35 +155,30 @@ int Gia_MappingIf( Gia_Man_t * p, If_Par_t * pPars ) SeeAlso [] ***********************************************************************/ -void Gia_ManPrintMappingStats( Gia_Man_t * p ) +int Gia_ManLutLevel( Gia_Man_t * p ) { - int * pLevels; - int i, k, iFan, nLutSize = 0, nLuts = 0, nFanins = 0, LevelMax = 0; - if ( !p->pMapping ) - return; - pLevels = ABC_CALLOC( int, Gia_ManObjNum(p) ); + Gia_Obj_t * pObj; + int i, k, iFan, Level; + int * pLevels = ABC_CALLOC( int, Gia_ManObjNum(p) ); Gia_ManForEachLut( p, i ) { - nLuts++; - nFanins += Gia_ObjLutSize(p, i); - nLutSize = Abc_MaxInt( nLutSize, Gia_ObjLutSize(p, i) ); + Level = 0; Gia_LutForEachFanin( p, i, iFan, k ) - pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[iFan] ); - pLevels[i]++; - LevelMax = Abc_MaxInt( LevelMax, pLevels[i] ); + if ( Level < pLevels[iFan] ) + Level = pLevels[iFan]; + pLevels[i] = Level + 1; } + Level = 0; + Gia_ManForEachCo( p, pObj, k ) + if ( Level < pLevels[Gia_ObjFaninId0p(p, pObj)] ) + Level = pLevels[Gia_ObjFaninId0p(p, pObj)]; ABC_FREE( pLevels ); - Abc_Print( 1, "mapping (K=%d) : ", nLutSize ); - Abc_Print( 1, "lut =%7d ", nLuts ); - Abc_Print( 1, "edge =%8d ", nFanins ); - Abc_Print( 1, "lev =%5d ", LevelMax ); - Abc_Print( 1, "mem =%5.2f MB", 4.0*(Gia_ManObjNum(p) + 2*nLuts + nFanins)/(1<<20) ); - Abc_Print( 1, "\n" ); + return Level; } /**Function************************************************************* - Synopsis [Prints mapping statistics.] + Synopsis [Assigns levels.] Description [] @@ -333,12 +187,17 @@ void Gia_ManPrintMappingStats( Gia_Man_t * p ) SeeAlso [] ***********************************************************************/ -int Gia_ManLutFaninCount( Gia_Man_t * p ) +void Gia_ManSetRefsMapped( Gia_Man_t * p ) { - int i, Counter = 0; + Gia_Obj_t * pObj; + int i, k, iFan; + ABC_FREE( p->pRefs ); + p->pRefs = ABC_CALLOC( int, Gia_ManObjNum(p) ); + Gia_ManForEachCo( p, pObj, i ) + Gia_ObjRefInc( p, Gia_ObjFanin0(pObj) ); Gia_ManForEachLut( p, i ) - Counter += Gia_ObjLutSize(p, i); - return Counter; + Gia_LutForEachFanin( p, i, iFan, k ) + Gia_ObjRefInc( p, Gia_ManObj(p, iFan) ); } /**Function************************************************************* @@ -352,17 +211,37 @@ int Gia_ManLutFaninCount( Gia_Man_t * p ) SeeAlso [] ***********************************************************************/ -int Gia_ManLutSizeMax( Gia_Man_t * p ) +void Gia_ManPrintMappingStats( Gia_Man_t * p ) { - int i, nSizeMax = -1; + int * pLevels; + int i, k, iFan, nLutSize = 0, nLuts = 0, nFanins = 0, LevelMax = 0; + if ( !p->pMapping ) + return; + pLevels = ABC_CALLOC( int, Gia_ManObjNum(p) ); Gia_ManForEachLut( p, i ) - nSizeMax = Abc_MaxInt( nSizeMax, Gia_ObjLutSize(p, i) ); - return nSizeMax; + { + nLuts++; + nFanins += Gia_ObjLutSize(p, i); + nLutSize = Abc_MaxInt( nLutSize, Gia_ObjLutSize(p, i) ); + Gia_LutForEachFanin( p, i, iFan, k ) + pLevels[i] = Abc_MaxInt( pLevels[i], pLevels[iFan] ); + pLevels[i]++; + LevelMax = Abc_MaxInt( LevelMax, pLevels[i] ); + } + ABC_FREE( pLevels ); + Abc_Print( 1, "mapping (K=%d) : ", nLutSize ); + Abc_Print( 1, "lut =%7d ", nLuts ); + Abc_Print( 1, "edge =%8d ", nFanins ); + Abc_Print( 1, "lev =%5d ", LevelMax ); + Abc_Print( 1, "mem =%5.2f MB", 4.0*(Gia_ManObjNum(p) + 2*nLuts + nFanins)/(1<<20) ); + Abc_Print( 1, "\n" ); } + + /**Function************************************************************* - Synopsis [Prints mapping statistics.] + Synopsis [Converts GIA into IF manager.] Description [] @@ -371,17 +250,66 @@ int Gia_ManLutSizeMax( Gia_Man_t * p ) SeeAlso [] ***********************************************************************/ -int Gia_ManLutNum( Gia_Man_t * p ) +static inline If_Obj_t * If_ManFanin0Copy( If_Man_t * pIfMan, Gia_Obj_t * pObj ) { return If_NotCond( If_ManObj(pIfMan, Gia_ObjValue(Gia_ObjFanin0(pObj))), Gia_ObjFaninC0(pObj) ); } +static inline If_Obj_t * If_ManFanin1Copy( If_Man_t * pIfMan, Gia_Obj_t * pObj ) { return If_NotCond( If_ManObj(pIfMan, Gia_ObjValue(Gia_ObjFanin1(pObj))), Gia_ObjFaninC1(pObj) ); } +If_Man_t * Gia_ManToIf( Gia_Man_t * p, If_Par_t * pPars ) { - int i, Counter = 0; - Gia_ManForEachLut( p, i ) - Counter ++; - return Counter; + If_Man_t * pIfMan; + If_Obj_t * pIfObj; + Gia_Obj_t * pObj; + int i; + // create levels with choices + Gia_ManChoiceLevel( p ); + // mark representative nodes + Gia_ManMarkFanoutDrivers( p ); + // start the mapping manager and set its parameters + pIfMan = If_ManStart( pPars ); + pIfMan->pName = Abc_UtilStrsav( Gia_ManName(p) ); + // print warning about excessive memory usage + if ( 1.0 * Gia_ManObjNum(p) * pIfMan->nObjBytes / (1<<30) > 1.0 ) + printf( "Warning: The mapper will allocate %.1f GB for to represent the subject graph with %d AIG nodes.\n", + 1.0 * Gia_ManObjNum(p) * pIfMan->nObjBytes / (1<<30), Gia_ManObjNum(p) ); + // load the AIG into the mapper + Gia_ManFillValue( p ); + Gia_ManConst0(p)->Value = If_ObjId( If_ManConst1(pIfMan) ); + Gia_ManForEachObj1( p, pObj, i ) + { + if ( Gia_ObjIsAnd(pObj) ) + pIfObj = If_ManCreateAnd( pIfMan, If_ManFanin0Copy(pIfMan, pObj), If_ManFanin1Copy(pIfMan, pObj) ); + else if ( Gia_ObjIsCi(pObj) ) + { + pIfObj = If_ManCreateCi( pIfMan ); + If_ObjSetLevel( pIfObj, Gia_ObjLevel(p, pObj) ); +// Abc_Print( 1, "pi%d=%d\n ", If_ObjId(pIfObj), If_ObjLevel(pIfObj) ); + if ( pIfMan->nLevelMax < (int)pIfObj->Level ) + pIfMan->nLevelMax = (int)pIfObj->Level; + } + else if ( Gia_ObjIsCo(pObj) ) + { + pIfObj = If_ManCreateCo( pIfMan, If_NotCond( If_ManFanin0Copy(pIfMan, pObj), Gia_ObjIsConst0(Gia_ObjFanin0(pObj))) ); +// Abc_Print( 1, "po%d=%d\n ", If_ObjId(pIfObj), If_ObjLevel(pIfObj) ); + } + else assert( 0 ); + assert( i == If_ObjId(pIfObj) ); + Gia_ObjSetValue( pObj, If_ObjId(pIfObj) ); + // set up the choice node + if ( Gia_ObjSibl(p, i) && pObj->fMark0 ) + { + Gia_Obj_t * pSibl, * pPrev; + for ( pPrev = pObj, pSibl = Gia_ObjSiblObj(p, i); pSibl; pPrev = pSibl, pSibl = Gia_ObjSiblObj(p, Gia_ObjId(p, pSibl)) ) + If_ObjSetChoice( If_ManObj(pIfMan, Gia_ObjValue(pObj)), If_ManObj(pIfMan, Gia_ObjValue(pSibl)) ); + If_ManCreateChoice( pIfMan, If_ManObj(pIfMan, Gia_ObjValue(pObj)) ); + } +// assert( If_ObjLevel(pIfObj) == Gia_ObjLevel(pNode) ); + } + Gia_ManCleanMark0( p ); + return pIfMan; } + /**Function************************************************************* - Synopsis [Prints mapping statistics.] + Synopsis [Derives node's AIG after SOP balancing] Description [] @@ -390,30 +318,47 @@ int Gia_ManLutNum( Gia_Man_t * p ) SeeAlso [] ***********************************************************************/ -int Gia_ManLutLevel( Gia_Man_t * p ) +int Gia_ManNodeIfSopToGiaInt( Gia_Man_t * pNew, Vec_Wrd_t * vAnds, int nVars, Vec_Int_t * vLeaves, int fHash ) { - Gia_Obj_t * pObj; - int i, k, iFan, Level; - int * pLevels = ABC_CALLOC( int, Gia_ManObjNum(p) ); - Gia_ManForEachLut( p, i ) + Vec_Int_t * vResults; + int iRes0, iRes1, iRes = -1; + If_And_t This; + word Entry; + int i; + if ( Vec_WrdSize(vAnds) == 0 ) + return 0; + if ( Vec_WrdSize(vAnds) == 1 && Vec_WrdEntry(vAnds,0) == 0 ) + return 1; + vResults = Vec_IntAlloc( Vec_WrdSize(vAnds) ); + for ( i = 0; i < nVars; i++ ) + Vec_IntPush( vResults, Vec_IntEntry(vLeaves, i) ); + Vec_WrdForEachEntryStart( vAnds, Entry, i, nVars ) { - Level = 0; - Gia_LutForEachFanin( p, i, iFan, k ) - if ( Level < pLevels[iFan] ) - Level = pLevels[iFan]; - pLevels[i] = Level + 1; + This = If_WrdToAnd( Entry ); + iRes0 = Abc_LitNotCond( Vec_IntEntry(vResults, This.iFan0), This.fCompl0 ); + iRes1 = Abc_LitNotCond( Vec_IntEntry(vResults, This.iFan1), This.fCompl1 ); + if ( fHash ) + iRes = Gia_ManHashAnd( pNew, iRes0, iRes1 ); + else + iRes = Gia_ManAppendAnd( pNew, iRes0, iRes1 ); + Vec_IntPush( vResults, iRes ); } - Level = 0; - Gia_ManForEachCo( p, pObj, k ) - if ( Level < pLevels[Gia_ObjFaninId0p(p, pObj)] ) - Level = pLevels[Gia_ObjFaninId0p(p, pObj)]; - ABC_FREE( pLevels ); - return Level; + Vec_IntFree( vResults ); + return Abc_LitNotCond( iRes, This.fCompl ); +} +int Gia_ManNodeIfSopToGia( Gia_Man_t * pNew, If_Man_t * p, If_Cut_t * pCut, Vec_Int_t * vLeaves, int fHash ) +{ + int iResult; + Vec_Wrd_t * vArray; + vArray = If_CutDelaySopArray( p, pCut ); + iResult = Gia_ManNodeIfSopToGiaInt( pNew, vArray, If_CutLeaveNum(pCut), vLeaves, fHash ); +// Vec_WrdFree( vArray ); + return iResult; } /**Function************************************************************* - Synopsis [Assigns levels.] + Synopsis [Recursively derives the local AIG for the cut.] Description [] @@ -422,22 +367,74 @@ int Gia_ManLutLevel( Gia_Man_t * p ) SeeAlso [] ***********************************************************************/ -void Gia_ManSetRefsMapped( Gia_Man_t * p ) +int Gia_ManNodeIfToGia_rec( Gia_Man_t * pNew, If_Man_t * pIfMan, If_Obj_t * pIfObj, Vec_Ptr_t * vVisited, int fHash ) { - Gia_Obj_t * pObj; - int i, k, iFan; - ABC_FREE( p->pRefs ); - p->pRefs = ABC_CALLOC( int, Gia_ManObjNum(p) ); - Gia_ManForEachCo( p, pObj, i ) - Gia_ObjRefInc( p, Gia_ObjFanin0(pObj) ); - Gia_ManForEachLut( p, i ) - Gia_LutForEachFanin( p, i, iFan, k ) - Gia_ObjRefInc( p, Gia_ManObj(p, iFan) ); + If_Cut_t * pCut; + If_Obj_t * pTemp; + int iFunc, iFunc0, iFunc1; + // get the best cut + pCut = If_ObjCutBest(pIfObj); + // if the cut is visited, return the result + if ( If_CutDataInt(pCut) ) + return If_CutDataInt(pCut); + // mark the node as visited + Vec_PtrPush( vVisited, pCut ); + // insert the worst case + If_CutSetDataInt( pCut, ~0 ); + // skip in case of primary input + if ( If_ObjIsCi(pIfObj) ) + return If_CutDataInt(pCut); + // compute the functions of the children + for ( pTemp = pIfObj; pTemp; pTemp = pTemp->pEquiv ) + { + iFunc0 = Gia_ManNodeIfToGia_rec( pNew, pIfMan, pTemp->pFanin0, vVisited, fHash ); + if ( iFunc0 == ~0 ) + continue; + iFunc1 = Gia_ManNodeIfToGia_rec( pNew, pIfMan, pTemp->pFanin1, vVisited, fHash ); + if ( iFunc1 == ~0 ) + continue; + // both branches are solved + if ( fHash ) + iFunc = Gia_ManHashAnd( pNew, Abc_LitNotCond(iFunc0, pTemp->fCompl0), Abc_LitNotCond(iFunc1, pTemp->fCompl1) ); + else + iFunc = Gia_ManAppendAnd( pNew, Abc_LitNotCond(iFunc0, pTemp->fCompl0), Abc_LitNotCond(iFunc1, pTemp->fCompl1) ); + if ( pTemp->fPhase != pIfObj->fPhase ) + iFunc = Abc_LitNot(iFunc); + If_CutSetDataInt( pCut, iFunc ); + break; + } + return If_CutDataInt(pCut); +} +int Gia_ManNodeIfToGia( Gia_Man_t * pNew, If_Man_t * pIfMan, If_Obj_t * pIfObj, Vec_Int_t * vLeaves, int fHash ) +{ + If_Cut_t * pCut; + If_Obj_t * pLeaf; + int i, iRes; + // get the best cut + pCut = If_ObjCutBest(pIfObj); + assert( pCut->nLeaves > 1 ); + // set the leaf variables + If_CutForEachLeaf( pIfMan, pCut, pLeaf, i ) + If_CutSetDataInt( If_ObjCutBest(pLeaf), Vec_IntEntry(vLeaves, i) ); + // recursively compute the function while collecting visited cuts + Vec_PtrClear( pIfMan->vTemp ); + iRes = Gia_ManNodeIfToGia_rec( pNew, pIfMan, pIfObj, pIfMan->vTemp, fHash ); + if ( iRes == ~0 ) + { + Abc_Print( -1, "Gia_ManNodeIfToGia(): Computing local AIG has failed.\n" ); + return ~0; + } + // clean the cuts + If_CutForEachLeaf( pIfMan, pCut, pLeaf, i ) + If_CutSetDataInt( If_ObjCutBest(pLeaf), 0 ); + Vec_PtrForEachEntry( If_Cut_t *, pIfMan->vTemp, pCut, i ) + If_CutSetDataInt( pCut, 0 ); + return iRes; } /**Function************************************************************* - Synopsis [Prints NPN class statistics.] + Synopsis [Converts IF into GIA manager.] Description [] @@ -446,83 +443,212 @@ void Gia_ManSetRefsMapped( Gia_Man_t * p ) SeeAlso [] ***********************************************************************/ -void Gia_ManPrintNpnClasses( Gia_Man_t * p ) +Gia_Man_t * Gia_ManFromIf( If_Man_t * pIfMan ) { - extern char ** Kit_DsdNpn4ClassNames(); - char ** pNames = Kit_DsdNpn4ClassNames(); - Vec_Int_t * vLeaves, * vTruth, * vVisited; - int * pLutClass, ClassCounts[222] = {0}; - int i, k, iFan, Class, OtherClasses, OtherClasses2, nTotal, Counter, Counter2; + int fHash = 0; + Gia_Man_t * pNew; + If_Obj_t * pIfObj, * pIfLeaf; + If_Cut_t * pCutBest; + Vec_Int_t * vLeaves; + Vec_Int_t * vCover; unsigned * pTruth; - assert( p->pMapping != NULL ); - assert( Gia_ManLutSizeMax( p ) <= 4 ); - vLeaves = Vec_IntAlloc( 100 ); - vVisited = Vec_IntAlloc( 100 ); - vTruth = Vec_IntAlloc( (1<<16) ); - pLutClass = ABC_CALLOC( int, Gia_ManObjNum(p) ); - Gia_ManCleanTruth( p ); - Gia_ManForEachLut( p, i ) + int Counter, iOffset, nItems = 0; + int i, k, w, GiaId; + // create new manager + pNew = Gia_ManStart( If_ManObjNum(pIfMan) ); + Gia_ManHashAlloc( pNew ); + // iterate through nodes used in the mapping + vCover = Vec_IntAlloc( 1 << 16 ); + vLeaves = Vec_IntAlloc( 16 ); + If_ManCleanCutData( pIfMan ); + If_ManForEachObj( pIfMan, pIfObj, i ) { - if ( Gia_ObjLutSize(p,i) > 4 ) + if ( pIfObj->nRefs == 0 && !If_ObjIsTerm(pIfObj) ) continue; - Vec_IntClear( vLeaves ); - Gia_LutForEachFanin( p, i, iFan, k ) - Vec_IntPush( vLeaves, iFan ); - for ( ; k < 4; k++ ) - Vec_IntPush( vLeaves, 0 ); - pTruth = Gia_ManConvertAigToTruth( p, Gia_ManObj(p, i), vLeaves, vTruth, vVisited ); - Class = Dar_LibReturnClass( *pTruth ); - ClassCounts[ Class ]++; - pLutClass[i] = Class; + if ( If_ObjIsAnd(pIfObj) ) + { + pCutBest = If_ObjCutBest( pIfObj ); + // collect leaves of the best cut + Vec_IntClear( vLeaves ); + If_CutForEachLeaf( pIfMan, pCutBest, pIfLeaf, k ) + Vec_IntPush( vLeaves, pIfLeaf->iCopy ); + // get the functionality + if ( pIfMan->pPars->pLutStruct ) + pIfObj->iCopy = Kit_TruthToGia( pNew, If_CutTruth(pCutBest), If_CutLeaveNum(pCutBest), vCover, vLeaves, fHash ); + else if ( pIfMan->pPars->fDelayOpt ) + pIfObj->iCopy = Gia_ManNodeIfSopToGia( pNew, pIfMan, pCutBest, vLeaves, fHash ); + else if ( pIfMan->pPars->fUserRecLib ) + pIfObj->iCopy = Abc_RecToGia2( pNew, pIfMan, pCutBest, pIfObj, vLeaves, fHash ); + else + pIfObj->iCopy = Gia_ManNodeIfToGia( pNew, pIfMan, pIfObj, vLeaves, fHash ); + // complement the node if the TT was used and the cut was complemented + if ( pIfMan->pPars->pLutStruct ) + pIfObj->iCopy = Abc_LitNotCond( pIfObj->iCopy, pCutBest->fCompl ); + // count entries in the mapping array + nItems += 2 + If_CutLeaveNum( pCutBest ); + } + else if ( If_ObjIsCi(pIfObj) ) + pIfObj->iCopy = Gia_ManAppendCi(pNew); + else if ( If_ObjIsCo(pIfObj) ) + pIfObj->iCopy = Gia_ManAppendCo( pNew, Abc_LitNotCond(If_ObjFanin0(pIfObj)->iCopy, If_ObjFaninC0(pIfObj)) ); + else if ( If_ObjIsConst1(pIfObj) ) + { + pIfObj->iCopy = 1; + nItems += 2; + } + else assert( 0 ); } + Vec_IntFree( vCover ); Vec_IntFree( vLeaves ); - Vec_IntFree( vTruth ); - Vec_IntFree( vVisited ); - Vec_IntFreeP( &p->vTruths ); - nTotal = 0; - for ( i = 0; i < 222; i++ ) - nTotal += ClassCounts[i]; - Abc_Print( 1, "NPN CLASS STATISTICS (for %d LUT4 present in the current mapping):\n", nTotal ); - OtherClasses = 0; - for ( i = 0; i < 222; i++ ) + Gia_ManHashStop( pNew ); + + // GIA after mapping with choices may end up with dangling nodes + // which participate as leaves of some cuts used in the mapping + // such nodes are marked here and skipped when mapping is derived + Counter = Gia_ManMarkDangling(pNew); +// if ( pIfMan->pPars->fVerbose && Counter ) + if ( Counter ) + printf( "GIA after mapping has %d dangling nodes.\n", Counter ); + + // create mapping + iOffset = Gia_ManObjNum(pNew); + pNew->pMapping = ABC_CALLOC( int, iOffset + nItems ); + assert( pNew->vTruths == NULL ); + if ( pIfMan->pPars->pLutStruct ) + pNew->vTruths = Vec_IntAlloc( 1000 ); + If_ManForEachObj( pIfMan, pIfObj, i ) { - if ( ClassCounts[i] == 0 ) + if ( pIfObj->nRefs == 0 && !If_ObjIsTerm(pIfObj) ) continue; - if ( 100.0 * ClassCounts[i] / (nTotal+1) < 0.1 ) // do not show anything below 0.1 percent - continue; - OtherClasses += ClassCounts[i]; - Abc_Print( 1, "Class %3d : Count = %6d (%7.2f %%) %s\n", - i, ClassCounts[i], 100.0 * ClassCounts[i] / (nTotal+1), pNames[i] ); + if ( If_ObjIsAnd(pIfObj) ) + { + GiaId = Abc_Lit2Var( pIfObj->iCopy ); + if ( !Gia_ObjIsAnd(Gia_ManObj(pNew, GiaId)) ) // skip trivial node + continue; + assert( Gia_ObjIsAnd(Gia_ManObj(pNew, GiaId)) ); + if ( !Gia_ManObj(pNew, GiaId)->fMark0 ) // skip dangling node + continue; + // get the best cut + pCutBest = If_ObjCutBest( pIfObj ); + // copy the truth tables + pTruth = NULL; + if ( pNew->vTruths ) + { + // copy truth table + for ( w = 0; w < pIfMan->nTruthWords; w++ ) + Vec_IntPush( pNew->vTruths, If_CutTruth(pCutBest)[w] ); + pTruth = (unsigned *)(Vec_IntArray(pNew->vTruths) + Vec_IntSize(pNew->vTruths) - pIfMan->nTruthWords); + // complement + if ( pCutBest->fCompl ^ Abc_LitIsCompl(pIfObj->iCopy) ) + for ( w = 0; w < pIfMan->nTruthWords; w++ ) + pTruth[w] = ~pTruth[w]; + } + // create node + pNew->pMapping[GiaId] = iOffset; + pNew->pMapping[iOffset++] = If_CutLeaveNum(pCutBest); + If_CutForEachLeaf( pIfMan, pCutBest, pIfLeaf, k ) + { + int FaninId = Abc_Lit2Var(pIfLeaf->iCopy); + if ( pTruth && Abc_LitIsCompl(pIfLeaf->iCopy) ) + Kit_TruthChangePhase( pTruth, If_CutLeaveNum(pCutBest), k ); + if ( !Gia_ManObj(pNew, FaninId)->fMark0 ) // skip dangling node + { + // update truth table + if ( pTruth ) + { + extern void If_CluSwapVars( word * pTruth, int nVars, int * V2P, int * P2V, int iVar, int jVar ); + if ( If_CutLeaveNum(pCutBest) >= 6 ) + If_CluSwapVars( (word*)pTruth, If_CutLeaveNum(pCutBest), NULL, NULL, k, If_CutLeaveNum(pCutBest)-1 ); + else + { + word Truth = ((word)pTruth[0] << 32) | (word)pTruth[0]; + If_CluSwapVars( &Truth, 6, NULL, NULL, k, If_CutLeaveNum(pCutBest)-1 ); + pTruth[0] = (Truth & 0xFFFFFFFF); + } + } + pNew->pMapping[iOffset-k-1]--; + continue; + } + assert( FaninId < GiaId ); + pNew->pMapping[iOffset++] = FaninId; + } + pNew->pMapping[iOffset++] = GiaId; + } + else if ( If_ObjIsConst1(pIfObj) ) + { + // create node + pNew->pMapping[0] = iOffset; + pNew->pMapping[iOffset++] = 0; + pNew->pMapping[iOffset++] = 0; +/* + if ( pNew->vTruths ) + { + printf( "%d ", nLeaves ); + for ( w = 0; w < pIfMan->nTruthWords; w++ ) + Vec_IntPush( pNew->vTruths, 0 ); + } +*/ + } } - OtherClasses = nTotal - OtherClasses; - Abc_Print( 1, "Other : Count = %6d (%7.2f %%)\n", - OtherClasses, 100.0 * OtherClasses / (nTotal+1) ); - // count the number of LUTs that have MUX function and two fanins with MUX functions - OtherClasses = OtherClasses2 = 0; - ABC_FREE( p->pRefs ); - Gia_ManSetRefsMapped( p ); - Gia_ManForEachLut( p, i ) + Gia_ManCleanMark0( pNew ); +// assert( iOffset == Gia_ManObjNum(pNew) + nItems ); + if ( pIfMan->pManTim ) + pNew->pManTime = Tim_ManDup( pIfMan->pManTim, 0 ); + // verify that COs have mapping { - if ( pLutClass[i] != 109 ) - continue; - Counter = Counter2 = 0; - Gia_LutForEachFanin( p, i, iFan, k ) + Gia_Obj_t * pObj; + Gia_ManForEachCo( pNew, pObj, i ) { - Counter += (pLutClass[iFan] == 109); - Counter2 += (pLutClass[iFan] == 109) && (Gia_ObjRefNumId(p, iFan) == 1); + if ( Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) ) + assert( pNew->pMapping[Gia_ObjFaninId0p(pNew, pObj)] != 0 ); } - OtherClasses += (Counter > 1); - OtherClasses2 += (Counter2 > 1); -// Abc_Print( 1, "%d -- ", pLutClass[i] ); -// Gia_LutForEachFanin( p, i, iFan, k ) -// Abc_Print( 1, "%d ", pLutClass[iFan] ); -// Abc_Print( 1, "\n" ); } - ABC_FREE( p->pRefs ); - Abc_Print( 1, "Approximate number of 4:1 MUX structures: All = %6d (%7.2f %%) MFFC = %6d (%7.2f %%)\n", - OtherClasses, 100.0 * OtherClasses / (nTotal+1), - OtherClasses2, 100.0 * OtherClasses2 / (nTotal+1) ); - ABC_FREE( pLutClass ); + return pNew; +} + +/**Function************************************************************* + + Synopsis [Interface of LUT mapping package.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Gia_Man_t * Gia_ManPerformMapping( Gia_Man_t * p, void * pp ) +{ + Gia_Man_t * pNew; + If_Man_t * pIfMan; + If_Par_t * pPars = (If_Par_t *)pp; + // set the arrival times + assert( pPars->pTimesArr == NULL ); + pPars->pTimesArr = ABC_ALLOC( float, Gia_ManCiNum(p) ); + memset( pPars->pTimesArr, 0, sizeof(float) * Gia_ManCiNum(p) ); + // translate into the mapper + pIfMan = Gia_ManToIf( p, pPars ); + if ( pIfMan == NULL ) + return NULL; + if ( p->pManTime ) + pIfMan->pManTim = Tim_ManDup( p->pManTime, 0 ); + if ( !If_ManPerformMapping( pIfMan ) ) + { + If_ManStop( pIfMan ); + return NULL; + } + // transform the result of mapping into the new network + pNew = Gia_ManFromIf( pIfMan ); + If_ManStop( pIfMan ); + // transfer name + assert( pNew->pName == NULL ); + pNew->pName = Abc_UtilStrsav( p->pName ); + pNew->pSpec = Abc_UtilStrsav( p->pSpec ); + Gia_ManSetRegNum( pNew, Gia_ManRegNum(p) ); + // unmap in case of SOP balancing +// if ( pIfMan->pPars->fDelayOpt ) +// Vec_IntFreeP( &pNew->vMapping ); + return pNew; } //////////////////////////////////////////////////////////////////////// diff --git a/src/aig/gia/giaMan.c b/src/aig/gia/giaMan.c index f78ea847..0ae484fc 100644 --- a/src/aig/gia/giaMan.c +++ b/src/aig/gia/giaMan.c @@ -21,6 +21,7 @@ #include "gia.h" #include "misc/tim/tim.h" #include "proof/abs/abs.h" +#include "opt/dar/dar.h" ABC_NAMESPACE_IMPL_START @@ -107,6 +108,7 @@ void Gia_ManStop( Gia_Man_t * p ) ABC_FREE( p->pReprsOld ); ABC_FREE( p->pReprs ); ABC_FREE( p->pNexts ); + ABC_FREE( p->pSibls ); ABC_FREE( p->pRefs ); // ABC_FREE( p->pNodeRefs ); ABC_FREE( p->pHTable ); @@ -260,6 +262,36 @@ void Gia_ManPrintTents( Gia_Man_t * p ) SeeAlso [] ***********************************************************************/ +void Gia_ManPrintChoiceStats( Gia_Man_t * p ) +{ + Gia_Obj_t * pObj; + int i, nEquivs = 0, nChoices = 0; + Gia_ManMarkFanoutDrivers( p ); + Gia_ManForEachAnd( p, pObj, i ) + { + if ( !Gia_ObjSibl(p, i) ) + continue; + nEquivs++; + if ( pObj->fMark0 ) + nChoices++; + assert( !Gia_ObjSiblObj(p, i)->fMark0 ); + assert( Gia_ObjIsAnd(Gia_ObjSiblObj(p, i)) ); + } + Abc_Print( 1, "Choice stats: Equivs =%7d. Choices =%7d.\n", nEquivs, nChoices ); + Gia_ManCleanMark0( p ); +} + +/**Function************************************************************* + + Synopsis [Prints stats for the AIG.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ void Gia_ManPrintStats( Gia_Man_t * p, int fTents, int fSwitch ) { if ( p->pName ) @@ -271,7 +303,7 @@ void Gia_ManPrintStats( Gia_Man_t * p, int fTents, int fSwitch ) printf( " ff =%7d", Gia_ManRegNum(p) ); printf( " and =%8d", Gia_ManAndNum(p) ); printf( " lev =%5d", Gia_ManLevelNum(p) ); Vec_IntFreeP( &p->vLevels ); - printf( " cut =%5d", Gia_ManCrossCut(p) ); + printf( " cut = %d(%d)", Gia_ManCrossCut(p, 0), Gia_ManCrossCut(p, 1) ); // printf( " mem =%5.2f MB", 1.0*(sizeof(Gia_Obj_t)*p->nObjs + sizeof(int)*(Vec_IntSize(p->vCis) + Vec_IntSize(p->vCos)))/(1<<20) ); printf( " mem =%5.2f MB", 1.0*(sizeof(Gia_Obj_t)*p->nObjsAlloc + sizeof(int)*(Vec_IntCap(p->vCis) + Vec_IntCap(p->vCos)))/(1<<20) ); if ( Gia_ManHasDangling(p) ) @@ -289,6 +321,8 @@ void Gia_ManPrintStats( Gia_Man_t * p, int fTents, int fSwitch ) // Gia_ManSatExperiment( p ); if ( p->pReprs && p->pNexts ) Gia_ManEquivPrintClasses( p, 0, 0.0 ); + if ( p->pSibls ) + Gia_ManPrintChoiceStats( p ); if ( p->pMapping ) Gia_ManPrintMappingStats( p ); if ( p->pPlacement ) @@ -427,6 +461,96 @@ void Gia_ManReportImprovement( Gia_Man_t * p, Gia_Man_t * pNew ) printf( "\n" ); } +/**Function************************************************************* + + Synopsis [Prints NPN class statistics.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManPrintNpnClasses( Gia_Man_t * p ) +{ + extern char ** Kit_DsdNpn4ClassNames(); + char ** pNames = Kit_DsdNpn4ClassNames(); + Vec_Int_t * vLeaves, * vTruth, * vVisited; + int * pLutClass, ClassCounts[222] = {0}; + int i, k, iFan, Class, OtherClasses, OtherClasses2, nTotal, Counter, Counter2; + unsigned * pTruth; + assert( p->pMapping != NULL ); + assert( Gia_ManLutSizeMax( p ) <= 4 ); + vLeaves = Vec_IntAlloc( 100 ); + vVisited = Vec_IntAlloc( 100 ); + vTruth = Vec_IntAlloc( (1<<16) ); + pLutClass = ABC_CALLOC( int, Gia_ManObjNum(p) ); + Gia_ManCleanTruth( p ); + Gia_ManForEachLut( p, i ) + { + if ( Gia_ObjLutSize(p,i) > 4 ) + continue; + Vec_IntClear( vLeaves ); + Gia_LutForEachFanin( p, i, iFan, k ) + Vec_IntPush( vLeaves, iFan ); + for ( ; k < 4; k++ ) + Vec_IntPush( vLeaves, 0 ); + pTruth = Gia_ManConvertAigToTruth( p, Gia_ManObj(p, i), vLeaves, vTruth, vVisited ); + Class = Dar_LibReturnClass( *pTruth ); + ClassCounts[ Class ]++; + pLutClass[i] = Class; + } + Vec_IntFree( vLeaves ); + Vec_IntFree( vTruth ); + Vec_IntFree( vVisited ); + Vec_IntFreeP( &p->vTruths ); + nTotal = 0; + for ( i = 0; i < 222; i++ ) + nTotal += ClassCounts[i]; + Abc_Print( 1, "NPN CLASS STATISTICS (for %d LUT4 present in the current mapping):\n", nTotal ); + OtherClasses = 0; + for ( i = 0; i < 222; i++ ) + { + if ( ClassCounts[i] == 0 ) + continue; + if ( 100.0 * ClassCounts[i] / (nTotal+1) < 0.1 ) // do not show anything below 0.1 percent + continue; + OtherClasses += ClassCounts[i]; + Abc_Print( 1, "Class %3d : Count = %6d (%7.2f %%) %s\n", + i, ClassCounts[i], 100.0 * ClassCounts[i] / (nTotal+1), pNames[i] ); + } + OtherClasses = nTotal - OtherClasses; + Abc_Print( 1, "Other : Count = %6d (%7.2f %%)\n", + OtherClasses, 100.0 * OtherClasses / (nTotal+1) ); + // count the number of LUTs that have MUX function and two fanins with MUX functions + OtherClasses = OtherClasses2 = 0; + ABC_FREE( p->pRefs ); + Gia_ManSetRefsMapped( p ); + Gia_ManForEachLut( p, i ) + { + if ( pLutClass[i] != 109 ) + continue; + Counter = Counter2 = 0; + Gia_LutForEachFanin( p, i, iFan, k ) + { + Counter += (pLutClass[iFan] == 109); + Counter2 += (pLutClass[iFan] == 109) && (Gia_ObjRefNumId(p, iFan) == 1); + } + OtherClasses += (Counter > 1); + OtherClasses2 += (Counter2 > 1); +// Abc_Print( 1, "%d -- ", pLutClass[i] ); +// Gia_LutForEachFanin( p, i, iFan, k ) +// Abc_Print( 1, "%d ", pLutClass[iFan] ); +// Abc_Print( 1, "\n" ); + } + ABC_FREE( p->pRefs ); + Abc_Print( 1, "Approximate number of 4:1 MUX structures: All = %6d (%7.2f %%) MFFC = %6d (%7.2f %%)\n", + OtherClasses, 100.0 * OtherClasses / (nTotal+1), + OtherClasses2, 100.0 * OtherClasses2 / (nTotal+1) ); + ABC_FREE( pLutClass ); +} + //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/aig/gia/giaScl.c b/src/aig/gia/giaScl.c index 0aa255db..9b4c1c3e 100644 --- a/src/aig/gia/giaScl.c +++ b/src/aig/gia/giaScl.c @@ -94,6 +94,32 @@ Gia_Man_t * Gia_ManCleanup( Gia_Man_t * p ) return Gia_ManDupMarked( p ); } +/**Function************************************************************* + + Synopsis [Skip the first outputs during cleanup.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Gia_Man_t * Gia_ManCleanupOutputs( Gia_Man_t * p, int nOutputs ) +{ + Gia_Obj_t * pObj; + int i; + assert( Gia_ManRegNum(p) == 0 ); + assert( nOutputs < Gia_ManCoNum(p) ); + Gia_ManCombMarkUsed( p ); + Gia_ManForEachCo( p, pObj, i ) + if ( i < nOutputs ) + pObj->fMark0 = 1; + else + break; + return Gia_ManDupMarked( p ); +} + /**Function************************************************************* diff --git a/src/aig/gia/giaUtil.c b/src/aig/gia/giaUtil.c index da713aa0..8389a9b0 100644 --- a/src/aig/gia/giaUtil.c +++ b/src/aig/gia/giaUtil.c @@ -550,12 +550,59 @@ int * Gia_ManCreateMuxRefs( Gia_Man_t * p ) SeeAlso [] ***********************************************************************/ -int Gia_ManCrossCut( Gia_Man_t * p ) +void Gia_ManDfsForCrossCut_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vNodes ) { + if ( Gia_ObjIsTravIdCurrent(p, pObj) ) + return; + Gia_ObjSetTravIdCurrent(p, pObj); + if ( Gia_ObjIsCi(pObj) ) + { + Vec_IntPush( vNodes, Gia_ObjId(p, pObj) ); + return; + } + if ( Gia_ObjIsCo(pObj) ) + { + Gia_ObjFanin0(pObj)->Value++; + Gia_ManDfsForCrossCut_rec( p, Gia_ObjFanin0(pObj), vNodes ); + Vec_IntPush( vNodes, Gia_ObjId(p, pObj) ); + return; + } + assert( Gia_ObjIsAnd(pObj) ); + Gia_ObjFanin0(pObj)->Value++; + Gia_ObjFanin1(pObj)->Value++; + Gia_ManDfsForCrossCut_rec( p, Gia_ObjFanin0(pObj), vNodes ); + Gia_ManDfsForCrossCut_rec( p, Gia_ObjFanin1(pObj), vNodes ); + Vec_IntPush( vNodes, Gia_ObjId(p, pObj) ); +} +Vec_Int_t * Gia_ManDfsForCrossCut( Gia_Man_t * p, int fReverse ) +{ + Vec_Int_t * vNodes; + Gia_Obj_t * pObj; + int i; + Gia_ManCleanValue( p ); + vNodes = Vec_IntAlloc( Gia_ManObjNum(p) ); + Gia_ManIncrementTravId( p ); + if ( fReverse ) + { + Gia_ManForEachCoReverse( p, pObj, i ) + if ( !Gia_ObjIsConst0(Gia_ObjFanin0(pObj)) ) + Gia_ManDfsForCrossCut_rec( p, pObj, vNodes ); + } + else + { + Gia_ManForEachCo( p, pObj, i ) + if ( !Gia_ObjIsConst0(Gia_ObjFanin0(pObj)) ) + Gia_ManDfsForCrossCut_rec( p, pObj, vNodes ); + } + return vNodes; +} +int Gia_ManCrossCut( Gia_Man_t * p, int fReverse ) +{ + Vec_Int_t * vNodes; Gia_Obj_t * pObj; int i, nCutCur = 0, nCutMax = 0; - Gia_ManCreateValueRefs( p ); - Gia_ManForEachObj( p, pObj, i ) + vNodes = Gia_ManDfsForCrossCut( p, fReverse ); + Gia_ManForEachObjVec( vNodes, p, pObj, i ) { if ( pObj->Value ) nCutCur++; @@ -574,8 +621,9 @@ int Gia_ManCrossCut( Gia_Man_t * p ) nCutCur--; } } -// Gia_ManForEachObj( p, pObj, i ) -// assert( pObj->Value == 0 ); + Vec_IntFree( vNodes ); + Gia_ManForEachObj( p, pObj, i ) + assert( pObj->Value == 0 ); return nCutMax; } @@ -1195,6 +1243,31 @@ int Gia_ManCompare( Gia_Man_t * p1, Gia_Man_t * p2 ) return 1; } +/**Function************************************************************* + + Synopsis [Marks nodes that appear as faninis of other nodes.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Gia_ManMarkFanoutDrivers( Gia_Man_t * p ) +{ + Gia_Obj_t * pObj; + int i; + Gia_ManCleanMark0( p ); + Gia_ManForEachObj( p, pObj, i ) + if ( Gia_ObjIsAnd(pObj) ) + { + Gia_ObjFanin0(pObj)->fMark0 = 1; + Gia_ObjFanin1(pObj)->fMark0 = 1; + } + else if ( Gia_ObjIsCo(pObj) ) + Gia_ObjFanin0(pObj)->fMark0 = 1; +} //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/base/abc/abc.h b/src/base/abc/abc.h index f8e16cd6..e08e11d9 100644 --- a/src/base/abc/abc.h +++ b/src/base/abc/abc.h @@ -789,7 +789,7 @@ extern ABC_DLL int Abc_NtkRecVarNum(); extern ABC_DLL Vec_Int_t * Abc_NtkRecMemory(); extern ABC_DLL int Abc_NtkRecStrashNode( Abc_Ntk_t * pNtkNew, Abc_Obj_t * pObj, unsigned * pTruth, int nVars ); /*=== abcRec2.c ==========================================================*/ -extern ABC_DLL void Abc_NtkRecStart2( Gia_Man_t *p, int nVars, int nCuts, int fTrim ); +extern ABC_DLL void Abc_NtkRecStart2( Gia_Man_t * p, int nVars, int nCuts, int fTrim ); extern ABC_DLL void Abc_NtkRecStop2(); extern ABC_DLL void Abc_NtkRecAdd2( Abc_Ntk_t * pNtk, int fUseSOPB ); extern ABC_DLL void Abc_NtkRecPs2(int fPrintLib); @@ -798,6 +798,15 @@ extern ABC_DLL void Abc_NtkRecLibMerge2(Gia_Man_t * pGia); extern ABC_DLL int Abc_NtkRecIsRunning2(); extern ABC_DLL int Abc_NtkRecIsInTrimMode2(); extern ABC_DLL void Abc_NtkRecFilter2(int nLimit); +/*=== abcRec3.c ==========================================================*/ +extern ABC_DLL void Abc_NtkRecStart3( Gia_Man_t * p, int nVars, int nCuts, int fFuncOnly, int fVerbose ); +extern ABC_DLL void Abc_NtkRecStop3(); +extern ABC_DLL void Abc_NtkRecAdd3( Abc_Ntk_t * pNtk, int fUseSOPB ); +extern ABC_DLL void Abc_NtkRecPs3(int fPrintLib); +extern ABC_DLL Gia_Man_t * Abc_NtkRecGetGia3(); +extern ABC_DLL int Abc_NtkRecIsRunning3(); +extern ABC_DLL void Abc_NtkRecLibMerge3(Gia_Man_t * pGia); +//extern ABC_DLL void Abc_NtkRecFilter3(int nLimit); /*=== abcReconv.c ==========================================================*/ extern ABC_DLL Abc_ManCut_t * Abc_NtkManCutStart( int nNodeSizeMax, int nConeSizeMax, int nNodeFanStop, int nConeFanStop ); extern ABC_DLL void Abc_NtkManCutStop( Abc_ManCut_t * p ); diff --git a/src/base/abc/abcCheck.c b/src/base/abc/abcCheck.c index bc3399e0..6dc06f19 100644 --- a/src/base/abc/abcCheck.c +++ b/src/base/abc/abcCheck.c @@ -377,12 +377,12 @@ int Abc_NtkCheckPos( Abc_Ntk_t * pNtk ) } if ( Abc_ObjFaninNum(pObj) != 1 ) { - fprintf( stdout, "NetworkCheck: A PO \"%s\" does not have one fanin.\n", Abc_ObjName(pObj) ); + fprintf( stdout, "NetworkCheck: A PO \"%s\" does not have one fanin (but %d).\n", Abc_ObjName(pObj), Abc_ObjFaninNum(pObj) ); return 0; } if ( Abc_ObjFanoutNum(pObj) > 0 ) { - fprintf( stdout, "NetworkCheck: A PO \"%s\" has fanouts.\n", Abc_ObjName(pObj) ); + fprintf( stdout, "NetworkCheck: A PO \"%s\" has %d fanout(s).\n", Abc_ObjName(pObj), Abc_ObjFanoutNum(pObj) ); return 0; } pObj->pCopy = (Abc_Obj_t *)1; diff --git a/src/base/abc/abcFanio.c b/src/base/abc/abcFanio.c index 5fb22d79..2669ae0c 100644 --- a/src/base/abc/abcFanio.c +++ b/src/base/abc/abcFanio.c @@ -87,20 +87,13 @@ void Abc_ObjAddFanin( Abc_Obj_t * pObj, Abc_Obj_t * pFanin ) assert( !Abc_ObjIsComplement(pObj) ); assert( pObj->pNtk == pFaninR->pNtk ); assert( pObj->Id >= 0 && pFaninR->Id >= 0 ); + assert( !Abc_ObjIsPi(pObj) && !Abc_ObjIsPo(pFanin) ); // fanin of PI or fanout of PO + assert( !Abc_ObjIsCo(pObj) || !Abc_ObjFaninNum(pObj) ); // CO with two fanins + assert( !Abc_ObjIsNet(pObj) || !Abc_ObjFaninNum(pObj) ); // net with two fanins Vec_IntPushMem( pObj->pNtk->pMmStep, &pObj->vFanins, pFaninR->Id ); Vec_IntPushMem( pObj->pNtk->pMmStep, &pFaninR->vFanouts, pObj->Id ); if ( Abc_ObjIsComplement(pFanin) ) Abc_ObjSetFaninC( pObj, Abc_ObjFaninNum(pObj)-1 ); - if ( Abc_ObjIsNet(pObj) && Abc_ObjFaninNum(pObj) > 1 ) - { - printf( "Abc_ObjAddFanin(): Error! Creating net \"%s\" with two fanins.\n", Abc_ObjName(pObj) ); - } -/* - if ( Abc_ObjIsCo(pFanin) ) - { - printf( "Abc_ObjAddFanin(): Error! Creating fanout of a CO.\n", Abc_ObjName(pFanin) ); - } -*/ } diff --git a/src/base/abci/abc.c b/src/base/abci/abc.c index d1acef62..c6ec9d5b 100644 --- a/src/base/abci/abc.c +++ b/src/base/abci/abc.c @@ -169,6 +169,10 @@ static int Abc_CommandSenseInput ( Abc_Frame_t * pAbc, int argc, cha static int Abc_CommandNpnLoad ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandNpnSave ( Abc_Frame_t * pAbc, int argc, char ** argv ); +static int Abc_CommandSendAig ( Abc_Frame_t * pAbc, int argc, char ** argv ); +static int Abc_CommandSendStatus ( Abc_Frame_t * pAbc, int argc, char ** argv ); +static int Abc_CommandSendCex ( Abc_Frame_t * pAbc, int argc, char ** argv ); + static int Abc_CommandIStrash ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandICut ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandIRewrite ( Abc_Frame_t * pAbc, int argc, char ** argv ); @@ -201,20 +205,27 @@ static int Abc_CommandFraigDress ( Abc_Frame_t * pAbc, int argc, cha static int Abc_CommandRecStart ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandRecStop ( Abc_Frame_t * pAbc, int argc, char ** argv ); -static int Abc_CommandRecAdd ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandRecPs ( Abc_Frame_t * pAbc, int argc, char ** argv ); +static int Abc_CommandRecAdd ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandRecUse ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandRecFilter ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandRecMerge ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandRecStart2 ( Abc_Frame_t * pAbc, int argc, char ** argv ); +static int Abc_CommandRecStop2 ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandRecPs2 ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandRecAdd2 ( Abc_Frame_t * pAbc, int argc, char ** argv ); -static int Abc_CommandRecStop2 ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandRecDump2 ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandRecMerge2 ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandRecFilter2 ( Abc_Frame_t * pAbc, int argc, char ** argv ); +static int Abc_CommandRecStart3 ( Abc_Frame_t * pAbc, int argc, char ** argv ); +static int Abc_CommandRecStop3 ( Abc_Frame_t * pAbc, int argc, char ** argv ); +static int Abc_CommandRecPs3 ( Abc_Frame_t * pAbc, int argc, char ** argv ); +static int Abc_CommandRecAdd3 ( Abc_Frame_t * pAbc, int argc, char ** argv ); +static int Abc_CommandRecDump3 ( Abc_Frame_t * pAbc, int argc, char ** argv ); +static int Abc_CommandRecMerge3 ( Abc_Frame_t * pAbc, int argc, char ** argv ); + static int Abc_CommandMap ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandAmap ( Abc_Frame_t * pAbc, int argc, char ** argv ); static int Abc_CommandUnmap ( Abc_Frame_t * pAbc, int argc, char ** argv ); @@ -622,6 +633,10 @@ void Abc_Init( Abc_Frame_t * pAbc ) Cmd_CommandAdd( pAbc, "Various", "npnload", Abc_CommandNpnLoad, 0 ); Cmd_CommandAdd( pAbc, "Various", "npnsave", Abc_CommandNpnSave, 0 ); + Cmd_CommandAdd( pAbc, "Various", "send_aig", Abc_CommandSendAig, 0 ); + Cmd_CommandAdd( pAbc, "Various", "send_status", Abc_CommandSendStatus, 0 ); + Cmd_CommandAdd( pAbc, "Various", "send_cex", Abc_CommandSendCex, 0 ); + Cmd_CommandAdd( pAbc, "New AIG", "istrash", Abc_CommandIStrash, 1 ); Cmd_CommandAdd( pAbc, "New AIG", "icut", Abc_CommandICut, 0 ); Cmd_CommandAdd( pAbc, "New AIG", "irw", Abc_CommandIRewrite, 1 ); @@ -653,16 +668,23 @@ void Abc_Init( Abc_Frame_t * pAbc ) Cmd_CommandAdd( pAbc, "Choicing", "rec_add", Abc_CommandRecAdd, 0 ); Cmd_CommandAdd( pAbc, "Choicing", "rec_ps", Abc_CommandRecPs, 0 ); Cmd_CommandAdd( pAbc, "Choicing", "rec_use", Abc_CommandRecUse, 1 ); - Cmd_CommandAdd( pAbc, "Choicing", "rec_filter", Abc_CommandRecFilter, 1 ); - Cmd_CommandAdd( pAbc, "Choicing", "rec_merge", Abc_CommandRecMerge, 1 ); - - Cmd_CommandAdd( pAbc, "Choicing", "rec_start2", Abc_CommandRecStart2, 0 ); - Cmd_CommandAdd( pAbc, "Choicing", "rec_stop2", Abc_CommandRecStop2, 0 ); - Cmd_CommandAdd( pAbc, "Choicing", "rec_add2", Abc_CommandRecAdd2, 0 ); - Cmd_CommandAdd( pAbc, "Choicing", "rec_ps2", Abc_CommandRecPs2, 0 ); - Cmd_CommandAdd( pAbc, "Choicing", "rec_dump2", Abc_CommandRecDump2, 1 ); - Cmd_CommandAdd( pAbc, "Choicing", "rec_filter2", Abc_CommandRecFilter2, 1 ); - Cmd_CommandAdd( pAbc, "Choicing", "rec_merge2", Abc_CommandRecMerge2, 1 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_filter", Abc_CommandRecFilter, 0 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_merge", Abc_CommandRecMerge, 0 ); + + Cmd_CommandAdd( pAbc, "Choicing", "rec_start2", Abc_CommandRecStart2, 0 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_stop2", Abc_CommandRecStop2, 0 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_ps2", Abc_CommandRecPs2, 0 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_add2", Abc_CommandRecAdd2, 0 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_dump2", Abc_CommandRecDump2, 1 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_filter2", Abc_CommandRecFilter2, 0 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_merge2", Abc_CommandRecMerge2, 0 ); + + Cmd_CommandAdd( pAbc, "Choicing", "rec_start3", Abc_CommandRecStart3, 0 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_stop3", Abc_CommandRecStop3, 0 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_ps3", Abc_CommandRecPs3, 0 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_add3", Abc_CommandRecAdd3, 0 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_dump3", Abc_CommandRecDump3, 0 ); + Cmd_CommandAdd( pAbc, "Choicing", "rec_merge3", Abc_CommandRecMerge3, 0 ); Cmd_CommandAdd( pAbc, "SC mapping", "map", Abc_CommandMap, 1 ); Cmd_CommandAdd( pAbc, "SC mapping", "amap", Abc_CommandAmap, 1 ); @@ -2628,10 +2650,10 @@ int Abc_CommandCollapse( Abc_Frame_t * pAbc, int argc, char ** argv ) pNtk = Abc_FrameReadNtk(pAbc); // set defaults - fVerbose = 1; + fVerbose = 0; fReorder = 1; fDualRail = 0; - fBddSizeMax = 50000000; + fBddSizeMax = ABC_INFINITY; Extra_UtilGetoptReset(); while ( ( c = Extra_UtilGetopt( argc, argv, "Brdvh" ) ) != EOF ) { @@ -4824,6 +4846,7 @@ usage: Abc_Print( -2, "\t 1: algebraic factoring applied to ISOP\n" ); Abc_Print( -2, "\t 2: bi-decomposition with cofactoring\n" ); Abc_Print( -2, "\t 3: disjoint-support decomposition with cofactoring\n" ); + Abc_Print( -2, "\t 4: updated disjoint-support decomposition with cofactoring\n" ); Abc_Print( -2, "\t-N <num> : the number of support variables (binary files only) [default = unused]\n" ); Abc_Print( -2, "\t-v : toggle verbose printout [default = %s]\n", fVerbose? "yes": "no" ); Abc_Print( -2, "\t-h : print the command usage\n"); @@ -4846,15 +4869,16 @@ usage: ***********************************************************************/ int Abc_CommandTestNpn( Abc_Frame_t * pAbc, int argc, char ** argv ) { - extern int Abc_NpnTest( char * pFileName, int NpnType, int nVarNum, int fDumpRes, int fVerbose ); + extern int Abc_NpnTest( char * pFileName, int NpnType, int nVarNum, int fDumpRes, int fBinary, int fVerbose ); char * pFileName; int c; int fVerbose = 0; int NpnType = 0; int nVarNum = -1; int fDumpRes = 0; + int fBinary = 0; Extra_UtilGetoptReset(); - while ( ( c = Extra_UtilGetopt( argc, argv, "ANdvh" ) ) != EOF ) + while ( ( c = Extra_UtilGetopt( argc, argv, "ANdbvh" ) ) != EOF ) { switch ( c ) { @@ -4883,6 +4907,9 @@ int Abc_CommandTestNpn( Abc_Frame_t * pAbc, int argc, char ** argv ) case 'd': fDumpRes ^= 1; break; + case 'b': + fBinary ^= 1; + break; case 'v': fVerbose ^= 1; break; @@ -4905,11 +4932,11 @@ int Abc_CommandTestNpn( Abc_Frame_t * pAbc, int argc, char ** argv ) // get the output file name pFileName = argv[globalUtilOptind]; // call the testbench - Abc_NpnTest( pFileName, NpnType, nVarNum, fDumpRes, fVerbose ); + Abc_NpnTest( pFileName, NpnType, nVarNum, fDumpRes, fBinary, fVerbose ); return 0; usage: - Abc_Print( -2, "usage: testnpn [-AN <num>] [-dvh] <file>\n" ); + Abc_Print( -2, "usage: testnpn [-AN <num>] [-dbvh] <file>\n" ); Abc_Print( -2, "\t testbench for computing (semi-)canonical forms\n" ); Abc_Print( -2, "\t of completely-specified Boolean functions up to 16 varibles\n" ); Abc_Print( -2, "\t-A <num> : semi-caninical form computation algorithm [default = %d]\n", NpnType ); @@ -4920,6 +4947,7 @@ usage: Abc_Print( -2, "\t 4: Jake's hybrid semi-canonical form (high-effort)\n" ); Abc_Print( -2, "\t-N <num> : the number of support variables (binary files only) [default = unused]\n" ); Abc_Print( -2, "\t-d : toggle dumping resulting functions into a file [default = %s]\n", fDumpRes? "yes": "no" ); + Abc_Print( -2, "\t-b : toggle dumping in binary format [default = %s]\n", fBinary? "yes": "no" ); Abc_Print( -2, "\t-v : toggle verbose printout [default = %s]\n", fVerbose? "yes": "no" ); Abc_Print( -2, "\t-h : print the command usage\n"); Abc_Print( -2, "\t<file> : a text file with truth tables in hexadecimal, listed one per line,\n"); @@ -11602,6 +11630,171 @@ usage: return 1; } + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_CommandSendAig( Abc_Frame_t * pAbc, int argc, char ** argv ) +{ + extern int Gia_ManToBridgeAbsNetlist( FILE * pFile, Gia_Man_t * p ); + int c, fAndSpace = 0; + Extra_UtilGetoptReset(); + while ( ( c = Extra_UtilGetopt( argc, argv, "a" ) ) != EOF ) + { + switch ( c ) + { + case 'a': + fAndSpace ^= 1; + break; + default: + goto usage; + } + } + if ( !Abc_FrameIsBridgeMode() ) + { + Abc_Print( -1, "The bridge mode is not available.\n" ); + return 1; + } + if ( fAndSpace ) + { + if ( pAbc->pGia == NULL ) + { + Abc_Print( -1, "There is no AIG in the &-space.\n" ); + return 1; + } + Gia_ManToBridgeAbsNetlist( stdout, pAbc->pGia ); + } + else + { + extern Aig_Man_t * Abc_NtkToDar( Abc_Ntk_t * pNtk, int fExors, int fRegisters ); + Aig_Man_t * pAig; + Gia_Man_t * pGia; + if ( pAbc->pNtkCur == NULL ) + { + Abc_Print( -1, "There is no network in the main-space.\n" ); + return 1; + } + if ( !Abc_NtkIsStrash(pAbc->pNtkCur) ) + { + Abc_Print( -1, "The main-space network is not an AIG.\n" ); + return 1; + } + pAig = Abc_NtkToDar( pAbc->pNtkCur, 0, 1 ); + pGia = Gia_ManFromAig( pAig ); + Aig_ManStop( pAig ); + Gia_ManToBridgeAbsNetlist( stdout, pGia ); + Gia_ManStop( pGia ); + } + return 0; + +usage: + Abc_Print( -2, "usage: send_aig -a\n" ); + Abc_Print( -2, "\t sends current AIG to the bridge\n" ); + Abc_Print( -2, "\t-a : toggle sending AIG from &-space [default = %s]\n", fAndSpace? "yes": "no" ); + Abc_Print( -2, "\t-h : print the command usage\n"); + return 1; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_CommandSendStatus( Abc_Frame_t * pAbc, int argc, char ** argv ) +{ + extern int Gia_ManToBridgeResult( FILE * pFile, int Result, Abc_Cex_t * pCex ); + int c; + Extra_UtilGetoptReset(); + while ( ( c = Extra_UtilGetopt( argc, argv, "" ) ) != EOF ) + { + switch ( c ) + { + case 'h': + goto usage; + default: + goto usage; + } + } + if ( !Abc_FrameIsBridgeMode() ) + { + Abc_Print( -1, "The bridge mode is not available.\n" ); + return 1; + } + if ( pAbc->Status == 0 && pAbc->pCex == NULL ) + { + Abc_Print( -1, "Status is \"sat\", but current CEX is not available.\n" ); + return 1; + } + Gia_ManToBridgeResult( stdout, pAbc->Status, pAbc->pCex ); + return 0; + +usage: + Abc_Print( -2, "usage: send_status\n" ); + Abc_Print( -2, "\t sends current status to the bridge\n" ); + Abc_Print( -2, "\t-h : print the command usage\n"); + return 1; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_CommandSendCex( Abc_Frame_t * pAbc, int argc, char ** argv ) +{ + extern void Gia_ManFromBridgeCex( FILE * pFile, Abc_Cex_t * pCex ); + int c; + Extra_UtilGetoptReset(); + while ( ( c = Extra_UtilGetopt( argc, argv, "" ) ) != EOF ) + { + switch ( c ) + { + case 'h': + goto usage; + default: + goto usage; + } + } + if ( !Abc_FrameIsBridgeMode() ) + { + Abc_Print( -1, "The bridge mode is not available.\n" ); + return 1; + } + if ( pAbc->pCex == NULL ) + { + Abc_Print( -1, "Current CEX is not available.\n" ); + return 1; + } + Gia_ManFromBridgeCex( stdout, pAbc->pCex ); + return 0; + +usage: + Abc_Print( -2, "usage: send_cex\n" ); + Abc_Print( -2, "\t sends current CEX to the bridge\n" ); + Abc_Print( -2, "\t-h : print the command usage\n"); + return 1; +} + /**Function************************************************************* @@ -12312,19 +12505,18 @@ usage: SeeAlso [] ***********************************************************************/ -int Abc_CommandRecAdd( Abc_Frame_t * pAbc, int argc, char ** argv ) +int Abc_CommandRecPs( Abc_Frame_t * pAbc, int argc, char ** argv ) { - Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc); - int c; - int fUseSOPB = 0; +// Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc); + int c, fPrintLib = 0; // set defaults Extra_UtilGetoptReset(); - while ( ( c = Extra_UtilGetopt( argc, argv, "gh" ) ) != EOF ) + while ( ( c = Extra_UtilGetopt( argc, argv, "ph" ) ) != EOF ) { switch ( c ) { - case 'g': - fUseSOPB = 1; + case 'p': + fPrintLib ^= 1; break; case 'h': goto usage; @@ -12332,22 +12524,17 @@ int Abc_CommandRecAdd( Abc_Frame_t * pAbc, int argc, char ** argv ) goto usage; } } - if ( !Abc_NtkIsStrash(pNtk) ) - { - Abc_Print( -1, "This command works for AIGs.\n" ); - return 0; - } if ( !Abc_NtkRecIsRunning() ) { - Abc_Print( -1, "This command works for AIGs after calling \"rec_start\".\n" ); + Abc_Print( -1, "This command works for AIGs only after calling \"rec_start\".\n" ); return 0; } - Abc_NtkRecAdd( pNtk, fUseSOPB); + Abc_NtkRecPs(fPrintLib); return 0; usage: - Abc_Print( -2, "usage: rec_add [-h]\n" ); - Abc_Print( -2, "\t adds subgraphs from the current network to the set\n" ); + Abc_Print( -2, "usage: rec_ps [-h]\n" ); + Abc_Print( -2, "\t prints statistics about the recorded AIG subgraphs\n" ); Abc_Print( -2, "\t-h : print the command usage\n"); return 1; } @@ -12363,18 +12550,19 @@ usage: SeeAlso [] ***********************************************************************/ -int Abc_CommandRecPs( Abc_Frame_t * pAbc, int argc, char ** argv ) +int Abc_CommandRecAdd( Abc_Frame_t * pAbc, int argc, char ** argv ) { -// Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc); - int c, fPrintLib = 0; + Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc); + int c; + int fUseSOPB = 0; // set defaults Extra_UtilGetoptReset(); - while ( ( c = Extra_UtilGetopt( argc, argv, "ph" ) ) != EOF ) + while ( ( c = Extra_UtilGetopt( argc, argv, "gh" ) ) != EOF ) { switch ( c ) { - case 'p': - fPrintLib ^= 1; + case 'g': + fUseSOPB = 1; break; case 'h': goto usage; @@ -12382,17 +12570,22 @@ int Abc_CommandRecPs( Abc_Frame_t * pAbc, int argc, char ** argv ) goto usage; } } + if ( !Abc_NtkIsStrash(pNtk) ) + { + Abc_Print( -1, "This command works for AIGs.\n" ); + return 0; + } if ( !Abc_NtkRecIsRunning() ) { - Abc_Print( -1, "This command works for AIGs only after calling \"rec_start\".\n" ); + Abc_Print( -1, "This command works for AIGs after calling \"rec_start\".\n" ); return 0; } - Abc_NtkRecPs(fPrintLib); + Abc_NtkRecAdd( pNtk, fUseSOPB); return 0; usage: - Abc_Print( -2, "usage: rec_ps [-h]\n" ); - Abc_Print( -2, "\t prints statistics about the recorded AIG subgraphs\n" ); + Abc_Print( -2, "usage: rec_add [-h]\n" ); + Abc_Print( -2, "\t adds subgraphs from the current network to the set\n" ); Abc_Print( -2, "\t-h : print the command usage\n"); return 1; } @@ -12728,19 +12921,18 @@ usage: SeeAlso [] ***********************************************************************/ -int Abc_CommandRecAdd2( Abc_Frame_t * pAbc, int argc, char ** argv ) +int Abc_CommandRecPs2( Abc_Frame_t * pAbc, int argc, char ** argv ) { - Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc); - int c; - int fUseSOPB = 0; +// Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc); + int c, fPrintLib = 0; // set defaults Extra_UtilGetoptReset(); - while ( ( c = Extra_UtilGetopt( argc, argv, "gh" ) ) != EOF ) + while ( ( c = Extra_UtilGetopt( argc, argv, "ph" ) ) != EOF ) { switch ( c ) { - case 'g': - fUseSOPB = 1; + case 'p': + fPrintLib ^= 1; break; case 'h': goto usage; @@ -12748,22 +12940,17 @@ int Abc_CommandRecAdd2( Abc_Frame_t * pAbc, int argc, char ** argv ) goto usage; } } - if ( !Abc_NtkIsStrash(pNtk) ) - { - Abc_Print( -1, "This command works for AIGs.\n" ); - return 0; - } if ( !Abc_NtkRecIsRunning2() ) { - Abc_Print( -1, "This command works for AIGs after calling \"rec_start2\".\n" ); + Abc_Print( -1, "This command works for AIGs only after calling \"rec_start2\".\n" ); return 0; } - Abc_NtkRecAdd2( pNtk, fUseSOPB); + Abc_NtkRecPs2(fPrintLib); return 0; usage: - Abc_Print( -2, "usage: rec_add2 [-h]\n" ); - Abc_Print( -2, "\t adds subgraphs from the current network to the set\n" ); + Abc_Print( -2, "usage: rec_ps2 [-h]\n" ); + Abc_Print( -2, "\t prints statistics about the recorded AIG subgraphs\n" ); Abc_Print( -2, "\t-h : print the command usage\n"); return 1; } @@ -12780,18 +12967,19 @@ usage: SeeAlso [] ***********************************************************************/ -int Abc_CommandRecPs2( Abc_Frame_t * pAbc, int argc, char ** argv ) +int Abc_CommandRecAdd2( Abc_Frame_t * pAbc, int argc, char ** argv ) { -// Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc); - int c, fPrintLib = 0; + Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc); + int c; + int fUseSOPB = 0; // set defaults Extra_UtilGetoptReset(); - while ( ( c = Extra_UtilGetopt( argc, argv, "ph" ) ) != EOF ) + while ( ( c = Extra_UtilGetopt( argc, argv, "gh" ) ) != EOF ) { switch ( c ) { - case 'p': - fPrintLib ^= 1; + case 'g': + fUseSOPB = 1; break; case 'h': goto usage; @@ -12799,17 +12987,22 @@ int Abc_CommandRecPs2( Abc_Frame_t * pAbc, int argc, char ** argv ) goto usage; } } + if ( !Abc_NtkIsStrash(pNtk) ) + { + Abc_Print( -1, "This command works for AIGs.\n" ); + return 0; + } if ( !Abc_NtkRecIsRunning2() ) { - Abc_Print( -1, "This command works for AIGs only after calling \"rec_start2\".\n" ); + Abc_Print( -1, "This command works for AIGs after calling \"rec_start2\".\n" ); return 0; } - Abc_NtkRecPs2(fPrintLib); + Abc_NtkRecAdd2( pNtk, fUseSOPB); return 0; usage: - Abc_Print( -2, "usage: rec_ps2 [-h]\n" ); - Abc_Print( -2, "\t prints statistics about the recorded AIG subgraphs\n" ); + Abc_Print( -2, "usage: rec_add2 [-h]\n" ); + Abc_Print( -2, "\t adds subgraphs from the current network to the set\n" ); Abc_Print( -2, "\t-h : print the command usage\n"); return 1; } @@ -13018,6 +13211,405 @@ usage: } + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_CommandRecStart3( Abc_Frame_t * pAbc, int argc, char ** argv ) +{ + char * FileName, * pTemp; + char ** pArgvNew; + int c, nArgcNew; + FILE * pFile; + Gia_Man_t * pGia = NULL; + int nVars = 6; + int nCuts = 32; + int fFuncOnly = 0; + int fVerbose = 0; + Extra_UtilGetoptReset(); + while ( ( c = Extra_UtilGetopt( argc, argv, "KCfvh" ) ) != EOF ) + { + switch ( c ) + { + case 'K': + if ( globalUtilOptind >= argc ) + { + Abc_Print( -1, "Command line switch \"-K\" should be followed by an integer.\n" ); + goto usage; + } + nVars = atoi(argv[globalUtilOptind]); + globalUtilOptind++; + if ( nVars < 1 ) + goto usage; + break; + case 'C': + if ( globalUtilOptind >= argc ) + { + Abc_Print( -1, "Command line switch \"-C\" should be followed by an integer.\n" ); + goto usage; + } + nCuts = atoi(argv[globalUtilOptind]); + globalUtilOptind++; + if ( nCuts < 1 ) + goto usage; + break; + case 'f': + fFuncOnly ^= 1; + break; + case 'v': + fVerbose ^= 1; + break; + case 'h': + goto usage; + default: + goto usage; + } + } + if ( !(nVars >= 3 && nVars <= 16) ) + { + Abc_Print( -1, "The range of allowed values is 3 <= K <= 16.\n" ); + return 0; + } + if ( Abc_NtkRecIsRunning3() ) + { + Abc_Print( -1, "The AIG subgraph recording is already started.\n" ); + return 0; + } + pArgvNew = argv + globalUtilOptind; + nArgcNew = argc - globalUtilOptind; + if ( nArgcNew != 1 ) + Abc_Print( 1, "File name is not given on the command line. Starting a new record.\n" ); + else + { + // get the input file name + FileName = pArgvNew[0]; + // fix the wrong symbol + for ( pTemp = FileName; *pTemp; pTemp++ ) + if ( *pTemp == '>' ) + *pTemp = '\\'; + if ( (pFile = fopen( FileName, "r" )) == NULL ) + { + Abc_Print( -1, "Cannot open input file \"%s\". ", FileName ); + if ( (FileName = Extra_FileGetSimilarName( FileName, ".aig", NULL, NULL, NULL, NULL )) ) + Abc_Print( 1, "Did you mean \"%s\"?", FileName ); + Abc_Print( 1, "\n" ); + return 1; + } + fclose( pFile ); + pGia = Gia_ReadAiger( FileName, 1, 0 ); + if ( pGia == NULL ) + { + Abc_Print( -1, "Reading AIGER has failed.\n" ); + return 0; + } + } + Abc_NtkRecStart3( pGia, nVars, nCuts, fFuncOnly, fVerbose ); + return 0; + +usage: + Abc_Print( -2, "usage: rec_start3 [-K num] [-C num] [-fvh] <file>\n" ); + Abc_Print( -2, "\t starts recording AIG subgraphs (should be called for\n" ); + Abc_Print( -2, "\t an empty network or after reading in a previous record)\n" ); + Abc_Print( -2, "\t-K num : the largest number of inputs [default = %d]\n", nVars ); + Abc_Print( -2, "\t-C num : the max number of cuts used at a node (0 < num < 2^12) [default = %d]\n", nCuts ); + Abc_Print( -2, "\t-f : toggles recording functions without AIG subgraphs [default = %s]\n", fFuncOnly? "yes": "no" ); + Abc_Print( -2, "\t-v : toggles additional verbose output [default = %s]\n", fVerbose? "yes": "no" ); + Abc_Print( -2, "\t-h : print the command usage\n"); + Abc_Print( -2, "\t<file> : AIGER file with the library\n"); + return 1; +} + + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_CommandRecStop3( Abc_Frame_t * pAbc, int argc, char ** argv ) +{ + int c; + Extra_UtilGetoptReset(); + while ( ( c = Extra_UtilGetopt( argc, argv, "dh" ) ) != EOF ) + { + switch ( c ) + { + case 'h': + goto usage; + default: + goto usage; + } + } + if ( !Abc_NtkRecIsRunning3() ) + { + Abc_Print( -1, "This command works only after calling \"rec_start3\".\n" ); + return 0; + } + Abc_NtkRecStop3(); + return 0; + +usage: + Abc_Print( -2, "usage: rec_stop3 [-h]\n" ); + Abc_Print( -2, "\t cleans the internal storage for AIG subgraphs\n" ); + Abc_Print( -2, "\t-h : print the command usage\n"); + return 1; +} + + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_CommandRecPs3( Abc_Frame_t * pAbc, int argc, char ** argv ) +{ + int c, fPrintLib = 0; + Extra_UtilGetoptReset(); + while ( ( c = Extra_UtilGetopt( argc, argv, "ph" ) ) != EOF ) + { + switch ( c ) + { + case 'p': + fPrintLib ^= 1; + break; + case 'h': + goto usage; + default: + goto usage; + } + } + if ( !Abc_NtkRecIsRunning3() ) + { + Abc_Print( -1, "This command works for AIGs only after calling \"rec_start2\".\n" ); + return 0; + } + Abc_NtkRecPs3(fPrintLib); + return 0; + +usage: + Abc_Print( -2, "usage: rec_ps3 [-h]\n" ); + Abc_Print( -2, "\t prints statistics about the recorded AIG subgraphs\n" ); + Abc_Print( -2, "\t-h : print the command usage\n"); + return 1; +} + + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_CommandRecAdd3( Abc_Frame_t * pAbc, int argc, char ** argv ) +{ + Abc_Ntk_t * pNtk = Abc_FrameReadNtk(pAbc); + int c; + int fUseSOPB = 0; + // set defaults + Extra_UtilGetoptReset(); + while ( ( c = Extra_UtilGetopt( argc, argv, "gh" ) ) != EOF ) + { + switch ( c ) + { + case 'g': + fUseSOPB = 1; + break; + case 'h': + goto usage; + default: + goto usage; + } + } + if ( !Abc_NtkIsStrash(pNtk) ) + { + Abc_Print( -1, "This command works for AIGs.\n" ); + return 0; + } + if ( !Abc_NtkRecIsRunning3() ) + { + Abc_Print( -1, "This command works for AIGs after calling \"rec_start2\".\n" ); + return 0; + } + Abc_NtkRecAdd3( pNtk, fUseSOPB ); + return 0; + +usage: + Abc_Print( -2, "usage: rec_add3 [-h]\n" ); + Abc_Print( -2, "\t adds subgraphs from the current network to the set\n" ); + Abc_Print( -2, "\t-h : print the command usage\n"); + return 1; +} + + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_CommandRecDump3( Abc_Frame_t * pAbc, int argc, char ** argv ) +{ + char * FileName; + char ** pArgvNew; + int nArgcNew; + Gia_Man_t * pGia; + int c; + + Extra_UtilGetoptReset(); + while ( ( c = Extra_UtilGetopt( argc, argv, "h" ) ) != EOF ) + { + switch ( c ) + { + case 'h': + goto usage; + default: + goto usage; + } + } + if ( !Abc_NtkRecIsRunning3() ) + { + Abc_Print( -1, "The AIG subgraph recording is not started.\n" ); + return 1; + } + + pGia = Abc_NtkRecGetGia3(); + pArgvNew = argv + globalUtilOptind; + nArgcNew = argc - globalUtilOptind; + if ( nArgcNew != 1 ) + { + Abc_Print( -1, "File name is not given on the command line.\n" ); + return 1; + } + else if( Gia_ManPoNum(pGia) == 0 ) + { + Abc_Print( 0, "No structure in the library.\n" ); + return 1; + } + else + { + // get the input file name + FileName = pArgvNew[0]; + Gia_WriteAiger( pGia, FileName, 0, 0 ); + } + return 0; + +usage: + Abc_Print( -2, "usage: rec_dump3 [-h] <file>\n" ); + Abc_Print( -2, "\t-h : print the command usage\n"); + Abc_Print( -2, "\t<file> : AIGER file to write the library\n"); + return 1; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_CommandRecMerge3( Abc_Frame_t * pAbc, int argc, char ** argv ) +{ + int c; + char * FileName, * pTemp; + char ** pArgvNew; + int nArgcNew; + FILE * pFile; + Gia_Man_t * pGia = NULL; + + // set defaults + Extra_UtilGetoptReset(); + while ( ( c = Extra_UtilGetopt( argc, argv, "dh" ) ) != EOF ) + { + switch ( c ) + { + case 'h': + goto usage; + default: + goto usage; + } + } + if ( !Abc_NtkRecIsRunning3() ) + { + Abc_Print( -1, "This command works for AIGs only after calling \"rec_start3\".\n" ); + return 0; + } + pArgvNew = argv + globalUtilOptind; + nArgcNew = argc - globalUtilOptind; + if ( nArgcNew != 1 ) + { + Abc_Print( -1, "File name is not given on the command line.\n" ); + return 1; + } + else + { + // get the input file name + FileName = pArgvNew[0]; + // fix the wrong symbol + for ( pTemp = FileName; *pTemp; pTemp++ ) + if ( *pTemp == '>' ) + *pTemp = '\\'; + if ( (pFile = fopen( FileName, "r" )) == NULL ) + { + Abc_Print( -1, "Cannot open input file \"%s\". ", FileName ); + if ( (FileName = Extra_FileGetSimilarName( FileName, ".aig", NULL, NULL, NULL, NULL )) ) + Abc_Print( 1, "Did you mean \"%s\"?", FileName ); + Abc_Print( 1, "\n" ); + return 1; + } + fclose( pFile ); + pGia = Gia_ReadAiger( FileName, 1, 0 ); + if ( pGia == NULL ) + { + Abc_Print( -1, "Reading AIGER has failed.\n" ); + return 0; + } + } + Abc_NtkRecLibMerge3(pGia); + Gia_ManStop( pGia ); + return 0; + +usage: + Abc_Print( -2, "usage: rec_merge3 [-h] <file>\n" ); + Abc_Print( -2, "\t merge libraries\n" ); + Abc_Print( -2, "\t-h : print the command usage\n"); + Abc_Print( -2, "\t<file> : AIGER file with the library\n"); + return 1; +} + + /**Function************************************************************* Synopsis [] @@ -13052,7 +13644,7 @@ int Abc_CommandMap( Abc_Frame_t * pAbc, int argc, char ** argv ) DelayMulti = 0; fAreaOnly = 0; fRecovery = 1; - fSweep = 1; + fSweep = 0; fSwitching = 0; fVerbose = 0; Extra_UtilGetoptReset(); @@ -14392,7 +14984,7 @@ usage: Abc_Print( -2, "\t-d : toggles deriving local AIGs using bi-decomposition [default = %s]\n", pPars->fBidec? "yes": "no" ); Abc_Print( -2, "\t-b : toggles the use of one special feature [default = %s]\n", pPars->fUseBat? "yes": "no" ); Abc_Print( -2, "\t-u : toggles the use of MUXes along with LUTs [default = %s]\n", fLutMux? "yes": "no" ); - Abc_Print( -2, "\t-g : toggles global delay optimization [default = %s]\n", pPars->fDelayOpt? "yes": "no" ); + Abc_Print( -2, "\t-g : toggles delay optimization by SOP balancing [default = %s]\n", pPars->fDelayOpt? "yes": "no" ); Abc_Print( -2, "\t-y : toggles delay optimization with recorded library [default = %s]\n", pPars->fUserRecLib? "yes": "no" ); Abc_Print( -2, "\t-o : toggles using buffers to decouple combinational outputs [default = %s]\n", pPars->fUseBuffs? "yes": "no" ); Abc_Print( -2, "\t-j : toggles enabling additional check [default = %s]\n", pPars->fEnableCheck07? "yes": "no" ); @@ -16004,7 +16596,7 @@ int Abc_CommandSeqSweep2( Abc_Frame_t * pAbc, int argc, char ** argv ) // set defaults Ssw_ManSetDefaultParams( pPars ); Extra_UtilGetoptReset(); - while ( ( c = Extra_UtilGetopt( argc, argv, "PQFCLSIVMNcmplkofdsevwh" ) ) != EOF ) + while ( ( c = Extra_UtilGetopt( argc, argv, "PQFCLSIVMNcmplkofdseqvwh" ) ) != EOF ) { switch ( c ) { @@ -16148,6 +16740,9 @@ int Abc_CommandSeqSweep2( Abc_Frame_t * pAbc, int argc, char ** argv ) case 'e': pPars->fEquivDump ^= 1; break; + case 'q': + pPars->fStopWhenGone ^= 1; + break; case 'v': pPars->fVerbose ^= 1; break; @@ -16214,7 +16809,7 @@ int Abc_CommandSeqSweep2( Abc_Frame_t * pAbc, int argc, char ** argv ) return 0; usage: - Abc_Print( -2, "usage: scorr [-PQFCLSIVMN <num>] [-cmplkodsevwh]\n" ); + Abc_Print( -2, "usage: scorr [-PQFCLSIVMN <num>] [-cmplkodseqvwh]\n" ); Abc_Print( -2, "\t performs sequential sweep using K-step induction\n" ); Abc_Print( -2, "\t-P num : max partition size (0 = no partitioning) [default = %d]\n", pPars->nPartSize ); Abc_Print( -2, "\t-Q num : partition overlap (0 = no overlap) [default = %d]\n", pPars->nOverSize ); @@ -16237,6 +16832,7 @@ usage: Abc_Print( -2, "\t-d : toggle dynamic addition of constraints [default = %s]\n", pPars->fDynamic? "yes": "no" ); Abc_Print( -2, "\t-s : toggle local simulation in the cone of influence [default = %s]\n", pPars->fLocalSim? "yes": "no" ); Abc_Print( -2, "\t-e : toggle dumping disproved internal equivalences [default = %s]\n", pPars->fEquivDump? "yes": "no" ); + Abc_Print( -2, "\t-q : toggle quitting when PO is not a constant candidate [default = %s]\n", pPars->fStopWhenGone? "yes": "no" ); Abc_Print( -2, "\t-w : toggle printout of flop equivalences [default = %s]\n", pPars->fFlopVerbose? "yes": "no" ); Abc_Print( -2, "\t-v : toggle verbose output [default = %s]\n", pPars->fVerbose? "yes": "no" ); Abc_Print( -2, "\t-h : print the command usage\n"); @@ -22697,7 +23293,12 @@ int Abc_CommandAbc9Put( Abc_Frame_t * pAbc, int argc, char ** argv ) Abc_Print( -1, "Empty network.\n" ); return 1; } - if ( Gia_ManHasDangling(pAbc->pGia) == 0 ) + if ( pAbc->pGia->pMapping ) + { + extern Abc_Ntk_t * Abc_NtkFromMappedGia( Gia_Man_t * p ); + pNtk = Abc_NtkFromMappedGia( pAbc->pGia ); + } + else if ( Gia_ManHasDangling(pAbc->pGia) == 0 ) { pMan = Gia_ManToAig( pAbc->pGia, 0 ); pNtk = Abc_NtkFromAigPhase( pMan ); @@ -25098,7 +25699,7 @@ int Abc_CommandAbc9Scorr( Abc_Frame_t * pAbc, int argc, char ** argv ) int c; Cec_ManCorSetDefaultParams( pPars ); Extra_UtilGetoptReset(); - while ( ( c = Extra_UtilGetopt( argc, argv, "FCPkrecwvh" ) ) != EOF ) + while ( ( c = Extra_UtilGetopt( argc, argv, "FCPkrecqwvh" ) ) != EOF ) { switch ( c ) { @@ -25147,6 +25748,9 @@ int Abc_CommandAbc9Scorr( Abc_Frame_t * pAbc, int argc, char ** argv ) case 'c': pPars->fUseCSat ^= 1; break; + case 'q': + pPars->fStopWhenGone ^= 1; + break; case 'w': pPars->fVerboseFlops ^= 1; break; @@ -25172,7 +25776,7 @@ int Abc_CommandAbc9Scorr( Abc_Frame_t * pAbc, int argc, char ** argv ) return 0; usage: - Abc_Print( -2, "usage: &scorr [-FCP num] [-krecwvh]\n" ); + Abc_Print( -2, "usage: &scorr [-FCP num] [-krecqwvh]\n" ); Abc_Print( -2, "\t performs signal correpondence computation\n" ); Abc_Print( -2, "\t-C num : the max number of conflicts at a node [default = %d]\n", pPars->nBTLimit ); Abc_Print( -2, "\t-F num : the number of timeframes in inductive case [default = %d]\n", pPars->nFrames ); @@ -25181,6 +25785,7 @@ usage: Abc_Print( -2, "\t-r : toggle using implication rings during refinement [default = %s]\n", pPars->fUseRings? "yes": "no" ); Abc_Print( -2, "\t-e : toggle using equivalences as choices [default = %s]\n", pPars->fMakeChoices? "yes": "no" ); Abc_Print( -2, "\t-c : toggle using circuit-based SAT solver [default = %s]\n", pPars->fUseCSat? "yes": "no" ); + Abc_Print( -2, "\t-q : toggle quitting when PO is not a constant candidate [default = %s]\n", pPars->fStopWhenGone? "yes": "no" ); Abc_Print( -2, "\t-w : toggle printing verbose info about equivalent flops [default = %s]\n", pPars->fVerboseFlops? "yes": "no" ); Abc_Print( -2, "\t-v : toggle printing verbose information [default = %s]\n", pPars->fVerbose? "yes": "no" ); Abc_Print( -2, "\t-h : print the command usage\n"); @@ -26210,20 +26815,18 @@ int Abc_CommandAbc9If( Abc_Frame_t * pAbc, int argc, char ** argv ) { char Buffer[200]; char LutSize[200]; + Gia_Man_t * pNew; If_Par_t Pars, * pPars = &Pars; int c; - extern void Gia_ManSetIfParsDefault( If_Par_t * pPars ); - extern int Gia_MappingIf( Gia_Man_t * p, If_Par_t * pPars ); // set defaults Gia_ManSetIfParsDefault( pPars ); -// if ( pAbc->pAbc8Lib == NULL ) -// { -// Abc_Print( -1, "LUT library is not given. Using default LUT library.\n" ); -// pAbc->pAbc8Lib = If_SetSimpleLutLib( 6 ); -// } -// pPars->pLutLib = pAbc->pAbc8Lib; + if ( pAbc->pLibLut == NULL ) + { + Abc_Print( -1, "LUT library is not given. Using default LUT library.\n" ); + pAbc->pLibLut = If_SetSimpleLutLib( 6 ); + } Extra_UtilGetoptReset(); - while ( ( c = Extra_UtilGetopt( argc, argv, "KCFADEqaflepmrsdbvh" ) ) != EOF ) + while ( ( c = Extra_UtilGetopt( argc, argv, "KCFAGDEWSqaflepmrsdbgyojikcvh" ) ) != EOF ) { switch ( c ) { @@ -26273,6 +26876,17 @@ int Abc_CommandAbc9If( Abc_Frame_t * pAbc, int argc, char ** argv ) if ( pPars->nAreaIters < 0 ) goto usage; break; + case 'G': + if ( globalUtilOptind >= argc ) + { + Abc_Print( -1, "Command line switch \"-G\" should be followed by a positive integer no less than 3.\n" ); + goto usage; + } + pPars->nGateSize = atoi(argv[globalUtilOptind]); + globalUtilOptind++; + if ( pPars->nGateSize < 2 ) + goto usage; + break; case 'D': if ( globalUtilOptind >= argc ) { @@ -26295,6 +26909,31 @@ int Abc_CommandAbc9If( Abc_Frame_t * pAbc, int argc, char ** argv ) if ( pPars->Epsilon < 0.0 || pPars->Epsilon > 1.0 ) goto usage; break; + case 'W': + if ( globalUtilOptind >= argc ) + { + Abc_Print( -1, "Command line switch \"-W\" should be followed by a floating point number.\n" ); + goto usage; + } + pPars->WireDelay = (float)atof(argv[globalUtilOptind]); + globalUtilOptind++; + if ( pPars->WireDelay < 0.0 ) + goto usage; + break; + case 'S': + if ( globalUtilOptind >= argc ) + { + Abc_Print( -1, "Command line switch \"-S\" should be followed by string.\n" ); + goto usage; + } + pPars->pLutStruct = argv[globalUtilOptind]; + globalUtilOptind++; + if ( strlen(pPars->pLutStruct) != 2 && strlen(pPars->pLutStruct) != 3 ) + { + Abc_Print( -1, "Command line switch \"-S\" should be followed by a 2- or 3-char string (e.g. \"44\" or \"555\").\n" ); + goto usage; + } + break; case 'q': pPars->fPreprocess ^= 1; break; @@ -26328,6 +26967,27 @@ int Abc_CommandAbc9If( Abc_Frame_t * pAbc, int argc, char ** argv ) case 'b': pPars->fUseBat ^= 1; break; + case 'g': + pPars->fDelayOpt ^= 1; + break; + case 'y': + pPars->fUserRecLib ^= 1; + break; + case 'o': + pPars->fUseBuffs ^= 1; + break; + case 'j': + pPars->fEnableCheck07 ^= 1; + break; + case 'i': + pPars->fEnableCheck08 ^= 1; + break; + case 'k': + pPars->fEnableCheck10 ^= 1; + break; + case 'c': + pPars->fEnableRealPos ^= 1; + break; case 'v': pPars->fVerbose ^= 1; break; @@ -26336,12 +26996,27 @@ int Abc_CommandAbc9If( Abc_Frame_t * pAbc, int argc, char ** argv ) goto usage; } } + if ( pAbc->pGia == NULL ) { - Abc_Print( -1, "Abc_CommandAbc9If(): There is no AIG to map.\n" ); + Abc_Print( -1, "Empty GIA network.\n" ); return 1; } + if ( pPars->nLutSize == -1 ) + { + if ( pPars->pLutLib == NULL ) + { + Abc_Print( -1, "The LUT library is not given.\n" ); + return 1; + } + // get LUT size from the library + pPars->nLutSize = pPars->pLutLib->LutMax; + // if variable pin delay, force truth table computation +// if ( pPars->pLutLib->fVarPinDelays ) +// pPars->fTruth = 1; + } + if ( pPars->nLutSize < 3 || pPars->nLutSize > IF_MAX_LUTSIZE ) { Abc_Print( -1, "Incorrect LUT size (%d).\n", pPars->nLutSize ); @@ -26355,9 +27030,10 @@ int Abc_CommandAbc9If( Abc_Frame_t * pAbc, int argc, char ** argv ) } // enable truth table computation if choices are selected - if ( (c = Gia_ManCountChoiceNodes( pAbc->pGia )) ) + if ( Gia_ManHasChoices(pAbc->pGia) ) { - Abc_Print( 0, "Performing LUT mapping with %d choices.\n", c ); + if ( !Abc_FrameReadFlag("silentmode") ) + Abc_Print( 0, "Performing LUT mapping with choices.\n" ); pPars->fExpRed = 0; } @@ -26371,12 +27047,86 @@ int Abc_CommandAbc9If( Abc_Frame_t * pAbc, int argc, char ** argv ) pPars->fCutMin = 1; } + if ( pPars->fEnableCheck07 + pPars->fEnableCheck08 + pPars->fEnableCheck10 + (pPars->pLutStruct != NULL) > 1 ) + { + Abc_Print( -1, "Only one additional check can be performed at the same time.\n" ); + return 1; + } + if ( pPars->fEnableCheck07 ) + { + if ( pPars->nLutSize < 6 || pPars->nLutSize > 7 ) + { + Abc_Print( -1, "This feature only works for {6,7}-LUTs.\n" ); + return 1; + } + pPars->pFuncCell = If_CutPerformCheck07; + pPars->fCutMin = 1; + } + if ( pPars->fEnableCheck08 ) + { + if ( pPars->nLutSize < 6 || pPars->nLutSize > 8 ) + { + Abc_Print( -1, "This feature only works for {6,7,8}-LUTs.\n" ); + return 1; + } + pPars->pFuncCell = If_CutPerformCheck08; + pPars->fCutMin = 1; + } + if ( pPars->fEnableCheck10 ) + { + if ( pPars->nLutSize < 6 || pPars->nLutSize > 10 ) + { + Abc_Print( -1, "This feature only works for {6,7,8,9,10}-LUTs.\n" ); + return 1; + } + pPars->pFuncCell = If_CutPerformCheck10; + pPars->fCutMin = 1; + } + if ( pPars->pLutStruct ) + { + if ( pPars->nLutSize < 6 || pPars->nLutSize > 16 ) + { + Abc_Print( -1, "This feature only works for [6;16]-LUTs.\n" ); + return 1; + } + pPars->pFuncCell = If_CutPerformCheck16; + pPars->fCutMin = 1; + } + // enable truth table computation if cut minimization is selected if ( pPars->fCutMin ) { pPars->fTruth = 1; pPars->fExpRed = 0; } + // modify the subgraph recording + if ( pPars->fUserRecLib ) + { + pPars->fTruth = 1; + pPars->fCutMin = 1; + pPars->fExpRed = 0; + pPars->fUsePerm = 1; + pPars->pLutLib = NULL; + } + // modify for global delay optimization + if ( pPars->fDelayOpt ) + { + pPars->fTruth = 1; + pPars->fCutMin = 1; + pPars->fExpRed = 0; + pPars->fUsePerm = 1; + pPars->pLutLib = NULL; + } + // modify for global delay optimization + if ( pPars->nGateSize > 0 ) + { + pPars->fTruth = 1; + pPars->fCutMin = 1; + pPars->fExpRed = 0; + pPars->fUsePerm = 1; + pPars->pLutLib = NULL; + pPars->nLutSize = pPars->nGateSize; + } // complain if truth tables are requested but the cut size is too large if ( pPars->fTruth && pPars->nLutSize > IF_MAX_FUNC_LUTSIZE ) @@ -26385,11 +27135,14 @@ int Abc_CommandAbc9If( Abc_Frame_t * pAbc, int argc, char ** argv ) return 1; } - if ( !Gia_MappingIf( pAbc->pGia, pPars ) ) + // perform mapping + pNew = Gia_ManPerformMapping( pAbc->pGia, pPars ); + if ( pNew == NULL ) { Abc_Print( -1, "Abc_CommandAbc9If(): Mapping of the AIG has failed.\n" ); return 1; } + Abc_CommandUpdate9( pAbc, pNew ); return 0; usage: @@ -26401,14 +27154,17 @@ usage: sprintf( LutSize, "library" ); else sprintf( LutSize, "%d", pPars->nLutSize ); - Abc_Print( -2, "usage: &if [-KCFA num] [-DE float] [-qarlepmdbvh]\n" ); + Abc_Print( -2, "usage: &if [-KCFAG num] [-DEW float] [-S str] [-qarlepmsdbgyojikcvh]\n" ); Abc_Print( -2, "\t performs FPGA technology mapping of the network\n" ); Abc_Print( -2, "\t-K num : the number of LUT inputs (2 < num < %d) [default = %s]\n", IF_MAX_LUTSIZE+1, LutSize ); Abc_Print( -2, "\t-C num : the max number of priority cuts (0 < num < 2^12) [default = %d]\n", pPars->nCutsMax ); Abc_Print( -2, "\t-F num : the number of area flow recovery iterations (num >= 0) [default = %d]\n", pPars->nFlowIters ); Abc_Print( -2, "\t-A num : the number of exact area recovery iterations (num >= 0) [default = %d]\n", pPars->nAreaIters ); + Abc_Print( -2, "\t-G num : the max AND/OR gate size for mapping (0 = unused) [default = %d]\n", pPars->nGateSize ); Abc_Print( -2, "\t-D float : sets the delay constraint for the mapping [default = %s]\n", Buffer ); Abc_Print( -2, "\t-E float : sets epsilon used for tie-breaking [default = %f]\n", pPars->Epsilon ); + Abc_Print( -2, "\t-W float : sets wire delay between adjects LUTs [default = %f]\n", pPars->WireDelay ); + Abc_Print( -2, "\t-S str : string representing the LUT structure [default = %s]\n", pPars->pLutStruct ? pPars->pLutStruct : "not used" ); Abc_Print( -2, "\t-q : toggles preprocessing using several starting points [default = %s]\n", pPars->fPreprocess? "yes": "no" ); Abc_Print( -2, "\t-a : toggles area-oriented mapping [default = %s]\n", pPars->fArea? "yes": "no" ); // Abc_Print( -2, "\t-f : toggles one fancy feature [default = %s]\n", pPars->fFancy? "yes": "no" ); @@ -26417,9 +27173,16 @@ usage: Abc_Print( -2, "\t-e : uses edge-based cut selection heuristics [default = %s]\n", pPars->fEdge? "yes": "no" ); Abc_Print( -2, "\t-p : uses power-aware cut selection heuristics [default = %s]\n", pPars->fPower? "yes": "no" ); Abc_Print( -2, "\t-m : enables cut minimization by removing vacuous variables [default = %s]\n", pPars->fCutMin? "yes": "no" ); -// Abc_Print( -2, "\t-s : toggles sequential mapping [default = %s]\n", pPars->fSeqMap? "yes": "no" ); + Abc_Print( -2, "\t-s : toggles sequential mapping [default = %s]\n", pPars->fSeqMap? "yes": "no" ); Abc_Print( -2, "\t-d : toggles deriving local AIGs using bi-decomposition [default = %s]\n", pPars->fBidec? "yes": "no" ); Abc_Print( -2, "\t-b : toggles the use of one special feature [default = %s]\n", pPars->fUseBat? "yes": "no" ); + Abc_Print( -2, "\t-g : toggles delay optimization by SOP balancing [default = %s]\n", pPars->fDelayOpt? "yes": "no" ); + Abc_Print( -2, "\t-y : toggles delay optimization with recorded library [default = %s]\n", pPars->fUserRecLib? "yes": "no" ); + Abc_Print( -2, "\t-o : toggles using buffers to decouple combinational outputs [default = %s]\n", pPars->fUseBuffs? "yes": "no" ); + Abc_Print( -2, "\t-j : toggles enabling additional check [default = %s]\n", pPars->fEnableCheck07? "yes": "no" ); + Abc_Print( -2, "\t-i : toggles enabling additional check [default = %s]\n", pPars->fEnableCheck08? "yes": "no" ); + Abc_Print( -2, "\t-k : toggles enabling additional check [default = %s]\n", pPars->fEnableCheck10? "yes": "no" ); + Abc_Print( -2, "\t-c : toggles enabling additional feature [default = %s]\n", pPars->fEnableRealPos? "yes": "no" ); Abc_Print( -2, "\t-v : toggles verbose output [default = %s]\n", pPars->fVerbose? "yes": "no" ); Abc_Print( -2, "\t-h : prints the command usage\n"); return 1; diff --git a/src/base/abci/abcDar.c b/src/base/abci/abcDar.c index 6072a9db..dbb75f59 100644 --- a/src/base/abci/abcDar.c +++ b/src/base/abci/abcDar.c @@ -620,6 +620,150 @@ Abc_Ntk_t * Abc_NtkFromAigPhase( Aig_Man_t * pMan ) return pNtkNew; } + + +/**Function************************************************************* + + Synopsis [Creates local function of the node.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Hop_Obj_t * Abc_ObjHopFromGia_rec( Hop_Man_t * pHopMan, Gia_Man_t * p, int Id, Vec_Ptr_t * vCopies ) +{ + Gia_Obj_t * pObj; + Hop_Obj_t * gFunc, * gFunc0, * gFunc1; + if ( Gia_ObjIsTravIdCurrentId(p, Id) ) + return (Hop_Obj_t *)Vec_PtrEntry( vCopies, Id ); + Gia_ObjSetTravIdCurrentId(p, Id); + pObj = Gia_ManObj(p, Id); + assert( Gia_ObjIsAnd(pObj) ); + // compute the functions of the children + gFunc0 = Abc_ObjHopFromGia_rec( pHopMan, p, Gia_ObjFaninId0(pObj, Id), vCopies ); + gFunc1 = Abc_ObjHopFromGia_rec( pHopMan, p, Gia_ObjFaninId1(pObj, Id), vCopies ); + // get the function of the cut + gFunc = Hop_And( pHopMan, Hop_NotCond(gFunc0, Gia_ObjFaninC0(pObj)), Hop_NotCond(gFunc1, Gia_ObjFaninC1(pObj)) ); + Vec_PtrWriteEntry( vCopies, Id, gFunc ); + return gFunc; +} +Hop_Obj_t * Abc_ObjHopFromGia( Hop_Man_t * pHopMan, Gia_Man_t * p, int GiaId, Vec_Ptr_t * vCopies ) +{ + int k, iFan; + assert( Gia_ObjIsLut(p, GiaId) ); + assert( Gia_ObjLutSize(p, GiaId) > 0 ); + Gia_ManIncrementTravId( p ); + Gia_LutForEachFanin( p, GiaId, iFan, k ) + { + Gia_ObjSetTravIdCurrentId(p, iFan); + Vec_PtrWriteEntry( vCopies, iFan, Hop_IthVar(pHopMan, k) ); + } + return Abc_ObjHopFromGia_rec( pHopMan, p, GiaId, vCopies ); +} + +/**Function************************************************************* + + Synopsis [Converts the network from the mapped GIA manager.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Abc_Ntk_t * Abc_NtkFromMappedGia( Gia_Man_t * p ) +{ + int fVerbose = 0; + int fDuplicate = 0; + Abc_Ntk_t * pNtkNew; + Abc_Obj_t * pObjNew, * pObjNewLi, * pObjNewLo, * pConst0 = NULL; + Gia_Obj_t * pObj, * pObjLi, * pObjLo; + Vec_Ptr_t * vReflect; + int i, k, iFan, nDupGates; + assert( p->pMapping != NULL ); + pNtkNew = Abc_NtkAlloc( ABC_NTK_LOGIC, ABC_FUNC_AIG, 1 ); + // duplicate the name and the spec + pNtkNew->pName = Extra_UtilStrsav(p->pName); + pNtkNew->pSpec = Extra_UtilStrsav(p->pSpec); + Gia_ManFillValue( p ); + // create constant + pConst0 = Abc_NtkCreateNodeConst0( pNtkNew ); + Gia_ManConst0(p)->Value = Abc_ObjId(pConst0); + // create PIs + Gia_ManForEachPi( p, pObj, i ) + pObj->Value = Abc_ObjId( Abc_NtkCreatePi( pNtkNew ) ); + // create POs + Gia_ManForEachPo( p, pObj, i ) + pObj->Value = Abc_ObjId( Abc_NtkCreatePo( pNtkNew ) ); + // create as many latches as there are registers in the manager + Gia_ManForEachRiRo( p, pObjLi, pObjLo, i ) + { + pObjNew = Abc_NtkCreateLatch( pNtkNew ); + pObjNewLi = Abc_NtkCreateBi( pNtkNew ); + pObjNewLo = Abc_NtkCreateBo( pNtkNew ); + Abc_ObjAddFanin( pObjNew, pObjNewLi ); + Abc_ObjAddFanin( pObjNewLo, pObjNew ); + pObjLi->Value = Abc_ObjId( pObjNewLi ); + pObjLo->Value = Abc_ObjId( pObjNewLo ); + Abc_LatchSetInit0( pObjNew ); + } + // rebuild the AIG + vReflect = Vec_PtrStart( Gia_ManObjNum(p) ); + Gia_ManForEachLut( p, i ) + { + pObj = Gia_ManObj(p, i); + assert( pObj->Value == ~0 ); + if ( Gia_ObjLutSize(p, i) == 0 ) + { + pObj->Value = Abc_ObjId(pConst0); + continue; + } + pObjNew = Abc_NtkCreateNode( pNtkNew ); + Gia_LutForEachFanin( p, i, iFan, k ) + Abc_ObjAddFanin( pObjNew, Abc_NtkObj(pNtkNew, Gia_ObjValue(Gia_ManObj(p, iFan))) ); + pObjNew->pData = Abc_ObjHopFromGia( pNtkNew->pManFunc, p, i, vReflect ); + pObj->Value = Abc_ObjId( pObjNew ); + } + Vec_PtrFree( vReflect ); + // connect the PO nodes + Gia_ManForEachCo( p, pObj, i ) + { + pObjNew = Abc_NtkObj( pNtkNew, Gia_ObjValue(Gia_ObjFanin0(pObj)) ); + Abc_ObjAddFanin( Abc_NtkCo(pNtkNew, i), Abc_ObjNotCond( pObjNew, Gia_ObjFaninC0(pObj) ) ); + } + // create names + Abc_NtkAddDummyPiNames( pNtkNew ); + Abc_NtkAddDummyPoNames( pNtkNew ); + Abc_NtkAddDummyBoxNames( pNtkNew ); + + // decouple the PO driver nodes to reduce the number of levels + nDupGates = Abc_NtkLogicMakeSimpleCos( pNtkNew, fDuplicate ); + if ( fVerbose && nDupGates && !Abc_FrameReadFlag("silentmode") ) + { + if ( !fDuplicate ) + printf( "Added %d buffers/inverters to decouple the CO drivers.\n", nDupGates ); + else + printf( "Duplicated %d gates to decouple the CO drivers.\n", nDupGates ); + } + // remove const node if it is not used + if ( Abc_ObjFanoutNum(pConst0) == 0 ) + Abc_NtkDeleteObj( pConst0 ); + + assert( Gia_ManPiNum(p) == Abc_NtkPiNum(pNtkNew) ); + assert( Gia_ManPoNum(p) == Abc_NtkPoNum(pNtkNew) ); + assert( Gia_ManRegNum(p) == Abc_NtkLatchNum(pNtkNew) ); + + // check the resulting AIG + if ( !Abc_NtkCheck( pNtkNew ) ) + Abc_Print( 1, "Abc_NtkFromMappedGia(): Network check has failed.\n" ); + return pNtkNew; +} + + /**Function************************************************************* Synopsis [Converts the network from the AIG manager into ABC.] diff --git a/src/base/abci/abcDec.c b/src/base/abci/abcDec.c index 309c6a50..f5dce96e 100644 --- a/src/base/abci/abcDec.c +++ b/src/base/abci/abcDec.c @@ -353,10 +353,10 @@ void Abc_TruthStoreRead( char * pFileName, Abc_TtStore_t * p ) SeeAlso [] ***********************************************************************/ -void Abc_TtStoreWrite( char * pFileName, Abc_TtStore_t * p ) +void Abc_TtStoreWrite( char * pFileName, Abc_TtStore_t * p, int fBinary ) { FILE * pFile; - int i; + int i, nBytes = 8 * Abc_Truth6WordNum( p->nVars ); pFile = fopen( pFileName, "wb" ); if ( pFile == NULL ) { @@ -365,8 +365,10 @@ void Abc_TtStoreWrite( char * pFileName, Abc_TtStore_t * p ) } for ( i = 0; i < p->nFuncs; i++ ) { - Abc_TruthWriteHex( pFile, p->pFuncs[i], p->nVars ); - fprintf( pFile, "\n" ); + if ( fBinary ) + fwrite( p->pFuncs[i], nBytes, 1, pFile ); + else + Abc_TruthWriteHex( pFile, p->pFuncs[i], p->nVars ), fprintf( pFile, "\n" ); } fclose( pFile ); } @@ -441,7 +443,7 @@ void Abc_TtStoreTest( char * pFileName ) return; // write into another file - Abc_TtStoreWrite( pFileOutput, p ); + Abc_TtStoreWrite( pFileOutput, p, 0 ); // delete data-structure Abc_TtStoreFree( p, -1 ); @@ -471,6 +473,8 @@ void Abc_TruthDecPerform( Abc_TtStore_t * p, int DecType, int fVerbose ) pAlgoName = "bi-decomp"; else if ( DecType == 3 ) pAlgoName = "DSD"; + else if ( DecType == 4 ) + pAlgoName = "fast DSD"; if ( pAlgoName ) printf( "Applying %-10s to %8d func%s of %2d vars... ", @@ -535,6 +539,24 @@ void Abc_TruthDecPerform( Abc_TtStore_t * p, int DecType, int fVerbose ) Kit_DsdNtkFree( pNtk ); } } + else if ( DecType == 4 ) + { + extern void Dau_DsdTestOne( word t, int i ); + if ( p->nVars != 6 ) + { + printf( "Currently only works for 6 variables.\n" ); + return; + } + // perform disjoint-support decomposition and count AIG nodes + // (non-DSD blocks are decomposed into 2:1 MUXes, each counting as 3 AIG nodes) + assert( p->nVars == 6 ); + for ( i = 0; i < p->nFuncs; i++ ) + { + if ( fVerbose ) + printf( "%7d : ", i ); + Dau_DsdTestOne( *p->pFuncs[i], i ); + } + } else assert( 0 ); printf( "AIG nodes =%9d ", nNodes ); @@ -585,7 +607,7 @@ int Abc_DecTest( char * pFileName, int DecType, int nVarNum, int fVerbose ) printf( "Using truth tables from file \"%s\"...\n", pFileName ); if ( DecType == 0 ) { if ( nVarNum < 0 ) Abc_TtStoreTest( pFileName ); } - else if ( DecType >= 1 && DecType <= 3 ) + else if ( DecType >= 1 && DecType <= 4 ) Abc_TruthDecTest( pFileName, DecType, nVarNum, fVerbose ); else printf( "Unknown decomposition type value (%d).\n", DecType ); diff --git a/src/base/abci/abcIf.c b/src/base/abci/abcIf.c index 362f0e46..76171eee 100644 --- a/src/base/abci/abcIf.c +++ b/src/base/abci/abcIf.c @@ -228,7 +228,6 @@ If_Man_t * Abc_NtkToIf( Abc_Ntk_t * pNtk, If_Par_t * pPars ) // set up the choice node if ( Abc_AigNodeIsChoice( pNode ) ) { - pIfMan->nChoices++; for ( pPrev = pNode, pFanin = (Abc_Obj_t *)pNode->pData; pFanin; pPrev = pFanin, pFanin = (Abc_Obj_t *)pFanin->pData ) If_ObjSetChoice( (If_Obj_t *)pPrev->pCopy, (If_Obj_t *)pFanin->pCopy ); If_ManCreateChoice( pIfMan, (If_Obj_t *)pNode->pCopy ); @@ -495,10 +494,13 @@ Abc_Obj_t * Abc_NodeFromIf_rec( Abc_Ntk_t * pNtkNew, If_Man_t * pIfMan, If_Obj_t { extern Hop_Obj_t * Abc_RecToHop( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut, If_Obj_t * pIfObj ); extern Hop_Obj_t * Abc_RecToHop2( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut, If_Obj_t * pIfObj ); - if(Abc_NtkRecIsRunning()) - pNodeNew->pData = Abc_RecToHop( (Hop_Man_t *)pNtkNew->pManFunc, pIfMan, pCutBest, pIfObj); - else + extern Hop_Obj_t * Abc_RecToHop3( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut, If_Obj_t * pIfObj ); + if(Abc_NtkRecIsRunning3()) + pNodeNew->pData = Abc_RecToHop3( (Hop_Man_t *)pNtkNew->pManFunc, pIfMan, pCutBest, pIfObj); + else if(Abc_NtkRecIsRunning2()) pNodeNew->pData = Abc_RecToHop2( (Hop_Man_t *)pNtkNew->pManFunc, pIfMan, pCutBest, pIfObj); + else + pNodeNew->pData = Abc_RecToHop( (Hop_Man_t *)pNtkNew->pManFunc, pIfMan, pCutBest, pIfObj); } else diff --git a/src/base/abci/abcNpn.c b/src/base/abci/abcNpn.c index 9494cba2..0e3f41f9 100644 --- a/src/base/abci/abcNpn.c +++ b/src/base/abci/abcNpn.c @@ -49,7 +49,7 @@ struct Abc_TtStore_t_ extern Abc_TtStore_t * Abc_TtStoreLoad( char * pFileName, int nVarNum ); extern void Abc_TtStoreFree( Abc_TtStore_t * p, int nVarNum ); -extern void Abc_TtStoreWrite( char * pFileName, Abc_TtStore_t * p ); +extern void Abc_TtStoreWrite( char * pFileName, Abc_TtStore_t * p, int fBinary ); //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// @@ -276,7 +276,7 @@ void Abc_TruthNpnPerform( Abc_TtStore_t * p, int NpnType, int fVerbose ) SeeAlso [] ***********************************************************************/ -void Abc_TruthNpnTest( char * pFileName, int NpnType, int nVarNum, int fDumpRes, int fVerbose ) +void Abc_TruthNpnTest( char * pFileName, int NpnType, int nVarNum, int fDumpRes, int fBinary, int fVerbose ) { Abc_TtStore_t * p; char * pFileNameOut; @@ -292,8 +292,11 @@ void Abc_TruthNpnTest( char * pFileName, int NpnType, int nVarNum, int fDumpRes, // write the result if ( fDumpRes ) { - pFileNameOut = Extra_FileNameGenericAppend( pFileName, "_out.txt" ); - Abc_TtStoreWrite( pFileNameOut, p ); + if ( fBinary ) + pFileNameOut = Extra_FileNameGenericAppend( pFileName, "_out.tt" ); + else + pFileNameOut = Extra_FileNameGenericAppend( pFileName, "_out.txt" ); + Abc_TtStoreWrite( pFileNameOut, p, fBinary ); if ( fVerbose ) printf( "The resulting functions are written into file \"%s\".\n", pFileNameOut ); } @@ -315,12 +318,12 @@ void Abc_TruthNpnTest( char * pFileName, int NpnType, int nVarNum, int fDumpRes, SeeAlso [] ***********************************************************************/ -int Abc_NpnTest( char * pFileName, int NpnType, int nVarNum, int fDumpRes, int fVerbose ) +int Abc_NpnTest( char * pFileName, int NpnType, int nVarNum, int fDumpRes, int fBinary, int fVerbose ) { if ( fVerbose ) printf( "Using truth tables from file \"%s\"...\n", pFileName ); if ( NpnType >= 0 && NpnType <= 4 ) - Abc_TruthNpnTest( pFileName, NpnType, nVarNum, fDumpRes, fVerbose ); + Abc_TruthNpnTest( pFileName, NpnType, nVarNum, fDumpRes, fBinary, fVerbose ); else printf( "Unknown canonical form value (%d).\n", NpnType ); fflush( stdout ); diff --git a/src/base/abci/abcRec2.c b/src/base/abci/abcRec2.c index 12e444e8..0eb843bf 100644 --- a/src/base/abci/abcRec2.c +++ b/src/base/abci/abcRec2.c @@ -86,6 +86,7 @@ struct Abc_ManRec_t_2 Vec_Ptr_t * vNodes; // the temporary nodes Vec_Ptr_t * vTtTemps; // the truth tables for the internal nodes of the cut Vec_Ptr_t * vLabels; // temporary storage for AIG node labels + Vec_Int_t * vLabelsInt; // temporary storage for AIG node labels Vec_Int_t * vUselessPos; // statistics int nTried; // the number of cuts tried @@ -1144,6 +1145,7 @@ p->timeInsert += clock() - timeInsert; p->vNodes = Vec_PtrAlloc( 100 ); p->vTtTemps = Vec_PtrAllocSimInfo( 1024, p->nWords ); p->vLabels = Vec_PtrStart( 1000 ); + p->vLabelsInt = Vec_IntStart( 1000 ); p->timeTotal += clock() - clkTotal; @@ -2065,6 +2067,105 @@ Hop_Obj_t * Abc_RecToHop2( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut, /**Function************************************************************* + Synopsis [Derive the final network from the library.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_RecToGia2( Gia_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut, If_Obj_t * pIfObj, Vec_Int_t * vLeaves, int fHash ) +{ + Rec_Obj_t2 * pCandMin; + int pHopObj, pFan0, pFan1; + Gia_Obj_t* pGiaObj, *pGiaTemp; + Gia_Man_t * pAig = s_pMan->pGia; + int nLeaves, i;// DelayMin = ABC_INFINITY , Delay = -ABC_INFINITY + unsigned uCanonPhase; + int nVars = s_pMan->nVars; + char pCanonPerm[16]; + unsigned *pInOut = s_pMan->pTemp1; + unsigned *pTemp = s_pMan->pTemp2; + int time = clock(); + int fCompl; + int * pCompl = &fCompl; + nLeaves = If_CutLeaveNum(pCut); +// if (nLeaves < 3) +// return Abc_NodeTruthToHop(pMan, pIfMan, pCut); + Kit_TruthCopy(pInOut, If_CutTruth(pCut), pCut->nLimit); + //special cases when cut-minimization return 2, that means there is only one leaf in the cut. + if ((Kit_TruthIsConst0(pInOut, nLeaves) && pCut->fCompl == 0) || (Kit_TruthIsConst1(pInOut, nLeaves) && pCut->fCompl == 1)) + return 0; + if ((Kit_TruthIsConst0(pInOut, nLeaves) && pCut->fCompl == 1) || (Kit_TruthIsConst1(pInOut, nLeaves) && pCut->fCompl == 0)) + return 1; + if (Kit_TruthSupport(pInOut, nLeaves) != Kit_BitMask(nLeaves)) + { + for (i = 0; i < nLeaves; i++) + if(Kit_TruthVarInSupport( pInOut, nLeaves, i )) + return Abc_LitNotCond( Vec_IntEntry(vLeaves, i), (pCut->fCompl ^ ((*pInOut & 0x01) > 0)) ); + } + + for (i = 0; i < nLeaves; i++) + pCanonPerm[i] = i; + uCanonPhase = Kit_TruthSemiCanonicize_new(pInOut, pTemp, nLeaves, pCanonPerm); + If_CutTruthStretch(pInOut, nLeaves, nVars); + pCandMin = Abc_NtkRecLookUpBest(pIfMan, pCut, pInOut, pCanonPerm, pCompl,NULL); + + // get the top-most GIA node + pGiaObj = Abc_NtkRecGetObj( Rec_ObjID(s_pMan, pCandMin) ); + assert( Gia_ObjIsAnd(pGiaObj) || Gia_ObjIsPi(pAig, pGiaObj) ); + // collect internal nodes into pAig->vTtNodes + if ( pAig->vTtNodes == NULL ) + pAig->vTtNodes = Vec_IntAlloc( 256 ); + Gia_ObjCollectInternal( pAig, pGiaObj ); + // collect HOP nodes for leaves + Vec_IntClear( s_pMan->vLabelsInt ); + for (i = 0; i < nLeaves; i++) + { + pHopObj = Vec_IntEntry(vLeaves, pCanonPerm[i]); + pHopObj = Abc_LitNotCond(pHopObj, ((uCanonPhase & (1 << i)) > 0)); + Vec_IntPush(s_pMan->vLabelsInt, pHopObj); + } + // compute HOP nodes for internal nodes + Gia_ManForEachObjVec( pAig->vTtNodes, pAig, pGiaTemp, i ) + { + pGiaTemp->fMark0 = 0; // unmark node marked by Gia_ObjCollectInternal() + + if ( Gia_ObjIsAnd(Gia_ObjFanin0(pGiaTemp)) ) + pFan0 = Vec_IntEntry(s_pMan->vLabelsInt, Gia_ObjNum(pAig, Gia_ObjFanin0(pGiaTemp)) + nLeaves); + else + pFan0 = Vec_IntEntry(s_pMan->vLabelsInt, Gia_ObjCioId(Gia_ObjFanin0(pGiaTemp))); + pFan0 = Abc_LitNotCond(pFan0, Gia_ObjFaninC0(pGiaTemp)); + + if ( Gia_ObjIsAnd(Gia_ObjFanin1(pGiaTemp)) ) + pFan1 = Vec_IntEntry(s_pMan->vLabelsInt, Gia_ObjNum(pAig, Gia_ObjFanin1(pGiaTemp)) + nLeaves); + else + pFan1 = Vec_IntEntry(s_pMan->vLabelsInt, Gia_ObjCioId(Gia_ObjFanin1(pGiaTemp))); + pFan1 = Abc_LitNotCond(pFan1, Gia_ObjFaninC1(pGiaTemp)); + + if ( fHash ) + pHopObj = Gia_ManHashAnd(pMan, pFan0, pFan1); + else + pHopObj = Gia_ManAppendAnd(pMan, pFan0, pFan1); + Vec_IntPush(s_pMan->vLabelsInt, pHopObj); + } + // get the final result + if ( Gia_ObjIsAnd(pGiaObj) ) + pHopObj = Vec_IntEntry(s_pMan->vLabelsInt, Gia_ObjNum(pAig, pGiaObj) + nLeaves); + else if ( Gia_ObjIsPi(pAig, pGiaObj) ) + pHopObj = Vec_IntEntry(s_pMan->vLabelsInt, Gia_ObjCioId(pGiaObj)); + else assert( 0 ); + + s_pMan->timeIfDerive += clock() - time; + s_pMan->timeIfTotal += clock() - time; + // complement the result if needed + return Abc_LitNotCond(pHopObj, (pCut->fCompl)^(((uCanonPhase & (1 << nLeaves)) > 0)) ^ fCompl); +} + +/**Function************************************************************* + Synopsis [Returns the given record.] Description [] @@ -2097,8 +2198,8 @@ void Abc_NtkRecStop2() ABC_FREE( s_pMan->pTemp2 ); Vec_PtrFree( s_pMan->vNodes ); Vec_PtrFree( s_pMan->vTtTemps ); - if ( s_pMan->vLabels ) - Vec_PtrFree( s_pMan->vLabels ); + Vec_PtrFree( s_pMan->vLabels ); + Vec_IntFree( s_pMan->vLabelsInt ); //if(s_pMan->pMemObj) // Mem_FixedStop(s_pMan->pMemObj, 0); Vec_IntFree( s_pMan->vUselessPos); diff --git a/src/base/abci/abcRec3.c b/src/base/abci/abcRec3.c new file mode 100644 index 00000000..ed6148ab --- /dev/null +++ b/src/base/abci/abcRec3.c @@ -0,0 +1,1097 @@ +/**CFile**************************************************************** + + FileName [abcRec2.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Network and node package.] + + Synopsis [Record of semi-canonical AIG subgraphs.] + + Author [Allan Yang, Alan Mishchenko] + + Affiliation [Fudan University in Shanghai, UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: abcRec.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "base/abc/abc.h" +#include "map/if/if.h" +#include "bool/kit/kit.h" +#include "aig/gia/giaAig.h" +#include "misc/vec/vecMem.h" +#include "bool/lucky/lucky.h" +#include "misc/util/utilTruth.h" + +ABC_NAMESPACE_IMPL_START + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +/* + This LMS manager can be used in two modes: + - library constuction + - AIG level minimization + + It is not OK to switch from library construction to AIG level minimization + without restarting LSM manager. To restart the LSM manager, GIA has to be written out + (rec_dump3 <file>.aig) and LMS manager started again (rec_start3 <file>.aig). +*/ + +typedef struct Lms_Man_t_ Lms_Man_t; +struct Lms_Man_t_ +{ + // parameters + int nVars; // the number of variables + int nWords; // the number of TT words + int nCuts; // the max number of cuts to use + int fFuncOnly; // record only functions + int fLibConstr; // this manager is used for library construction + // internal data for library construction + Gia_Man_t * pGia; // the record + Vec_Mem_t * vTtMem; // truth table memory and hash table + Vec_Int_t * vTruthIds; // truth table IDs of each PO + // internal data for AIG level minimization (allocated the first time it is called) + Vec_Int_t * vTruthPo; // first PO where this canonicized truth table was seen + Vec_Wrd_t * vDelays; // pin-to-pin delays of each PO + Vec_Str_t * vAreas; // number of AND gates in each PO + Vec_Int_t * vFreqs; // subgraph usage frequencies + // temporaries + Vec_Ptr_t * vNodes; // the temporary nodes + Vec_Ptr_t * vLabelsP; // temporary storage for HOP node labels + Vec_Int_t * vLabels; // temporary storage for AIG node labels + word pTemp1[1024]; // copy of the truth table + word pTemp2[1024]; // copy of the truth table + // statistics + int nTried; + int nFilterSize; + int nFilterRedund; + int nFilterVolume; + int nFilterTruth; + int nFilterError; + int nFilterSame; + int nAdded; + int nAddedFuncs; + int nHoleInTheWall; + // runtime + clock_t timeCollect; + clock_t timeCanon; + clock_t timeBuild; + clock_t timeCheck; + clock_t timeInsert; + clock_t timeOther; + clock_t timeTotal; +}; + +static Lms_Man_t * s_pMan3 = NULL; + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Lms_Man_t * Lms_ManStart( Gia_Man_t * pGia, int nVars, int nCuts, int fFuncOnly, int fVerbose ) +{ + Lms_Man_t * p; + // if GIA is given, use the number of variables from GIA + nVars = pGia ? Gia_ManCiNum(pGia) : nVars; + assert( nVars >= 6 && nVars <= 16 ); + // allocate manager + p = ABC_CALLOC( Lms_Man_t, 1 ); + // parameters + p->nVars = nVars; + p->nCuts = nCuts; + p->nWords = Abc_Truth6WordNum( nVars ); + p->fFuncOnly = fFuncOnly; + // internal data for library construction + p->vTtMem = Vec_MemAlloc( p->nWords, 12 ); // 32 KB/page for 6-var functions + Vec_MemHashAlloc( p->vTtMem, 10000 ); + p->vTruthIds = Vec_IntAlloc( 10000 ); + if ( pGia == NULL ) + { + int i; + p->pGia = Gia_ManStart( 10000 ); + p->pGia->pName = Abc_UtilStrsav( "record" ); + for ( i = 0; i < nVars; i++ ) + Gia_ManAppendCi( p->pGia ); + } + else + { + Gia_Obj_t * pObj; + unsigned * pTruth; + int i, Index, Prev = -1; + p->pGia = pGia; + // populate the manager with subgraphs present in GIA + p->nAdded = Gia_ManCoNum( p->pGia ); + Gia_ManForEachCo( p->pGia, pObj, i ) + { + pTruth = Gia_ObjComputeTruthTable( p->pGia, pObj ); + Index = Vec_MemHashInsert( p->vTtMem, (word *)pTruth ); + assert( Index == Prev || Index == Prev + 1 ); // GIA subgraphs should be ordered + Vec_IntPush( p->vTruthIds, Index ); + Prev = Index; + } + } + // temporaries + p->vNodes = Vec_PtrAlloc( 1000 ); + p->vLabelsP = Vec_PtrAlloc( 1000 ); + p->vLabels = Vec_IntAlloc( 1000 ); + return p; +} +void Lms_ManStop( Lms_Man_t * p ) +{ + // temporaries + Vec_IntFreeP( &p->vLabels ); + Vec_PtrFreeP( &p->vLabelsP ); + Vec_PtrFreeP( &p->vNodes ); + // internal data for AIG level minimization + Vec_IntFreeP( &p->vTruthPo ); + Vec_WrdFreeP( &p->vDelays ); + Vec_StrFreeP( &p->vAreas ); + Vec_IntFreeP( &p->vFreqs ); + // internal data for library construction + Vec_IntFreeP( &p->vTruthIds ); + Vec_MemHashFree( p->vTtMem ); + Vec_MemFree( p->vTtMem ); + Gia_ManStop( p->pGia ); + ABC_FREE( p ); +} +void Lms_ManPrint( Lms_Man_t * p ) +{ +// Gia_ManPrintStats( p->pGia, 0, 0 ); + printf( "Library with %d vars has %d classes and %d AIG subgraphs with %d AND nodes.\n", + Gia_ManCiNum(p->pGia), Vec_MemEntryNum(p->vTtMem), p->nAdded, Gia_ManAndNum(p->pGia) ); + + p->nAddedFuncs = Vec_MemEntryNum(p->vTtMem); + printf( "Subgraphs tried = %10d. (%6.2f %%)\n", p->nTried, !p->nTried? 0 : 100.0*p->nTried/p->nTried ); + printf( "Subgraphs filtered by support size = %10d. (%6.2f %%)\n", p->nFilterSize, !p->nTried? 0 : 100.0*p->nFilterSize/p->nTried ); + printf( "Subgraphs filtered by structural redundancy = %10d. (%6.2f %%)\n", p->nFilterRedund, !p->nTried? 0 : 100.0*p->nFilterRedund/p->nTried ); + printf( "Subgraphs filtered by volume = %10d. (%6.2f %%)\n", p->nFilterVolume, !p->nTried? 0 : 100.0*p->nFilterVolume/p->nTried ); + printf( "Subgraphs filtered by TT redundancy = %10d. (%6.2f %%)\n", p->nFilterTruth, !p->nTried? 0 : 100.0*p->nFilterTruth/p->nTried ); + printf( "Subgraphs filtered by error = %10d. (%6.2f %%)\n", p->nFilterError, !p->nTried? 0 : 100.0*p->nFilterError/p->nTried ); + printf( "Subgraphs filtered by isomorphism = %10d. (%6.2f %%)\n", p->nFilterSame, !p->nTried? 0 : 100.0*p->nFilterSame/p->nTried ); + printf( "Subgraphs added = %10d. (%6.2f %%)\n", p->nAdded, !p->nTried? 0 : 100.0*p->nAdded/p->nTried ); + printf( "Functions added = %10d. (%6.2f %%)\n", p->nAddedFuncs, !p->nTried? 0 : 100.0*p->nAddedFuncs/p->nTried ); + if ( p->nHoleInTheWall ) + printf( "Cuts whose logic structure has a hole = %10d. (%6.2f %%)\n", p->nHoleInTheWall, !p->nTried? 0 : 100.0*p->nHoleInTheWall/p->nTried ); + + p->timeOther = p->timeTotal - p->timeCollect - p->timeCanon - p->timeBuild - p->timeCheck - p->timeInsert; + ABC_PRTP( "Runtime: Collect", p->timeCollect, p->timeTotal ); + ABC_PRTP( "Runtime: Canon ", p->timeCanon, p->timeTotal ); + ABC_PRTP( "Runtime: Build ", p->timeBuild, p->timeTotal ); + ABC_PRTP( "Runtime: Check ", p->timeCheck, p->timeTotal ); + ABC_PRTP( "Runtime: Insert ", p->timeInsert, p->timeTotal ); + ABC_PRTP( "Runtime: Other ", p->timeOther, p->timeTotal ); + ABC_PRTP( "Runtime: TOTAL ", p->timeTotal, p->timeTotal ); +} + + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Abc_NtkRecStart3( Gia_Man_t * p, int nVars, int nCuts, int fFuncOnly, int fVerbose ) +{ + assert( s_pMan3 == NULL ); + s_pMan3 = Lms_ManStart( p, nVars, nCuts, fFuncOnly, fVerbose ); +} + +void Abc_NtkRecStop3() +{ + assert( s_pMan3 != NULL ); + Lms_ManStop( s_pMan3 ); + s_pMan3 = NULL; +} + + +/**Function************************************************************* + + Synopsis [Compute delay/area profiles of POs.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Lms_DelayGet( word D, int v ) { assert(v >= 0 && v < 16); return (int)((D >> (v << 2)) & 0xF); } +static inline void Lms_DelaySet( word * pD, int v, int d ) { assert(v >= 0 && v < 16); assert(d >= 0 && d < 16); *pD |= ((word)d << (v << 2)); } +static inline word Lms_DelayInit( int v ) { assert(v >= 0 && v < 16); return (word)1 << (v << 2); } +static inline word Lms_DelayMax( word D1, word D2, int nVars ) +{ + int v, Max; + word D = 0; + for ( v = 0; v < nVars; v++ ) + if ( (Max = Abc_MaxInt(Lms_DelayGet(D1, v), Lms_DelayGet(D2, v))) ) + Lms_DelaySet( &D, v, Abc_MinInt(Max + 1, 15) ); + return D; +} +static inline word Lms_DelayDecrement( word D1, int nVars ) +{ + int v; + word D = 0; + for ( v = 0; v < nVars; v++ ) + if ( Lms_DelayGet(D1, v) ) + Lms_DelaySet( &D, v, Lms_DelayGet(D1, v) - 1 ); + return D; +} +static inline int Lms_DelayEqual( word D1, word D2, int nVars ) // returns 1 if D1 has the same delays than D2 +{ + int v; + for ( v = 0; v < nVars; v++ ) + if ( Lms_DelayGet(D1, v) != Lms_DelayGet(D2, v) ) + return 0; + return 1; +} +static inline int Lms_DelayDom( word D1, word D2, int nVars ) // returns 1 if D1 has the same or smaller delays than D2 +{ + int v; + for ( v = 0; v < nVars; v++ ) + if ( Lms_DelayGet(D1, v) > Lms_DelayGet(D2, v) ) + return 0; + return 1; +} +static inline void Lms_DelayPrint( word D, int nVars ) +{ + int v; + printf( "Delay profile = {" ); + for ( v = 0; v < nVars; v++ ) + printf( " %d", Lms_DelayGet(D, v) ); + printf( " }\n" ); +} +Vec_Wrd_t * Lms_GiaDelays( Gia_Man_t * p ) +{ + Vec_Wrd_t * vDelays, * vResult; + Gia_Obj_t * pObj; + int i; + // compute delay profiles of all objects + vDelays = Vec_WrdAlloc( Gia_ManObjNum(p) ); + Vec_WrdPush( vDelays, 0 ); // const 0 + Gia_ManForEachObj1( p, pObj, i ) + { + if ( Gia_ObjIsAnd(pObj) ) + Vec_WrdPush( vDelays, Lms_DelayMax( Vec_WrdEntry(vDelays, Gia_ObjFaninId0(pObj, i)), Vec_WrdEntry(vDelays, Gia_ObjFaninId1(pObj, i)), Gia_ManCiNum(p) ) ); + else if ( Gia_ObjIsCo(pObj) ) + Vec_WrdPush( vDelays, Lms_DelayDecrement( Vec_WrdEntry(vDelays, Gia_ObjFaninId0(pObj, i)), Gia_ManCiNum(p) ) ); + else if ( Gia_ObjIsCi(pObj) ) + Vec_WrdPush( vDelays, Lms_DelayInit( Gia_ObjCioId(pObj) ) ); + else assert( 0 ); + } + // collect delay profiles of COs only + vResult = Vec_WrdAlloc( Gia_ManCoNum(p) ); + Gia_ManForEachCo( p, pObj, i ) + Vec_WrdPush( vResult, Vec_WrdEntry(vDelays, Gia_ObjId(p, pObj)) ); + Vec_WrdFree( vDelays ); + return vResult; +} +void Lms_ObjAreaMark_rec( Gia_Obj_t * pObj ) +{ + if ( pObj->fMark0 || Gia_ObjIsCi(pObj) ) + return; + pObj->fMark0 = 1; + Lms_ObjAreaMark_rec( Gia_ObjFanin0(pObj) ); + Lms_ObjAreaMark_rec( Gia_ObjFanin1(pObj) ); +} +int Lms_ObjAreaUnmark_rec( Gia_Obj_t * pObj ) +{ + if ( !pObj->fMark0 || Gia_ObjIsCi(pObj) ) + return 0; + pObj->fMark0 = 0; + return 1 + Lms_ObjAreaUnmark_rec( Gia_ObjFanin0(pObj) ) + + Lms_ObjAreaUnmark_rec( Gia_ObjFanin1(pObj) ); +} +int Lms_ObjArea( Gia_Obj_t * pObj ) +{ + assert( Gia_ObjIsAnd(pObj) ); + Lms_ObjAreaMark_rec( pObj ); + return Lms_ObjAreaUnmark_rec( pObj ); +} +Vec_Str_t * Lms_GiaAreas( Gia_Man_t * p ) +{ + Vec_Str_t * vAreas; + Gia_Obj_t * pObj; + int i; + vAreas = Vec_StrAlloc( Gia_ManCoNum(p) ); + Gia_ManForEachCo( p, pObj, i ) + Vec_StrPush( vAreas, (char)(Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) ? Lms_ObjArea(Gia_ObjFanin0(pObj)) : 0) ); + return vAreas; +} + +/**Function************************************************************* + + Synopsis [Prints one GIA subgraph.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Lms_GiaPrintSubgraph_rec( Gia_Man_t * p, Gia_Obj_t * pObj ) +{ + if ( !pObj->fMark0 || Gia_ObjIsCi(pObj) ) + return; + pObj->fMark0 = 0; + assert( Gia_ObjIsAnd(pObj) ); + Lms_GiaPrintSubgraph_rec( p, Gia_ObjFanin0(pObj) ); + Lms_GiaPrintSubgraph_rec( p, Gia_ObjFanin1(pObj) ); + Gia_ObjPrint( p, pObj ); +} +void Lms_GiaPrintSubgraph( Gia_Man_t * p, Gia_Obj_t * pObj ) +{ + assert( Gia_ObjIsCo(pObj) ); + if ( Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) ) + { + Lms_ObjAreaMark_rec( Gia_ObjFanin0(pObj) ); + Lms_GiaPrintSubgraph_rec( p, Gia_ObjFanin0(pObj) ); + } + else + Gia_ObjPrint( p, Gia_ObjFanin0(pObj) ); + Gia_ObjPrint( p, pObj ); +} + +/**Function************************************************************* + + Synopsis [Prints delay/area profiles of the GIA subgraphs.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Lms_GiaProfilesPrint( Gia_Man_t * p ) +{ + Gia_Obj_t * pObj; + int i; + Vec_Wrd_t * vDelays; + Vec_Str_t * vAreas; + vDelays = Lms_GiaDelays( p ); + vAreas = Lms_GiaAreas( p ); + + Gia_ManForEachPo( p, pObj, i ) + { + printf( "%6d : ", i ); + printf( "A = %2d ", Vec_StrEntry(vAreas, i) ); + Lms_DelayPrint( Vec_WrdEntry(vDelays, i), Gia_ManPiNum(p) ); +// Lms_GiaPrintSubgraph( p, pObj ); +// printf( "\n" ); + } + + Vec_WrdFree( vDelays ); + Vec_StrFree( vAreas ); +} + +/**Function************************************************************* + + Synopsis [Compute support sizes for each CO.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Vec_Str_t * Gia_ManSuppSizes( Gia_Man_t * p ) +{ + Vec_Str_t * vResult; + Vec_Str_t * vSupps; + Gia_Obj_t * pObj; + int i; + vSupps = Vec_StrAlloc( Gia_ManObjNum(p) ); + Vec_StrPush( vSupps, 0 ); + Gia_ManForEachObj1( p, pObj, i ) + { + if ( Gia_ObjIsAnd(pObj) ) + Vec_StrPush( vSupps, (char)Abc_MaxInt( Vec_StrEntry(vSupps, Gia_ObjFaninId0(pObj, i)), Vec_StrEntry(vSupps, Gia_ObjFaninId1(pObj, i)) ) ); + else if ( Gia_ObjIsCo(pObj) ) + Vec_StrPush( vSupps, Vec_StrEntry(vSupps, Gia_ObjFaninId0(pObj, i)) ); + else if ( Gia_ObjIsCi(pObj) ) + Vec_StrPush( vSupps, (char)(Gia_ObjCioId(pObj)+1) ); + else assert( 0 ); + } + assert( Vec_StrSize(vSupps) == Gia_ManObjNum(p) ); + vResult = Vec_StrAlloc( Gia_ManCoNum(p) ); + Gia_ManForEachCo( p, pObj, i ) + Vec_StrPush( vResult, Vec_StrEntry(vSupps, Gia_ObjId(p, pObj)) ); + Vec_StrFree( vSupps ); + return vResult; +} + + +/**Function************************************************************* + + Synopsis [Recanonicizes the library and add it to the current library.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Abc_NtkRecLibMerge3( Gia_Man_t * pLib ) +{ + int fCheck = 0; + Lms_Man_t * p = s_pMan3; + Gia_Man_t * pGia = p->pGia; + Vec_Str_t * vSupps; + char pCanonPerm[16]; + unsigned uCanonPhase; + unsigned * pTruth; + int i, k, Index, iFanin0, iFanin1, nLeaves; + Gia_Obj_t * pObjPo, * pDriver, * pTemp = NULL; + clock_t clk, clk2 = clock(); + + assert( Gia_ManCiNum(pLib) == Gia_ManCiNum(pGia) ); + + // create hash table if not available + if ( pGia->pHTable == NULL ) + Gia_ManHashStart( pGia ); + + // add AIG subgraphs + vSupps = Gia_ManSuppSizes( pLib ); + Gia_ManForEachCo( pLib, pObjPo, k ) + { + // get support size + nLeaves = Vec_StrEntry(vSupps, k); + assert( nLeaves > 1 ); + // compute the truth table +clk = clock(); + pTruth = Gia_ObjComputeTruthTable( pLib, Gia_ObjFanin0(pObjPo) ); +p->timeCollect += clock() - clk; + // semi-canonicize +clk = clock(); + memcpy( p->pTemp1, pTruth, p->nWords * sizeof(word) ); + // uCanonPhase = luckyCanonicizer_final_fast( p->pTemp1, nLeaves, pCanonPerm ); + uCanonPhase = Kit_TruthSemiCanonicize( (unsigned *)p->pTemp1, (unsigned *)p->pTemp2, nLeaves, pCanonPerm ); + Abc_TtStretch5( (unsigned *)p->pTemp1, nLeaves, p->nVars ); +p->timeCanon += clock() - clk; + // pCanonPerm and uCanonPhase show what was the variable corresponding to each var in the current truth + +clk = clock(); + // map cut leaves into elementary variables of GIA + for ( i = 0; i < nLeaves; i++ ) + Gia_ManCi( pLib, pCanonPerm[i] )->Value = Abc_Var2Lit( Gia_ObjId(pGia, Gia_ManPi(pGia, i)), (uCanonPhase >> i) & 1 ); + // build internal nodes + assert( Vec_IntSize(pLib->vTtNodes) > 0 ); + Gia_ManForEachObjVec( pLib->vTtNodes, pLib, pTemp, i ) + { + iFanin0 = Abc_LitNotCond( Gia_ObjFanin0(pTemp)->Value, Gia_ObjFaninC0(pTemp) ); + iFanin1 = Abc_LitNotCond( Gia_ObjFanin1(pTemp)->Value, Gia_ObjFaninC1(pTemp) ); + pTemp->Value = Gia_ManHashAnd( pGia, iFanin0, iFanin1 ); + } +p->timeBuild += clock() - clk; + + // check if this node is already driving a PO + assert( Gia_ObjIsAnd(pTemp) ); + pDriver = Gia_ManObj(pGia, Abc_Lit2Var(pTemp->Value)); + if ( pDriver->fMark1 ) + { + p->nFilterSame++; + continue; + } + pDriver->fMark1 = 1; + // create output + Gia_ManAppendCo( pGia, Abc_LitNotCond( pTemp->Value, (uCanonPhase >> nLeaves) & 1 ) ); + + // verify truth table + if ( fCheck ) + { +clk = clock(); + pTemp = Gia_ManCo(pGia, Gia_ManCoNum(pGia)-1); + pTruth = Gia_ObjComputeTruthTable( pGia, Gia_ManCo(pGia, Gia_ManCoNum(pGia)-1) ); +p->timeCheck += clock() - clk; + if ( memcmp( p->pTemp1, pTruth, p->nWords * sizeof(word) ) != 0 ) + { + + Kit_DsdPrintFromTruth( pTruth, nLeaves ); printf( "\n" ); + Kit_DsdPrintFromTruth( (unsigned *)p->pTemp1, nLeaves ); printf( "\n" ); + printf( "Truth table verification has failed.\n" ); + + // drive PO with constant + Gia_ManPatchCoDriver( pGia, Gia_ManCoNum(pGia)-1, 0 ); + // save truth table ID + Vec_IntPush( p->vTruthIds, -1 ); + p->nFilterTruth++; + continue; + } + } + +clk = clock(); + // add the resulting truth table to the hash table + Index = Vec_MemHashInsert( p->vTtMem, p->pTemp1 ); + // save truth table ID + Vec_IntPush( p->vTruthIds, Index ); + assert( Gia_ManCoNum(pGia) == Vec_IntSize(p->vTruthIds) ); + p->nAdded++; +p->timeInsert += clock() - clk; + } + Vec_StrFree( vSupps ); +p->timeTotal += clock() - clk2; +} + + +/**Function************************************************************* + + Synopsis [Evaluates one cut during library construction.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_NtkRecAddCut3( If_Man_t * pIfMan, If_Obj_t * pRoot, If_Cut_t * pCut ) +{ + Lms_Man_t * p = s_pMan3; + char pCanonPerm[16]; + unsigned uCanonPhase; + int i, Index, iFanin0, iFanin1, fHole; + int nLeaves = If_CutLeaveNum(pCut); + Vec_Ptr_t * vNodes = p->vNodes; + Gia_Man_t * pGia = p->pGia; + Gia_Obj_t * pDriver; + If_Obj_t * pIfObj = NULL; + unsigned * pTruth; + clock_t clk; + p->nTried++; + + // skip small cuts + assert( p->nVars == (int)pCut->nLimit ); + if ( nLeaves < 2 ) + { + p->nFilterSize++; + return 1; + } + + // collect internal nodes and skip redundant cuts +clk = clock(); + If_CutTraverse( pIfMan, pRoot, pCut, vNodes ); +p->timeCollect += clock() - clk; + + // semi-canonicize truth table +clk = clock(); + memcpy( p->pTemp1, If_CutTruthW(pCut), p->nWords * sizeof(word) ); +// uCanonPhase = luckyCanonicizer_final_fast( p->pTemp1, nLeaves, pCanonPerm ); + uCanonPhase = Kit_TruthSemiCanonicize( (unsigned *)p->pTemp1, (unsigned *)p->pTemp2, nLeaves, pCanonPerm ); + Abc_TtStretch5( (unsigned *)p->pTemp1, nLeaves, p->nVars ); +p->timeCanon += clock() - clk; + // pCanonPerm and uCanonPhase show what was the variable corresponding to each var in the current truth + +clk = clock(); + // map cut leaves into elementary variables of GIA + for ( i = 0; i < nLeaves; i++ ) + If_ManObj( pIfMan, pCut->pLeaves[(int)pCanonPerm[i]] )->iCopy = Abc_Var2Lit( Gia_ObjId(pGia, Gia_ManPi(pGia, i)), (uCanonPhase >> i) & 1 ); + // build internal nodes + fHole = 0; + assert( Vec_PtrSize(vNodes) > 0 ); + Vec_PtrForEachEntryStart( If_Obj_t *, vNodes, pIfObj, i, nLeaves ) + { + if ( If_ObjIsCi(pIfObj) ) + { + pIfObj->iCopy = 0; + fHole = 1; + continue; + } + iFanin0 = Abc_LitNotCond( If_ObjFanin0(pIfObj)->iCopy, If_ObjFaninC0(pIfObj) ); + iFanin1 = Abc_LitNotCond( If_ObjFanin1(pIfObj)->iCopy, If_ObjFaninC1(pIfObj) ); + pIfObj->iCopy = Gia_ManHashAnd( pGia, iFanin0, iFanin1 ); + } + p->nHoleInTheWall += fHole; +p->timeBuild += clock() - clk; + + // check if this node is already driving a PO + assert( If_ObjIsAnd(pIfObj) ); + pDriver = Gia_ManObj(pGia, Abc_Lit2Var(pIfObj->iCopy)); + if ( pDriver->fMark1 ) + { + p->nFilterSame++; + return 1; + } + pDriver->fMark1 = 1; + // create output + Gia_ManAppendCo( pGia, Abc_LitNotCond( pIfObj->iCopy, (uCanonPhase >> nLeaves) & 1 ) ); + + // verify truth table +clk = clock(); + pTruth = Gia_ObjComputeTruthTable( pGia, Gia_ManCo(pGia, Gia_ManCoNum(pGia)-1) ); +p->timeCheck += clock() - clk; + if ( memcmp( p->pTemp1, pTruth, p->nWords * sizeof(word) ) != 0 ) + { +/* + Kit_DsdPrintFromTruth( pTruth, nLeaves ); printf( "\n" ); + Kit_DsdPrintFromTruth( (unsigned *)p->pTemp1, nLeaves ); printf( "\n" ); + printf( "Truth table verification has failed.\n" ); +*/ + // drive PO with constant + Gia_ManPatchCoDriver( pGia, Gia_ManCoNum(pGia)-1, 0 ); + // save truth table ID + Vec_IntPush( p->vTruthIds, -1 ); + p->nFilterTruth++; + return 1; + } + +clk = clock(); + // add the resulting truth table to the hash table + Index = Vec_MemHashInsert( p->vTtMem, p->pTemp1 ); + // save truth table ID + Vec_IntPush( p->vTruthIds, Index ); + assert( Gia_ManCoNum(pGia) == Vec_IntSize(p->vTruthIds) ); + p->nAdded++; +p->timeInsert += clock() - clk; + return 1; +} + +/**Function************************************************************* + + Synopsis [Top level procedure for library construction.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Abc_NtkRecAdd3( Abc_Ntk_t * pNtk, int fUseSOPB ) +{ + extern Abc_Ntk_t * Abc_NtkIf( Abc_Ntk_t * pNtk, If_Par_t * pPars ); + If_Par_t Pars, * pPars = &Pars; + Abc_Ntk_t * pNtkNew; + int clk = clock(); + if ( Abc_NtkGetChoiceNum( pNtk ) ) + printf( "Performing recoding structures with choices.\n" ); + // remember that the manager was used for library construction + s_pMan3->fLibConstr = 1; + // create hash table if not available + if ( s_pMan3->pGia->pHTable == NULL ) + Gia_ManHashStart( s_pMan3->pGia ); + + // set defaults + memset( pPars, 0, sizeof(If_Par_t) ); + // user-controlable paramters + pPars->nLutSize = s_pMan3->nVars; + pPars->nCutsMax = s_pMan3->nCuts; + pPars->DelayTarget = -1; + pPars->Epsilon = (float)0.005; + pPars->fArea = 1; + // internal parameters + if ( fUseSOPB ) + { + pPars->fTruth = 1; + pPars->fCutMin = 0; + pPars->fUsePerm = 1; + pPars->fDelayOpt = 1; + } + else + { + pPars->fTruth = 1; + pPars->fCutMin = 1; + pPars->fUsePerm = 0; + pPars->fDelayOpt = 0; + } + pPars->fSkipCutFilter = 0; + pPars->pFuncCost = NULL; + pPars->pFuncUser = Abc_NtkRecAddCut3; + // perform recording + pNtkNew = Abc_NtkIf( pNtk, pPars ); + Abc_NtkDelete( pNtkNew ); +s_pMan3->timeTotal += clock() - clk; +} + + /**Function************************************************************* + + Synopsis [Returns min AIG level at the output fo the cut using the library.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int If_CutComputeDelay( If_Man_t * p, If_Cut_t * pCut, char * pCanonPerm, word Delay ) +{ + If_Obj_t* pLeaf; + int nLeaves = If_CutLeaveNum(pCut); + int i, delayTemp, delayMax = -ABC_INFINITY; + for ( i = 0; i < nLeaves; i++ ) + { + pLeaf = If_ManObj(p, (pCut)->pLeaves[(int)pCanonPerm[i]]); + delayTemp = If_ObjCutBest(pLeaf)->Delay + Lms_DelayGet(Delay, i); + if(delayTemp > delayMax) + delayMax = delayTemp; + } + return delayMax; +} +static inline int If_CutFindBestStruct( If_Man_t * pIfMan, If_Cut_t * pCut, char * pCanonPerm, unsigned * puCanonPhase, int * pBestPo ) +{ + Lms_Man_t * p = s_pMan3; + int i, * pTruthId, iFirstPo, iFirstPoNext, iBestPo; + int BestDelay = ABC_INFINITY, BestArea = ABC_INFINITY, Delay, Area; + int nLeaves = If_CutLeaveNum( pCut ); + clock_t clk; + + // semicanonicize the function +clk = clock(); + memcpy( p->pTemp1, If_CutTruthW(pCut), p->nWords * sizeof(word) ); +// uCanonPhase = luckyCanonicizer_final_fast( p->pTemp1, nLeaves, pCanonPerm ); + *puCanonPhase = Kit_TruthSemiCanonicize( (unsigned *)p->pTemp1, (unsigned *)p->pTemp2, nLeaves, pCanonPerm ); + Abc_TtStretch5( (unsigned *)p->pTemp1, nLeaves, p->nVars ); +p->timeCanon += clock() - clk; + + // get TT ID for the given class + pTruthId = Vec_MemHashLookup( p->vTtMem, p->pTemp1 ); + if ( *pTruthId == -1 ) + return ABC_INFINITY; + + // note that array p->vTruthPo contains the first PO for the given truth table + // other POs belonging to the same equivalence class follow immediately after this one + // to iterate through the POs, we need to perform the following steps + + // find the first PO of this class + iFirstPo = Vec_IntEntry( p->vTruthPo, *pTruthId ); + // find the first PO of the next class + iFirstPoNext = Vec_IntEntry( p->vTruthPo, *pTruthId+1 ); + // iterate through the subgraphs of this class + iBestPo = -1; + for ( i = iFirstPo; i < iFirstPoNext; i++ ) + { + Delay = If_CutComputeDelay( pIfMan, pCut, pCanonPerm, Vec_WrdEntry(p->vDelays, i) ); + Area = Vec_StrEntry(p->vAreas, i); + if ( iBestPo == -1 || BestDelay > Delay || (BestDelay == Delay && BestArea > Area) ) + { + iBestPo = i; + BestDelay = Delay; + BestArea = Area; + } + } + if ( pBestPo ) + *pBestPo = iBestPo; + return BestDelay; +} +int If_CutDelayRecCost3( If_Man_t * pIfMan, If_Cut_t * pCut, If_Obj_t * pObj ) +{ + Lms_Man_t * p = s_pMan3; + char pCanonPerm[16]; + unsigned uCanonPhase; + // make sure the cut functions match the library + assert( p->nVars == (int)pCut->nLimit ); + // if this assertion fires, it means that LMS manager was used for library construction + // in this case, GIA has to be written out and the manager restarted as described above + assert( !p->fLibConstr ); + if ( p->vTruthPo == NULL ) // the first time AIG level minimization is called + { + // compute the first PO for each semi-canonical form + int i, Entry; + p->vTruthPo = Vec_IntStartFull( Vec_MemEntryNum(p->vTtMem)+1 ); + assert( Vec_IntFindMin(p->vTruthIds) >= 0 ); + assert( Vec_IntFindMax(p->vTruthIds) < Vec_MemEntryNum(p->vTtMem) ); + Vec_IntForEachEntry( p->vTruthIds, Entry, i ) + if ( Vec_IntEntry(p->vTruthPo, Entry) == -1 ) + Vec_IntWriteEntry( p->vTruthPo, Entry, i ); + Vec_IntWriteEntry( p->vTruthPo, Vec_MemEntryNum(p->vTtMem), Gia_ManCoNum(p->pGia) ); + // compute delay/area and init frequency + assert( p->vDelays == NULL ); + assert( p->vAreas == NULL ); + assert( p->vFreqs == NULL ); + p->vDelays = Lms_GiaDelays( p->pGia ); + p->vAreas = Lms_GiaAreas( p->pGia ); + p->vFreqs = Vec_IntStart( Gia_ManCoNum(p->pGia) ); + } + // return the delay of the best structure + return If_CutFindBestStruct( pIfMan, pCut, pCanonPerm, &uCanonPhase, NULL ); +} + +/**Function************************************************************* + + Synopsis [Reexpresses the best structure of the cut in the HOP manager.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +Hop_Obj_t * Abc_RecToHop3( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut, If_Obj_t * pIfObj ) +{ + Lms_Man_t * p = s_pMan3; + char pCanonPerm[16]; + unsigned uCanonPhase; + Hop_Obj_t * pFan0, * pFan1, * pHopObj; + Gia_Man_t * pGia = p->pGia; + Gia_Obj_t * pGiaPo, * pGiaTemp = NULL; + int i, BestPo = -1, nLeaves = If_CutLeaveNum(pCut); + assert( pIfMan->pPars->fCutMin == 1 ); + assert( nLeaves > 1 ); + + // get the best output for this node + If_CutFindBestStruct( pIfMan, pCut, pCanonPerm, &uCanonPhase, &BestPo ); + assert( BestPo >= 0 ); + pGiaPo = Gia_ManCo( pGia, BestPo ); + + // collect internal nodes into pGia->vTtNodes + if ( pGia->vTtNodes == NULL ) + pGia->vTtNodes = Vec_IntAlloc( 256 ); + Gia_ObjCollectInternal( pGia, pGiaPo ); + // collect HOP nodes for leaves + Vec_PtrClear( p->vLabelsP ); + for ( i = 0; i < nLeaves; i++ ) + { + pHopObj = Hop_IthVar( pMan, pCanonPerm[i] ); + pHopObj = Hop_NotCond( pHopObj, (uCanonPhase >> i) & 1 ); + Vec_PtrPush(p->vLabelsP, pHopObj); + } + // compute HOP nodes for internal nodes + Gia_ManForEachObjVec( pGia->vTtNodes, pGia, pGiaTemp, i ) + { + pGiaTemp->fMark0 = 0; // unmark node marked by Gia_ObjCollectInternal() + + if ( Gia_ObjIsAnd(Gia_ObjFanin0(pGiaTemp)) ) + pFan0 = (Hop_Obj_t *)Vec_PtrEntry(p->vLabelsP, Gia_ObjNum(pGia, Gia_ObjFanin0(pGiaTemp)) + nLeaves); + else + pFan0 = (Hop_Obj_t *)Vec_PtrEntry(p->vLabelsP, Gia_ObjCioId(Gia_ObjFanin0(pGiaTemp))); + pFan0 = Hop_NotCond(pFan0, Gia_ObjFaninC0(pGiaTemp)); + + if ( Gia_ObjIsAnd(Gia_ObjFanin1(pGiaTemp)) ) + pFan1 = (Hop_Obj_t *)Vec_PtrEntry(p->vLabelsP, Gia_ObjNum(pGia, Gia_ObjFanin1(pGiaTemp)) + nLeaves); + else + pFan1 = (Hop_Obj_t *)Vec_PtrEntry(p->vLabelsP, Gia_ObjCioId(Gia_ObjFanin1(pGiaTemp))); + pFan1 = Hop_NotCond(pFan1, Gia_ObjFaninC1(pGiaTemp)); + + pHopObj = Hop_And(pMan, pFan0, pFan1); + Vec_PtrPush(p->vLabelsP, pHopObj); + } + // get the final result + assert( Gia_ObjIsAnd(pGiaTemp) ); + pHopObj = (Hop_Obj_t *)Vec_PtrEntry(p->vLabelsP, Gia_ObjNum(pGia, pGiaTemp) + nLeaves); + // complement the result if needed + return Hop_NotCond( pHopObj, pCut->fCompl ^ Gia_ObjFaninC0(pGiaPo) ^ ((uCanonPhase >> nLeaves) & 1) ); +} + + +/**Function************************************************************* + + Synopsis [Reduces GIA to contain only useful COs and internal nodes.] + + Description [During library construction, redundant nodes are added. + Some COs are found to be useless because their TT does not match the + (semi-canonicized TT) of the cut, etc. This procedure reduces GIA + to contains only useful (non-redundant, non-dominated) COs and the + corresponding internal nodes. This procedure replaces GIA by a new GIA + and creates new vTruthIds. The COs with the same truth table have + adjacent IDs. This procedure does not change the truth tables.] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +// count how many times TT occurs +Vec_Int_t * Lms_GiaCountTruths( Lms_Man_t * p ) +{ + Vec_Int_t * vCounts = Vec_IntStart( Vec_MemEntryNum(p->vTtMem) ); + int i, Entry; + Vec_IntForEachEntry( p->vTruthIds, Entry, i ) + if ( Entry >= 0 ) + Vec_IntAddToEntry( vCounts, Entry, 1 ); + return vCounts; +} +// collect PO indexes worth visiting +Vec_Int_t * Lms_GiaCollectUsefulCos( Lms_Man_t * p ) +{ + Vec_Int_t * vBegins = Vec_IntAlloc( Vec_MemEntryNum(p->vTtMem) ); + Vec_Int_t * vUseful = Vec_IntStartFull( Gia_ManCoNum(p->pGia) + Vec_MemEntryNum(p->vTtMem) ); + Vec_Int_t * vCounts = Lms_GiaCountTruths( p ); + int i, Entry, * pPlace, SumTotal = 0; + // mark up the place for POs + Vec_IntForEachEntry( vCounts, Entry, i ) + { + assert( Entry > 0 ); + Vec_IntPush( vBegins, SumTotal ); + SumTotal += Entry + 1; +// printf( "%d ", Entry ); + } + Vec_IntPush( vBegins, SumTotal ); + // fill out POs in their places + Vec_IntFill( vCounts, Vec_IntSize(vCounts), 0 ); + Vec_IntForEachEntry( p->vTruthIds, Entry, i ) + { + if ( Entry < 0 ) + continue; + pPlace = Vec_IntEntryP( vUseful, Vec_IntEntry(vBegins, Entry) + Vec_IntEntry(vCounts, Entry) ); + assert( *pPlace == -1 ); + *pPlace = i; + Vec_IntAddToEntry( vCounts, Entry, 1 ); + } + Vec_IntFree( vBegins ); + Vec_IntFree( vCounts ); + return vUseful; +} +// collect non-dominated COs +Vec_Int_t * Lms_GiaFindNonRedundantCos( Lms_Man_t * p ) +{ + Vec_Int_t * vRemain; + Vec_Int_t * vUseful; + Vec_Wrd_t * vDelays; + int i, k, EntryI, EntryK; + word D1, D2; + vDelays = Lms_GiaDelays( p->pGia ); + vUseful = Lms_GiaCollectUsefulCos( p ); + Vec_IntForEachEntry( vUseful, EntryI, i ) + { + if ( EntryI < 0 ) + continue; + D1 = Vec_WrdEntry(vDelays, EntryI); + assert( D1 > 0 ); + Vec_IntForEachEntryStart( vUseful, EntryK, k, i+1 ) + { + if ( EntryK == -1 ) + break; + if ( EntryK == -2 ) + continue; + D2 = Vec_WrdEntry(vDelays, EntryK); + assert( D2 > 0 ); + if ( Lms_DelayDom(D1, D2, Gia_ManCiNum(p->pGia)) ) // D1 dominate D2 + { + Vec_IntWriteEntry( vUseful, k, -2 ); + continue; + } + if ( Lms_DelayDom(D2, D1, Gia_ManCiNum(p->pGia)) ) // D2 dominate D1 + { + Vec_IntWriteEntry( vUseful, i, -2 ); + break; + } + } + } + + vRemain = Vec_IntAlloc( 1000 ); + Vec_IntForEachEntry( vUseful, EntryI, i ) + if ( EntryI >= 0 ) + Vec_IntPush( vRemain, EntryI ); + Vec_IntFree( vUseful ); + Vec_WrdFree( vDelays ); + return vRemain; +} +// replace GIA and vTruthIds by filtered ones +void Lms_GiaNormalize( Lms_Man_t * p ) +{ + Gia_Man_t * pGiaNew; + Gia_Obj_t * pObj; + Vec_Int_t * vRemain; + Vec_Int_t * vTruthIdsNew; + int i, Entry, Prev = -1, Next; + clock_t clk = clock(); + // collect non-redundant COs + vRemain = Lms_GiaFindNonRedundantCos( p ); + // change these to be useful literals + vTruthIdsNew = Vec_IntAlloc( Vec_IntSize(vRemain) ); + Vec_IntForEachEntry( vRemain, Entry, i ) + { + pObj = Gia_ManCo(p->pGia, Entry); + assert( Gia_ObjIsAnd(Gia_ObjFanin0(pObj)) ); + Vec_IntWriteEntry( vRemain, i, Gia_ObjFaninLit0p(p->pGia, pObj) ); + // create new truth IDs + Next = Vec_IntEntry(p->vTruthIds, Gia_ObjCioId(pObj)); + assert( Prev <= Next ); + Vec_IntPush( vTruthIdsNew, Next ); + Prev = Next; + } + // create a new GIA + Gia_ManForEachObj( p->pGia, pObj, i ) + assert( pObj->fMark0 == 0 ); + for ( i = 0; i < Gia_ManCoNum(p->pGia); i++ ) + Gia_ManPatchCoDriver( p->pGia, i, 0 ); + Vec_IntForEachEntry( vRemain, Entry, i ) + Gia_ManAppendCo( p->pGia, Entry ); +// pGiaNew = Gia_ManCleanup( p->pGia ); + pGiaNew = Gia_ManCleanupOutputs( p->pGia, Gia_ManCoNum(p->pGia) - Vec_IntSize(vRemain) ); + Gia_ManStop( p->pGia ); + p->pGia = pGiaNew; + Vec_IntFree( vRemain ); + // update truth IDs + Vec_IntFree( p->vTruthIds ); + p->vTruthIds = vTruthIdsNew; +// Vec_IntPrint( vTruthIdsNew ); + Abc_PrintTime( 1, "Normalization runtime", clock() - clk ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Abc_NtkRecPs3(int fPrintLib) +{ + Lms_ManPrint( s_pMan3 ); + + printf( "Before normalizing\n" ); + Gia_ManPrintStats( s_pMan3->pGia, 0, 0 ); + + Lms_GiaNormalize( s_pMan3 ); + + printf( "After normalizing\n" ); + Gia_ManPrintStats( s_pMan3->pGia, 0, 0 ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_NtkRecIsRunning3() +{ + return s_pMan3 != NULL; +} +Gia_Man_t * Abc_NtkRecGetGia3() +{ + Lms_GiaNormalize( s_pMan3 ); + return s_pMan3->pGia; +} + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + +ABC_NAMESPACE_IMPL_END
\ No newline at end of file diff --git a/src/base/abci/module.make b/src/base/abci/module.make index d96afbd1..90bdb419 100644 --- a/src/base/abci/module.make +++ b/src/base/abci/module.make @@ -46,6 +46,7 @@ SRC += src/base/abci/abc.c \ src/base/abci/abcQuant.c \ src/base/abci/abcRec.c \ src/base/abci/abcRec2.c \ + src/base/abci/abcRec3.c \ src/base/abci/abcReconv.c \ src/base/abci/abcReach.c \ src/base/abci/abcRefactor.c \ diff --git a/src/base/io/io.c b/src/base/io/io.c index b7c3234c..466a563a 100644 --- a/src/base/io/io.c +++ b/src/base/io/io.c @@ -1654,9 +1654,10 @@ int IoCommandWriteBlif( Abc_Frame_t * pAbc, int argc, char **argv ) char * pFileName; char * pLutStruct = NULL; int c, fSpecial = 0; + int fUseHie = 0; Extra_UtilGetoptReset(); - while ( ( c = Extra_UtilGetopt( argc, argv, "Sjh" ) ) != EOF ) + while ( ( c = Extra_UtilGetopt( argc, argv, "Sjah" ) ) != EOF ) { switch ( c ) { @@ -1677,6 +1678,9 @@ int IoCommandWriteBlif( Abc_Frame_t * pAbc, int argc, char **argv ) case 'j': fSpecial ^= 1; break; + case 'a': + fUseHie ^= 1; + break; case 'h': goto usage; default: @@ -1694,16 +1698,17 @@ int IoCommandWriteBlif( Abc_Frame_t * pAbc, int argc, char **argv ) pFileName = argv[globalUtilOptind]; // call the corresponding file writer if ( fSpecial || pLutStruct ) - Io_WriteBlifSpecial( pAbc->pNtkCur, pFileName, pLutStruct ); + Io_WriteBlifSpecial( pAbc->pNtkCur, pFileName, pLutStruct, fUseHie ); else Io_Write( pAbc->pNtkCur, pFileName, IO_FILE_BLIF ); return 0; usage: - fprintf( pAbc->Err, "usage: write_blif [-S str] [-jh] <file>\n" ); + fprintf( pAbc->Err, "usage: write_blif [-S str] [-jah] <file>\n" ); fprintf( pAbc->Err, "\t writes the network into a BLIF file\n" ); fprintf( pAbc->Err, "\t-S str : string representing the LUT structure [default = %s]\n", pLutStruct ? pLutStruct : "not used" ); fprintf( pAbc->Err, "\t-j : enables special BLIF writing [default = %s]\n", fSpecial? "yes" : "no" );; + fprintf( pAbc->Err, "\t-a : enables hierarchical BLIF writing for LUT structures [default = %s]\n", fUseHie? "yes" : "no" );; fprintf( pAbc->Err, "\t-h : print the help massage\n" ); fprintf( pAbc->Err, "\tfile : the name of the file to write (extension .blif)\n" ); return 1; @@ -2734,17 +2739,22 @@ int IoCommandWriteTruths( Abc_Frame_t * pAbc, int argc, char **argv ) char * pFileName; FILE * pFile; unsigned * pTruth; + int nBytes; int fReverse = 0; + int fBinary = 0; int c, i; Extra_UtilGetoptReset(); - while ( ( c = Extra_UtilGetopt( argc, argv, "rh" ) ) != EOF ) + while ( ( c = Extra_UtilGetopt( argc, argv, "rbh" ) ) != EOF ) { switch ( c ) { case 'r': fReverse ^= 1; break; + case 'b': + fBinary ^= 1; + break; case 'h': goto usage; default: @@ -2761,30 +2771,39 @@ int IoCommandWriteTruths( Abc_Frame_t * pAbc, int argc, char **argv ) Abc_Print( -1, "IoCommandWriteTruths(): Can write truth tables up to 16 inputs.\n" ); return 0; } + if ( Gia_ManPiNum(pAbc->pGia) < 3 ) + { + Abc_Print( -1, "IoCommandWriteTruths(): Can write truth tables for 3 inputs or more.\n" ); + return 0; + } if ( argc != globalUtilOptind + 1 ) goto usage; // get the input file name pFileName = argv[globalUtilOptind]; // convert to logic - pFile = fopen( pFileName, "w" ); + pFile = fopen( pFileName, "wb" ); if ( pFile == NULL ) { printf( "Cannot open file \"%s\" for writing.\n", pFileName ); return 0; } + nBytes = 8 * Abc_Truth6WordNum( Gia_ManPiNum(pAbc->pGia) ); Gia_ManForEachCo( pAbc->pGia, pObj, i ) { pTruth = Gia_ObjComputeTruthTable( pAbc->pGia, pObj ); - Extra_PrintHex( pFile, pTruth, Gia_ManPiNum(pAbc->pGia) ); - fprintf( pFile, "\n" ); + if ( fBinary ) + fwrite( pTruth, nBytes, 1, pFile ); + else + Extra_PrintHex( pFile, pTruth, Gia_ManPiNum(pAbc->pGia) ), fprintf( pFile, "\n" ); } fclose( pFile ); return 0; usage: - fprintf( pAbc->Err, "usage: &write_truths [-rh] <file>\n" ); + fprintf( pAbc->Err, "usage: &write_truths [-rbh] <file>\n" ); fprintf( pAbc->Err, "\t writes truth tables of each PO of GIA manager into a file\n" ); fprintf( pAbc->Err, "\t-r : toggle reversing bits in the truth table [default = %s]\n", fReverse? "yes":"no" ); + fprintf( pAbc->Err, "\t-b : toggle using binary format [default = %s]\n", fBinary? "yes":"no" ); 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/ioAbc.h b/src/base/io/ioAbc.h index 039f53c0..efac1212 100644 --- a/src/base/io/ioAbc.h +++ b/src/base/io/ioAbc.h @@ -106,7 +106,7 @@ extern void Io_WriteBblif( Abc_Ntk_t * pNtk, char * pFileName ); extern void Io_WriteBlifLogic( Abc_Ntk_t * pNtk, char * pFileName, int fWriteLatches ); extern void Io_WriteBlif( Abc_Ntk_t * pNtk, char * pFileName, int fWriteLatches, int fBb2Wb, int fSeq ); extern void Io_WriteTimingInfo( FILE * pFile, Abc_Ntk_t * pNtk ); -extern void Io_WriteBlifSpecial( Abc_Ntk_t * pNtk, char * FileName, char * pLutStruct ); +extern void Io_WriteBlifSpecial( Abc_Ntk_t * pNtk, char * FileName, char * pLutStruct, int fUseHie ); /*=== abcWriteBlifMv.c ==========================================================*/ extern void Io_WriteBlifMv( Abc_Ntk_t * pNtk, char * FileName ); /*=== abcWriteBench.c =========================================================*/ diff --git a/src/base/io/ioReadBlifMv.c b/src/base/io/ioReadBlifMv.c index bbaad423..ab40065e 100644 --- a/src/base/io/ioReadBlifMv.c +++ b/src/base/io/ioReadBlifMv.c @@ -1272,7 +1272,7 @@ static int Io_MvParseLineSubckt( Io_MvMod_t * p, char * pLine ) return 0; } */ - if ( k == nEquals ) + if ( pName2 == NULL ) { Abc_Obj_t * pNode = Abc_NtkCreateNode( p->pNtk ); pNode->pData = Abc_SopRegister( (Mem_Flex_t *)p->pNtk->pManFunc, " 0\n" ); @@ -1313,11 +1313,10 @@ static int Io_MvParseLineSubckt( Io_MvMod_t * p, char * pLine ) return 0; } */ - assert( pName2 != NULL ); // create the BI with the actual name pTerm = Abc_NtkCreateBo( p->pNtk ); - pNet = Abc_NtkFindOrCreateNet( p->pNtk, k == nEquals ? Abc_ObjNameSuffix(pTerm, "abc") : pName2 ); + pNet = Abc_NtkFindOrCreateNet( p->pNtk, pName2 == NULL ? Abc_ObjNameSuffix(pTerm, "abc") : pName2 ); Abc_ObjAddFanin( pNet, pTerm ); Abc_ObjAddFanin( pTerm, pBox ); } diff --git a/src/base/io/ioWriteBlif.c b/src/base/io/ioWriteBlif.c index e13037db..bd7d9819 100644 --- a/src/base/io/ioWriteBlif.c +++ b/src/base/io/ioWriteBlif.c @@ -514,6 +514,68 @@ void Io_NtkWriteNodeFanins( FILE * pFile, Abc_Obj_t * pNode ) fprintf( pFile, " %s", pName ); } +/**Function************************************************************* + + Synopsis [Writes the primary input list.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Io_NtkWriteSubcktFanins( FILE * pFile, Abc_Obj_t * pNode ) +{ + Abc_Obj_t * pNet; + int LineLength; + int AddedLength; + int NameCounter; + char * pName; + int i; + + LineLength = 6; + NameCounter = 0; + + // get the output name + pName = Abc_ObjName(Abc_ObjFanout0(pNode)); + // get the line length after the output name is written + AddedLength = strlen(pName) + 1; + fprintf( pFile, " m%d", Abc_ObjId(pNode) ); + + // get the input names + Abc_ObjForEachFanin( pNode, pNet, i ) + { + // get the fanin name + pName = Abc_ObjName(pNet); + // get the line length after the fanin name is written + AddedLength = strlen(pName) + 3; + if ( NameCounter && LineLength + AddedLength + 3 > IO_WRITE_LINE_LENGTH ) + { // write the line extender + fprintf( pFile, " \\\n" ); + // reset the line length + LineLength = 0; + NameCounter = 0; + } + fprintf( pFile, " %c=%s", 'a'+i, pName ); + LineLength += AddedLength; + NameCounter++; + } + + // get the output name + pName = Abc_ObjName(Abc_ObjFanout0(pNode)); + // get the line length after the output name is written + AddedLength = strlen(pName) + 3; + if ( NameCounter && LineLength + AddedLength > 75 ) + { // write the line extender + fprintf( pFile, " \\\n" ); + // reset the line length + LineLength = 0; + NameCounter = 0; + } + fprintf( pFile, " %c=%s", 'o', pName ); +} + /**Function************************************************************* @@ -586,6 +648,26 @@ int Io_NtkWriteNode( FILE * pFile, Abc_Obj_t * pNode, int Length ) /**Function************************************************************* + Synopsis [Write the node into a file.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Io_NtkWriteNodeSubckt( FILE * pFile, Abc_Obj_t * pNode, int Length ) +{ + int RetValue = 0; + fprintf( pFile, ".subckt" ); + Io_NtkWriteSubcktFanins( pFile, pNode ); + fprintf( pFile, "\n" ); + return RetValue; +} + +/**Function************************************************************* + Synopsis [Writes the timing info.] Description [] @@ -1022,6 +1104,182 @@ void Io_NtkWriteNodeIntStruct( FILE * pFile, Abc_Obj_t * pNode, Vec_Int_t * vCov /**Function************************************************************* + Synopsis [Write the node into a file.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Io_NtkWriteModelIntStruct( FILE * pFile, Abc_Obj_t * pNode, Vec_Int_t * vCover, char * pStr ) +{ + Abc_Obj_t * pNet; + int nLeaves = Abc_ObjFaninNum(pNode); + int i, nLutLeaf, nLutLeaf2, nLutRoot, Length; + + // write the header + fprintf( pFile, "\n" ); + fprintf( pFile, ".model m%d\n", Abc_ObjId(pNode) ); + fprintf( pFile, ".inputs" ); + for ( i = 0; i < Abc_ObjFaninNum(pNode); i++ ) + fprintf( pFile, " %c", 'a' + i ); + fprintf( pFile, "\n" ); + fprintf( pFile, ".outputs o\n" ); + + // quit if parameters are wrong + Length = strlen(pStr); + if ( Length != 2 && Length != 3 ) + { + printf( "Wrong LUT struct (%s)\n", pStr ); + return; + } + for ( i = 0; i < Length; i++ ) + if ( pStr[i] - '0' < 3 || pStr[i] - '0' > 6 ) + { + printf( "The LUT size (%d) should belong to {3,4,5,6}.\n", pStr[i] - '0' ); + return; + } + + nLutLeaf = pStr[0] - '0'; + nLutLeaf2 = ( Length == 3 ) ? pStr[1] - '0' : 0; + nLutRoot = pStr[Length-1] - '0'; + if ( nLeaves > nLutLeaf - 1 + (nLutLeaf2 ? nLutLeaf2 - 1 : 0) + nLutRoot ) + { + printf( "The node size (%d) is too large for the LUT structure %s.\n", nLeaves, pStr ); + return; + } + + // consider easy case + if ( nLeaves <= Abc_MaxInt( nLutLeaf2, Abc_MaxInt(nLutLeaf, nLutRoot) ) ) + { + // write the .names line + fprintf( pFile, ".names" ); + Abc_ObjForEachFanin( pNode, pNet, i ) + fprintf( pFile, " %c", 'a' + i ); + // get the output name + fprintf( pFile, " %s\n", "o" ); + // write the cubes + fprintf( pFile, "%s", (char*)Abc_ObjData(pNode) ); + fprintf( pFile, ".end\n" ); + return; + } + else + { + extern int If_CluMinimumBase( word * t, int * pSupp, int nVarsAll, int * pnVars ); + + static word TruthStore[16][1<<10] = {{0}}, * pTruths[16]; + word pCube[1<<10], pRes[1<<10], Func0, Func1, Func2; + char pLut0[32], pLut1[32], pLut2[32] = {0}, * pSop; +// int nVarsMin[3], pVars[3][20]; + + if ( TruthStore[0][0] == 0 ) + { + static word Truth6[6] = { + 0xAAAAAAAAAAAAAAAA, + 0xCCCCCCCCCCCCCCCC, + 0xF0F0F0F0F0F0F0F0, + 0xFF00FF00FF00FF00, + 0xFFFF0000FFFF0000, + 0xFFFFFFFF00000000 + }; + int nVarsMax = 16; + int nWordsMax = (1 << 10); + int i, k; + assert( nVarsMax <= 16 ); + for ( i = 0; i < nVarsMax; i++ ) + pTruths[i] = TruthStore[i]; + for ( i = 0; i < 6; i++ ) + for ( k = 0; k < nWordsMax; k++ ) + pTruths[i][k] = Truth6[i]; + for ( i = 6; i < nVarsMax; i++ ) + for ( k = 0; k < nWordsMax; k++ ) + pTruths[i][k] = ((k >> (i-6)) & 1) ? ~(word)0 : 0; + } + + // collect variables +// Abc_ObjForEachFanin( pNode, pNet, i ) +// pVars[0][i] = pVars[1][i] = pVars[2][i] = i; + + // derive truth table + Abc_SopToTruthBig( (char*)Abc_ObjData(pNode), nLeaves, pTruths, pCube, pRes ); + if ( Kit_TruthIsConst0((unsigned *)pRes, nLeaves) || Kit_TruthIsConst1((unsigned *)pRes, nLeaves) ) + { + fprintf( pFile, ".names %s\n %d\n", "o", Kit_TruthIsConst1((unsigned *)pRes, nLeaves) ); + fprintf( pFile, ".end\n" ); + return; + } + +// Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " ); +// Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" ); + + // perform decomposition + if ( Length == 2 ) + { + if ( !If_CluCheckExt( NULL, pRes, nLeaves, nLutLeaf, nLutRoot, pLut0, pLut1, &Func0, &Func1 ) ) + { + Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " ); + Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" ); + printf( "Node \"%s\" is not decomposable. Writing BLIF has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) ); + return; + } + } + else + { + if ( !If_CluCheckExt3( NULL, pRes, nLeaves, nLutLeaf, nLutLeaf2, nLutRoot, pLut0, pLut1, pLut2, &Func0, &Func1, &Func2 ) ) + { + Extra_PrintHex( stdout, (unsigned *)pRes, nLeaves ); printf( " " ); + Kit_DsdPrintFromTruth( (unsigned*)pRes, nLeaves ); printf( "\n" ); + printf( "Node \"%s\" is not decomposable. Writing BLIF has failed.\n", Abc_ObjName(Abc_ObjFanout0(pNode)) ); + return; + } + } + + // write leaf node + fprintf( pFile, ".names" ); + for ( i = 0; i < pLut1[0]; i++ ) + fprintf( pFile, " %c", 'a' + pLut1[2+i] ); + fprintf( pFile, " lut1\n" ); + // write SOP + pSop = Io_NtkDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func1, pLut1[0], vCover ); + fprintf( pFile, "%s", pSop ); + + if ( Length == 3 && pLut2[0] > 0 ) + { + // write leaf node + fprintf( pFile, ".names" ); + for ( i = 0; i < pLut2[0]; i++ ) + if ( pLut2[2+i] == nLeaves ) + fprintf( pFile, " lut1" ); + else + fprintf( pFile, " %c", 'a' + pLut2[2+i] ); + fprintf( pFile, " lut2\n" ); + // write SOP + pSop = Io_NtkDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func2, pLut2[0], vCover ); + fprintf( pFile, "%s", pSop ); + } + + // write root node + fprintf( pFile, ".names" ); + for ( i = 0; i < pLut0[0]; i++ ) + if ( pLut0[2+i] == nLeaves ) + fprintf( pFile, " lut1" ); + else if ( pLut0[2+i] == nLeaves+1 ) + fprintf( pFile, " lut2" ); + else + fprintf( pFile, " %c", 'a' + pLut0[2+i] ); + fprintf( pFile, " %s\n", "o" ); + // write SOP + pSop = Io_NtkDeriveSop( (Mem_Flex_t *)Abc_ObjNtk(pNode)->pManFunc, Func0, pLut0[0], vCover ); + fprintf( pFile, "%s", pSop ); + fprintf( pFile, ".end\n" ); + } +} + + +/**Function************************************************************* + Synopsis [Write the network into a BLIF file with the given name.] Description [] @@ -1031,7 +1289,7 @@ void Io_NtkWriteNodeIntStruct( FILE * pFile, Abc_Obj_t * pNode, Vec_Int_t * vCov SeeAlso [] ***********************************************************************/ -void Io_WriteBlifInt( Abc_Ntk_t * pNtk, char * FileName, char * pLutStruct ) +void Io_WriteBlifInt( Abc_Ntk_t * pNtk, char * FileName, char * pLutStruct, int fUseHie ) { FILE * pFile; Vec_Int_t * vCover; @@ -1063,18 +1321,33 @@ void Io_WriteBlifInt( Abc_Ntk_t * pNtk, char * FileName, char * pLutStruct ) Io_NtkWriteLatch( pFile, pLatch ); if ( Abc_NtkLatchNum(pNtk) ) fprintf( pFile, "\n" ); - // write each internal node + // write the hierarchy vCover = Vec_IntAlloc( (1<<16) ); - Abc_NtkForEachNode( pNtk, pNode, i ) + if ( fUseHie ) { - if ( pLutStruct ) - Io_NtkWriteNodeIntStruct( pFile, pNode, vCover, pLutStruct ); - else - Io_NtkWriteNodeInt( pFile, pNode, vCover ); + // write each internal node + fprintf( pFile, "\n" ); + Abc_NtkForEachNode( pNtk, pNode, i ) + Io_NtkWriteNodeSubckt( pFile, pNode, 0 ); + fprintf( pFile, ".end\n\n" ); + // write models + Abc_NtkForEachNode( pNtk, pNode, i ) + Io_NtkWriteModelIntStruct( pFile, pNode, vCover, pLutStruct ); + fprintf( pFile, "\n" ); + } + else + { + // write each internal node + Abc_NtkForEachNode( pNtk, pNode, i ) + { + if ( pLutStruct ) + Io_NtkWriteNodeIntStruct( pFile, pNode, vCover, pLutStruct ); + else + Io_NtkWriteNodeInt( pFile, pNode, vCover ); + } + fprintf( pFile, ".end\n\n" ); } Vec_IntFree( vCover ); - // write the end - fprintf( pFile, ".end\n\n" ); fclose( pFile ); } @@ -1089,7 +1362,7 @@ void Io_WriteBlifInt( Abc_Ntk_t * pNtk, char * FileName, char * pLutStruct ) SeeAlso [] ***********************************************************************/ -void Io_WriteBlifSpecial( Abc_Ntk_t * pNtk, char * FileName, char * pLutStruct ) +void Io_WriteBlifSpecial( Abc_Ntk_t * pNtk, char * FileName, char * pLutStruct, int fUseHie ) { Abc_Ntk_t * pNtkTemp; assert( Abc_NtkIsLogic(pNtk) ); @@ -1101,7 +1374,10 @@ void Io_WriteBlifSpecial( Abc_Ntk_t * pNtk, char * FileName, char * pLutStruct ) fprintf( stdout, "Writing BLIF has failed.\n" ); return; } - Io_WriteBlifInt( pNtkTemp, FileName, pLutStruct ); + if ( pLutStruct && fUseHie ) + Io_WriteBlifInt( pNtkTemp, FileName, pLutStruct, 1 ); + else + Io_WriteBlifInt( pNtkTemp, FileName, pLutStruct, 0 ); Abc_NtkDelete( pNtkTemp ); } diff --git a/src/base/main/mainInt.h b/src/base/main/mainInt.h index 4db982f0..f30a13e5 100644 --- a/src/base/main/mainInt.h +++ b/src/base/main/mainInt.h @@ -111,7 +111,7 @@ struct Abc_Frame_t_ void * pAbc85Ntl2; void * pAbc85Best; void * pAbc85Delay; - If_Lib_t * pAbc85Lib; +// If_Lib_t * pAbc85Lib; EXT_ABC_FRAME // plugin for external functionality }; diff --git a/src/bool/kit/kit.h b/src/bool/kit/kit.h index 5ecb5581..cb1c1eb0 100644 --- a/src/bool/kit/kit.h +++ b/src/bool/kit/kit.h @@ -68,7 +68,8 @@ struct Kit_Node_t_ Kit_Edge_t eEdge0; // the left child of the node Kit_Edge_t eEdge1; // the right child of the node // other info - void * pFunc; // the function of the node (BDD or AIG) + union { int iFunc; // the function of the node (BDD or AIG) + void * pFunc; }; // the function of the node (BDD or AIG) unsigned Level : 14; // the level of this node in the global AIG // printing info unsigned fNodeOr : 1; // marks the original OR node @@ -561,6 +562,7 @@ extern unsigned Kit_GraphToTruth( Kit_Graph_t * pGraph ); extern Kit_Graph_t * Kit_TruthToGraph( unsigned * pTruth, int nVars, Vec_Int_t * vMemory ); extern int Kit_GraphLeafDepth_rec( Kit_Graph_t * pGraph, Kit_Node_t * pNode, Kit_Node_t * pLeaf ); /*=== kitHop.c ==========================================================*/ +//extern int Kit_TruthToGia( Gia_Man_t * pMan, unsigned * pTruth, int nVars, Vec_Int_t * vMemory, Vec_Int_t * vLeaves, int fHash ); //extern Hop_Obj_t * Kit_GraphToHop( Hop_Man_t * pMan, Kit_Graph_t * pGraph ); //extern Hop_Obj_t * Kit_TruthToHop( Hop_Man_t * pMan, unsigned * pTruth, int nVars, Vec_Int_t * vMemory ); //extern Hop_Obj_t * Kit_CoverToHop( Hop_Man_t * pMan, Vec_Int_t * vCover, int nVars, Vec_Int_t * vMemory ); diff --git a/src/bool/kit/kitHop.c b/src/bool/kit/kitHop.c index c7c855af..a4ce79f3 100644 --- a/src/bool/kit/kitHop.c +++ b/src/bool/kit/kitHop.c @@ -20,6 +20,7 @@ #include "kit.h" #include "aig/hop/hop.h" +#include "aig/gia/gia.h" ABC_NAMESPACE_IMPL_START @@ -43,31 +44,66 @@ ABC_NAMESPACE_IMPL_START SeeAlso [] ***********************************************************************/ -Hop_Obj_t * Kit_GraphToHopInternal( Hop_Man_t * pMan, Kit_Graph_t * pGraph ) +int Kit_GraphToGiaInternal( Gia_Man_t * pMan, Kit_Graph_t * pGraph, int fHash ) { Kit_Node_t * pNode = NULL; - Hop_Obj_t * pAnd0, * pAnd1; - int i; + int i, pAnd0, pAnd1; // check for constant function if ( Kit_GraphIsConst(pGraph) ) - return Hop_NotCond( Hop_ManConst1(pMan), Kit_GraphIsComplement(pGraph) ); + return Abc_LitNotCond( 1, Kit_GraphIsComplement(pGraph) ); // check for a literal if ( Kit_GraphIsVar(pGraph) ) - return Hop_NotCond( (Hop_Obj_t *)Kit_GraphVar(pGraph)->pFunc, Kit_GraphIsComplement(pGraph) ); + return Abc_LitNotCond( Kit_GraphVar(pGraph)->iFunc, Kit_GraphIsComplement(pGraph) ); // build the AIG nodes corresponding to the AND gates of the graph Kit_GraphForEachNode( pGraph, pNode, i ) { - pAnd0 = Hop_NotCond( (Hop_Obj_t *)Kit_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc, pNode->eEdge0.fCompl ); - pAnd1 = Hop_NotCond( (Hop_Obj_t *)Kit_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc, pNode->eEdge1.fCompl ); - pNode->pFunc = Hop_And( pMan, pAnd0, pAnd1 ); + pAnd0 = Abc_LitNotCond( Kit_GraphNode(pGraph, pNode->eEdge0.Node)->iFunc, pNode->eEdge0.fCompl ); + pAnd1 = Abc_LitNotCond( Kit_GraphNode(pGraph, pNode->eEdge1.Node)->iFunc, pNode->eEdge1.fCompl ); + if ( fHash ) + pNode->iFunc = Gia_ManHashAnd( pMan, pAnd0, pAnd1 ); + else + pNode->iFunc = Gia_ManAppendAnd( pMan, pAnd0, pAnd1 ); } // complement the result if necessary - return Hop_NotCond( (Hop_Obj_t *)pNode->pFunc, Kit_GraphIsComplement(pGraph) ); + return Abc_LitNotCond( pNode->iFunc, Kit_GraphIsComplement(pGraph) ); +} +int Kit_GraphToGia( Gia_Man_t * pMan, Kit_Graph_t * pGraph, Vec_Int_t * vLeaves, int fHash ) +{ + Kit_Node_t * pNode = NULL; + int i; + // collect the fanins + Kit_GraphForEachLeaf( pGraph, pNode, i ) + pNode->iFunc = Vec_IntEntry( vLeaves, i ); + // perform strashing + return Kit_GraphToGiaInternal( pMan, pGraph, fHash ); +} +int Kit_TruthToGia( Gia_Man_t * pMan, unsigned * pTruth, int nVars, Vec_Int_t * vMemory, Vec_Int_t * vLeaves, int fHash ) +{ + int iLit; + Kit_Graph_t * pGraph; + // transform truth table into the decomposition tree + if ( vMemory == NULL ) + { + vMemory = Vec_IntAlloc( 0 ); + pGraph = Kit_TruthToGraph( pTruth, nVars, vMemory ); + Vec_IntFree( vMemory ); + } + else + pGraph = Kit_TruthToGraph( pTruth, nVars, vMemory ); + if ( pGraph == NULL ) + { + printf( "Kit_TruthToGia(): Converting truth table to AIG has failed for function:\n" ); + Kit_DsdPrintFromTruth( pTruth, nVars ); printf( "\n" ); + } + // derive the AIG for the decomposition tree + iLit = Kit_GraphToGia( pMan, pGraph, vLeaves, fHash ); + Kit_GraphFree( pGraph ); + return iLit; } /**Function************************************************************* - Synopsis [Strashes one logic node using its SOP.] + Synopsis [Transforms the decomposition graph into the AIG.] Description [] @@ -76,6 +112,27 @@ Hop_Obj_t * Kit_GraphToHopInternal( Hop_Man_t * pMan, Kit_Graph_t * pGraph ) SeeAlso [] ***********************************************************************/ +Hop_Obj_t * Kit_GraphToHopInternal( Hop_Man_t * pMan, Kit_Graph_t * pGraph ) +{ + Kit_Node_t * pNode = NULL; + Hop_Obj_t * pAnd0, * pAnd1; + int i; + // check for constant function + if ( Kit_GraphIsConst(pGraph) ) + return Hop_NotCond( Hop_ManConst1(pMan), Kit_GraphIsComplement(pGraph) ); + // check for a literal + if ( Kit_GraphIsVar(pGraph) ) + return Hop_NotCond( (Hop_Obj_t *)Kit_GraphVar(pGraph)->pFunc, Kit_GraphIsComplement(pGraph) ); + // build the AIG nodes corresponding to the AND gates of the graph + Kit_GraphForEachNode( pGraph, pNode, i ) + { + pAnd0 = Hop_NotCond( (Hop_Obj_t *)Kit_GraphNode(pGraph, pNode->eEdge0.Node)->pFunc, pNode->eEdge0.fCompl ); + pAnd1 = Hop_NotCond( (Hop_Obj_t *)Kit_GraphNode(pGraph, pNode->eEdge1.Node)->pFunc, pNode->eEdge1.fCompl ); + pNode->pFunc = Hop_And( pMan, pAnd0, pAnd1 ); + } + // complement the result if necessary + return Hop_NotCond( (Hop_Obj_t *)pNode->pFunc, Kit_GraphIsComplement(pGraph) ); +} Hop_Obj_t * Kit_GraphToHop( Hop_Man_t * pMan, Kit_Graph_t * pGraph ) { Kit_Node_t * pNode = NULL; @@ -86,18 +143,6 @@ Hop_Obj_t * Kit_GraphToHop( Hop_Man_t * pMan, Kit_Graph_t * pGraph ) // perform strashing return Kit_GraphToHopInternal( pMan, pGraph ); } - -/**Function************************************************************* - - Synopsis [Strashed onen logic nodes using its truth table.] - - Description [] - - SideEffects [] - - SeeAlso [] - -***********************************************************************/ Hop_Obj_t * Kit_TruthToHop( Hop_Man_t * pMan, unsigned * pTruth, int nVars, Vec_Int_t * vMemory ) { Hop_Obj_t * pObj; diff --git a/src/bool/kit/kitTruth.c b/src/bool/kit/kitTruth.c index a6951163..87b28135 100644 --- a/src/bool/kit/kitTruth.c +++ b/src/bool/kit/kitTruth.c @@ -1664,6 +1664,8 @@ unsigned Kit_TruthSemiCanonicize( unsigned * pInOut, unsigned * pAux, int nVars, // canonicize output uCanonPhase = 0; + for ( i = 0; i < nVars; i++ ) + pCanonPerm[i] = i; nOnes = Kit_TruthCountOnes(pIn, nVars); //if(pIn[0] & 1) diff --git a/src/map/if/if.h b/src/map/if/if.h index f74a59da..9e649e0c 100644 --- a/src/map/if/if.h +++ b/src/map/if/if.h @@ -333,7 +333,7 @@ static inline void * If_ObjCopy( If_Obj_t * pObj ) { r static inline int If_ObjLevel( If_Obj_t * pObj ) { return pObj->Level; } static inline void If_ObjSetLevel( If_Obj_t * pObj, int Level ) { pObj->Level = Level; } static inline void If_ObjSetCopy( If_Obj_t * pObj, void * pCopy ) { pObj->pCopy = pCopy; } -static inline void If_ObjSetChoice( If_Obj_t * pObj, If_Obj_t * pEqu ) { pObj->pEquiv = pEqu; } +static inline void If_ObjSetChoice( If_Obj_t * pObj, If_Obj_t * pEqu ) { assert( pObj->Id > pEqu->Id ); pObj->pEquiv = pEqu; } static inline If_Cut_t * If_ObjCutBest( If_Obj_t * pObj ) { return &pObj->CutBest; } static inline unsigned If_ObjCutSign( unsigned ObjId ) { return (1 << (ObjId % 31)); } @@ -353,8 +353,9 @@ static inline void If_CutSetDataInt( If_Cut_t * pCut, int Data ) { * static inline int If_CutLeaveNum( If_Cut_t * pCut ) { return pCut->nLeaves; } static inline int * If_CutLeaves( If_Cut_t * pCut ) { return pCut->pLeaves; } static inline unsigned * If_CutTruth( If_Cut_t * pCut ) { return pCut->pTruth; } +static inline word * If_CutTruthW( If_Cut_t * pCut ) { return (word *)pCut->pTruth; } static inline unsigned If_CutSuppMask( If_Cut_t * pCut ) { return (~(unsigned)0) >> (32-pCut->nLeaves); } -static inline int If_CutTruthWords( int nVarsMax ) { return nVarsMax <= 5 ? 1 : (1 << (nVarsMax - 5)); } +static inline int If_CutTruthWords( int nVarsMax ) { return nVarsMax <= 5 ? 2 : (1 << (nVarsMax - 5)); } static inline int If_CutPermWords( int nVarsMax ) { return nVarsMax / sizeof(int) + ((nVarsMax % sizeof(int)) > 0); } static inline float If_CutLutArea( If_Man_t * p, If_Cut_t * pCut ) { return pCut->fUser? (float)pCut->Cost : (p->pPars->pLutLib? p->pPars->pLutLib->pLutAreas[pCut->nLeaves] : (float)1.0); } @@ -505,8 +506,9 @@ extern void If_CutPropagateRequired( If_Man_t * p, If_Obj_t * pObj, I extern void If_CutRotatePins( If_Man_t * p, If_Cut_t * pCut ); /*=== ifTruth.c ===========================================================*/ extern int If_CutTruthMinimize( If_Man_t * p, If_Cut_t * pCut ); -extern int If_CutComputeTruth( If_Man_t * p, If_Cut_t * pCut, If_Cut_t * pCut0, If_Cut_t * pCut1, int fCompl0, int fCompl1 ); extern void If_CutTruthPermute( unsigned * pOut, unsigned * pIn, int nVars, float * pDelays, int * pVars ); +extern int If_CutComputeTruth( If_Man_t * p, If_Cut_t * pCut, If_Cut_t * pCut0, If_Cut_t * pCut1, int fCompl0, int fCompl1 ); +extern int If_CutComputeTruth2( If_Man_t * p, If_Cut_t * pCut, If_Cut_t * pCut0, If_Cut_t * pCut1, int fCompl0, int fCompl1 ); /*=== ifUtil.c ============================================================*/ extern void If_ManCleanNodeCopy( If_Man_t * p ); extern void If_ManCleanCutData( If_Man_t * p ); @@ -525,13 +527,18 @@ extern Vec_Ptr_t * If_ManCollectMappingDirect( If_Man_t * p ); extern Vec_Int_t * If_ManCollectMappingInt( If_Man_t * p ); extern int If_ManCountSpecialPos( If_Man_t * p ); +extern void If_CutTraverse( If_Man_t * p, If_Obj_t * pRoot, If_Cut_t * pCut, Vec_Ptr_t * vNodes ); +extern void If_ObjPrint( If_Obj_t * pObj ); /*=== abcRec.c ============================================================*/ +/*=== abcRec2.c ============================================================*/ +/*=== abcRec3.c ============================================================*/ extern int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut, If_Obj_t * pObj); extern int If_CutDelayRecCost2(If_Man_t* p, If_Cut_t* pCut, If_Obj_t * pObj); -/*=== abcRec2.c ============================================================*/ +extern int If_CutDelayRecCost3(If_Man_t* p, If_Cut_t* pCut, If_Obj_t * pObj); extern ABC_DLL int Abc_NtkRecIsRunning(); extern ABC_DLL int Abc_NtkRecIsRunning2(); +extern ABC_DLL int Abc_NtkRecIsRunning3(); // othe packages extern int Bat_ManCellFuncLookup( unsigned * pTruth, int nVars, int nLeaves ); diff --git a/src/map/if/ifMan.c b/src/map/if/ifMan.c index 3028e370..0ebdec1b 100644 --- a/src/map/if/ifMan.c +++ b/src/map/if/ifMan.c @@ -337,6 +337,7 @@ void If_ManCreateChoice( If_Man_t * p, If_Obj_t * pObj ) // mark the largest level if ( p->nLevelMax < (int)pObj->Level ) p->nLevelMax = (int)pObj->Level; + p->nChoices++; } /**Function************************************************************* @@ -410,8 +411,7 @@ void If_ManSetupCutTriv( If_Man_t * p, If_Cut_t * pCut, int ObjId ) // set up elementary truth table of the unit cut if ( p->pPars->fTruth ) { - int i, nTruthWords; - nTruthWords = pCut->nLimit <= 5 ? 1 : (1 << (pCut->nLimit - 5)); + int i, nTruthWords = If_CutTruthWords(pCut->nLimit); for ( i = 0; i < nTruthWords; i++ ) If_CutTruth(pCut)[i] = 0xAAAAAAAA; } diff --git a/src/map/if/ifMap.c b/src/map/if/ifMap.c index 6fcb8799..1f7ba898 100644 --- a/src/map/if/ifMap.c +++ b/src/map/if/ifMap.c @@ -75,7 +75,8 @@ float If_CutDelaySpecial( If_Man_t * p, If_Cut_t * pCut, int fCarry ) Delay = IF_MAX( Delay, Pin2Pin[fCarry][i] + DelayCur ); } return Delay; - } +} + /**Function************************************************************* @@ -157,12 +158,13 @@ void If_ObjPerformMappingAnd( If_Man_t * p, If_Obj_t * pObj, int Mode, int fPrep /// pCut->Delay = If_CutDelayLutStruct( p, pCut, p->pPars->pLutStruct, p->pPars->WireDelay ); if ( p->pPars->fUserRecLib ) { - if((Abc_NtkRecIsRunning2()&& Abc_NtkRecIsRunning()) || (!Abc_NtkRecIsRunning2()&& !Abc_NtkRecIsRunning())) - assert(0); - else if(Abc_NtkRecIsRunning()) - pCut->Delay = If_CutDelayRecCost(p, pCut, pObj); + assert( Abc_NtkRecIsRunning() + Abc_NtkRecIsRunning2() + Abc_NtkRecIsRunning3() == 1 ); + if ( Abc_NtkRecIsRunning3() ) + pCut->Delay = If_CutDelayRecCost3(p, pCut, pObj); + else if( Abc_NtkRecIsRunning2() ) + pCut->Delay = If_CutDelayRecCost2(p, pCut, pObj); else - pCut->Delay = If_CutDelayRecCost2(p, pCut, pObj); + pCut->Delay = If_CutDelayRecCost(p, pCut, pObj); } else if(p->pPars->fDelayOpt) pCut->Delay = If_CutDelaySopCost(p,pCut); @@ -211,8 +213,10 @@ void If_ObjPerformMappingAnd( If_Man_t * p, If_Obj_t * pObj, int Mode, int fPrep if ( p->pPars->fTruth ) { // clock_t clk = clock(); - int RetValue = If_CutComputeTruth( p, pCut, pCut0, pCut1, pObj->fCompl0, pObj->fCompl1 ); +// int RetValue = If_CutComputeTruth( p, pCut, pCut0, pCut1, pObj->fCompl0, pObj->fCompl1 ); + int RetValue = If_CutComputeTruth2( p, pCut, pCut0, pCut1, pObj->fCompl0, pObj->fCompl1 ); // p->timeTruth += clock() - clk; + pCut->fUseless = 0; if ( p->pPars->pFuncCell && RetValue < 2 ) { @@ -236,12 +240,13 @@ void If_ObjPerformMappingAnd( If_Man_t * p, If_Obj_t * pObj, int Mode, int fPrep /// pCut->Delay = If_CutDelayLutStruct( p, pCut, p->pPars->pLutStruct, p->pPars->WireDelay ); if ( p->pPars->fUserRecLib ) { - if((Abc_NtkRecIsRunning2()&& Abc_NtkRecIsRunning()) || (!Abc_NtkRecIsRunning2()&& !Abc_NtkRecIsRunning())) - assert(0); - else if(Abc_NtkRecIsRunning()) - pCut->Delay = If_CutDelayRecCost(p, pCut, pObj); - else + assert( Abc_NtkRecIsRunning() + Abc_NtkRecIsRunning2() + Abc_NtkRecIsRunning3() == 1 ); + if ( Abc_NtkRecIsRunning3() ) + pCut->Delay = If_CutDelayRecCost3(p, pCut, pObj); + else if( Abc_NtkRecIsRunning2() ) pCut->Delay = If_CutDelayRecCost2(p, pCut, pObj); + else + pCut->Delay = If_CutDelayRecCost(p, pCut, pObj); } else if (p->pPars->fDelayOpt) pCut->Delay = If_CutDelaySopCost(p, pCut); @@ -263,6 +268,7 @@ void If_ObjPerformMappingAnd( If_Man_t * p, If_Obj_t * pObj, int Mode, int fPrep pCut->AveRefs = (Mode == 0)? (float)0.0 : If_CutAverageRefs( p, pCut ); // insert the cut into storage If_CutSort( p, pCutSet, pCut ); +// If_CutTraverse( p, pObj, pCut ); } assert( pCutSet->nCuts > 0 ); diff --git a/src/map/if/ifTruth.c b/src/map/if/ifTruth.c index f0289695..4b0db8b4 100644 --- a/src/map/if/ifTruth.c +++ b/src/map/if/ifTruth.c @@ -19,6 +19,7 @@ ***********************************************************************/ #include "if.h" +#include "misc/util/utilTruth.h" ABC_NAMESPACE_IMPL_START @@ -43,29 +44,28 @@ ABC_NAMESPACE_IMPL_START SeeAlso [] ***********************************************************************/ -static inline int If_TruthWordNum( int nVars ) { return nVars <= 5 ? 1 : (1 << (nVars - 5)); } static inline void If_TruthNot( unsigned * pOut, unsigned * pIn, int nVars ) { int w; - for ( w = If_TruthWordNum(nVars)-1; w >= 0; w-- ) + for ( w = If_CutTruthWords(nVars)-1; w >= 0; w-- ) pOut[w] = ~pIn[w]; } static inline void If_TruthCopy( unsigned * pOut, unsigned * pIn, int nVars ) { int w; - for ( w = If_TruthWordNum(nVars)-1; w >= 0; w-- ) + for ( w = If_CutTruthWords(nVars)-1; w >= 0; w-- ) pOut[w] = pIn[w]; } static inline void If_TruthNand( unsigned * pOut, unsigned * pIn0, unsigned * pIn1, int nVars ) { int w; - for ( w = If_TruthWordNum(nVars)-1; w >= 0; w-- ) + for ( w = If_CutTruthWords(nVars)-1; w >= 0; w-- ) pOut[w] = ~(pIn0[w] & pIn1[w]); } static inline void If_TruthAnd( unsigned * pOut, unsigned * pIn0, unsigned * pIn1, int nVars ) { int w; - for ( w = If_TruthWordNum(nVars)-1; w >= 0; w-- ) + for ( w = If_CutTruthWords(nVars)-1; w >= 0; w-- ) pOut[w] = pIn0[w] & pIn1[w]; } @@ -89,7 +89,7 @@ void If_TruthSwapAdjacentVars( unsigned * pOut, unsigned * pIn, int nVars, int i { 0xF00FF00F, 0x00F000F0, 0x0F000F00 }, { 0xFF0000FF, 0x0000FF00, 0x00FF0000 } }; - int nWords = If_TruthWordNum( nVars ); + int nWords = If_CutTruthWords( nVars ); int i, k, Step, Shift; assert( iVar < nVars - 1 ); @@ -245,7 +245,7 @@ void If_TruthShrink( unsigned * pOut, unsigned * pIn, int nVars, int nVarsAll, u ***********************************************************************/ int If_CutTruthVarInSupport( unsigned * pTruth, int nVars, int iVar ) { - int nWords = If_TruthWordNum( nVars ); + int nWords = If_CutTruthWords( nVars ); int i, k, Step; assert( iVar < nVars ); @@ -449,6 +449,191 @@ int If_CutTruthMinimize( If_Man_t * p, If_Cut_t * pCut ) } + + +/**Function************************************************************* + + Synopsis [Performs truth table computation.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int If_CutTruthMinimize6( If_Man_t * p, If_Cut_t * pCut ) +{ + unsigned uSupport; + int i, k, nSuppSize; + int nVars = If_CutLeaveNum(pCut); + // compute the support of the cut's function + uSupport = Abc_Tt6SupportAndSize( *If_CutTruthW(pCut), nVars, &nSuppSize ); + if ( nSuppSize == If_CutLeaveNum(pCut) ) + return 0; +// TEMPORARY + if ( nSuppSize < 2 ) + { + p->nSmallSupp++; + return 2; + } + // update leaves and signature + pCut->uSign = 0; + for ( i = k = 0; i < nVars; i++ ) + { + if ( !(uSupport & (1 << i)) ) + continue; + pCut->uSign |= If_ObjCutSign( pCut->pLeaves[i] ); + if ( k < i ) + { + pCut->pLeaves[k] = pCut->pLeaves[i]; + Abc_TtSwapVars( If_CutTruthW(pCut), pCut->nLimit, k, i ); + } + k++; + } + assert( k == nSuppSize ); + pCut->nLeaves = nSuppSize; + // verify the result +// assert( nSuppSize == Abc_TtSupportSize(If_CutTruthW(pCut), nVars) ); + return 1; +} +static inline word If_TruthStretch6( word Truth, If_Cut_t * pCut, If_Cut_t * pCut0 ) +{ + int i, k; + for ( i = (int)pCut->nLeaves - 1, k = (int)pCut0->nLeaves - 1; i >= 0 && k >= 0; i-- ) + { + if ( pCut0->pLeaves[k] < pCut->pLeaves[i] ) + continue; + assert( pCut0->pLeaves[k] == pCut->pLeaves[i] ); + if ( k < i ) + Abc_TtSwapVars( &Truth, pCut->nLimit, k, i ); + k--; + } + return Truth; +} +static inline int If_CutComputeTruth6( If_Man_t * p, If_Cut_t * pCut, If_Cut_t * pCut0, If_Cut_t * pCut1, int fCompl0, int fCompl1 ) +{ + word t0 = (fCompl0 ^ pCut0->fCompl) ? ~*If_CutTruthW(pCut0) : *If_CutTruthW(pCut0); + word t1 = (fCompl1 ^ pCut1->fCompl) ? ~*If_CutTruthW(pCut1) : *If_CutTruthW(pCut1); + assert( pCut->nLimit <= 6 ); + t0 = If_TruthStretch6( t0, pCut, pCut0 ); + t1 = If_TruthStretch6( t1, pCut, pCut1 ); + *If_CutTruthW(pCut) = t0 & t1; + if ( p->pPars->fCutMin ) + return If_CutTruthMinimize6( p, pCut ); + return 0; +} + + +/**Function************************************************************* + + Synopsis [Performs truth table computation.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +// this procedure handles special case reductions +static inline int If_CutTruthMinimize21( If_Man_t * p, If_Cut_t * pCut ) +{ + word * pTruth = If_CutTruthW(pCut); + int i, k, nVars = If_CutLeaveNum(pCut); + unsigned uSign = 0; + for ( i = k = 0; i < nVars; i++ ) + { + if ( !Abc_TtHasVar( pTruth, nVars, i ) ) + continue; + uSign |= If_ObjCutSign( pCut->pLeaves[i] ); + if ( k < i ) + { + pCut->pLeaves[k] = pCut->pLeaves[i]; + Abc_TtSwapVars( pTruth, nVars, k, i ); + } + k++; + } + if ( k == nVars ) + return 0; + assert( k < nVars ); + pCut->nLeaves = k; + pCut->uSign = uSign; +// TEMPORARY + if ( pCut->nLeaves < 2 ) + { + p->nSmallSupp++; + return 2; + } + // verify the result + assert( If_CutLeaveNum(pCut) == Abc_TtSupportSize(pTruth, nVars) ); + return 1; +} +static inline int If_CutTruthMinimize2( If_Man_t * p, If_Cut_t * pCut ) +{ + unsigned uSupport; + int i, k, nSuppSize; + int nVars = If_CutLeaveNum(pCut); + // compute the support of the cut's function + uSupport = Abc_TtSupportAndSize( If_CutTruthW(pCut), nVars, &nSuppSize ); + if ( nSuppSize == If_CutLeaveNum(pCut) ) + return 0; +// TEMPORARY + if ( nSuppSize < 2 ) + { + p->nSmallSupp++; + return 2; + } + // update leaves and signature + pCut->uSign = 0; + for ( i = k = 0; i < nVars; i++ ) + { + if ( !(uSupport & (1 << i)) ) + continue; + pCut->uSign |= If_ObjCutSign( pCut->pLeaves[i] ); + if ( k < i ) + { + pCut->pLeaves[k] = pCut->pLeaves[i]; + Abc_TtSwapVars( If_CutTruthW(pCut), pCut->nLimit, k, i ); + } + k++; + } + assert( k == nSuppSize ); + pCut->nLeaves = nSuppSize; + // verify the result +// assert( nSuppSize == Abc_TtSupportSize(If_CutTruthW(pCut), nVars) ); + return 1; +} +static inline void If_TruthStretch2( word * pTruth, If_Cut_t * pCut, If_Cut_t * pCut0 ) +{ + int i, k; + for ( i = (int)pCut->nLeaves - 1, k = (int)pCut0->nLeaves - 1; i >= 0 && k >= 0; i-- ) + { + if ( pCut0->pLeaves[k] < pCut->pLeaves[i] ) + continue; + assert( pCut0->pLeaves[k] == pCut->pLeaves[i] ); + if ( k < i ) + Abc_TtSwapVars( pTruth, pCut->nLimit, k, i ); + k--; + } +} +inline int If_CutComputeTruth2( If_Man_t * p, If_Cut_t * pCut, If_Cut_t * pCut0, If_Cut_t * pCut1, int fCompl0, int fCompl1 ) +{ + int nWords; + if ( pCut->nLimit < 7 ) + return If_CutComputeTruth6( p, pCut, pCut0, pCut1, fCompl0, fCompl1 ); + nWords = Abc_TtWordNum( pCut->nLimit ); + Abc_TtCopy( (word *)p->puTemp[0], If_CutTruthW(pCut0), nWords, fCompl0 ^ pCut0->fCompl ); + Abc_TtCopy( (word *)p->puTemp[1], If_CutTruthW(pCut1), nWords, fCompl1 ^ pCut1->fCompl ); + If_TruthStretch2( (word *)p->puTemp[0], pCut, pCut0 ); + If_TruthStretch2( (word *)p->puTemp[1], pCut, pCut1 ); + Abc_TtAnd( If_CutTruthW(pCut), (word *)p->puTemp[0], (word *)p->puTemp[1], nWords, 0 ); + if ( p->pPars->fCutMin ) + return If_CutTruthMinimize2( p, pCut ); + return 0; +} + + //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/map/if/ifUtil.c b/src/map/if/ifUtil.c index 4d904613..b8b03d70 100644 --- a/src/map/if/ifUtil.c +++ b/src/map/if/ifUtil.c @@ -769,6 +769,90 @@ int If_ManCountSpecialPos( If_Man_t * p ) } +/**Function************************************************************* + + Synopsis [Traverse the cut and counts its volume.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static void If_CutTraverse_rec( If_Obj_t * pNode, Vec_Ptr_t * vNodes ) +{ + if ( pNode->fMark ) + return; + pNode->fMark = 1; +// assert( !If_ObjIsCi(pNode) ); // does not hold with cut minimization + if ( If_ObjIsAnd(pNode) ) + If_CutTraverse_rec( If_ObjFanin0(pNode), vNodes ); + if ( If_ObjIsAnd(pNode) ) + If_CutTraverse_rec( If_ObjFanin1(pNode), vNodes ); + Vec_PtrPush( vNodes, pNode ); +} +void If_CutTraverse( If_Man_t * p, If_Obj_t * pRoot, If_Cut_t * pCut, Vec_Ptr_t * vNodes ) +{ + If_Obj_t * pLeaf; + int i; + // collect the internal nodes of the cut + Vec_PtrClear( vNodes ); + If_CutForEachLeaf( p, pCut, pLeaf, i ) + { + Vec_PtrPush( vNodes, pLeaf ); + assert( pLeaf->fMark == 0 ); + pLeaf->fMark = 1; + } + // collect other nodes + If_CutTraverse_rec( pRoot, vNodes ); + // clean the mark + Vec_PtrForEachEntry( If_Obj_t *, vNodes, pLeaf, i ) + pLeaf->fMark = 0; +} +void If_CutTraverseTest( If_Man_t * p, If_Obj_t * pRoot, If_Cut_t * pCut ) +{ + Vec_Ptr_t * vNodes; + vNodes = Vec_PtrAlloc( 1000 ); + If_CutTraverse( p, pRoot, pCut, vNodes ); +//if ( Vec_PtrSize(vNodes) > 30 ) +//printf( "%d ", Vec_PtrSize(vNodes) ); + Vec_PtrFree( vNodes ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void If_ObjPrint( If_Obj_t * pObj ) +{ + if ( pObj == NULL ) + { + printf( "Object is NULL." ); + return; + } + printf( "Obj %4d : ", If_ObjId(pObj) ); + if ( If_ObjIsConst1(pObj) ) + printf( "constant 1" ); + else if ( If_ObjIsCi(pObj) ) + printf( "PI" ); + else if ( If_ObjIsCo(pObj) ) + printf( "PO( %4d%s )", If_ObjId(If_ObjFanin0(pObj)), (If_ObjFaninC0(pObj)? "\'" : " ") ); + else + printf( "AND( %4d%s, %4d%s )", + If_ObjId(If_ObjFanin0(pObj)), (If_ObjFaninC0(pObj)? "\'" : " "), + If_ObjId(If_ObjFanin1(pObj)), (If_ObjFaninC1(pObj)? "\'" : " ") ); + printf( " (refs = %3d)", pObj->nVisitsCopy ); + printf( "\n" ); +} + //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/map/scl/sclTime.c b/src/map/scl/sclTime.c index 66a28b51..4e3b3de8 100644 --- a/src/map/scl/sclTime.c +++ b/src/map/scl/sclTime.c @@ -109,6 +109,7 @@ static inline void Abc_SclTimeNodePrint( SC_Man * p, Abc_Obj_t * pObj, int fRise { printf( "%7d : ", Abc_ObjId(pObj) ); printf( "%d ", Abc_ObjFaninNum(pObj) ); + printf( "%d ", Abc_ObjFanoutNum(pObj) ); printf( "%-*s ", Length, Abc_SclObjCell(p, pObj)->pName ); if ( fRise >= 0 ) printf( "(%s) ", fRise ? "rise" : "fall" ); diff --git a/src/misc/util/abc_global.h b/src/misc/util/abc_global.h index 03474a04..3259fa0d 100644 --- a/src/misc/util/abc_global.h +++ b/src/misc/util/abc_global.h @@ -52,9 +52,11 @@ #endif // catch memory leaks in Visual Studio -#ifdef _DEBUG -#define _CRTDBG_MAP_ALLOC -#include <crtdbg.h> +#ifdef WIN32 + #ifdef _DEBUG + #define _CRTDBG_MAP_ALLOC + #include <crtdbg.h> + #endif #endif #if !defined(___unused) diff --git a/src/misc/util/utilTruth.h b/src/misc/util/utilTruth.h new file mode 100644 index 00000000..6bfb5699 --- /dev/null +++ b/src/misc/util/utilTruth.h @@ -0,0 +1,422 @@ +/**CFile**************************************************************** + + FileName [utilTruth.h] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [Truth table manipulation.] + + Synopsis [Truth table manipulation.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - October 28, 2012.] + + Revision [$Id: utilTruth.h,v 1.00 2012/10/28 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#ifndef ABC__misc__util__utilTruth_h +#define ABC__misc__util__utilTruth_h + +//////////////////////////////////////////////////////////////////////// +/// INCLUDES /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// PARAMETERS /// +//////////////////////////////////////////////////////////////////////// + +ABC_NAMESPACE_HEADER_START + +//////////////////////////////////////////////////////////////////////// +/// BASIC TYPES /// +//////////////////////////////////////////////////////////////////////// + +static word s_Truths6[6] = { + 0xAAAAAAAAAAAAAAAA, + 0xCCCCCCCCCCCCCCCC, + 0xF0F0F0F0F0F0F0F0, + 0xFF00FF00FF00FF00, + 0xFFFF0000FFFF0000, + 0xFFFFFFFF00000000 +}; + +//////////////////////////////////////////////////////////////////////// +/// MACRO DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Abc_TtWordNum( int nVars ) { return nVars <= 6 ? 1 : 1 << (nVars-6); } + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Abc_TtCopy( word * pOut, word * pIn, int nWords, int fCompl ) +{ + int w; + if ( fCompl ) + for ( w = 0; w < nWords; w++ ) + pOut[w] = ~pIn[w]; + else + for ( w = 0; w < nWords; w++ ) + pOut[w] = pIn[w]; +} +static inline void Abc_TtAnd( word * pOut, word * pIn1, word * pIn2, int nWords, int fCompl ) +{ + int w; + if ( fCompl ) + for ( w = 0; w < nWords; w++ ) + pOut[w] = ~(pIn1[w] & pIn2[w]); + else + for ( w = 0; w < nWords; w++ ) + pOut[w] = pIn1[w] & pIn2[w]; +} + + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Abc_TtSuppIsMinBase( int Supp ) +{ + return (Supp & (Supp+1)) == 0; +} +static inline int Abc_Tt6HasVar( word t, int iVar ) +{ + return ((t << (1<<iVar)) & s_Truths6[iVar]) != (t & s_Truths6[iVar]); +} +static inline int Abc_TtHasVar( word * t, int nVars, int iVar ) +{ + int nWords = Abc_TtWordNum( nVars ); + assert( iVar < nVars ); + if ( iVar < 6 ) + { + int i, Shift = (1 << iVar); + for ( i = 0; i < nWords; i++ ) + if ( ((t[i] << Shift) & s_Truths6[iVar]) != (t[i] & s_Truths6[iVar]) ) + return 1; + return 0; + } + else + { + int i, Step = (1 << (iVar - 6)); + word * tLimit = t + nWords; + for ( ; t < tLimit; t += 2*Step ) + for ( i = 0; i < Step; i++ ) + if ( t[i] != t[Step+i] ) + return 1; + return 0; + } +} +static inline int Abc_TtSupport( word * t, int nVars ) +{ + int v, Supp = 0; + for ( v = 0; v < nVars; v++ ) + if ( Abc_TtHasVar( t, nVars, v ) ) + Supp |= (1 << v); + return Supp; +} +static inline int Abc_TtSupportSize( word * t, int nVars ) +{ + int v, SuppSize = 0; + for ( v = 0; v < nVars; v++ ) + if ( Abc_TtHasVar( t, nVars, v ) ) + SuppSize++; + return SuppSize; +} +static inline int Abc_TtSupportAndSize( word * t, int nVars, int * pSuppSize ) +{ + int v, Supp = 0; + *pSuppSize = 0; + for ( v = 0; v < nVars; v++ ) + if ( Abc_TtHasVar( t, nVars, v ) ) + Supp |= (1 << v), (*pSuppSize)++; + return Supp; +} +static inline int Abc_Tt6SupportAndSize( word t, int nVars, int * pSuppSize ) +{ + int v, Supp = 0; + *pSuppSize = 0; + assert( nVars <= 6 ); + for ( v = 0; v < nVars; v++ ) + if ( Abc_Tt6HasVar( t, v ) ) + Supp |= (1 << v), (*pSuppSize)++; + return Supp; +} + + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Abc_TtSwapVars( word * pTruth, int nVars, int iVar, int jVar ) +{ + static word PPMasks[5][6][3] = { + { + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 0 0 + { 0x9999999999999999, 0x2222222222222222, 0x4444444444444444 }, // 0 1 + { 0xA5A5A5A5A5A5A5A5, 0x0A0A0A0A0A0A0A0A, 0x5050505050505050 }, // 0 2 + { 0xAA55AA55AA55AA55, 0x00AA00AA00AA00AA, 0x5500550055005500 }, // 0 3 + { 0xAAAA5555AAAA5555, 0x0000AAAA0000AAAA, 0x5555000055550000 }, // 0 4 + { 0xAAAAAAAA55555555, 0x00000000AAAAAAAA, 0x5555555500000000 } // 0 5 + }, + { + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 1 0 + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 1 1 + { 0xC3C3C3C3C3C3C3C3, 0x0C0C0C0C0C0C0C0C, 0x3030303030303030 }, // 1 2 + { 0xCC33CC33CC33CC33, 0x00CC00CC00CC00CC, 0x3300330033003300 }, // 1 3 + { 0xCCCC3333CCCC3333, 0x0000CCCC0000CCCC, 0x3333000033330000 }, // 1 4 + { 0xCCCCCCCC33333333, 0x00000000CCCCCCCC, 0x3333333300000000 } // 1 5 + }, + { + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 2 0 + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 2 1 + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 2 2 + { 0xF00FF00FF00FF00F, 0x00F000F000F000F0, 0x0F000F000F000F00 }, // 2 3 + { 0xF0F00F0FF0F00F0F, 0x0000F0F00000F0F0, 0x0F0F00000F0F0000 }, // 2 4 + { 0xF0F0F0F00F0F0F0F, 0x00000000F0F0F0F0, 0x0F0F0F0F00000000 } // 2 5 + }, + { + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 3 0 + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 3 1 + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 3 2 + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 3 3 + { 0xFF0000FFFF0000FF, 0x0000FF000000FF00, 0x00FF000000FF0000 }, // 3 4 + { 0xFF00FF0000FF00FF, 0x00000000FF00FF00, 0x00FF00FF00000000 } // 3 5 + }, + { + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 4 0 + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 4 1 + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 4 2 + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 4 3 + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000 }, // 4 4 + { 0xFFFF00000000FFFF, 0x00000000FFFF0000, 0x0000FFFF00000000 } // 4 5 + } + }; + if ( iVar == jVar ) + return; + if ( jVar < iVar ) + ABC_SWAP( int, iVar, jVar ); + assert( iVar < jVar && jVar < nVars ); + if ( nVars <= 6 ) + { + word * pMasks = PPMasks[iVar][jVar]; + int shift = (1 << jVar) - (1 << iVar); + pTruth[0] = (pTruth[0] & pMasks[0]) | ((pTruth[0] & pMasks[1]) << shift) | ((pTruth[0] & pMasks[2]) >> shift); + } + else + { + if ( jVar <= 5 ) + { + word * pMasks = PPMasks[iVar][jVar]; + int nWords = Abc_TtWordNum(nVars); + int w, shift = (1 << jVar) - (1 << iVar); + for ( w = 0; w < nWords; w++ ) + pTruth[w] = (pTruth[w] & pMasks[0]) | ((pTruth[w] & pMasks[1]) << shift) | ((pTruth[w] & pMasks[2]) >> shift); + } + else if ( iVar <= 5 && jVar > 5 ) + { + word low2High, high2Low; + word * pLimit = pTruth + Abc_TtWordNum(nVars); + int j, jStep = Abc_TtWordNum(jVar); + int shift = 1 << iVar; + for ( ; pTruth < pLimit; pTruth += 2*jStep ) + for ( j = 0; j < jStep; j++ ) + { + low2High = (pTruth[j] & s_Truths6[iVar]) >> shift; + high2Low = (pTruth[j+jStep] << shift) & s_Truths6[iVar]; + pTruth[j] = (pTruth[j] & ~s_Truths6[iVar]) | high2Low; + pTruth[j+jStep] = (pTruth[j+jStep] & s_Truths6[iVar]) | low2High; + } + } + else + { + word temp, * pLimit = pTruth + Abc_TtWordNum(nVars); + int i, iStep = Abc_TtWordNum(iVar); + int j, jStep = Abc_TtWordNum(jVar); + for ( ; pTruth < pLimit; pTruth += 2*jStep ) + for ( i = 0; i < jStep; i += 2*iStep ) + for ( j = 0; j < iStep; j++ ) + { + temp = pTruth[iStep + i + j]; + pTruth[iStep + i + j] = pTruth[jStep + i + j]; + pTruth[jStep + i + j] = temp; + } + } + } +} + +static inline void Abc_TtSwapVars_( word * pTruth, int nVars, int iVar, int jVar ) +{ + static word PPMasks[6][6] = { + { 0x2222222222222222, 0x0A0A0A0A0A0A0A0A, 0x00AA00AA00AA00AA, 0x0000AAAA0000AAAA, 0x00000000AAAAAAAA, 0xAAAAAAAAAAAAAAAA }, + { 0x0000000000000000, 0x0C0C0C0C0C0C0C0C, 0x00CC00CC00CC00CC, 0x0000CCCC0000CCCC, 0x00000000CCCCCCCC, 0xCCCCCCCCCCCCCCCC }, + { 0x0000000000000000, 0x0000000000000000, 0x00F000F000F000F0, 0x0000F0F00000F0F0, 0x00000000F0F0F0F0, 0xF0F0F0F0F0F0F0F0 }, + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000FF000000FF00, 0x00000000FF00FF00, 0xFF00FF00FF00FF00 }, + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x00000000FFFF0000, 0xFFFF0000FFFF0000 }, + { 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0x0000000000000000, 0xFFFFFFFF00000000 } + }; + if ( nVars <= 6 ) + { + int shift; + word low2High, high2Low; + assert( iVar <= 5 && jVar <= 5 && iVar < jVar ); + shift = (1 << jVar) - (1 << iVar); + low2High = (pTruth[0] & PPMasks[iVar][jVar - 1] ) << shift; + pTruth[0] &= ~PPMasks[iVar][jVar - 1]; + high2Low = (pTruth[0] & (PPMasks[iVar][jVar - 1] << shift )) >> shift; + pTruth[0] &= ~(PPMasks[iVar][jVar - 1] << shift); + pTruth[0] |= low2High | high2Low; + } + else + { + word low2High, high2Low, temp; + int nWords = Abc_TtWordNum(nVars); + int shift, step, iStep, jStep; + int w = 0, i = 0, j = 0; + if ( iVar == jVar ) + return; + if ( jVar < iVar ) + ABC_SWAP( int, iVar, jVar ); + if ( iVar <= 5 && jVar <= 5 ) + { + shift = (1 << jVar) - (1 << iVar); + for ( w = 0; w < nWords; w++ ) + { + low2High = (pTruth[w] & PPMasks[iVar][jVar - 1] ) << shift; + pTruth[w] &= ~PPMasks[iVar][jVar - 1]; + high2Low = (pTruth[w] & (PPMasks[iVar][jVar - 1] << shift )) >> shift; + pTruth[w] &= ~(PPMasks[iVar][jVar - 1] << shift); + pTruth[w] |= low2High | high2Low; + } + } + else if ( iVar <= 5 && jVar > 5 ) + { + step = Abc_TtWordNum(jVar + 1)/2; + shift = 1 << iVar; + for ( w = 0; w < nWords; w += 2*step ) + { + for (j = 0; j < step; j++) + { + low2High = (pTruth[w + j] & PPMasks[iVar][5]) >> shift; + pTruth[w + j] &= ~PPMasks[iVar][5]; + high2Low = (pTruth[w + step + j] & (PPMasks[iVar][5] >> shift)) << shift; + pTruth[w + step + j] &= ~(PPMasks[iVar][5] >> shift); + pTruth[w + j] |= high2Low; + pTruth[w + step + j] |= low2High; + } + } + } + else + { + iStep = Abc_TtWordNum(iVar + 1)/2; + jStep = Abc_TtWordNum(jVar + 1)/2; + for (w = 0; w < nWords; w += 2*jStep) + { + for (i = 0; i < jStep; i += 2*iStep) + { + for (j = 0; j < iStep; j++) + { + temp = pTruth[w + iStep + i + j]; + pTruth[w + iStep + i + j] = pTruth[w + jStep + i + j]; + pTruth[w + jStep + i + j] = temp; + } + } + } + } + } +} + + + +/**Function************************************************************* + + Synopsis [Stretch truthtable to have more input variables.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static void Abc_TtStretch5( unsigned * pInOut, int nVarS, int nVarB ) +{ + int w, i, step, nWords; + if ( nVarS == nVarB ) + return; + assert( nVarS < nVarB ); + step = Abc_TruthWordNum(nVarS); + nWords = Abc_TruthWordNum(nVarB); + if ( step == nWords ) + return; + assert( step < nWords ); + for ( w = 0; w < nWords; w += step ) + for ( i = 0; i < step; i++ ) + pInOut[w + i] = pInOut[i]; +} +static void Abc_TtStretch6( word * pInOut, int nVarS, int nVarB ) +{ + int w, i, step, nWords; + if ( nVarS == nVarB ) + return; + assert( nVarS < nVarB ); + step = Abc_Truth6WordNum(nVarS); + nWords = Abc_Truth6WordNum(nVarB); + if ( step == nWords ) + return; + assert( step < nWords ); + for ( w = 0; w < nWords; w += step ) + for ( i = 0; i < step; i++ ) + pInOut[w + i] = pInOut[i]; +} + +/*=== utilTruth.c ===========================================================*/ + + +ABC_NAMESPACE_HEADER_END + +#endif + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// diff --git a/src/misc/vec/vecMem.h b/src/misc/vec/vecMem.h index 229c53a2..eaa9481f 100644 --- a/src/misc/vec/vecMem.h +++ b/src/misc/vec/vecMem.h @@ -57,14 +57,16 @@ struct Vec_Mem_t_ int nPageAlloc; // number of pages currently allocated int iPage; // the number of a page currently used word ** ppPages; // memory pages + Vec_Int_t * vTable; // hash table + Vec_Int_t * vNexts; // next pointers }; //////////////////////////////////////////////////////////////////////// /// MACRO DEFINITIONS /// //////////////////////////////////////////////////////////////////////// -#define Vec_MemForEachEntry( vVec, pEntry, i ) \ - for ( i = 0; (i < Vec_MemEntryNum(vVec)) && ((pEntry) = Vec_MemReadEntry(vVec, i)); i++ ) +#define Vec_MemForEachEntry( p, pEntry, i ) \ + for ( i = 0; (i < Vec_MemEntryNum(p)) && ((pEntry) = Vec_MemReadEntry(p, i)); i++ ) //////////////////////////////////////////////////////////////////////// /// FUNCTION DEFINITIONS /// @@ -266,12 +268,12 @@ static inline void Vec_MemShrink( Vec_Mem_t * p, int nEntriesNew ) SeeAlso [] ***********************************************************************/ -static inline void Vec_MemPrint( Vec_Mem_t * vVec ) +static inline void Vec_MemPrint( Vec_Mem_t * p ) { word * pEntry; int i; - printf( "Memory vector has %d entries: ", Vec_MemEntryNum(vVec) ); - Vec_MemForEachEntry( vVec, pEntry, i ) + printf( "Memory vector has %d entries: ", Vec_MemEntryNum(p) ); + Vec_MemForEachEntry( p, pEntry, i ) { printf( "%3d : ", i ); // add printout here @@ -279,6 +281,76 @@ static inline void Vec_MemPrint( Vec_Mem_t * vVec ) } } +/**Function************************************************************* + + Synopsis [Hashing entries in the memory vector.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline void Vec_MemHashAlloc( Vec_Mem_t * p, int nTableSize ) +{ + assert( p->vTable == NULL && p->vNexts == NULL ); + p->vTable = Vec_IntStartFull( Abc_PrimeCudd(nTableSize) ); + p->vNexts = Vec_IntAlloc( nTableSize ); +} +static inline void Vec_MemHashFree( Vec_Mem_t * p ) +{ + Vec_IntFreeP( &p->vTable ); + Vec_IntFreeP( &p->vNexts ); +} +static inline unsigned Vec_MemHashKey( Vec_Mem_t * p, word * pEntry ) +{ + static int s_Primes[8] = { 1699, 4177, 5147, 5647, 6343, 7103, 7873, 8147 }; + int i, nData = 2 * p->nEntrySize; + unsigned * pData = (unsigned *)pEntry; + unsigned uHash = 0; + for ( i = 0; i < nData; i++ ) + uHash += pData[i] * s_Primes[i & 0x7]; + return uHash % Vec_IntSize(p->vTable); +} +static int * Vec_MemHashLookup( Vec_Mem_t * p, word * pEntry ) +{ + int * pSpot = Vec_IntEntryP( p->vTable, Vec_MemHashKey(p, pEntry) ); + for ( ; *pSpot != -1; pSpot = Vec_IntEntryP(p->vNexts, *pSpot) ) + if ( !memcmp( Vec_MemReadEntry(p, *pSpot), pEntry, sizeof(word) * p->nEntrySize ) ) // equal + return pSpot; + return pSpot; +} +static void Vec_MemHashResize( Vec_Mem_t * p ) +{ + word * pEntry; + int i, * pSpot; + Vec_IntFill( p->vTable, Abc_PrimeCudd(2 * Vec_IntSize(p->vTable)), -1 ); + Vec_IntClear( p->vNexts ); + Vec_MemForEachEntry( p, pEntry, i ) + { + pSpot = Vec_MemHashLookup( p, pEntry ); + assert( *pSpot == -1 ); + *pSpot = Vec_IntSize(p->vNexts); + Vec_IntPush( p->vNexts, -1 ); + } + assert( p->nEntries == Vec_IntSize(p->vNexts) ); +} +static int Vec_MemHashInsert( Vec_Mem_t * p, word * pEntry ) +{ + int * pSpot; + if ( p->nEntries > Vec_IntSize(p->vTable) ) + Vec_MemHashResize( p ); + pSpot = Vec_MemHashLookup( p, pEntry ); + if ( *pSpot != -1 ) + return *pSpot; + *pSpot = Vec_IntSize(p->vNexts); + Vec_IntPush( p->vNexts, -1 ); + Vec_MemPush( p, pEntry ); + assert( p->nEntries == Vec_IntSize(p->vNexts) ); + return Vec_IntSize(p->vNexts) - 1; +} + ABC_NAMESPACE_HEADER_END diff --git a/src/opt/dau/dauDsd.c b/src/opt/dau/dauDsd.c index 6f970b62..f6367304 100644 --- a/src/opt/dau/dauDsd.c +++ b/src/opt/dau/dauDsd.c @@ -19,6 +19,7 @@ ***********************************************************************/ #include "dauInt.h" +#include "misc/util/utilTruth.h" ABC_NAMESPACE_IMPL_START @@ -443,7 +444,7 @@ void Dau_DsdTestOne( word t, int i ) { word t2; char * p = Dau_DsdPerform( t ); -// return; + return; t2 = Dau_DsdToTruth( p ); if ( t != t2 ) { @@ -463,6 +464,344 @@ void Dau_DsdTestOne( word t, int i ) Dau_DsdTestOne( *p->pFuncs[i], i ); */ + + + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Abc_TtTruthIsConst0( word * p, int nWords ) { int w; for ( w = 0; w < nWords; w++ ) if ( p[w] != 0 ) return 0; return 1; } +static inline int Abc_TtTruthIsConst1( word * p, int nWords ) { int w; for ( w = 0; w < nWords; w++ ) if ( p[w] != ~(word)0 ) return 0; return 1; } + +static inline int Abc_TtCof0IsConst0( word * t, int nWords, int iVar ) +{ + if ( iVar < 6 ) + { + int i; + for ( i = 0; i < nWords; i++ ) + if ( t[i] & ~s_Truths6[iVar] ) + return 0; + return 1; + } + else + { + int i, Step = (1 << (iVar - 6)); + word * tLimit = t + nWords; + for ( ; t < tLimit; t += 2*Step ) + for ( i = 0; i < Step; i++ ) + if ( t[i] ) + return 0; + return 1; + } +} +static inline int Abc_TtCof0IsConst1( word * t, int nWords, int iVar ) +{ + if ( iVar < 6 ) + { + int i; + for ( i = 0; i < nWords; i++ ) + if ( (t[i] & ~s_Truths6[iVar]) != ~s_Truths6[iVar] ) + return 0; + return 1; + } + else + { + int i, Step = (1 << (iVar - 6)); + word * tLimit = t + nWords; + for ( ; t < tLimit; t += 2*Step ) + for ( i = 0; i < Step; i++ ) + if ( t[i] != ~(word)0 ) + return 0; + return 1; + } +} +static inline int Abc_TtCof1IsConst0( word * t, int nWords, int iVar ) +{ + if ( iVar < 6 ) + { + int i; + for ( i = 0; i < nWords; i++ ) + if ( t[i] & s_Truths6[iVar] ) + return 0; + return 1; + } + else + { + int i, Step = (1 << (iVar - 6)); + word * tLimit = t + nWords; + for ( ; t < tLimit; t += 2*Step ) + for ( i = 0; i < Step; i++ ) + if ( t[i+Step] ) + return 0; + return 1; + } +} +static inline int Abc_TtCof1IsConst1( word * t, int nWords, int iVar ) +{ + if ( iVar < 6 ) + { + int i; + for ( i = 0; i < nWords; i++ ) + if ( (t[i] & s_Truths6[iVar]) != s_Truths6[iVar] ) + return 0; + return 1; + } + else + { + int i, Step = (1 << (iVar - 6)); + word * tLimit = t + nWords; + for ( ; t < tLimit; t += 2*Step ) + for ( i = 0; i < Step; i++ ) + if ( t[i+Step] != ~(word)0 ) + return 0; + return 1; + } +} +static inline int Abc_TtCofsOpposite( word * t, int nWords, int iVar ) +{ + if ( iVar < 6 ) + { + int i, Shift = (1 << iVar); + for ( i = 0; i < nWords; i++ ) + if ( ((t[i] << Shift) & s_Truths6[iVar]) != (~t[i] & s_Truths6[iVar]) ) + return 0; + return 1; + } + else + { + int i, Step = (1 << (iVar - 6)); + word * tLimit = t + nWords; + for ( ; t < tLimit; t += 2*Step ) + for ( i = 0; i < Step; i++ ) + if ( t[i] != ~t[i+Step] ) + return 0; + return 1; + } +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +static inline int Abc_TtCof0HasVar( word * t, int nWords, int iVarI, int iVarJ ) +{ + assert( iVarI > iVarJ ); + if ( iVarI < 6 ) + { + int i, Shift = (1 << iVarJ); + for ( i = 0; i < nWords; i++ ) + if ( (((t[i] & ~s_Truths6[iVarI]) << Shift) & s_Truths6[iVarJ]) != ((t[i] & ~s_Truths6[iVarI]) & s_Truths6[iVarJ]) ) + return 0; + return 1; + } + else if ( iVarI == 6 ) + { + } + else + { + int i, Step = (1 << (iVarJ - 6)); + word * tLimit = t + nWords; + for ( ; t < tLimit; t += 2*Step ) + for ( i = 0; i < Step; i++ ) + if ( t[i] != t[i+Step] ) + return 0; + return 1; + } +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Dau_DsdMinimize( word * p, int * pVars, int nVars ) +{ + int i, k; + assert( nVars > 6 ); + for ( i = k = nVars - 1; i >= 0; i-- ) + { + if ( Abc_TtHasVar( p, nVars, i ) ) + continue; + if ( i < k ) + { + pVars[i] = pVars[k]; + Abc_TtSwapVars( p, nVars, i, k ); + } + k--; + nVars--; + } + return nVars; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Dau_DsdRun6_rec( word * p, int * pVars, int nVars, char * pBuffer, int Pos, char pStore[16][16], int Func ) +{ + return 0; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Dau_DsdRun_rec( word * p, int * pVars, int nVars, char * pBuffer, int Pos, char pStore[16][16], int Func ) +{ + int v, nWords = Abc_TtWordNum( nVars ); + nVars = Dau_DsdMinimize( p, pVars, nVars ); + if ( nVars <= 6 ) + return Dau_DsdRun6_rec( p, pVars, nVars, pBuffer, Pos, pStore, Func ); + if ( p[0] & 1 ) + { + // check for !(ax) + for ( v = 0; v < nVars; v++ ) + if ( Abc_TtCof0IsConst0( p, nWords, v ) ) + { + pBuffer[Pos++] = '('; + pBuffer[Pos++] = 'a' + pVars[v]; + Abc_TtSwapVars( p, nVars, v, nVars - 1 ); + pVars[v] = pVars[nVars-1]; + Pos = Dau_DsdRun_rec( p + nWords/2, pVars, nVars-1, pBuffer, Pos, pStore, Func ); + pBuffer[Pos++] = ')'; + return Pos; + } + } + else + { + // check for ax + for ( v = 0; v < nVars; v++ ) + if ( Abc_TtCof0IsConst1( p, nWords, v ) ) + { + pBuffer[Pos++] = '!'; + pBuffer[Pos++] = '('; + pBuffer[Pos++] = 'a' + pVars[v]; + Abc_TtSwapVars( p, nVars, v, nVars - 1 ); + pVars[v] = pVars[nVars-1]; + Pos = Dau_DsdRun_rec( p + nWords/2, pVars, nVars-1, pBuffer, Pos, pStore, Func ); + pBuffer[Pos++] = ')'; + return Pos; + } + } + if ( (p[nWords-1] >> 63) & 1 ) + { + // check for !(!ax) + for ( v = 0; v < nVars; v++ ) + if ( Abc_TtCof0IsConst1( p, nWords, v ) ) + { + pBuffer[Pos++] = '!'; + pBuffer[Pos++] = '('; + pBuffer[Pos++] = '!'; + pBuffer[Pos++] = 'a' + pVars[v]; + Abc_TtSwapVars( p, nVars, v, nVars - 1 ); + pVars[v] = pVars[nVars-1]; + Pos = Dau_DsdRun_rec( p, pVars, nVars-1, pBuffer, Pos, pStore, Func ); + pBuffer[Pos++] = ')'; + return Pos; + } + } + else + { + // check for !ax + for ( v = 0; v < nVars; v++ ) + if ( Abc_TtCof1IsConst0( p, nWords, v ) ) + { + pBuffer[Pos++] = '('; + pBuffer[Pos++] = '!'; + pBuffer[Pos++] = 'a' + pVars[v]; + Abc_TtSwapVars( p, nVars, v, nVars - 1 ); + pVars[v] = pVars[nVars-1]; + Pos = Dau_DsdRun_rec( p, pVars, nVars-1, pBuffer, Pos, pStore, Func ); + pBuffer[Pos++] = ')'; + return Pos; + } + } + // check for a^x + for ( v = 0; v < nVars; v++ ) + if ( Abc_TtCofsOpposite( p, nWords, v ) ) + { + pBuffer[Pos++] = '['; + pBuffer[Pos++] = 'a' + pVars[v]; + Abc_TtSwapVars( p, nVars, v, nVars - 1 ); + pVars[v] = pVars[nVars-1]; + Pos = Dau_DsdRun_rec( p, pVars, nVars-1, pBuffer, Pos, pStore, Func ); + pBuffer[Pos++] = ']'; + return Pos; + } + + return 0; +} + + + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +char * Dau_DsdRun( word * p, int nVars ) +{ + static char pBuffer[DAU_MAX_STR+20]; + static char pStore[16][16]; + int nWords = Abc_TtWordNum( nVars ); + int i, Pos = 0, Func = 0, pVars[16]; + assert( nVars <= 16 ); + for ( i = 0; i < nVars; i++ ) + pVars[i] = i; + if ( Abc_TtTruthIsConst0( p, nWords ) ) + pBuffer[Pos++] = '0'; + else if ( Abc_TtTruthIsConst1( p, nWords ) ) + pBuffer[Pos++] = '1'; + else if ( nVars <= 6 ) + Pos = Dau_DsdRun6_rec( p, pVars, nVars, pBuffer, Pos, pStore, Func ); + else + Pos = Dau_DsdRun_rec( p, pVars, nVars, pBuffer, Pos, pStore, Func ); + pBuffer[Pos++] = 0; + Dau_DsdCleanBraces( pBuffer ); + return pBuffer; +} + //////////////////////////////////////////////////////////////////////// /// END OF FILE /// //////////////////////////////////////////////////////////////////////// diff --git a/src/opt/dau/dauEnum.c b/src/opt/dau/dauEnum.c new file mode 100644 index 00000000..58e44c02 --- /dev/null +++ b/src/opt/dau/dauEnum.c @@ -0,0 +1,253 @@ +/**CFile**************************************************************** + + FileName [dauEnum.c] + + SystemName [ABC: Logic synthesis and verification system.] + + PackageName [DAG-aware unmapping.] + + Synopsis [Enumeration of decompositions.] + + Author [Alan Mishchenko] + + Affiliation [UC Berkeley] + + Date [Ver. 1.0. Started - June 20, 2005.] + + Revision [$Id: dauEnum.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $] + +***********************************************************************/ + +#include "dauInt.h" + +ABC_NAMESPACE_IMPL_START + +//////////////////////////////////////////////////////////////////////// +/// DECLARATIONS /// +//////////////////////////////////////////////////////////////////////// + + +//////////////////////////////////////////////////////////////////////// +/// FUNCTION DEFINITIONS /// +//////////////////////////////////////////////////////////////////////// + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +char * Dau_EnumLift( char * pName, int Shift ) +{ + static char pBuffer[64]; + char * pTemp; + for ( pTemp = pBuffer; *pName; pTemp++, pName++ ) + *pTemp = (*pName >= 'a' && *pName <= 'z') ? *pName + Shift : *pName; + *pTemp = 0; + return pBuffer; +} +char * Dau_EnumLift2( char * pName, int Shift ) +{ + static char pBuffer[64]; + char * pTemp; + for ( pTemp = pBuffer; *pName; pTemp++, pName++ ) + *pTemp = (*pName >= 'a' && *pName <= 'z') ? *pName + Shift : *pName; + *pTemp = 0; + return pBuffer; +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Dau_EnumCombineTwo( Vec_Ptr_t * vOne, int fStar, int fXor, char * pName1, char * pName2, int Shift2, int fCompl1, int fCompl2 ) +{ + static char pBuffer[256]; + pName2 = Dau_EnumLift( pName2, Shift2 ); + sprintf( pBuffer, "%s%c%s%s%s%s%c", + fStar?"*":"", + fXor?'[':'(', + fCompl1?"!":"", pName1[0] == '*' ? pName1 + 1 : pName1, + fCompl2?"!":"", pName2[0] == '*' ? pName2 + 1 : pName2, + fXor?']':')' ); +// printf( "%s ", pBuffer ); + Vec_PtrPush( vOne, Abc_UtilStrsav(pBuffer) ); +} +void Dau_EnumCombineThree( Vec_Ptr_t * vOne, int fStar, char * pNameC, char * pName1, char * pName2, int Shift1, int Shift2, int fComplC, int fCompl1, int fCompl2 ) +{ + static char pBuffer[256]; + pName1 = Dau_EnumLift( pName1, Shift1 ); + pName2 = Dau_EnumLift2( pName2, Shift2 ); + sprintf( pBuffer, "%s%c%s%s%s%s%s%s%c", + fStar?"*":"", + '<', + fComplC?"!":"", pNameC[0] == '*' ? pNameC + 1 : pNameC, + fCompl1?"!":"", pName1[0] == '*' ? pName1 + 1 : pName1, + fCompl2?"!":"", pName2[0] == '*' ? pName2 + 1 : pName2, + '>' ); +// printf( "%s ", pBuffer ); + Vec_PtrPush( vOne, Abc_UtilStrsav(pBuffer) ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Dau_EnumTestDump( Vec_Ptr_t * vSets, char * pFileName ) +{ + FILE * pFile; + Vec_Ptr_t * vOne; + char * pName; + int v, k; + pFile = fopen( pFileName, "wb" ); + if ( pFile == NULL ) + return; + Vec_PtrForEachEntry( Vec_Ptr_t *, vSets, vOne, v ) + { + fprintf( pFile, "VARIABLE NUMBER %d:\n", v ); + Vec_PtrForEachEntry( char *, vOne, pName, k ) + fprintf( pFile, "%s\n", pName ); + } + fclose( pFile ); +} + +/**Function************************************************************* + + Synopsis [] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Dau_EnumTest() +{ + int v, k, nVarMax = 10; + Vec_Ptr_t * vSets; + Vec_Ptr_t * vOne; + char * pName; + // 0 vars + vSets = Vec_PtrAlloc( 16 ); + Vec_PtrPush( vSets, Vec_PtrAlloc(0) ); + // 1 vars + vOne = Vec_PtrAlloc( 1 ); + Vec_PtrPush( vOne, Abc_UtilStrsav("*a") ); + Vec_PtrPush( vSets, vOne ); + // 2+ vars + for ( v = 2; v <= nVarMax; v++ ) + { + Vec_Ptr_t * vSetI, * vSetJ, * vSetK; + char * pNameI, * pNameJ, * pNameK; + int i, j, k, i1, j1, k1; + vOne = Vec_PtrAlloc( 100 ); + for ( i = 1; i < v; i++ ) + for ( j = i; j < v; j++ ) + { + if ( i + j != v ) + continue; + vSetI = (Vec_Ptr_t *)Vec_PtrEntry( vSets, i ); + vSetJ = (Vec_Ptr_t *)Vec_PtrEntry( vSets, j ); + Vec_PtrForEachEntry( char *, vSetI, pNameI, i1 ) + Vec_PtrForEachEntry( char *, vSetJ, pNameJ, j1 ) + { + // AND(a,b) + Dau_EnumCombineTwo( vOne, 0, 0, pNameI, pNameJ, i, 0, 0 ); + // AND(!a,b) + if ( pNameI[0] != '*' ) + Dau_EnumCombineTwo( vOne, 0, 0, pNameI, pNameJ, i, 1, 0 ); + // AND(a,!b) + if ( pNameJ[0] != '*' && !(i == j && i1 == j1) ) + Dau_EnumCombineTwo( vOne, 0, 0, pNameI, pNameJ, i, 0, 1 ); + // AND(!a,!b) + if ( pNameI[0] != '*' && pNameJ[0] != '*' ) + Dau_EnumCombineTwo( vOne, 0, 0, pNameI, pNameJ, i, 1, 1 ); + // XOR(a,b) + Dau_EnumCombineTwo( vOne, pNameI[0] == '*' || pNameJ[0] == '*', 1, pNameI, pNameJ, i, 0, 0 ); + } + } + for ( k = 1; k < v; k++ ) + for ( i = 1; i < v; i++ ) + for ( j = i; j < v; j++ ) + { + if ( k + i + j != v ) + continue; + vSetK = (Vec_Ptr_t *)Vec_PtrEntry( vSets, k ); + vSetI = (Vec_Ptr_t *)Vec_PtrEntry( vSets, i ); + vSetJ = (Vec_Ptr_t *)Vec_PtrEntry( vSets, j ); + Vec_PtrForEachEntry( char *, vSetK, pNameK, k1 ) + Vec_PtrForEachEntry( char *, vSetI, pNameI, i1 ) + Vec_PtrForEachEntry( char *, vSetJ, pNameJ, j1 ) + { + int fStar = pNameI[0] == '*' && pNameJ[0] == '*'; + + // MUX(c,a,b) + Dau_EnumCombineThree( vOne, fStar, pNameK, pNameI, pNameJ, k, k+i, 0, 0, 0 ); + // MUX(c,!a,b) + if ( pNameI[0] != '*' ) + Dau_EnumCombineThree( vOne, fStar, pNameK, pNameI, pNameJ, k, k+i, 0, 1, 0 ); + // MUX(c,a,!b) + if ( pNameJ[0] != '*' && !(i == j && i1 == j1) ) + Dau_EnumCombineThree( vOne, fStar, pNameK, pNameI, pNameJ, k, k+i, 0, 0, 1 ); + + if ( pNameK[0] != '*' && !(i == j && i1 == j1) ) + { + // MUX(!c,a,b) + Dau_EnumCombineThree( vOne, fStar, pNameK, pNameI, pNameJ, k, k+i, 1, 0, 0 ); + // MUX(!c,!a,b) + if ( pNameI[0] != '*' ) + Dau_EnumCombineThree( vOne, fStar, pNameK, pNameI, pNameJ, k, k+i, 1, 1, 0 ); + // MUX(!c,a,!b) + if ( pNameJ[0] != '*' ) + Dau_EnumCombineThree( vOne, fStar, pNameK, pNameI, pNameJ, k, k+i, 1, 0, 1 ); + } + } + } + Vec_PtrPush( vSets, vOne ); + } + Dau_EnumTestDump( vSets, "_npn/npn/dsd10.txt" ); + + Vec_PtrForEachEntry( Vec_Ptr_t *, vSets, vOne, v ) + { + printf( "VARIABLE NUMBER %d:\n", v ); + Vec_PtrForEachEntry( char *, vOne, pName, k ) + printf( "%s\n", pName ); + if ( v == 4 ) + break; + } + Vec_PtrForEachEntry( Vec_Ptr_t *, vSets, vOne, v ) + { + printf( "%d=%d ", v, Vec_PtrSize(vOne) ); + Vec_PtrFreeFree( vOne ); + } + Vec_PtrFree( vSets ); + printf( "\n" ); +} + +//////////////////////////////////////////////////////////////////////// +/// END OF FILE /// +//////////////////////////////////////////////////////////////////////// + + +ABC_NAMESPACE_IMPL_END + diff --git a/src/opt/dau/module.make b/src/opt/dau/module.make index c58d8807..87a800e9 100644 --- a/src/opt/dau/module.make +++ b/src/opt/dau/module.make @@ -1,3 +1,4 @@ SRC += src/opt/dau/dau.c \ src/opt/dau/dauCore.c \ - src/opt/dau/dauDsd.c + src/opt/dau/dauDsd.c \ + src/opt/dau/dauEnum.c diff --git a/src/opt/nwk/nwkMap.c b/src/opt/nwk/nwkMap.c index e80c4c93..e8be5a2d 100644 --- a/src/opt/nwk/nwkMap.c +++ b/src/opt/nwk/nwkMap.c @@ -163,7 +163,6 @@ If_Man_t * Nwk_ManToIf( Aig_Man_t * p, If_Par_t * pPars, Vec_Ptr_t * vAigToIf ) // set up the choice node if ( Aig_ObjIsChoice( p, pNode ) ) { - pIfMan->nChoices++; for ( pPrev = pNode, pFanin = Aig_ObjEquiv(p, pNode); pFanin; pPrev = pFanin, pFanin = Aig_ObjEquiv(p, pFanin) ) If_ObjSetChoice( (If_Obj_t *)pPrev->pData, (If_Obj_t *)pFanin->pData ); If_ManCreateChoice( pIfMan, (If_Obj_t *)pNode->pData ); diff --git a/src/proof/cec/cec.h b/src/proof/cec/cec.h index 10b06c28..65d2e24e 100644 --- a/src/proof/cec/cec.h +++ b/src/proof/cec/cec.h @@ -144,6 +144,7 @@ struct Cec_ParCor_t_ int fUseCSat; // use circuit-based solver // int fFirstStop; // stop on the first sat output int fUseSmartCnf; // use smart CNF computation + int fStopWhenGone; // quit when PO is not a candidate constant int fVerboseFlops; // verbose stats int fVeryVerbose; // verbose stats int fVerbose; // verbose stats diff --git a/src/proof/cec/cecCorr.c b/src/proof/cec/cecCorr.c index f35cd952..f3a84d3a 100644 --- a/src/proof/cec/cecCorr.c +++ b/src/proof/cec/cecCorr.c @@ -753,6 +753,7 @@ void Cec_ManRefinedClassPrintStats( Gia_Man_t * p, Vec_Str_t * vStatus, int iIte nFail++; } Abc_Print( 1, "p =%6d d =%6d f =%6d ", nProve, nDispr, nFail ); + Abc_Print( 1, "%c ", Gia_ObjIsConst( p, Gia_ObjFaninId0p(p, Gia_ManPo(p, 0)) ) ? '+' : '-' ); Abc_PrintTime( 1, "T", Time ); } @@ -950,6 +951,14 @@ int Cec_ManLSCorrespondenceClasses( Gia_Man_t * pAig, Cec_ParCor_t * pPars ) //Gia_ManEquivPrintClasses( pAig, 1, 0 ); if ( pPars->pFunc ) ((int (*)(void *))pPars->pFunc)( pPars->pData ); + // quit if const is no longer there + if ( pPars->fStopWhenGone && Gia_ManPoNum(pAig) == 1 && !Gia_ObjIsConst( pAig, Gia_ObjFaninId0p(pAig, Gia_ManPo(pAig, 0)) ) ) + { + printf( "Iterative refinement is stopped after iteration %d\n", r ); + printf( "because the property output is no longer a candidate constant.\n" ); + Cec_ManSimStop( pSim ); + return 0; + } } if ( pPars->fVerbose ) Cec_ManRefinedClassPrintStats( pAig, NULL, r+1, clock() - clk ); @@ -1071,7 +1080,11 @@ Gia_Man_t * Cec_ManLSCorrespondence( Gia_Man_t * pAig, Cec_ParCor_t * pPars ) ABC_FREE( pAig->pReprs ); ABC_FREE( pAig->pNexts ); if ( pPars->nPrefix == 0 ) + { RetValue = Cec_ManLSCorrespondenceClasses( pAig, pPars ); + if ( RetValue == 0 ) + return Gia_ManDup( pAig ); + } else { // compute the cycles AIG diff --git a/src/proof/dch/dchChoice.c b/src/proof/dch/dchChoice.c index 783202e2..3f097ecc 100644 --- a/src/proof/dch/dchChoice.c +++ b/src/proof/dch/dchChoice.c @@ -95,7 +95,7 @@ int Dch_DeriveChoiceCountEquivs( Aig_Man_t * pAig ) pEquiv = Aig_ObjEquiv( pAig, pObj ); if ( pEquiv == NULL ) continue; - assert( pEquiv->Id > pObj->Id ); + assert( pEquiv->Id < pObj->Id ); nEquivs++; } return nEquivs; diff --git a/src/proof/dch/dchCore.c b/src/proof/dch/dchCore.c index 0d2e8c0d..b92de8a6 100644 --- a/src/proof/dch/dchCore.c +++ b/src/proof/dch/dchCore.c @@ -111,7 +111,9 @@ p->timeTotal = clock() - clkTotal; pResult = Dch_DeriveChoiceAig( pAig, pPars->fSkipRedSupp ); // count the number of representatives if ( pPars->fVerbose ) - Abc_Print( 1, "STATS: Reprs = %6d. Equivs = %6d. Choices = %6d.\n", + Abc_Print( 1, "STATS: Ands:%8d ->%8d. Reprs:%7d ->%7d. Choices =%7d.\n", + Aig_ManNodeNum(pAig), + Aig_ManNodeNum(pResult), Dch_DeriveChoiceCountReprs( pAig ), Dch_DeriveChoiceCountEquivs( pResult ), Aig_ManChoiceNum( pResult ) ); diff --git a/src/proof/llb/llb4Map.c b/src/proof/llb/llb4Map.c index 51f1fec6..4b46f308 100644 --- a/src/proof/llb/llb4Map.c +++ b/src/proof/llb/llb4Map.c @@ -48,7 +48,7 @@ Vec_Int_t * Llb_AigMap( Aig_Man_t * pAig, int nLutSize, int nLutMin ) { extern Abc_Ntk_t * Abc_NtkFromAigPhase( Aig_Man_t * pMan ); extern If_Man_t * Abc_NtkToIf( Abc_Ntk_t * pNtk, If_Par_t * pPars ); - extern void Gia_ManSetIfParsDefault( If_Par_t * pPars ); + extern void Gia_ManSetIfParsDefault( void * pPars ); If_Par_t Pars, * pPars = &Pars; If_Man_t * pIfMan; If_Obj_t * pAnd; diff --git a/src/proof/ssw/ssw.h b/src/proof/ssw/ssw.h index 35d41a35..df73c357 100644 --- a/src/proof/ssw/ssw.h +++ b/src/proof/ssw/ssw.h @@ -70,6 +70,7 @@ struct Ssw_Pars_t_ int fVerbose; // verbose stats int fFlopVerbose; // verbose printout of redundant flops int fEquivDump; // enables dumping equivalences + int fStopWhenGone; // stop when PO output is not a candidate constant // optimized latch correspondence int fLatchCorrOpt; // perform register correspondence (optimized) int nSatVarMax; // max number of SAT vars before recycling SAT solver (optimized latch corr only) diff --git a/src/proof/ssw/sswCore.c b/src/proof/ssw/sswCore.c index 7e2e66da..7a9d4b9f 100644 --- a/src/proof/ssw/sswCore.c +++ b/src/proof/ssw/sswCore.c @@ -346,6 +346,24 @@ clk = clock(); } // if ( p->pPars->fDynamic && p->nSatCallsSat-nSatCallsSat < 100 ) // p->pPars->nBTLimit = 10000; + + if ( p->pPars->fStopWhenGone && Saig_ManPoNum(p->pAig) == 1 && !Ssw_ObjIsConst1Cand(p->pAig,Aig_ObjFanin0(Aig_ManCo(p->pAig,0))) ) + { + printf( "Iterative refinement is stopped after iteration %d\n", nIter ); + printf( "because the property output is no longer a candidate constant.\n" ); + // prepare to quite + p->nLitsEnd = p->nLitsBeg; + p->nNodesEnd = p->nNodesBeg; + p->nRegsEnd = p->nRegsBeg; + // cleanup + Ssw_SatStop( p->pMSat ); + p->pMSat = NULL; + Ssw_ManCleanup( p ); + // cleanup + Aig_ManSetPhase( p->pAig ); + Aig_ManCleanMarkB( p->pAig ); + return Aig_ManDupSimple( p->pAig ); + } } nSatProof = p->nSatProof; nSatCallsSat = p->nSatCallsSat; |