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

Isomorphism checking code.

This commit is contained in:
Alan Mishchenko 2012-02-15 18:40:05 -08:00
parent e405d71398
commit ecd14d4daf
5 changed files with 846 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
abclib.dsp
View File

@ -3439,6 +3439,10 @@ SOURCE=.\src\aig\gia\giaIf.c
# End Source File
# Begin Source File
SOURCE=.\src\aig\gia\giaIso.c
# End Source File
# Begin Source File
SOURCE=.\src\aig\gia\giaMan.c
# End Source File
# Begin Source File

3
src/aig/gia/gia.h
View File

@ -620,6 +620,8 @@ extern Gia_Man_t * Gia_ReadAigerFromMemory( char * pContents, int nFileS
extern Gia_Man_t * Gia_ReadAiger( char * pFileName, int fCheck );
extern void Gia_WriteAiger( Gia_Man_t * p, char * pFileName, int fWriteSymbols, int fCompact );
extern void Gia_DumpAiger( Gia_Man_t * p, char * pFilePrefix, int iFileNum, int nFileNumDigits );
extern Vec_Str_t * Gia_WriteAigerIntoMemoryStr( Gia_Man_t * p );
extern Vec_Str_t * Gia_WriteAigerIntoMemoryStrPart( Gia_Man_t * p, Vec_Int_t * vCis, Vec_Int_t * vAnds, Vec_Int_t * vCos, int nRegs );
/*=== giaBidec.c ===========================================================*/
extern unsigned * Gia_ManConvertAigToTruth( Gia_Man_t * p, Gia_Obj_t * pRoot, Vec_Int_t * vLeaves, Vec_Int_t * vTruth, Vec_Int_t * vVisited );
extern Gia_Man_t * Gia_ManPerformBidec( Gia_Man_t * p, int fVerbose );
@ -671,6 +673,7 @@ extern Gia_Man_t * Gia_ManDupWithConstraints( Gia_Man_t * p, Vec_Int_t *
extern Gia_Man_t * Gia_ManDupAbsFlops( Gia_Man_t * p, Vec_Int_t * vFlopClasses );
extern Gia_Man_t * Gia_ManDupAbsGates( Gia_Man_t * p, Vec_Int_t * vGateClasses );
extern Vec_Int_t * Gia_GlaCollectAssigned( Gia_Man_t * p, Vec_Int_t * vGateClasses );
extern Gia_Man_t * Gia_ManDupCones( Gia_Man_t * p, int * pPos, int nPos );
/*=== giaEnable.c ==========================================================*/
extern void Gia_ManDetectSeqSignals( Gia_Man_t * p, int fSetReset, int fVerbose );
extern Gia_Man_t * Gia_ManUnrollAndCofactor( Gia_Man_t * p, int nFrames, int nFanMax, int fVerbose );

179
src/aig/gia/giaAiger.c
View File

@ -1565,6 +1565,185 @@ void Gia_DumpAiger( Gia_Man_t * p, char * pFilePrefix, int iFileNum, int nFileNu
Gia_WriteAiger( p, Buffer, 0, 0 );
}
/**Function*************************************************************
Synopsis [Adds one unsigned AIG edge to the output buffer.]
Description [This procedure is a slightly modified version of Armin Biere's
procedure "void encode (FILE * file, unsigned x)" ]
SideEffects [Returns the current writing position.]
SeeAlso []
***********************************************************************/
void Gia_WriteAigerEncodeStr( Vec_Str_t * vStr, unsigned x )
{
unsigned char ch;
while (x & ~0x7f)
{
ch = (x & 0x7f) | 0x80;
// putc (ch, file);
// pBuffer[Pos++] = ch;
Vec_StrPush( vStr, ch );
x >>= 7;
}
ch = x;
// putc (ch, file);
// pBuffer[Pos++] = ch;
Vec_StrPush( vStr, ch );
}
/**Function*************************************************************
Synopsis [Writes the AIG in into the memory buffer.]
Description [The resulting buffer constains the AIG in AIGER format.
The resulting buffer should be deallocated by the user.]
SideEffects []
SeeAlso []
***********************************************************************/
Vec_Str_t * Gia_WriteAigerIntoMemoryStr( Gia_Man_t * p )
{
Vec_Str_t * vBuffer;
Gia_Obj_t * pObj;
int nNodes = 0, i, uLit, uLit0, uLit1;
// set the node numbers to be used in the output file
Gia_ManConst1(p)->Value = nNodes++;
Gia_ManForEachCi( p, pObj, i )
pObj->Value = nNodes++;
Gia_ManForEachAnd( p, pObj, i )
pObj->Value = nNodes++;
// write the header "M I L O A" where M = I + L + A
vBuffer = Vec_StrAlloc( 3*Gia_ManObjNum(p) );
Vec_StrPrintStr( vBuffer, "aig " );
Vec_StrPrintNum( vBuffer, Gia_ManCandNum(p) );
Vec_StrPrintStr( vBuffer, " " );
Vec_StrPrintNum( vBuffer, Gia_ManPiNum(p) );
Vec_StrPrintStr( vBuffer, " " );
Vec_StrPrintNum( vBuffer, Gia_ManRegNum(p) );
Vec_StrPrintStr( vBuffer, " " );
Vec_StrPrintNum( vBuffer, Gia_ManPoNum(p) );
Vec_StrPrintStr( vBuffer, " " );
Vec_StrPrintNum( vBuffer, Gia_ManAndNum(p) );
Vec_StrPrintStr( vBuffer, "\n" );
// write latch drivers
Gia_ManForEachRi( p, pObj, i )
{
uLit = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
// fprintf( pFile, "%u\n", uLit );
Vec_StrPrintNum( vBuffer, uLit );
Vec_StrPrintStr( vBuffer, "\n" );
}
// write PO drivers
Gia_ManForEachPo( p, pObj, i )
{
uLit = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
// fprintf( pFile, "%u\n", uLit );
Vec_StrPrintNum( vBuffer, uLit );
Vec_StrPrintStr( vBuffer, "\n" );
}
// write the nodes into the buffer
Gia_ManForEachAnd( p, pObj, i )
{
uLit = Abc_Var2Lit( Gia_ObjValue(pObj), 0 );
uLit0 = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
uLit1 = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin1(pObj)), Gia_ObjFaninC1(pObj) );
assert( uLit0 != uLit1 );
if ( uLit0 > uLit1 )
{
int Temp = uLit0;
uLit0 = uLit1;
uLit1 = Temp;
}
Gia_WriteAigerEncodeStr( vBuffer, uLit - uLit1 );
Gia_WriteAigerEncodeStr( vBuffer, uLit1 - uLit0 );
}
Vec_StrPrintStr( vBuffer, "c" );
return vBuffer;
}
/**Function*************************************************************
Synopsis [Writes the AIG in into the memory buffer.]
Description [The resulting buffer constains the AIG in AIGER format.
The CI/CO/AND nodes are assumed to be ordered according to some rule.
The resulting buffer should be deallocated by the user.]
SideEffects [Note that in vCos, the latches should be ordered first!!!]
SeeAlso []
***********************************************************************/
Vec_Str_t * Gia_WriteAigerIntoMemoryStrPart( Gia_Man_t * p, Vec_Int_t * vCis, Vec_Int_t * vAnds, Vec_Int_t * vCos, int nRegs )
{
Vec_Str_t * vBuffer;
Gia_Obj_t * pObj;
int nNodes = 0, i, uLit, uLit0, uLit1;
// set the node numbers to be used in the output file
Gia_ManConst1(p)->Value = nNodes++;
Gia_ManForEachObjVec( vCis, p, pObj, i )
{
assert( Gia_ObjIsCi(pObj) );
pObj->Value = nNodes++;
}
Gia_ManForEachObjVec( vAnds, p, pObj, i )
{
assert( Gia_ObjIsAnd(pObj) );
pObj->Value = nNodes++;
}
// write the header "M I L O A" where M = I + L + A
vBuffer = Vec_StrAlloc( 3*Gia_ManObjNum(p) );
Vec_StrPrintStr( vBuffer, "aig " );
Vec_StrPrintNum( vBuffer, Vec_IntSize(vCis) + Vec_IntSize(vAnds) );
Vec_StrPrintStr( vBuffer, " " );
Vec_StrPrintNum( vBuffer, Vec_IntSize(vCis) - nRegs );
Vec_StrPrintStr( vBuffer, " " );
Vec_StrPrintNum( vBuffer, nRegs );
Vec_StrPrintStr( vBuffer, " " );
Vec_StrPrintNum( vBuffer, Vec_IntSize(vCos) - nRegs );
Vec_StrPrintStr( vBuffer, " " );
Vec_StrPrintNum( vBuffer, Vec_IntSize(vAnds) );
Vec_StrPrintStr( vBuffer, "\n" );
// write latch drivers
Gia_ManForEachObjVec( vCos, p, pObj, i )
{
assert( Gia_ObjIsCo(pObj) );
uLit = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
// fprintf( pFile, "%u\n", uLit );
Vec_StrPrintNum( vBuffer, uLit );
Vec_StrPrintStr( vBuffer, "\n" );
}
// write the nodes into the buffer
Gia_ManForEachObjVec( vAnds, p, pObj, i )
{
uLit = Abc_Var2Lit( Gia_ObjValue(pObj), 0 );
uLit0 = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin0(pObj)), Gia_ObjFaninC0(pObj) );
uLit1 = Abc_Var2Lit( Gia_ObjValue(Gia_ObjFanin1(pObj)), Gia_ObjFaninC1(pObj) );
assert( uLit0 != uLit1 );
if ( uLit0 > uLit1 )
{
int Temp = uLit0;
uLit0 = uLit1;
uLit1 = Temp;
}
Gia_WriteAigerEncodeStr( vBuffer, uLit - uLit1 );
Gia_WriteAigerEncodeStr( vBuffer, uLit1 - uLit0 );
}
Vec_StrPrintStr( vBuffer, "c" );
return vBuffer;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///
////////////////////////////////////////////////////////////////////////

