/**Function*************************************************************
Synopsis [Computes delay.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
float Amap_ManMaxDelay( Amap_Man_t * p )
{
Amap_Obj_t * pObj;
float Delay = 0.0;
int i;
Amap_ManForEachPo( p, pObj, i )
Delay = ABC_MAX( Delay, Amap_ObjFanin0(p,pObj)->Best.Delay );
return Delay;
}
/**Function*************************************************************
Synopsis [Sets the default arrival time for the network.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_NtkTimeSetDefaultRequired( Abc_Ntk_t * pNtk, float Rise, float Fall )
{
if ( Rise == 0.0 && Fall == 0.0 )
return;
if ( pNtk->pManTime == NULL )
pNtk->pManTime = Abc_ManTimeStart();
pNtk->pManTime->tReqDef.Rise = Rise;
pNtk->pManTime->tReqDef.Rise = Fall;
pNtk->pManTime->tReqDef.Worst = ABC_MAX( Rise, Fall );
}
Kit_GraphForEachNode( pGraph, pNode, i )
{
// get the children of this node
pNode0 = Kit_GraphNode( pGraph, pNode->eEdge0.Node );
pNode1 = Kit_GraphNode( pGraph, pNode->eEdge1.Node );
// get the AIG nodes corresponding to the children
pAnd0 = (Aig_Obj_t *)pNode0->pFunc;
pAnd1 = (Aig_Obj_t *)pNode1->pFunc;
if ( pAnd0 && pAnd1 )
{
// if they are both present, find the resulting node
pAnd0 = Aig_NotCond( pAnd0, pNode->eEdge0.fCompl );
pAnd1 = Aig_NotCond( pAnd1, pNode->eEdge1.fCompl );
pAnd = Aig_TableLookupTwo( pAig, pAnd0, pAnd1 );
// return -1 if the node is the same as the original root
if ( Aig_Regular(pAnd) == pRoot )
return -1;
}
else
pAnd = NULL;
// count the number of added nodes
if ( pAnd == NULL || Aig_ObjIsTravIdCurrent(pAig, Aig_Regular(pAnd)) )
{
if ( ++Counter > NodeMax )
return -1;
}
// count the number of new levels
LevelNew = 1 + ABC_MAX( pNode0->Level, pNode1->Level );
if ( pAnd )
{
if ( Aig_Regular(pAnd) == Aig_ManConst1(pAig) )
LevelNew = 0;
else if ( Aig_Regular(pAnd) == Aig_Regular(pAnd0) )
LevelNew = (int)Aig_Regular(pAnd0)->Level;
else if ( Aig_Regular(pAnd) == Aig_Regular(pAnd1) )
LevelNew = (int)Aig_Regular(pAnd1)->Level;
LevelOld = (int)Aig_Regular(pAnd)->Level;
// assert( LevelNew == LevelOld );
}
if ( LevelNew > LevelMax )
return -1;
pNode->pFunc = pAnd;
pNode->Level = LevelNew;
/*
printf( "Checking " );
Ref_ObjPrint( pAnd0 );
printf( " and " );
Ref_ObjPrint( pAnd1 );
printf( " Result " );
Ref_ObjPrint( pNode->pFunc );
printf( "\n" );
*/
}
/**Function*************************************************************
Synopsis [Sets the arrival time for an object.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Abc_NtkTimeSetRequired( Abc_Ntk_t * pNtk, int ObjId, float Rise, float Fall )
{
Vec_Ptr_t * vTimes;
Abc_Time_t * pTime;
if ( pNtk->pManTime == NULL )
pNtk->pManTime = Abc_ManTimeStart();
if ( pNtk->pManTime->tReqDef.Rise == Rise && pNtk->pManTime->tReqDef.Fall == Fall )
return;
Abc_ManTimeExpand( pNtk->pManTime, ObjId + 1, 1 );
// set the required time
vTimes = pNtk->pManTime->vReqs;
pTime = vTimes->pArray[ObjId];
pTime->Rise = Rise;
pTime->Fall = Rise;
pTime->Worst = ABC_MAX( Rise, Fall );
}
/**Function*************************************************************
Synopsis [Precomputes the forest in the manager.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Rwr_ManPrecompute( Rwr_Man_t * p )
{
Rwr_Node_t * p0, * p1;
int i, k, Level, Volume;
int LevelOld = -1;
int nNodes;
Vec_PtrForEachEntryStart( Rwr_Node_t *, p->vForest, p0, i, 1 )
Vec_PtrForEachEntryStart( Rwr_Node_t *, p->vForest, p1, k, 1 )
{
if ( LevelOld < (int)p0->Level )
{
LevelOld = p0->Level;
printf( "Starting level %d (at %d nodes).\n", LevelOld+1, i );
printf( "Considered = %5d M. Found = %8d. Classes = %6d. Trying %7d.\n",
p->nConsidered/1000000, p->vForest->nSize, p->nClasses, i );
}
if ( k == i )
break;
// if ( p0->Level + p1->Level > 6 ) // hard
// break;
if ( p0->Level + p1->Level > 5 ) // easy
break;
// if ( p0->Level + p1->Level > 6 || (p0->Level == 3 && p1->Level == 3) )
// break;
// compute the level and volume of the new nodes
Level = 1 + ABC_MAX( p0->Level, p1->Level );
Volume = 1 + Rwr_ManNodeVolume( p, p0, p1 );
// try four different AND nodes
Rwr_ManTryNode( p, p0 , p1 , 0, Level, Volume );
Rwr_ManTryNode( p, Rwr_Not(p0), p1 , 0, Level, Volume );
Rwr_ManTryNode( p, p0 , Rwr_Not(p1), 0, Level, Volume );
Rwr_ManTryNode( p, Rwr_Not(p0), Rwr_Not(p1), 0, Level, Volume );
// try EXOR
Rwr_ManTryNode( p, p0 , p1 , 1, Level, Volume + 1 );
// report the progress
if ( p->nConsidered % 50000000 == 0 )
printf( "Considered = %5d M. Found = %8d. Classes = %6d. Trying %7d.\n",
p->nConsidered/1000000, p->vForest->nSize, p->nClasses, i );
// quit after some time
if ( p->vForest->nSize == RWR_LIMIT + 5 )
{
printf( "Considered = %5d M. Found = %8d. Classes = %6d. Trying %7d.\n",
p->nConsidered/1000000, p->vForest->nSize, p->nClasses, i );
goto save;
}
}
save :
// mark the relevant ones
Rwr_ManIncTravId( p );
k = 5;
nNodes = 0;
Vec_PtrForEachEntryStart( Rwr_Node_t *, p->vForest, p0, i, 5 )
if ( p0->uTruth == p->puCanons[p0->uTruth] )
{
Rwr_MarkUsed_rec( p, p0 );
nNodes++;
}
// compact the array by throwing away non-canonical
k = 5;
Vec_PtrForEachEntryStart( Rwr_Node_t *, p->vForest, p0, i, 5 )
if ( p0->fUsed )
{
p->vForest->pArray[k] = p0;
p0->Id = k++;
}
p->vForest->nSize = k;
printf( "Total canonical = %4d. Total used = %5d.\n", nNodes, p->vForest->nSize );
}
