luke
/
abc
mirror of https://github.com/YosysHQ/abc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Changes to the lazy man's synthesis code.

This commit is contained in:
Alan Mishchenko 2012-01-17 23:38:11 -08:00
parent d8d705c717
commit 2a236864ab
5 changed files with 367 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/base/abci/abcIf.c
View File

@ -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
{

380
src/base/abci/abcRec.c
View File

@ -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*************************************************************

2
src/map/if/if.h
View File

@ -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 );

2
src/map/if/ifCut.c
View File

@ -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 )

10
src/map/if/ifMap.c
View File

@ -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;