77
src/aig/gia/giaDup.c
View File

@ -1740,6 +1740,83 @@ Vec_Int_t * Gia_GlaCollectAssigned( Gia_Man_t * p, Vec_Int_t * vGateClasses )
return vAssigned;
}
/**Function*************************************************************
Synopsis [Copy an AIG structure related to the selected POs.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Gia_ManDupCones_rec( Gia_Man_t * p, Gia_Obj_t * pObj, Vec_Ptr_t * vLeaves, Vec_Ptr_t * vNodes, Vec_Ptr_t * vRoots )
{
if ( Gia_ObjIsTravIdCurrent(p, pObj) )
return;
Gia_ObjSetTravIdCurrent(p, pObj);
if ( Gia_ObjIsAnd(pObj) )
{
Gia_ManDupCones_rec( p, Gia_ObjFanin0(pObj), vLeaves, vNodes, vRoots );
Gia_ManDupCones_rec( p, Gia_ObjFanin1(pObj), vLeaves, vNodes, vRoots );
Vec_PtrPush( vNodes, pObj );
}
else if ( Gia_ObjIsPo(p, pObj) )
Gia_ManDupCones_rec( p, Gia_ObjFanin0(pObj), vLeaves, vNodes, vRoots );
else if ( Gia_ObjIsRo(p, pObj) )
Vec_PtrPush( vRoots, Gia_ObjRoToRi(p, pObj) );
else if ( Gia_ObjIsPi(p, pObj) )
Vec_PtrPush( vLeaves, pObj );
else assert( 0 );
}
Gia_Man_t * Gia_ManDupCones( Gia_Man_t * p, int * pPos, int nPos )
{
Gia_Man_t * pNew;
Vec_Ptr_t * vLeaves, * vNodes, * vRoots;
Gia_Obj_t * pObj;
int i;
// collect initial POs
vLeaves = Vec_PtrAlloc( 100 );
vNodes = Vec_PtrAlloc( 100 );
vRoots = Vec_PtrAlloc( 100 );
for ( i = 0; i < nPos; i++ )
Vec_PtrPush( vRoots, Gia_ManPo(p, pPos[i]) );
// mark internal nodes
Gia_ManIncrementTravId( p );
Gia_ObjSetTravIdCurrent( p, Gia_ManConst0(p) );
Vec_PtrForEachEntry( Gia_Obj_t *, vRoots, pObj, i )
Gia_ManDupCones_rec( p, pObj, vLeaves, vNodes, vRoots );
// start the new manager
Gia_ManFillValue( p );
pNew = Gia_ManStart( Vec_PtrSize(vLeaves) + Vec_PtrSize(vNodes) + Vec_PtrSize(vRoots) + 1);
pNew->pName = Abc_UtilStrsav( p->pName );
// map the constant node
Gia_ManConst0(p)->Value = 0;
// create PIs
Vec_PtrForEachEntry( Gia_Obj_t *, vLeaves, pObj, i )
pObj->Value = Gia_ManAppendCi( pNew );
// create LOs
Vec_PtrForEachEntryStart( Gia_Obj_t *, vRoots, pObj, i, nPos )
Gia_ObjRiToRo(p, pObj)->Value = Gia_ManAppendCi( pNew );
// create internal nodes
Vec_PtrForEachEntry( Gia_Obj_t *, vNodes, pObj, i )
pObj->Value = Gia_ManAppendAnd( pNew, Gia_ObjFanin0Copy(pObj), Gia_ObjFanin1Copy(pObj) );
// create COs
Vec_PtrForEachEntry( Gia_Obj_t *, vRoots, pObj, i )
Gia_ManAppendCo( pNew, Gia_ObjFanin0Copy(pObj) );
// finalize
Gia_ManSetRegNum( pNew, Vec_PtrSize(vRoots)-nPos );
Vec_PtrFree( vLeaves );
Vec_PtrFree( vNodes );
Vec_PtrFree( vRoots );
return pNew;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///

673
src/aig/gia/giaIso.c
View File

@ -27,56 +27,47 @@ 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;
int nUniques;
// collected info
Vec_Int_t * vLevels;
Vec_Int_t * vFin0Levs;
Vec_Int_t * vFin1Levs;
Vec_Int_t * vFinSig;
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;
Vec_Int_t * vFanout;
Vec_Int_t * vFanout2;
// class representation
Vec_Int_t * vItems;
Gia_IsoLst_t List;
Gia_IsoLnk_t * pLinks;
Gia_IsoLnk_t * pLinksFree;
int nLinksUsed;
int nLinksAlloc;
Vec_Int_t * vUniques;
Vec_Int_t * vClass;
Vec_Int_t * vClass2;
Vec_Int_t * vClassNew;
Vec_Int_t * vLevelLim;
// temporary storage
Vec_Ptr_t * vRoots;
Vec_Int_t * vUsed;
Vec_Int_t * vRefs;
// results
Vec_Ptr_t * vResults;
Vec_Int_t * vPermCis;
Vec_Int_t * vPermCos;
};
static inline int * Gia_IsoFanoutVec( Vec_Int_t * p, int Id ) { return Vec_IntEntryP( p, Vec_IntEntry(p, Id) ); }
////////////////////////////////////////////////////////////////////////
/// FUNCTION DEFINITIONS ///
////////////////////////////////////////////////////////////////////////
@ -102,9 +93,9 @@ Gia_IsoMan_t * Gia_IsoManStart( Gia_Man_t * pGia )
p->vLevels = Vec_IntAlloc( p->nObjs );
p->vFin0Levs = Vec_IntAlloc( p->nObjs );
p->vFin1Levs = Vec_IntAlloc( p->nObjs );
p->vFinSig = 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 );
@ -112,14 +103,22 @@ Gia_IsoMan_t * Gia_IsoManStart( Gia_Man_t * pGia )
p->vResult = Vec_IntAlloc( p->nObjs );
// class representation
p->vItems = Vec_IntAlloc( p->nObjs );
p->vUniques = Vec_IntAlloc( p->nObjs );
p->vClass = Vec_IntAlloc( p->nObjs/2 );
p->vClass2 = Vec_IntAlloc( p->nObjs/2 );
p->vClassNew = Vec_IntAlloc( p->nObjs/2 );
p->vLevelLim = Vec_IntAlloc( 1000 );
// fanout representation
p->vFanouts = Vec_IntAlloc( 6 * p->nObjs );
p->vFanout = Vec_IntAlloc( 6 * p->nObjs );
p->vFanout2 = Vec_IntAlloc( 0 );
// 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) );
p->vPermCis = Vec_IntAlloc( Gia_ManCiNum(pGia) );
p->vPermCos = Vec_IntAlloc( Gia_ManCoNum(pGia) );
return p;
}
void Gia_IsoManStop( Gia_IsoMan_t * p )
@ -128,9 +127,9 @@ void Gia_IsoManStop( Gia_IsoMan_t * p )
Vec_IntFree( p->vLevels );
Vec_IntFree( p->vFin0Levs );
Vec_IntFree( p->vFin1Levs );
Vec_IntFree( p->vFinSig );
Vec_IntFree( p->vFoutPos );
Vec_IntFree( p->vFoutNeg );
Vec_IntFree( p->vFinSig );
// sorting structures
Vec_IntFree( p->vMap );
Vec_IntFree( p->vSeens );
@ -138,13 +137,22 @@ void Gia_IsoManStop( Gia_IsoMan_t * p )
Vec_IntFree( p->vResult );
// class representation
Vec_IntFree( p->vItems );
Vec_IntFree( p->vUniques );
Vec_IntFree( p->vClass );
Vec_IntFree( p->vClass2 );
Vec_IntFree( p->vClassNew );
Vec_IntFree( p->vLevelLim );
// fanout representation
Vec_IntFree( p->vFanouts );
Vec_IntFree( p->vFanout );
Vec_IntFree( p->vFanout2 );
// temporary storage
Vec_IntFree( p->vRefs );
Vec_IntFree( p->vUsed );
Vec_PtrFree( p->vRoots );
// results
// Vec_PtrFree( p->vResults );
Vec_IntFree( p->vPermCis );
Vec_IntFree( p->vPermCos );
ABC_FREE( p );
}
@ -259,8 +267,8 @@ void Gia_IsoCreateFanout( Gia_Man_t * p, Vec_Int_t * vUsed, Vec_Int_t * vRefs, V
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) );
pOff0 = Gia_IsoFanoutVec( vFanout, Gia_ObjFanin0(pObj)->Value );
pOff1 = Gia_IsoFanoutVec( 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) );
@ -270,15 +278,15 @@ void Gia_IsoCreateFanout( Gia_Man_t * p, Vec_Int_t * vUsed, Vec_Int_t * vRefs, V
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) );
pOff0 = Gia_IsoFanoutVec( vFanout, Gia_ObjFanin0(pObjRi)->Value );
pOff[1+(*pOff)++] = Abc_Var2Lit( Gia_ObjFanin0(pObjRi)->Value, Gia_ObjFaninC0(pObjRi) );
pOff0[1+(*pOff0)++] = Abc_Var2Lit( pObj->Value, Gia_ObjFaninC0(pObjRi) );
}
}
// verify
Gia_ManForEachObjVec( vUsed, p, pObj, i )
{
nOffset = Vec_IntEntry( vFanout, Vec_IntEntry(vFanout, pObj->Value) );
nOffset = *Gia_IsoFanoutVec( vFanout, pObj->Value );
if ( Gia_ObjIsAnd(pObj) )
nOffset -= 2;
else if ( Gia_ObjIsRo(p, pObj) )
@ -287,6 +295,75 @@ void Gia_IsoCreateFanout( Gia_Man_t * p, Vec_Int_t * vUsed, Vec_Int_t * vRefs, V
}
}
/**Function*************************************************************
Synopsis [Add fanouts of a new singleton object.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
static inline void Gia_IsoAddSingletonFanouts( Gia_IsoMan_t * p, int Item, int Unique )
{
int i, * pFan, * pFan2;
pFan = Gia_IsoFanoutVec( p->vFanout, Item );
for ( i = 0; i < pFan[0]; i++ )
{
if ( Vec_IntEntry( p->vUniques, Abc_Lit2Var(pFan[1+i]) ) >= 0 )
continue;
pFan2 = Gia_IsoFanoutVec( p->vFanout2, Abc_Lit2Var(pFan[1+i]) );
pFan2[1+(*pFan2)++] = Abc_Var2Lit( Unique, Abc_LitIsCompl(pFan[1+i]) );
}
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Gia_IsoCreateFanout2( Gia_IsoMan_t * p )
{
int i, Entry, nOffset, nFanouts = 0, nLeftover = 0;
assert( Vec_IntSize(p->vFanout2) == 0 );
// count the number of fanouts and objects remaining
Vec_IntForEachEntry( p->vUniques, Entry, i )
{
if ( Entry >= 0 )
continue;
nLeftover++;
nFanouts += *Gia_IsoFanoutVec(p->vFanout, i);
}
assert( nLeftover + p->nUniques == Vec_IntSize(p->vUsed) );
// assign the fanouts
nOffset = Vec_IntSize(p->vUsed);
Vec_IntGrowResize( p->vFanout2, Vec_IntSize(p->vUsed) + 2 * nLeftover + nFanouts );
Vec_IntForEachEntry( p->vUniques, Entry, i )
{
if ( Entry >= 0 )
continue;
Vec_IntWriteEntry( p->vFanout2, i, nOffset );
Vec_IntWriteEntry( p->vFanout2, nOffset, 0 );
nOffset += 2 + *Gia_IsoFanoutVec(p->vFanout, i);
}
assert( nOffset == Vec_IntSize(p->vUsed) + 2 * nLeftover + nFanouts );
// add currently available items
Vec_IntForEachEntry( p->vUniques, Entry, i )
{
if ( Entry == -1 )
continue;
Gia_IsoAddSingletonFanouts( p, i, Entry );
}
}
/**Function*************************************************************
Synopsis []
@ -306,8 +383,8 @@ void Gia_IsoCreateSigs( Gia_IsoMan_t * p )
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 );
Vec_IntFill( p->vFoutPos, Vec_IntSize(p->vUsed), 0 );
Vec_IntFill( p->vFoutNeg, Vec_IntSize(p->vUsed), 0 );
Gia_ManForEachObjVec( p->vUsed, p->pGia, pObj, i )
{
if ( Gia_ObjIsAnd(pObj) )
@ -338,7 +415,7 @@ void Gia_IsoCreateSigs( Gia_IsoMan_t * p )
{
pObjRi = Gia_ObjRoToRi(p->pGia, pObj);
Vec_IntPush( p->vLevels, 0 );
Vec_IntPush( p->vFin0Levs, 1 );
Vec_IntPush( p->vFin0Levs, 1 ); // not ready yet!
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 );
@ -359,7 +436,11 @@ void Gia_IsoCreateSigs( Gia_IsoMan_t * p )
}
else assert( 0 );
}
// create items
assert( Vec_IntSize( p->vLevels ) == Vec_IntSize(p->vUsed) );
assert( Vec_IntSize( p->vFin0Levs ) == Vec_IntSize(p->vUsed) );
assert( Vec_IntSize( p->vFin1Levs ) == Vec_IntSize(p->vUsed) );
assert( Vec_IntSize( p->vFinSig ) == Vec_IntSize(p->vUsed) );
// prepare items
Vec_IntClear( p->vItems );
for ( i = 0; i < Vec_IntSize(p->vUsed); i++ )
Vec_IntPush( p->vItems, i );
@ -393,8 +474,9 @@ void Gia_IsoSortStats( Vec_Int_t * vItems, Vec_Int_t * vCosts, Vec_Int_t * vMap,
// collect places
Vec_IntClear( vSeens );
Vec_IntClear( vCounts );
Vec_IntForEachEntry( vCosts, Entry, i )
Vec_IntForEachEntry( vItems, Entry, i )
{
Entry = Vec_IntEntry(vCosts, Entry);
Place = Vec_IntEntry(vMap, Entry);
if ( Place == -1 )
{
@ -444,25 +526,56 @@ void Gia_IsoSortStats( Vec_Int_t * vItems, Vec_Int_t * vCosts, Vec_Int_t * vMap,
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 )
Vec_Int_t * Gia_IsoCreateStats( Gia_IsoMan_t * p, int iPo )
{
int i, Entry, Place, Counter;
Vec_Int_t * vStats = Vec_IntAlloc( 1000 );
Gia_IsoCollectUsed( p->pGia, iPo, p->vUsed, p->vRoots );
Gia_IsoSortStats( p->vItems, p->vLevels, p->vMap, p->vSeens, p->vCounts, p->vResult ); Vec_IntAppend( vStats, p->vResult );
Gia_IsoSortStats( p->vItems, p->vFin0Levs, p->vMap, p->vSeens, p->vCounts, p->vResult ); Vec_IntAppend( vStats, p->vResult );
Gia_IsoSortStats( p->vItems, p->vFin1Levs, p->vMap, p->vSeens, p->vCounts, p->vResult ); Vec_IntAppend( vStats, p->vResult );
Gia_IsoSortStats( p->vItems, p->vFoutPos, p->vMap, p->vSeens, p->vCounts, p->vResult ); Vec_IntAppend( vStats, p->vResult );
Gia_IsoSortStats( p->vItems, p->vFoutNeg, p->vMap, p->vSeens, p->vCounts, p->vResult ); Vec_IntAppend( vStats, p->vResult );
Gia_IsoSortStats( p->vItems, p->vFinSig, p->vMap, p->vSeens, p->vCounts, p->vResult ); Vec_IntAppend( vStats, p->vResult );
Gia_IsoCleanUsed( p->pGia, p->vUsed );
return vStats;
}
/**Function*************************************************************
Synopsis [Sorting an array of entries.]
Description [This procedure can have the following outcomes:
- There is no refinement (the class remains unchanged).
- There is complete refinement (all elements became singletons)
- There is partial refinement (some new classes and some singletons)
The permutes set of items if returned in vItems.]
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,
Vec_Int_t * vClassNew )
{
int i, Entry, Entry0, 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;
}
// prepare return values
Vec_IntClear( vClassNew );
// collect places
Vec_IntClear( vSeens );
Vec_IntClear( vCounts );
Vec_IntForEachEntry( vCosts, Entry, i )
Vec_IntForEachEntry( vItems, Entry0, i )
{
Entry = Vec_IntEntry(vCosts, Entry0);
Place = Vec_IntEntry(vMap, Entry);
if ( Place == -1 )
{
@ -474,29 +587,45 @@ void Gia_IsoSortVec( Vec_Int_t * vItems, Vec_Int_t * vCosts, Vec_Int_t * vMap, V
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 )
// check if refinement is happening
if ( Vec_IntSize(vSeens) == 1 ) // there is no refinement
{
Place = Vec_IntEntry( vMap, Entry );
Vec_IntWriteEntry( vMap, Entry, Counter );
Counter += Vec_IntEntry( vCounts, Place );
Vec_IntPush( vClassNew, 0 );
Vec_IntPush( vClassNew, Vec_IntSize(vItems) );
// no need to change vItems
}
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 )
else // complete or partial refinement
{
Place = Vec_IntAddToEntry( vMap, Entry, 1 ) - 1;
Vec_IntWriteEntry( vResult, Place, Entry );
// 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 );
Vec_IntPush( vClassNew, Counter );
Vec_IntPush( vClassNew, Vec_IntEntry( vCounts, Place ) );
assert( Vec_IntEntry( vCounts, Place ) > 0 );
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, Entry0, i )
{
Entry = Vec_IntEntry(vCosts, Entry0);
Place = Vec_IntAddToEntry( vMap, Entry, 1 ) - 1;
Vec_IntWriteEntry( vResult, Place, Entry0 );
}
Vec_IntForEachEntry( vResult, Entry, i ) // verify
assert( Entry >= 0 );
assert( Vec_IntSize(vItems) == Vec_IntSize(vResult) );
memmove( Vec_IntArray(vItems), Vec_IntArray(vResult), sizeof(int) * Vec_IntSize(vResult) );
}
Vec_IntForEachEntry( vResult, Entry, i ) // verify
assert( Entry >= 0 );
// clean map
Vec_IntForEachEntry( vSeens, Entry, i )
@ -505,26 +634,76 @@ void Gia_IsoSortVec( Vec_Int_t * vItems, Vec_Int_t * vCosts, Vec_Int_t * vMap, V
/**Function*************************************************************
Synopsis []
Synopsis [Introduces a new singleton object.]
Description []
Description [Updates current equivalence classes.]
SideEffects []
SeeAlso []
***********************************************************************/
Vec_Int_t * Gia_IsoCreateStats( Gia_IsoMan_t * p )
void Gia_IsoAddSingleton( Gia_IsoMan_t * p, int Item )
{
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;
// assign unique number
assert( Vec_IntEntry( p->vUniques, Item ) == -1 );
Vec_IntWriteEntry( p->vUniques, Item, p->nUniques++ );
if ( Vec_IntSize(p->vFanout2) == 0 )
return;
// create fanouts
Gia_IsoAddSingletonFanouts( p, Item, p->nUniques-1 );
}
/**Function*************************************************************
Synopsis [Updates current equivalence classes.]]
Description [
SideEffects []
SeeAlso []
***********************************************************************/
int Gia_IsoRefine( Gia_IsoMan_t * p, Vec_Int_t * vParam )
{
Vec_Int_t vThis, * pTemp;
int i, k, Begin, nSize, Begin2, nSize2, Counter = 0;
assert( Vec_IntSize(p->vClass) > 0 );
assert( Vec_IntSize(p->vClass) % 2 == 0 );
Vec_IntClear( p->vClass2 );
Vec_IntForEachEntryDouble( p->vClass, Begin, nSize, i )
{
vThis.nSize = vThis.nCap = nSize;
vThis.pArray = Vec_IntArray(p->vItems) + Begin;
Gia_IsoSortVec( &vThis, vParam, p->vMap, p->vSeens, p->vCounts, p->vResult, p->vClassNew );
Vec_IntForEachEntryDouble( p->vClassNew, Begin2, nSize2, k )
{
if ( nSize2 == 1 )
{
Gia_IsoAddSingleton( p, Vec_IntEntry(p->vItems, Begin+Begin2) );
Counter++;
continue;
}
Vec_IntPush( p->vClass2, Begin+Begin2 );
Vec_IntPush( p->vClass2, nSize2 );
}
}
// update classes
pTemp = p->vClass2; p->vClass2 = p->vClass; p->vClass = pTemp;
// remember beginning of each level
if ( vParam == p->vLevels )
{
Vec_IntClear( p->vLevelLim );
Vec_IntForEachEntryDouble( p->vClass, Begin, nSize, i )
{
assert( nSize > 0 );
assert( Vec_IntEntry(p->vLevels, Vec_IntEntry(p->vItems, Begin)) == i );
Vec_IntPush( p->vLevelLim, Begin );
}
Vec_IntPush( p->vLevelLim, Vec_IntSize(p->vItems) );
}
return Counter;
}
/**Function*************************************************************
@ -538,17 +717,222 @@ Vec_Int_t * Gia_IsoCreateStats( Gia_IsoMan_t * p )
SeeAlso []
***********************************************************************/
Vec_Int_t * Gia_IsoOne( Gia_IsoMan_t * p, int iPo )
int Gia_IsoAssignUniqueToLastLevel( Gia_IsoMan_t * p )
{
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;
int i, Begin, End, Item, Level, Counter = 0;
assert( Vec_IntSize( p->vClass ) > 0 );
// get the last unrefined class
Begin = Vec_IntEntry( p->vClass, Vec_IntSize(p->vClass)-2 );
// get the last unrefined class
Item = Vec_IntEntry( p->vItems, Begin );
// get the level of this class
Level = Vec_IntEntry( p->vLevels, Item );
// get the first entry on this level
Begin = Vec_IntEntry( p->vLevelLim, Level );
End = Vec_IntEntry( p->vLevelLim, Level+1 );
// assign all unassigned items on this level
Vec_IntForEachEntryStartStop( p->vItems, Item, i, Begin, End )
if ( Vec_IntEntry( p->vUniques, Item ) == -1 )
{
Gia_IsoAddSingleton( p, Item );
Counter++;
}
return Counter;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Gia_IsoPrint( Gia_IsoMan_t * p, int Iter, int nSingles, int Time )
{
printf( "Iter %3d : ", Iter );
printf( "Classes =%7d. ", Vec_IntSize(p->vClass)/2 );
printf( "Uniques =%7d. ", p->nUniques );
printf( "Singles =%7d. ", nSingles );
Abc_PrintTime( 1, "Time", Time );
}
/**Function*************************************************************
Synopsis [Compares two objects by their ID.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Gia_ObjCompareByValue( Gia_Obj_t ** pp1, Gia_Obj_t ** pp2 )
{
Gia_Obj_t * pObj1 = *pp1;
Gia_Obj_t * pObj2 = *pp2;
assert( Gia_ObjIsTerm(pObj1) && Gia_ObjIsTerm(pObj2) );
return pObj1->Value - pObj2->Value;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Gia_IsoCreateUniques( Gia_IsoMan_t * p, int iPo )
{
Vec_Int_t * vArray[6] = { p->vLevels, p->vFin0Levs, p->vFin1Levs, p->vFoutPos, p->vFoutNeg, p->vFinSig };
int i, nSingles, clk = clock();
Gia_IsoCollectUsed( p->pGia, iPo, p->vUsed, p->vRoots );
Vec_IntClear( p->vFanout2 );
// prepare uniques
p->nUniques = 0;
Vec_IntFill( p->vUniques, Vec_IntSize(p->vUsed), -1 );
Gia_IsoAddSingleton( p, 0 );
// prepare classes
Vec_IntClear( p->vClass );
Vec_IntPush( p->vClass, 1 );
Vec_IntPush( p->vClass, Vec_IntSize(p->vUsed) );
// perform refinement
Gia_IsoPrint( p, 0, 0, clock() - clk );
for ( i = 0; i < 6; i++ )
{
nSingles = Gia_IsoRefine( p, vArray[i] );
Gia_IsoPrint( p, i+1, nSingles, clock() - clk );
}
// derive fanouts
Gia_IsoCreateFanout( p->pGia, p->vUsed, p->vRefs, p->vFanout );
Gia_IsoCreateFanout2( p );
// perform refinement
for ( i = 6; p->nUniques < Vec_IntSize(p->vUsed); i++ )
{
nSingles = Gia_IsoRefine( p, NULL );
Gia_IsoPrint( p, i+1, nSingles, clock() - clk );
if ( nSingles == 0 )
{
nSingles = Gia_IsoAssignUniqueToLastLevel( p );
Gia_IsoPrint( p, i+1, nSingles, clock() - clk );
}
}
// finished refinement
Gia_IsoCleanUsed( p->pGia, p->vUsed );
}
/**Function*************************************************************
Synopsis [Returns canonical permutation of the inputs.]
Description [Assumes that each CI/AND object has its unique number set.]
SideEffects []
SeeAlso []
***********************************************************************/
void Gia_ManFindIsoPermCis( Gia_Man_t * p, Vec_Ptr_t * vTemp, Vec_Int_t * vRes )
{
Gia_Obj_t * pObj;
int i;
Vec_IntClear( vRes );
// assign unique IDs to PIs
Vec_PtrClear( vTemp );
Gia_ManForEachPi( p, pObj, i )
Vec_PtrPush( vTemp, pObj );
Vec_PtrSort( vTemp, (int (*)(void))Gia_ObjCompareByValue );
// create the result
Vec_PtrForEachEntry( Gia_Obj_t *, vTemp, pObj, i )
Vec_IntPush( vRes, Gia_ObjCioId(pObj) );
// assign unique IDs to ROs
Vec_PtrClear( vTemp );
Gia_ManForEachRo( p, pObj, i )
Vec_PtrPush( vTemp, pObj );
Vec_PtrSort( vTemp, (int (*)(void))Gia_ObjCompareByValue );
// create the result
Vec_PtrForEachEntry( Gia_Obj_t *, vTemp, pObj, i )
Vec_IntPush( vRes, Gia_ObjCioId(pObj) );
}
/**Function*************************************************************
Synopsis [Find the canonical permutation of the COs.]
Description []
SideEffects []
SeeAlso []
***********************************************************************/
void Gia_ManFindIsoPermCos( Gia_Man_t * p, Vec_Int_t * vPermCis, Vec_Ptr_t * vTemp, Vec_Int_t * vRes )
{
Gia_Obj_t * pObj;
int i, Entry, Diff;
assert( Vec_IntSize(vPermCis) == Gia_ManCiNum(p) );
Vec_IntClear( vRes );
if ( Gia_ManPoNum(p) == 1 )
Vec_IntPush( vRes, 0 );
else
{
Vec_PtrClear( vTemp );
Gia_ManForEachPo( p, pObj, i )
{
pObj->Value = Abc_Var2Lit( Gia_ObjFanin0(pObj)->Value, Gia_ObjFaninC0(pObj) );
Vec_PtrPush( vTemp, pObj );
}
Vec_PtrSort( vTemp, (int (*)(void))Gia_ObjCompareByValue );
Vec_PtrForEachEntry( Gia_Obj_t *, vTemp, pObj, i )
Vec_IntPush( vRes, Gia_ObjCioId(pObj) );
}
// add flop outputs
Diff = Gia_ManPoNum(p) - Gia_ManPiNum(p);
Vec_IntForEachEntryStart( vPermCis, Entry, i, Gia_ManPiNum(p) )
Vec_IntPush( vRes, Entry + Diff );
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Gia_Man_t * Gia_ManDupCanonical( Gia_Man_t * p, Vec_Int_t * vUsed, Vec_Int_t * vUniques )
{
return NULL;
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
int Gia_IsoCompareVecStr( Vec_Str_t ** p1, Vec_Str_t ** p2 )
{
return Vec_StrCompareVec( *p1, *p2 );
}
/**Function*************************************************************
Synopsis []
@ -571,16 +955,15 @@ void Gia_IsoTest( Gia_Man_t * pGia )
p = Gia_IsoManStart( pGia );
for ( i = 0; i < Gia_ManPoNum(pGia); i++ )
{
if ( i % 1000 == 0 )
if ( i % 100 == 0 )
printf( "Finished %5d\r", i );
vStats = Gia_IsoOne( p, i );
vStats = Gia_IsoCreateStats( 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 );
@ -590,6 +973,116 @@ void Gia_IsoTest( Gia_Man_t * pGia )
}
/**Function*************************************************************
Synopsis []
Description []
SideEffects []
SeeAlso []
***********************************************************************/
Gia_Man_t * Gia_IsoFilterPos( Gia_Man_t * pGia, int fVerbose )
{
int fVeryVerbose = 0;
Gia_IsoMan_t * p;
Gia_Man_t * pTemp;
Vec_Ptr_t * vBuffers, * vClasses;
Vec_Int_t * vLevel, * vRemain;
Vec_Str_t * vStr, * vPrev;
int i, nUnique = 0, clk = clock();
int clkAig = 0, clkIso = 0, clk2;
// start the manager
Gia_ManCleanValue( pGia );
p = Gia_IsoManStart( pGia );
// derive AIG for each PO
vBuffers = Vec_PtrAlloc( Gia_ManPoNum(pGia) );
for ( i = 0; i < Gia_ManPoNum(pGia); i++ )
{
if ( i % 100 == 0 )
printf( "%6d finished...\r", i );
clk2 = clock();
pTemp = Gia_ManDupCanonical( pGia, p->vUsed, p->vUniques );
clkIso += clock() - clk2;
clk2 = clock();
vStr = Gia_WriteAigerIntoMemoryStr( pTemp );
clkAig += clock() - clk2;
Vec_PtrPush( vBuffers, vStr );
Gia_ManStop( pTemp );
// remember the output number in nCap (attention: hack!)
vStr->nCap = i;
}
// stop the manager
Gia_IsoManStop( p );
// s_Counter = 0;
if ( fVerbose )
{
Abc_PrintTime( 1, "Isomorph time", clkIso );
Abc_PrintTime( 1, "AIGER time", clkAig );
}
// sort the infos
clk = clock();
Vec_PtrSort( vBuffers, (int (*)(void))Gia_IsoCompareVecStr );
// create classes
clk = clock();
vClasses = Vec_PtrAlloc( Gia_ManPoNum(pGia) );
// start the first class
Vec_PtrPush( vClasses, (vLevel = Vec_IntAlloc(4)) );
vPrev = (Vec_Str_t *)Vec_PtrEntry( vBuffers, 0 );
Vec_IntPush( vLevel, vPrev->nCap );
// consider other classes
Vec_PtrForEachEntryStart( Vec_Str_t *, vBuffers, vStr, i, 1 )
{
if ( Vec_StrCompareVec(vPrev, vStr) )
Vec_PtrPush( vClasses, Vec_IntAlloc(4) );
vLevel = (Vec_Int_t *)Vec_PtrEntryLast( vClasses );
Vec_IntPush( vLevel, vStr->nCap );
vPrev = vStr;
}
Vec_VecFree( (Vec_Vec_t *)vBuffers );
if ( fVerbose )
Abc_PrintTime( 1, "Sorting time", clock() - clk );
// Abc_PrintTime( 1, "Traversal time", time_Trav );
// report the results
// Vec_VecPrintInt( (Vec_Vec_t *)vClasses );
// printf( "Devided %d outputs into %d cand equiv classes.\n", Gia_ManPoNum(pGia), Vec_PtrSize(vClasses) );
if ( fVerbose )
{
Vec_PtrForEachEntry( Vec_Int_t *, vClasses, vLevel, i )
if ( Vec_IntSize(vLevel) > 1 )
printf( "%d ", Vec_IntSize(vLevel) );
else
nUnique++;
printf( " Unique = %d\n", nUnique );
}
// collect the first ones
vRemain = Vec_IntAlloc( 100 );
Vec_PtrForEachEntry( Vec_Int_t *, vClasses, vLevel, i )
Vec_IntPush( vRemain, Vec_IntEntry(vLevel, 0) );
// derive the resulting AIG
pTemp = Gia_ManDupCones( pGia, Vec_IntArray(vRemain), Vec_IntSize(vRemain) );
Vec_IntFree( vRemain );
// return (Vec_Vec_t *)vClasses;
Vec_VecFree( (Vec_Vec_t *)vClasses );
// printf( "The number of all checks %d. Complex checks %d.\n", nPos*(nPos-1)/2, s_Counter );
return pTemp;
}
////////////////////////////////////////////////////////////////////////
/// END OF FILE ///