mirror of https://github.com/YosysHQ/abc.git
506 lines
18 KiB
C
506 lines
18 KiB
C
/**CFile****************************************************************
|
|
|
|
FileName [bmcUnroll.c]
|
|
|
|
SystemName [ABC: Logic synthesis and verification system.]
|
|
|
|
PackageName [SAT-based bounded model checking.]
|
|
|
|
Synopsis [Unrolling manager.]
|
|
|
|
Author [Alan Mishchenko]
|
|
|
|
Affiliation [UC Berkeley]
|
|
|
|
Date [Ver. 1.0. Started - June 20, 2005.]
|
|
|
|
Revision [$Id: bmc.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
|
|
|
|
***********************************************************************/
|
|
|
|
#include "bmc.h"
|
|
|
|
ABC_NAMESPACE_IMPL_START
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// DECLARATIONS ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
#define UNR_DIFF_NULL 0x7FFF
|
|
|
|
typedef struct Unr_Obj_t_ Unr_Obj_t; // 24 bytes + (RankMax-1) * 4 bytes
|
|
struct Unr_Obj_t_
|
|
{
|
|
unsigned hFan0; // address of the fanin
|
|
unsigned hFan1; // address of the fanin
|
|
unsigned fCompl0 : 1; // complemented bit
|
|
unsigned fCompl1 : 1; // complemented bit
|
|
unsigned uRDiff0 : 15; // rank diff of the fanin
|
|
unsigned uRDiff1 : 15; // rank diff of the fanin
|
|
unsigned fItIsPi : 1; // remember attributes
|
|
unsigned fItIsPo : 1; // remember attributes
|
|
unsigned RankMax : 15; // max rank diff between node and its fanout
|
|
unsigned RankCur : 15; // cur rank of the node
|
|
unsigned OrigId; // original object ID
|
|
unsigned Res[1]; // RankMax entries
|
|
};
|
|
|
|
struct Unr_Man_t_
|
|
{
|
|
// input data
|
|
Gia_Man_t * pGia; // the user's AIG manager
|
|
Gia_Man_t * pFrames; // unrolled manager
|
|
int nObjs; // the number of objects
|
|
// intermediate data
|
|
Vec_Int_t * vOrder; // ordering of GIA objects
|
|
Vec_Int_t * vOrderLim; // beginning of each time frame
|
|
Vec_Int_t * vTents; // tents of GIA objects
|
|
Vec_Int_t * vRanks; // ranks of GIA objects
|
|
// unrolling data
|
|
int * pObjs; // storage for unroling objects
|
|
int * pEnd; // end of storage
|
|
Vec_Int_t * vObjLim; // handle of the first object in each frame
|
|
Vec_Int_t * vCiMap; // mapping of GIA CIs into unrolling objects
|
|
Vec_Int_t * vCoMap; // mapping of GIA POs into unrolling objects
|
|
Vec_Int_t * vPiLits; // storage for PI literals
|
|
};
|
|
|
|
static inline Unr_Obj_t * Unr_ManObj( Unr_Man_t * p, int h ) { assert( h >= 0 && h < p->pEnd - p->pObjs ); return (Unr_Obj_t *)(p->pObjs + h); }
|
|
static inline int Unr_ObjSizeInt( int Rank ) { return 0xFFFFFFFE & (sizeof(Unr_Obj_t) / sizeof(int) + Rank); }
|
|
static inline int Unr_ObjSize( Unr_Obj_t * pObj ) { return Unr_ObjSizeInt(pObj->RankMax); }
|
|
|
|
static inline int Unr_ManFanin0Value( Unr_Man_t * p, Unr_Obj_t * pObj )
|
|
{
|
|
Unr_Obj_t * pFanin = Unr_ManObj( p, pObj->hFan0 );
|
|
int Index = (pFanin->RankCur + pFanin->RankMax - pObj->uRDiff0) % pFanin->RankMax;
|
|
assert( pFanin->RankCur < pFanin->RankMax );
|
|
assert( pObj->uRDiff0 < pFanin->RankMax );
|
|
return Abc_LitNotCond( pFanin->Res[Index], pObj->fCompl0 );
|
|
}
|
|
static inline int Unr_ManFanin1Value( Unr_Man_t * p, Unr_Obj_t * pObj )
|
|
{
|
|
Unr_Obj_t * pFanin = Unr_ManObj( p, pObj->hFan1 );
|
|
int Index = (pFanin->RankCur + pFanin->RankMax - pObj->uRDiff1) % pFanin->RankMax;
|
|
assert( pFanin->RankCur < pFanin->RankMax );
|
|
assert( pObj->uRDiff1 < pFanin->RankMax );
|
|
return Abc_LitNotCond( pFanin->Res[Index], pObj->fCompl1 );
|
|
}
|
|
static inline int Unr_ManObjReadValue( Unr_Obj_t * pObj )
|
|
{
|
|
assert( pObj->RankCur >= 0 && pObj->RankCur < pObj->RankMax );
|
|
return pObj->Res[ pObj->RankCur ];
|
|
}
|
|
static inline void Unr_ManObjSetValue( Unr_Obj_t * pObj, int Value )
|
|
{
|
|
assert( Value >= 0 );
|
|
pObj->RankCur = (UNR_DIFF_NULL & (pObj->RankCur + 1)) % pObj->RankMax;
|
|
pObj->Res[ pObj->RankCur ] = Value;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// FUNCTION DEFINITIONS ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
/**Function*************************************************************
|
|
|
|
Synopsis []
|
|
|
|
Description []
|
|
|
|
SideEffects []
|
|
|
|
SeeAlso []
|
|
|
|
***********************************************************************/
|
|
static inline void Vec_IntWriteMaxEntry( Vec_Int_t * p, int i, int Entry )
|
|
{
|
|
assert( i >= 0 && i < p->nSize );
|
|
p->pArray[i] = Abc_MaxInt( p->pArray[i], Entry );
|
|
}
|
|
|
|
/**Function*************************************************************
|
|
|
|
Synopsis []
|
|
|
|
Description []
|
|
|
|
SideEffects []
|
|
|
|
SeeAlso []
|
|
|
|
***********************************************************************/
|
|
void Unr_ManProfileRanks( Vec_Int_t * vRanks )
|
|
{
|
|
int RankMax = Vec_IntFindMax( vRanks );
|
|
Vec_Int_t * vCounts = Vec_IntStart( RankMax+1 );
|
|
int i, Rank, Count, nExtras = 0;
|
|
Vec_IntForEachEntry( vRanks, Rank, i )
|
|
Vec_IntAddToEntry( vCounts, Rank, 1 );
|
|
Vec_IntForEachEntry( vCounts, Count, i )
|
|
{
|
|
if ( Count == 0 )
|
|
continue;
|
|
printf( "%2d : %8d (%6.2f %%)\n", i, Count, 100.0 * Count / Vec_IntSize(vRanks) );
|
|
nExtras += Count * i;
|
|
}
|
|
printf( "Extra space = %d (%6.2f %%) ", nExtras, 100.0 * nExtras / Vec_IntSize(vRanks) );
|
|
Vec_IntFree( vCounts );
|
|
}
|
|
|
|
/**Function*************************************************************
|
|
|
|
Synopsis []
|
|
|
|
Description []
|
|
|
|
SideEffects []
|
|
|
|
SeeAlso []
|
|
|
|
***********************************************************************/
|
|
void Unr_ManSetup_rec( Unr_Man_t * p, int iObj, int iTent, Vec_Int_t * vRoots )
|
|
{
|
|
Gia_Obj_t * pObj;
|
|
int iFanin;
|
|
if ( Vec_IntEntry(p->vTents, iObj) >= 0 )
|
|
return;
|
|
Vec_IntWriteEntry(p->vTents, iObj, iTent);
|
|
pObj = Gia_ManObj( p->pGia, iObj );
|
|
if ( Gia_ObjIsAnd(pObj) || Gia_ObjIsCo(pObj) )
|
|
{
|
|
Unr_ManSetup_rec( p, (iFanin = Gia_ObjFaninId0(pObj, iObj)), iTent, vRoots );
|
|
Vec_IntWriteMaxEntry( p->vRanks, iFanin, Abc_MaxInt(0, iTent - Vec_IntEntry(p->vTents, iFanin) - 1) );
|
|
}
|
|
if ( Gia_ObjIsAnd(pObj) )
|
|
{
|
|
Unr_ManSetup_rec( p, (iFanin = Gia_ObjFaninId1(pObj, iObj)), iTent, vRoots );
|
|
Vec_IntWriteMaxEntry( p->vRanks, iFanin, Abc_MaxInt(0, iTent - Vec_IntEntry(p->vTents, iFanin) - 1) );
|
|
}
|
|
else if ( Gia_ObjIsRo(p->pGia, pObj) )
|
|
{
|
|
Vec_IntPush( vRoots, (iFanin = Gia_ObjId(p->pGia, Gia_ObjRoToRi(p->pGia, pObj))) );
|
|
Vec_IntWriteMaxEntry( p->vRanks, iFanin, 0 );
|
|
}
|
|
Vec_IntPush( p->vOrder, iObj );
|
|
}
|
|
void Unr_ManSetup( Unr_Man_t * p, int fVerbose )
|
|
{
|
|
Vec_Int_t * vRoots, * vRoots2, * vMap;
|
|
Unr_Obj_t * pUnrObj;
|
|
Gia_Obj_t * pObj;
|
|
int i, k, t, iObj, nInts, * pInts;
|
|
abctime clk = Abc_Clock();
|
|
// create zero rank
|
|
assert( Vec_IntSize(p->vOrder) == 0 );
|
|
Vec_IntPush( p->vOrder, 0 );
|
|
Vec_IntPush( p->vOrderLim, Vec_IntSize(p->vOrder) );
|
|
Vec_IntWriteEntry( p->vTents, 0, 0 );
|
|
Vec_IntWriteEntry( p->vRanks, 0, 0 );
|
|
// start from the POs
|
|
vRoots = Vec_IntAlloc( 100 );
|
|
vRoots2 = Vec_IntAlloc( 100 );
|
|
Gia_ManForEachPo( p->pGia, pObj, i )
|
|
Unr_ManSetup_rec( p, Gia_ObjId(p->pGia, pObj), 0, vRoots );
|
|
// collect tents
|
|
while ( Vec_IntSize(vRoots) > 0 )
|
|
{
|
|
Vec_IntPush( p->vOrderLim, Vec_IntSize(p->vOrder) );
|
|
Vec_IntClear( vRoots2 );
|
|
Vec_IntForEachEntry( vRoots, iObj, i )
|
|
Unr_ManSetup_rec( p, iObj, Vec_IntSize(p->vOrderLim)-1, vRoots2 );
|
|
ABC_SWAP( Vec_Int_t *, vRoots, vRoots2 );
|
|
}
|
|
Vec_IntPush( p->vOrderLim, Vec_IntSize(p->vOrder) );
|
|
Vec_IntFree( vRoots );
|
|
Vec_IntFree( vRoots2 );
|
|
// allocate memory
|
|
nInts = 0;
|
|
Vec_IntForEachEntry( p->vOrder, iObj, i )
|
|
nInts += Unr_ObjSizeInt( Vec_IntEntry(p->vRanks, iObj) + 1 );
|
|
p->pObjs = pInts = ABC_CALLOC( int, nInts );
|
|
p->pEnd = p->pObjs + nInts;
|
|
// create const0 node
|
|
pUnrObj = Unr_ManObj( p, pInts - p->pObjs );
|
|
pUnrObj->RankMax = Vec_IntEntry(p->vRanks, 0) + 1;
|
|
pUnrObj->uRDiff0 = pUnrObj->uRDiff1 = UNR_DIFF_NULL;
|
|
pUnrObj->Res[0] = 0; // const0
|
|
// map the objects
|
|
vMap = Vec_IntStartFull( p->nObjs );
|
|
Vec_IntWriteEntry( vMap, 0, pInts - p->pObjs );
|
|
pInts += Unr_ObjSize(pUnrObj);
|
|
// mark up the entries
|
|
assert( Vec_IntSize(p->vObjLim) == 0 );
|
|
for ( t = Vec_IntSize(p->vOrderLim) - 2; t >= 0; t-- )
|
|
{
|
|
int Beg = Vec_IntEntry(p->vOrderLim, t);
|
|
int End = Vec_IntEntry(p->vOrderLim, t+1);
|
|
Vec_IntPush( p->vObjLim, pInts - p->pObjs );
|
|
Vec_IntForEachEntryStartStop( p->vOrder, iObj, i, Beg, End )
|
|
{
|
|
pObj = Gia_ManObj( p->pGia, iObj );
|
|
pUnrObj = Unr_ManObj( p, pInts - p->pObjs );
|
|
pUnrObj->uRDiff0 = pUnrObj->uRDiff1 = UNR_DIFF_NULL;
|
|
if ( Gia_ObjIsAnd(pObj) || Gia_ObjIsCo(pObj) )
|
|
pUnrObj->uRDiff0 = Abc_MaxInt(0, Vec_IntEntry(p->vTents, iObj) - Vec_IntEntry(p->vTents, Gia_ObjFaninId0(pObj, iObj)) - 1);
|
|
if ( Gia_ObjIsAnd(pObj) )
|
|
pUnrObj->uRDiff1 = Abc_MaxInt(0, Vec_IntEntry(p->vTents, iObj) - Vec_IntEntry(p->vTents, Gia_ObjFaninId1(pObj, iObj)) - 1);
|
|
else if ( Gia_ObjIsRo(p->pGia, pObj) )
|
|
pUnrObj->uRDiff0 = 0;
|
|
pUnrObj->RankMax = Vec_IntEntry(p->vRanks, iObj) + 1;
|
|
pUnrObj->RankCur = UNR_DIFF_NULL;
|
|
pUnrObj->OrigId = iObj;
|
|
for ( k = 0; k < (int)pUnrObj->RankMax; k++ )
|
|
pUnrObj->Res[k] = -1;
|
|
assert( ((pInts - p->pObjs) & 1) == 0 ); // align for 64-bits
|
|
Vec_IntWriteEntry( vMap, iObj, pInts - p->pObjs );
|
|
pInts += Unr_ObjSize( pUnrObj );
|
|
}
|
|
}
|
|
assert( pInts - p->pObjs == nInts );
|
|
// label the objects
|
|
Gia_ManForEachObj( p->pGia, pObj, i )
|
|
{
|
|
if ( Vec_IntEntry(vMap, i) == -1 )
|
|
continue;
|
|
pUnrObj = Unr_ManObj( p, Vec_IntEntry(vMap, i) );
|
|
if ( Gia_ObjIsAnd(pObj) || Gia_ObjIsCo(pObj) )
|
|
{
|
|
pUnrObj->hFan0 = Vec_IntEntry( vMap, Gia_ObjFaninId0(pObj, i) );
|
|
pUnrObj->fCompl0 = Gia_ObjFaninC0(pObj);
|
|
pUnrObj->fItIsPo = Gia_ObjIsPo(p->pGia, pObj);
|
|
}
|
|
if ( Gia_ObjIsAnd(pObj) )
|
|
{
|
|
pUnrObj->hFan1 = Vec_IntEntry( vMap, Gia_ObjFaninId1(pObj, i) );
|
|
pUnrObj->fCompl1 = Gia_ObjFaninC1(pObj);
|
|
}
|
|
else if ( Gia_ObjIsRo(p->pGia, pObj) )
|
|
{
|
|
pUnrObj->hFan0 = Vec_IntEntry( vMap, Gia_ObjId(p->pGia, Gia_ObjRoToRi(p->pGia, pObj)) );
|
|
pUnrObj->fCompl0 = 0;
|
|
}
|
|
else if ( Gia_ObjIsPi(p->pGia, pObj) )
|
|
{
|
|
pUnrObj->hFan0 = Gia_ObjCioId(pObj); // remember CIO id
|
|
pUnrObj->hFan1 = Vec_IntEntry(p->vTents, i); // remember tent
|
|
pUnrObj->fItIsPi = 1;
|
|
}
|
|
}
|
|
// store CI/PO objects;
|
|
Gia_ManForEachCi( p->pGia, pObj, i )
|
|
Vec_IntPush( p->vCiMap, Vec_IntEntry(vMap, Gia_ObjId(p->pGia, pObj)) );
|
|
Gia_ManForEachCo( p->pGia, pObj, i )
|
|
Vec_IntPush( p->vCoMap, Vec_IntEntry(vMap, Gia_ObjId(p->pGia, pObj)) );
|
|
Vec_IntFreeP( &vMap );
|
|
// print stats
|
|
if ( fVerbose )
|
|
{
|
|
Unr_ManProfileRanks( p->vRanks );
|
|
printf( "Memory usage = %6.2f MB ", 4.0 * nInts / (1<<20) );
|
|
Abc_PrintTime( 1, "Time", Abc_Clock() - clk );
|
|
}
|
|
Vec_IntFreeP( &p->vOrder );
|
|
Vec_IntFreeP( &p->vOrderLim );
|
|
Vec_IntFreeP( &p->vRanks );
|
|
Vec_IntFreeP( &p->vTents );
|
|
}
|
|
|
|
|
|
|
|
/**Function*************************************************************
|
|
|
|
Synopsis []
|
|
|
|
Description []
|
|
|
|
SideEffects []
|
|
|
|
SeeAlso []
|
|
|
|
***********************************************************************/
|
|
Unr_Man_t * Unr_ManAlloc( Gia_Man_t * pGia )
|
|
{
|
|
Unr_Man_t * p;
|
|
p = ABC_CALLOC( Unr_Man_t, 1 );
|
|
p->pGia = pGia;
|
|
p->nObjs = Gia_ManObjNum(pGia);
|
|
p->vOrder = Vec_IntAlloc( p->nObjs );
|
|
p->vOrderLim = Vec_IntAlloc( 100 );
|
|
p->vTents = Vec_IntStartFull( p->nObjs );
|
|
p->vRanks = Vec_IntStart( p->nObjs );
|
|
p->vObjLim = Vec_IntAlloc( 100 );
|
|
p->vCiMap = Vec_IntAlloc( Gia_ManCiNum(pGia) );
|
|
p->vCoMap = Vec_IntAlloc( Gia_ManCoNum(pGia) );
|
|
p->vPiLits = Vec_IntAlloc( 10000 );
|
|
p->pFrames = Gia_ManStart( 10000 );
|
|
p->pFrames->pName = Abc_UtilStrsav( pGia->pName );
|
|
Gia_ManHashStart( p->pFrames );
|
|
return p;
|
|
}
|
|
void Unr_ManFree( Unr_Man_t * p )
|
|
{
|
|
Gia_ManStop( p->pFrames );
|
|
// intermediate data
|
|
Vec_IntFreeP( &p->vOrder );
|
|
Vec_IntFreeP( &p->vOrderLim );
|
|
Vec_IntFreeP( &p->vTents );
|
|
Vec_IntFreeP( &p->vRanks );
|
|
// unrolling data
|
|
Vec_IntFreeP( &p->vObjLim );
|
|
Vec_IntFreeP( &p->vCiMap );
|
|
Vec_IntFreeP( &p->vCoMap );
|
|
Vec_IntFreeP( &p->vPiLits );
|
|
ABC_FREE( p->pObjs );
|
|
ABC_FREE( p );
|
|
}
|
|
|
|
/**Function*************************************************************
|
|
|
|
Synopsis [Perform smart unrolling.]
|
|
|
|
Description []
|
|
|
|
SideEffects []
|
|
|
|
SeeAlso []
|
|
|
|
***********************************************************************/
|
|
Unr_Man_t * Unr_ManUnrollStart( Gia_Man_t * pGia, int fVerbose )
|
|
{
|
|
int i, iHandle;
|
|
Unr_Man_t * p;
|
|
p = Unr_ManAlloc( pGia );
|
|
Unr_ManSetup( p, fVerbose );
|
|
for ( i = 0; i < Gia_ManRegNum(p->pGia); i++ )
|
|
if ( (iHandle = Vec_IntEntry(p->vCoMap, Gia_ManPoNum(p->pGia) + i)) != -1 )
|
|
Unr_ManObjSetValue( Unr_ManObj(p, iHandle), 0 );
|
|
return p;
|
|
}
|
|
Gia_Man_t * Unr_ManUnrollFrame( Unr_Man_t * p, int f )
|
|
{
|
|
int i, iLit, iLit0, iLit1, hStart;
|
|
for ( i = 0; i < Gia_ManPiNum(p->pGia); i++ )
|
|
Vec_IntPush( p->vPiLits, Gia_ManAppendCi(p->pFrames) );
|
|
hStart = Vec_IntEntry( p->vObjLim, Abc_MaxInt(0, Vec_IntSize(p->vObjLim)-1-f) );
|
|
while ( p->pObjs + hStart < p->pEnd )
|
|
{
|
|
Unr_Obj_t * pUnrObj = Unr_ManObj( p, hStart );
|
|
if ( pUnrObj->uRDiff0 != UNR_DIFF_NULL && pUnrObj->uRDiff1 != UNR_DIFF_NULL ) // AND node
|
|
{
|
|
iLit0 = Unr_ManFanin0Value( p, pUnrObj );
|
|
iLit1 = Unr_ManFanin1Value( p, pUnrObj );
|
|
iLit = Gia_ManHashAnd( p->pFrames, iLit0, iLit1 );
|
|
Unr_ManObjSetValue( pUnrObj, iLit );
|
|
}
|
|
else if ( pUnrObj->uRDiff0 != UNR_DIFF_NULL && pUnrObj->uRDiff1 == UNR_DIFF_NULL ) // PO/RI/RO
|
|
{
|
|
iLit = Unr_ManFanin0Value( p, pUnrObj );
|
|
Unr_ManObjSetValue( pUnrObj, iLit );
|
|
if ( pUnrObj->fItIsPo )
|
|
Gia_ManAppendCo( p->pFrames, iLit );
|
|
}
|
|
else // PI (pUnrObj->hFan0 is CioId; pUnrObj->hFan1 is tent)
|
|
{
|
|
assert( pUnrObj->fItIsPi && f >= (int)pUnrObj->hFan1 );
|
|
iLit = Vec_IntEntry( p->vPiLits, Gia_ManPiNum(p->pGia) * (f - pUnrObj->hFan1) + pUnrObj->hFan0 );
|
|
Unr_ManObjSetValue( pUnrObj, iLit );
|
|
}
|
|
hStart += Unr_ObjSize( pUnrObj );
|
|
}
|
|
assert( p->pObjs + hStart == p->pEnd );
|
|
assert( Gia_ManPoNum(p->pFrames) == (f + 1) * Gia_ManPoNum(p->pGia) );
|
|
return p->pFrames;
|
|
}
|
|
Gia_Man_t * Unr_ManUnroll( Gia_Man_t * pGia, int nFrames )
|
|
{
|
|
Unr_Man_t * p;
|
|
Gia_Man_t * pFrames;
|
|
int f;
|
|
p = Unr_ManUnrollStart( pGia, 1 );
|
|
for ( f = 0; f < nFrames; f++ )
|
|
Unr_ManUnrollFrame( p, f );
|
|
pFrames = Gia_ManCleanup( p->pFrames );
|
|
Unr_ManFree( p );
|
|
return pFrames;
|
|
}
|
|
|
|
/**Function*************************************************************
|
|
|
|
Synopsis [Perform naive unrolling.]
|
|
|
|
Description []
|
|
|
|
SideEffects []
|
|
|
|
SeeAlso []
|
|
|
|
***********************************************************************/
|
|
Gia_Man_t * Unr_ManUnrollSimple( Gia_Man_t * pGia, int nFrames )
|
|
{
|
|
Gia_Man_t * pFrames;
|
|
Gia_Obj_t * pObj, * pObjRi;
|
|
int f, i;
|
|
pFrames = Gia_ManStart( 10000 );
|
|
pFrames->pName = Abc_UtilStrsav( pGia->pName );
|
|
Gia_ManHashAlloc( pFrames );
|
|
Gia_ManConst0(pGia)->Value = 0;
|
|
Gia_ManForEachRi( pGia, pObj, i )
|
|
pObj->Value = 0;
|
|
for ( f = 0; f < nFrames; f++ )
|
|
{
|
|
Gia_ManForEachPi( pGia, pObj, i )
|
|
pObj->Value = Gia_ManAppendCi(pFrames);
|
|
Gia_ManForEachRiRo( pGia, pObjRi, pObj, i )
|
|
pObj->Value = pObjRi->Value;
|
|
Gia_ManForEachAnd( pGia, pObj, i )
|
|
pObj->Value = Gia_ManHashAnd( pFrames, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
|
|
Gia_ManForEachCo( pGia, pObj, i )
|
|
pObj->Value = Gia_ObjFanin0Copy(pObj);
|
|
Gia_ManForEachPo( pGia, pObj, i )
|
|
Gia_ManAppendCo( pFrames, pObj->Value );
|
|
}
|
|
Gia_ManHashStop( pFrames );
|
|
Gia_ManSetRegNum( pFrames, 0 );
|
|
pFrames = Gia_ManCleanup( pGia = pFrames );
|
|
Gia_ManStop( pGia );
|
|
return pFrames;
|
|
}
|
|
|
|
/**Function*************************************************************
|
|
|
|
Synopsis [Perform evaluation.]
|
|
|
|
Description []
|
|
|
|
SideEffects []
|
|
|
|
SeeAlso []
|
|
|
|
***********************************************************************/
|
|
void Unr_ManTest( Gia_Man_t * pGia, int nFrames )
|
|
{
|
|
Gia_Man_t * pFrames0, * pFrames1;
|
|
abctime clk = Abc_Clock();
|
|
pFrames0 = Unr_ManUnroll( pGia, nFrames );
|
|
Abc_PrintTime( 1, "Unroll ", Abc_Clock() - clk );
|
|
clk = Abc_Clock();
|
|
pFrames1 = Unr_ManUnrollSimple( pGia, nFrames );
|
|
Abc_PrintTime( 1, "UnrollS", Abc_Clock() - clk );
|
|
|
|
Gia_ManPrintStats( pFrames0, NULL );
|
|
Gia_ManPrintStats( pFrames1, NULL );
|
|
Gia_AigerWrite( pFrames0, "frames0.aig", 0, 0, 0 );
|
|
Gia_AigerWrite( pFrames1, "frames1.aig", 0, 0, 0 );
|
|
|
|
Gia_ManStop( pFrames0 );
|
|
Gia_ManStop( pFrames1 );
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
/// END OF FILE ///
|
|
////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
ABC_NAMESPACE_IMPL_END
|
|
|