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

Version abc80404_2

This commit is contained in:
Alan Mishchenko 2008-04-04 20:01:00 -07:00
parent ef20b0c533
commit 0c4d314ef0
7 changed files with 397 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
src/aig/aig/aig.h
View File

@ -544,6 +544,7 @@ extern void Aig_ObjCreateRepr( Aig_Man_t * p, Aig_Obj_t * pNode1, Aig
extern void Aig_ManTransferRepr( Aig_Man_t * pNew, Aig_Man_t * p );
extern Aig_Man_t * Aig_ManDupRepr( Aig_Man_t * p, int fOrdered );
extern Aig_Man_t * Aig_ManRehash( Aig_Man_t * p );
extern int Aig_ObjCheckTfi( Aig_Man_t * p, Aig_Obj_t * pNew, Aig_Obj_t * pOld );
extern void Aig_ManMarkValidChoices( Aig_Man_t * p );
extern int Aig_TransferMappedClasses( Aig_Man_t * pAig, Aig_Man_t * pPart, int * pMapBack );
/*=== aigRet.c ========================================================*/

2
src/aig/aig/aigDup.c
View File

@ -255,7 +255,7 @@ Aig_Man_t * Aig_ManDupDfs( Aig_Man_t * p )
pObj->pData = pObjNew;
}
}
assert( Aig_ManBufNum(p) != 0 || Aig_ManNodeNum(p) == Aig_ManNodeNum(pNew) );
assert( p->pEquivs != NULL || Aig_ManBufNum(p) != 0 || Aig_ManNodeNum(p) == Aig_ManNodeNum(pNew) );
if ( p->pEquivs == NULL && p->pReprs == NULL && (nNodes = Aig_ManCleanup( pNew )) )
printf( "Aig_ManDupDfs(): Cleanup after AIG duplication removed %d nodes.\n", nNodes );
// duplicate the timing manager

2
src/aig/aig/aigRepr.c
View File

@ -341,6 +341,8 @@ int Aig_ObjCheckTfi_rec( Aig_Man_t * p, Aig_Obj_t * pNode, Aig_Obj_t * pOld )
// check the trivial cases
if ( pNode == NULL )
return 0;
if ( Aig_ObjIsPi(pNode) )
return 0;
// if ( pNode->Id < pOld->Id ) // cannot use because of choices of pNode
// return 0;
if ( pNode == pOld )

5
src/aig/nwk/nwk.h
View File

