From 2a236864ab0b9f96f917addc96ee7442abb09d9d Mon Sep 17 00:00:00 2001 From: Alan Mishchenko Date: Tue, 17 Jan 2012 23:38:11 -0800 Subject: Changes to the lazy man's synthesis code. --- src/base/abci/abcIf.c | 4 +- src/base/abci/abcRec.c | 380 ++++++++++++++++++++++++++++++++++++++++++++++--- src/map/if/if.h | 2 +- src/map/if/ifCut.c | 2 +- src/map/if/ifMap.c | 10 +- 5 files changed, 367 insertions(+), 31 deletions(-) (limited to 'src') diff --git a/src/base/abci/abcIf.c b/src/base/abci/abcIf.c index bdc0970d..674a4550 100644 --- a/src/base/abci/abcIf.c +++ b/src/base/abci/abcIf.c @@ -490,8 +490,8 @@ Abc_Obj_t * Abc_NodeFromIf_rec( Abc_Ntk_t * pNtkNew, If_Man_t * pIfMan, If_Obj_t } else if ( pIfMan->pPars->fUserRecLib ) { - extern Hop_Obj_t * Abc_RecToHop( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut ); - pNodeNew->pData = Abc_RecToHop( (Hop_Man_t *)pNtkNew->pManFunc, pIfMan, pCutBest ); + extern Hop_Obj_t * Abc_RecToHop( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut, If_Obj_t * pIfObj ); + pNodeNew->pData = Abc_RecToHop( (Hop_Man_t *)pNtkNew->pManFunc, pIfMan, pCutBest, pIfObj); } else { diff --git a/src/base/abci/abcRec.c b/src/base/abci/abcRec.c index f53caeb8..abb4be4b 100644 --- a/src/base/abci/abcRec.c +++ b/src/base/abci/abcRec.c @@ -74,6 +74,13 @@ struct Abc_ManRec_t_ int * pMints; // temporary storage for minterm counters unsigned * pTemp1; // temporary truth table unsigned * pTemp2; // temporary truth table + unsigned * pTempTruth; // temporary truth table + char * pTempDepths; // temporary depths + int * pTempleaves; // temporary leaves + unsigned tempUsign; + unsigned tempNleaves; + unsigned currentCost; + int currentDelay; 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 @@ -98,11 +105,13 @@ struct Abc_ManRec_t_ int nFunsTried; int nFunsFilteredBysupport; // the function filtered when rewriting because not all supports are in use. int nFunsDelayComput; // the times delay computed, just for statistics + int nNoBetter; // the number of functions found but no better than the current structures. // rewriting runtime int timeIfTotal; // time used on the whole process of rewriting a structure. int timeIfComputDelay; // time used on the structure's delay computation. int timeIfCanonicize; // time used on canonicize the function int timeIfDerive; // time used on derive the final network; + int timeIfCopmutCur; // time used on compute the current structures info int timeIfOther; // time used on other things // record runtime int timeTrim; // the runtime to filter the library @@ -124,7 +133,7 @@ static Rec_Obj_t ** Abc_NtkRecTableLookup( Abc_ManRec_t* p, Rec_Obj_t ** pBins, static int Abc_NtkRecComputeTruth( Abc_Obj_t * pObj, Vec_Ptr_t * vTtNodes, int nVars ); static int Abc_NtkRecAddCutCheckCycle_rec( Abc_Obj_t * pRoot, Abc_Obj_t * pObj ); static void Abc_NtkRecAddFromLib( Abc_Ntk_t* pNtk, Abc_Obj_t * pRoot, int nVars ); - +static void Abc_NtkRecCurrentUnMark_rec(If_Obj_t * pObj); static Abc_ManRec_t * s_pMan = NULL; static inline void Abc_ObjSetMax( Abc_Obj_t * pObj, int Value ) { assert( pObj->Level < 0xff ); pObj->Level = (Value << 8) | (pObj->Level & 0xff); } @@ -253,7 +262,7 @@ void Rec_ObjSet(Abc_ManRec_t* p, Rec_Obj_t* pRecObj, Abc_Obj_t* pObj, char* newD SeeAlso [] ***********************************************************************/ -int If_CutComputDelay(If_Man_t* p, Rec_Obj_t* entry, If_Cut_t* pCut, char* pCanonPerm , int nVars) +inline int If_CutComputDelay(If_Man_t* p, Rec_Obj_t* entry, If_Cut_t* pCut, char* pCanonPerm , int nVars) { If_Obj_t* pLeaf; int i, delayTemp, delayMax = -ABC_INFINITY; @@ -675,6 +684,66 @@ void Abc_NtkRecInsertToLookUpTable(Abc_ManRec_t* p, Rec_Obj_t** ppSpot, Abc_Obj_ return pRes; } + /**Function************************************************************* + + Synopsis [Build up the structure using library.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ + Hop_Obj_t * Abc_NtkRecBuildUpFromCurrent_rec(Hop_Man_t* pMan, If_Obj_t* pObj, Vec_Ptr_t * vNodes) + { + Hop_Obj_t * pRes0, *pRes1, *pRes; + If_Obj_t *pRegular = If_Regular(pObj); + if (Vec_PtrEntry(vNodes, pRegular->Id) && pRegular->fMark == 1) + return (Hop_Obj_t *)Vec_PtrEntry(vNodes, pRegular->Id); + pRes0 = Abc_NtkRecBuildUpFromCurrent_rec(pMan, If_ObjFanin0(pRegular), vNodes); + pRes0 = Hop_NotCond(pRes0, pRegular->fCompl0); + pRes1 = Abc_NtkRecBuildUpFromCurrent_rec(pMan, If_ObjFanin1(pRegular), vNodes); + pRes1 = Hop_NotCond(pRes1, pRegular->fCompl1); + pRes = Hop_And(pMan, pRes0, pRes1); + Vec_PtrWriteEntry(vNodes,pRegular->Id,pRes); + assert(pRegular->fMark == 0); + pRegular->fMark = 1; + return pRes; + } + + /**Function************************************************************* + + Synopsis [Derive the final network from the library.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ + Hop_Obj_t * Abc_RecFromCurrentToHop(Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut, If_Obj_t * pRoot) + { + int i; + If_Obj_t * pLeaf; + Hop_Obj_t* pHopObj; + Vec_PtrGrow(s_pMan->vLabels, pIfMan->vObjs->nSize); + s_pMan->vLabels->nSize = s_pMan->vLabels->nCap; + If_CutForEachLeaf(pIfMan, pCut, pLeaf, i) + { + pHopObj = Hop_IthVar(pMan, i); + Vec_PtrWriteEntry(s_pMan->vLabels, pLeaf->Id, pHopObj); + assert(pLeaf->fMark == 0); + pLeaf->fMark = 1; + } + pHopObj = Abc_NtkRecBuildUpFromCurrent_rec(pMan, pRoot, s_pMan->vLabels); + Abc_NtkRecCurrentUnMark_rec(pRoot); + return pHopObj; + + + } + /**Function************************************************************* Synopsis [Derive the final network from the library.] @@ -686,7 +755,7 @@ void Abc_NtkRecInsertToLookUpTable(Abc_ManRec_t* p, Rec_Obj_t** ppSpot, Abc_Obj_ SeeAlso [] ***********************************************************************/ -Hop_Obj_t * Abc_RecToHop( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut ) +Hop_Obj_t * Abc_RecToHop( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut, If_Obj_t * pIfObj ) { Rec_Obj_t *pCand, *pCandMin, **ppSpot; Hop_Obj_t* pHopObj; @@ -694,16 +763,12 @@ Hop_Obj_t * Abc_RecToHop( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut ) Abc_Ntk_t * pAig = s_pMan->pNtk; int nLeaves, i, DelayMin = ABC_INFINITY , Delay = -ABC_INFINITY; unsigned uCanonPhase; - Vec_Ptr_t * vNodes = s_pMan->vLabels; int nVars = s_pMan->nVars; char pCanonPerm[16]; unsigned *pInOut = s_pMan->pTemp1; unsigned *pTemp = s_pMan->pTemp2; int time = clock(); int fCompl = 0; -#ifdef Dervie - static FILE* pFile; -#endif nLeaves = If_CutLeaveNum(pCut); // if (nLeaves < 3) // return Abc_NodeTruthToHop(pMan, pIfMan, pCut); @@ -739,13 +804,8 @@ Hop_Obj_t * Abc_RecToHop( Hop_Man_t * pMan, If_Man_t * pIfMan, If_Cut_t * pCut ) } } assert( pCandMin != NULL ); - if ( s_pMan->vLabels == NULL ) - s_pMan->vLabels = Vec_PtrStart( Abc_NtkObjNumMax(pAig)); - else - { - Vec_PtrGrow(s_pMan->vLabels, Abc_NtkObjNumMax(pAig)); - s_pMan->vLabels->nSize = s_pMan->vLabels->nCap; - } + Vec_PtrGrow(s_pMan->vLabels, Abc_NtkObjNumMax(pAig)); + s_pMan->vLabels->nSize = s_pMan->vLabels->nCap; for (i = 0; i < nLeaves; i++) { pAbcObj = Abc_NtkPi( pAig, i ); @@ -1159,7 +1219,8 @@ void Abc_NtkRecStart( Abc_Ntk_t * pNtk, int nVars, int nCuts, int fTrim ) Vec_PtrPush( p->vTtNodes, Mem_FixedEntryFetch(p->pMmTruth) ); // create hash table - p->nBins = 50011; + //p->nBins = 50011; + p->nBins =500011; p->pBins = ABC_ALLOC( Rec_Obj_t *, p->nBins ); memset( p->pBins, 0, sizeof(Rec_Obj_t *) * p->nBins ); @@ -1212,9 +1273,13 @@ p->timeTruth += clock() - clk; p->pMints = ABC_ALLOC( int, 2*p->nVars ); p->pTemp1 = ABC_ALLOC( unsigned, p->nWords ); p->pTemp2 = ABC_ALLOC( unsigned, p->nWords ); + p->pTempTruth = ABC_ALLOC( unsigned, p->nWords ); + p->pTempDepths = ABC_ALLOC( char, p->nVars ); + p->pTempleaves = ABC_ALLOC( int, p->nVars ); p->vNodes = Vec_PtrAlloc( 100 ); p->vTtTemps = Vec_PtrAllocSimInfo( 1024, p->nWords ); p->vMemory = Vec_IntAlloc( Abc_TruthWordNum(p->nVars) * 1000 ); + p->vLabels = Vec_PtrStart( 1000); // set the manager s_pMan = p; @@ -1282,6 +1347,8 @@ void Abc_NtkRecStop() ABC_FREE( s_pMan->pMints ); ABC_FREE( s_pMan->pTemp1 ); ABC_FREE( s_pMan->pTemp2 ); + ABC_FREE( s_pMan->pTempTruth ); + ABC_FREE( s_pMan->pTempDepths ); Vec_PtrFree( s_pMan->vNodes ); Vec_PtrFree( s_pMan->vTtTemps ); if ( s_pMan->vLabels ) @@ -2178,7 +2245,6 @@ void Abc_NtkRecAddFromLib( Abc_Ntk_t* pNtk, Abc_Obj_t * pRoot, int nVars ) Abc_NtkRecInsertToLookUpTable(s_pMan, ppSpot, pObj, nLeaves, s_pMan->fTrim); } - /**Function************************************************************* Synopsis [Prints one AIG sugraph recursively.] @@ -2205,6 +2271,273 @@ void Abc_RecPrint_rec( Abc_Obj_t * pObj ) printf( ")" ); } +/**Function************************************************************* + + Synopsis [back up the info of the cut.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Abc_NtkRecBackUpCut(If_Cut_t* pCut) +{ + int i; + s_pMan->tempUsign = pCut->uSign; + s_pMan->tempNleaves = pCut->nLeaves; + for (i = 0; i < (int)pCut->nLeaves; i++) + s_pMan->pTempleaves[i] = pCut->pLeaves[i]; + Kit_TruthCopy(s_pMan->pTempTruth, pCut->pTruth, s_pMan->nVars); +} + +/**Function************************************************************* + + Synopsis [restore the info of the cut.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Abc_NtkRecRestoreCut(If_Cut_t* pCut) +{ + int i; + pCut->uSign = s_pMan->tempUsign; + pCut->nLeaves = s_pMan->tempNleaves; + for (i = 0; i < (int)pCut->nLeaves; i++) + pCut->pLeaves[i] = s_pMan->pTempleaves[i]; + Kit_TruthCopy(pCut->pTruth ,s_pMan->pTempTruth, s_pMan->nVars); +} + +/**Function************************************************************* + + Synopsis [compute current cut's area.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Abc_NtkRecCurrentUnMark_rec(If_Obj_t * pObj) +{ + pObj = If_Regular(pObj); + if(pObj->fMark == 0) + return; + if(pObj->pFanin0) + Abc_NtkRecCurrentUnMark_rec(If_ObjFanin0(pObj)); + if(pObj->pFanin1) + Abc_NtkRecCurrentUnMark_rec(If_ObjFanin1(pObj)); + pObj->fMark = 0; + return; +} + +/**Function************************************************************* + + Synopsis [compute current cut's area.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_NtkRecCurrentMarkAndCount_rec(If_Obj_t * pObj) +{ + int Area0, Area1, Area; + pObj = If_Regular(pObj); + if(pObj->fMark == 1) + return 0; + Area0 = Abc_NtkRecCurrentMarkAndCount_rec(If_ObjFanin0(pObj)); + Area1 = Abc_NtkRecCurrentMarkAndCount_rec(If_ObjFanin1(pObj)); + Area = Area1 + Area0 + 1; + pObj->fMark = 1; + return Area; +} + +/**Function************************************************************* + + Synopsis [compute current cut's area.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_NtkRecCurrentAera(If_Man_t* p, If_Cut_t* pCut, If_Obj_t * pRoot) +{ + int Area, i; + If_Obj_t * pLeaf; + Vec_PtrClear( s_pMan->vNodes ); + If_CutForEachLeaf( p, pCut, pLeaf, i ) + { + Vec_PtrPush( s_pMan->vNodes, pLeaf ); + assert( pLeaf->fMark == 0 ); + pLeaf->fMark = 1; + } + + // collect other nodes + Abc_NtkRecCollectNodes_rec( pRoot, s_pMan->vNodes ); + Vec_PtrForEachEntry( If_Obj_t *, s_pMan->vNodes, pLeaf, i ) + pLeaf->fMark = 0; + If_CutForEachLeaf(p, pCut, pLeaf, i) + pLeaf->fMark = 1; + Area = Abc_NtkRecCurrentMarkAndCount_rec(pRoot); + Abc_NtkRecCurrentUnMark_rec(pRoot); + return Area; +} + +/**Function************************************************************* + + Synopsis [compute current cut's delay.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +char Abc_NtkRecCurrentDepth_rec(If_Obj_t * pObj, int iLeaf) +{ + char Depth0, Depth1, Depth; + pObj = If_Regular(pObj); + if(pObj->Id == iLeaf) + return 0; + if(pObj->fMark) + return -IF_BIG_CHAR; + Depth0 = Abc_NtkRecCurrentDepth_rec(If_ObjFanin0(pObj), iLeaf); + Depth1 = Abc_NtkRecCurrentDepth_rec(If_ObjFanin1(pObj), iLeaf); + Depth = ABC_MAX(Depth0, Depth1); + Depth = (Depth == -IF_BIG_CHAR) ? -IF_BIG_CHAR : Depth + 1; + assert(Depth <= 127); + return Depth; +} + +/**Function************************************************************* + + Synopsis [compute current cut's delay.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Abc_NtkRecCurrentDepth(If_Man_t* p, If_Cut_t* pCut, If_Obj_t * pRoot) +{ + int i; + If_Obj_t * pLeaf; + If_CutForEachLeaf(p, pCut, pLeaf, i) + pLeaf->fMark = 1; + If_CutForEachLeaf(p, pCut, pLeaf, i) + s_pMan->pTempDepths[i] = Abc_NtkRecCurrentDepth_rec(pRoot, pLeaf->Id); + If_CutForEachLeaf(p, pCut, pLeaf, i) + pLeaf->fMark = 0; +} + +/**Function************************************************************* + + Synopsis [compute current cut's delay.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +int Abc_NtkRecCurrentDelay(If_Man_t* p, If_Cut_t* pCut, If_Obj_t * pRoot) +{ + If_Obj_t* pLeaf; + int i, delayTemp, delayMax = -ABC_INFINITY; + Abc_NtkRecCurrentDepth(p , pCut, pRoot); + If_CutForEachLeaf(p, pCut, pLeaf, i) + { + delayTemp = s_pMan->pTempDepths[i] + If_ObjCutBest(pLeaf)->Delay; + if(delayTemp > delayMax) + delayMax = delayTemp; + } + // plus each pin's delay with its pin-to-output delay, the biggest one is the delay of the structure. + return delayMax; +} + +/**Function************************************************************* + + Synopsis [compute current cut's delay and area.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void Abc_NtkRecComputCurrentStructure(If_Man_t* p, If_Cut_t* pCut, If_Obj_t * pRoot) +{ + if (pRoot->Id == 78) + { + int a = 1; + } + + s_pMan->currentCost = Abc_NtkRecCurrentAera(p, pCut, pRoot); + s_pMan->currentDelay = Abc_NtkRecCurrentDelay(p, pCut, pRoot); +} + +/**Function************************************************************* + + Synopsis [the cut not found in the library.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void SetUselessCut(If_Cut_t* pCut) +{ + int i; + pCut->fUseless = 1; + pCut->fUser = 1; + pCut->Cost = s_pMan->currentCost; + for (i = 0; i < (int)pCut->nLeaves; i++) + pCut->pPerm[i] = s_pMan->pTempDepths[i]; + return; +} + +/**Function************************************************************* + + Synopsis [the cut not found in the library.] + + Description [] + + SideEffects [] + + SeeAlso [] + +***********************************************************************/ +void SetUseCut(If_Cut_t* pCut, Rec_Obj_t * pRecObj, char * pCanonPerm) +{ + int i; + pCut->fUseless = 0; + pCut->fUser = 1; + pCut->Cost = pRecObj->cost; + for (i = 0; i < (int)pCut->nLeaves; i++) + pCut->pPerm[pCanonPerm[i]] = pRecObj->pinToPinDelay[i]; + return; + +} + /**Function************************************************************* Synopsis [Computes the delay using library.] @@ -2216,7 +2549,7 @@ void Abc_RecPrint_rec( Abc_Obj_t * pObj ) SeeAlso [] ***********************************************************************/ -int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut) +int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut, If_Obj_t * pObj) { int fVerbose = 0; int timeDelayComput, timeTotal = clock(), timeCanonicize; @@ -2228,7 +2561,8 @@ int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut) Abc_Ntk_t *pAig = s_pMan->pNtk; unsigned *pInOut = s_pMan->pTemp1; unsigned *pTemp = s_pMan->pTemp2; - int Counter, nVars = s_pMan->nVars; + int nVars = s_pMan->nVars; + int Counter; assert( s_pMan != NULL ); nLeaves = If_CutLeaveNum(pCut); s_pMan->nFunsTried++; @@ -2239,6 +2573,7 @@ int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut) { s_pMan->nFunsFilteredBysupport++; pCut->fUser = 1; + pCut->fUseless = 1; pCut->Cost = IF_COST_MAX; return ABC_INFINITY; } @@ -2248,20 +2583,22 @@ int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut) pCanonPerm[i] = i; uCanonPhase = Kit_TruthSemiCanonicize(pInOut, pTemp, nLeaves, pCanonPerm, (short*)s_pMan->pMints); If_CutTruthStretch(pInOut, nLeaves, nVars); - s_pMan->timeIfCanonicize += clock() - timeCanonicize; ppSpot = Abc_NtkRecTableLookup(s_pMan, s_pMan->pBins, s_pMan->nBins, pInOut, nVars ); if (*ppSpot == NULL) { Kit_TruthNot(pInOut, pInOut, nVars); ppSpot = Abc_NtkRecTableLookup(s_pMan, s_pMan->pBins, s_pMan->nBins, pInOut, nVars ); } + s_pMan->timeIfCanonicize += clock() - timeCanonicize; assert (!(*ppSpot == NULL && nLeaves == 2)); //functional class not found in the library. if ( *ppSpot == NULL ) { + s_pMan->nFunsNotFound++; pCut->Cost = IF_COST_MAX; pCut->fUser = 1; + pCut->fUseless = 1; return ABC_INFINITY; } s_pMan->nFunsFound++; @@ -2293,7 +2630,6 @@ int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut) Abc_RecPrint_rec( Abc_ObjRegular(pCand->obj) ); printf( ") " ); } - s_pMan->nFunsDelayComput++; Delay = If_CutComputDelay(p, pCand, pCut, pCanonPerm ,nLeaves); if ( DelayMin > Delay ) @@ -2310,7 +2646,6 @@ int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut) } if ( fVerbose ) printf( "Printed %d subgraphs.\n", Counter ); - s_pMan->timeIfComputDelay += clock() - timeDelayComput; assert( pCandMin != NULL ); for ( i = 0; i < nLeaves; i++ ) @@ -2319,7 +2654,8 @@ int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut) } s_pMan->timeIfTotal += clock() - timeTotal; pCut->Cost = pCandMin->cost; - return DelayMin; + return DelayMin; + } /**Function************************************************************* diff --git a/src/map/if/if.h b/src/map/if/if.h index ea830065..9f04902b 100644 --- a/src/map/if/if.h +++ b/src/map/if/if.h @@ -500,7 +500,7 @@ extern Vec_Int_t * If_ManCollectMappingInt( If_Man_t * p ); extern int If_ManCountSpecialPos( If_Man_t * p ); /*=== abcRec.c ============================================================*/ -extern int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut); +extern int If_CutDelayRecCost(If_Man_t* p, If_Cut_t* pCut, If_Obj_t * pObj); // othe packages extern int Bat_ManCellFuncLookup( unsigned * pTruth, int nVars, int nLeaves ); diff --git a/src/map/if/ifCut.c b/src/map/if/ifCut.c index 35d6376c..36aa935d 100644 --- a/src/map/if/ifCut.c +++ b/src/map/if/ifCut.c @@ -685,7 +685,7 @@ void If_CutSort( If_Man_t * p, If_Set_t * pCutSet, If_Cut_t * pCut ) return; } - if ( (p->pPars->fUseBat || p->pPars->fEnableCheck07 || p->pPars->fEnableCheck08 || p->pPars->fEnableCheck10 || p->pPars->pLutStruct) && !pCut->fUseless ) + if ( (p->pPars->fUseBat || p->pPars->fEnableCheck07 || p->pPars->fEnableCheck08 || p->pPars->fEnableCheck10 || p->pPars->pLutStruct || p->pPars->fUserRecLib) && !pCut->fUseless ) { If_Cut_t * pFirst = pCutSet->ppCuts[0]; if ( pFirst->fUseless || If_ManSortCompare(p, pFirst, pCut) == 1 ) diff --git a/src/map/if/ifMap.c b/src/map/if/ifMap.c index c6547fce..f40244ca 100644 --- a/src/map/if/ifMap.c +++ b/src/map/if/ifMap.c @@ -157,7 +157,7 @@ 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 ); // else if ( p->pPars->fDelayOpt ) if ( p->pPars->fUserRecLib ) - pCut->Delay = If_CutDelayRecCost(p, pCut); + pCut->Delay = If_CutDelayRecCost(p, pCut, pObj); else if(p->pPars->fDelayOpt) pCut->Delay = If_CutDelaySopCost(p,pCut); else @@ -180,7 +180,6 @@ void If_ObjPerformMappingAnd( If_Man_t * p, If_Obj_t * pObj, int Mode, int fPrep If_ObjForEachCut( pObj->pFanin0, pCut0, i ) If_ObjForEachCut( pObj->pFanin1, pCut1, k ) { - // get the next free cut assert( pCutSet->nCuts <= pCutSet->nCutsMax ); pCut = pCutSet->ppCuts[pCutSet->nCuts]; @@ -218,6 +217,7 @@ void If_ObjPerformMappingAnd( If_Man_t * p, If_Obj_t * pObj, int Mode, int fPrep } } + // compute the application-specific cost and depth pCut->fUser = (p->pPars->pFuncCost != NULL); pCut->Cost = p->pPars->pFuncCost? p->pPars->pFuncCost(pCut) : 0; @@ -228,13 +228,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 ); // else if ( p->pPars->fDelayOpt ) if ( p->pPars->fUserRecLib ) - pCut->Delay = If_CutDelayRecCost(p, pCut); + pCut->Delay = If_CutDelayRecCost(p, pCut, pObj); else if (p->pPars->fDelayOpt) pCut->Delay = If_CutDelaySopCost(p, pCut); else pCut->Delay = If_CutDelay( p, pObj, pCut ); - if ( pCut->Cost == IF_COST_MAX ) - continue; + //if ( pCut->Cost == IF_COST_MAX ) + // continue; // Abc_Print( 1, "%.2f ", pCut->Delay ); if ( Mode && pCut->Delay > pObj->Required + p->fEpsilon ) continue; -- cgit v1.2.3