mirror of https://github.com/YosysHQ/abc.git
Isomorphism checking code.
This commit is contained in:
Alan Mishchenko
parent
a9980135a0
commit
e405d71398
|
|
@ -0,0 +1,600 @@
|
|||
/**CFile****************************************************************
|
||||
|
||||
FileName [giaIso.c]
|
||||
|
||||
SystemName [ABC: Logic synthesis and verification system.]
|
||||
|
||||
PackageName [Scalable AIG package.]
|
||||
|
||||
Synopsis [Graph isomorphism.]
|
||||
|
||||
Author [Alan Mishchenko]
|
||||
|
||||
Affiliation [UC Berkeley]
|
||||
|
||||
Date [Ver. 1.0. Started - June 20, 2005.]
|
||||
|
||||
Revision [$Id: giaIso.c,v 1.00 2005/06/20 00:00:00 alanmi Exp $]
|
||||
|
||||
***********************************************************************/
|
||||
|
||||
#include "gia.h"
|
||||
|
||||
ABC_NAMESPACE_IMPL_START
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// DECLARATIONS ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
typedef struct Gia_IsoLnk_t_ Gia_IsoLnk_t;
|
||||
struct Gia_IsoLnk_t_
|
||||
{
|
||||
int iBeg;
|
||||
int nSize;
|
||||
int iPrev;
|
||||
int iNext;
|
||||
};
|
||||
|
||||
typedef struct Gia_IsoLst_t_ Gia_IsoLst_t;
|
||||
struct Gia_IsoLst_t_
|
||||
{
|
||||
int iHead;
|
||||
int iTail;
|
||||
};
|
||||
|
||||
typedef struct Gia_IsoMan_t_ Gia_IsoMan_t;
|
||||
struct Gia_IsoMan_t_
|
||||
{
|
||||
Gia_Man_t * pGia;
|
||||
int nObjs;
|
||||
// collected info
|
||||
Vec_Int_t * vLevels;
|
||||
Vec_Int_t * vFin0Levs;
|
||||
Vec_Int_t * vFin1Levs;
|
||||
Vec_Int_t * vFoutPos;
|
||||
Vec_Int_t * vFoutNeg;
|
||||
Vec_Int_t * vFinSig;
|
||||
// sorting structures
|
||||
Vec_Int_t * vMap;
|
||||
Vec_Int_t * vSeens;
|
||||
Vec_Int_t * vCounts;
|
||||
Vec_Int_t * vResult;
|
||||
// fanout representation
|
||||
Vec_Int_t * vFanouts;
|
||||
// class representation
|
||||
Vec_Int_t * vItems;
|
||||
Gia_IsoLst_t List;
|
||||
Gia_IsoLnk_t * pLinks;
|
||||
Gia_IsoLnk_t * pLinksFree;
|
||||
int nLinksUsed;
|
||||
int nLinksAlloc;
|
||||
// temporary storage
|
||||
Vec_Ptr_t * vRoots;
|
||||
Vec_Int_t * vUsed;
|
||||
Vec_Int_t * vRefs;
|
||||
// results
|
||||
Vec_Ptr_t * vResults;
|
||||
};
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// FUNCTION DEFINITIONS ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
Gia_IsoMan_t * Gia_IsoManStart( Gia_Man_t * pGia )
|
||||
{
|
||||
Gia_IsoMan_t * p;
|
||||
p = ABC_CALLOC( Gia_IsoMan_t, 1 );
|
||||
p->pGia = pGia;
|
||||
p->nObjs = Gia_ManObjNum( pGia );
|
||||
// collected info
|
||||
p->vLevels = Vec_IntAlloc( p->nObjs );
|
||||
p->vFin0Levs = Vec_IntAlloc( p->nObjs );
|
||||
p->vFin1Levs = Vec_IntAlloc( p->nObjs );
|
||||
p->vFoutPos = Vec_IntAlloc( p->nObjs );
|
||||
p->vFoutNeg = Vec_IntAlloc( p->nObjs );
|
||||
p->vFinSig = Vec_IntAlloc( p->nObjs );
|
||||
// sorting structures
|
||||
p->vMap = Vec_IntStartFull( 2*p->nObjs );
|
||||
p->vSeens = Vec_IntAlloc( p->nObjs );
|
||||
p->vCounts = Vec_IntAlloc( p->nObjs );
|
||||
p->vResult = Vec_IntAlloc( p->nObjs );
|
||||
// class representation
|
||||
p->vItems = Vec_IntAlloc( p->nObjs );
|
||||
// fanout representation
|
||||
p->vFanouts = Vec_IntAlloc( 6 * p->nObjs );
|
||||
// temporary storage
|
||||
p->vRoots = Vec_PtrAlloc( 1000 );
|
||||
p->vUsed = Vec_IntAlloc( p->nObjs );
|
||||
p->vRefs = Vec_IntAlloc( p->nObjs );
|
||||
// results
|
||||
p->vResults = Vec_PtrAlloc( Gia_ManPoNum(pGia) );
|
||||
return p;
|
||||
}
|
||||
void Gia_IsoManStop( Gia_IsoMan_t * p )
|
||||
{
|
||||
// collected info
|
||||
Vec_IntFree( p->vLevels );
|
||||
Vec_IntFree( p->vFin0Levs );
|
||||
Vec_IntFree( p->vFin1Levs );
|
||||
Vec_IntFree( p->vFoutPos );
|
||||
Vec_IntFree( p->vFoutNeg );
|
||||
Vec_IntFree( p->vFinSig );
|
||||
// sorting structures
|
||||
Vec_IntFree( p->vMap );
|
||||
Vec_IntFree( p->vSeens );
|
||||
Vec_IntFree( p->vCounts );
|
||||
Vec_IntFree( p->vResult );
|
||||
// class representation
|
||||
Vec_IntFree( p->vItems );
|
||||
// fanout representation
|
||||
Vec_IntFree( p->vFanouts );
|
||||
// temporary storage
|
||||
Vec_IntFree( p->vRefs );
|
||||
Vec_IntFree( p->vUsed );
|
||||
Vec_PtrFree( p->vRoots );
|
||||
// Vec_PtrFree( p->vResults );
|
||||
ABC_FREE( p );
|
||||
}
|
||||
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Collect the nodes used for the given PO.]
|
||||
|
||||
Description [Includes Const0, CI and AND nodes, no COs.]
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Gia_IsoCleanUsed( Gia_Man_t * p, Vec_Int_t * vUsed )
|
||||
{
|
||||
Gia_Obj_t * pObj;
|
||||
int i;
|
||||
Gia_ManForEachObjVec( vUsed, p, pObj, i )
|
||||
pObj->Value = 0;
|
||||
}
|
||||
void Gia_IsoCollectUsed_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Int_t * vUsed, Vec_Ptr_t * vRoots )
|
||||
{
|
||||
if ( pObj->Value )
|
||||
return;
|
||||
if ( Gia_ObjIsAnd(pObj) )
|
||||
{
|
||||
Gia_IsoCollectUsed_rec( p, Gia_ObjFanin0(pObj), vUsed, vRoots );
|
||||
Gia_IsoCollectUsed_rec( p, Gia_ObjFanin1(pObj), vUsed, vRoots );
|
||||
}
|
||||
else if ( Gia_ObjIsRo(p, pObj) )
|
||||
Vec_PtrPush( vRoots, Gia_ObjRoToRi(p, pObj) );
|
||||
else if ( !Gia_ObjIsPi(p, pObj) )
|
||||
assert( 0 );
|
||||
pObj->Value = Vec_IntSize( vUsed );
|
||||
Vec_IntPush( vUsed, Gia_ObjId(p, pObj) );
|
||||
}
|
||||
void Gia_IsoCollectUsed( Gia_Man_t * p, int iPo, Vec_Int_t * vUsed, Vec_Ptr_t * vRoots )
|
||||
{
|
||||
Gia_Obj_t * pObj;
|
||||
int i;
|
||||
assert( iPo >= 0 && iPo < Gia_ManPoNum(p) );
|
||||
Vec_PtrClear( vRoots );
|
||||
Vec_PtrPush( vRoots, Gia_ManPo(p, iPo) );
|
||||
// collect used nodes
|
||||
Vec_IntClear( vUsed );
|
||||
Vec_IntPush( vUsed, 0 );
|
||||
Vec_PtrForEachEntry( Gia_Obj_t *, vRoots, pObj, i )
|
||||
if ( !Gia_ObjIsConst0(Gia_ObjFanin0(pObj)) )
|
||||
Gia_IsoCollectUsed_rec( p, Gia_ObjFanin0(pObj), vUsed, vRoots );
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Gia_IsoCreateFanout( Gia_Man_t * p, Vec_Int_t * vUsed, Vec_Int_t * vRefs, Vec_Int_t * vFanout )
|
||||
{
|
||||
// Value of GIA objects points to the index in Used
|
||||
// vUsed includes only CIs and ANDs
|
||||
Gia_Obj_t * pObj, * pObjRi;
|
||||
int * pOff, * pOff0, * pOff1;
|
||||
int i, nOffset, Counter = 0;
|
||||
|
||||
// count references
|
||||
Vec_IntFill( vRefs, Vec_IntSize(vUsed), 0 );
|
||||
Gia_ManForEachObjVec( vUsed, p, pObj, i )
|
||||
{
|
||||
if ( !i ) continue;
|
||||
if ( Gia_ObjIsAnd(pObj) )
|
||||
{
|
||||
Vec_IntAddToEntry( vRefs, Gia_ObjFanin0(pObj)->Value, 1 );
|
||||
Vec_IntAddToEntry( vRefs, Gia_ObjFanin1(pObj)->Value, 1 );
|
||||
Counter += 2;
|
||||
}
|
||||
else if ( Gia_ObjIsRo(p, pObj) )
|
||||
{
|
||||
pObj = Gia_ObjRoToRi(p, pObj);
|
||||
Vec_IntAddToEntry( vRefs, Gia_ObjFanin0(pObj)->Value, 1 );
|
||||
Counter += 1;
|
||||
}
|
||||
else if ( !Gia_ObjIsPi(p, pObj) )
|
||||
assert( 0 );
|
||||
}
|
||||
|
||||
// create fanout
|
||||
nOffset = Vec_IntSize(vUsed);
|
||||
Vec_IntGrowResize( vFanout, 2 * Vec_IntSize(vUsed) + 2 * Counter );
|
||||
Gia_ManForEachObjVec( vUsed, p, pObj, i )
|
||||
{
|
||||
Vec_IntWriteEntry( vFanout, i, nOffset );
|
||||
Vec_IntWriteEntry( vFanout, nOffset, 0 );
|
||||
nOffset += 1 + Vec_IntEntry(vRefs, pObj->Value);
|
||||
if ( Gia_ObjIsAnd(pObj) )
|
||||
nOffset += 2;
|
||||
else if ( Gia_ObjIsRo(p, pObj) )
|
||||
nOffset += 1;
|
||||
}
|
||||
assert( nOffset == 2 * Vec_IntSize(vUsed) + 2 * Counter );
|
||||
|
||||
// load fanout
|
||||
Gia_ManForEachObjVec( vUsed, p, pObj, i )
|
||||
{
|
||||
pOff = Vec_IntEntryP( vFanout, Vec_IntEntry(vFanout, pObj->Value) );
|
||||
if ( Gia_ObjIsAnd(pObj) )
|
||||
{
|
||||
pOff0 = Vec_IntEntryP( vFanout, Vec_IntEntry(vFanout, Gia_ObjFanin0(pObj)->Value) );
|
||||
pOff1 = Vec_IntEntryP( vFanout, Vec_IntEntry(vFanout, Gia_ObjFanin1(pObj)->Value) );
|
||||
pOff[1+(*pOff)++] = Abc_Var2Lit( Gia_ObjFanin0(pObj)->Value, Gia_ObjFaninC0(pObj) );
|
||||
pOff[1+(*pOff)++] = Abc_Var2Lit( Gia_ObjFanin1(pObj)->Value, Gia_ObjFaninC1(pObj) );
|
||||
pOff0[1+(*pOff0)++] = Abc_Var2Lit( pObj->Value, Gia_ObjFaninC0(pObj) );
|
||||
pOff1[1+(*pOff1)++] = Abc_Var2Lit( pObj->Value, Gia_ObjFaninC1(pObj) );
|
||||
|
||||
}
|
||||
else if ( Gia_ObjIsRo(p, pObj) )
|
||||
{
|
||||
pObjRi = Gia_ObjRoToRi(p, pObj);
|
||||
pOff0 = Vec_IntEntryP( vFanout, Vec_IntEntry(vFanout, Gia_ObjFanin0(pObjRi)->Value) );
|
||||
pOff[1+(*pOff)++] = Abc_Var2Lit( Gia_ObjFanin0(pObj)->Value, Gia_ObjFaninC0(pObj) );
|
||||
pOff0[1+(*pOff0)++] = Abc_Var2Lit( pObj->Value, Gia_ObjFaninC0(pObj) );
|
||||
}
|
||||
}
|
||||
// verify
|
||||
Gia_ManForEachObjVec( vUsed, p, pObj, i )
|
||||
{
|
||||
nOffset = Vec_IntEntry( vFanout, Vec_IntEntry(vFanout, pObj->Value) );
|
||||
if ( Gia_ObjIsAnd(pObj) )
|
||||
nOffset -= 2;
|
||||
else if ( Gia_ObjIsRo(p, pObj) )
|
||||
nOffset -= 1;
|
||||
assert( nOffset == Vec_IntEntry(vRefs, pObj->Value) );
|
||||
}
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Gia_IsoCreateSigs( Gia_IsoMan_t * p )
|
||||
{
|
||||
Gia_Obj_t * pObj, * pObjRi;
|
||||
int i, Lev0, Lev1, Lev;
|
||||
Vec_IntClear( p->vLevels );
|
||||
Vec_IntClear( p->vFin0Levs );
|
||||
Vec_IntClear( p->vFin1Levs );
|
||||
Vec_IntClear( p->vFinSig );
|
||||
Vec_IntFill( p->vFoutPos, p->nObjs, 0 );
|
||||
Vec_IntFill( p->vFoutNeg, p->nObjs, 0 );
|
||||
Gia_ManForEachObjVec( p->vUsed, p->pGia, pObj, i )
|
||||
{
|
||||
if ( Gia_ObjIsAnd(pObj) )
|
||||
{
|
||||
Lev0 = Vec_IntEntry( p->vLevels, Gia_ObjFanin0(pObj)->Value );
|
||||
Lev1 = Vec_IntEntry( p->vLevels, Gia_ObjFanin1(pObj)->Value );
|
||||
Lev = 1 + Abc_MaxInt( Lev0, Lev1 );
|
||||
|
||||
Vec_IntPush( p->vLevels, Lev );
|
||||
if ( Gia_ObjFaninC0(pObj) < Gia_ObjFaninC1(pObj) || (Gia_ObjFaninC0(pObj) == Gia_ObjFaninC1(pObj) && Lev0 < Lev1) )
|
||||
{
|
||||
Vec_IntPush( p->vFin0Levs, Lev-Lev0 );
|
||||
Vec_IntPush( p->vFin1Levs, Lev-Lev1 );
|
||||
}
|
||||
else
|
||||
{
|
||||
Vec_IntPush( p->vFin0Levs, Lev-Lev1 );
|
||||
Vec_IntPush( p->vFin1Levs, Lev-Lev0 );
|
||||
}
|
||||
if ( Gia_ObjIsMuxType(pObj) ) // uniqify MUX/XOR
|
||||
Vec_IntPush( p->vFinSig, 3 );
|
||||
else
|
||||
Vec_IntPush( p->vFinSig, Gia_ObjFaninC0(pObj) + Gia_ObjFaninC1(pObj) );
|
||||
Vec_IntAddToEntry( Gia_ObjFaninC0(pObj) ? p->vFoutNeg : p->vFoutPos, Gia_ObjFanin0(pObj)->Value, 1 );
|
||||
Vec_IntAddToEntry( Gia_ObjFaninC1(pObj) ? p->vFoutNeg : p->vFoutPos, Gia_ObjFanin1(pObj)->Value, 1 );
|
||||
}
|
||||
else if ( Gia_ObjIsRo(p->pGia, pObj) )
|
||||
{
|
||||
pObjRi = Gia_ObjRoToRi(p->pGia, pObj);
|
||||
Vec_IntPush( p->vLevels, 0 );
|
||||
Vec_IntPush( p->vFin0Levs, 1 );
|
||||
Vec_IntPush( p->vFin1Levs, 0 );
|
||||
Vec_IntPush( p->vFinSig, Gia_ObjFaninC0(pObjRi) );
|
||||
Vec_IntAddToEntry( Gia_ObjFaninC0(pObjRi) ? p->vFoutNeg : p->vFoutPos, Gia_ObjFanin0(pObjRi)->Value, 1 );
|
||||
}
|
||||
else if ( Gia_ObjIsPi(p->pGia, pObj) )
|
||||
{
|
||||
Vec_IntPush( p->vLevels, 0 );
|
||||
Vec_IntPush( p->vFin0Levs, 0 );
|
||||
Vec_IntPush( p->vFin1Levs, 0 );
|
||||
Vec_IntPush( p->vFinSig, 4 );
|
||||
}
|
||||
else if ( Gia_ObjIsConst0(pObj) )
|
||||
{
|
||||
Vec_IntPush( p->vLevels, 0 );
|
||||
Vec_IntPush( p->vFin0Levs, 0 );
|
||||
Vec_IntPush( p->vFin1Levs, 0 );
|
||||
Vec_IntPush( p->vFinSig, 5 );
|
||||
}
|
||||
else assert( 0 );
|
||||
}
|
||||
// create items
|
||||
Vec_IntClear( p->vItems );
|
||||
for ( i = 0; i < Vec_IntSize(p->vUsed); i++ )
|
||||
Vec_IntPush( p->vItems, i );
|
||||
}
|
||||
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Gia_IsoSortStats( Vec_Int_t * vItems, Vec_Int_t * vCosts, Vec_Int_t * vMap, Vec_Int_t * vSeens, Vec_Int_t * vCounts, Vec_Int_t * vResult )
|
||||
{
|
||||
int i, Entry, Place;
|
||||
// assumes vCosts are between 0 and Vec_IntSize(vMap)
|
||||
// assumes vMap is clean and leaves it clean
|
||||
// Vec_IntForEachEntry( vMap, Entry, i )
|
||||
// assert( Entry == -1 );
|
||||
|
||||
// printf( "vItems: " );
|
||||
// Vec_IntPrint( vItems );
|
||||
// printf( "vCosts: " );
|
||||
// Vec_IntPrint( vCosts );
|
||||
|
||||
// collect places
|
||||
Vec_IntClear( vSeens );
|
||||
Vec_IntClear( vCounts );
|
||||
Vec_IntForEachEntry( vCosts, Entry, i )
|
||||
{
|
||||
Place = Vec_IntEntry(vMap, Entry);
|
||||
if ( Place == -1 )
|
||||
{
|
||||
Vec_IntWriteEntry( vMap, Entry, Vec_IntSize(vSeens) );
|
||||
Vec_IntPush( vSeens, Entry );
|
||||
Vec_IntPush( vCounts, 1 );
|
||||
}
|
||||
else
|
||||
Vec_IntAddToEntry( vCounts, Place, 1 );
|
||||
}
|
||||
|
||||
// sort places
|
||||
Vec_IntSort( vSeens, 0 );
|
||||
|
||||
// printf( "vCounts: " );
|
||||
// Vec_IntPrint( vCounts );
|
||||
// printf( "vSeens: " );
|
||||
// Vec_IntPrint( vSeens );
|
||||
|
||||
// create the final array
|
||||
Vec_IntClear( vResult );
|
||||
Vec_IntForEachEntry( vSeens, Entry, i )
|
||||
{
|
||||
Place = Vec_IntEntry( vMap, Entry );
|
||||
Vec_IntPush( vResult, Entry );
|
||||
Vec_IntPush( vResult, Vec_IntEntry(vCounts, Place) );
|
||||
}
|
||||
|
||||
// clean map
|
||||
Vec_IntForEachEntry( vSeens, Entry, i )
|
||||
Vec_IntWriteEntry( vMap, Entry, -1 );
|
||||
|
||||
// printf( "vResult: " );
|
||||
// Vec_IntPrint( vResult );
|
||||
|
||||
// printf( "(%d)", Vec_IntSize(vResult)/2 );
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Gia_IsoSortVec( Vec_Int_t * vItems, Vec_Int_t * vCosts, Vec_Int_t * vMap, Vec_Int_t * vSeens, Vec_Int_t * vCounts, Vec_Int_t * vResult )
|
||||
{
|
||||
int i, Entry, Place, Counter;
|
||||
// assumes vCosts are between 0 and Vec_IntSize(vMap)
|
||||
// assumes vMap is clean and leaves it clean
|
||||
assert( Vec_IntSize(vItems) > 1 );
|
||||
if ( Vec_IntSize(vItems) < 15 )
|
||||
{
|
||||
Vec_IntGrowResize( vResult, Vec_IntSize(vItems) );
|
||||
memmove( Vec_IntArray(vResult), Vec_IntArray(vItems), sizeof(int) * Vec_IntSize(vItems) );
|
||||
Vec_IntSelectSortCost( Vec_IntArray(vResult), Vec_IntSize(vItems), vCosts );
|
||||
return;
|
||||
}
|
||||
|
||||
// collect places
|
||||
Vec_IntClear( vSeens );
|
||||
Vec_IntClear( vCounts );
|
||||
Vec_IntForEachEntry( vCosts, Entry, i )
|
||||
{
|
||||
Place = Vec_IntEntry(vMap, Entry);
|
||||
if ( Place == -1 )
|
||||
{
|
||||
Vec_IntWriteEntry( vMap, Entry, Vec_IntSize(vSeens) );
|
||||
Vec_IntPush( vSeens, Entry );
|
||||
Vec_IntPush( vCounts, 1 );
|
||||
}
|
||||
else
|
||||
Vec_IntAddToEntry( vCounts, Place, 1 );
|
||||
}
|
||||
|
||||
// sort places
|
||||
Vec_IntSort( vSeens, 0 );
|
||||
|
||||
// set the map to point to the place in the final array
|
||||
Counter = 0;
|
||||
Vec_IntForEachEntry( vSeens, Entry, i )
|
||||
{
|
||||
Place = Vec_IntEntry( vMap, Entry );
|
||||
Vec_IntWriteEntry( vMap, Entry, Counter );
|
||||
Counter += Vec_IntEntry( vCounts, Place );
|
||||
}
|
||||
assert( Counter == Vec_IntSize(vItems) );
|
||||
|
||||
// fill the result
|
||||
Vec_IntGrowResize( vResult, Vec_IntSize(vItems) );
|
||||
Vec_IntFill( vResult, Vec_IntSize(vItems), -1 ); // verify
|
||||
Vec_IntForEachEntry( vItems, Entry, i )
|
||||
{
|
||||
Place = Vec_IntAddToEntry( vMap, Entry, 1 ) - 1;
|
||||
Vec_IntWriteEntry( vResult, Place, Entry );
|
||||
}
|
||||
Vec_IntForEachEntry( vResult, Entry, i ) // verify
|
||||
assert( Entry >= 0 );
|
||||
|
||||
// clean map
|
||||
Vec_IntForEachEntry( vSeens, Entry, i )
|
||||
Vec_IntWriteEntry( vMap, Entry, -1 );
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
Vec_Int_t * Gia_IsoCreateStats( Gia_IsoMan_t * p )
|
||||
{
|
||||
Vec_Int_t * vRes;
|
||||
vRes = Vec_IntAlloc( 1000 );
|
||||
Gia_IsoSortStats( p->vItems, p->vLevels, p->vMap, p->vSeens, p->vCounts, p->vResult ); Vec_IntAppend( vRes, p->vResult );
|
||||
Gia_IsoSortStats( p->vItems, p->vFin0Levs, p->vMap, p->vSeens, p->vCounts, p->vResult ); Vec_IntAppend( vRes, p->vResult );
|
||||
Gia_IsoSortStats( p->vItems, p->vFin1Levs, p->vMap, p->vSeens, p->vCounts, p->vResult ); Vec_IntAppend( vRes, p->vResult );
|
||||
Gia_IsoSortStats( p->vItems, p->vFoutPos, p->vMap, p->vSeens, p->vCounts, p->vResult ); Vec_IntAppend( vRes, p->vResult );
|
||||
Gia_IsoSortStats( p->vItems, p->vFoutNeg, p->vMap, p->vSeens, p->vCounts, p->vResult ); Vec_IntAppend( vRes, p->vResult );
|
||||
Gia_IsoSortStats( p->vItems, p->vFinSig, p->vMap, p->vSeens, p->vCounts, p->vResult ); Vec_IntAppend( vRes, p->vResult );
|
||||
return vRes;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
Vec_Int_t * Gia_IsoOne( Gia_IsoMan_t * p, int iPo )
|
||||
{
|
||||
Vec_Int_t * vStats = NULL;
|
||||
Gia_IsoCollectUsed( p->pGia, iPo, p->vUsed, p->vRoots );
|
||||
// Gia_IsoCreateFanout( p->pGia, p->vUsed, p->vRefs, p->vFanouts );
|
||||
Gia_IsoCreateSigs( p );
|
||||
vStats = Gia_IsoCreateStats( p );
|
||||
Gia_IsoCleanUsed( p->pGia, p->vUsed );
|
||||
return vStats;
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Gia_IsoTest( Gia_Man_t * pGia )
|
||||
{
|
||||
int fVerbose = 0;
|
||||
Vec_Ptr_t * vResults;
|
||||
Vec_Int_t * vStats;
|
||||
Gia_IsoMan_t * p;
|
||||
int i, clk = clock();
|
||||
Gia_ManCleanValue( pGia );
|
||||
p = Gia_IsoManStart( pGia );
|
||||
for ( i = 0; i < Gia_ManPoNum(pGia); i++ )
|
||||
{
|
||||
if ( i % 1000 == 0 )
|
||||
printf( "Finished %5d\r", i );
|
||||
vStats = Gia_IsoOne( p, i );
|
||||
Vec_PtrPush( p->vResults, vStats );
|
||||
if ( fVerbose )
|
||||
printf( "%d ", Vec_IntSize(vStats)/2 );
|
||||
}
|
||||
if ( fVerbose )
|
||||
printf( " \n" );
|
||||
|
||||
vResults = p->vResults;
|
||||
p->vResults = NULL;
|
||||
Gia_IsoManStop( p );
|
||||
// return vResults;
|
||||
Vec_VecFree( (Vec_Vec_t *)vResults );
|
||||
Abc_PrintTime( 1, "Time", clock() - clk );
|
||||
}
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// END OF FILE ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
ABC_NAMESPACE_IMPL_END
|
||||
|
||||
Loading…
Reference in New Issue