@ -231,8 +231,13 @@ extern Nwk_Obj_t * Nwk_ManCreateBox( Nwk_Man_t * pMan, int nFanins, int nFan
extern Nwk_Obj_t * Nwk_ManCreateLatch( Nwk_Man_t * pMan );
extern void Nwk_ManDeleteNode( Nwk_Obj_t * pObj );
extern void Nwk_ManDeleteNode_rec( Nwk_Obj_t * pObj );
/*=== nwkSpeedup.c ============================================================*/
extern Aig_Man_t * Nwk_ManSpeedup( Nwk_Man_t * pNtk, int fUseLutLib, int Percentage, int Degree, int fVerbose, int fVeryVerbose );
/*=== nwkStrash.c ============================================================*/
extern Aig_Man_t * Nwk_ManStrash( Nwk_Man_t * pNtk );
/*=== nwkTiming.c ============================================================*/
extern int Nwk_ManVerifyTiming( Nwk_Man_t * pNtk );
extern void Nwk_ManDelayTraceSortPins( Nwk_Obj_t * pNode, int * pPinPerm, float * pPinDelays );
extern float Nwk_ManDelayTraceLut( Nwk_Man_t * pNtk );
extern void Nwk_ManDelayTracePrint( Nwk_Man_t * pNtk );
extern void Nwk_ManUpdate( Nwk_Obj_t * pObj, Nwk_Obj_t * pObjNew, Vec_Vec_t * vLevels );

319
src/aig/nwk/nwkSpeedup.c
View File

@ -30,7 +30,7 @@
/**Function*************************************************************
Synopsis []
Synopsis [Adds strashed nodes for one node.]
Description []
@ -39,9 +39,322 @@
SeeAlso []
***********************************************************************/
Aig_Man_t * Nwk_ManSpeedup( Nwk_Man_t * pNtk )
int Aig_ManSpeedupNode_rec( Aig_Man_t * pAig, Aig_Obj_t * pNode, Vec_Ptr_t * vNodes )
{
return NULL;
if ( Aig_ObjIsTravIdCurrent(pAig, pNode) )
return 1;
if ( Aig_ObjIsPi(pNode) )
return 0;
assert( Aig_ObjIsNode(pNode) );
Aig_ObjSetTravIdCurrent( pAig, pNode );
if ( !Aig_ManSpeedupNode_rec( pAig, Aig_ObjFanin0(pNode), vNodes ) )
return 0;
if ( !Aig_ManSpeedupNode_rec( pAig, Aig_ObjFanin1(pNode), vNodes ) )
return 0;
Vec_PtrPush( vNodes, pNode );
return 1;
}
/**Function*************************************************************
Synopsis [Adds strashed nodes for one node.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Aig_ManSpeedupNode( Nwk_Man_t * pNtk, Aig_Man_t * pAig, Nwk_Obj_t * pNode, Vec_Ptr_t * vLeaves, Vec_Ptr_t * vTimes )
{
Vec_Ptr_t * vNodes;
Nwk_Obj_t * pObj, * pObj2;
Aig_Obj_t * ppCofs[32], * pAnd, * pTemp;
int nCofs, i, k, nSkip;
// quit of regulars are the same
Vec_PtrForEachEntry( vLeaves, pObj, i )
Vec_PtrForEachEntry( vLeaves, pObj2, k )
if ( i != k && Aig_Regular(pObj->pCopy) == Aig_Regular(pObj2->pCopy) )
{
// printf( "Identical after structural hashing!!!\n" );
return;
}
// collect the AIG nodes
vNodes = Vec_PtrAlloc( 100 );
Aig_ManIncrementTravId( pAig );
Aig_ObjSetTravIdCurrent( pAig, Aig_ManConst1(pAig) );
Vec_PtrForEachEntry( vLeaves, pObj, i )
{
pAnd = pObj->pCopy;
Aig_ObjSetTravIdCurrent( pAig, Aig_Regular(pAnd) );
}
// traverse from the root node
pAnd = pNode->pCopy;
if ( !Aig_ManSpeedupNode_rec( pAig, Aig_Regular(pAnd), vNodes ) )
{
// printf( "Bad node!!!\n" );
Vec_PtrFree( vNodes );
return;
}
// derive cofactors
nCofs = (1 << Vec_PtrSize(vTimes));
for ( i = 0; i < nCofs; i++ )
{
Vec_PtrForEachEntry( vLeaves, pObj, k )
{
pAnd = pObj->pCopy;
Aig_Regular(pAnd)->pData = Aig_Regular(pAnd);
}
Vec_PtrForEachEntry( vTimes, pObj, k )
{
pAnd = pObj->pCopy;
Aig_Regular(pAnd)->pData = Aig_NotCond( Aig_ManConst1(pAig), ((i & (1<<k)) == 0) );
}
Vec_PtrForEachEntry( vNodes, pTemp, k )
pTemp->pData = Aig_And( pAig, Aig_ObjChild0Copy(pTemp), Aig_ObjChild1Copy(pTemp) );
// save the result
pAnd = pNode->pCopy;
ppCofs[i] = Aig_NotCond( Aig_Regular(pAnd)->pData, Aig_IsComplement(pAnd) );
}
Vec_PtrFree( vNodes );
//Nwk_ObjAddFanin( Nwk_ManCreatePo(pAig), ppCofs[0] );
//Nwk_ObjAddFanin( Nwk_ManCreatePo(pAig), ppCofs[1] );
// collect the resulting tree
Vec_PtrForEachEntry( vTimes, pObj, k )
for ( nSkip = (1<<k), i = 0; i < nCofs; i += 2*nSkip )
{
pAnd = pObj->pCopy;
ppCofs[i] = Aig_Mux( pAig, Aig_Regular(pAnd), ppCofs[i+nSkip], ppCofs[i] );
}
//Nwk_ObjAddFanin( Nwk_ManCreatePo(pAig), ppCofs[0] );
// create choice node
pAnd = Aig_Regular(pNode->pCopy); // repr
pTemp = Aig_Regular(ppCofs[0]); // new
if ( pAig->pEquivs[pAnd->Id] == NULL && pAig->pEquivs[pTemp->Id] == NULL && !Aig_ObjCheckTfi(pAig, pTemp, pAnd) )
pAig->pEquivs[pAnd->Id] = pTemp;
}
/**Function*************************************************************
Synopsis [Determines timing-critical edges of the node.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
unsigned Nwk_ManDelayTraceTCEdges( Nwk_Man_t * pNtk, Nwk_Obj_t * pNode, float tDelta, int fUseLutLib )
{
int pPinPerm[32];
float pPinDelays[32];
If_Lib_t * pLutLib = fUseLutLib? pNtk->pLutLib : NULL;
Nwk_Obj_t * pFanin;
unsigned uResult = 0;
float tRequired, * pDelays;
int k;
tRequired = Nwk_ObjRequired(pNode);
if ( pLutLib == NULL )
{
Nwk_ObjForEachFanin( pNode, pFanin, k )
if ( tRequired < Nwk_ObjArrival(pFanin) + 1.0 + tDelta )
uResult |= (1 << k);
}
else if ( !pLutLib->fVarPinDelays )
{
pDelays = pLutLib->pLutDelays[Nwk_ObjFaninNum(pNode)];
Nwk_ObjForEachFanin( pNode, pFanin, k )
if ( tRequired < Nwk_ObjArrival(pFanin) + pDelays[0] + tDelta )
uResult |= (1 << k);
}
else
{
pDelays = pLutLib->pLutDelays[Nwk_ObjFaninNum(pNode)];
Nwk_ManDelayTraceSortPins( pNode, pPinPerm, pPinDelays );
Nwk_ObjForEachFanin( pNode, pFanin, k )
if ( tRequired < Nwk_ObjArrival(Nwk_ObjFanin(pNode,pPinPerm[k])) + pDelays[k] + tDelta )
uResult |= (1 << pPinPerm[k]);
}
return uResult;
}
/**Function*************************************************************
Synopsis [Adds choices to speed up the network by the given percentage.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Aig_Man_t * Nwk_ManSpeedup( Nwk_Man_t * pNtk, int fUseLutLib, int Percentage, int Degree, int fVerbose, int fVeryVerbose )
{
Aig_Man_t * pAig, * pTemp;
Vec_Ptr_t * vTimeCries, * vTimeFanins;
Nwk_Obj_t * pNode, * pFanin, * pFanin2;
Aig_Obj_t * pAnd;
If_Lib_t * pTempLib = pNtk->pLutLib;
float tDelta, tArrival;
int i, k, k2, Counter, CounterRes, nTimeCris;
unsigned * puTCEdges;
// perform delay trace
if ( !fUseLutLib )
pNtk->pLutLib = NULL;
tArrival = Nwk_ManDelayTraceLut( pNtk );
tDelta = fUseLutLib ? tArrival*Percentage/100.0 : 1.0;
if ( fVerbose )
{
printf( "Max delay = %.2f. Delta = %.2f. ", tArrival, tDelta );
printf( "Using %s model. ", fUseLutLib? "LUT library" : "unit-delay" );
if ( fUseLutLib )
printf( "Percentage = %d. ", Percentage );
printf( "\n" );
}
// mark the timing critical nodes and edges
puTCEdges = ALLOC( int, Nwk_ManObjNumMax(pNtk) );
memset( puTCEdges, 0, sizeof(int) * Nwk_ManObjNumMax(pNtk) );
Nwk_ManForEachNode( pNtk, pNode, i )
{
if ( Nwk_ObjSlack(pNode) >= tDelta )
continue;
puTCEdges[pNode->Id] = Nwk_ManDelayTraceTCEdges( pNtk, pNode, tDelta, fUseLutLib );
}
if ( fVerbose )
{
Counter = CounterRes = 0;
Nwk_ManForEachNode( pNtk, pNode, i )
{
Nwk_ObjForEachFanin( pNode, pFanin, k )
if ( !Nwk_ObjIsCi(pFanin) && Nwk_ObjSlack(pFanin) < tDelta )
Counter++;
CounterRes += Aig_WordCountOnes( puTCEdges[pNode->Id] );
}
printf( "Edges: Total = %7d. 0-slack = %7d. Critical = %7d. Ratio = %4.2f\n",
Nwk_ManGetTotalFanins(pNtk), Counter, CounterRes, Counter? 1.0*CounterRes/Counter : 0.0 );
}
// start the resulting network
pAig = Nwk_ManStrash( pNtk );
pAig->pEquivs = ALLOC( Aig_Obj_t *, 3 * Aig_ManObjNumMax(pAig) );
memset( pAig->pEquivs, 0, sizeof(Aig_Obj_t *) * 3 * Aig_ManObjNumMax(pAig) );
// collect nodes to be used for resynthesis
Counter = CounterRes = 0;
vTimeCries = Vec_PtrAlloc( 16 );
vTimeFanins = Vec_PtrAlloc( 16 );
Nwk_ManForEachNode( pNtk, pNode, i )
{
if ( Nwk_ObjSlack(pNode) >= tDelta )
continue;
// count the number of non-PI timing-critical nodes
nTimeCris = 0;
Nwk_ObjForEachFanin( pNode, pFanin, k )
if ( !Nwk_ObjIsCi(pFanin) && (puTCEdges[pNode->Id] & (1<<k)) )
nTimeCris++;
if ( !fVeryVerbose && nTimeCris == 0 )
continue;
Counter++;
// count the total number of timing critical second-generation nodes
Vec_PtrClear( vTimeCries );
if ( nTimeCris )
{
Nwk_ObjForEachFanin( pNode, pFanin, k )
if ( !Nwk_ObjIsCi(pFanin) && (puTCEdges[pNode->Id] & (1<<k)) )
Nwk_ObjForEachFanin( pFanin, pFanin2, k2 )
if ( puTCEdges[pFanin->Id] & (1<<k2) )
Vec_PtrPushUnique( vTimeCries, pFanin2 );
}
// if ( !fVeryVerbose && (Vec_PtrSize(vTimeCries) == 0 || Vec_PtrSize(vTimeCries) > Degree) )
if ( (Vec_PtrSize(vTimeCries) == 0 || Vec_PtrSize(vTimeCries) > Degree) )
continue;
CounterRes++;
// collect second generation nodes
Vec_PtrClear( vTimeFanins );
Nwk_ObjForEachFanin( pNode, pFanin, k )
{
if ( Nwk_ObjIsCi(pFanin) )
Vec_PtrPushUnique( vTimeFanins, pFanin );
else
Nwk_ObjForEachFanin( pFanin, pFanin2, k2 )
Vec_PtrPushUnique( vTimeFanins, pFanin2 );
}
// print the results
if ( fVeryVerbose )
{
printf( "%5d Node %5d : %d %2d %2d ", Counter, pNode->Id,
nTimeCris, Vec_PtrSize(vTimeCries), Vec_PtrSize(vTimeFanins) );
Nwk_ObjForEachFanin( pNode, pFanin, k )
printf( "%d(%.2f)%s ", pFanin->Id, Nwk_ObjSlack(pFanin), (puTCEdges[pNode->Id] & (1<<k))? "*":"" );
printf( "\n" );
}
// add the node to choices
if ( Vec_PtrSize(vTimeCries) == 0 || Vec_PtrSize(vTimeCries) > Degree )
continue;
// order the fanins in the increasing order of criticalily
if ( Vec_PtrSize(vTimeCries) > 1 )
{
pFanin = Vec_PtrEntry( vTimeCries, 0 );
pFanin2 = Vec_PtrEntry( vTimeCries, 1 );
if ( Nwk_ObjSlack(pFanin) < Nwk_ObjSlack(pFanin2) )
{
Vec_PtrWriteEntry( vTimeCries, 0, pFanin2 );
Vec_PtrWriteEntry( vTimeCries, 1, pFanin );
}
}
if ( Vec_PtrSize(vTimeCries) > 2 )
{
pFanin = Vec_PtrEntry( vTimeCries, 1 );
pFanin2 = Vec_PtrEntry( vTimeCries, 2 );
if ( Nwk_ObjSlack(pFanin) < Nwk_ObjSlack(pFanin2) )
{
Vec_PtrWriteEntry( vTimeCries, 1, pFanin2 );
Vec_PtrWriteEntry( vTimeCries, 2, pFanin );
}
pFanin = Vec_PtrEntry( vTimeCries, 0 );
pFanin2 = Vec_PtrEntry( vTimeCries, 1 );
if ( Nwk_ObjSlack(pFanin) < Nwk_ObjSlack(pFanin2) )
{
Vec_PtrWriteEntry( vTimeCries, 0, pFanin2 );
Vec_PtrWriteEntry( vTimeCries, 1, pFanin );
}
}
// add choice
Aig_ManSpeedupNode( pNtk, pAig, pNode, vTimeFanins, vTimeCries );
}
Vec_PtrFree( vTimeCries );
Vec_PtrFree( vTimeFanins );
free( puTCEdges );
if ( fVerbose )
printf( "Nodes: Total = %7d. 0-slack = %7d. Workable = %7d. Ratio = %4.2f\n",
Nwk_ManNodeNum(pNtk), Counter, CounterRes, Counter? 1.0*CounterRes/Counter : 0.0 );
// remove invalid choice nodes
Aig_ManForEachNode( pAig, pAnd, i )
if ( pAig->pEquivs[pAnd->Id] )
{
if ( Aig_ObjRefs(pAig->pEquivs[pAnd->Id]) > 0 )
pAig->pEquivs[pAnd->Id] = NULL;
}
// put back the library
if ( !fUseLutLib )
pNtk->pLutLib = pTempLib;
// reconstruct the network
pAig = Aig_ManDupDfs( pTemp = pAig );
Aig_ManStop( pTemp );
// reset levels
Aig_ManChoiceLevel( pAig );
return pAig;
}
////////////////////////////////////////////////////////////////////////

29
src/base/abci/abc.c
View File

@ -215,6 +215,7 @@ static int Abc_CommandAbc8Mfs ( Abc_Frame_t * pAbc, int argc, char ** arg
static int Abc_CommandAbc8Lutpack ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandAbc8Balance ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandAbc8Speedup ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandAbc8Fraig ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandAbc8Cec ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandAbc8Scl ( Abc_Frame_t * pAbc, int argc, char ** argv );
static int Abc_CommandAbc8Lcorr ( Abc_Frame_t * pAbc, int argc, char ** argv );
@ -450,6 +451,7 @@ void Abc_Init( Abc_Frame_t * pAbc )
Cmd_CommandAdd( pAbc, "ABC8", "*lp", Abc_CommandAbc8Lutpack, 0 );
Cmd_CommandAdd( pAbc, "ABC8", "*b", Abc_CommandAbc8Balance, 0 );
Cmd_CommandAdd( pAbc, "ABC8", "*speedup", Abc_CommandAbc8Speedup, 0 );
Cmd_CommandAdd( pAbc, "ABC8", "*fraig", Abc_CommandAbc8Fraig, 0 );
Cmd_CommandAdd( pAbc, "ABC8", "*cec", Abc_CommandAbc8Cec, 0 );
Cmd_CommandAdd( pAbc, "ABC8", "*scl", Abc_CommandAbc8Scl, 0 );
Cmd_CommandAdd( pAbc, "ABC8", "*lcorr", Abc_CommandAbc8Lcorr, 0 );
@ -15674,9 +15676,14 @@ int Abc_CommandAbc8Speedup( Abc_Frame_t * pAbc, int argc, char ** argv )
int Degree;
int fVerbose;
int fVeryVerbose;
extern Aig_Man_t * Nwk_ManSpeedup( void * pNtk );
extern Aig_Man_t * Nwk_ManSpeedup( void * pNtk, int fUseLutLib, int Percentage, int Degree, int fVerbose, int fVeryVerbose );
// set defaults
fUseLutLib = 0;
Percentage = 3;
Degree = 2;
fVerbose = 0;
fVeryVerbose = 0;
Extra_UtilGetoptReset();
while ( ( c = Extra_UtilGetopt( argc, argv, "PNlvwh" ) ) != EOF )
{
@ -15724,8 +15731,8 @@ int Abc_CommandAbc8Speedup( Abc_Frame_t * pAbc, int argc, char ** argv )
printf( "Abc_CommandAbc8DChoice(): There is no mapped network to strash.\n" );
return 1;
}
pAigNew = Nwk_ManSpeedup( pAbc->pAbc8Nwk );
pAigNew = Nwk_ManSpeedup( pAbc->pAbc8Nwk, fUseLutLib, Percentage, Degree, fVerbose, fVeryVerbose );
if ( pAigNew == NULL )
{
printf( "Abc_CommandAbc8Speedup(): Tranformation of the AIG has failed.\n" );
@ -15748,6 +15755,22 @@ usage:
return 1;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Abc_CommandAbc8Fraig( Abc_Frame_t * pAbc, int argc, char ** argv )
{
return 0;
}
/**Function*************************************************************
Synopsis []

92
src/base/abci/abcDelay.c
View File

@ -227,52 +227,6 @@ float Abc_NtkDelayTraceLut( Abc_Ntk_t * pNtk, int fUseLutLib )
return tArrival;
}
/**Function*************************************************************
Synopsis [Determines timing-critical edges of the node.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
unsigned Abc_NtkDelayTraceTCEdges( Abc_Ntk_t * pNtk, Abc_Obj_t * pNode, float tDelta, int fUseLutLib )
{
int pPinPerm[32];
float pPinDelays[32];
If_Lib_t * pLutLib;
Abc_Obj_t * pFanin;
unsigned uResult = 0;
float tRequired, * pDelays;
int k;
pLutLib = fUseLutLib? Abc_FrameReadLibLut() : NULL;
tRequired = Abc_ObjRequired(pNode);
if ( pLutLib == NULL )
{
Abc_ObjForEachFanin( pNode, pFanin, k )
if ( tRequired < Abc_ObjArrival(pFanin) + 1.0 + tDelta )
uResult |= (1 << k);
}
else if ( !pLutLib->fVarPinDelays )
{
pDelays = pLutLib->pLutDelays[Abc_ObjFaninNum(pNode)];
Abc_ObjForEachFanin( pNode, pFanin, k )
if ( tRequired < Abc_ObjArrival(pFanin) + pDelays[0] + tDelta )
uResult |= (1 << k);
}
else
{
pDelays = pLutLib->pLutDelays[Abc_ObjFaninNum(pNode)];
Abc_NtkDelayTraceSortPins( pNode, pPinPerm, pPinDelays );
Abc_ObjForEachFanin( pNode, pFanin, k )
if ( tRequired < Abc_ObjArrival(Abc_ObjFanin(pNode,pPinPerm[k])) + pDelays[k] + tDelta )
uResult |= (1 << pPinPerm[k]);
}
return uResult;
}
/**Function*************************************************************
Synopsis [Delay tracing of the LUT mapped network.]
@ -495,6 +449,52 @@ void Abc_NtkSpeedupNode( Abc_Ntk_t * pNtk, Abc_Ntk_t * pAig, Abc_Obj_t * pNode,
}
/**Function*************************************************************
Synopsis [Determines timing-critical edges of the node.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
unsigned Abc_NtkDelayTraceTCEdges( Abc_Ntk_t * pNtk, Abc_Obj_t * pNode, float tDelta, int fUseLutLib )
{
int pPinPerm[32];
float pPinDelays[32];
If_Lib_t * pLutLib;
Abc_Obj_t * pFanin;
unsigned uResult = 0;
float tRequired, * pDelays;
int k;
pLutLib = fUseLutLib? Abc_FrameReadLibLut() : NULL;
tRequired = Abc_ObjRequired(pNode);
if ( pLutLib == NULL )
{
Abc_ObjForEachFanin( pNode, pFanin, k )
if ( tRequired < Abc_ObjArrival(pFanin) + 1.0 + tDelta )
uResult |= (1 << k);
}
else if ( !pLutLib->fVarPinDelays )
{
pDelays = pLutLib->pLutDelays[Abc_ObjFaninNum(pNode)];
Abc_ObjForEachFanin( pNode, pFanin, k )
if ( tRequired < Abc_ObjArrival(pFanin) + pDelays[0] + tDelta )
uResult |= (1 << k);
}
else
{
pDelays = pLutLib->pLutDelays[Abc_ObjFaninNum(pNode)];
Abc_NtkDelayTraceSortPins( pNode, pPinPerm, pPinDelays );
Abc_ObjForEachFanin( pNode, pFanin, k )
if ( tRequired < Abc_ObjArrival(Abc_ObjFanin(pNode,pPinPerm[k])) + pDelays[k] + tDelta )
uResult |= (1 << pPinPerm[k]);
}
return uResult;
}
/**Function*************************************************************
Synopsis [Adds choices to speed up the network by the given percentage.]