mirror of https://github.com/YosysHQ/abc.git
Various changes.
This commit is contained in:
Alan Mishchenko
parent
1b0439d128
commit
c3c643820e
|
|
@ -20,6 +20,7 @@
|
|||
|
||||
#include "gia.h"
|
||||
#include "misc/util/utilTruth.h"
|
||||
#include "misc/vec/vecHsh.h"
|
||||
|
||||
ABC_NAMESPACE_IMPL_START
|
||||
|
||||
|
|
@ -29,7 +30,7 @@ ABC_NAMESPACE_IMPL_START
|
|||
////////////////////////////////////////////////////////////////////////
|
||||
|
||||
#define GIA_MAX_CUTSIZE 8
|
||||
#define GIA_MAX_CUTNUM 51
|
||||
#define GIA_MAX_CUTNUM 65
|
||||
#define GIA_MAX_TT_WORDS ((GIA_MAX_CUTSIZE > 6) ? 1 << (GIA_MAX_CUTSIZE-6) : 1)
|
||||
|
||||
#define GIA_CUT_NO_LEAF 0xF
|
||||
|
|
@ -778,6 +779,218 @@ void Gia_ManExtractTest( Gia_Man_t * pGia )
|
|||
Abc_PrintTime( 0, "Creating windows", Abc_Clock() - clk );
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis [Extract a given number of cuts.]
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Gia_StoCutPrint( int * pCut )
|
||||
{
|
||||
int v;
|
||||
printf( "{" );
|
||||
for ( v = 1; v <= pCut[0]; v++ )
|
||||
printf( " %d", pCut[v] );
|
||||
printf( " }\n" );
|
||||
}
|
||||
void Gia_StoPrintCuts( Vec_Int_t * vThis, int iObj, int nCutSize )
|
||||
{
|
||||
int i, * pCut;
|
||||
printf( "Cuts of node %d (size = %d):\n", iObj, nCutSize );
|
||||
Sdb_ForEachCut( Vec_IntArray(vThis), pCut, i )
|
||||
if ( !nCutSize || pCut[0] == nCutSize )
|
||||
Gia_StoCutPrint( pCut );
|
||||
}
|
||||
Vec_Wec_t * Gia_ManFilterCuts( Gia_Man_t * pGia, Vec_Wec_t * vStore, int nCutSize, int nCuts )
|
||||
{
|
||||
abctime clkStart = Abc_Clock();
|
||||
Vec_Wec_t * vCutsSel = Vec_WecAlloc( nCuts );
|
||||
Vec_Int_t * vLevel, * vCut = Vec_IntAlloc( 10 );
|
||||
Vec_Wec_t * vCuts = Vec_WecAlloc( 1000 );
|
||||
Hsh_VecMan_t * p = Hsh_VecManStart( 1000 ); int i, s;
|
||||
Vec_WecForEachLevel( vStore, vLevel, i ) if ( Vec_IntSize(vLevel) )
|
||||
{
|
||||
int v, k, * pCut, Value;
|
||||
Sdb_ForEachCut( Vec_IntArray(vLevel), pCut, k )
|
||||
{
|
||||
if ( pCut[0] < 2 )
|
||||
continue;
|
||||
|
||||
for ( v = 1; v <= pCut[0]; v++ )
|
||||
if ( pCut[v] < 9 )
|
||||
break;
|
||||
if ( v <= pCut[0] )
|
||||
continue;
|
||||
|
||||
Vec_IntClear( vCut );
|
||||
Vec_IntPushArray( vCut, pCut+1, pCut[0] );
|
||||
Value = Hsh_VecManAdd( p, vCut );
|
||||
if ( Value == Vec_WecSize(vCuts) )
|
||||
{
|
||||
Vec_Int_t * vTemp = Vec_WecPushLevel(vCuts);
|
||||
Vec_IntPush( vTemp, 0 );
|
||||
Vec_IntAppend( vTemp, vCut );
|
||||
}
|
||||
Vec_IntAddToEntry( Vec_WecEntry(vCuts, Value), 0, 1 );
|
||||
}
|
||||
}
|
||||
printf( "Collected cuts = %d.\n", Vec_WecSize(vCuts) );
|
||||
for ( s = 3; s <= nCutSize; s++ )
|
||||
Vec_WecForEachLevel( vCuts, vLevel, i )
|
||||
if ( Vec_IntSize(vLevel) - 1 == s )
|
||||
{
|
||||
int * pCut = Vec_IntEntryP(vLevel, 1);
|
||||
int u, v, Value;
|
||||
for ( u = 0; u < s; u++ )
|
||||
{
|
||||
Vec_IntClear( vCut );
|
||||
for ( v = 0; v < s; v++ ) if ( v != u )
|
||||
Vec_IntPush( vCut, pCut[v] );
|
||||
assert( Vec_IntSize(vCut) == s-1 );
|
||||
Value = Hsh_VecManAdd( p, vCut );
|
||||
if ( Value < Vec_WecSize(vCuts) )
|
||||
Vec_IntAddToEntry( vLevel, 0, Vec_IntEntry(Vec_WecEntry(vCuts, Value), 0) );
|
||||
}
|
||||
}
|
||||
Hsh_VecManStop( p );
|
||||
Vec_IntFree( vCut );
|
||||
// collect
|
||||
Vec_WecSortByFirstInt( vCuts, 1 );
|
||||
Vec_WecForEachLevelStop( vCuts, vLevel, i, Abc_MinInt(Vec_WecSize(vCuts), nCuts) )
|
||||
Vec_IntAppend( Vec_WecPushLevel(vCutsSel), vLevel );
|
||||
Abc_PrintTime( 0, "Cut filtering time", Abc_Clock() - clkStart );
|
||||
return vCutsSel;
|
||||
}
|
||||
int Gia_ManCountRefs( Gia_Man_t * pGia, Vec_Int_t * vLevel )
|
||||
{
|
||||
int i, iObj, nRefs = 0;
|
||||
Vec_IntForEachEntry( vLevel, iObj, i )
|
||||
nRefs += Gia_ObjRefNumId(pGia, iObj);
|
||||
return nRefs;
|
||||
}
|
||||
Vec_Wrd_t * Gia_ManGenSims( Gia_Man_t * pGia )
|
||||
{
|
||||
Vec_Wrd_t * vSims;
|
||||
Vec_WrdFreeP( &pGia->vSimsPi );
|
||||
pGia->vSimsPi = Vec_WrdStartTruthTables( Gia_ManCiNum(pGia) );
|
||||
vSims = Gia_ManSimPatSim( pGia );
|
||||
return vSims;
|
||||
}
|
||||
int Gia_ManFindSatDcs( Gia_Man_t * pGia, Vec_Wrd_t * vSims, Vec_Int_t * vLevel )
|
||||
{
|
||||
int nWords = Vec_WrdSize(pGia->vSimsPi) / Gia_ManCiNum(pGia);
|
||||
int i, w, iObj, Res = 0, Pres[256] = {0}, nMints = 1 << Vec_IntSize(vLevel);
|
||||
for ( w = 0; w < 64*nWords; w++ )
|
||||
{
|
||||
int iInMint = 0;
|
||||
Vec_IntForEachEntry( vLevel, iObj, i )
|
||||
if ( Abc_TtGetBit( Vec_WrdEntryP(vSims, iObj*nWords), w ) )
|
||||
iInMint |= 1 << i;
|
||||
Pres[iInMint]++;
|
||||
}
|
||||
for ( i = 0; i < nMints; i++ )
|
||||
Res += Pres[i] == 0;
|
||||
return Res;
|
||||
}
|
||||
|
||||
|
||||
int Gia_ManCollectCutDivs( Gia_Man_t * p, Vec_Int_t * vIns )
|
||||
{
|
||||
Gia_Obj_t * pObj; int i, Res = 0;
|
||||
Vec_Int_t * vRes = Vec_IntAlloc( 100 );
|
||||
Vec_IntSort( vIns, 0 );
|
||||
|
||||
Vec_IntPush( vRes, 0 );
|
||||
Vec_IntAppend( vRes, vIns );
|
||||
|
||||
Gia_ManIncrementTravId( p );
|
||||
Gia_ManIncrementTravId( p );
|
||||
Gia_ManForEachObjVec( vIns, p, pObj, i )
|
||||
Gia_ObjSetTravIdCurrent( p, pObj );
|
||||
|
||||
Gia_ManForEachAnd( p, pObj, i )
|
||||
if ( Gia_ObjIsTravIdCurrent(p, pObj) )
|
||||
continue;
|
||||
else if ( Gia_ObjIsTravIdCurrent(p, Gia_ObjFanin0(pObj)) && Gia_ObjIsTravIdCurrent(p, Gia_ObjFanin1(pObj)) )
|
||||
{
|
||||
if ( !Gia_ObjIsTravIdPrevious(p, pObj) )
|
||||
Vec_IntPush( vRes, i );
|
||||
Gia_ObjSetTravIdCurrent( p, pObj );
|
||||
}
|
||||
// printf( "Divisors: " );
|
||||
// Vec_IntPrint( vRes );
|
||||
Res = Vec_IntSize(vRes);
|
||||
Vec_IntFree( vRes );
|
||||
return Res;
|
||||
}
|
||||
|
||||
void Gia_ManConsiderCuts( Gia_Man_t * pGia, Vec_Wec_t * vCuts )
|
||||
{
|
||||
Vec_Wrd_t * vSims = Gia_ManGenSims( pGia );
|
||||
Vec_Int_t * vLevel; int i;
|
||||
Gia_ManCreateRefs( pGia );
|
||||
Vec_WecForEachLevel( vCuts, vLevel, i )
|
||||
{
|
||||
printf( "Cut %3d ", i );
|
||||
printf( "Ref = %3d : ", Vec_IntEntry(vLevel, 0) );
|
||||
|
||||
Vec_IntShift( vLevel, 1 );
|
||||
printf( "Ref = %3d : ", Gia_ManCountRefs(pGia, vLevel) );
|
||||
printf( "SDC = %3d : ", Gia_ManFindSatDcs(pGia, vSims, vLevel) );
|
||||
printf( "Div = %3d : ", Gia_ManCollectCutDivs(pGia, vLevel) );
|
||||
Vec_IntPrint( vLevel );
|
||||
Vec_IntShift( vLevel, -1 );
|
||||
}
|
||||
Vec_WrdFree( vSims );
|
||||
}
|
||||
|
||||
|
||||
Vec_Wec_t * Gia_ManExploreCuts( Gia_Man_t * pGia, int nCutSize0, int nCuts0, int fVerbose0 )
|
||||
{
|
||||
int nCutSize = nCutSize0;
|
||||
int nCutNum = 64;
|
||||
int fCutMin = 0;
|
||||
int fTruthMin = 0;
|
||||
int fVerbose = fVerbose0;
|
||||
Vec_Wec_t * vCutsSel;
|
||||
Gia_Sto_t * p = Gia_StoAlloc( pGia, nCutSize, nCutNum, fCutMin, fTruthMin, fVerbose );
|
||||
Gia_Obj_t * pObj; int i, iObj;
|
||||
assert( nCutSize <= GIA_MAX_CUTSIZE );
|
||||
assert( nCutNum < GIA_MAX_CUTNUM );
|
||||
// prepare references
|
||||
Gia_ManForEachObj( p->pGia, pObj, iObj )
|
||||
Gia_StoRefObj( p, iObj );
|
||||
// compute cuts
|
||||
Gia_StoComputeCutsConst0( p, 0 );
|
||||
Gia_ManForEachCiId( p->pGia, iObj, i )
|
||||
Gia_StoComputeCutsCi( p, iObj );
|
||||
Gia_ManForEachAnd( p->pGia, pObj, iObj )
|
||||
Gia_StoComputeCutsNode( p, iObj );
|
||||
if ( p->fVerbose )
|
||||
{
|
||||
printf( "Running cut computation with CutSize = %d CutNum = %d CutMin = %s TruthMin = %s\n",
|
||||
p->nCutSize, p->nCutNum, p->fCutMin ? "yes":"no", p->fTruthMin ? "yes":"no" );
|
||||
printf( "CutPair = %.0f ", p->CutCount[0] );
|
||||
printf( "Merge = %.0f (%.2f %%) ", p->CutCount[1], 100.0*p->CutCount[1]/p->CutCount[0] );
|
||||
printf( "Eval = %.0f (%.2f %%) ", p->CutCount[2], 100.0*p->CutCount[2]/p->CutCount[0] );
|
||||
printf( "Cut = %.0f (%.2f %%) ", p->CutCount[3], 100.0*p->CutCount[3]/p->CutCount[0] );
|
||||
printf( "Cut/Node = %.2f ", p->CutCount[3] / Gia_ManAndNum(p->pGia) );
|
||||
printf( "\n" );
|
||||
printf( "The number of nodes with cut count over the limit (%d cuts) = %d nodes (out of %d). ",
|
||||
p->nCutNum, p->nCutsOver, Gia_ManAndNum(pGia) );
|
||||
Abc_PrintTime( 0, "Time", Abc_Clock() - p->clkStart );
|
||||
}
|
||||
vCutsSel = Gia_ManFilterCuts( pGia, p->vCuts, nCutSize0, nCuts0 );
|
||||
Gia_ManConsiderCuts( pGia, vCutsSel );
|
||||
Gia_StoFree( p );
|
||||
return vCutsSel;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// END OF FILE ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -2943,7 +2943,7 @@ Vec_Wrd_t * Gia_ManRelDerive( Gia_Man_t * p, Vec_Int_t * vObjs, Vec_Wrd_t * vSim
|
|||
Vec_Wrd_t * Gia_ManRelDerive2( Gia_Man_t * p, Vec_Int_t * vObjs, Vec_Wrd_t * vSims )
|
||||
{
|
||||
int nWords = Vec_WrdSize(p->vSimsPi) / Gia_ManCiNum(p); Gia_Obj_t * pObj;
|
||||
int i, Id, m, Index, iMint = 0, nMints = 1 << Vec_IntSize(vObjs);
|
||||
int i, Id, m, Index, nMints = 1 << Vec_IntSize(vObjs);
|
||||
Vec_Wrd_t * vPos, * vRel = Vec_WrdStart( Gia_ManCoNum(p) * nWords * nMints );
|
||||
for ( m = 0; m < nMints; m++ )
|
||||
{
|
||||
|
|
@ -2991,15 +2991,83 @@ void Gia_ManRelPrint( Gia_Man_t * p, Vec_Int_t * vObjs, Vec_Wrd_t * vSims, Vec_W
|
|||
printf( "\n" );
|
||||
}
|
||||
}
|
||||
void Gia_ManRelPrint2( Gia_Man_t * p, Vec_Int_t * vObjs, Vec_Wrd_t * vSims, Vec_Wrd_t * vRel )
|
||||
{
|
||||
int w, nWords = Vec_WrdSize(p->vSimsPi) / Gia_ManCiNum(p);
|
||||
int i, Id, m, nMints = 1 << Vec_IntSize(vObjs);
|
||||
int nWordsM = Abc_Truth6WordNum(Vec_IntSize(vObjs));
|
||||
Vec_Wrd_t * vRes = Vec_WrdStart( 64*nWords * nWordsM );
|
||||
printf( "Relation has %d inputs and %d outputs:\n", Gia_ManCiNum(p), Vec_IntSize(vObjs) );
|
||||
for ( w = 0; w < 64*nWords; w++ )
|
||||
{
|
||||
int iMint = 0;
|
||||
int nValid = 0;
|
||||
Gia_ManForEachCiId( p, Id, i )
|
||||
printf( "%d", Abc_TtGetBit(Vec_WrdEntryP(vSims, Id*nWords), w) );
|
||||
printf( " " );
|
||||
Vec_IntForEachEntry( vObjs, Id, i )
|
||||
{
|
||||
printf( "%d", Abc_TtGetBit(Vec_WrdEntryP(vSims, Id*nWords), w) );
|
||||
if ( Abc_TtGetBit(Vec_WrdEntryP(vSims, Id*nWords), w) )
|
||||
iMint |= 1 << i;
|
||||
}
|
||||
printf( " " );
|
||||
Gia_ManForEachCoId( p, Id, i )
|
||||
printf( "%d", Abc_TtGetBit(Vec_WrdEntryP(vSims, Id*nWords), w) );
|
||||
printf( " " );
|
||||
for ( m = 0; m < nMints; m++ )
|
||||
{
|
||||
int Count = 0;
|
||||
Gia_ManForEachCoId( p, Id, i )
|
||||
Count += Abc_TtGetBit(Vec_WrdEntryP(vRel, (m*Gia_ManCoNum(p)+i)*nWords), w);
|
||||
printf( "%d", Count == 0 );
|
||||
nValid += Count > 0;
|
||||
if ( Count == 0 )
|
||||
Abc_TtSetBit( Vec_WrdEntryP(vRes, w*nWordsM), m );
|
||||
}
|
||||
printf( " " );
|
||||
for ( m = 0; m < nMints; m++ )
|
||||
printf( "%d", Abc_TtGetBit(Vec_WrdEntryP(vRes, w*nWordsM), m) );
|
||||
printf( " " );
|
||||
assert( Abc_TtGetBit(Vec_WrdEntryP(vRes, w*nWordsM), iMint) );
|
||||
for ( i = 0; i < Vec_IntSize(vObjs); i++ )
|
||||
if ( Abc_TtGetBit(Vec_WrdEntryP(vRes, w*nWordsM), iMint ^ (1 << i)) )
|
||||
printf( "-" );
|
||||
else
|
||||
printf( "%d", (iMint >> i) & 1 );
|
||||
printf( " %d", nMints-nValid );
|
||||
printf( "\n" );
|
||||
}
|
||||
Vec_WrdFree( vRes );
|
||||
}
|
||||
Vec_Int_t * Gia_ManRelInitObjs()
|
||||
{
|
||||
Vec_Int_t * vRes = Vec_IntAlloc( 3 );
|
||||
Vec_IntPush( vRes, 41 );
|
||||
Vec_IntPush( vRes, 46 );
|
||||
Vec_Int_t * vRes = Vec_IntAlloc( 10 );
|
||||
/*
|
||||
Vec_IntPush( vRes, 33 );
|
||||
Vec_IntPush( vRes, 52 );
|
||||
Vec_IntPush( vRes, 53 );
|
||||
Vec_IntPush( vRes, 65 );
|
||||
Vec_IntPush( vRes, 79 );
|
||||
Vec_IntPush( vRes, 81 );
|
||||
*/
|
||||
/*
|
||||
Vec_IntPush( vRes, 60 );
|
||||
Vec_IntPush( vRes, 61 );
|
||||
Vec_IntPush( vRes, 71 );
|
||||
Vec_IntPush( vRes, 72 );
|
||||
*/
|
||||
/*
|
||||
Vec_IntPush( vRes, 65 );
|
||||
Vec_IntPush( vRes, 79 );
|
||||
Vec_IntPush( vRes, 81 );
|
||||
*/
|
||||
Vec_IntPush( vRes, 52 );
|
||||
Vec_IntPush( vRes, 54 );
|
||||
Vec_IntPrint( vRes );
|
||||
return vRes;
|
||||
}
|
||||
void Gia_ManRelDeriveTest( Gia_Man_t * p )
|
||||
void Gia_ManRelDeriveTest2( Gia_Man_t * p )
|
||||
{
|
||||
Vec_Int_t * vObjs = Gia_ManRelInitObjs();
|
||||
Vec_Wrd_t * vSims, * vRel, * vRel2; int nWords;
|
||||
|
|
@ -3009,14 +3077,189 @@ void Gia_ManRelDeriveTest( Gia_Man_t * p )
|
|||
vSims = Gia_ManSimPatSim( p );
|
||||
vRel = Gia_ManRelDerive( p, vObjs, vSims );
|
||||
vRel2 = Gia_ManRelDerive2( p, vObjs, vSims );
|
||||
assert( !memcmp(vRel2->pArray, vRel->pArray, sizeof(word)*Vec_WrdSize(vRel)) );
|
||||
Gia_ManRelPrint( p, vObjs, vSims, vRel );
|
||||
//assert( !memcmp(vRel2->pArray, vRel->pArray, sizeof(word)*Vec_WrdSize(vRel)) );
|
||||
Gia_ManRelPrint2( p, vObjs, vSims, vRel );
|
||||
Vec_WrdFree( vRel2 );
|
||||
Vec_WrdFree( vRel );
|
||||
Vec_WrdFree( vSims );
|
||||
Vec_IntFree( vObjs );
|
||||
}
|
||||
|
||||
/**Function*************************************************************
|
||||
|
||||
Synopsis []
|
||||
|
||||
Description []
|
||||
|
||||
SideEffects []
|
||||
|
||||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
Vec_Int_t * Gia_ManRelInitIns()
|
||||
{
|
||||
Vec_Int_t * vRes = Vec_IntAlloc( 10 );
|
||||
Vec_IntPush( vRes, 12 );
|
||||
Vec_IntPush( vRes, 18 );
|
||||
Vec_IntPush( vRes, 21 );
|
||||
Vec_IntPush( vRes, 34 );
|
||||
Vec_IntPush( vRes, 45 );
|
||||
Vec_IntPush( vRes, 59 );
|
||||
return vRes;
|
||||
}
|
||||
Vec_Int_t * Gia_ManRelInitOuts()
|
||||
{
|
||||
Vec_Int_t * vRes = Vec_IntAlloc( 10 );
|
||||
Vec_IntPush( vRes, 65 );
|
||||
Vec_IntPush( vRes, 66 );
|
||||
return vRes;
|
||||
}
|
||||
Vec_Int_t * Gia_ManRelInitMffc( Gia_Man_t * p, Vec_Int_t * vOuts )
|
||||
{
|
||||
Gia_Obj_t * pObj; int i;
|
||||
Vec_Int_t * vRes = Vec_IntAlloc( 100 );
|
||||
Vec_IntSort( vOuts, 0 );
|
||||
Gia_ManIncrementTravId( p );
|
||||
Gia_ManForEachObjVec( vOuts, p, pObj, i )
|
||||
Gia_ObjSetTravIdCurrent( p, pObj );
|
||||
Gia_ManIncrementTravId( p );
|
||||
Gia_ManForEachCo( p, pObj, i )
|
||||
if ( !Gia_ObjIsTravIdPrevious(p, Gia_ObjFanin0(pObj)) )
|
||||
Gia_ObjSetTravIdCurrent( p, Gia_ObjFanin0(pObj) );
|
||||
Gia_ManForEachAndReverse( p, pObj, i )
|
||||
if ( Gia_ObjIsTravIdPrevious(p, pObj) )
|
||||
continue;
|
||||
else if ( Gia_ObjIsTravIdCurrent(p, pObj) )
|
||||
{
|
||||
if ( !Gia_ObjIsTravIdPrevious(p, Gia_ObjFanin0(pObj)) )
|
||||
Gia_ObjSetTravIdCurrent( p, Gia_ObjFanin0(pObj) );
|
||||
if ( !Gia_ObjIsTravIdPrevious(p, Gia_ObjFanin1(pObj)) )
|
||||
Gia_ObjSetTravIdCurrent( p, Gia_ObjFanin1(pObj) );
|
||||
}
|
||||
Gia_ManForEachAnd( p, pObj, i )
|
||||
if ( !Gia_ObjIsTravIdCurrent(p, pObj) )
|
||||
Vec_IntPush( vRes, i );
|
||||
printf( "MFFC: " );
|
||||
Vec_IntPrint( vRes );
|
||||
return vRes;
|
||||
}
|
||||
Vec_Int_t * Gia_ManRelInitDivs( Gia_Man_t * p, Vec_Int_t * vIns, Vec_Int_t * vOuts )
|
||||
{
|
||||
Gia_Obj_t * pObj; int i;
|
||||
Vec_Int_t * vMffc = Gia_ManRelInitMffc( p, vOuts );
|
||||
Vec_Int_t * vRes = Vec_IntAlloc( 100 );
|
||||
Vec_IntSort( vIns, 0 );
|
||||
|
||||
Gia_ManIncrementTravId( p );
|
||||
Gia_ManForEachObjVec( vMffc, p, pObj, i )
|
||||
Gia_ObjSetTravIdCurrent( p, pObj );
|
||||
Vec_IntFree( vMffc );
|
||||
|
||||
Vec_IntPush( vRes, 0 );
|
||||
Vec_IntAppend( vRes, vIns );
|
||||
|
||||
Gia_ManIncrementTravId( p );
|
||||
Gia_ManForEachObjVec( vIns, p, pObj, i )
|
||||
Gia_ObjSetTravIdCurrent( p, pObj );
|
||||
|
||||
Gia_ManForEachAnd( p, pObj, i )
|
||||
if ( Gia_ObjIsTravIdCurrent(p, pObj) )
|
||||
continue;
|
||||
else if ( Gia_ObjIsTravIdCurrent(p, Gia_ObjFanin0(pObj)) && Gia_ObjIsTravIdCurrent(p, Gia_ObjFanin1(pObj)) )
|
||||
{
|
||||
if ( !Gia_ObjIsTravIdPrevious(p, pObj) )
|
||||
Vec_IntPush( vRes, i );
|
||||
Gia_ObjSetTravIdCurrent( p, pObj );
|
||||
}
|
||||
printf( "Divisors: " );
|
||||
Vec_IntPrint( vRes );
|
||||
return vRes;
|
||||
}
|
||||
|
||||
Vec_Int_t * Gia_ManRelDeriveSimple( Gia_Man_t * p, Vec_Wrd_t * vSims, Vec_Int_t * vIns, Vec_Int_t * vOuts )
|
||||
{
|
||||
Vec_Int_t * vRes = Vec_IntStartFull( 1 << Vec_IntSize(vIns) );
|
||||
int w, nWords = Vec_WrdSize(p->vSimsPi) / Gia_ManCiNum(p);
|
||||
for ( w = 0; w < 64*nWords; w++ )
|
||||
{
|
||||
int i, iObj, iMint = 0, iMint2 = 0;
|
||||
Vec_IntForEachEntry( vIns, iObj, i )
|
||||
if ( Abc_TtGetBit(Vec_WrdEntryP(vSims, iObj*nWords), w) )
|
||||
iMint |= 1 << i;
|
||||
if ( Vec_IntEntry(vRes, iMint) >= 0 )
|
||||
continue;
|
||||
Vec_IntForEachEntry( vOuts, iObj, i )
|
||||
if ( Abc_TtGetBit(Vec_WrdEntryP(vSims, iObj*nWords), w) )
|
||||
iMint2 |= 1 << i;
|
||||
Vec_IntWriteEntry( vRes, iMint, iMint2 );
|
||||
}
|
||||
return vRes;
|
||||
}
|
||||
|
||||
void Gia_ManRelSolve( Gia_Man_t * p, Vec_Wrd_t * vSims, Vec_Int_t * vIns, Vec_Int_t * vOuts, Vec_Int_t * vRel, Vec_Int_t * vDivs )
|
||||
{
|
||||
extern void Exa4_ManGenTest( Vec_Wrd_t * vSimsIn, Vec_Wrd_t * vSimsOut, int nIns, int nDivs, int nOuts, int nNodes, int TimeOut, int fOnlyAnd, int fFancy, int fOrderNodes, int fVerbose );
|
||||
|
||||
int i, m, iObj, Entry, iMint = 0, nMints = Vec_IntSize(vRel) - Vec_IntCountEntry(vRel, -1);
|
||||
Vec_Wrd_t * vSimsIn = Vec_WrdStart( nMints );
|
||||
Vec_Wrd_t * vSimsOut = Vec_WrdStart( nMints );
|
||||
int Entry0 = Vec_IntEntry( vRel, 0 );
|
||||
|
||||
word Value, Phase = 0;
|
||||
int nWords = Vec_WrdSize(p->vSimsPi) / Gia_ManCiNum(p);
|
||||
Vec_IntForEachEntry( vDivs, iObj, i )
|
||||
if ( Vec_WrdEntry(vSims, iObj*nWords) & 1 )
|
||||
Phase |= 1 << i;
|
||||
|
||||
assert( Entry0 >= 0 );
|
||||
printf( "Entry0 = %d\n", Entry0 );
|
||||
Entry0 ^= 1;
|
||||
// for ( m = 0; m < nMints; m++ )
|
||||
Vec_IntForEachEntry( vRel, Entry, m )
|
||||
{
|
||||
if ( Entry == -1 )
|
||||
continue;
|
||||
Abc_TtSetBit( Vec_WrdEntryP(vSimsOut, iMint), Entry0 ^ Entry );
|
||||
|
||||
Value = 0;
|
||||
Vec_IntForEachEntry( vDivs, iObj, i )
|
||||
if ( Abc_TtGetBit(Vec_WrdEntryP(vSims, iObj*nWords), m) )
|
||||
Abc_TtSetBit( &Value, i );
|
||||
Vec_WrdEntryP(vSimsOut, iMint)[0] = Value ^ Phase;
|
||||
|
||||
iMint++;
|
||||
}
|
||||
assert( iMint == nMints );
|
||||
printf( "Created %d minterms.\n", iMint );
|
||||
Exa4_ManGenTest( vSimsIn, vSimsOut, Vec_IntSize(vIns), Vec_IntSize(vDivs), Vec_IntSize(vOuts), 10, 0, 0, 0, 0, 1 );
|
||||
Vec_WrdFree( vSimsIn );
|
||||
Vec_WrdFree( vSimsOut );
|
||||
}
|
||||
void Gia_ManRelDeriveTest( Gia_Man_t * p )
|
||||
{
|
||||
Vec_Int_t * vIns = Gia_ManRelInitIns();
|
||||
Vec_Int_t * vOuts = Gia_ManRelInitOuts();
|
||||
Vec_Wrd_t * vSims; Vec_Int_t * vRel, * vDivs; int nWords;
|
||||
Vec_WrdFreeP( &p->vSimsPi );
|
||||
p->vSimsPi = Vec_WrdStartTruthTables( Gia_ManCiNum(p) );
|
||||
nWords = Vec_WrdSize(p->vSimsPi) / Gia_ManCiNum(p);
|
||||
vSims = Gia_ManSimPatSim( p );
|
||||
vRel = Gia_ManRelDeriveSimple( p, vSims, vIns, vOuts );
|
||||
vDivs = Gia_ManRelInitDivs( p, vIns, vOuts );
|
||||
//printf( "Neg = %d\n", Vec_IntCountEntry(vRel, -1) );
|
||||
|
||||
Gia_ManRelSolve( p, vSims, vIns, vOuts, vRel, vDivs );
|
||||
|
||||
Vec_IntFree( vDivs );
|
||||
Vec_IntPrint( vRel );
|
||||
Vec_IntFree( vRel );
|
||||
Vec_WrdFree( vSims );
|
||||
Vec_IntFree( vIns );
|
||||
Vec_IntFree( vOuts );
|
||||
}
|
||||
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// END OF FILE ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
|
|
|||
|
|
@ -9061,7 +9061,7 @@ int Abc_CommandAllExact( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
Bmc_EsPar_t Pars, * pPars = &Pars;
|
||||
Bmc_EsParSetDefault( pPars );
|
||||
Extra_UtilGetoptReset();
|
||||
while ( ( c = Extra_UtilGetopt( argc, argv, "MINKiaoegvh" ) ) != EOF )
|
||||
while ( ( c = Extra_UtilGetopt( argc, argv, "MINKianegvh" ) ) != EOF )
|
||||
{
|
||||
switch ( c )
|
||||
{
|
||||
|
|
@ -9115,7 +9115,7 @@ int Abc_CommandAllExact( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
case 'a':
|
||||
pPars->fOnlyAnd ^= 1;
|
||||
break;
|
||||
case 'o':
|
||||
case 'n':
|
||||
pPars->fOrderNodes ^= 1;
|
||||
break;
|
||||
case 'e':
|
||||
|
|
@ -9211,7 +9211,7 @@ int Abc_CommandAllExact( Abc_Frame_t * pAbc, int argc, char ** argv )
|
|||
return 0;
|
||||
|
||||
usage:
|
||||
Abc_Print( -2, "usage: allexact [-MIKN <num>] [-iaoevh] <hex>\n" );
|
||||
Abc_Print( -2, "usage: allexact [-MIKN <num>] [-ianevh] <hex>\n" );
|
||||
Abc_Print( -2, "\t exact synthesis of I-input function using N K-input gates\n" );
|
||||
Abc_Print( -2, "\t-M <num> : the majority support size (overrides -I and -K) [default = %d]\n", pPars->nMajSupp );
|
||||
Abc_Print( -2, "\t-I <num> : the number of input variables [default = %d]\n", pPars->nVars );
|
||||
|
|
@ -9219,7 +9219,7 @@ usage:
|
|||
Abc_Print( -2, "\t-N <num> : the number of K-input nodes [default = %d]\n", pPars->nNodes );
|
||||
Abc_Print( -2, "\t-i : toggle using incremental solving [default = %s]\n", pPars->fUseIncr ? "yes" : "no" );
|
||||
Abc_Print( -2, "\t-a : toggle using only AND-gates when K = 2 [default = %s]\n", pPars->fOnlyAnd ? "yes" : "no" );
|
||||
Abc_Print( -2, "\t-o : toggle using node ordering by fanins [default = %s]\n", pPars->fOrderNodes ? "yes" : "no" );
|
||||
Abc_Print( -2, "\t-n : toggle using node ordering by fanins [default = %s]\n", pPars->fOrderNodes ? "yes" : "no" );
|
||||
Abc_Print( -2, "\t-e : toggle enumerating all solutions [default = %s]\n", pPars->fEnumSols ? "yes" : "no" );
|
||||
// Abc_Print( -2, "\t-g : toggle using Glucose 3.0 by Gilles Audemard and Laurent Simon [default = %s]\n", pPars->fGlucose ? "yes" : "no" );
|
||||
Abc_Print( -2, "\t-v : toggle verbose printout [default = %s]\n", pPars->fVerbose ? "yes" : "no" );
|
||||
|
|
|
|||
|
|
@ -535,10 +535,23 @@ Wlc_Ntk_t * Wlc_NtkFromNdr( void * pData )
|
|||
SeeAlso []
|
||||
|
||||
***********************************************************************/
|
||||
void Ndr_DumpNdr( void * pDesign )
|
||||
{
|
||||
int i;
|
||||
char ** pNames = ABC_CALLOC( char *, 10000 );
|
||||
for ( i = 0; i < 10000; i++ )
|
||||
{
|
||||
char Buffer[100];
|
||||
sprintf( Buffer, "s%d", i );
|
||||
pNames[i] = Abc_UtilStrsav( Buffer );
|
||||
}
|
||||
Ndr_WriteVerilog( "temp.v", pDesign, pNames, 0 );
|
||||
}
|
||||
Wlc_Ntk_t * Wlc_ReadNdr( char * pFileName )
|
||||
{
|
||||
void * pData = Ndr_Read( pFileName );
|
||||
Wlc_Ntk_t * pNtk = Wlc_NtkFromNdr( pData );
|
||||
//Ndr_DumpNdr( pData );
|
||||
//char * ppNames[10] = { NULL, "a", "b", "c", "d", "e", "f", "g", "h", "i" };
|
||||
//Ndr_WriteVerilog( NULL, pData, ppNames, 0 );
|
||||
//Ndr_Delete( pData );
|
||||
|
|
|
|||
|
|
@ -27,6 +27,13 @@
|
|||
ABC_NAMESPACE_IMPL_START
|
||||
|
||||
|
||||
#ifdef WIN32
|
||||
#include <process.h>
|
||||
#define unlink _unlink
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
/// DECLARATIONS ///
|
||||
////////////////////////////////////////////////////////////////////////
|
||||
|
|
@ -1252,7 +1259,7 @@ static int Exa3_ManAddCnfStart( Exa3_Man_t * p, int fOnlyAnd )
|
|||
}
|
||||
//#ifdef USE_NODE_ORDER
|
||||
// node ordering
|
||||
if ( p->pPars->fUseIncr )
|
||||
if ( p->pPars->fOrderNodes )
|
||||
{
|
||||
for ( j = p->nVars; j < i; j++ )
|
||||
for ( n = 0; n < p->nObjs; n++ ) if ( p->VarMarks[i][0][n] )
|
||||
|
|
@ -1616,6 +1623,7 @@ Vec_Int_t * Exa4_ManParse( char * pFileName )
|
|||
assert( 0 );
|
||||
}
|
||||
fclose( pFile );
|
||||
unlink( pFileName );
|
||||
return vRes;
|
||||
}
|
||||
Vec_Int_t * Exa4_ManSolve( char * pFileNameIn, char * pFileNameOut, int TimeOut, int fVerbose )
|
||||
|
|
|
|||
Loading…
Reference in New Issue